Category Archives: CPP

• CORBA基本架构
• IDL文件编写
• CPP示例实现（上）
• CPP示例实现（下）
• C示例实现（IOR+NS上）
• C示例实现（IOR+NS下）
• C示例实现（IOR上）
• C示例实现（IOR下）

然后完成客户端部分，同样分了三个文件：

HiClientImpl.hh

#include <iostream>
#include <fstream>
#include "Hi.hh"
                                                                                
using namespace std;
                                                                                
class HiClientImpl {
public:
   HiClientImpl();
   ~HiClientImpl();
   void TestAdd();
                                                                                
   CosNaming::Name m_corbaCosName;
                                                                                
   // CORBA ORB
   CORBA::ORB_var             m_orb;
   // ORB Object                                                                     
   CORBA::Object_var          m_obj;   
   // Resolved id to object reference   
   CORBA::Object_var          m_obj1;                                                                                  
   // Resolved and narrowed CORBA object for proxy calls
   HiCorba::Hi_var            m_Data;
};
                                                                                
class DS_ServerConnectionException{
public:
   DS_ServerConnectionException() { cerr << "CORBA COMM_FAILURE" << endl; };
};
                                                                                
class DS_SystemException{
public:
   DS_SystemException() { cerr << "CORBA Exception" << endl; };
};
                                                                                
class DS_FatalException{
public:
   DS_FatalException() { cerr << "CORBA Fatal Exception" << endl; };
};
                                                                                
class DS_Exception{
public:
   DS_Exception() { cerr << "Exception" << endl; };
};

HiClientImpl.cc

#include "assert.h"
#include "HiClientImpl.hh"
#include "Hi.hh"
                                                                                
HiClientImpl::HiClientImpl()
{
  try {
    //------------------------------------------------------------------------
    // Initialize ORB object.
    //------------------------------------------------------------------------
    int    argc=0;       // Dummy variables to support following call.
    char** argv=0;
    CORBA::ORB_var orb = CORBA::ORB_init(argc, argv);

    //------------------------------------------------------------------------
    // Bind ORB object to name service object.
    // (Reference to Name service root context.)
    //------------------------------------------------------------------------
    //CORBA::Object_var obj = orb->resolve_initial_references("OmniNameService");
    CORBA::Object_var obj = orb->resolve_initial_references("NameService");
    assert (!CORBA::is_nil(obj.in()));
    cerr << "resolve_initial_reference OK" << endl;
                                                                                
    //------------------------------------------------------------------------
    // Narrow this to the naming context (Narrowed reference to root context.)
    //------------------------------------------------------------------------
    CosNaming::NamingContext_var nc = CosNaming::NamingContext::_narrow(obj.in());
    assert (!CORBA::is_nil(nc.in()));
    cerr << "narrow ok" << endl;
                                                                                
    //------------------------------------------------------------------------
    // The "name text" put forth by CORBA server in name service.
    // This same name ("DataServiceName1") is used by the CORBA server when
    // binding to the name server (CosNaming::Name).
    //------------------------------------------------------------------------
    CosNaming::Name _corbaCosName;
    _corbaCosName.length(1);
    _corbaCosName[0].id=CORBA::string_dup("Hi");
                                                                                
    //------------------------------------------------------------------------
    // Resolve "name text" identifier to an object reference.
    //------------------------------------------------------------------------
    CORBA::Object_var obj1 = nc->resolve(_corbaCosName);
    assert(!CORBA::is_nil(obj1.in()));
    cerr << "resolve OK" << endl;
                                                                                
    m_Data = HiCorba::Hi::_narrow(obj1.in());
    if (CORBA::is_nil(m_Data.in()))
    {
       cerr << "IOR is not an SA object reference." << endl;
    }
    else{
        cerr << "narrow OK" << endl;
    }
  }
  catch(CORBA::COMM_FAILURE& ex) {
    cerr << "Caught system exception COMM_FAILURE -- unable to contact the "
         << "object." << endl;
    throw DS_ServerConnectionException();
    return;
  }
  catch(CORBA::SystemException& ) {
    cerr << "Caught a CORBA::SystemException." << endl;
    throw DS_SystemException();
    return;
  }
  catch(CORBA::Exception& ) {
    cerr << "Caught CORBA::Exception." << endl;
    throw DS_Exception();
    return;
  }  catch(omniORB::fatalException& fe) {
    cerr << "Caught omniORB::fatalException:" << endl;
    cerr << "  file: " << fe.file() << endl;
    cerr << "  line: " << fe.line() << endl;
    cerr << "  mesg: " << fe.errmsg() << endl;
    throw DS_FatalException();
    return;
  }
  catch(...) {
    cerr << "Caught unknown exception." << endl;
    throw DS_Exception();
    return;
  }
  return;
}
                                                                                
