jaus++/2.0/src/jaus/core/control/accesscontrol.cpp

Go to the documentation of this file.

#include "jaus/core/control/accesscontrol.h"
#include "jaus/core/events/event.h"
#include "jaus/core/component.h"

#include <iostream>
#include <tinyxml/tinyxml.h>

using namespace JAUS;

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

AccessControl::AccessControl() : Events::Child(Service::ID(AccessControl::Name),
                                               Service::ID(Events::Name))
{
    mControllableFlag = true;
    mAuthorityCode = 0;
    mControllerAuthorityCode = 0;
    mTimeoutPeriod = 5;
    mTimeoutThreshold = 25; // % threshold.
}


AccessControl::~AccessControl()
{
}


bool AccessControl::AcceptCommandMessage(const Message* commandMessage) const
{
    if(commandMessage->IsCommand())
    {
        // Check for exclusive control before
        // passing command to child services for
        // processing.
        Mutex::ScopedLock lock(&mControlMutex);
        if(mControllerID.IsValid() && mControllerID != commandMessage->GetSourceID())
        {
            // The only command to allow through is Request Control.
            if(commandMessage->GetMessageCode() != REQUEST_CONTROL)
            {
                return false;
            }
        }
    }
    return true;
}


bool AccessControl::LoadSettings(const std::string& filename)
{
    TiXmlDocument xml;

    if(xml.LoadFile(filename.c_str()) == false)
    {
        return false;
    }
    TiXmlHandle doc(&xml);
    TiXmlNode* node;
    node = doc.FirstChild("JAUS").FirstChild("AccessControl").FirstChild("Controllable").FirstChild().ToNode();
    if(node && node->Value())
    {
        mControllableFlag = atoi(node->Value()) > 0 ? true : false;
    }
    TiXmlElement* element = NULL;
    element = doc.FirstChild("JAUS").FirstChild("AccessControl").FirstChild("TimeoutSeconds").ToElement();
    if(element && element->FirstChild() && element->FirstChild()->Value())
    {
        mTimeoutPeriod = (Byte)atoi(element->FirstChild()->Value());

        if(element->Attribute("threshold"))
        {
            mTimeoutThreshold = atof(element->Attribute("threshold"));
            if(mTimeoutThreshold < 0.5 || mTimeoutThreshold > 50.0)
            {
                mTimeoutThreshold = 5; // 5 %
            }
        }
    }
    node = doc.FirstChild("JAUS").FirstChild("AccessControl").FirstChild("AuthorityLevel").FirstChild().ToNode();
    if(node && node->Value())
    {
        mAuthorityCode = (Byte)atoi(node->Value());
    }
    
    return true;
}


void AccessControl::Shutdown()
{
    // Release control of all components.
    ReleaseComponentControl(Address());
    // Send loss of control to controller.
    if(mControllerID.IsValid())
    {
        RejectControl release(mControllerID, GetComponentID());
        release.SetResponseCode(RejectControl::ControlReleased);
        Send(&release);
    }
} 


