def setup_class(cls): cls.OmeroPy = cls.omeropydir() cls.__clients = Clients() # Create a root client p = Ice.createProperties(sys.argv) rootpass = p.getProperty("omero.rootpass") try: cls.root = omero.client() # ok because adds self cls.__clients.add(cls.root) cls.root.setAgent("OMERO.py.root_test") cls.root.createSession("root", rootpass) cls.root.getSession().keepAlive(None) except: raise Exception("Could not initiate a root connection") cls.group = cls.new_group(perms=cls.DEFAULT_PERMS) cls.user = cls.new_user(group=cls.group, owner=cls.DEFAULT_GROUP_OWNER) cls.client = omero.client() # ok because adds self cls.__clients.add(cls.client) cls.client.setAgent("OMERO.py.test") cls.sf = cls.client.createSession(cls.user.omeName.val, cls.user.omeName.val) cls.ctx = cls.sf.getAdminService().getEventContext() cls.update = cls.sf.getUpdateService() cls.query = cls.sf.getQueryService()
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 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 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 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 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 checkwindows(self, args): """ Checks that the templates file as defined in etc\Windows.cfg can be found. """ self.check_access(os.R_OK) if not self._isWindows(): self.ctx.die(123, "Not Windows") import Ice key = "IceGrid.Node.Data" properties = Ice.createProperties([self._icecfg()]) nodedata = properties.getProperty(key) if not nodedata: self.ctx.die(300, "Bad configuration: No IceGrid.Node.Data property") nodepath = path(nodedata) pp = nodepath.parpath(self.ctx.dir) if pp: return if nodepath == r"c:\omero_dist\var\master": self.ctx.out("Found default value: %s" % nodepath) self.ctx.out("Attempting to correct...") from omero.install.win_set_path import win_set_path count = win_set_path(dir = self.ctx.dir) if count: return self.ctx.die(400, """ %s is not in this directory. Aborting... Please see the installation instructions on modifying the files for your installation (%s) with bin\winconfig.bat """ % (nodedata, self.ctx.dir))
def setUp(self): self.OmeroPy = self.omeropydir() self.__clients = Clients() p = Ice.createProperties(sys.argv) rootpass = p.getProperty("omero.rootpass") name = None pasw = None if rootpass: self.root = omero.client() # ok because adds self self.__clients.add(self.root) self.root.setAgent("OMERO.py.root_test") self.root.createSession("root", rootpass) newuser = self.new_user() name = newuser.omeName.val pasw = "1" else: self.root = None self.client = omero.client() # ok because adds self self.__clients.add(self.client) self.client.setAgent("OMERO.py.test") self.sf = self.client.createSession(name, pasw) self.update = self.sf.getUpdateService() self.query = self.sf.getQueryService()
def main(configFile = 'config/server/SenStore.cfg'): # Setup logging p = Ice.createProperties() p.load(configFile) level = p.getProperty('Logging.level').upper() try: loglevel = logging.__dict__[level] except: loglevel = logging.INFO FORMAT = "%(asctime)-15s:%(levelname)s %(message)s" logging.basicConfig(level=loglevel,format=FORMAT) dbname = p.getProperty('PostgreSQL.database') logging.info('Creating new empty SQL database: %s' % dbname) createDb(p, dbname) logging.info('Creating database tables') execSql(p, dbname, 'install/tables_create.sql') time.sleep(0.1) # Remove old HDF5 database h5file = p.getProperty('HDF5.database') if os.path.exists(h5file): logging.info('Removing HDF5 database: %s' % h5file) os.unlink(h5file)
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 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 _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 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_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 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(): # 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 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 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 get_communicator(host, port): """Return a Ice communicator instance""" 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 initializeProperties(args, properties = Ice.createProperties()): properties.parseIceCommandLineOptions(args) iceconfigfiles = properties.getProperty("Ice.Config") if (iceconfigfiles): for iceconfig in iceconfigfiles.split(","): loadIceConfig(iceconfig, properties) properties.parseCommandLineOptions("", args) return properties
def loadIceConfig(filename, properties = Ice.createProperties()): filepath = findConfigFile(filename) if (filepath): print ('loading Ice.Config file %s' %(filepath)) properties.load(filepath) else: msg = "Ice.Config file '%s' could not being found" % (filename) raise ValueError(msg) return properties
def initialize(args): """ Parse the command line options and return the values in the config file. This will remove the Ice runtime arguments if any exist. The Ice runtime arguments will not be returned, but discarded. If you need the Ice runtime arguments, you should initialize the runtime before calling this function (typically done automatically by C{Ice.Application}. This will add the log files for the stream handler and the file handler to the logger. """ if args is None: args = sys.argv[:] # discard Ice command line arguments Ice.createProperties(args) parser = OptionParser( usage="""Usage: %s <tool...> [options] Tools: ripper\t\truns the ripper testgenerator\t\truns the test generator replayer\t\truns the replayer""" % os.path.basename(args[0]) ) parser.add_option( "-c", "--config", dest="configfile", default="guitar.cfg", help="config file path", metavar="FILE" ) (options, args) = parser.parse_args(args) # add logging handlers to the global logger if not os.path.exists("logs"): os.mkdir("logs") log = logging.log log.addHandler(logging.stdout()) log.addHandler(logging.file_handler()) return config.load(options.configfile)
def loadIceConfig(filename, properties=Ice.createProperties()): filepath = findConfigFile(filename) if (filepath): print('loading Ice.Config file %s' % (filepath)) properties.load(filepath) else: msg = "Ice.Config file '%s' could not being found" % (filename) raise ValueError(msg) return properties
def __init__(self, properties=None): properties = properties or [] data = Ice.InitializationData() data.properties = Ice.createProperties() for p in properties: data.properties.setProperty(p[0], p[1]) self.communicator = Ice.initialize(data) self.adapter = self.communicator.createObjectAdapterWithEndpoints('Adapter', 'tcp') self.adapter.activate()
def init_ice(self): initdata_properties = Ice.createProperties(sys.argv) initdata_properties.setProperty("Ice.ImplicitContext", "Shared") initdata_properties.setProperty("Ice.Default.EncodingVersion", "1.0") initdata_properties.setProperty("Ice.Default.Timeout", str(self.ice_timeout_in_millis)) initdata = Ice.InitializationData() initdata.properties = initdata_properties return Ice.initialize(initdata)
def _setup_communicator(): if "ICE_CONFIG" in os.environ: return Ice.initialize(sys.argv) host = 'localhost' port = 4062 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 _setup_communicator(host, port): if not host: if not os.environ.get("ICE_CONFIG", None): raise OSError("'ICE_CONFIG' not set") return Ice.initialize(sys.argv) 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 test_fdc(): try: props = Ice.createProperties() c = Ice.initializeWithProperties(sys.argv,props) fdc = FrontDispatchControllerPrx.checkedCast(c.stringToProxy("fdc:tcp -h 192.168.14.10 -p 4501")) print fdc.GetFPCSettings() fpc = fpcParameter() fpc.ip='192.168.14.16' fpc.mac='00-01-02-03' #fdc.ReportMideaPlayEvent('',[EventMediaPlay('m1','qq','192.168.14.2','11-11-11',0,100)]) except: print traceback.print_exc()
def __init__(self, endpoint = 'tcp -h 127.0.0.1 -p 6502', secret = None): Ice.loadSlice('Murmur/Murmur.ice') prop = Ice.createProperties([]) prop.setProperty('Ice.ImplicitContext', 'Shared') idd = Ice.InitializationData() idd.properties = prop ice = Ice.initialize(idd) if secret is not None and secret != '': ice.getImplicitContext().put('secret', secret.encode('utf-8')) endpoint = 'Meta:'+endpoint prx = ice.stringToProxy(endpoint.encode('utf-8')) self.murmur = Murmur.MetaPrx.checkedCast(prx)
def readwork(workconfig): global reader while 1: msglist0 = {} try: rst1, msglist = reader.readMessages(READ_QUEUE_NAME, msglist0) except Exception as e: lg.info('read msg err : %s' % e) exc_type, exc_obj, exc_tb = sys.exc_info() fname = os.path.split(exc_tb.tb_frame.f_code.co_filename)[1] lg.info((exc_type, fname, exc_tb.tb_lineno)) gevent.sleep(5) id = Ice.InitializationData() if id.properties == None: id.properties = Ice.createProperties(sys.argv) if Ice.intVersion() > 30500: if not id.properties.getProperty( "Ice.Default.EncodingVersion"): id.properties.setProperty("Ice.Default.EncodingVersion", "1.0") ic = Ice.initialize(id) base = ic.stringToProxy('gmqObjectId:tcp -h %s -p %s' % (QUEUE_IP, QUEUE_PORT)) reader = GMQ.MsgQueuePrx.checkedCast(base) continue gevent.sleep(0.1) if len(msglist) == 0: gevent.sleep(0.5) continue for msg in msglist: print msg try: jsoninfo = json.loads(msg) print(jsoninfo) taskInfo = { 'task_id': jsoninfo['task_id'], 'plat_id': jsoninfo['plat_id'], 'obj_id': jsoninfo['obj_id'], 'obj_name': jsoninfo['obj_name'], 'obj_code': jsoninfo['obj_code'], 'obj_ext': jsoninfo['obj_ext'], 'create_time': jsoninfo['create_time'], 'task_send_time': jsoninfo['task_send_time'], 'sn': jsoninfo['sn'], 'mode': jsoninfo['mode'] } tasks.put(taskInfo) except Exception as e: lg.info('unknown err process:%s' % (e))
def testInitializationDataConstructor(self): id = Ice.InitializationData() id.properties = Ice.createProperties([]) id.properties.setProperty("omero.user", "root") id.properties.setProperty("omero.pass", self.rootpasswd) c = omero.client(id=id) try: c.createSession() c.closeSession() c.createSession() c.closeSession() finally: c.__del__()
def test_fdc(): try: props = Ice.createProperties() c = Ice.initializeWithProperties(sys.argv, props) fdc = FrontDispatchControllerPrx.checkedCast( c.stringToProxy("fdc:tcp -h 192.168.14.10 -p 4501")) print fdc.GetFPCSettings() fpc = fpcParameter() fpc.ip = '192.168.14.16' fpc.mac = '00-01-02-03' #fdc.ReportMideaPlayEvent('',[EventMediaPlay('m1','qq','192.168.14.2','11-11-11',0,100)]) except: print traceback.print_exc()
def keepRootAlive(self): """ Keeps root connection alive. """ try: if self.root.sf is None: p = Ice.createProperties(sys.argv) rootpass = p.getProperty("omero.rootpass") self.root.createSession("root", rootpass) else: self.root.sf.keepAlive(None) except Exception: raise
def __init__(self, secret): import Ice, IcePy # Setup Ice icepath = Ice.getSliceDir() prop = Ice.createProperties([]) prop.setProperty("Ice.ImplicitContext", "Shared") prop.setProperty("Ice.MessageSizeMax", "65535") idd = Ice.InitializationData() idd.properties = prop ice = Ice.initialize(idd) # Set the secret ice.getImplicitContext().put( "secret", secret ) # Initialization of a local connexion prx = ice.stringToProxy('Meta:tcp -h localhost -p 6502') prx.ice_ping() # Load the object definition Ice.loadSlice( '', ['-I' + icepath, "Murmur.ice" ] ) import Murmur self._murmur = Murmur.MetaPrx.checkedCast(prx) # Generic ACL ready to use self._password_ACL = [ Murmur.ACL( applyHere = True, applySubs = False, inherited = False, userid = -1, group = "all", allow = 0, deny = 910, ), Murmur.ACL( applyHere = True, applySubs = False, inherited = False, userid = -1, # The password is defined by adding a # in front of group name group = "", allow = 910, deny = 0, ) ] self._server = self._murmur.getServer(1)
def init(force=False): global state, murmur if state != 'uninitialised' and not force: return 'previously failed' try: settings = TrosnothServerSettings.get() if not settings.iceEnabled: state = 'disabled' return import Ice, IcePy proxyString = settings.iceProxyStringOverride if not proxyString: proxyString = 'Meta:tcp -h {host} -p {port} -t 1000'.format( host=settings.iceHost, port=settings.icePort) props = Ice.createProperties() props.setProperty('Ice.ImplicitContext', 'Shared') initData = Ice.InitializationData() initData.properties = props ice = Ice.initialize(initData) proxy = ice.stringToProxy(proxyString) op = IcePy.Operation('getSlice', Ice.OperationMode.Idempotent, Ice.OperationMode.Idempotent, True, None, (), (), (), ((), IcePy._t_string, False, 0), ()) sl = op.invoke(proxy, ((), None)) fd, path = tempfile.mkstemp(suffix='.ice') f = os.fdopen(fd, 'w') with f: f.write(sl) f.flush() Ice.loadSlice('', ['-I' + Ice.getSliceDir(), path]) os.unlink(path) if settings.iceSecret: ice.getImplicitContext().put('secret', settings.iceSecret.encode('ascii')) import Murmur murmur = Murmur.MetaPrx.checkedCast(proxy) except Exception: log.exception('Error initialising murmur connection') state = 'failed' else: state = 'initialised' return state
def createIceCommunicator(iceprops={}): import Ice props = Ice.createProperties() props.setProperty("Ice.ThreadPool.Server.SizeMax", "16") props.setProperty("Ice.MessageSizeMax", "0") for k, v in iceprops.items(): props.setProperty(k, str(v)) # props.setProperty("Ice.Trace.ThreadPool", "1") # props.setProperty("Ice.Trace.Network", "1") # props.setProperty("Ice.Trace.Protocol", "1") data = Ice.InitializationData() data.properties = props return Ice.initialize(data=data)
def configure_ice(self): logging.info('Configuring Ice connector.') prxstr = "Meta:tcp -h %s -p %d -t 1000" % (self.host, self.port) props = Ice.createProperties() props.setProperty("Ice.ImplicitContext", "Shared") idata = Ice.InitializationData() idata.properties = props self.ice = Ice.initialize(idata) self.prx = self.ice.stringToProxy(prxstr) logging.info('Ice connector configured')
def __generate_ice_config(): init_data = Ice.InitializationData() init_data.properties = Ice.createProperties() init_data.properties.setProperty(r'Ice.ThreadPool.Client.Size', r'8') init_data.properties.setProperty(r'Ice.ThreadPool.Client.SizeMax', r'64') init_data.properties.setProperty(r'Ice.ThreadPool.Client.ThreadIdleTime', r'0') init_data.properties.setProperty(r'Ice.ThreadPool.Client.StackSize', r'8388608') init_data.properties.setProperty(r'StorageApi.Proxy', r'dss : tcp -h 127.0.0.1 -p 21119') init_data.properties.setProperty(r'Ice.Default.Host', r'localhost') init_data.properties.setProperty(r'Ice.Warn.Connections', r'1') init_data.properties.setProperty(r'Ice.RetryIntervals', r'0') init_data.properties.setProperty(r'Ice.MessageSizeMax', r'65536') # 64MB init_data.properties.setProperty(r'Ice.ACM.Heartbeat', r'3') # BoxService KernelTcp 会检测心跳 return init_data
def _properties(self, prefix=""): """ Loads all files returned by _cfglist() into a new Ice.Properties instance and return the map from getPropertiesForPrefix(prefix) where the default is to return all properties. """ import Ice if getattr(self, "_props", None) is None: self._props = Ice.createProperties() for cfg in self._cfglist(): try: self._props.load(str(cfg)) except Exc, exc: self.ctx.die(3, "Could not find file: "+cfg + "\nDid you specify the proper node?")
def main(configFile = 'config/server/SenStore.cfg'): # Setup logging p = Ice.createProperties() p.load(configFile) level = p.getProperty('Logging.level').upper() try: loglevel = logging.__dict__[level] except: loglevel = logging.INFO FORMAT = "%(asctime)-15s:%(levelname)s %(message)s" logging.basicConfig(level=loglevel,format=FORMAT) # Start server app = Server() args = ['--Ice.Config=%s' % configFile] + sys.argv sys.exit(app.main(args))
def testEmptyInitializationDataConstructor(self): id = Ice.InitializationData() # With no argument id.properties is empty id.properties = Ice.createProperties() id.properties.setProperty("omero.host", self.host) id.properties.setProperty("omero.port", native_str(self.port)) id.properties.setProperty("omero.user", "root") id.properties.setProperty("omero.pass", self.rootpasswd) c = omero.client(id=id) try: c.createSession() c.closeSession() c.createSession() c.closeSession() finally: c.__del__()
def init_oce_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.Default.Host", ''), ("Ice.Default.Locator", "XiaoNei/Locator:default -h XiaoNeiRegistry -p 12000:default -h XiaoNeiRegistryReplica1 -p 12001:default -h XiaoNeiRegistryReplica2 -p 12002")] for i in kv: initData.properties.setProperty(i[0], i[1]) oce_ic = Ice.initialize(None, initData) return oce_ic
def _init_Ice(self): import Ice props = Ice.createProperties() props.setProperty("Ice.ThreadPool.Server.SizeMax", "16") # props.setProperty("Ice.ThreadPool.SizeMax", "16") props.setProperty("Ice.MessageSizeMax", "0") # props.setProperty("Ice.Trace.ThreadPool", "1") # props.setProperty("Ice.Trace.Network", "1") # props.setProperty("Ice.Trace.Protocol", "1") data = Ice.InitializationData() data.properties = props self._ice_ic = ic = Ice.initialize(data=data) self._ice_adapter = adapter = ic.createObjectAdapter("") self._ice_ident = ident = Ice.Identity() ident.name = Ice.generateUUID() adapter.add(self, ident) adapter.activate()
def initAppData(xcfg=None, props=None): """初始化一个ICE的应用数据类 xcfg XmlConfig配置的路径(可选) props 额外指定的属性(可选) """ data = Ice.InitializationData() data.properties = Ice.createProperties() if xcfg: import XmlConfig if xcfg[-1:] != '/': xcfg += '/' for k, v in XmlConfig.list(xcfg).items(): data.properties.setProperty(k, v) if props: for k, v in props.items(): data.properties.setProperty(k, v) return data
def get_mini_loader_ptr(self, wait_timeout=30 * 60): init_data = Ice.InitializationData() init_data.properties = Ice.createProperties() init_data.properties.setProperty(r'Ice.LogFile', r'clw_MiniLoader_ice.log') init_data.properties.setProperty(r'Ice.ThreadPool.Server.Size', r'1') init_data.properties.setProperty(r'Ice.ThreadPool.Server.SizeMax', r'8') init_data.properties.setProperty(r'Ice.ThreadPool.Server.StackSize', r'8388608') init_data.properties.setProperty(r'Ice.ThreadPool.Client.Size', r'1') init_data.properties.setProperty(r'Ice.ThreadPool.Client.SizeMax', r'8') init_data.properties.setProperty(r'Ice.ThreadPool.Client.StackSize', r'8388608') init_data.properties.setProperty(r'Ice.Default.Host', r'localhost') init_data.properties.setProperty(r'Ice.Warn.Connections', r'1') init_data.properties.setProperty(r'Ice.ACM.Heartbeat', r'3') init_data.properties.setProperty( r'Ice.ThreadPool.Client.ThreadIdleTime', r'0') init_data.properties.setProperty( r'Ice.ThreadPool.Server.ThreadIdleTime', r'0') init_data.properties.setProperty(r'Callback.Server.Endpoints', r'tcp -h 0.0.0.0 -p 10000') init_data.properties.setProperty(r'Ice.MessageSizeMax', r'131072') # 单位KB, 128MB self._communicator = Ice.initialize(sys.argv, init_data) adapter = self._communicator.createObjectAdapter(r'Callback.Server') sender = CallbackSenderI(self._communicator) adapter.add(sender, self._communicator.stringToIdentity(r"sender")) adapter.activate() st1 = datetime.datetime.now() while True: client = sender.getClient() if client: _logger.info('get_mini_loader_ptr OK.') return client break st2 = datetime.datetime.now() if (st2 - st1).seconds > wait_timeout: _logger.info('get_mini_loader_ptr getClient Failed. timeout.') self.destroy() break time.sleep(1) return None
def start(self): if self.started: return if not self.devices: self.logger.warning("There is no device to host.") return self.logger.info("Starting DeviceRack...") ice_props = Ice.createProperties() ice_props.setProperty("Ice.ThreadPool.Client.Size", "1") ice_props.setProperty("Ice.ThreadPool.Client.SizeMax", "10") ice_props.setProperty("Ice.ThreadPool.Server.Size", "1") ice_props.setProperty("Ice.ThreadPool.Server.SizeMax", "10") ice_props.setProperty("Ice.MessageSizeMax", "20000") # 20MB ice_init_data = Ice.InitializationData() ice_init_data.properties = ice_props with Ice.initialize(ice_init_data) as ic: self.ic = ic self.started = True self.adapter = ic.createObjectAdapterWithEndpoints( "DeviceRackAdapter", "tcp -h 0.0.0.0 -p 0") self.rack: DeviceRackPrx = DeviceRackPrx.uncheckedCast( self.adapter.add(self, ic.stringToIdentity(self.name))) self.adapter.activate() endpoint_info = self.adapter.getEndpoints()[0].getInfo() self.bind_address = endpoint_info.host self.bind_port = endpoint_info.port self.logger.info(f"DeviceRack started at {self.bind_address}:" f"{self.bind_port}.") self._connect_and_register_devices() try: ic.waitForShutdown() except KeyboardInterrupt: self.started = False
def main(self, args, fd=None, cfgfile=None, syslog=False): try: with self._cond_var: # initialize runtime self._signal_handler = Ice.CtrlCHandler() self._signal_handler.setCallback(self.interruptCallback) init_data = Ice.InitializationData() init_data.properties = Ice.createProperties([args[0]]) if cfgfile: init_data.properties.load(cfgfile) args = init_data.properties.parseIceCommandLineOptions(args) if syslog: init_data.properties.setProperty("Ice.UseSyslog", "1") self._communicator = Ice.initialize([args[0]], init_data) Ice.setProcessLogger(self._communicator.getLogger()) # initialize daemon instance self.instance = self.daemon(self._communicator, args) # report success _report_result(fd, 0, "%d" % os.getpid()) except Exception: return _report_exception(fd) try: # run the daemon status = self.instance.run() #cleanup with self._cond_var: while self._communicator is not None: self._cond_var.wait() self._signal_handler.destroy() self._signal_handler = None return status except Exception: return _report_exception()
def test_cms(): try: props = Ice.createProperties() c = Ice.initializeWithProperties(sys.argv, props) cms = CentreMangementSystemPrx.checkedCast( c.stringToProxy("cms:tcp -h 192.168.14.10 -p 4502")) fpc = fpcParameter() fpc.ip = '192.168.14.11' fpc.mac = '00-01-02-03' iden = Ice.stringToIdentity('test') #cms.RegisterFDC(iden) #print cms.GetfpcControlInfo('') print cms.GetPlayPolicies('') #ftp = cms.GetFtpServer() #set = cms.GetPlayPolicies('') print cms.GetFPCSettings() except: print traceback.print_exc()
def __init__(self, server_address, server_port): server_url = 'ice:tcp -h {host} -p {port} -z'.format( host=server_address, port=server_port) try: properties = Ice.createProperties() properties.setProperty('Ice.MessageSizeMax', '10240') properties.setProperty('Ice.Override.Compress', '1') data = Ice.InitializationData() data.properties = properties communicator = Ice.initialize(data) self._server_proxy = ice_utils.IIceDispatcherPrx.checkedCast( communicator.stringToProxy(server_url)) except Ice.Exception as ice_error: print ice_error sys.exit(30) self._user = None self._ticket = None
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 __init__(self, user_id: str, password: str, host: str, port: int = 1888, config_file: Optional[str] = None): super().__init__() ice_file_path = os.path.join(os.path.dirname(stub_ice.__file__), 'stub.ice') Ice.loadSlice(ice_file_path) init_data = Ice.InitializationData() init_data.properties = Ice.createProperties() if config_file: init_data.properties.load(config_file) logger.debug(f'load initial config from file: {config_file}') self._ic = Ice.initialize(init_data) base = self._ic.stringToProxy( init_data.properties.getProperty("DataApi.Proxy")) else: logger.debug('load default initial config') init_data.properties.setProperty("Ice.Warn.Connections", "1") init_data.properties.setProperty("Ice.Trace.Protocol", "0") init_data.properties.setProperty("Ice.MessageSizeMax", "20971520") init_data.properties.setProperty("Ice.ThreadPool.Client.Size", "10") init_data.properties.setProperty("Ice.Default.EncodingVersion", "1.0") self._ic = Ice.initialize(init_data) base = self._ic.stringToProxy(f"DataApi:tcp -h {host} -p {port}") self._api = cma.cimiss.DataAPIAccessPrx.checkedCast(base) if not self._api: raise RuntimeError("Invalid proxy") self._client_ip = socket.gethostbyname(socket.gethostname()) self._language = "python" self._version = "1.3" self._user_id = user_id self._pwd = password self._host = host self._port = port
def __init__(self): # initialize Ice self.prop = Ice.createProperties() self.prop.setProperty("Ice.ImplicitContext", "Shared") self.idd = Ice.InitializationData() self.idd.properties = self.prop self.ice = Ice.initialize(self.idd) self.ice.getImplicitContext().put("secret", "1234567890") # Let Ice know where to go to connect to mumble self.proxy = self.ice.stringToProxy("Meta:tcp -p 6502") # Create a dynamic object that allows us to get a programmable interface for Mumble self.meta = Murmur.MetaPrx.checkedCast(self.proxy) # Get the server instance from the set of servers. self.server = self.meta.getServer(1) self.channels = self.server.getChannels() self.users = self.server.getUsers()
def connect(self, IP, node): #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) self.ics[node] = ic # Create proxy #base = ic.stringToProxy("SRTController:default -h 192.168.0.6 -p 10000") IP_string = IP #IP_string = "SRTClient:default -h " + IP base = ic.stringToProxy(IP_string) if IP_string.startswith('SRT'): controller = SRTClient.ClientPrx.checkedCast(base) print time.strftime( '%Y-%m-%d %H:%M:%S', time.localtime()) + " Connecting to SRT Client" if IP_string.startswith('SH'): controller = SHControl.SignalHoundPrx.checkedCast(base) print time.strftime( '%Y-%m-%d %H:%M:%S', time.localtime()) + " Connecting to Signal hound Client" controller.begin_message("connected to client", self.genericCB, self.failureCB) #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 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) init.threadHook = ThreadHook() init.threadStart = init.threadHook.threadStart init.threadStop = init.threadHook.threadStop # # Initialize a new communicator. # communicator = Ice.initialize(init) proxy = current.adapter.addWithUUID( RemoteCommunicatorI(communicator, init.threadHook)) return Test.RemoteCommunicatorPrx.uncheckedCast(proxy)
def __init__(self, host_address, host_port): self.host_address = host_address self.host_port = host_port ice_props = Ice.createProperties() ice_props.setProperty("Ice.ACM.Close", "0") # CloseOff # Heartbeat is sent by the server side. ice_props.setProperty("Ice.ACM.Heartbeat", "0") # HeartbeatOff ice_props.setProperty("Ice.MessageSizeMax", "20000") # 20MB ice_init_data = Ice.InitializationData() ice_init_data.properties = ice_props self.ic = Ice.initialize(ice_init_data) self.host: DeviceRepo = DeviceRepo.checkedCast( self.ic.stringToProxy(f"DeviceRepo:tcp -h {self.host_address} " f"-p {self.host_port}")) self.host.ice_ping() self.id_prx_map = {}
def connect(self, ip='127.0.0.1', port=6502): init_data = Ice.InitializationData() init_data.properties = Ice.createProperties(sys.argv) init_data.properties.setProperty('Ice.ImplicitContext', 'Shared') init_data.logger = Logger() self.__ice = Ice.initialize(init_data) if self.secret: self.__ice.getImplicitContext().put('secret', self.secret) self.__adapter = self.__ice.createObjectAdapterWithEndpoints( 'Callback.Client', 'tcp -h 127.0.0.1') self.__adapter.activate() proxy = self.__ice.stringToProxy('Meta:tcp -h %s -p %d' % (ip, port)) self._load_slice(proxy) import Murmur self.__meta = Murmur.MetaPrx.checkedCast(proxy)