maciContainerServices.h

Go to the documentation of this file.

#ifndef maciContainerServices_h
#define maciContainerServices_h
/*******************************************************************************
 *    ALMA - Atacama Large Millimiter Array
 *    (c) European Southern Observatory, 2002
 *    Copyright by ESO (in the framework of the ALMA collaboration)
 *    and Cosylab 2002, All rights reserved
 *
 *    This library is free software; you can redistribute it and/or
 *    modify it under the terms of the GNU Lesser General Public
 *    License as published by the Free Software Foundation; either
 *    version 2.1 of the License, or (at your option) any later version.
 *
 *    This library 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
 *    Lesser General Public License for more details.
 *
 *    You should have received a copy of the GNU Lesser General Public
 *    License along with this library; if not, write to the Free Software
 *    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA
 *
 *
 * "@(#) $Id: maciContainerServices.h,v 1.36 2011/10/14 16:57:58 rtobar Exp $"
 *
 * who       when      what
 * --------  --------  ----------------------------------------------
 * rcirami   27/11/03  created 
 */

#include <acsutil.h>
#include <acsContainerServices.h>
#include <maciComponentStateManager.h>
#include <acscomponentImpl.h>
#include <logging.h>
#include <maciContainerImpl.h>
#include <cdbDALS.h>
#include <acscomponentS.h>
#include <acscommonS.h>
#include <acsErrTypeContainerServices.h>
#include <acsErrTypeLifeCycle.h>
#include <vector>
#include <string>
#include <iterator>

#include <ace/Synch.h>
#include <ace/Hash_Map_Manager.h>

namespace maci {
        
class ContainerImpl;
class MACIContainerServices;
class ComponentReleaseCallback;

//Dummy CBlong Callback implementation
class MyCBlongImpl: public POA_ACS::CBlong {
public:
    MyCBlongImpl(ComponentReleaseCallback *cb);
    virtual ~MyCBlongImpl();
    void working(::CORBA::Long value, const ::ACSErr::Completion & c,
            const ::ACS::CBDescOut & desc);
    void done(::CORBA::Long value, const ::ACSErr::Completion & c,
            const ::ACS::CBDescOut & desc);
    ::CORBA::Boolean negotiate(::ACS::TimeInterval time_to_transmit,
            const ::ACS::CBDescOut & desc);
private:
    ComponentReleaseCallback *callback;
};

class ComponentReleaseCallback {
    friend class MACIContainerServices;
    friend class MyCBlongImpl;

public:
    ComponentReleaseCallback();
    virtual ~ComponentReleaseCallback();
    virtual void errorNoPermission(std::string message);
    virtual void componentReleased(maciErrType::ComponentDeactivationUncleanEx deactivationUncleanEx);
    virtual void componentReleased();
    virtual void errorComponentReleaseFailed(maciErrType::ComponentDeactivationUncleanEx deactivationFailureEx);

    bool awaitComponentRelease(unsigned long timeout);

private:
    MyCBlongImpl myCBlong;
    ACE_Mutex mutex;

    void callOver();
};

class MACIContainerServices: public ContainerServices

{
  public:
  
  MACIContainerServices(
    const maci::Handle componentHandle, 
    ACE_CString& name,
    ACE_CString& type,
    PortableServer::POA_ptr poa);

  MACIContainerServices(
                  const maci::Handle componentHandle,
                  ACE_CString& name,
                  PortableServer::POA_ptr poa,
                  Manager_ptr manager);

  virtual ~MACIContainerServices();
 
  public:
 
    void test(const char* txt);
    CORBA::Object* getCORBAComponent(const char* name);

    CORBA::Object* getCORBAComponentNonSticky(const char* name);
    
    CORBA::Object* getCORBADynamicComponent(maci::ComponentSpec compSpec, bool markAsDefault);
    
    CORBA::Object* getCORBACollocatedComponent(maci::ComponentSpec compSpec, bool markAsDefault, const char* targetComponent);
    
    CORBA::Object* getCORBADefaultComponent(const char* idlType);
  
 public:

  ComponentInfo getComponentDescriptor(const char* componentName);

  ACE_CString_Vector findComponents(const char *nameWilcard, const char *typeWildcard);

    void releaseComponent(const char *name);
    
    void releaseComponent(std::string &name, ComponentReleaseCallback *callback);

    void releaseAllComponents();

  CDB::DAL_ptr getCDB();
  
  PortableServer::POA_var getOffShootPOA() { return m_offShootPOA; }

  ACS::OffShoot_ptr activateOffShoot(PortableServer::Servant cbServant);
  
  void deactivateOffShoot(PortableServer::Servant cbServant);
  
  PortableServer::POA_var createOffShootPOA();
  
   maci::ComponentStateManager* getComponentStateManager();

   acsalarm::AlarmSource* getAlarmSource() { return m_alarmSource; }

    void fireComponentsUnavailable(ACE_CString_Vector& compNames);
    void fireComponentsAvailable(ACE_CString_Vector& compNames);

 private:

  maci::Manager_var m_manager;

  maci::ContainerImpl *m_containerImpl;
  
  PortableServer::POA_var m_offShootPOA; 
  
  maci::Handle m_componentHandle;
  
  typedef ACE_Hash_Map_Manager <ACE_CString, maci::Handle, ACE_Recursive_Thread_Mutex> COMPONENT_HASH_MAP;
  typedef ACE_Hash_Map_Iterator <ACE_CString, maci::Handle, ACE_Recursive_Thread_Mutex> COMPONENT_HASH_MAP_ITER;
  typedef ACE_Hash_Map_Entry <ACE_CString, maci::Handle> COMPONENT_HASH_MAP_ENTRY;

  COMPONENT_HASH_MAP m_usedComponents;

  maci::ComponentStateManager* componentStateManager_mp;

  acsalarm::AlarmSource* m_alarmSource;

};

} // end namespace maci

#endif // maciContainerServices_h