jaus++/2.0/src/jaus/core/management/management.cpp

Go to the documentation of this file.

#include "jaus/core/management/management.h"
#include "jaus/core/component.h"
#include <iostream>

using namespace JAUS;

const std::string Management::Name = "urn:jaus:jss:core:Management";


bool Management::Child::RequestComponentControl(const Address &id, 
                                                const bool sendResumeCommand, 
                                                const bool reacquire, 
                                                const unsigned int waitTimeMs)
{
    if(GetComponent() == NULL)
    {
        return false;
    }
    if(!GetComponent()->AccessControlService()->HaveControl(id))
    {
        if(GetComponent()->AccessControlService()->RequestComponentControl(id, reacquire, waitTimeMs))
        {
            if(sendResumeCommand)
            {
                return GetComponent()->ManagementService()->Resume(id, waitTimeMs);
            }
            return true;
        }

        return false;
    }
    else if(sendResumeCommand) // Already have control, send resume command if needed.
    {
        return GetComponent()->ManagementService()->Resume(id, waitTimeMs);
    }

    return true;
}


bool Management::Child::ReleaseComponentControl(const Address &id, 
                                                const bool sendStandbyCommand, 
                                                const unsigned int waitTimeMs)
{
    if(GetComponent())
    {
        if(sendStandbyCommand)
        {
            if(GetComponent()->ManagementService()->Standby(id, waitTimeMs) &&
               GetComponent()->AccessControlService()->ReleaseComponentControl(id, waitTimeMs))
            {
                return true;
            }
        }
        else if(GetComponent()->AccessControlService()->ReleaseComponentControl(id, waitTimeMs))
        {
            return true;
        }
    }

    return false;
}


Management::Management() : AccessControl::Child(Service::ID(Management::Name),
                                                Service::ID(AccessControl::Name))
{
    mStatus = Status::Initialized;
}


Management::~Management()
{
}


bool Management::Resume(const Address& id,
                        const unsigned int waitTimeMs)
{
    if(id.mSubsystem == GetComponentID().mSubsystem)
    {
        if(GetComponentStatus(id) == (int)Status::Ready)
        {
            return true;
        }
    }
    JAUS::Resume resume(id, GetComponentID());
    if(Send(&resume))
    {
        if(waitTimeMs > 0)
        {
            CxUtils::SleepMs(10);
            QueryStatus query(id, GetComponentID());
            ReportStatus response;
            if(Send(&query, &response, waitTimeMs) && response.GetStatus() == Status::Ready)
            {
                return true;
            }
            if(GetComponentStatus(id) == (int)Status::Ready)
            {
                return true;
            }
        }
        else
        {
            return true;
        }
    }
    return false;
}


bool Management::Standby(const Address& id,
                         const unsigned int waitTimeMs)
{
    if(id.IsValid() == false)
    {
        Address::List inControl = GetComponent()->AccessControlService()->GetControlledComponents();
        Address::List::iterator c;
        bool result = true;
        for(c = inControl.begin(); c != inControl.end(); c++)
        {
            result &= Standby(*c, waitTimeMs);
        }
        return result;
    }

    if(id.mSubsystem == GetComponentID().mSubsystem)
    {
        if(GetComponentStatus(id) == (int)Status::Standby)
        {
            return true;
        }
    }

    JAUS::Standby standby(id, GetComponentID());
    if(Send(&standby))
    {
        if(waitTimeMs > 0)
        {
            QueryStatus query(id, GetComponentID());
            ReportStatus response;
            if(Send(&query, &response, waitTimeMs) && response.GetStatus() == Status::Standby)
            {
                return true;
            }
        }
        else
        {
            return true;
        }
    }
    return false;
}