bool AccessControl::RequestComponentControl(const Address& id, 
                                            const bool reacquire,
                                            const unsigned int waitTimeMs)
{
    RequestControl request(id, GetComponentID());
    request.SetAuthorityCode(mAuthorityCode);
    Message::List responses;
    ConfirmControl confirm;
    RejectControl reject;
    responses.push_back(&confirm);
    responses.push_back(&reject);

    if(Send(&request, responses, waitTimeMs) && responses.size() == 1)
    {
        // See if control was acquired.
        if(responses.front()->GetMessageCode() == CONFIRM_CONTROL)
        {
            if(confirm.GetResponseCode() == ConfirmControl::ControlAccepted)
            {
                // Don't use a scoped lock because we
                // dont' want the callback mutex run within it.

                mControlMutex.Lock();
                mControlledComponents.insert(id);
                mMaintainFlags[id] = reacquire;    
                mControlFlags[id] = true;
                // Set the time we verified we have control.
                mControlCheckTimes[id].SetCurrentTime();
                // Set the time we confirmed control.
                mControlConfirmTimes[id].SetCurrentTime();
                // Set a default value for timeout.
                mTimeoutPeriods[id] = mTimeoutPeriod;

                // Unlock
                mControlMutex.Unlock();

                // Query the timout period for the component.
                QueryTimeout query(id, GetComponentID());
                Send(&query);

                // Trigger acquisition of control events!

                Service::Map children = GetChildServices();
                Service::Map::iterator child;
                for(child = children.begin();
                    child != children.end();
                    child++)
                {
                    Child* controlChild = dynamic_cast<Child *>(child->second);
                    if(controlChild)
                    {
                        controlChild->ProcessAcquisitionOfControl(id);
                    }
                }

                Mutex::ScopedLock cbLock(&mCallbacksMutex);
                Callback::Set::iterator cb;
                for(cb = mCallbacks.begin();
                    cb != mCallbacks.end();
                    cb++)
                {
                    (*cb)->ProcessAcquisitionfControl(id);
                }

                return true;
            }
        }
        else
        {
            return false;
        }
    }
    return false;
}

bool AccessControl::ReleaseComponentControl(const Address& id, 
                                            const unsigned int waitTimeMs)
{
    bool result = false;

    if(id.IsValid() == false)
    {
        result = true;
        Address::Set controlled;
        mControlMutex.Lock();
        controlled = mControlledComponents;
        mControlMutex.Unlock();
        Address::Set::iterator component;
        for(component = controlled.begin();
            component != controlled.end();
            component++)
        {
            result &= ReleaseComponentControl(*component, waitTimeMs);
        }
    }
    else
    {
        std::map<Address, bool>::iterator flag;
        mControlMutex.Lock();
        flag = mControlFlags.find(id);
        if(flag != mControlFlags.end())
        {
            // If we lost control at some point, then
            // we don't need to release it, just remove
            // the component from our lists.
            if(flag->second == false)
            {
                result = true;
                // Remove the component from our lists.
                EraseComponentControlInfo(id);
            }
        }
        else
        {
            // Can't release control of a component
            // we never requested control from.
            result = true;
            EraseComponentControlInfo(id);
        }
        mControlMutex.Unlock();

        if(!result)
        {
            // Signal control routines to not
            // try and maintain control for this component anymore.
            mControlMutex.Lock();
            mToReleaseControl.insert(id);
            mControlMutex.Unlock();
            // Send request to release control, and verify response.
            ReleaseControl release(id, GetComponentID());

            RejectControl reject;

            if(Send(&release, &reject, waitTimeMs))
            {
                if(reject.GetResponseCode() == RejectControl::ControlReleased)
                {
                    result = true;
                    Mutex::ScopedLock lock(&mControlMutex);
                    EraseComponentControlInfo(id);
                }
            }

            // Remove ID.
            mControlMutex.Lock();
            mToReleaseControl.erase(mToReleaseControl.find(id));
            mControlMutex.Unlock();
        }
    }
    return result;
}


bool AccessControl::GenerateEvent(const Events::Subscription& info) const
{
    if(info.mpQueryMessage->GetMessageCode() == QUERY_AUTHORITY)
    {
        ReportAuthority report;
        report.SetAuthorityCode(mAuthorityCode);
        SendEvent(info, &report);
        return true;
    }
    else if(info.mpQueryMessage->GetMessageCode() == QUERY_CONTROL)
    {
        ReportControl report;
        report.SetAuthorityCode(mControllerAuthorityCode);
        report.SetControllingComponent(mControllerID);
        SendEvent(info, &report);
        return true;
    }

    return false; // Unsupported event.
}


bool AccessControl::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_AUTHORITY:
    case QUERY_CONTROL:
        confirmedPeriodicRate = requestedPeriodicRate;
        result = true;
        break;
    default:
        result = false;
        break;
    };
    return result;
}


void AccessControl::SetControllable(const bool on)
{
    mControllableFlag = on;
}


