messenger.cpp

Go to the documentation of this file.

// Copyright (c) 2016-2025  Made to Order Software Corp.  All Rights Reserved
//
// https://snapwebsites.org/project/cluck
// contact@m2osw.com
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
 
// self
//
#include    "messenger.h"
 
#include    "cluckd.h"
 
 
// cluck
//
#include    <cluck/names.h>
 
 
// eventdispatcher
//
#include    <eventdispatcher/names.h>
 
 
// communicator
//
#include    <communicator/names.h>
 
 
// last include
//
#include    <snapdev/poison.h>
 
 
 
namespace cluck_daemon
{
 
 
messenger::messenger(cluckd * c, advgetopt::getopt & opts)
    : fluid_settings_connection(opts, "cluckd")
    , f_cluckd(c)
{
    set_name("cluck_messenger");
    get_dispatcher()->add_matches({
        // eventdispatcher commands
        //
        ed::define_match(
              ed::Expression(ed::g_name_ed_cmd_absolutely)
            , ed::Callback(std::bind(&cluckd::msg_absolutely, c, std::placeholders::_1))
        ),
 
        // communicator commands
        //
        ed::define_match(
              ed::Expression(::communicator::g_name_communicator_cmd_clock_stable)
            , ed::Callback(std::bind(&cluckd::msg_clock_stable, c, std::placeholders::_1))
        ),
        ed::define_match(
              ed::Expression(::communicator::g_name_communicator_cmd_cluster_down)
            , ed::Callback(std::bind(&cluckd::msg_cluster_down, c, std::placeholders::_1))
        ),
        ed::define_match(
              ed::Expression(::communicator::g_name_communicator_cmd_cluster_up)
            , ed::Callback(std::bind(&cluckd::msg_cluster_up, c, std::placeholders::_1))
        ),
        ed::define_match(
              ed::Expression(::communicator::g_name_communicator_cmd_disconnected)
            , ed::Callback(std::bind(&cluckd::msg_server_gone, c, std::placeholders::_1))
        ),
        ed::define_match(
              ed::Expression(::communicator::g_name_communicator_cmd_hangup)
            , ed::Callback(std::bind(&cluckd::msg_server_gone, c, std::placeholders::_1))
        ),
        ed::define_match(
              ed::Expression(::communicator::g_name_communicator_cmd_status)
            , ed::Callback(std::bind(&cluckd::msg_status, c, std::placeholders::_1))
            , ed::MatchFunc(&ed::one_to_one_callback_match)
            , ed::Priority(ed::dispatcher_match::DISPATCHER_MATCH_CALLBACK_PRIORITY)
        ),
 
        // cluck commands
        //
        ed::define_match(
              ed::Expression(cluck::g_name_cluck_cmd_activate_lock)
            , ed::Callback(std::bind(&cluckd::msg_activate_lock, c, std::placeholders::_1))
        ),
        ed::define_match(
              ed::Expression(cluck::g_name_cluck_cmd_add_ticket)
            , ed::Callback(std::bind(&cluckd::msg_add_ticket, c, std::placeholders::_1))
        ),
        ed::define_match(
              ed::Expression(cluck::g_name_cluck_cmd_drop_ticket)
            , ed::Callback(std::bind(&cluckd::msg_drop_ticket, c, std::placeholders::_1))
        ),
        ed::define_match(
              ed::Expression(cluck::g_name_cluck_cmd_get_max_ticket)
            , ed::Callback(std::bind(&cluckd::msg_get_max_ticket, c, std::placeholders::_1))
        ),
        ed::define_match(
              ed::Expression(cluck::g_name_cluck_cmd_info)
            , ed::Callback(std::bind(&cluckd::msg_info, c, std::placeholders::_1))
        ),
        ed::define_match(
              ed::Expression(cluck::g_name_cluck_cmd_list_tickets)
            , ed::Callback(std::bind(&cluckd::msg_list_tickets, c, std::placeholders::_1))
        ),
        ed::define_match(
              ed::Expression(cluck::g_name_cluck_cmd_lock)
            , ed::Callback(std::bind(&cluckd::msg_lock, c, std::placeholders::_1))
        ),
        ed::define_match(
              ed::Expression(cluck::g_name_cluck_cmd_lock_activated)
            , ed::Callback(std::bind(&cluckd::msg_lock_activated, c, std::placeholders::_1))
        ),
        ed::define_match(
              ed::Expression(cluck::g_name_cluck_cmd_lock_entered)
            , ed::Callback(std::bind(&cluckd::msg_lock_entered, c, std::placeholders::_1))
        ),
        ed::define_match(
              ed::Expression(cluck::g_name_cluck_cmd_lock_entering)
            , ed::Callback(std::bind(&cluckd::msg_lock_entering, c, std::placeholders::_1))
        ),
        ed::define_match(
              ed::Expression(cluck::g_name_cluck_cmd_lock_exiting)
            , ed::Callback(std::bind(&cluckd::msg_lock_exiting, c, std::placeholders::_1))
        ),
        ed::define_match(
              ed::Expression(cluck::g_name_cluck_cmd_lock_failed)
            , ed::Callback(std::bind(&cluckd::msg_lock_failed, c, std::placeholders::_1))
        ),
        ed::define_match(
              ed::Expression(cluck::g_name_cluck_cmd_lock_leaders)
            , ed::Callback(std::bind(&cluckd::msg_lock_leaders, c, std::placeholders::_1))
        ),
        ed::define_match(
              ed::Expression(cluck::g_name_cluck_cmd_lock_started)
            , ed::Callback(std::bind(&cluckd::msg_lock_started, c, std::placeholders::_1))
        ),
        ed::define_match(
              ed::Expression(cluck::g_name_cluck_cmd_lock_status)
            , ed::Callback(std::bind(&cluckd::msg_lock_status, c, std::placeholders::_1))
        ),
        ed::define_match(
              ed::Expression(cluck::g_name_cluck_cmd_lock_tickets)
            , ed::Callback(std::bind(&cluckd::msg_lock_tickets, c, std::placeholders::_1))
        ),
        ed::define_match(
              ed::Expression(cluck::g_name_cluck_cmd_max_ticket)
            , ed::Callback(std::bind(&cluckd::msg_max_ticket, c, std::placeholders::_1))
        ),
        ed::define_match(
              ed::Expression(cluck::g_name_cluck_cmd_ticket_added)
            , ed::Callback(std::bind(&cluckd::msg_ticket_added, c, std::placeholders::_1))
        ),
        ed::define_match(
              ed::Expression(cluck::g_name_cluck_cmd_ticket_ready)
            , ed::Callback(std::bind(&cluckd::msg_ticket_ready, c, std::placeholders::_1))
        ),
        ed::define_match(
              ed::Expression(cluck::g_name_cluck_cmd_unlock)
            , ed::Callback(std::bind(&cluckd::msg_unlock, c, std::placeholders::_1))
        ),
    });
}
 
 
messenger::~messenger()
{
}
 
 
void messenger::finish_parsing()
{
    process_fluid_settings_options();
    automatic_watch_initialization();
}
 
 
void messenger::ready(ed::message & msg)
{
    fluid_settings_connection::ready(msg);
    f_cluckd->set_my_ip_address(get_my_address());
 
    // request the status of the system clock
    //
    ed::message clock_status;
    clock_status.reply_to(msg);
    clock_status.set_command(::communicator::g_name_communicator_cmd_clock_status);
    clock_status.add_parameter(
              ::communicator::g_name_communicator_param_cache
            , ::communicator::g_name_communicator_value_no);
    send_message(clock_status);
}
 
 
void messenger::stop(bool quitting)
{
    f_cluckd->stop(quitting);
}
 
 
void messenger::fluid_settings_changed(
      fluid_settings::fluid_settings_status_t status
    , std::string const & name
    , std::string const & value)
{
    fluid_settings_connection::fluid_settings_changed(status, name, value);
 
    if(status == fluid_settings::fluid_settings_status_t::FLUID_SETTINGS_STATUS_READY)
    {
        // now we're ready to start with cluckd
        //
        ed::message clusterstatus_message;
        clusterstatus_message.set_command(::communicator::g_name_communicator_cmd_cluster_status);
        clusterstatus_message.set_service(::communicator::g_name_communicator_service_communicatord);
        send_message(clusterstatus_message);
    }
}
 
 
 
} // namespace cluck_daemon
// vim: ts=4 sw=4 et