HiClientImpl::~HiClientImpl()
{
}
                                                                                
void HiClientImpl::TestAdd()
{
   CORBA::Long num1=70;
   CORBA::Long num2=80;
   CORBA::Long retNum;
                                                                                
   cout << "Values input to Server: "
        << num1 << " "
        << num2 << " " << endl;
                                                                                
   if( retNum = m_Data->add( num1, num2)) // This is the CORBA call which is to be executed remotely
   {    // Ok
      cout << "Values returned by Server: "
           << num1 << "+"
           << num2 << "="
           << retNum << endl;
   }
}

HiClient.cc

#include "HiClientImpl.hh"
                                                                                
int main(int argc, char** argv)
{
   HiClientImpl impl;  
   impl.TestAdd();                                                      
   return 0;
}

MakeClient

CC            = /usr/bin/g++
CPPFLAGS      = -g -c -I/usr/include -I/usr/include/omniORB4
LDFLAGS       = -g -L/usr/lib -lomniORB4 -lomnithread -lomniDynamic4
OMNIIDL       = /usr/bin/omniidl
                                                                                
all: HiClient.bin

HiClient.bin: HiClient.o HiClientImpl.o HiSK.o
	$(CC) $(LDFLAGS) -o HiClient.bin HiClient.o HiClientImpl.o HiSK.o
                                                                                
HiSK.o: HiSK.cc Hi.hh
	$(CC) $(CPPFLAGS) $(INCLUDES) HiSK.cc
                                                                                
HiClient.o: HiClient.cc HiClientImpl.hh
	$(CC) $(CPPFLAGS) HiClient.cc
                                                                                
HiClientImpl.o: HiClientImpl.cc HiClientImpl.hh Hi.hh
	$(CC) $(CPPFLAGS) HiClientImpl.cc
                                                                                
nidl: Hi.idl
	$(OMNIIDL) -bcxx Hi.idl
                                                                                
clean:
	rm -f *.o

编译

make -f MakeClient

然后是运行

#首先检查OMNI Naming Service是否在运行，默认端口2809
ps -aux | grep omni
root      1585  0.0  0.2 315608  4912 ?        Sl   12:04   0:00 /usr/bin/omniNames -errlog /var/log/omniorb-nameserver.log
neohope   1943  0.0  0.1  12720  2180 tty2     S+   14:57   0:00 grep omni

#运行服务端
./HiServer

#运行客户端
./HiClient
>>Values input to Server: 70 80
>>Values returned by Server: 70+80=150

• CORBA基本架构
• IDL文件编写
• CPP示例实现（上）
• CPP示例实现（下）
• C示例实现（IOR+NS上）
• C示例实现（IOR+NS下）
• C示例实现（IOR上）
• C示例实现（IOR下）

在linux系统下，有很多开源的CORBA通讯框架，在CPP的示例中，使用了OmniORB的框架。
如我用的是Debian系统，可以直接安装：

apt-get install omniorb
apt-get install omniorb-nameserver
apt-get install omniidl
apt-get install libomniorb4-dev
export OMNIORB_CONFIG=/etc/omniORB.cfg

然后修改配置文件/etc/omniORB.cfg，修改日志输出级别。

编译Hi.idl文件，将生成文件Hi.hh及HiSK.cc

omniidl -bcxx Hi.idl

首先完成服务端部分，分了三个文件：

HiServerImpl.hh

#include <CORBA.h>
#include "Hi.hh"

class HiServerImpl : public virtual POA_HiCorba::Hi, public virtual PortableServer::RefCountServantBase
{
	public:
		HiServerImpl();
		~HiServerImpl();
		char* sayHiTo(const char* someone);
		::CORBA::Long add(::CORBA::Long numa, ::CORBA::Long numb);
		void shutdown();
};

HiServerImpl.cc

#include <vector>
#include <string>
#include <string.h>
#include <sys/types.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <iostream>
#include <fstream>
#include <stdio.h>
#include <sys/wait.h>

#include "HiServerImpl.hh"

using namespace HiCorba;

HiServerImpl::HiServerImpl()
{
}

HiServerImpl::~HiServerImpl()
{
}

char* HiServerImpl::sayHiTo(const char* someone)
{

}

::CORBA::Long HiServerImpl::add(::CORBA::Long numa, ::CORBA::Long numb)
{
	return numa+numb;
}

void HiServerImpl::shutdown()
{

}

HiServer.cc

#include <stdlib.h>
#include <iostream>
#include <string>
#include <assert.h>
#include <signal.h>
#include <unistd.h>

#include "HiServerImpl.hh"
#include "Hi.hh"

using namespace std;