void AccessControl::Receive(const Message* message)
{
    if(AcceptCommandMessage(message) == false)
    {
        return;
    }

    if(mControllerID == message->GetSourceID())
    {
        mControllerUpdateTime.SetCurrentTime();
    }

    switch(message->GetMessageCode())
    {
    case CONFIRM_CONTROL:
        {
            const ConfirmControl* command = dynamic_cast<const ConfirmControl*>(message);
            if(command == NULL)
                return;
            
            if(command->GetResponseCode() == ConfirmControl::ControlAccepted)
            {
                bool firstTime = true;

                // Lock data.
                mControlMutex.Lock();
                // See if we already had control, and if not, then
                // we re-acquired control of this component and must
                // signal via callbacks, etc. of this event.
                Address::Set::iterator controlledComponent = mControlledComponents.find(message->GetSourceID());
                if(controlledComponent != mControlledComponents.end())
                {
                    // If we get here, we have been trying to control this
                    // component. Check the control status flag.
                    std::map<Address, bool>::iterator flag = mControlFlags.find(message->GetSourceID());
                    if(flag->second == true)
                    {
                        // We already had control, nothing new here.
                        // So don't trigger events.
                        firstTime = false;
                    }
                }

                mControlledComponents.insert(message->GetSourceID());
                mControlConfirmTimes[message->GetSourceID()].SetCurrentTime();
                mControlFlags[message->GetSourceID()] = true;

                // Unlock data.
                mControlMutex.Unlock();

                if(mDebugMessagesFlag)
                {
                    Mutex::ScopedLock plock(&mDebugMessagesMutex);
                    if(firstTime)
                    {
                        std::cout << "[" << GetServiceID().ToString() << "-" << mComponentID.ToString() 
                                  << "] - Acquired Control of " << message->GetSourceID().ToString() << " at " << Time::GetUtcTime().ToString() << "\n";
                    }
                    else
                    {
                        std::cout << "[" << GetServiceID().ToString() << "-" << mComponentID.ToString() 
                                  << "] - Maintained Control of " << message->GetSourceID().ToString() << " at " << Time::GetUtcTime().ToString() << "\n";
                    }
                }

                // Trigger callbacks if needed.
                if(firstTime)
                {
                    Service::Map children = GetChildServices();
                    Service::Map::iterator child;
                    for(child = children.begin();
                        child != children.end();
                        child++)
                    {
                        Child* controlChild = dynamic_cast<Child *>(child->second);
                        if(controlChild)
                        {
                            controlChild->ProcessAcquisitionOfControl(message->GetSourceID());
                        }
                    }

                    Mutex::ScopedLock cbLock(&mCallbacksMutex);
                    Callback::Set::iterator cb;
                    for(cb = mCallbacks.begin();
                        cb != mCallbacks.end();
                        cb++)
                    {
                        (*cb)->ProcessAcquisitionfControl(message->GetSourceID());
                    }
                }
            }
            else
            {
                Address::Set::iterator component;

                // Lock data.
                mControlMutex.Lock();

                component = mControlledComponents.find(message->GetSourceID());
                if(component != mControlledComponents.end())
                {                    
                    std::map<Address, bool>::iterator flag;
                    flag = mMaintainFlags.find(message->GetSourceID());
                    if(flag != mMaintainFlags.end())
                    {
                        // If we didn't get control, and we are not
                        // trying to maintain control, remove the component
                        // from our lists. If we don't have high enough authority
                        // then don't bother trying to re-acquire control.
                        if(flag->second == false || command->GetMessageCode() == ConfirmControl::InsufficientAuthority)
                        {
                            EraseComponentControlInfo(message->GetSourceID());
                        }
                        else // Update control status
                        {
                            mControlFlags[message->GetSourceID()] = false;
                        }
                    }
                    // Delete junk data.
                    else
                    {
                        EraseComponentControlInfo(message->GetSourceID());
                    }
                }
                // Unlock data.
                mControlMutex.Unlock();
            }
        }
        break;
    case QUERY_AUTHORITY:
        {
            if(mShutdownServiceFlag)
            {
                break;
            }
            Mutex::ScopedLock lock(&mControlMutex);
            ReportAuthority report(message->GetSourceID(), GetComponentID());
            report.SetAuthorityCode(mAuthorityCode);
            Send(&report);
        }
        break;
    case QUERY_CONTROL:
        {
            Mutex::ScopedLock lock(&mControlMutex);
            ReportControl report(message->GetSourceID(), GetComponentID());
            report.SetAuthorityCode(mControllerAuthorityCode);
            report.SetControllingComponent(mControllerID);
            Send(&report);
        } 
        break;
    case QUERY_TIMEOUT:
        {
            Mutex::ScopedLock lock(&mControlMutex);
            ReportTimeout report(message->GetSourceID(), GetComponentID());
            report.SetTimeoutSeconds(mTimeoutPeriod);
            Send(&report);
        }
        break;
    case REJECT_CONTROL:
        {
            const RejectControl* command = dynamic_cast<const RejectControl*>(message);
            if(mShutdownServiceFlag || command == NULL)
                return;

            Mutex::ScopedLock lock(&mControlMutex);

            Address::Set::iterator component;
            component = mControlledComponents.find(message->GetSourceID());
            if(component != mControlledComponents.end())
            {                
                std::map<Address, bool>::iterator flag;
                flag = mMaintainFlags.find(message->GetSourceID());
                if(flag != mMaintainFlags.end())
                {
                    // If we lost control, and we are not
                    // trying to maintain control, remove the component
                    // from our lists.
                    if(flag->second == false)
                    {
                        mMaintainFlags.erase(flag);
                        mControlFlags.erase(mControlFlags.find(message->GetSourceID()));
                        mControlConfirmTimes.erase(mControlConfirmTimes.find(message->GetSourceID()));
                        mControlledComponents.erase(component);
                    }
                    else // Update control status
                    {
                        mControlFlags[message->GetSourceID()] = false;
                    }
                    // Generate events and callbacks.
                    Mutex::ScopedLock clock(&mCallbacksMutex);
                    Callback::Set::iterator cb;
                    for(cb = mCallbacks.begin();
                        cb != mCallbacks.end();
                        cb++)
                    {
                        (*cb)->ProcessLossOfControl(message->GetSourceID());
                    }
                }
                // Delete junk data.
                else
                {
                    if(mControlFlags.find(*component) != mControlFlags.end())
                    {
                        mControlFlags.erase(*component);
                    }
                    mControlledComponents.erase(*component);
                }
            }
            if(mDebugMessagesFlag)
            {
                Mutex::ScopedLock plock(&mDebugMessagesMutex);
                std::cout << "[" << GetServiceID().ToString() << "-" << mComponentID.ToString() 
                          << "] - Lost Control of " << message->GetSourceID().ToString() << " at " << Time::GetUtcTime().ToString() << "\n";
            }
        }
        break;
    case RELEASE_CONTROL:
        {
            const ReleaseControl* command = dynamic_cast<const ReleaseControl*>(message);
            if(mShutdownServiceFlag || command == NULL)
                return;
            
            Mutex::ScopedLock lock(&mControlMutex);
            if(command->GetSourceID() == mControllerID)
            {
                RejectControl response(mControllerID, GetComponentID());

                bool controlReleased = true;
                Service::Map children = GetChildServices();
                Service::Map::iterator child;
                for(child = children.begin();
                    child != children.end();
                    child++)
                {
                    Child* controlChild = dynamic_cast<Child *>(child->second);
                    if(controlChild)
                    {
                        if(controlChild->ReleaseControl())
                        {
                            controlReleased;
                        }
                    }
                }
                if(controlReleased)
                {
                    response.SetResponseCode(RejectControl::ControlReleased);
                    Send(&response);

                    mControllerID = Address();
                    mControllerAuthorityCode = 0;
                    mControllerUpdateTime.Clear();
                    mControllerCheckTime.Clear();

                    if(mDebugMessagesFlag)
                    {
                        Mutex::ScopedLock plock(&mDebugMessagesMutex);
                        std::cout << "[" << GetServiceID().ToString() << "-" << mComponentID.ToString() 
                                  << "] - Control Released from " << message->GetSourceID().ToString() << " at " << Time::GetUtcTime().ToString() << "\n";
                    }

                    // Generate events and callbacks.
                    Mutex::ScopedLock clock(&mCallbacksMutex);
                    Callback::Set::iterator cb;
                    for(cb = mCallbacks.begin();
                        cb != mCallbacks.end();
                        cb++)
                    {
                        (*cb)->ProcessReleaseOfControl(message->GetSourceID());
                    }
                    SignalEvent(REPORT_CONTROL);
                }
                else
                {
                    response.SetResponseCode(RejectControl::NotAvailable);
                    Send(&response);
                }
            }
        }
        break;
    case REPORT_AUTHORITY:
        {
            const JAUS::ReportAuthority* report = dynamic_cast<const JAUS::ReportAuthority*>(message);
            if(report)
            {
                // Update Discovery Contents.
                try
                {
                    Discovery* discovery = GetComponent()->DiscoveryService();
                    if(discovery)
                    {
                        discovery->GetSubsystem(report->GetSourceID().mSubsystem)->GetComponent(report->GetSourceID())->mAuthorityLevel = (int)report->GetAuthorityCode();
                        if( discovery->GetVehicle(report->GetSourceID().mSubsystem).IsValid() && 
                            discovery->GetVehicle(report->GetSourceID().mSubsystem)->mAuthority < (int)report->GetAuthorityCode())
                        {
                            discovery->GetVehicle(report->GetSourceID().mSubsystem)->mAuthority = (int)report->GetAuthorityCode();
                        }
                    }
                }
                catch(Exception& e)
                {
                    e.Print();
                }
            }
        }
        break;
    case REPORT_CONTROL:
        // Not used.
        break;
    case REPORT_TIMEOUT:
        {
            const ReportTimeout* report = dynamic_cast<const ReportTimeout*>(message);
            if(report == NULL)
                return;

            Mutex::ScopedLock lock(&mControlMutex);
            mTimeoutPeriods[message->GetSourceID()] = report->GetTimeoutSeconds();
            if(mTimeoutPeriods[message->GetSourceID()] == 0)
            {
                // We always want to check for control.
                mTimeoutPeriods[message->GetSourceID()] = 2;
            }
        }
        break;
    case REQUEST_CONTROL:
        {
            const RequestControl* command = dynamic_cast<const RequestControl*>(message);
            if(mShutdownServiceFlag || command == NULL)
                return;
            
            ConfirmControl response(message->GetSourceID(), GetComponentID());

            Mutex::ScopedLock lock(&mControlMutex);
            // If they have minimum authority and we are
            // not under control or component has greater authority than
            // the current controller, accept.
            if(mControllableFlag && 
               command->GetAuthorityCode() >= mAuthorityCode &&
               (mControllerID == command->GetSourceID() || mControllerID.IsValid() == false || command->GetAuthorityCode() > mControllerAuthorityCode))
            {
                bool controlAccepted = true;
                Service::Map children = GetChildServices();
                Service::Map::iterator child;
                for(child = children.begin();
                    child != children.end();
                    child++)
                {
                    Child* controlChild = dynamic_cast<Child *>(child->second);
                    if(controlChild)
                    {
                        controlAccepted = controlChild->RequestControl();
                        if(controlAccepted)
                        {
                            break;
                        }
                    }
                }
                // This check is needed in case any child
                // service (Management) is in an Emergency state
                // and cannot transition.
                if(controlAccepted == false)
                {
                    response.SetResponseCode(ConfirmControl::NotAvailable);
                }
                else
                {
                    response.SetResponseCode(ConfirmControl::ControlAccepted);
                    if(mControllerID != command->GetSourceID() && mControllerID.IsValid())
                    {
                        // Notify controller that they have lost control.
                        RejectControl reject(mControllerID, GetComponentID());
                        reject.SetResponseCode(RejectControl::ControlReleased);
                        Send(&reject);
                    }
                    mControllerID = message->GetSourceID();
                    mControllerAuthorityCode = command->GetAuthorityCode();
                    mControllerCheckTime.SetCurrentTime();
                    mControllerUpdateTime.SetCurrentTime();
                    if(mDebugMessagesFlag)
                    {
                        Mutex::ScopedLock plock(&mDebugMessagesMutex);
                        std::cout << "[" << GetServiceID().ToString() << "-" << mComponentID.ToString() 
                            << "] - Control Granted to " << message->GetSourceID().ToString() << " at " << Time::GetUtcTime().ToString() << "\n";
                    }
                }
            }
            else
            {    
                if(mControllableFlag == false)
                {
                    response.SetResponseCode(ConfirmControl::NotAvailable);
                }
                else
                {                    
                    response.SetResponseCode(ConfirmControl::InsufficientAuthority);
                }      
                if(mDebugMessagesFlag)
                {
                    Mutex::ScopedLock plock(&mDebugMessagesMutex);
                    std::cout << "[" << GetServiceID().ToString() << "-" << mComponentID.ToString() 
                              << "] - Control Rejected from " << message->GetSourceID().ToString() << " at " << Time::GetUtcTime().ToString() << "\n";
                }
            }
            Send(&response);
        }
        break;
    case SET_AUTHORITY:
        {
            const SetAuthority* command = dynamic_cast<const SetAuthority*>(message);
            if(command == NULL)
                return;
            
            Mutex::ScopedLock lock(&mControlMutex);
            mAuthorityCode = command->GetAuthorityCode();
            SignalEvent(REPORT_AUTHORITY);

            // Update Discovery Contents.
            try
            {
                Discovery* discovery = GetComponent()->DiscoveryService();
                if(discovery)
                {
                    discovery->GetSubsystem(command->GetDestinationID().mSubsystem)->GetComponent(command->GetDestinationID())->mAuthorityLevel = (int)command->GetAuthorityCode();
                    if(discovery->GetVehicle(command->GetDestinationID().mSubsystem)->mAuthority < (int)command->GetAuthorityCode())
                    {
                        discovery->GetVehicle(command->GetDestinationID().mSubsystem)->mAuthority = (int)command->GetAuthorityCode();
                    }
                }
            }
            catch(Exception& e)
            {
                e.Print();
            }
        }
        break;
    default:
        break;
    };
}