bool Management::SetEmergency(const Address& id,
                              const unsigned int waitTimeMs)
{
    JAUS::SetEmergency setEmergency(id, GetComponentID());
    setEmergency.SetEmergencyCode(1);
    if(Send(&setEmergency))
    {
        if(waitTimeMs > 0)
        {
            QueryStatus query(id, GetComponentID());
            ReportStatus response;
            if(Send(&query, &response, waitTimeMs) && response.GetStatus() == Status::Emergency)
            {
                return true;
            }
        }
        else
        {
            return true;
        }
    }
    return false;
}


bool Management::ClearEmergency(const Address& id,
                                const unsigned int waitTimeMs)
{
    JAUS::ClearEmergency clearEmergency(id, GetComponentID());
    clearEmergency.SetEmergencyCode(1);
    if(Send(&clearEmergency))
    {
        if(waitTimeMs > 0)
        {
            QueryStatus query(id, GetComponentID());
            ReportStatus response;
            if(Send(&query, &response, waitTimeMs) && response.GetStatus() != Status::Emergency)
            {
                return true;
            }
        }
        else
        {
            return true;
        }
    }
    return false;
}


bool Management::Shutdown(const Address& id)
{
    if(id.IsValid() == false)
    {
        Address::List inControl = GetComponent()->AccessControlService()->GetControlledComponents();
        Address::List::iterator c;
        bool result = true;
        for(c = inControl.begin(); c != inControl.end(); c++)
        {
            result &= Shutdown(*c);
        }
        return result;
    }

    JAUS::Shutdown shutdown(id, GetComponentID());
    if(Send(&shutdown))
    {
        return true;
    }
    return false;
}


void Management::Initialize()
{
    mStatus = Management::Status::Initialized;
    SetStatus(mStatus);
}


void Management::Shutdown()
{
    mStatus = Status::Shutdown;
}


bool Management::GenerateEvent(const Events::Subscription& info) const
{
    if(info.mpQueryMessage->GetMessageCode() == QUERY_STATUS)
    {
        JAUS::ReportStatus report;
        report.SetStatus(mStatus);
        SendEvent(info, &report);
        return true;
    }
    return false; // Unsupported event.
}


bool Management::IsEventSupported(const Events::Type type,
                                  const double requestedPeriodicRate,
                                  const Message* queryMessage,
                                  double& confirmedPeriodicRate,
                                  std::string& errorMessage) const
{
    bool result = false;
    switch(queryMessage->GetMessageCode())
    {
    case QUERY_STATUS:
        confirmedPeriodicRate = requestedPeriodicRate;
        result = true;
        break;
    default:
        result = false;
        break;
    };
    return result;
}