int main(int argc, char** argv)
{
	try {
		//------------------------------------------------------------------------
		// Initialize CORBA ORB - "orb"
		//------------------------------------------------------------------------
		CORBA::ORB_var orb = CORBA::ORB_init(argc, argv);

		//------------------------------------------------------------------------
		// Servant must register with POA in order to be made available for client
		// Get reference to the RootPOA.
		//------------------------------------------------------------------------
		CORBA::Object_var obj = orb->resolve_initial_references("RootPOA");
		PortableServer::POA_var _poa = PortableServer::POA::_narrow(obj.in());

		//------------------------------------------------------------------------
		// Operations defined in object interface invoked via an object reference.
		// Instance of CRequestSocketStream_i servant is initialized.
		//------------------------------------------------------------------------
		HiServerImpl* impl = new HiServerImpl();

		//------------------------------------------------------------------------
		// Servant object activated in RootPOA.
		// (Object id used for various POA operations.)
		//------------------------------------------------------------------------
		PortableServer::ObjectId_var myOid = _poa->activate_object(impl);

		//------------------------------------------------------------------------
		// Obtain object reference from servant and register in naming service(??)
		//------------------------------------------------------------------------
		CORBA::Object_var SA_obj = impl->_this();

		//------------------------------------------------------------------------
		// Obtain a reference to the object, and print it out as string IOR.
		//------------------------------------------------------------------------
		CORBA::String_var sior(orb->object_to_string(SA_obj.in()));
		cerr << "'" << (char*)sior << "'" << endl;

		//========================================================================
		// Bind (rebind) object (orb) to name (SA_obj)
		//========================================================================

		//------------------------------------------------------------------------
		// Bind object to name service as defined by directive InitRef
		// and identifier "OmniNameService" in config file omniORB.cfg.
		//------------------------------------------------------------------------
		//CORBA::Object_var obj1=orb->resolve_initial_references("OmniNameService");
		CORBA::Object_var obj1=orb->resolve_initial_references("NameService");
		assert(!CORBA::is_nil(obj1.in()));
		cerr << "resolve_initial_references successed" << endl;

		//------------------------------------------------------------------------
		// narrow this to the naming context
		//------------------------------------------------------------------------
		CosNaming::NamingContext_var nc = CosNaming::NamingContext::_narrow(obj1.in());
		assert(!CORBA::is_nil(nc.in()));
		cerr << "narrow successed" << endl;

		//------------------------------------------------------------------------
		// Bind to CORBA name service. Same name to be requested by client.
		//------------------------------------------------------------------------
		CosNaming::Name name;
		name.length(1);
		name[0].id=CORBA::string_dup("Hi");
		nc->rebind (name,SA_obj.in());
		cerr << "rebind successed" << endl;

		//========================================================================
		impl->_remove_ref();

		//------------------------------------------------------------------------
		// Activate the POA manager
		//------------------------------------------------------------------------
		PortableServer::POAManager_var pmgr = _poa->the_POAManager();
		pmgr->activate();
		cerr << "poamanager activate successed" << endl;

		//------------------------------------------------------------------------
		// Accept requests from clients
		//------------------------------------------------------------------------
		orb->run();

		//------------------------------------------------------------------------
		// If orb leaves event handling loop.
		// - currently configured never to time out (??)
		//------------------------------------------------------------------------
		orb->destroy();

		free(name[0].id); // str_dup does a malloc internally
	}
	catch(CORBA::SystemException&) {
		cerr << "Caught CORBA::SystemException." << endl;
	}
	catch(CORBA::Exception&) {
		cerr << "Caught CORBA::Exception." << endl;
	}
	catch(omniORB::fatalException& fe) {
		cerr << "Caught omniORB::fatalException:" << endl;
		cerr << "  file: " << fe.file() << endl;
		cerr << "  line: " << fe.line() << endl;
		cerr << "  mesg: " << fe.errmsg() << endl;
	}
	catch(...) {
		cerr << "Caught unknown exception." << endl;
	}

	return 0;
}

MakeServer

CC            = /usr/bin/g++
CPPFLAGS      = -g -c -I/usr/include -I/usr/include/omniORB4
LDFLAGS       = -g -L/usr/lib -lomniORB4 -lomnithread -lomniDynamic4
OMNIIDL       = /usr/bin/omniidl

all: HiServer.bin
                                                            
HiServer.bin:  HiSK.o HiServerImpl.o HiServer.o
	$(CC) $(LDFLAGS) -o HiServer.bin HiSK.o HiServerImpl.o HiServer.o
                                                                                
HiSK.o: HiSK.cc Hi.hh
	$(CC) $(CPPFLAGS) $(INCLUDES) HiSK.cc
                                                                                
HiServer.o: HiServer.cc Hi.hh
	$(CC) $(CPPFLAGS) $(INCLUDES) HiServer.cc
                                                                                