Message* AccessControl::CreateMessage(const UShort messageCode) const
{
    Message* message;
    switch(messageCode)
    {
    case CONFIRM_CONTROL:
        message = new ConfirmControl();
        break;
    case QUERY_AUTHORITY:
        message = new QueryAuthority();
        break;
    case QUERY_CONTROL:
        message = new QueryControl();
        break;
    case QUERY_TIMEOUT:
        message = new QueryTimeout();
        break;
    case REJECT_CONTROL:
        message = new RejectControl();
        break;
    case RELEASE_CONTROL:
        message = new ReleaseControl();
        break;
    case REPORT_AUTHORITY:
        message = new ReportAuthority();
        break;
    case REPORT_CONTROL:
        message = new ReportControl();
        break;
    case REPORT_TIMEOUT:
        message = new ReportTimeout();
        break;
    case REQUEST_CONTROL:
        message = new RequestControl();
        break;
    case SET_AUTHORITY:
        message = new SetAuthority();
        break;
    default:
        message = NULL;
        break;
    };
    return message;
}


void AccessControl::SetAuthorityCode(const Byte authorityCode)
{
    Mutex::ScopedLock lock(&mControlMutex);
    mAuthorityCode = authorityCode;
    SignalEvent(REPORT_AUTHORITY);
}


