recoveryprocess.cpp

oracle下调用数据泵接口进行远程数据导出和导入（数据恢复）的CORBA服务

#include <STAR/CORBA.h>

#include <STAR/AFLSInitializer.h>
#include <STAR/Properties.h>
#include <MTL/MTL.h>

#include <checkConfig.h>
#include <STAR/Properties.h>
#include "DataRecovery_impl.h"
#include <DataRecovery.h>

#ifdef __UNIX__
#include <sys/time.h>
#endif

#ifdef _WIN32
#include <time.h>
#endif

#ifdef HAVE_FSTREAM
#   include <fstream>
#else
#   include <fstream.h>
#endif

#ifdef HAVE_STD_IOSTREAM
using namespace std;
#endif

CORBA::ORB_var orb;

DataRecovery_var * DRImpl;

char * sAflsConfig;

int
run(int argc, char* argv[])
{
	  //create afls object
		CORBA::Object_var obj	=
		orb->string_to_object(sAflsConfig);
		
		Afls_var afls =Afls::_narrow(obj);
		assert(!CORBA::is_nil(afls));
		
	  //
	  // Resolve Root POA
	  //
	  CORBA::Object_var poaObj = orb -> resolve_initial_references("RootPOA");
	  PortableServer::POA_var rootPOA = PortableServer::POA::_narrow(poaObj);
	  
	  //
	  // Get a reference to the POA manager
	  //
	  PortableServer::POAManager_var manager = rootPOA -> the_POAManager();
	  
	  CORBA::PolicyList policies;
	  policies.length(2);
	  policies[0] =
	      rootPOA -> create_id_assignment_policy(PortableServer::USER_ID);
	  policies[1] =
	      rootPOA -> create_lifespan_policy(PortableServer::PERSISTENT);
	
	  PortableServer::POA_var poa;
	  try
	  {
	      poa = rootPOA -> create_POA("DRPOA", manager, policies);
	  }
	  catch(const PortableServer::POA::AdapterAlreadyExists&)
	  {
	  }
	  assert(!CORBA::is_nil(poa));
 	
		DataRecovery_impl* DRImpl = new DataRecovery_impl(rootPOA);
		
		if (DRImpl == NULL)
		{
			cerr<<"error in new DataRecovery!"<<endl;	
			return -1;
		}
		DataRecovery_var DRercovery = DRImpl -> _this();
		PortableServer::ServantBase_var servant = DRImpl;
	
		LoadProvider_var lpv = LoadProvider_init(orb);
	
		afls->register_obj("DataRecovery",DRercovery.in(), lpv.in());

		cout << "DataRecovery is available!" << endl;
		manager -> activate();
		orb -> run();
		return 0;
}

int
main(int argc, char* argv[], char*[])
{	
	int status = 0;
	
	//20060224 Yuan zhijian 改成从数据字典中读Afls的信息
	//CConfCheck AflsConfCheck;
	CConfCheck AflsConfCheck("OUTER");
	
	if (AflsConfCheck.nCheckConf() != 0)
	return -2;
    
	char *strEnv = getenv("PDBHOME");
	


	sAflsConfig = AflsConfCheck.sGetAflsConf();
	
	AFLS_init();	
	//CORBA::ORB_var orb;
	MTLInitialize initialize;
	try
	{
		STAR::Properties_var props = STAR::Properties::getDefaultProperties();
		STAR::ParseArgs(argc, argv, props);
		
		orb = STARCORBA::ORB_init(argc, argv, props);
		
		//status = run(orb, argc, argv);
		status = run(argc, argv);
	}
	catch(const CORBA::Exception& ex)
	{
		cerr << ex << endl;
		
		#ifdef HAS_DEBUG_LEVEL
		//STARTINFO(4,"exit abnormally")
		#endif
		
		status = -1;
	}
	if(!CORBA::is_nil(orb))
	{
		try
		{
    		orb -> destroy();
		}
		catch(const CORBA::Exception& ex)
		{
		    cerr << ex << endl;
		    status = -1;
		}
	}
	
	return status;
}

//added by baixiaobo 20041227
//超时线程管理函数，连接异常断开之后调用
class CloseCallback_impl : public ATF::CloseCallback
{
	TimeOutThreadHandle m_TimeThread;
public:
	CloseCallback_impl(TimeOutThreadHandle ttTimeThread)
	{
		m_TimeThread = ttTimeThread;
	}

    virtual void close_callback(ATF::TransportInfo_ptr transport_info)//连接断开时的回调函数
    {
        ATF::IIOP::TransportInfo_var iiopInfo =
            ATF::IIOP::TransportInfo::_narrow(transport_info);
		char ipport[50]="";
        if(!CORBA::is_nil(iiopInfo))
        {
            ATF::IIOP::InetAddr_var remoteAddr = iiopInfo -> remote_addr();
            CORBA::UShort remotePort = iiopInfo -> remote_port();

            //cout << "Closing connection from: "
            //     << (int)remoteAddr[0] << '.' << (int)remoteAddr[1] << '.'
            //     << (int)remoteAddr[2] << '.' << (int)remoteAddr[3]
            //     << ":" << remotePort << endl;
		   //exit(0);
		    sprintf(ipport,"%d.%d.%d.%d:%d",(int)remoteAddr[0],
						(int)remoteAddr[1],
						(int)remoteAddr[2],
						(int)remoteAddr[3],remotePort);
		    m_TimeThread->delNodebyIp(ipport);
        }
    }
};