void Management::Receive(const Message* message)
{
    switch(message->GetMessageCode())
    {
    case CLEAR_EMERGENCY:
        {
            // Ensure appropriate transitions.
            if(mStatus == Status::Emergency)
            {
                Service::Map children = GetChildServices();
                Service::Map::iterator i;
                for(i = children.begin();
                    i != children.end();
                    i++)
                {
                    Management::Child* child = dynamic_cast<Management::Child*>(i->second);
                    if(child)
                    {
                        child->ClearEmergency();
                        child->mStatus = mStatus;
                    }
                }
                // Set status.
                SetStatus(Status::Standby);
            }
        }
        break;
    case QUERY_STATUS:
        {
            // Send current status.
            JAUS::ReportStatus report(message->GetSourceID(), GetComponentID());
            report.SetStatus(mStatus);
            Send(&report);
            if(mDebugMessagesFlag)
            {
                Mutex::ScopedLock plock(&mDebugMessagesMutex);
                std::cout << "[" << GetServiceID().ToString() << "-" << mComponentID.ToString() 
                          << "] - " << report.GetDestinationID().ToString() << " Requested Status at " << Time::GetUtcTime().ToString() << "\n";
            }
        }
        break;
    case REPORT_STATUS:
        {
            const JAUS::ReportStatus* report = dynamic_cast<const JAUS::ReportStatus*>(message);
            if(report)
            {
                if(report->GetSourceID().mSubsystem == GetComponentID().mSubsystem)
                {
                    Mutex::ScopedLock lock(&mStatesMutex);
                    mSubsystemStates[report->GetSourceID()] = (int)report->GetStatus();
                }
                else
                {
                    try
                    {
                        // Update Discovery Contents.
                        Discovery* discovery = GetComponent()->DiscoveryService();
                        if(discovery)
                        {
                            discovery->GetSubsystem(report->GetSourceID().mSubsystem)->GetComponent(report->GetSourceID())->mStatus = (int)report->GetStatus();
                        }
                    }
                    catch(Exception& e)
                    {
                        e.Print();
                    }
                }
            }
        }
        break;
    case RESET:
        {
            if(mDebugMessagesFlag)
            {
                Mutex::ScopedLock plock(&mDebugMessagesMutex);
                std::cout << "[" << GetServiceID().ToString() << "-" << mComponentID.ToString() 
                          << "] - " << GetComponent()->AccessControlService()->GetControllerID().ToString() << " Sent Reset at " << Time::GetUtcTime().ToString() << "\n";
            }
            // Ensure appropriate transitions.
            if(mStatus != Status::Initialized)
            {
                SetStatus(Status::Standby);
            }
        }
        break;
    case RESUME:
        {
            if(mDebugMessagesFlag)
            {
                Mutex::ScopedLock plock(&mDebugMessagesMutex);
                std::cout << "[" << GetServiceID().ToString() << "-" << mComponentID.ToString() 
                          << "] - " << GetComponent()->AccessControlService()->GetControllerID().ToString() << " Sent Resume at " << Time::GetUtcTime().ToString() << "\n";
            }
            // Ensure appropriate transitions.
            if(mStatus == Status::Standby || mStatus == Status::Initialized)
            {
                SetStatus(Status::Ready);
            }
        }
        break;
    case SET_EMERGENCY:
        {
            if(mDebugMessagesFlag)
            {
                Mutex::ScopedLock plock(&mDebugMessagesMutex);
                std::cout << "[" << GetServiceID().ToString() << "-" << mComponentID.ToString() 
                          << "] - " << GetComponent()->AccessControlService()->GetControllerID().ToString() << " Sent Emergency at " << Time::GetUtcTime().ToString() << "\n";
            }
            SetStatus(Status::Emergency);
        }
        break;
    case SHUTDOWN:
        {
            mStatus = Status::Shutdown;
            if(mDebugMessagesFlag)
            {
                Mutex::ScopedLock plock(&mDebugMessagesMutex);
                std::cout << "[" << GetServiceID().ToString() << "-" << mComponentID.ToString() 
                          << "] - " << GetComponent()->AccessControlService()->GetControllerID().ToString() << " Sent Shutdown at " << Time::GetUtcTime().ToString() << "\n";
            }

            // Shutdown the component.
            if(GetComponent())
            {
                Service::Map children = GetChildServices();
                Service::Map::iterator i;
                for(i = children.begin();
                    i != children.end();
                    i++)
                {
                    Management::Child* child = dynamic_cast<Management::Child*>(i->second);
                    if(child)
                    {
                        child->mStatus = mStatus;
                    }
                }
                // You must check for shutdown in your program.
                //GetComponent()->Shutdown();
            }
        }
        break;
    case STANDBY:
        {
            if(mDebugMessagesFlag)
            {
                Mutex::ScopedLock plock(&mDebugMessagesMutex);
                std::cout << "[" << GetServiceID().ToString() << "-" << mComponentID.ToString() 
                          << "] - " << GetComponent()->AccessControlService()->GetControllerID().ToString() << " Sent Standby at " << Time::GetUtcTime().ToString() << "\n";
            }
            // Ensure appropriate transitions.
            if(mStatus == Status::Ready || mStatus == Status::Initialized)
            {
                SetStatus(Status::Standby);
            }
        }
    default:
        break;
    };
}