bool AccessControl::HaveControl(const Address& id) const
{
    Mutex::ScopedLock lock(&mControlMutex);
    
    if(id.IsValid() == false && mControlledComponents.size() != 0)
    {
        return true;
    }

    Address::Set::const_iterator c;
    c = mControlledComponents.find(id);
    if(c != mControlledComponents.end())
    {
        return mControlFlags.find(*c)->second;
    }
    return false;
}


bool AccessControl::IsControlled() const
{
    Mutex::ScopedLock lock(&mControlMutex);
    return mControllerID.IsValid();
}


void AccessControl::SetControllerID(const Address& id)
{
    if(id.IsValid() && !id.IsBroadcast())
    {
        Mutex::ScopedLock lock(&mControlMutex);
        mControllerID = id;
    }
}


Address AccessControl::GetControllerID() const
{
    Mutex::ScopedLock lock(&mControlMutex);
    return mControllerID;
}


Byte AccessControl::GetControllerAuthorityCode() const
{
    Mutex::ScopedLock lock(&mControlMutex);
    return mControllerAuthorityCode;
}


Address::List AccessControl::GetControlledComponents() const
{
    Mutex::ScopedLock lock(&mControlMutex);
    Address::List result;
    std::map<Address, bool>::const_iterator flags;
    for(flags = mControlFlags.begin();
        flags != mControlFlags.end();
        flags++)
    {
        if(flags->second)
        {
            result.push_back(flags->first);
        }
    }
    return result;
}