HiServerImpl_i.o: HiServerImpl.cc HiServerImpl.hh Hi.hh
	$(CC) $(CPPFLAGS) $(INCLUDES) HiServerImpl.cc
                                                                                
nidl: Hi.idl
	$(OMNIIDL) -bcxx Hi.idl
                                                                                
clean:
	rm -f *.o
	rm -f *.bin

编译

make -f MakeServer

本文主要内容涉及：

• CORBA基本架构
• IDL文件编写
• CPP示例实现（上）
• CPP示例实现（下）
• C示例实现（IOR+NS上）
• C示例实现（IOR+NS下）
• C示例实现（IOR上）
• C示例实现（IOR下）

要写一个静态绑定的CORBA程序，首先要完成的就是定义接口。CORBA采用的接口描述方式为IDL（Interface Description Language），IDL的语法规则类似于CPP。

IDL与CPP常见类型映射关系如下：

比如，下面就是一个很简单的IDL文件：
hi.idl

module HiCorba
{
	interface Hi
	{
		string sayHiTo(in string someone);
		long add(in long numa, in long numb);
		oneway void shutdown();
	};
};

本文主要内容涉及：

• CORBA基本架构
• IDL文件编写
• CPP示例实现（上）
• CPP示例实现（下）
• C示例实现（IOR+NS上）
• C示例实现（IOR+NS下）
• C示例实现（IOR上）
• C示例实现（IOR下）

CORBA(Common Object Request Broker Architecture)，即公用对象请求代理程序体系结构，是一种为解决分布式处理环境中硬件和软件系统的互连而提出的一种解决方案。其基本架构如下：

Object Services，即对象服务，是为使用和实现对象而提供的基本对象集合，这些服务应独立于应用领域。主要的CORBA服务有：名录服务（Naming Service）、事件服务（Event Service）、生命周期服务（Life Cycle Service）、关系服务（Relationship Service）以及事务服务（Transaction Service）等。这些服务几乎包括分布系统和面向对象系统的各个方面，每个组成部分都非常复杂。

IDL（Interface Description Language），即接口定义语言，是用来描述软件组件接口的一种规范语言。用户可以定义模块、接口、属性、方法、输入输出参数，甚至异常等等。IDL在不同的语言下都有相应的实现，可以把IDL描述的接口编译为目标语言，包括客户端代理和服务器端框架，以及相应的帮助类等等。

ORB（Object Request Broker），即对象请求代理，是一个中间件，在对象间建立客户-服务器的关系。通过 ORB，一个客户可以很简单地使用服务器对象的方法而不论服务器是在同一机器上还是通过一个网络访问。ORB 截获调用然后负责找到一个对象实现这个请求，传递参数和方法，最后返回结果。客户不用知道对象在哪里，是什么语言实现的，他的操作系统以及其他和对象接口无关的东西。

CORBA按接口绑定方式，分为两大类，一类为动态绑定，一类为静态绑定。这里主要讲的是静态绑定。
在静态绑定时，客户端需要实现IDL Stubs，服务端需要实现IDL Skeleton。
在静态绑定中，CORBA在服务端实现IDL接口有两种方式，一种为继承模式（分为标准模式POA及兼容模式ImplBase），另一种为为委托模式（分为标准模式POA/Tie及兼容模式ImplBase/Tie）。各模式的区别主要在于生成IDL代码时，输入的参数不同，从而生成的接口不同，实现方式也略有区别。这里主要讲的为标准模式。

一次典型的CORBA调用，流程如下图所示：

GIOP（General Inter-ORB Protocol），即通用对象请求代理间通信协，提供了一个标准传输语法（低层数据表示方法）和ORB之间通信的信息格式集。GIOP只能用在ORB与ORB之间，而且，只能在符合理想条件的面向连接传输协议中使用。它不需要使用更高一层的RPC机制。这个协议是简单的（尽可能简单，但不是简单化），可升级的，使用方便。它被设计为可移动的、高效能的表现、较少依靠其它的低层传输协议。当然，由于不同传输使用不同版本的GIOP，它们可能不能直接协作工作，但它能很容易的连接网络域。

IIOP （Internet Inter-ORB Protocol），即Internet对象代理间通信协议，指出如何通过TCP/IP连接交换GIOP信息。IIOP为Internet提供了一个标准的协作工作协议，它使兼容的ORB能基于现在流行的协议和产品进行“out of the box”方式的协作工作。它也能被用于两个半桥（half-bridges ）之间的协议。该协议能用于任何ORB与IP（Internet Protocol）域之间的协作工作，除非ORB选择了特殊的协议。这时，它是TCP/IP环境下基本的inter-ORB 协议，最普遍的传输层。

GIOP 不基于任何特别的网络协议，OMG 在最广泛使用的通信传输平台 — TCP/IP 上标准化 GIOP，GIOP 加 TCP/IP 等于 IIOP。