Message* Management::CreateMessage(const UShort messageCode) const
{
    Message* message;
    switch(messageCode)
    {
    case CLEAR_EMERGENCY:
        message = new JAUS::ClearEmergency();
        break;
    case QUERY_STATUS:
        message = new JAUS::QueryStatus();
        break;
    case REPORT_STATUS:
        message = new JAUS::ReportStatus();
        break;
    case RESET:
        message = new JAUS::Reset();
        break;
    case RESUME:
        message = new JAUS::Resume();
        break;
    case SET_EMERGENCY:
        message = new JAUS::SetEmergency();
        break;
    case SHUTDOWN:
        message = new JAUS::Shutdown();
        break;
    case STANDBY:
        message = new JAUS::Standby();
        break;
    default:
        message = NULL;
        break;
    };
    return message;
}


bool Management::SetStatus(const Byte state)
{
    // If Byte value is valid...
    if(state <= Status::Emergency)
    {
        mStatus = state;

        // Update Discovery Contents.
        try
        {
            Discovery* discovery = GetComponent()->DiscoveryService();
            if(discovery)
            {
                discovery->GetSubsystem(GetComponentID().mSubsystem)->GetComponent(GetComponentID())->mStatus = (int)mStatus;
            }
        }
        catch(Exception& e)
        {
            e.Print();
        }

        Service::Map children = GetChildServices();
        Service::Map::iterator i;
        for(i = children.begin();
            i != children.end();
            i++)
        {
            Management::Child* child = dynamic_cast<Management::Child*>(i->second);
            if(child)
            {
                switch(mStatus)
                {
                case Status::Ready:
                    child->Resume();
                    break;
                case Status::Standby:
                    child->Standby();
                    break;
                case Status::Emergency:
                    child->SetEmergency();
                    break;
                default:
                    // Do nothing for shutdown or failure.
                    break;
                }
                child->mStatus = mStatus;
            }
        }
        // Signal state change event.
        SignalEvent(REPORT_STATUS);
        return true;
    }
    return false;
}


bool Management::ReleaseControl()
{
    return SetStatus(Status::Standby);
}


int Management::GetComponentStatus(const Address& id, const unsigned int waitTimeMs) const
{
    int result = -1;
    if(id.mSubsystem == GetComponentID().mSubsystem)
    {
        
        std::map<Address, int>::const_iterator s;
        mStatesMutex.Lock();
        s = mSubsystemStates.find(id);
        if(s != mSubsystemStates.end())
        {
            result = (int)s->second;
        }
        mStatesMutex.Unlock();
    }

    if(result == -1)
    {
        JAUS::QueryStatus query(id, GetComponentID());
        JAUS::ReportStatus report;
        if(Send(&query, &report, waitTimeMs))
        {
            result = (int)report.GetStatus();
            // Send again to receive response later for state tracking of this subsystem.
            if(id.mSubsystem == GetComponentID().mSubsystem)
            {
                Send(&query);
            }
        }
    }

    return result;
}


void Management::PrintStatus() const
{
    std::cout << "[" << GetServiceID().ToString() << "] - " << GetComponentID().ToString() << " Status: ";
    switch(mStatus)
    {
    case Status::Ready:
        std::cout << "Ready\n";
        break;
    case Status::Standby:
        std::cout << "Standby\n";
        break;
    case Status::Shutdown:
        std::cout << "Shutdown\n";
        break;
    case Status::Failure:
        std::cout << "Failure\n";
        break;
    case Status::Emergency:
        std::cout << "Emergency\n";
        break;
    default:
        std::cout << "Intialized\n";
        break;
    }
}


