def setup(self):
"""Sets up ICE"""
if self.config.mumble:
slicefile = self.config.mumble.slice
icesecret = self.config.mumble.secret
else:
slicefile = self.config.mumble_slice
icesecret = self.config.mumble_secret
Ice.loadSlice('', ['-I' + Ice.getSliceDir(), slicefile ] )
prop = Ice.createProperties([])
prop.setProperty('Ice.Default.EncodingVersion', '1.0')
prop.setProperty("Ice.ImplicitContext", "Shared")
prop.setProperty("Ice.MessageSizeMax", "65535")
idd = Ice.InitializationData()
idd.properties = prop
global ice
ice = Ice.initialize(idd)
ice.getImplicitContext().put("secret", icesecret.encode("utf-8"))
global Murmur
import Murmur
## Set up threaded checker
print "set up and now starting timer thread"
t = threading.Timer(20.0, mumble_auto_loop, [self])
t.start()
def run(self, args):
properties = self.createTestProperties(args)
#
# This test kills connections, so we don't want warnings.
#
properties.setProperty("Ice.Warn.Connections", "0")
#
# Limit the recv buffer size, this test relies on the socket
# send() blocking after sending a given amount of data.
#
properties.setProperty("Ice.TCP.RcvSize", "50000")
with self.initialize(properties=properties) as communicator:
communicator.getProperties().setProperty("TestAdapter.Endpoints", self.getTestEndpoint())
communicator.getProperties().setProperty("ControllerAdapter.Endpoints", self.getTestEndpoint(num=1))
communicator.getProperties().setProperty("ControllerAdapter.ThreadPool.Size", "1")
adapter = communicator.createObjectAdapter("TestAdapter")
adapter2 = communicator.createObjectAdapter("ControllerAdapter")
testController = TestI.TestIntfControllerI(adapter)
adapter.add(TestI.TestIntfI(), Ice.stringToIdentity("test"))
adapter.add(TestI.TestIntfII(), Ice.stringToIdentity("test2"))
adapter.activate()
adapter2.add(testController, Ice.stringToIdentity("testController"))
adapter2.activate()
communicator.waitForShutdown()
def createCommunicator(self, props, current=None):
#
# Prepare the property set using the given properties.
#
init = Ice.InitializationData()
init.properties = Ice.createProperties()
for k, v in props.items():
init.properties.setProperty(k, v)
#
# Initialize a new communicator.
#
communicator = Ice.initialize(init)
#
# Install a custom admin facet.
#
communicator.addAdminFacet(TestFacetI(), "TestFacet")
#
# The RemoteCommunicator servant also implements PropertiesAdminUpdateCallback.
# Set the callback on the admin facet.
#
servant = RemoteCommunicatorI(communicator)
admin = communicator.findAdminFacet("Properties")
if admin != None:
admin.addUpdateCallback(servant)
proxy = current.adapter.addWithUUID(servant)
return Test.RemoteCommunicatorPrx.uncheckedCast(proxy)
def __init__(self,slice = "Murmur.ice",proxy = "Meta:tcp -h 127.0.0.1 -p 6502"):
Ice.loadSlice(slice)
import Murmur
ice = Ice.initialize()
prx = ice.stringToProxy(proxy)
self.murmur = Murmur.MetaPrx.checkedCast(prx)
self.Murmur = Murmur
def connect():
# setup
iceslice = os.environ.get('iceslice', '/usr/share/slice/Murmur.ice')
iceincpath = os.environ.get('iceincpath', '/usr/share/Ice/slice')
port = int(os.environ.get('port', '6502'))
secret = os.environ.get('secret', '')
messagemax = os.environ.get('messagemax', '65535')
# open
import Ice, sys
Ice.loadSlice('--all -I%s %s' % (iceincpath, iceslice))
props = Ice.createProperties([])
props.setProperty('Ice.MessageSizeMax', str(messagemax))
props.setProperty('Ice.ImplicitContext', 'Shared')
id = Ice.InitializationData()
id.properties = props
ice = Ice.initialize(id)
ice.getImplicitContext().put('secret', secret)
# init
import Murmur
meta = Murmur.MetaPrx.checkedCast(ice.stringToProxy('Meta:tcp -h 127.0.0.1 -p %s' % (port)))
try:
server = meta.getServer(1)
except Murmur.InvalidSecretException:
print 'Incorrect secret!'
ice.shutdown()
sys.exit(1)
return server
def load(target):
"""
uses __import__ followed by Ice.updateModules if available.
"""
__import__(target)
Ice.updateModules()
def run(self,req):
try:
props = Ice.createProperties(sys.argv)
props.setProperty("Ice.MessageSizeMax", "20480")
id = Ice.InitializationData()
id.properties = props
ic = Ice.initialize(id)
twoway = ESUN.EASPrx.checkedCast(ic.stringToProxy(self.connect))
if not twoway:
print ": invalid proxy"
return 1
starttime=time.time()
ID = self.ID
ret = twoway.invoke(ID, req, req)
usetime = time.time()-starttime
mark = True
sret = json.dumps(ret,ensure_ascii=False).decode('gbk').encode('utf-8')
ssret = json.loads(sret)
#print sret
return mark,ssret
except Ice.Exception, ex:
mark = False
#print ex
return mark,ex
def run(self, args):
properties = self.createTestProperties(args)
properties.setProperty("Ice.Warn.Dispatch", "0")
properties.setProperty("Ice.Warn.Connections", "0")
properties.setProperty("Ice.MessageSizeMax", "10")
with self.initialize(properties=properties) as communicator:
communicator.getProperties().setProperty("TestAdapter.Endpoints", self.getTestEndpoint(num=0))
communicator.getProperties().setProperty("Ice.MessageSizeMax", "10")
communicator.getProperties().setProperty("TestAdapter2.Endpoints", self.getTestEndpoint(num=1))
communicator.getProperties().setProperty("TestAdapter2.MessageSizeMax", "0")
communicator.getProperties().setProperty("TestAdapter3.Endpoints", self.getTestEndpoint(num=2))
communicator.getProperties().setProperty("TestAdapter3.MessageSizeMax", "1")
adapter = communicator.createObjectAdapter("TestAdapter")
adapter2 = communicator.createObjectAdapter("TestAdapter2")
adapter3 = communicator.createObjectAdapter("TestAdapter3")
object = TestI.ThrowerI()
adapter.add(object, Ice.stringToIdentity("thrower"))
adapter2.add(object, Ice.stringToIdentity("thrower"))
adapter3.add(object, Ice.stringToIdentity("thrower"))
adapter.activate()
adapter2.activate()
adapter3.activate()
communicator.waitForShutdown()
def startServer(self, current=None):
#
# Simulate a server: create a new communicator and object
# adapter. The object adapter is started on a system allocated
# port. The configuration used here contains the Ice.Locator
# configuration variable. The new object adapter will register
# its endpoints with the locator and create references containing
# the adapter id instead of the endpoints.
#
serverCommunicator = Ice.initialize(data=initData)
self._communicators.append(serverCommunicator)
adapter = serverCommunicator.createObjectAdapter("TestAdapter")
adapter2 = serverCommunicator.createObjectAdapter("TestAdapter2")
locator = serverCommunicator.stringToProxy("locator:default -p 12010")
adapter.setLocator(Ice.LocatorPrx.uncheckedCast(locator))
adapter2.setLocator(Ice.LocatorPrx.uncheckedCast(locator))
object = TestI(adapter, adapter2, self._registry)
self._registry.addObject(adapter.add(object, Ice.stringToIdentity("test")))
self._registry.addObject(adapter.add(object, Ice.stringToIdentity("test2")))
adapter.add(object, Ice.stringToIdentity("test3"))
adapter.activate()
adapter2.activate()
def run(args, communicator, initData):
#
# Register the server manager. The server manager creates a new
# 'server' (a server isn't a different process, it's just a new
# communicator and object adapter).
#
properties = communicator.getProperties()
properties.setProperty("Ice.ThreadPool.Server.Size", "2")
properties.setProperty("ServerManager.Endpoints", "default -p 12010:udp")
adapter = communicator.createObjectAdapter("ServerManager")
#
# We also register a sample server locator which implements the
# locator interface, this locator is used by the clients and the
# 'servers' created with the server manager interface.
#
registry = ServerLocatorRegistry()
registry.addObject(adapter.createProxy(Ice.stringToIdentity("ServerManager")))
object = ServerManagerI(registry, initData)
adapter.add(object, Ice.stringToIdentity("ServerManager"))
registryPrx = Ice.LocatorRegistryPrx.uncheckedCast(adapter.add(registry, Ice.stringToIdentity("registry")))
locator = ServerLocator(registry, registryPrx)
adapter.add(locator, Ice.stringToIdentity("locator"))
adapter.activate()
communicator.waitForShutdown()
return True
def setup(bot):
global _server,_meta
bot.config.module_config('mumble_host',[None,'Host for mumble server'])
bot.config.module_config('mumble_port',[0,'Port for mumble server'])
bot.config.module_config('mumble_secret',[None,'Secret for mumble server'])
if not bot.config.mumble_host or not bot.config.mumble_port:
return
prxstr = "s/1 -t:tcp -h %s -p %d -t 1000" % (bot.config.mumble_host,bot.config.mumble_port)
meta_prxstr = "Meta:tcp -h %s -p %d -t 1000" % (bot.config.mumble_host,bot.config.mumble_port)
props = Ice.createProperties()
props.setProperty("Ice.ImplicitContext", "Shared")
idata = Ice.InitializationData()
idata.properties = props
ice = Ice.initialize(idata)
prx = ice.stringToProxy(str(prxstr))
prx_meta = ice.stringToProxy(str(meta_prxstr))
try:
slice = IcePy.Operation('getSlice', Ice.OperationMode.Idempotent, Ice.OperationMode.Idempotent, True, (), (), (), IcePy._t_string, ()).invoke(prx_meta, ((), None))
(dynslicefiledesc, dynslicefilepath) = tempfile.mkstemp(suffix = '.ice')
dynslicefile = os.fdopen(dynslicefiledesc, 'w')
dynslicefile.write(slice)
dynslicefile.flush()
Ice.loadSlice('', ['-I' + Ice.getSliceDir(), dynslicefilepath])
dynslicefile.close()
os.remove(dynslicefilepath)
import Murmur
if bot.config.mumble_secret:
ice.getImplicitContext().put("secret", str(bot.config.mumble_secret))
_server = Murmur.ServerPrx.checkedCast(prx)
_meta = Murmur.MetaPrx.checkedCast(prx_meta)
bot.mumbleannounce = lambda msg: _server.sendMessageChannel(0,True,msg)
except Exception, e:
print str(e)
def connect():
global status
global ic
global impl
print "Connecting.."
status = 0
try:
# Reading configuration info
configPath = os.environ.get("INTROOT")
#print configPath
#configPath = configPath + "/config/API-client.config"
configPath = "./API-client.config"
initData = Ice.InitializationData()
initData.properties = Ice.createProperties()
initData.properties.load(configPath)
ic = Ice.initialize(sys.argv, initData)
# Create proxy
properties = ic.getProperties();
proxyProperty = "APIAdapter.Proxy"
proxy = properties.getProperty(proxyProperty);
print "proxy=" + proxy
obj = ic.stringToProxy(proxy);
impl = ARIAPI.APIPrx.checkedCast(obj)
print "Connected to ARI API Server"
if not impl:
raise RuntimeError("Invalid proxy")
except:
traceback.print_exc()
status = 1
sys.exit(status)
def connect(self, host = "127.0.0.1", port = 6502, secret = None, prxstr = None):
if self.__ice:
self.__log.warning("Connection attempt with tainted object, disconnect first")
return True
if not prxstr:
prxstr = "Meta:tcp -h %s -p %d -t 1000" % (host, port)
self.__log.info("Connecting to proxy: %s", prxstr)
props = Ice.createProperties(sys.argv)
props.setProperty("Ice.ImplicitContext", "Shared")
idata = Ice.InitializationData()
idata.properties = props
ice = Ice.initialize(idata)
self.__ice = ice
if secret:
ice.getImplicitContext().put("secret", secret)
prx = ice.stringToProxy(prxstr)
self.__prx = prx
self.__log.debug("Retrieve version from target host")
try:
version = IcePy.Operation('getVersion', Ice.OperationMode.Idempotent, Ice.OperationMode.Idempotent, True, (), (), (((), IcePy._t_int), ((), IcePy._t_int), ((), IcePy._t_int), ((), IcePy._t_string)), None, ()).invoke(prx, ((), None))
major, minor, patch, text = version
self.__log.debug("Server version is %s", str(version))
except Exception, e:
self.__log.critical("Failed to retrieve version from target host")
self.__log.exception(e)
return False
def _setup_communicator(self, host, port):
init = Ice.InitializationData()
init.properties = Ice.createProperties()
loc = "IceGrid/Locator:tcp -h "+ host + " -p " + str(port)
init.properties.setProperty('Ice.Default.Locator', loc)
init.properties.setProperty('Ice.IPv6', '0')
return Ice.initialize(init)
def init_oce_communicator():
""" default client communicator """
initData = Ice.InitializationData()
initData.properties = Ice.createProperties(None, initData.properties)
kv = [
("Ice.Override.ConnectTimeout", "300"),
# ("IceGrid.InstanceName", "XiaoNei"),
("Ice.ThreadPool.Client.StackSize", "65535"),
# ("Ice.ThreadPool.Server.StackSize", "65535"),
("Ice.MessageSizeMax", "20480"),
# ("Ice.Trace.Network", "5"),
# ("Ice.Trace.Location", "5"),
# ("Ice.Trace.Locator", "5"),
# ("Ice.Trace.Protocol", "5"),
# ("Ice.Trace.GC", "5"),
# TODO: ("Ice.Default.Host", ''),
(
"Ice.Default.Locator",
"XiaoNei/Locator:default -h XiaoNeiRegistry -p 12000:default -h XiaoNeiRegistryReplica1 -p 12001:default -h XiaoNeiRegistryReplica2 -p 12002",
),
]
for k, v in kv:
initData.properties.setProperty(k, v)
oce_ic = Ice.initialize(None, initData)
return oce_ic
def connect(self):
#client connection routine to server
#global statusIC
#global ic
#global controller
self.statusIC = 0
try:
# Reading configuration info
#configPath = os.environ.get("SWROOT")
#configPath = configPath + "/config/LCU-config"
initData = Ice.InitializationData()
initData.properties = Ice.createProperties()
#initData.properties.load('IceConfig')
self.ic = Ice.initialize(sys.argv, initData)
# Create proxy
#base = ic.stringToProxy("SRTController:default -h 192.168.0.6 -p 10000")
base = self.ic.stringToProxy(self.IP_string)
self.controller = SRTControl.telescopePrx.checkedCast(base)
self.controller.begin_message("connected to controller", self.genericCB, self.failureCB);
self.controller.begin_SRTGetName(self.getNameCB, self.failureCB)
print time.strftime('%Y-%m-%d %H:%M:%S', time.localtime())+" " +"Connecting to SRTController"
self.controller.begin_serverState(self.serverCB, self.failureCB);
Status_Thread = threading.Thread(target = self.status_thread, name='status')
print "starting status thread"
Status_Thread.start()
self.disableSpectrum()
if not self.controller:
raise RuntimeError("Invalid proxy")
except:
traceback.print_exc()
self.statusIC = 1
sys.exit(self.statusIC)
return
def __init__(self, slicePath, sliceOpts=''): self.slicePath = slicePath self.sliceOpts = sliceOpts self.RoboComps = dict() loadCommand = self.sliceOpts+' '+self.slicePath print 'Loading SLICE file: "'+loadCommand+'"' print '1' modulesA = [ module for module in sys.modules ] print '2' try: print '3', loadCommand Ice.loadSlice(loadCommand) print '4' modulesB = [ module for module in sys.modules ] newModules = [ module for module in modulesB if not module in modulesA ] for newModule in newModules: print ' New module: ' + newModule self.RoboComps[str(newModule)] = __import__(newModule) try: global global_ic global_ic = Ice.initialize(sys.argv) except: print ' global_ic' except: traceback.print_exc(file=sys.stdout) print 'Error loading ' + loadCommand + '.' finally: print 'Done loading ' + self.slicePath + '.'
def __init__(self):
try:
Ice.loadSlice(self.settings['ice_file'])
import Murmur
self.mur = Murmur
except:
pass
def connect(self, IP):
""" Connects to Observing Mode server
IP: is the Observing Mode server IP and port
example: connect(‘192.168.3.100 -p 10015’)
"""
#clcdient connection routine to server
#global statusIC
#global ic
#global controller
statusIC = 0
try:
# Reading configuration info
#configPath = os.environ.get("SWROOT")
#configPath = configPath + "/config/LCU-config"
initData = Ice.InitializationData()
initData.properties = Ice.createProperties()
#initData.properties.load('IceConfig')
self.ic = Ice.initialize(sys.argv, initData)
# Create proxy
#base = ic.stringToProxy("SRTController:default -h 192.168.0.6 -p 10000")
IP_string = "ARIAPI:default -h " + IP
base = self.ic.stringToProxy(IP_string)
self.controller = ARIAPI.APIPrx.checkedCast(base)
self.controller.begin_testConn("connected to observing mode server", self.connectCB, self.failureCB);
print "Connecting to ARIAPI"
#self.controller.begin_serverState(self.serverCB, self.failureCB);
if not self.controller:
raise RuntimeError("Invalid proxy")
except:
traceback.print_exc()
self.statusIC = 1
sys.exit(statusIC)
return
def run(self, argv):
properties = self.communicator().getProperties()
path = properties.getProperty("Breeze.Path")
filename = properties.getProperty("Breeze.FileName")
extension = properties.getProperty("Breeze.FileExtension")
theLogger = logger.Logger(path, filename, extension)
publish = logger.Publish(theLogger)
lastlog = logger.Lastlog(theLogger)
adapter = self.communicator().createObjectAdapter("BreezeAdapter")
publishId = Ice.stringToIdentity("Publish")
lastlogId = Ice.stringToIdentity("Lastlog")
adapter.add(publish, publishId)
adapter.add(lastlog, lastlogId)
publishPrx = adapter.createDirectProxy(publishId)
lastlogPrx = adapter.createDirectProxy(lastlogId)
adapter.activate()
text = "server started\n%s\n%s" % (publishPrx.ice_toString(), lastlogPrx.ice_toString())
publish.log(text)
self.communicator().waitForShutdown()
publish.log("server shutting down")
def __hash__(self):
_h = 0
_h = 5 * _h + Ice.getHash(self.interest)
_h = 5 * _h + Ice.getHash(self.moneyProvided)
_h = 5 * _h + Ice.getHash(self.moneyEarned)
_h = 5 * _h + Ice.getHash(self.monthsLeft)
return _h % 0x7fffffff
def __hash__(self):
_h = 0
_h = 5 * _h + Ice.getHash(self.firstName)
_h = 5 * _h + Ice.getHash(self.lastName)
_h = 5 * _h + Ice.getHash(self.nationality)
_h = 5 * _h + Ice.getHash(self.nationalIDNumber)
return _h % 0x7fffffff
def connect(self):
# client connection routine to server
global status
global ic
global controller
status = 0
try:
# Reading configuration info
# configPath = os.environ.get("SWROOT")
# configPath = configPath + "/config/LCU-config"
initData = Ice.InitializationData()
initData.properties = Ice.createProperties()
initData.properties.load("IceConfig")
ic = Ice.initialize(sys.argv, initData)
# Create proxy
# base = ic.stringToProxy("SHController:default -h 192.168.0.6 -p 10002")
base = ic.stringToProxy(self.IP_string)
controller = SHControl.SignalHoundPrx.checkedCast(base)
controller.begin_message("connected to controller", self.genericCB, self.failureCB)
print "Connecting to SHController"
# controller.begin_serverState(self.serverCB, self.failureCB);
if not controller:
raise RuntimeError("Invalid proxy")
except:
traceback.print_exc()
status = 1
sys.exit(status)
return
def __hash__(self):
_h = 0
_h = 5 * _h + Ice.getHash(self.interest)
_h = 5 * _h + Ice.getHash(self.paid)
_h = 5 * _h + Ice.getHash(self.toPay)
_h = 5 * _h + Ice.getHash(self.monthsLeft)
return _h % 0x7fffffff
def load_slice_files(icedir=os.path.normpath("../../Ice")):
"""
Load slice files. This can be done dynamically in Python. Note that this requires
the ICEROOT environment variable to be (correctly) set.
"""
import Ice;
# The following line throws an exception if ICEROOT is not an environment variable:
iceroot = os.environ["ICEROOT"];
if not iceroot:
print "WARNING: ICEROOT is not defined! It's required to load slice files dynamically!";
def create_load_string(target_file):
"""
Create a string which loads Slice definition files.
@param target_file File to load.
@return Formatted string.
"""
return "-I\"%s/slice\" -I\"%s\" --all %s/%s" % (
iceroot, icedir, icedir, target_file);
ice_files = [ file for file in os.listdir(icedir) if file.endswith(".ice") ];
for file in ice_files:
debug_reporter("Loading %s..." % file);
Ice.loadSlice(create_load_string(file));
def run(self, args):
properties = self.createTestProperties(args)
properties.setProperty("Ice.Warn.Connections", "0")
#
# The client sends large messages to cause the transport
# buffers to fill up.
#
properties.setProperty("Ice.MessageSizeMax", "10000")
#
# Limit the recv buffer size, this test relies on the socket
# send() blocking after sending a given amount of data.
#
properties.setProperty("Ice.TCP.RcvSize", "50000")
with self.initialize(properties=properties) as communicator:
communicator.getProperties().setProperty("TestAdapter.Endpoints", self.getTestEndpoint())
communicator.getProperties().setProperty("ControllerAdapter.Endpoints", self.getTestEndpoint(num=1))
communicator.getProperties().setProperty("ControllerAdapter.ThreadPool.Size", "1")
adapter = communicator.createObjectAdapter("TestAdapter")
adapter.add(TimeoutI(), Ice.stringToIdentity("timeout"))
adapter.activate()
controllerAdapter = communicator.createObjectAdapter("ControllerAdapter")
controllerAdapter.add(ControllerI(adapter), Ice.stringToIdentity("controller"))
controllerAdapter.activate()
communicator.waitForShutdown()
def run(self, args):
initData = Ice.InitializationData()
initData.properties = self.createTestProperties(args)
with self.initialize(initData=initData) as communicator:
#
# Register the server manager. The server manager creates a new
# 'server' (a server isn't a different process, it's just a new
# communicator and object adapter).
#
communicator.getProperties().setProperty("Ice.ThreadPool.Server.Size", "2")
communicator.getProperties().setProperty("ServerManager.Endpoints", self.getTestEndpoint())
adapter = communicator.createObjectAdapter("ServerManager")
#
# We also register a sample server locator which implements the
# locator interface, this locator is used by the clients and the
# 'servers' created with the server manager interface.
#
registry = ServerLocatorRegistry()
registry.addObject(adapter.createProxy(Ice.stringToIdentity("ServerManager")))
adapter.add(ServerManagerI(registry, initData, self), Ice.stringToIdentity("ServerManager"))
registryPrx = Ice.LocatorRegistryPrx.uncheckedCast(adapter.add(registry, Ice.stringToIdentity("registry")))
locator = ServerLocator(registry, registryPrx)
adapter.add(locator, Ice.stringToIdentity("locator"))
adapter.activate()
communicator.waitForShutdown()
def connect(self, IP):
#client connection routine to server
#global statusIC
#global ic
#global controller
statusIC = 0
try:
# Reading configuration info
#configPath = os.environ.get("SWROOT")
#configPath = configPath + "/config/LCU-config"
initData = Ice.InitializationData()
initData.properties = Ice.createProperties()
#initData.properties.load('IceConfig')
ic = Ice.initialize(sys.argv, initData)
# Create proxy
#base = ic.stringToProxy("SRTController:default -h 192.168.0.6 -p 10000")
IP_string = "SRTClient:default -h " + IP
base = ic.stringToProxy(IP_string)
controller = SRTClient.ClientPrx.checkedCast(base)
controller.begin_message("connected to client", self.genericCB, self.failureCB);
print "Connecting to SRTClient"
#self.controller.begin_serverState(self.serverCB, self.failureCB);
if not controller:
raise RuntimeError("Invalid proxy")
except:
traceback.print_exc()
self.statusIC = 1
sys.exit(statusIC)
return controller
def run(self, args):
with self.initialize(args=args) as communicator:
communicator.getProperties().setProperty("TestAdapter.Endpoints", self.getTestEndpoint())
adapter = communicator.createObjectAdapter("TestAdapter")
adapter.add(CustomI(), Ice.stringToIdentity("test"))
if hasNumPy:
adapter.add(NumPyCustomI(), Ice.stringToIdentity("test.numpy"))
adapter.activate()
communicator.waitForShutdown()
def run(sef, args):
sys.stdout.write("testing load properties from UTF-8 path... ")
sys.stdout.flush()
properties = Ice.createProperties()
properties.load("./config/中国_client.config")
test(properties.getProperty("Ice.Trace.Network") == "1")
test(properties.getProperty("Ice.Trace.Protocol") == "1")
test(properties.getProperty("Config.Path") == "./config/中国_client.config")
test(properties.getProperty("Ice.ProgramName") == "PropertiesClient")
print("ok")
sys.stdout.write("testing load properties from UTF-8 path using Ice::Application... ")
sys.stdout.flush()
app = App()
app.main(args, "./config/中国_client.config")
print("ok")
sys.stdout.write("testing using Ice.Config with multiple config files... ")
sys.stdout.flush()
properties = Ice.createProperties(["--Ice.Config=config/config.1, config/config.2, config/config.3"])
test(properties.getProperty("Config1") == "Config1")
test(properties.getProperty("Config2") == "Config2")
test(properties.getProperty("Config3") == "Config3")
print("ok")
sys.stdout.write("testing configuration file escapes... ")
sys.stdout.flush()
properties = Ice.createProperties(["--Ice.Config=config/escapes.cfg"])
props = {
"Foo\tBar": "3",
"Foo\\tBar": "4",
"Escape\\ Space": "2",
"Prop1": "1",
"Prop2": "2",
"Prop3": "3",
"My Prop1": "1",
"My Prop2": "2",
"My.Prop1": "a property",
"My.Prop2": "a property",
"My.Prop3": " a property ",
"My.Prop4": " a property ",
"My.Prop5": "a \\ property",
"foo=bar": "1",
"foo#bar": "2",
"foo bar": "3",
"A": "1",
"B": "2 3 4",
"C": "5=#6",
"AServer": "\\\\server\\dir",
"BServer": "\\server\\dir"
}
for k in props.keys():
test(properties.getProperty(k) == props[k])
print("ok")
def getObject(self, id):
if id not in self._objects:
raise Ice.ObjectNotFoundException()
return self._objects[id]
def iGetIdentity(self):
_id = Ice.Identity()
_id.name = self._uuid
_id.category = self._category
return _id
def __init__(self):
self.delegate = Ice.initialize()
for of in ObjectFactories.values():
of.register(self.delegate) # Columns
#!/usr/bin/env python
#
# Copyright (c) ZeroC, Inc. All rights reserved.
#
import sys
import Ice
slice_dir = Ice.getSliceDir()
if not slice_dir:
print(sys.argv[0] + ': Slice directory not found.')
sys.exit(1)
Ice.loadSlice("'-I" + slice_dir + "' Props.ice")
import Demo
def run(communicator):
props = Demo.PropsPrx.checkedCast(
communicator.propertyToProxy("Props.Proxy"))
if props is None:
print("invalid proxy")
return 1
admin = Ice.PropertiesAdminPrx.checkedCast(
communicator.propertyToProxy("Admin.Proxy"))
batch1 = {}
batch1["Demo.Prop1"] = "1"
batch1["Demo.Prop2"] = "2"
batch1["Demo.Prop3"] = "3"
# You should have received a copy of the GNU General Public License
# along with RoboComp. If not, see <http://www.gnu.org/licenses/>.
import sys, Ice, os
from PySide2 import QtWidgets, QtCore
ROBOCOMP = ''
try:
ROBOCOMP = os.environ['ROBOCOMP']
except KeyError:
print(
'$ROBOCOMP environment variable not set, using the default value /opt/robocomp'
)
ROBOCOMP = '/opt/robocomp'
preStr = "-I/opt/robocomp/interfaces/ -I" + ROBOCOMP + "/interfaces/ --all /opt/robocomp/interfaces/"
Ice.loadSlice(preStr + "CommonBehavior.ice")
import RoboCompCommonBehavior
additionalPathStr = ''
icePaths = ['/opt/robocomp/interfaces']
try:
SLICE_PATH = os.environ['SLICE_PATH'].split(':')
for p in SLICE_PATH:
icePaths.append(p)
additionalPathStr += ' -I' + p + ' '
icePaths.append('/opt/robocomp/interfaces')
except:
print(
'SLICE_PATH environment variable was not exported. Using only the default paths'
)
pass
def __init__(self, adapter, adapter2, registry):
self._adapter1 = adapter
self._adapter2 = adapter2
self._registry = registry
self._registry.addObject(
self._adapter1.add(HelloI(), Ice.stringToIdentity("hello")))
#
# You should have received a copy of the GNU General Public License
# along with RoboComp. If not, see <http://www.gnu.org/licenses/>.
import sys, Ice, os
from PySide import *
ROBOCOMP = ''
try:
ROBOCOMP = os.environ['ROBOCOMP']
except KeyError:
print '$ROBOCOMP environment variable not set, using the default value /opt/robocomp'
ROBOCOMP = '/opt/robocomp'
preStr = "-I/opt/robocomp/interfaces/ -I" + ROBOCOMP + "/interfaces/ --all /opt/robocomp/interfaces/"
Ice.loadSlice(preStr + "CommonBehavior.ice")
import RoboCompCommonBehavior
preStr = "-I/opt/robocomp/interfaces/ -I" + ROBOCOMP + "/interfaces/ --all /opt/robocomp/interfaces/"
Ice.loadSlice(preStr + "TripodController.ice")
from RoboCompTripController import *
preStr = "-I/opt/robocomp/interfaces/ -I" + ROBOCOMP + "/interfaces/ --all /opt/robocomp/interfaces/"
Ice.loadSlice(preStr + "JointMotor.ice")
from RoboCompJointMotor import *
from tripodcontrollerI import *
class GenericWorker(QtCore.QObject):
kill = QtCore.Signal()
#!/usr/bin/env python
# **********************************************************************
#
# Copyright (c) 2003-2017 ZeroC, Inc. All rights reserved.
#
# This copy of Ice is licensed to you under the terms described in the
# ICE_LICENSE file included in this distribution.
#
# **********************************************************************
import os, sys, traceback
import Ice
Ice.loadSlice('Test.ice')
import Test, AllTests
def run(args, communicator):
custom = AllTests.allTests(communicator)
custom.shutdown()
return True
try:
with Ice.initialize(sys.argv) as communicator:
status = run(sys.argv, communicator)
except:
traceback.print_exc()
status = False
sys.exit(not status)
/*
** Generated by blitz/resources/templates/combined.vm
**
** Copyright 2007, 2008 Glencoe Software, Inc. All rights reserved.
** Use is subject to license terms supplied in LICENSE.txt
**
*/
"""
import Ice
import IceImport
import omero
IceImport.load("omero_model_DetailsI")
IceImport.load("omero_model_Namespace_ice")
from omero.rtypes import rlong
from collections import namedtuple
_omero = Ice.openModule("omero")
_omero_model = Ice.openModule("omero.model")
__name__ = "omero.model"
class NamespaceI(_omero_model.Namespace):
# Property Metadata
_field_info_data = namedtuple("FieldData", ["wrapper", "nullable"])
_field_info_type = namedtuple("FieldInfo", [
"keywords",
"multivalued",
"display",
"displayName",
"annotationLinks",
"name",
oldIc = self.__ic
self.__ic = None
# Only possible if improperly configured.
if not oldIc:
return
if oldOa:
try:
oldOa.deactivate()
except Exception, e:
self.__logger.warning("While deactivating adapter: " +
str(e.message))
self.__previous = Ice.InitializationData()
self.__previous.properties = oldIc.getProperties().clone()
try:
try:
self.getRouter(oldIc).destroySession()
except Glacier2.SessionNotExistException:
# ok. We don't want it to exist
pass
except Ice.ConnectionLostException:
# ok. Exception will always be thrown
pass
except Ice.ConnectionRefusedException:
# ok. Server probably went down
pass
except Ice.ConnectTimeoutException:
# Generated by slice2py - DO NOT EDIT!
#
import Ice
Ice.updateModule("org")
# Modules:
import service_ice
# Submodules:
def _initData(self, id):
"""
Initializes the current client via an Ice.InitializationData
instance. This is called by all of the constructors, but may
also be called on createSession(name, pass) if a previous
call to closeSession() has nulled the Ice.Communicator.
"""
if not id:
raise omero.ClientError("No initialization data provided.")
# Strictly necessary for this class to work
self._optSetProp(id, "Ice.ImplicitContext", "Shared")
if Ice.intVersion() >= 30600:
self._optSetProp(id, "Ice.ACM.Client.Timeout",
str(omero.constants.ACMCLIENTTIMEOUT))
self._optSetProp(id, "Ice.ACM.Client.Heartbeat",
str(omero.constants.ACMCLIENTHEARTBEAT))
else:
self._optSetProp(id, "Ice.ACM.Client", "0")
self._optSetProp(id, "Ice.CacheMessageBuffers", "0")
self._optSetProp(id, "Ice.RetryIntervals", "-1")
self._optSetProp(id, "Ice.Default.EndpointSelection", "Ordered")
self._optSetProp(id, "Ice.Default.PreferSecure", "1")
self._optSetProp(id, "Ice.Plugin.IceSSL", "IceSSL:createIceSSL")
if Ice.intVersion() >= 30600:
if sys.platform == "darwin":
self._optSetProp(id, "IceSSL.Ciphers", "NONE (DH_anon.*AES)")
else:
self._optSetProp(id, "IceSSL.Ciphers", "ADH")
else:
self._optSetProp(id, "IceSSL.Ciphers", "ADH")
self._optSetProp(id, "IceSSL.VerifyPeer", "0")
self._optSetProp(id, "IceSSL.Protocols", "tls1")
# Setting block size
self._optSetProp(id, "omero.block_size",
str(omero.constants.DEFAULTBLOCKSIZE))
# Set the default encoding if this is Ice 3.5 or later
# and none is set.
if Ice.intVersion() >= 30500:
self._optSetProp(id, "Ice.Default.EncodingVersion", "1.0")
# Setting MessageSizeMax
self._optSetProp(id, "Ice.MessageSizeMax",
str(omero.constants.MESSAGESIZEMAX))
# Setting ConnectTimeout
self.parseAndSetInt(id, "Ice.Override.ConnectTimeout",
omero.constants.CONNECTTIMEOUT)
# Set large thread pool max values for all communicators
for x in ("Client", "Server"):
sizemax = id.properties.getProperty("Ice.ThreadPool.%s.SizeMax" %
x)
if not sizemax or len(sizemax) == 0:
id.properties.setProperty("Ice.ThreadPool.%s.SizeMax" % x,
"50")
# Port, setting to default if not present
port = self.parseAndSetInt(id, "omero.port",
omero.constants.GLACIER2PORT)
# Default Router, set a default and then replace
router = id.properties.getProperty("Ice.Default.Router")
if not router or len(router) == 0:
router = str(omero.constants.DEFAULTROUTER)
host = id.properties.getPropertyWithDefault(
"omero.host", """<"omero.host" not set>""")
router = router.replace("@omero.port@", str(port))
router = router.replace("@omero.host@", str(host))
id.properties.setProperty("Ice.Default.Router", router)
# Dump properties
dump = id.properties.getProperty("omero.dump")
if len(dump) > 0:
m = self.getPropertyMap(id.properties)
keys = list(m.keys())
keys.sort()
for key in keys:
print "%s=%s" % (key, m[key])
self.__lock.acquire()
try:
if self.__ic:
raise omero.ClientError("Client already initialized")
try:
self.__ic = Ice.initialize(id)
except Ice.EndpointParseException:
msg = "No host specified. "
msg += "Use omero.client(HOSTNAME), ICE_CONFIG, or similar."
raise omero.ClientError(msg)
if not self.__ic:
raise omero.ClientError("Improper initialization")
# Register Object Factory
import ObjectFactoryRegistrar as ofr
ofr.registerObjectFactory(self.__ic, self)
for of in omero.rtypes.ObjectFactories.values():
of.register(self.__ic)
# Define our unique identifier (used during close/detach)
self.__uuid = str(uuid.uuid4())
ctx = self.__ic.getImplicitContext()
if not ctx:
raise omero.ClientError(
"Ice.ImplicitContext not set to Shared")
ctx.put(omero.constants.CLIENTUUID, self.__uuid)
# ticket:2951 - sending user group
group = id.properties.getPropertyWithDefault("omero.group", "")
if group:
ctx.put("omero.group", group)
finally:
self.__lock.release()
def __init__(self, args=None, id=None, host=None, port=None, pmap=None):
"""
Constructor which takes one sys.argv-style list, one initialization
data, one host string, one port integer, and one properties map, in
that order. *However*, to simplify use, we reassign values based on
their type with a warning printed. A cleaner approach is to use named
parameters.
::
c1 = omero.client(None, None, "host", myPort) # Correct
c2 = omero.client(host = "host", port = myPort) # Correct
# Works with warning
c3 = omero.client("host", myPort)
Both "Ice" and "omero" prefixed properties will be parsed.
Defines the state variables::
__previous : InitializationData from any previous communicator, if
any. Used to re-initialization the client
post-closeSession()
__ic : communicator. Nullness => init() needed on
createSession()
__sf : current session. Nullness => createSession() needed.
__resources: if non-null, hs access to this client instance and
will periodically call sf.keepAlive(None) in order to
keep any session alive. This can be enabled either
via the omero.keep_alive configuration property, or
by calling the enableKeepAlive() method.
Once enabled, the period cannot be adjusted during a
single session.
Modifying these variables outside of the accessors can lead to
undefined behavior.
Equivalent to all OmeroJava and OmeroCpp constructors
"""
# Setting all protected values to prevent AttributeError
self.__agent = "OMERO.py" #: See setAgent
self.__ip = None #: See setIP
self.__insecure = False
self.__previous = None
self.__ic = None
self.__oa = None
self.__cb = None
self.__sf = None
self.__uuid = None
self.__resources = None
self.__lock = threading.RLock()
# Logging
self.__logger = logging.getLogger("omero.client")
logging.basicConfig() # Does nothing if already configured
# Reassigning based on argument type
args, id, host, port, pmap = self._repair(args, id, host, port, pmap)
# Copying args since we don't really want them edited
if not args:
args = []
else:
# See ticket:5516 To prevent issues on systems where the base
# class of path.path is unicode, we will encode all unicode
# strings here.
for idx, arg in enumerate(args):
if isinstance(arg, unicode):
arg = arg.encode("utf-8")
args[idx] = arg
# Equiv to multiple constructors. #######################
if id is None:
id = Ice.InitializationData()
if id.properties is None:
id.properties = Ice.createProperties(args)
id.properties.parseCommandLineOptions("omero", args)
if host:
id.properties.setProperty("omero.host", str(host))
if not port:
port = id.properties.getPropertyWithDefault(
"omero.port", str(omero.constants.GLACIER2PORT))
id.properties.setProperty("omero.port", str(port))
if pmap:
for k, v in pmap.items():
id.properties.setProperty(str(k), str(v))
self._initData(id)
def createSession(self, username=None, password=None):
"""
Performs the actual logic of logging in, which is done via the
getRouter(). Disallows an extant ServiceFactoryPrx, and
tries to re-create a null Ice.Communicator. A null or empty
username will throw an exception, but an empty password is allowed.
"""
import omero
self.__lock.acquire()
try:
# Checking state
if self.__sf:
raise omero.ClientError(
"Session already active. "
"Create a new omero.client or closeSession()")
if not self.__ic:
if not self.__previous:
raise omero.ClientError(
"No previous data to recreate communicator.")
self._initData(self.__previous)
self.__previous = None
# Check the required properties
if not username:
username = self.getProperty("omero.user")
elif isinstance(username, omero.RString):
username = username.val
if not username or len(username) == 0:
raise omero.ClientError("No username specified")
if not password:
password = self.getProperty("omero.pass")
elif isinstance(password, omero.RString):
password = password.val
if not password:
raise omero.ClientError("No password specified")
# Acquire router and get the proxy
prx = None
retries = 0
while retries < 3:
reason = None
if retries > 0:
self.__logger.warning("%s - createSession retry: %s" %
(reason, retries))
try:
ctx = self.getContext()
ctx[omero.constants.AGENT] = self.__agent
if self.__ip is not None:
ctx[omero.constants.IP] = self.__ip
rtr = self.getRouter(self.__ic)
prx = rtr.createSession(username, password, ctx)
# Create the adapter
self.__oa = self.__ic.createObjectAdapterWithRouter(
"omero.ClientCallback", rtr)
self.__oa.activate()
id = Ice.Identity()
id.name = self.__uuid
id.category = rtr.getCategoryForClient()
self.__cb = BaseClient.CallbackI(self.__ic, self.__oa, id)
self.__oa.add(self.__cb, id)
break
except omero.WrappedCreateSessionException, wrapped:
if not wrapped.concurrency:
raise wrapped # We only retry concurrency issues.
reason = "%s:%s" % (wrapped.type, wrapped.reason)
retries = retries + 1
except Ice.ConnectTimeoutException, cte:
reason = "Ice.ConnectTimeoutException:%s" % str(cte)
retries = retries + 1
def getAdapter(self, adapter):
if adapter not in self._adapters:
raise Ice.AdapterNotFoundException()
return self._adapters[adapter]
def asyncException_async(self, cb, current=None):
cb.ice_exception(Test.TestIntfUserException())
raise Ice.ObjectNotExistException()
def getReplicatedHello(self, current=None):
return Test.HelloPrx.uncheckedCast(
self._adapter1.createProxy(Ice.stringToIdentity("hello")))
def asyncResponse_async(self, cb, current=None):
cb.ice_response()
raise Ice.ObjectNotExistException()
#!/usr/bin/env python
# **********************************************************************
#
# Copyright (c) 2003-2016 ZeroC, Inc. All rights reserved.
#
# This copy of Ice is licensed to you under the terms described in the
# ICE_LICENSE file included in this distribution.
#
# **********************************************************************
import os, sys, traceback
import Ice
slice_dir = Ice.getSliceDir()
if not slice_dir:
print(sys.argv[0] + ': Slice directory not found.')
sys.exit(1)
Ice.loadSlice("'-I" + slice_dir + "' Test.ice")
import Test
class ServerLocatorRegistry(Test.TestLocatorRegistry):
def __init__(self):
self._adapters = {}
self._objects = {}
def setAdapterDirectProxy(self, adapter, obj, current=None):
if obj:
self._adapters[adapter] = obj
else:
def unknownExceptionWithServantException_async(self, cb, current=None):
cb.ice_exception(Ice.ObjectNotExistException())
import sys, traceback, Ice
import Demo
status = 0
ic = None
try:
ic = Ice.initialize(sys.argv)
base = ic.stringToProxy("SimplePrinter:default -p 10000")
printer = Demo.PrinterPrx.checkedCast(base)
if not printer:
raise RuntimeError("Invalid proxy")
printer.printString("Hello, World!")
except:
traceback.print_exc()
status = 1
if ic:
try:
ic.destroy()
except:
traceback.print_exc()
status = 1
sys.exit(status)
# Ice version 3.6.1
#
# <auto-generated>
#
# Generated from file `PermissionsVerifier.ice'
#
# Warning: do not edit this file.
#
# </auto-generated>
#
import Ice, IcePy
import Glacier2_SSLInfo_ice
# Included module Ice
_M_Ice = Ice.openModule('Ice')
# Included module Glacier2
_M_Glacier2 = Ice.openModule('Glacier2')
# Start of module Glacier2
__name__ = 'Glacier2'
if 'PermissionDeniedException' not in _M_Glacier2.__dict__:
_M_Glacier2.PermissionDeniedException = Ice.createTempClass()
class PermissionDeniedException(Ice.UserException):
'''This exception is raised if a client is denied the ability to create
a session with the router.'''
def __init__(self, reason=''):
self.reason = reason
#!/usr/bin/python3 -u
# -*- coding: utf-8 -*-
import sys
import Ice
Ice.loadSlice('./factorial.ice')
import Example
def factorial(n):
if n == 0:
return 1
return n * factorial(n - 1)
class MathI(Example.Math):
def factorial(self, n, current=None):
return factorial(n)
class Server(Ice.Application):
def run(self, argv):
broker = self.communicator()
adapter = broker.createObjectAdapter("MathAdapter")
math = adapter.add(MathI(), broker.stringToIdentity("math1"))
print math
def batchOneways(p):
if sys.version_info[0] == 2:
bs1 = []
bs1[0:10 * 1024] = range(0, 10 * 1024) # add 100,000 entries.
bs1 = ['\x00' for x in bs1] # set them all to \x00
bs1 = ''.join(bs1) # make into a byte array
else:
bs1 = bytes([0 for x in range(0, 10 * 1024)])
try:
p.opByteSOneway(bs1)
except Ice.MemoryLimitException:
test(False)
batch = Test.MyClassPrx.uncheckedCast(p.ice_batchOneway())
batch.ice_flushBatchRequests() # Empty flush
if batch.ice_getConnection():
batch.ice_getConnection().flushBatchRequests(
Ice.CompressBatch.BasedOnProxy)
batch.ice_getCommunicator().flushBatchRequests(
Ice.CompressBatch.BasedOnProxy)
p.opByteSOnewayCallCount() # Reset the call count
for i in range(30):
batch.opByteSOneway(bs1)
count = 0
while count < 27: # 3 * 9 requests auto-flushed.
count += p.opByteSOnewayCallCount()
time.sleep(0.01)
if p.ice_getConnection():
batch1 = Test.MyClassPrx.uncheckedCast(p.ice_batchOneway())
batch2 = Test.MyClassPrx.uncheckedCast(p.ice_batchOneway())
batch1.ice_ping()
batch2.ice_ping()
batch1.ice_flushBatchRequests()
batch1.ice_getConnection().close(
Ice.ConnectionClose.GracefullyWithWait)
batch1.ice_ping()
batch2.ice_ping()
batch1.ice_getConnection()
batch2.ice_getConnection()
batch1.ice_ping()
batch1.ice_getConnection().close(
Ice.ConnectionClose.GracefullyWithWait)
batch1.ice_ping()
batch2.ice_ping()
identity = Ice.Identity()
identity.name = "invalid"
batch3 = batch.ice_identity(identity)
batch3.ice_ping()
batch3.ice_flushBatchRequests()
# Make sure that a bogus batch request doesn't cause troubles to other ones.
batch3.ice_ping()
batch.ice_ping()
batch.ice_flushBatchRequests()
batch.ice_ping()
if batch.ice_getConnection():
initData = Ice.InitializationData()
initData.properties = p.ice_getCommunicator().getProperties().clone()
interceptor = BatchRequestInterceptorI()
initData.batchRequestInterceptor = interceptor
ic = Ice.initialize(data=initData)
batch = Test.MyClassPrx.uncheckedCast(
ic.stringToProxy(p.ice_toString())).ice_batchOneway()
test(interceptor.count() == 0)
batch.ice_ping()
batch.ice_ping()
batch.ice_ping()
test(interceptor.count() == 0)
interceptor.setEnabled(True)
batch.ice_ping()
batch.ice_ping()
batch.ice_ping()
test(interceptor.count() == 3)
batch.ice_flushBatchRequests()
batch.ice_ping()
test(interceptor.count() == 1)
batch.opByteSOneway(bs1)
test(interceptor.count() == 2)
batch.opByteSOneway(bs1)
test(interceptor.count() == 3)
batch.opByteSOneway(bs1) # This should trigger the flush
batch.ice_ping()
test(interceptor.count() == 2)
ic.destroy()
#!/usr/bin/env python
# **********************************************************************
#
# Copyright (c) 2003-2013 ZeroC, Inc. All rights reserved.
#
# This copy of Ice is licensed to you under the terms described in the
# ICE_LICENSE file included in this distribution.
#
# **********************************************************************
import sys, os, traceback, threading, Ice
Ice.loadSlice('Hello.ice')
import Demo
class CallbackEntry(object):
def __init__(self, cb, delay):
self.cb = cb
self.delay = delay
class WorkQueue(threading.Thread):
def __init__(self):
threading.Thread.__init__(self)
self._callbacks = []
self._done = False
self._cond = threading.Condition()
def run(self):
self._cond.acquire()
#!/usr/bin/python
# -*- coding: utf-8 -*-
# **********************************************************************
#
# Authors: Cristian Gómez Portes, Pedro Gómez Martín
#
# **********************************************************************
import Ice
Ice.loadSlice('services.ice --all -I .')
import services
import drobots
import sys, time, random
class PlayerApp(Ice.Application):
def run(self, argv):
broker = self.communicator()
#well-known object
container_proxy = broker.stringToProxy('container')
container = services.ContainerPrx.checkedCast(container_proxy)
adapter = broker.createObjectAdapter('PlayerAdapter')
adapter.activate()
player_servant = PlayerI(broker, adapter, container)
proxy_player = adapter.addWithUUID(player_servant)
print('Proxy player: ' + str(proxy_player))
direct_player = adapter.createDirectProxy(
#!/usr/bin/env python
# **********************************************************************
#
# Copyright (c) 2003-2016 ZeroC, Inc. All rights reserved.
#
# **********************************************************************
import sys, traceback, Ice
Ice.loadSlice('Printer.ice')
import Demo
class PrinterI(Demo.Printer):
def printString(self, s, current=None):
print(s)
status = 0
ice = None
try:
ic = Ice.initialize(sys.argv)
adapter = ic.createObjectAdapterWithEndpoints(
"SimplePrinterAdapter", "default -h localhost -p 10000")
object = PrinterI()
adapter.add(object, Ice.stringToIdentity("SimplePrinter"))
adapter.activate()
ic.waitForShutdown()
except:
traceback.print_exc()
status = 1
# along with RoboComp. If not, see <http://www.gnu.org/licenses/>.
#
#
#
# CODE BEGINS
#
import sys, time, traceback, os, math, random, threading, time
import Ice
from PyQt4 import QtCore, QtGui, Qt
from ui_formManager import Ui_Form
import rcmanagerConfig
global_ic = Ice.initialize(sys.argv)
# Ctrl+c handling
import signal
signal.signal(signal.SIGINT, signal.SIG_DFL)
dict = rcmanagerConfig.getDefaultValues()
initDir = os.getcwd()
sys.path.append('.')
sys.path.append('/opt/robocomp/bin')
import rcmanagerEditor
# CommandDialog class: It's the dialog sending "up()/down() component X signal to the main
def __init__(self):
if Ice.getType(self) == _M_Glacier2.PermissionsVerifier:
raise RuntimeError(
'Glacier2.PermissionsVerifier is an abstract class')
#
# <auto-generated>
#
# Generated from file `SSLInfo.ice'
#
# Warning: do not edit this file.
#
# </auto-generated>
#
from sys import version_info as _version_info_
import Ice, IcePy
import Ice.BuiltinSequences_ice
# Included module Ice
_M_Ice = Ice.openModule('Ice')
# Start of module Glacier2
_M_Glacier2 = Ice.openModule('Glacier2')
__name__ = 'Glacier2'
if 'SSLInfo' not in _M_Glacier2.__dict__:
_M_Glacier2.SSLInfo = Ice.createTempClass()
class SSLInfo(object):
"""
Information taken from an SSL connection used for permissions
verification.
Members:
remoteHost -- The remote host.
remotePort -- The remote port.