void AccessControl::CheckServiceStatus(const unsigned int timeSinceLastCheckMs)
{
    RequestControl request;

    mControlMutex.Lock();

    request.SetSourceID(GetComponentID());
    request.SetAuthorityCode(mAuthorityCode);

    Address::Set::iterator component;
    Time currentTime;
    currentTime.SetCurrentTime();
    
    for(component = mControlledComponents.begin();
        component != mControlledComponents.end();
        component++)
    {
        // If we are releasing control, do not check.
        if(mToReleaseControl.find(*component) != mToReleaseControl.end())
        {
            continue;
        }
        // If we have not checked within timeout - .x seconds, then re-acquire control to
        // maintain constant control of component.
        double thresh = mTimeoutPeriods[*component]*mTimeoutThreshold/100.0;
        double checkTimeDiff = currentTime.ToSeconds() - mControlCheckTimes[*component].ToSeconds();
        double timeThresh = (mTimeoutPeriods[*component] - thresh);
        bool checkConfirmation = true;
        if(mTimeoutPeriods[*component] > 0 && checkTimeDiff >= thresh)
        {
            request.SetDestinationID(*component);
            if(Send(&request))
            {
                // Update the check time.
                mControlCheckTimes[*component].SetCurrentTime();
                checkConfirmation = false;
            }
        }
        double confirmTimeDiff = currentTime.ToSeconds() - mControlConfirmTimes[*component].ToSeconds();
        timeThresh = (mTimeoutPeriods[*component] + thresh);
        // If we haven't been confirmed in this time, then we have lost control.
        if(checkConfirmation && confirmTimeDiff > timeThresh)
        {
            mControlFlags[*component] = false;
            // Generate events and callbacks.
            Mutex::ScopedLock clock(&mCallbacksMutex);
            Callback::Set::iterator cb;
            for(cb = mCallbacks.begin();
                cb != mCallbacks.end();
                cb++)
            {
                (*cb)->ProcessLossOfControl(*component);
            }
        }
    }
    
    mControlMutex.Unlock();
    // Allow control check time to update.
    mControlMutex.Lock();

    Address controller = mControllerID;
    bool timeout = false;
    currentTime.SetCurrentTime();
    double timeSinceRequest = currentTime - mControllerCheckTime;
    if(mTimeoutPeriod > 0 && 
       controller.IsValid() && 
       timeSinceRequest >= (double)mTimeoutPeriod + mTimeoutPeriod*mTimeoutThreshold/100.0)
    {
        timeout = true;
        // Release control due to timeout.
        RejectControl reject(controller, GetComponentID());
        reject.SetResponseCode(RejectControl::ControlReleased);
        Send(&reject);
        if(mDebugMessagesFlag)
        {
            Mutex::ScopedLock plock(&mDebugMessagesMutex);
            std::cout << "[" << GetServiceID().ToString() << "-" << mComponentID.ToString() 
                      << "] - Control Time Out From " << controller.ToString() << " at " << Time::GetUtcTime().ToString() << "\n";
        }
        // Clear values.
        mControllerID.Clear();
        mControllerAuthorityCode = 0;
        mControllerCheckTime.Clear();
        mControllerUpdateTime.Clear();
    }

    mControlMutex.Unlock();

    if(timeout)
    {
        Callback::Set::iterator cb;
        for(cb = mCallbacks.begin();
            cb != mCallbacks.end();
            cb++)
        {
            (*cb)->ProcessReleaseOfControl(controller);
        }
        Service::Map children = GetChildServices();
        Service::Map::iterator child;
        for(child = children.begin();
            child != children.end();
            child++)
        {
            Child* controlChild = dynamic_cast<Child *>(child->second);
            if(controlChild)
            {
                controlChild->ReleaseControl();
            }
        }
        SignalEvent(REPORT_CONTROL);
    }
}