void Management::PrintStatus(const bool allData) const
{
    std::cout << "[" << GetServiceID().ToString() << "] - " << GetComponentID().ToString() << " Status: ";
    switch(mStatus)
    {
    case Status::Ready:
        std::cout << "Ready\n";
        break;
    case Status::Standby:
        std::cout << "Standby\n";
        break;
    case Status::Shutdown:
        std::cout << "Shutdown\n";
        break;
    case Status::Failure:
        std::cout << "Failure\n";
        break;
    case Status::Emergency:
        std::cout << "Emergency\n";
        break;
    default:
        std::cout << "Intialized\n";
        break;
    }

    if(allData)
    {
        std::cout << "State of Subsystem Components:\n";
        Mutex::ScopedLock lock(&mStatesMutex);
        std::map<Address, int>::const_iterator s;
        for(s = mSubsystemStates.begin();
            s != mSubsystemStates.end();
            s++)
        {
            std::cout << "    " << s->first.ToString() << " - ";
            switch(s->second)
            {
            case (int)Status::Ready:
                std::cout << "Ready\n";
                break;
            case (int)Status::Standby:
                std::cout << "Standby\n";
                break;
            case (int)Status::Shutdown:
                std::cout << "Shutdown\n";
                break;
            case (int)Status::Initialized:
                std::cout << "Initialized\n";
                break;
            case (int)Status::Emergency:
                std::cout << "Emergency\n";
                break;
            default:
                std::cout << "Unknown\n";
                break;
            }
        }
    }
}


void Management::CheckServiceStatus(const unsigned int timeSinceLastCheckMs)
{
    if(mShutdownServiceFlag)
    {
        return;
    }
    if(Time::GetUtcTimeMs() - mCheckStatusTimeMs >= 2000)
    {
        // Verify status is set correctly for all child services.
        Service::Map children = GetChildServices();
        Service::Map::iterator i;
        for(i = children.begin();
            i != children.end();
            i++)
        {
            Management::Child* child = dynamic_cast<Management::Child*>(i->second);
            if(child)
            {
                child->mStatus = mStatus;
            }
        }
        
        // Query all components for this subsystem for there status.
        Address::List components = GetComponent()->DiscoveryService()->GetSubsystem(GetComponentID().mSubsystem)->GetAddressList();
        Address::List::iterator c;

        mStatesMutex.Lock();
        std::map<Address, int> states;

        states[GetComponentID()] = mStatus;
        // Rebuild our states map since components may no longer be
        // part of the subsystem or new ones may have been discovered.
        for(c = components.begin();
            c != components.end();
            c++)
        {
            if(*c != GetComponentID())
            {
                if(mSubsystemStates.find(*c) != mSubsystemStates.end())
                {
                    states[*c] = mSubsystemStates[*c];
                }
                else
                {
                    states[*c] = -1; // Unknown state value.
                }
            }
        }
        mSubsystemStates = states;

        mStatesMutex.Unlock();

        // Now query everyone for the status.
        QueryStatus query(Address(), GetComponentID());
        for(c = components.begin();
            c != components.end() && mShutdownServiceFlag == false;
            c++)
        {
            if(*c != GetComponentID()) // Only query other components.
            {
                query.SetDestinationID(*c);
                if(!GetComponent()->EventsService()->HaveSubscription(REPORT_STATUS, *c))
                {
                    if(GetComponent()->EventsService()->RequestPeriodicEvent(*c, &query, 0.5, 0.25) == false)
                    {
                        // Do a manual query if we can't create a subscription.
                        Send(&query);
                    }
                }
            }
        }

        Subsystem::Map subsystems;
        Subsystem::Map::iterator ss;
        GetComponent()->DiscoveryService()->GetSubsystems(subsystems);
        for(ss = subsystems.begin();
            ss != subsystems.end();
            ss++)
        {
            components = ss->second->GetComponentsWithService(Management::Name);
            for(c = components.begin();
                c != components.end() && mShutdownServiceFlag == false;
                c++)
            {
                if(*c != GetComponentID()) // Only query other components.
                {
                    query.SetDestinationID(*c);
                    if(ss->second->GetComponent(*c)->mStatus < 0)
                    {
                        Send(&query);
                    }
                }
            }
        }
        // Free memory
        Subsystem::DeleteSubsystemMap(subsystems);

        mCheckStatusTimeMs = Time::GetUtcTimeMs();
    }
}

/*  End of File */