client/protocol/corba/CorbaConnection.h

Go to the documentation of this file.

/*----------------------------------------------------------------------------
Name:      CorbaConnection.h
Project:   xmlBlaster.org
Copyright: xmlBlaster.org, see xmlBlaster-LICENSE file
Comment:   Helper to connect to xmlBlaster: for now a simplified version 
           without caching and without failsafe mode.
Author:    <Michele Laghi> laghi@swissinfo.org
-----------------------------------------------------------------------------*/

#ifndef _CLIENT_PROTOCOL_CORBA_CORBACONNECTION_H
#define _CLIENT_PROTOCOL_CORBA_CORBACONNECTION_H

#include <util/xmlBlasterDef.h>

#include <string>
#include <vector>
#include <fstream>
#include <client/protocol/corba/DefaultCallback.h>
#include <util/I_Log.h>
#include <client/protocol/corba/NameServerControl.h>
#include <util/qos/address/CallbackAddress.h>
#include <util/MessageUnit.h>
#include <util/qos/ConnectQosFactory.h>
#include <util/qos/MsgQosFactory.h>
#include <util/key/MsgKeyFactory.h>

#include <client/protocol/corba/CompatibleCorba.h>  // client side headers
#include COSNAMING

 // org::xmlBlaster::util::qos::ConnectQos + org::xmlBlaster::util::qos::ConnectReturnQos

namespace org {
 namespace xmlBlaster {
  namespace client {
   namespace protocol {
    namespace corba {

   class Dll_Export CorbaConnection {
      
   private:
      
      std::string me() const {
         return std::string("CorbaConnection");
      }
      /* static*/ CORBA::ORB_ptr           orb_;
      /*static*/ PortableServer::POA_ptr  poa_;
      NameServerControl*              nameServerControl_;
      authenticateIdl::AuthServer_ptr authServer_;
      serverIdl::Server_ptr           xmlBlaster_;
      clientIdl::BlasterCallback_ptr  callback_;
      std::string                          loginName_;
      std::string                          passwd_;
      int                             numLogins_;
      DefaultCallback*                defaultCallback_;
      org::xmlBlaster::util::qos::ConnectReturnQosRef connectReturnQos_;
      std::string                          sessionId_;
      std::string                          xmlBlasterIOR_;
      std::string                          callbackIOR_;
      org::xmlBlaster::util::Global&       global_;
      /* mutable */ org::xmlBlaster::util::I_Log&     log_;
      org::xmlBlaster::util::key::MsgKeyFactory msgKeyFactory_;
      org::xmlBlaster::util::qos::MsgQosFactory msgQosFactory_;

   public:
      CorbaConnection(org::xmlBlaster::util::Global& global, CORBA::ORB_ptr orb=NULL);

      ~CorbaConnection();

      std::string getAddress() const;

      std::string getCbAddress() const;

      bool orbPerformWork() {
         if (orb_ != NULL) {
            bool ret = (orb_->work_pending() != 0);
            if (ret) orb_->perform_work();
            return ret;
         }
         else
            return false;
      }


      void run() {
         if (orb_ != NULL)
            orb_->run();
      }
    

      /*
       * Accessing the xmlBlaster handle.
       * @return Server
       * @exception if not logged in
      serverIdl::Server_ptr getXmlBlaster();
       */
      
private:
      void initNamingService();

public:
      void initAuthenticationService();

       org::xmlBlaster::util::qos::ConnectReturnQosRef connect(const org::xmlBlaster::util::qos::ConnectQosRef& connectQos);

       bool disconnect(const std::string& qos="");

       bool shutdown();

       bool shutdownCb();

      void createCallbackServer(POA_clientIdl::BlasterCallback *implObj);


      const std::string &getLoginName() const {
         return loginName_;
      }
      
      
      bool isLoggedIn() {
         if (CORBA::is_nil(authServer_)) initAuthenticationService();
         return (!CORBA::is_nil(xmlBlaster_ /*.in()*/ ));
      }
      
      
      std::string subscribe(const std::string &xmlKey, const std::string &qos=std::string("<qos/>"));
      
 
      std::vector<std::string> unSubscribe(const std::string &xmlKey, const std::string &qos=std::string("<qos/>"));
      
      
      std::string publish(const serverIdl::MessageUnit &msgUnit);

      std::string publish(const util::MessageUnit &msgUnitUtil);
      
      std::vector<std::string> publishArr(const std::vector<util::MessageUnit> &msgVec);
     
      serverIdl::XmlTypeArr* publishArr(const serverIdl::MessageUnitArr& msgUnitArr);

      void publishOneway(const std::vector<util::MessageUnit>& msgVec);

      void publishOneway(const serverIdl::MessageUnitArr& msgUnitArr);

      std::vector<std::string> erase(const std::string &xmlKey, const std::string &qos=std::string("<qos/>"));

      
      std::vector<util::MessageUnit> get(const std::string &xmlKey, const std::string &qos=std::string("<qos/>"));

      //serverIdl::MessageUnitArr* get(const std::string &xmlKey, const std::string &qos);
      
      
      std::string ping(const std::string &qos=std::string("<qos/>"));

      void copyToCorba(serverIdl::MessageUnit &dest, const util::MessageUnit &src) const;

      void copyToCorba(serverIdl::MessageUnitArr_var &units, const std::vector<util::MessageUnit> &msgVec) const;

      void copyFromCorba(std::vector<util::MessageUnit> &vecArr, serverIdl::MessageUnitArr_var &units);

      static std::string usage();
   
   }; // class CorbaConnection
}}}}} // namespace


#endif