def __init__(self, orb=None, ifr=None, argv=None):
"""Supply AT MOST ONE of the three optional arguments."""
self.orb = orb
self.ifr = ifr
if (not self.ifr):
if (not self.orb):
if (argv):
self.orb = CORBA.ORB_init(argv, CORBA.ORB_ID)
else:
self.orb = CORBA.ORB_init(sys.argv, CORBA.ORB_ID)
obj = self.orb.resolve_initial_references("InterfaceRepository")
self.ifr = obj._narrow(CORBA.Repository)
def corbaClient(objectClass, iorDir=None, iorFile=None):
"""
Creates reference to interface object running in the servant processes.
Arguments are:
servantClass - a class implementing the interface
iorDir - path to the directory where ior files are existing
(exact ior file name is concluded from objectClass name)
iorFile - direct path the the ior file with reference to the object"""
logger.info('starting corba client')
if not iorDir and not iorFile:
logger.error("iorDir or iorFile must be specified!")
raise CorbaException("Corba client wrong configuration")
try:
orb = CORBA.ORB_init([], CORBA.ORB_ID)
if not iorFile:
#concluding the name of ior file from interface object class name
iorFile = iorDir + '/%s.ior' % objectClass.__name__
ior = file(iorFile).readline()
obj = orb.string_to_object(ior)
objectReference = obj._narrow(objectClass)
# reference to the remote object is available
return objectReference
except:
traceback.print_exc()
logger.error("Exception" + traceback.format_exc())
raise CorbaException("Corba connection to %s failed!" %
objectClass.__name__)
def __init__(self):
self.simulationitem = []
self.modelitem = []
self.collisionpairitem = []
self.orb = None
self.ns = None
self.sim = None
self.viewer = None
self.modelloader = None
# initialize CORBA
self.orb = CORBA.ORB_init([sys.argv[0],
"-ORBInitRef",
"NameService=corbaloc::localhost:2809/NameService"],
CORBA.ORB_ID)
# find CORBA name server
nsobj = self.orb.resolve_initial_references("NameService")
self.ns = nsobj._narrow(CosNaming.NamingContext)
# find simulator service from the name server
try:
obj = self.ns.resolve([CosNaming.NameComponent("DynamicsSimulator","")])
self.sim = obj._narrow(OpenHRP.DynamicsSimulator)
except CosNaming.NamingContext.NotFound:
pass
def GetSCAFileContents(url):
fileContents = None
scheme, netloc, path, params, query, fragment = urlparse.urlparse(url)
if scheme == "sca":
queryAsDict = dict([x.split("=") for x in query.split("&")])
try:
## RESOLVE ORB
orb = CORBA.ORB_init()
fileSys = orb.string_to_object(queryAsDict["fs"])
except KeyError:
logging.warning("sca URI missing fs query parameter")
except:
logging.warning("Unable to get ORB reference")
else:
if fileSys == None:
logging.warning("Failed to lookup file system")
else:
try:
scaFile = fileSys.open(path, True)
fileSize = scaFile.sizeOf()
fileContents = scaFile.read(fileSize)
scaFile.close()
finally:
pass
return fileContents
def __init__(self, servantClass, data, iorDir, iorName=None):
"""
Constructor of the class with arguments:
servantClass - a class implementing the interface
dataModels - object containing data
iorDir - path to the directory where ior file will be created
iorName - ior filename - otherwise IDL interface name is used
"""
Thread.__init__(self)
self.servantClass = servantClass
self.interfaceName = iorName or servantClass.__name__
self.data = data
logger.info('initializing corba enviroment for %s' %
self.interfaceName)
try:
self.orb = CORBA.ORB_init([], CORBA.ORB_ID)
rootPoa = self.orb.resolve_initial_references("RootPOA")
poaManager = rootPoa._get_the_POAManager()
poaManager.activate()
self.iorFile = iorDir + '/%s.ior' % self.interfaceName
servantInstance = self.servantClass(self.data)
servantObject = servantInstance._this()
#logger.debug("Look at servant %s", servantObject)
self.servantObject = servantObject
self.ior = self.orb.object_to_string(servantObject)
except:
logger.error("Exception" + traceback.format_exc())
raise CorbaException("Corba enviroment initialization failed" +
traceback.format_exc())
def main(argv):
print 'Initialising the ORB...'
# Initialise the ORB.
orb = CORBA.ORB_init(sys.argv, CORBA.ORB_ID)
# Read the server's stringified IOR from a file (this is just a 'cheap and
# cheerful' way of locating the server - in practise the client would use
# the naming or trader services).
stringified_ior = open('server.ref').read()
# Convert the stringified IOR into an active object reference.
server_obj = orb.string_to_object(stringified_ior)
# Narrow the reference, to make it active
server = server_obj._narrow(HelloWorld.Hello)
# Make sure that the server is not a 'nil object reference' (represented
# in Python by the value 'None').
if server is None:
print "Object is not a Hello|World.Hello server"
raise 'Nil object reference!'
# Call the server.
print server.hello_world()
return 0
def __init__(self):
self.m_pInterfaceLogger = None
if trace=="logger":
ok = 0
steps = 40
while steps > 0 and ok == 0:
try:
orb = CORBA.ORB_init(sys.argv, CORBA.ORB_ID)
theObj = orb.resolve_initial_references("NameService")
inc = theObj._narrow(CosNaming.NamingContext)
name = [CosNaming.NameComponent("Logger","")]
obj = inc.resolve(name);
self.m_pInterfaceLogger = obj._narrow(SALOME_Logger.Logger)
if not self.m_pInterfaceLogger is None:
ok = 1
except CosNaming.NamingContext.NotFound, e :
if steps == 1: print "Caught exception: Naming Service can't found Logger"
except (CORBA.TRANSIENT,CORBA.OBJECT_NOT_EXIST,CORBA.COMM_FAILURE):
if steps == 1: print "Caught CORBA::SystemException CommFailure"
except CORBA.SystemException, e:
if steps == 1: print "Caught CORBA::SystemException."
def start_cosname(cosnames, port_number):
p = None
pid = None
start_naming = True
for p in psutil.process_iter():
try:
# find process using port_number
if filter(lambda c: c.local_address[1] == port_number,
p.get_connections()):
print "\033[31m[rtmlaunch]", p.name, "is already started with port", port_number, "\033[0m"
try:
orb = CORBA.ORB_init(sys.argv, CORBA.ORB_ID)
nameserver = orb.resolve_initial_references("NameService")
rootnc = nameserver._narrow(CosNaming.NamingContext)
def findObject(name, kind="", rnc=None):
nc = CosNaming.NameComponent(name, kind)
if not rnc: rnc = rootnc
return rnc.resolve([nc])
cxt = findObject(socket.gethostname(), "host_cxt")
obj = findObject("manager", "mgr", cxt)
start_naming = False
except CosNaming.NamingContext.NotFound, ex:
# this is ok since host_cxt, manager is not bind
start_naming = False
pass
except:
print "\033[31m[rtmlaunch] name server is unreachable so kill process\033[0m"
print "\033[31m[rtmlaunch] kill ", cosnames, " of pid", p.pid, "\033[0m"
p.terminate()
def main(argv):
print 'Starting the Server...'
# Initialise the ORB.
orb = CORBA.ORB_init(sys.argv, CORBA.ORB_ID)
# Initialise the POA.
poa = orb.resolve_initial_references("RootPOA")
# Create an instance of the server and get its reference
# this will also implicitly activate the object in the POA
ei = HelloWorldServer()
eo = ei._this()
# Initialise and activate the POA MAnager
poaManager = poa._get_the_POAManager()
poaManager.activate()
# Write the stringified object reference to a file (this is just a 'cheap
# and cheerful' way of making the object reference available to the
# client!).
f = open('server.ref', 'w')
f.write(orb.object_to_string(eo))
f.flush()
print 'Server created and accepting requests...'
# Start the event loop.
orb.run()
def __init__(self):
self._orb = CORBA.ORB_init()
self._poa = self._orb.resolve_initial_references("RootPOA")
OpenRTM_aist.RTObject_impl.__init__(self, orb=self._orb, poa=self._poa)
self._error = False
self._ref = self._this()
self._eclist = []
def main(argv):
# Initialize the ORB
orb = CORBA.ORB_init(sys.argv, CORBA.ORB_ID)
# Get a reference to the Naming service
ns = orb.resolve_initial_references("NameService")
rootContext = ns._narrow(CosNaming.NamingContext)
if rootContext == None:
print "Failed to narrow the root naming context"
sys.exit(1)
# resolve the Count object in the Naming service
countName = [CosNaming.NameComponent("countName", "")]
counter = rootContext.resolve(countName)
#Set sum to initial value of 0
print "Setting sum to 0"
counter._set_sum(0)
# Calculate Start time
startTime = time()
# Increment 1000 times
print "Incrementing"
for i in range(1000):
counter.increment()
# Calculate stop time print out statistics
stopTime = time()
print "Avg Ping = ", stopTime - startTime, " msecs"
print "Sum = ", counter._get_sum()
def __init__(self, orb=None):
"""
Standard Constructor, with ORB reference.
Initializes the naming service root context
"""
#MESSAGE ( "SALOME_NamingServicePy_i::__init__" )
if orb is None:
orb = CORBA.ORB_init([''], CORBA.ORB_ID)
self._orb = orb
# initialize root context and current context
ok = 0
steps = 240
while steps > 0 and ok == 0:
try:
obj = self._orb.resolve_initial_references("NameService")
self._root_context = obj._narrow(CosNaming.NamingContext)
self._current_context = self._root_context
if self._root_context is None:
#MESSAGE ( "Name Service Reference is invalid" )
#sys.exit(1)
MESSAGE(" Name service not found")
else:
ok = 1
except (CORBA.TRANSIENT, CORBA.OBJECT_NOT_EXIST,
CORBA.COMM_FAILURE):
MESSAGE(" Name service not found")
time.sleep(0.25)
steps = steps - 1
if steps == 0 and self._root_context is None:
MESSAGE("Name Service Reference is invalid")
sys.exit(1)
def main():
orb = CORBA.ORB_init(sys.argv)
poa = orb.resolve_initial_references("RootPOA")
poa._get_the_POAManager().activate()
naming = OpenRTM_aist.CorbaNaming(orb, "localhost")
servant = ComponentObserver_i()
oid = poa.servant_to_id(servant)
provider = poa.id_to_reference(oid)
rtc = naming.resolve("COCTestRTC0.rtc")._narrow(RTC.RTObject)
config = rtc.get_configuration()
properties = [
OpenRTM_aist.NVUtil.newNV("heartbeat.enable", "YES"),
OpenRTM_aist.NVUtil.newNV("heartbeat.interval", "10"),
OpenRTM_aist.NVUtil.newNV("observed_status", "ALL")
]
id = OpenRTM_aist.toTypename(servant)
sprof = SDOPackage.ServiceProfile("test_id", id, properties, provider)
ret = config.add_service_profile(sprof)
flag = True
print("If you exit program, please input 'q'.")
sys.stdin.readline()
ret = config.remove_service_profile("test_id")
print("test program end. ret : ", ret)
return
def main(argv):
# Initialise the ORB.
orb = CORBA.ORB_init(sys.argv, CORBA.ORB_ID)
# Initialise the POA.
poa = orb.resolve_initial_references("RootPOA")
# Create an instance of the server and get its reference
# this will also implicitly activate the object in the POA
ei = CounterServer()
eo = ei._this()
# Initialise and activate the POA Manager
poaManager = poa._get_the_POAManager()
poaManager.activate()
# Get a reference to the Naming service
ns = orb.resolve_initial_references("NameService")
rootContext = ns._narrow(CosNaming.NamingContext)
if rootContext == None:
print "Failed to narrow the root naming context"
sys.exit(1)
# bind the Count object in the Naming service
countName = [CosNaming.NameComponent("countName", "")]
rootContext.rebind(countName, eo)
print 'Server created and accepting requests...'
# Start the event loop.
orb.run()
def setup_component_connection(self):
''' Mostly contains CORBA stuff.
Will create self.PortHandle.
This is an outbound connection.'''
self.CORBA_being_used = False
if True:
self.CORBA_being_used = True
self.orb = CORBA.ORB_init(sys.argv, CORBA.ORB_ID)
obj = self.orb.resolve_initial_references("NameService")
rootContext = obj._narrow(CosNaming.NamingContext)
if rootContext is None:
print "Failed to narrow the root naming context"
sys.exit(1)
name = [CosNaming.NameComponent(self.component_name[0],""),
CosNaming.NameComponent(self.component_name[1],""),
CosNaming.NameComponent(self.component_name[2],"")]
try:
ResourceRef = rootContext.resolve(name)
except:
print "Required resource not found"
sys.exit(1)
#connect to an existing port
ResourceHandle = ResourceRef._narrow(CF.Resource)
PortReference = ResourceHandle.getPort(self.port_name)
if PortReference is None:
print "Failed to get Port reference"
self.PortHandle = PortReference._narrow(standardInterfaces__POA.complexShort)
def __init__(self, clients=defaultClients, url=None, host=None):
"""
Initialize CORBA and create default clients.
:param url: URL in the IOR, corbaloc, corbalocs, and corbanames formats.
For a remote corba server, use
url = "corbaloc:iiop:<host>:<port>/NameService".
If None, url is initialized with param host, or alternatively with _getIIOPurl
:param host: if not None, url is set to = "corbaloc:iiop:" + str(host) + "/NameService"
"""
if host is not None:
url = "corbaloc:iiop:" + str(host) + "/NameService"
elif url is None:
url = _getIIOPurl()
import sys
self.orb = CORBA.ORB_init(sys.argv, CORBA.ORB_ID)
obj = self.orb.string_to_object(url)
self.rootContext = obj._narrow(CosNaming.NamingContext)
if self.rootContext is None:
raise CorbaError('failed to narrow the root context')
for client in clients:
self.makeClient(client)
# In the python interpreter of gepetto-gui, gui.createWindow
# crashes for an obscure reason. This hack makes it work.
try:
from PythonQt.gepetto import MainWindow
# At this point, we are in the python interpreter of gepetto-gui
self.gui.createWindow = lambda x: MainWindow.instance().createView(
x).windowID()
except ImportError:
# At this point, we are NOT in the python interpreter of gepetto-gui
pass
def getObject(self,
ns="localhost",
context="fred",
object="ZoneGenerator"):
try:
# Initialise the ORB
orb = CORBA.ORB_init([
"-ORBnativeCharCodeSet", "UTF-8", "-ORBInitRef",
"NameService=corbaname::" + ns
], CORBA.ORB_ID)
# Obtain a reference to the root naming context
obj = orb.resolve_initial_references("NameService")
rootContext = obj._narrow(CosNaming.NamingContext)
if rootContext is None:
raise ZoneException("Failed to narrow the root naming context")
# Resolve the name "fred.context/ZoneGenerator.Object"
name = [
CosNaming.NameComponent(context, "context"),
CosNaming.NameComponent(object, "Object")
]
obj = rootContext.resolve(name)
# Narrow the object to an fred::ZoneGenerator
zone_orb_object = obj._narrow(ccReg.ZoneGenerator)
if (zone_orb_object is None):
raise ZoneException("Obtained object reference is not "
"ccReg::ZoneGenerator")
return zone_orb_object
except CORBA.TRANSIENT, e:
raise ZoneException("Is nameservice running? (%s)" % e)
def __init__(self):
args = ["-ORBoneCallPerConnection", "0"]
self.orb = CORBA.ORB_init(args, CORBA.ORB_ID)
self.inc = self.orb.resolve_initial_references('NameService')._narrow(
CosNaming.NamingContext)
self.runThreads = threading.Event()
self.threads = []
def initialiseServer(c=None,l=None,block=0,controlName="Control"):
"""c is the control object
l is a threading.Lock object (or soemthing with acquire and release methods
block is whether to block here, or return.
controlName is the darc prefix+Control.
"""
# Initialise the ORB and find the root POA
orb = CORBA.ORB_init(sys.argv, CORBA.ORB_ID)
poa = orb.resolve_initial_references("RootPOA")
# Create an instance of ControlServer and a Control object reference
ei = ControlServer(c,l)
eo = ei._this()
# Obtain a reference to the root naming context
obj = orb.resolve_initial_references("NameService")
try:
rootContext = obj._narrow(CosNaming.NamingContext)
except:
print "Unable to connect the nameservice"
return None
if rootContext is None:
print "Failed to narrow the root naming context"
sys.exit(1)
# Bind a context named "rtcServer.my_context" to the root context
name = [CosNaming.NameComponent("darc", "control")]
try:
rtcServerContext = rootContext.bind_new_context(name)
print "New rtcServer context bound"
except CosNaming.NamingContext.AlreadyBound, ex:
print "RtcControl context already exists"
obj = rootContext.resolve(name)
rtcServerContext = obj._narrow(CosNaming.NamingContext)
if rtcServerContext is None:
print "rtcServer.mycontext exists but is not a NamingContext"
sys.exit(1)
def GetObject(module_name, obj_name, context_name , poa_path = None):
"""
def GetObject(module_name, obj_name, context_name , poa_path = None):
Arguments:
- `module_name`:
- `context_name`: list of names to the object [("name1","context1"),("name2","context2"),...,("name","object")]
- `obj_name`: typically "module.interface as" defined in idl file
- `poa_path`: path to omniidl generated interface
Example:
loscli=corba_util.GetObject("robotviewer_corba","robotviewer_corba.Localstepper",[('robotviewer_corba','context'),('localstepper','object')])
"""
if poa_path:
sys.path = [poa_path] + sys.path
exec("import %s"%module_name)
# Initialise the ORB
orb = CORBA.ORB_init(sys.argv, CORBA.ORB_ID)
# Obtain a reference to the root naming context
obj = orb.resolve_initial_references("NameService")
rootContext = obj._narrow(CosNaming.NamingContext)
if context_name:
try:
name = [ CosNaming.NameComponent(component[0],component[1]) for component in context_name]
except Exception,e:
raise Exception("Failed to construct name %s"%str(context_name))
else:
obj = rootContext.resolve(name)
def unbind(controlName="Control"):
# Initialise the ORB and find the root POA
orb = CORBA.ORB_init(sys.argv, CORBA.ORB_ID)
poa = orb.resolve_initial_references("RootPOA")
obj = orb.resolve_initial_references("NameService")
try:
rootContext = obj._narrow(CosNaming.NamingContext)
except:
print "Cannot unbind: Unable to connect the nameservice"
return None
if rootContext is None:
print "Cannot unbind: Failed to narrow the root naming context"
return None
# Bind a context named "darc.server" to the root context
name = [CosNaming.NameComponent("darc", "server")]
try:
rtcServerContext = rootContext.bind_new_context(name)
print "New darc context bound"
except CosNaming.NamingContext.AlreadyBound, ex:
print "RtcControl context already exists"
obj = rootContext.resolve(name)
rtcServerContext = obj._narrow(CosNaming.NamingContext)
if rtcServerContext is None:
print "darc.server exists but is not a NamingContext"
return None
def setUp(self):
self.setContext()
if self.srcData:
self.seq = self.srcData
else:
self.seq = range(50)
if self.ptype == 'Int8':
self.seq = numpy.array(self.seq, numpy.int8).tostring()
if self.ptype == 'UInt8':
self.seq = numpy.array(self.seq, numpy.uint8).tostring()
self.orb = CORBA.ORB_init()
self.rootPOA = self.orb.resolve_initial_references("RootPOA")
self.logger = logging.getLogger(self.ptype[0])
self.logger.setLevel(logging.NOTSET)
#self.logger.setLevel(logging.INFO)
self.ip1 = self.bio_in_module("sink_1")
self.ip1_oid = self.rootPOA.activate_object(self.ip1)
self.ip2 = self.bio_in_module("sink_2")
self.ip2_oid = self.rootPOA.activate_object(self.ip2)
self.ip3 = self.bio_in_module("sink_3")
self.ip3_oid = self.rootPOA.activate_object(self.ip3)
self.ip4 = self.bio_in_module("sink_4")
self.ip4_oid = self.rootPOA.activate_object(self.ip4)
self.port = self.bio_out_module("multiout_source")
self.port_oid = self.rootPOA.activate_object(self.port)
self.setup_connection_table()
def initCORBA():
global rootnc, orb, nshost, nsport
# from omniorb's document
# When CORBA::ORB_init() is called, the value for each configuration parameter is searched for in the following order:
# Command line arguments
# Environment variables
# so init_CORBA will follow this order
# first check command line argument
try:
n = sys.argv.index('-ORBInitRef')
(nshost, nsport) = re.match(
'NameService=corbaloc:iiop:(\w+):(\d+)/NameService',
sys.argv[n + 1]).group(1, 2)
except:
if not nshost: nshost = socket.gethostname()
if not nsport: nsport = 15005
print "configuration ORB with ", nshost, ":", nsport
os.environ[
'ORBInitRef'] = 'NameService=corbaloc:iiop:{0}:{1}/NameService'.format(
nshost, nsport)
try:
orb = CORBA.ORB_init(sys.argv, CORBA.ORB_ID)
nameserver = orb.resolve_initial_references("NameService")
rootnc = nameserver._narrow(CosNaming.NamingContext)
except omniORB.CORBA.ORB.InvalidName, e:
sys.exit('[ERROR] Invalide Name (hostname={0}).\n'.format(nshost) +
'Make sure the hostname is correct.\n' + str(e))
def _finish_init_(self):
self._isStreaming = False
self._greenletPeriodSec = 0.25
if ('Uses' == self._obj._direction):
datatype = self._obj._using.filename
else:
datatype = self._obj._interface.filename
if ('bio_dataShort' == datatype):
self._helper = StreamHelper_Short(self)
elif('bio_dataUshort' == datatype):
self._helper = StreamHelper_Ushort(self)
elif('bio_dataOctet' == datatype):
self._helper = StreamHelper_Octet(self)
elif('bio_dataLong' == datatype):
self._helper = StreamHelper_Long(self)
elif('bio_dataUlong' == datatype):
self._helper = StreamHelper_Ulong(self)
elif('bio_dataFloat' == datatype):
self._helper = StreamHelper_Float(self)
elif('bio_dataDouble' == datatype):
self._helper = StreamHelper_Double(self)
else:
# FIXME: Need more handlers...
raise Port_BULKIO("No stream handler for this type: " + datatype)
orb = CORBA.ORB_init()
self._poa = orb.resolve_initial_references("RootPOA")
self._poaManager = self._poa._get_the_POAManager()
self._poaManager.activate()
self._poa.activate_object(self._helper)
self._connectionID = self.getID + "_stream"
def __init__(self, url=None):
"""
Initialize CORBA and create default clients.
:param url: URL in the IOR, corbaloc, corbalocs, and corbanames formats.
For a remote corba server, use
url = "corbaloc:iiop:<host>:<port>/NameService"
"""
import sys
self.orb = CORBA.ORB_init(sys.argv, CORBA.ORB_ID)
if url is None:
obj = self.orb.string_to_object(_getIIOPurl())
else:
obj = self.orb.string_to_object(url)
self.rootContext = obj._narrow(CosNaming.NamingContext)
if self.rootContext is None:
raise CorbaError('failed to narrow the root context')
# client of Graph interface
name = [
CosNaming.NameComponent("hpp", "corbaserver"),
CosNaming.NameComponent("manipulation", "graph")
]
try:
obj = self.rootContext.resolve(name)
except CosNaming.NamingContext.NotFound, ex:
raise CorbaError('failed to find manipulation service.')
def scan(location=None):
orb = _CORBA.ORB_init(_sys.argv, _CORBA.ORB_ID)
if location:
try:
obj = orb.string_to_object('corbaname::' + location)
except _CORBA.BAD_INV_ORDER:
orb.destroy()
orb = _CORBA.ORB_init(_sys.argv, _CORBA.ORB_ID)
obj = orb.string_to_object('corbaname::' + location)
else:
try:
obj = orb.resolve_initial_references("NameService")
except _CORBA.BAD_INV_ORDER:
orb.destroy()
orb = _CORBA.ORB_init(_sys.argv, _CORBA.ORB_ID)
obj = orb.resolve_initial_references("NameService")
try:
rootContext = obj._narrow(_CosNaming.NamingContext)
except:
raise RuntimeError('NameService not found')
base_list = rootContext.list(100)
domainsFound = []
for entry in base_list[0]:
if entry.binding_type != _CosNaming.ncontext:
continue
ctx = rootContext.resolve(entry.binding_name)
objs = ctx.list(100)[0]
foundDomain = False
for obj in objs:
if obj.binding_type == _CosNaming.nobject:
if obj.binding_name[0].id == entry.binding_name[0].id:
tmpobj = ctx.resolve(obj.binding_name)
tmpDomainManager = tmpobj._narrow(_CF.DomainManager)
# Make sure Domain is alive
try:
fileManager = tmpDomainManager._get_fileMgr()
except:
continue
if tmpDomainManager:
foundDomain = True
break
if foundDomain:
domainsFound.append(entry.binding_name[0].id)
return domainsFound
def setAdditionalParameters(self, softwareProfile, application_registrar_ior, nic):
super(Component,self).setAdditionalParameters(softwareProfile, application_registrar_ior, nic)
orb = CORBA.ORB_init()
obj = orb.string_to_object(application_registrar_ior)
self._net = containers.NetworkContainer(nic)
applicationRegistrar = obj._narrow(CF.ApplicationRegistrar)
if applicationRegistrar != None:
self._app = containers.ApplicationContainer(applicationRegistrar._get_app())
def orbCreator():
"""
A method to pass to callOmniorbpyWithTimeout.
"""
orb = CORBA.ORB_init()
queue.put(orb)
def setUp(self):
self._orb = CORBA.ORB_init()
self._poa = self._orb.resolve_initial_references("RootPOA")
self._poa._get_the_POAManager().activate()
self._com = CorbaObjectManager(self._orb, self._poa)
self._obj = test_comp()
def setUp(self):
self._domBooter, self._domMgr = self.launchDomainManager()
# create listener interface
orb = CORBA.ORB_init()
self.chanMgr = ChannelManager(orb)
self._app=None
# Force creation
self.channel1 = self.chanMgr.createEventChannel("TestChan", force=True)