void AccessControl::SetTimeoutPeriod(const Byte timeSeconds)
{
    Mutex::ScopedLock lock(&mControlMutex);
    mTimeoutPeriod = timeSeconds;
}

Byte AccessControl::GetTimeoutPeriod() const
{
    Mutex::ScopedLock lock(&mControlMutex);
    return mTimeoutPeriod;
}


void AccessControl::RegisterCallback(Callback* callback, const bool add)
{
    Mutex::ScopedLock lock(&mCallbacksMutex);
    if(add)
    {
        mCallbacks.insert(callback);
    }
    else
    {
        Callback::Set::iterator cb;
        cb = mCallbacks.find(callback);
        if(cb != mCallbacks.end())
        {
            mCallbacks.erase(cb);
        }
    }
}


void AccessControl::PrintStatus() const
{
    //Mutex::ScopedLock lock(&mControlMutex);
    
    std::cout << "[" << GetServiceID().ToString() << "] - " << GetComponentID().ToString() << "\n";

    Address controller;
    Byte authority;
    Address::Set controlled;
    std::map<Address, bool> flags;

    mControlMutex.Lock();
    controller = mControllerID;
    authority = mControllerAuthorityCode;
    controlled = mControlledComponents;
    flags = mControlFlags;
    mControlMutex.Unlock();

    if(controller.IsValid())
    {
        std::cout << "Controlled by: " 
                  << controller.ToString() 
                  << " Authority Code: " 
                  << (int)authority << std::endl;
    }
    if(controlled.size() > 0)
    {
        Address::Set::const_iterator c;
        std::cout << "In Control of the Following:\n";
        for(c = controlled.begin();
            c != controlled.end();
            c++)
        {
            if(flags.find(*c)->second)
            {
                std::cout << " - " << c->ToString() << std::endl;
            }
        }
    }
}


void AccessControl::EraseComponentControlInfo(const Address& id)
{
    std::map<Address, Byte>::iterator tp;
    std::map<Address, Time>::iterator ct;
    std::map<Address, bool>::iterator flag;
    Address::Set::iterator c;

    tp = mTimeoutPeriods.find(id);
    if(tp != mTimeoutPeriods.end())
    {
        mTimeoutPeriods.erase(tp);
    }
    ct = mControlCheckTimes.find(id);
    if(ct != mControlCheckTimes.end())
    {
        mControlCheckTimes.erase(ct);
    }
    ct = mControlConfirmTimes.find(id);
    if(ct != mControlConfirmTimes.end())
    {
        mControlConfirmTimes.erase(ct);
    }

    flag = mMaintainFlags.find(id);
    if(flag != mMaintainFlags.end())
    {
        mMaintainFlags.erase(flag);
    }
    flag = mControlFlags.find(id);
    if(flag != mControlFlags.end())
    {
        mControlFlags.erase(flag);
    }

    c = mControlledComponents.find(id);
    if(c != mControlledComponents.end())
    {
        mControlledComponents.erase(c);
    }
}
/*  End of File */