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 __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 _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 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 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)
