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)])
batch = Test.MyClassPrx.uncheckedCast(p.ice_batchOneway())
batch.end_ice_flushBatchRequests(
batch.begin_ice_flushBatchRequests()) # Empty flush
test(batch.begin_ice_flushBatchRequests().isSent()) # Empty flush
test(batch.begin_ice_flushBatchRequests().isCompleted()) # Empty flush
test(batch.begin_ice_flushBatchRequests().sentSynchronously()
) # Empty flush
for i in range(30):
batch.begin_opByteSOneway(bs1, lambda: 0, lambda ex: test(False))
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.end_ice_ping(batch1.begin_ice_ping())
batch2.end_ice_ping(batch2.begin_ice_ping())
batch1.end_ice_flushBatchRequests(
batch1.begin_ice_flushBatchRequests())
batch1.ice_getConnection().close(
Ice.ConnectionClose.GracefullyWithWait)
batch1.end_ice_ping(batch1.begin_ice_ping())
batch2.end_ice_ping(batch2.begin_ice_ping())
batch1.ice_getConnection()
batch2.ice_getConnection()
batch1.ice_getConnection().close(
Ice.ConnectionClose.GracefullyWithWait)
batch1.end_ice_ping(batch1.begin_ice_ping())
batch2.end_ice_ping(batch2.begin_ice_ping())
identity = Ice.Identity()
identity.name = "invalid"
batch3 = batch.ice_identity(identity)
batch3.ice_ping()
batch3.end_ice_flushBatchRequests(batch3.begin_ice_flushBatchRequests())
# Make sure that a bogus batch request doesn't cause troubles to other ones.
batch3.ice_ping()
batch.ice_ping()
batch.end_ice_flushBatchRequests(batch.begin_ice_flushBatchRequests())
batch.ice_ping()
def __init__(self,
ctx,
file_obj,
factory,
storage,
uuid="unknown",
call_context=None,
adapter=None):
self.id = Ice.Identity()
self.id.name = uuid
self.uuid = uuid
self.file_obj = file_obj
self.factory = factory
self.storage = storage
self.call_context = call_context
self.adapter = adapter
self.can_write = factory.getAdminService().canUpdate(
file_obj, call_context)
omero.util.SimpleServant.__init__(self, ctx)
self.stamp = time.time()
self.storage.incr(self)
self._closed = False
if (not self.file_obj.isLoaded() or self.file_obj.getDetails() is None
or self.file_obj.details.group is None):
self.file_obj = self.ctx.getSession().getQueryService().get(
'omero.model.OriginalFileI', unwrap(file_obj.id),
{"omero.group": "-1"})
def run(self, argv):
status = 0
ic = self.communicator()
if (not ic):
return
pylog4cxx.configure()
logger = pylog4cxx.Logger("cast.server.python.ComponentServer", "", "")
logger.info("Python server version: \"%s\"" %
(cast.cdl.CASTRELEASESTRING))
portArgs = "tcp -p %d" % cast.cdl.PYTHONSERVERPORT
adapter = ic.createObjectAdapterWithEndpoints("ComponentServer3",
portArgs)
idty = Ice.Identity()
idty.name = "ComponentFactory"
idty.category = "ComponentFactory"
factory = CASTComponentFactory()
adapter.add(factory, idty)
adapter.activate()
# logger.trace("Python Server Running...")
ic.waitForShutdown()
def xtest_createLocalMirror(self):
print('createLocalMirror')
dataRoot = cvac.DirectoryPath( "corpus" );
corpusConfigFile = cvac.FilePath( dataRoot, "CvacCorpusTest.properties" )
corpus = self.cs.openCorpus( corpusConfigFile )
if not corpus:
raise RuntimeError("could not open corpus from config file at '"
+dataRoot.relativePath+"/"+corpusConfigFile.filename+"'")
adapter = self.ic.createObjectAdapter("")
ident = Ice.Identity()
ident.name = IcePy.generateUUID()
ident.category = ""
# adapter.add( self, ident )
adapter.add( TestCorpusCallback(), ident )
adapter.activate()
# adapter = self.ic.createObjectAdapter("CorpusServer")
# adapter.add( TestCorpusCallback(), ic.stringToIdentity("CorpusServer:default -p 10011"))
# adapter.activate()
# receiver = cvac.CorpusCallbackPrx.uncheckedCast(
# adapter.createProxy( self.ic.stringToIdentity("callbackReceiver")))
self.cs.createLocalMirror( corpus, ident )
if not self.cs.localMirrorExists( corpus ):
raise RuntimeError( "could not create local mirror for",
corpusConfigFile.filename )
def getTable(self, file_obj, factory, current=None):
"""
Create and/or register a table servant.
"""
# Will throw an exception if not allowed.
file_id = None
if file_obj is not None and file_obj.id is not None:
file_id = file_obj.id.val
self.logger.info("getTable: %s %s", file_id, current.ctx)
file_path = self.repo_mgr.getFilePath(file_obj)
p = path(file_path).dirname()
if not p.exists():
p.makedirs()
storage = self._storage_factory.getOrCreate(file_path, self.read_only)
id = Ice.Identity()
id.name = Ice.generateUUID()
table = TableI(self.ctx, file_obj, factory, storage, uuid=id.name,
call_context=current.ctx)
self.resources.add(table)
prx = current.adapter.add(table, id)
return self._table_cast(prx)
def __init__(self):
super(Client, self).__init__()
self._session_prx = None
self.agent_receiver_ice_ident = Ice.Identity()
self.agent_receiver_ice_ident.category = "RPCChannel"
self.agent_receiver_ice_ident.name = Ice.generateUUID()
self.agent_receiver_adapter = None
self.agent_receiver = AgentReceiverI(self)
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)])
batch = Test.MyClassPrx.uncheckedCast(p.ice_batchOneway())
f = batch.ice_flushBatchRequestsAsync() # Empty flush
f.result()
test(batch.ice_flushBatchRequestsAsync().is_sent()) # Empty flush
test(batch.ice_flushBatchRequestsAsync().done()) # Empty flush
test(batch.ice_flushBatchRequestsAsync().sent_synchronously()) # Empty flush
for i in range(30):
batch.opByteSOnewayAsync(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_pingAsync()
batch2.ice_pingAsync()
batch1.ice_flushBatchRequestsAsync().result()
batch1.ice_getConnection().close(False)
batch1.ice_pingAsync()
batch2.ice_pingAsync()
batch1.ice_getConnection()
batch2.ice_getConnection()
batch1.ice_getConnection().close(False)
test(not batch1.ice_pingAsync().done())
test(not batch2.ice_pingAsync().done())
identity = Ice.Identity()
identity.name = "invalid";
batch3 = batch.ice_identity(identity)
batch3.ice_ping()
batch3.ice_flushBatchRequestsAsync().result()
# Make sure that a bogus batch request doesn't cause troubles to other ones.
batch3.ice_ping()
batch.ice_ping()
batch.ice_flushBatchRequestsAsync().result()
batch.ice_ping()
def __init__(self, adapter_or_client, handle, poll=True):
self.event = omero.util.concurrency.get_event(name="DeleteCallbackI")
self.result = None
self.poll = poll
self.handle = handle
self.adapter = adapter_or_client
self.id = Ice.Identity(str(uuid.uuid4()), "DeleteHandleCallback")
if not isinstance(self.adapter, Ice.ObjectAdapter):
self.adapter = self.adapter.adapter
def run(self, argv):
rtFile = self.communicator().getProperties().getPropertyWithDefault(
"RoutingTable", "RTABLE")
self.router.getRoutingTable().load(rtFile)
self.router.pox = pox.PacketInjectorPrx.checkedCast(
self.communicator().propertyToProxy(
"SimpleRouter.Proxy").ice_twoway())
if not self.router.pox:
log.error(
"ERROR: Cannot connect to POX controller or invalid configuration of the controller"
)
return -1
ifFile = self.communicator().getProperties().getPropertyWithDefault(
"Ifconfig", "IP_CONFIG")
self.router.loadIfconfig(ifFile)
adapter = self.communicator().createObjectAdapter("")
ident = Ice.Identity()
ident.name = Ice.generateUUID()
ident.category = ""
adapter.add(PacketHandler(self.router), ident)
adapter.activate()
self.router.pox.ice_getConnection().setAdapter(adapter)
self.router.pox.addPacketHandler(ident)
ifaces = self.router.pox.getIfaces()
self.router.reset(ifaces)
def poxPinger(self):
while not self.shouldStop:
time.sleep(1)
try:
self.router.pox.ice_ping()
except:
print("Connection to POX service broken, exiting...",
file=sys.stderr)
self.communicator().shutdown()
self.shouldStop = False
checkThread = threading.Thread(target=poxPinger, args=(self, ))
checkThread.start()
testAdapter = self.communicator().createObjectAdapterWithEndpoints(
"Tester", "tcp -p 65500")
testAdapter.add(Tester(self.router),
self.communicator().stringToIdentity("Tester"))
testAdapter.activate()
self.communicator().waitForShutdown()
self.shouldStop = True
self.router.arpCache.stop()
checkThread.join()
return 0
def newComponent(self, id, type, newProcess, current):
#print "Creating new", type
component = self._createBase(type)
tmp = Ice.Identity(id, type)
component.setID(id, None)
component.setObjectAdapter(current.adapter)
component.setIceID(tmp)
base = current.adapter.add(component, tmp)
prx = cast.interfaces.CASTComponentPrx.uncheckedCast(base)
return prx
def __init__(self, communicator, name, parent):
self._name = name
self._parent = parent
self.lines = []
assert (self._parent != None)
# Create an identity
#
self._id = Ice.Identity()
self._id.name = Ice.generateUUID()
def __init__(self, adapter_or_client, process, poll=True, category=None):
self.event = omero.util.concurrency.get_event(name="ProcessCallbackI")
self.result = None
self.poll = poll
self.process = process
self.adapter, self.category = \
adapter_and_category(adapter_or_client, category)
self.id = Ice.Identity(str(uuid.uuid4()), self.category)
self.prx = self.adapter.add(self, self.id) # OK ADAPTER USAGE
self.prx = omero.grid.ProcessCallbackPrx.uncheckedCast(self.prx)
process.registerCallback(self.prx)
def __init__(self, hosts):
self._hosts = hosts
myID = Ice.Identity()
myID.name = "Backend"
# Add the identity to the object adapter
self._adapter.add(self, myID)
# Create a proxy for the new node and
# add it as a child to the parent
#
thisNode = Matcloud.BackendPrx.uncheckedCast(
self._adapter.createProxy(myID))
def __init__(self, communicator, name, parent):
self._name = name
self._parent = parent
self._contents = []
# Create an identity. The root directory has the fixed identity "RootDir"
#
self._id = Ice.Identity()
if self._parent:
self._id.name = Ice.generateUUID()
else:
self._id.name = "RootDir"
def activate(self, a):
#
# Create an identity. The root directory has the fixed identity "RootDir"
#
id = Ice.Identity()
if self._parent:
id.name = Ice.generateUUID()
else:
id.name = "RootDir"
thisNode = Filesystem.NodePrx.uncheckedCast(a.add(self, id))
if self._parent:
self._parent.addChild(thisNode)
def __init__(self, ip_string, client_type, userlevel, reporter=None):
"""
@param ip_string IP string, which is retrieved from current.con.toString().
@param client_type Type of client that this is.
@param userlevel How powerful this user is.
@param reporter Optional reporter function for debug output.
"""
self.ip = ip_string
self.type = client_type
self.userlevel = userlevel
self.reporter = reporter
self.last_action = time()
self.id = Ice.Identity()
self.ingame = False
self.server = None
def __init__(self, host):
self._hosts = host
#self._client = {}
self._mutex = threading.Lock()
self.unmap = {}
myID = Ice.Identity()
myID.name = "Frontend"
# Add the identity to the object adapter
#
self._adapter.add(self, myID)
# Create a proxy for the new node and
# add it as a child to the parent
#
thisNode = Matcloud.FrontendPrx.uncheckedCast(
self._adapter.createProxy(myID))
def usermode_processor(client,
serverid="UsermodeProcessor",
cfg=None,
accepts_list=None,
stop_event=None,
omero_home=path.getcwd()):
"""
Creates and activates a usermode processor for the given client.
It is the responsibility of the client to call "cleanup()" on
the ProcessorI implementation which is returned.
cfg is the path to an --Ice.Config-valid file or files. If none
is given, the value of ICE_CONFIG will be taken from the environment
if available. Otherwise, all properties will be taken from the client
instance.
accepts_list is the list of IObject instances which will be passed to
omero.api.IScripts.validateScript. If none is given, only the current
Experimenter's own object will be passed.
stop_event is an threading.Event. One will be acquired from
omero.util.concurrency.get_event if none is provided.
"""
if cfg is None:
cfg = os.environ.get("ICE_CONFIG")
if accepts_list is None:
uid = client.sf.getAdminService().getEventContext().userId
accepts_list = [omero.model.ExperimenterI(uid, False)]
if stop_event is None:
stop_event = omero.util.concurrency.get_event(name="UsermodeProcessor")
id = Ice.Identity()
id.name = "%s-%s" % (serverid, uuid.uuid4())
id.category = client.getCategory()
ctx = omero.util.ServerContext(serverid, client.ic, stop_event)
impl = omero.processor.ProcessorI(ctx,
use_session=client.sf,
accepts_list=accepts_list,
cfg=cfg,
omero_home=omero_home,
category=id.category)
ctx.add_servant(client.adapter, impl, ice_identity=id)
return impl
def run(self, argv):
broker = self.communicator()
servant = PrinterI()
identity = Ice.Identity(Ice.generateUUID())
adapter = broker.createObjectAdapter("")
adapter.add(servant, identity)
adapter.activate()
proxy = broker.stringToProxy(argv[1])
server = Example.CallbackPrx.checkedCast(proxy)
server.ice_getConnection().setAdapter(adapter)
server.attach(identity)
self.communicator().waitForShutdown()
return 0
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 run(self, args):
if len(args) > 1:
print(self.appName() + ": too many arguments")
return 1
server = Demo.CallbackSenderPrx.checkedCast(self.communicator().propertyToProxy('CallbackSender.Proxy'))
if not server:
print(self.appName() + ": invalid proxy")
return 1
adapter = self.communicator().createObjectAdapter("")
ident = Ice.Identity()
ident.name = Ice.generateUUID()
ident.category = ""
adapter.add(CallbackReceiverI(), ident)
adapter.activate()
server.ice_getConnection().setAdapter(adapter)
server.addClient(ident)
self.communicator().waitForShutdown()
return 0
def __init__(self, adapter_or_client, handle, category=None):
if adapter_or_client is None:
raise omero.ClientError("Null client")
if handle is None:
raise omero.ClientError("Null handle")
self.event = omero.util.concurrency.get_event(name="CmdCallbackI")
self.state = (None, None) # (Response, Status)
self.handle = handle
self.adapter, self.category = \
adapter_and_category(adapter_or_client, category)
self.id = Ice.Identity(str(uuid.uuid4()), self.category)
self.prx = self.adapter.add(self, self.id) # OK ADAPTER USAGE
self.prx = omero.cmd.CmdCallbackPrx.uncheckedCast(self.prx)
handle.addCallback(self.prx)
# Now check just in case the process exited VERY quickly
self.poll()
def run (self, argv):
"""Ejecuci�n del c�digo asociado al renderAgent"""
self.shutdownOnInterrupt()
# Conexión con Glacier2.
router = Glacier2.RouterPrx.checkedCast(self.communicator().getDefaultRouter())
session = router.createSession('david', 'david')
self.obtainServiceRoot()
self.getBasicServices()
self.addRenderService('render', TYPEOFSERVICE)
# Subscripci�n al DirectoryFacilitator.
self.subscribeDF()
### ACCIONES ESPECÍFICAS.
self.obtainProxies()
# Informar del tiempo de ejecuci�n del benchmark.
self.notifyBenchmarkValue()
### FIN ACCIONES ESPECÍFICAS.
# Subscripci�n al Master.
oa = self.communicator().createObjectAdapter('MyAdapter')
ident = Ice.Identity()
ident.name = Ice.generateUUID()
ident.category = router.getServerProxy().ice_getIdentity().category
prx = MASYRO.RenderAgentPrx.uncheckedCast(oa.add(self, ident))
self.subscribeMaster(prx)
self.communicator().waitForShutdown()
# Baja del DirectoryFacilitator y del AMS.
self.deregister()
self.unsubscribeDF()
# Eliminaci�n de la subscripci�n al Master.
self.unsubscribeMaster()
# Limpieza de recursos.
self.clear()
return 0
def __init__(self,
adapter_or_client,
handle,
category=None,
foreground_poll=True):
if adapter_or_client is None:
raise omero.ClientError("Null client")
if handle is None:
raise omero.ClientError("Null handle")
self.event = omero.util.concurrency.get_event(name="CmdCallbackI")
self.state = (None, None) # (Response, Status)
self.handle = handle
self.adapter, self.category = \
adapter_and_category(adapter_or_client, category)
self.id = Ice.Identity(native_str(uuid.uuid4()), self.category)
self.prx = self.adapter.add(self, self.id) # OK ADAPTER USAGE
self.prx = omero.cmd.CmdCallbackPrx.uncheckedCast(self.prx)
handle.addCallback(self.prx)
self.initialPoll(foreground_poll)
def xtest_openCorpusLabelMe(self):
print('openCorpusLabelMe')
dataRoot = cvac.DirectoryPath( "corpus" );
corpusConfigFile = cvac.FilePath( dataRoot, "LabelMeCarsTest.properties" )
# corpusConfigFile = cvac.FilePath( dataRoot, "NpsVisionLabelMe.properties" )
corpus = self.cs.openCorpus( corpusConfigFile )
if not corpus:
raise RuntimeError("could not open corpus from config file at '"
+dataRoot.relativePath+"/"+corpusConfigFile.filename+"'"+"\n"
+"Did you build CVAC with BUILD_LABELME_CORPUS=ON?")
adapter = self.ic.createObjectAdapter("")
ident = Ice.Identity()
ident.name = IcePy.generateUUID()
ident.category = ""
adapter.add( TestCorpusCallback(), ident )
adapter.activate()
self.cs.createLocalMirror( corpus, ident )
labels = self.cs.getDataSet( corpus )
if not labels:
raise RuntimeError("could not obtain labels from Corpus '"
+corpus.name+"'")
def allTests(communicator, collocated):
sys.stdout.write("testing stringToProxy... ")
sys.stdout.flush()
#
# Test nil proxies.
#
p = communicator.stringToProxy('')
test(p == None)
p = communicator.propertyToProxy('bogus')
test(p == None)
ref = "test:default -p 12010"
base = communicator.stringToProxy(ref)
test(base)
b1 = communicator.stringToProxy("test")
test(b1.ice_getIdentity().name == "test" and len(b1.ice_getIdentity().category) == 0 and \
len(b1.ice_getAdapterId()) == 0 and len(b1.ice_getFacet()) == 0)
b1 = communicator.stringToProxy("test ")
test(b1.ice_getIdentity().name == "test" and len(b1.ice_getIdentity().category) == 0 and \
len(b1.ice_getFacet()) == 0)
b1 = communicator.stringToProxy(" test ")
test(b1.ice_getIdentity().name == "test" and len(b1.ice_getIdentity().category) == 0 and \
len(b1.ice_getFacet()) == 0)
b1 = communicator.stringToProxy(" test")
test(b1.ice_getIdentity().name == "test" and len(b1.ice_getIdentity().category) == 0 and \
len(b1.ice_getFacet()) == 0)
b1 = communicator.stringToProxy("'test -f facet'")
test(b1.ice_getIdentity().name == "test -f facet" and len(b1.ice_getIdentity().category) == 0 and \
len(b1.ice_getFacet()) == 0)
try:
b1 = communicator.stringToProxy("\"test -f facet'")
test(False)
except Ice.ProxyParseException:
pass
b1 = communicator.stringToProxy("\"test -f facet\"")
test(b1.ice_getIdentity().name == "test -f facet" and len(b1.ice_getIdentity().category) == 0 and \
len(b1.ice_getFacet()) == 0)
b1 = communicator.stringToProxy("\"test -f facet@test\"")
test(b1.ice_getIdentity().name == "test -f facet@test" and len(b1.ice_getIdentity().category) == 0 and \
len(b1.ice_getFacet()) == 0)
b1 = communicator.stringToProxy("\"test -f facet@test @test\"")
test(b1.ice_getIdentity().name == "test -f facet@test @test" and len(b1.ice_getIdentity().category) == 0 and \
len(b1.ice_getFacet()) == 0)
try:
b1 = communicator.stringToProxy("test test")
test(False)
except Ice.ProxyParseException:
pass
b1 = communicator.stringToProxy("test\\040test")
test(b1.ice_getIdentity().name == "test test"
and len(b1.ice_getIdentity().category) == 0)
try:
b1 = communicator.stringToProxy("test\\777")
test(False)
except Ice.IdentityParseException:
pass
b1 = communicator.stringToProxy("test\\40test")
test(b1.ice_getIdentity().name == "test test")
# Test some octal and hex corner cases.
b1 = communicator.stringToProxy("test\\4test")
test(b1.ice_getIdentity().name == "test\4test")
b1 = communicator.stringToProxy("test\\04test")
test(b1.ice_getIdentity().name == "test\4test")
b1 = communicator.stringToProxy("test\\004test")
test(b1.ice_getIdentity().name == "test\4test")
b1 = communicator.stringToProxy("test\\1114test")
test(b1.ice_getIdentity().name == "test\1114test")
b1 = communicator.stringToProxy("test\\b\\f\\n\\r\\t\\'\\\"\\\\test")
test(b1.ice_getIdentity().name == "test\b\f\n\r\t\'\"\\test"
and len(b1.ice_getIdentity().category) == 0)
b1 = communicator.stringToProxy("category/test")
test(b1.ice_getIdentity().name == "test" and b1.ice_getIdentity().category == "category" and \
len(b1.ice_getAdapterId()) == 0)
b1 = communicator.stringToProxy("test@adapter")
test(b1.ice_getIdentity().name == "test" and len(b1.ice_getIdentity().category) == 0 and \
b1.ice_getAdapterId() == "adapter")
try:
b1 = communicator.stringToProxy("id@adapter test")
test(False)
except Ice.ProxyParseException:
pass
b1 = communicator.stringToProxy("category/test@adapter")
test(b1.ice_getIdentity().name == "test" and b1.ice_getIdentity().category == "category" and \
b1.ice_getAdapterId() == "adapter")
b1 = communicator.stringToProxy("category/test@adapter:tcp")
test(b1.ice_getIdentity().name == "test" and b1.ice_getIdentity().category == "category" and \
b1.ice_getAdapterId() == "adapter:tcp")
b1 = communicator.stringToProxy("'category 1/test'@adapter")
test(b1.ice_getIdentity().name == "test" and b1.ice_getIdentity().category == "category 1" and \
b1.ice_getAdapterId() == "adapter")
b1 = communicator.stringToProxy("'category/test 1'@adapter")
test(b1.ice_getIdentity().name == "test 1" and b1.ice_getIdentity().category == "category" and \
b1.ice_getAdapterId() == "adapter")
b1 = communicator.stringToProxy("'category/test'@'adapter 1'")
test(b1.ice_getIdentity().name == "test" and b1.ice_getIdentity().category == "category" and \
b1.ice_getAdapterId() == "adapter 1")
b1 = communicator.stringToProxy("\"category \\/test@foo/test\"@adapter")
test(b1.ice_getIdentity().name == "test" and b1.ice_getIdentity().category == "category /test@foo" and \
b1.ice_getAdapterId() == "adapter")
b1 = communicator.stringToProxy(
"\"category \\/test@foo/test\"@\"adapter:tcp\"")
test(b1.ice_getIdentity().name == "test" and b1.ice_getIdentity().category == "category /test@foo" and \
b1.ice_getAdapterId() == "adapter:tcp")
b1 = communicator.stringToProxy("id -f facet")
test(b1.ice_getIdentity().name == "id" and len(b1.ice_getIdentity().category) == 0 and \
b1.ice_getFacet() == "facet")
b1 = communicator.stringToProxy("id -f 'facet x'")
test(b1.ice_getIdentity().name == "id" and len(b1.ice_getIdentity().category) == 0 and \
b1.ice_getFacet() == "facet x")
b1 = communicator.stringToProxy("id -f \"facet x\"")
test(b1.ice_getIdentity().name == "id" and len(b1.ice_getIdentity().category) == 0 and \
b1.ice_getFacet() == "facet x")
try:
b1 = communicator.stringToProxy("id -f \"facet x")
test(False)
except Ice.ProxyParseException:
pass
try:
b1 = communicator.stringToProxy("id -f \'facet x")
test(False)
except Ice.ProxyParseException:
pass
b1 = communicator.stringToProxy("test -f facet:tcp")
test(b1.ice_getIdentity().name == "test" and len(b1.ice_getIdentity().category) == 0 and \
b1.ice_getFacet() == "facet" and len(b1.ice_getAdapterId()) == 0)
b1 = communicator.stringToProxy("test -f \"facet:tcp\"")
test(b1.ice_getIdentity().name == "test" and len(b1.ice_getIdentity().category) == 0 and \
b1.ice_getFacet() == "facet:tcp" and len(b1.ice_getAdapterId()) == 0)
b1 = communicator.stringToProxy("test -f facet@test")
test(b1.ice_getIdentity().name == "test" and len(b1.ice_getIdentity().category) == 0 and \
b1.ice_getFacet() == "facet" and b1.ice_getAdapterId() == "test")
b1 = communicator.stringToProxy("test -f 'facet@test'")
test(b1.ice_getIdentity().name == "test" and len(b1.ice_getIdentity().category) == 0 and \
b1.ice_getFacet() == "facet@test" and len(b1.ice_getAdapterId()) == 0)
b1 = communicator.stringToProxy("test -f 'facet@test'@test")
test(b1.ice_getIdentity().name == "test" and len(b1.ice_getIdentity().category) == 0 and \
b1.ice_getFacet() == "facet@test" and b1.ice_getAdapterId() == "test")
try:
b1 = communicator.stringToProxy("test -f facet@test @test")
test(False)
except Ice.ProxyParseException:
pass
b1 = communicator.stringToProxy("test")
test(b1.ice_isTwoway())
b1 = communicator.stringToProxy("test -t")
test(b1.ice_isTwoway())
b1 = communicator.stringToProxy("test -o")
test(b1.ice_isOneway())
b1 = communicator.stringToProxy("test -O")
test(b1.ice_isBatchOneway())
b1 = communicator.stringToProxy("test -d")
test(b1.ice_isDatagram())
b1 = communicator.stringToProxy("test -D")
test(b1.ice_isBatchDatagram())
b1 = communicator.stringToProxy("test")
test(not b1.ice_isSecure())
b1 = communicator.stringToProxy("test -s")
test(b1.ice_isSecure())
try:
b1 = communicator.stringToProxy("test:tcp@adapterId")
test(False)
except Ice.EndpointParseException:
pass
# This is an unknown endpoint warning, not a parse exception.
#
#try:
# b1 = communicator.stringToProxy("test -f the:facet:tcp")
# test(False)
#except Ice.EndpointParseException:
# pass
try:
b1 = communicator.stringToProxy("test::tcp")
test(False)
except Ice.EndpointParseException:
pass
print("ok")
sys.stdout.write("testing propertyToProxy... ")
sys.stdout.flush()
prop = communicator.getProperties()
propertyPrefix = "Foo.Proxy"
prop.setProperty(propertyPrefix, "test:default -p 12010")
b1 = communicator.propertyToProxy(propertyPrefix)
test(b1.ice_getIdentity().name == "test" and len(b1.ice_getIdentity().category) == 0 and \
len(b1.ice_getAdapterId()) == 0 and len(b1.ice_getFacet()) == 0)
property = propertyPrefix + ".Locator"
test(not b1.ice_getLocator())
prop.setProperty(property, "locator:default -p 10000")
b1 = communicator.propertyToProxy(propertyPrefix)
test(b1.ice_getLocator()
and b1.ice_getLocator().ice_getIdentity().name == "locator")
prop.setProperty(property, "")
property = propertyPrefix + ".LocatorCacheTimeout"
test(b1.ice_getLocatorCacheTimeout() == -1)
prop.setProperty(property, "1")
b1 = communicator.propertyToProxy(propertyPrefix)
test(b1.ice_getLocatorCacheTimeout() == 1)
prop.setProperty(property, "")
# Now retest with an indirect proxy.
prop.setProperty(propertyPrefix, "test")
property = propertyPrefix + ".Locator"
prop.setProperty(property, "locator:default -p 10000")
b1 = communicator.propertyToProxy(propertyPrefix)
test(b1.ice_getLocator()
and b1.ice_getLocator().ice_getIdentity().name == "locator")
prop.setProperty(property, "")
property = propertyPrefix + ".LocatorCacheTimeout"
test(b1.ice_getLocatorCacheTimeout() == -1)
prop.setProperty(property, "1")
b1 = communicator.propertyToProxy(propertyPrefix)
test(b1.ice_getLocatorCacheTimeout() == 1)
prop.setProperty(property, "")
# This cannot be tested so easily because the property is cached
# on communicator initialization.
#
#prop.setProperty("Ice.Default.LocatorCacheTimeout", "60")
#b1 = communicator.propertyToProxy(propertyPrefix)
#test(b1.ice_getLocatorCacheTimeout() == 60)
#prop.setProperty("Ice.Default.LocatorCacheTimeout", "")
prop.setProperty(propertyPrefix, "test:default -p 12010")
property = propertyPrefix + ".Router"
test(not b1.ice_getRouter())
prop.setProperty(property, "router:default -p 10000")
b1 = communicator.propertyToProxy(propertyPrefix)
test(b1.ice_getRouter()
and b1.ice_getRouter().ice_getIdentity().name == "router")
prop.setProperty(property, "")
property = propertyPrefix + ".PreferSecure"
test(not b1.ice_isPreferSecure())
prop.setProperty(property, "1")
b1 = communicator.propertyToProxy(propertyPrefix)
test(b1.ice_isPreferSecure())
prop.setProperty(property, "")
property = propertyPrefix + ".ConnectionCached"
test(b1.ice_isConnectionCached())
prop.setProperty(property, "0")
b1 = communicator.propertyToProxy(propertyPrefix)
test(not b1.ice_isConnectionCached())
prop.setProperty(property, "")
property = propertyPrefix + ".InvocationTimeout"
test(b1.ice_getInvocationTimeout() == -1)
prop.setProperty(property, "1000")
b1 = communicator.propertyToProxy(propertyPrefix)
test(b1.ice_getInvocationTimeout() == 1000)
prop.setProperty(property, "")
property = propertyPrefix + ".EndpointSelection"
test(b1.ice_getEndpointSelection() == Ice.EndpointSelectionType.Random)
prop.setProperty(property, "Random")
b1 = communicator.propertyToProxy(propertyPrefix)
test(b1.ice_getEndpointSelection() == Ice.EndpointSelectionType.Random)
prop.setProperty(property, "Ordered")
b1 = communicator.propertyToProxy(propertyPrefix)
test(b1.ice_getEndpointSelection() == Ice.EndpointSelectionType.Ordered)
prop.setProperty(property, "")
property = propertyPrefix + ".CollocationOptimized"
test(b1.ice_isCollocationOptimized())
prop.setProperty(property, "0")
b1 = communicator.propertyToProxy(propertyPrefix)
test(not b1.ice_isCollocationOptimized())
prop.setProperty(property, "")
print("ok")
sys.stdout.write("testing proxyToProperty... ")
sys.stdout.flush()
b1 = communicator.stringToProxy("test")
b1 = b1.ice_collocationOptimized(True)
b1 = b1.ice_connectionCached(True)
b1 = b1.ice_preferSecure(False)
b1 = b1.ice_endpointSelection(Ice.EndpointSelectionType.Ordered)
b1 = b1.ice_locatorCacheTimeout(100)
b1 = b1.ice_invocationTimeout(1234)
b1 = b1.ice_encodingVersion(Ice.EncodingVersion(1, 0))
router = communicator.stringToProxy("router")
router = router.ice_collocationOptimized(False)
router = router.ice_connectionCached(True)
router = router.ice_preferSecure(True)
router = router.ice_endpointSelection(Ice.EndpointSelectionType.Random)
router = router.ice_locatorCacheTimeout(200)
router = router.ice_invocationTimeout(1500)
locator = communicator.stringToProxy("locator")
locator = locator.ice_collocationOptimized(True)
locator = locator.ice_connectionCached(False)
locator = locator.ice_preferSecure(True)
locator = locator.ice_endpointSelection(Ice.EndpointSelectionType.Random)
locator = locator.ice_locatorCacheTimeout(300)
locator = locator.ice_invocationTimeout(1500)
locator = locator.ice_router(Ice.RouterPrx.uncheckedCast(router))
b1 = b1.ice_locator(Ice.LocatorPrx.uncheckedCast(locator))
proxyProps = communicator.proxyToProperty(b1, "Test")
test(len(proxyProps) == 21)
test(proxyProps["Test"] == "test -t -e 1.0")
test(proxyProps["Test.CollocationOptimized"] == "1")
test(proxyProps["Test.ConnectionCached"] == "1")
test(proxyProps["Test.PreferSecure"] == "0")
test(proxyProps["Test.EndpointSelection"] == "Ordered")
test(proxyProps["Test.LocatorCacheTimeout"] == "100")
test(proxyProps["Test.InvocationTimeout"] == "1234")
test(proxyProps["Test.Locator"] == "locator -t -e " +
Ice.encodingVersionToString(Ice.currentEncoding()))
test(proxyProps["Test.Locator.CollocationOptimized"] == "1")
test(proxyProps["Test.Locator.ConnectionCached"] == "0")
test(proxyProps["Test.Locator.PreferSecure"] == "1")
test(proxyProps["Test.Locator.EndpointSelection"] == "Random")
test(proxyProps["Test.Locator.LocatorCacheTimeout"] == "300")
test(proxyProps["Test.Locator.InvocationTimeout"] == "1500")
test(proxyProps["Test.Locator.Router"] == "router -t -e " +
Ice.encodingVersionToString(Ice.currentEncoding()))
test(proxyProps["Test.Locator.Router.CollocationOptimized"] == "0")
test(proxyProps["Test.Locator.Router.ConnectionCached"] == "1")
test(proxyProps["Test.Locator.Router.PreferSecure"] == "1")
test(proxyProps["Test.Locator.Router.EndpointSelection"] == "Random")
test(proxyProps["Test.Locator.Router.LocatorCacheTimeout"] == "200")
test(proxyProps["Test.Locator.Router.InvocationTimeout"] == "1500")
print("ok")
sys.stdout.write("testing ice_getCommunicator... ")
sys.stdout.flush()
test(base.ice_getCommunicator() == communicator)
print("ok")
sys.stdout.write("testing proxy methods... ")
sys.stdout.flush()
test(communicator.identityToString(base.ice_identity(communicator.stringToIdentity("other")).ice_getIdentity()) \
== "other")
#
# Verify that ToStringMode is passed correctly
#
ident = Ice.Identity("test", "\x7F\xE2\x82\xAC")
idStr = Ice.identityToString(ident, Ice.ToStringMode.Unicode)
test(idStr == "\\u007f\xE2\x82\xAC/test")
ident2 = Ice.stringToIdentity(idStr)
test(ident == ident2)
test(Ice.identityToString(ident) == idStr)
idStr = Ice.identityToString(ident, Ice.ToStringMode.ASCII)
test(idStr == "\\u007f\\u20ac/test")
ident2 = Ice.stringToIdentity(idStr)
test(ident == ident2)
idStr = Ice.identityToString(ident, Ice.ToStringMode.Compat)
test(idStr == "\\177\\342\\202\\254/test")
ident2 = Ice.stringToIdentity(idStr)
test(ident == ident2)
ident2 = Ice.stringToIdentity(communicator.identityToString(ident))
test(ident == ident2)
test(base.ice_facet("facet").ice_getFacet() == "facet")
test(base.ice_adapterId("id").ice_getAdapterId() == "id")
test(base.ice_twoway().ice_isTwoway())
test(base.ice_oneway().ice_isOneway())
test(base.ice_batchOneway().ice_isBatchOneway())
test(base.ice_datagram().ice_isDatagram())
test(base.ice_batchDatagram().ice_isBatchDatagram())
test(base.ice_secure(True).ice_isSecure())
test(not base.ice_secure(False).ice_isSecure())
test(base.ice_collocationOptimized(True).ice_isCollocationOptimized())
test(not base.ice_collocationOptimized(False).ice_isCollocationOptimized())
test(base.ice_preferSecure(True).ice_isPreferSecure())
test(not base.ice_preferSecure(False).ice_isPreferSecure())
test(
base.ice_encodingVersion(Ice.Encoding_1_0).ice_getEncodingVersion() ==
Ice.Encoding_1_0)
test(
base.ice_encodingVersion(Ice.Encoding_1_1).ice_getEncodingVersion() ==
Ice.Encoding_1_1)
test(
base.ice_encodingVersion(Ice.Encoding_1_0).ice_getEncodingVersion() !=
Ice.Encoding_1_1)
try:
base.ice_timeout(0)
test(False)
except RuntimeError:
pass
try:
base.ice_timeout(-1)
except RuntimeError:
test(False)
try:
base.ice_timeout(-2)
test(False)
except RuntimeError:
pass
try:
base.ice_invocationTimeout(0)
test(False)
except RuntimeError:
pass
try:
base.ice_invocationTimeout(-1)
except RuntimeError:
test(False)
try:
base.ice_invocationTimeout(-2)
test(False)
except RuntimeError:
pass
try:
base.ice_locatorCacheTimeout(0)
except RuntimeError:
test(False)
try:
base.ice_locatorCacheTimeout(-1)
except RuntimeError:
test(False)
try:
base.ice_locatorCacheTimeout(-2)
test(False)
except RuntimeError:
pass
print("ok")
sys.stdout.write("testing proxy comparison... ")
sys.stdout.flush()
test(
communicator.stringToProxy("foo") == communicator.stringToProxy("foo"))
test(
communicator.stringToProxy("foo") != communicator.stringToProxy("foo2")
)
test(
communicator.stringToProxy("foo") < communicator.stringToProxy("foo2"))
test(not (communicator.stringToProxy("foo2") < communicator.stringToProxy(
"foo")))
compObj = communicator.stringToProxy("foo")
test(compObj.ice_facet("facet") == compObj.ice_facet("facet"))
test(compObj.ice_facet("facet") != compObj.ice_facet("facet1"))
test(compObj.ice_facet("facet") < compObj.ice_facet("facet1"))
test(not (compObj.ice_facet("facet") < compObj.ice_facet("facet")))
test(compObj.ice_oneway() == compObj.ice_oneway())
test(compObj.ice_oneway() != compObj.ice_twoway())
test(compObj.ice_twoway() < compObj.ice_oneway())
test(not (compObj.ice_oneway() < compObj.ice_twoway()))
test(compObj.ice_secure(True) == compObj.ice_secure(True))
test(compObj.ice_secure(False) != compObj.ice_secure(True))
test(compObj.ice_secure(False) < compObj.ice_secure(True))
test(not (compObj.ice_secure(True) < compObj.ice_secure(False)))
test(
compObj.ice_collocationOptimized(True) ==
compObj.ice_collocationOptimized(True))
test(
compObj.ice_collocationOptimized(False) !=
compObj.ice_collocationOptimized(True))
test(
compObj.ice_collocationOptimized(False) <
compObj.ice_collocationOptimized(True))
test(not (compObj.ice_collocationOptimized(True) <
compObj.ice_collocationOptimized(False)))
test(
compObj.ice_connectionCached(True) == compObj.ice_connectionCached(
True))
test(
compObj.ice_connectionCached(False) != compObj.ice_connectionCached(
True))
test(
compObj.ice_connectionCached(False) < compObj.ice_connectionCached(
True))
test(not (compObj.ice_connectionCached(True) <
compObj.ice_connectionCached(False)))
test(compObj.ice_endpointSelection(Ice.EndpointSelectionType.Random) == \
compObj.ice_endpointSelection(Ice.EndpointSelectionType.Random))
test(compObj.ice_endpointSelection(Ice.EndpointSelectionType.Random) != \
compObj.ice_endpointSelection(Ice.EndpointSelectionType.Ordered))
test(compObj.ice_endpointSelection(Ice.EndpointSelectionType.Random) < \
compObj.ice_endpointSelection(Ice.EndpointSelectionType.Ordered))
test(not (compObj.ice_endpointSelection(Ice.EndpointSelectionType.Ordered) < \
compObj.ice_endpointSelection(Ice.EndpointSelectionType.Random)))
test(compObj.ice_connectionId("id2") == compObj.ice_connectionId("id2"))
test(compObj.ice_connectionId("id1") != compObj.ice_connectionId("id2"))
test(compObj.ice_connectionId("id1") < compObj.ice_connectionId("id2"))
test(not (
compObj.ice_connectionId("id2") < compObj.ice_connectionId("id1")))
test(compObj.ice_connectionId("id1").ice_getConnectionId() == "id1")
test(compObj.ice_connectionId("id2").ice_getConnectionId() == "id2")
test(compObj.ice_compress(True) == compObj.ice_compress(True))
test(compObj.ice_compress(False) != compObj.ice_compress(True))
test(compObj.ice_compress(False) < compObj.ice_compress(True))
test(not (compObj.ice_compress(True) < compObj.ice_compress(False)))
test(compObj.ice_timeout(20) == compObj.ice_timeout(20))
test(compObj.ice_timeout(10) != compObj.ice_timeout(20))
test(compObj.ice_timeout(10) < compObj.ice_timeout(20))
test(not (compObj.ice_timeout(20) < compObj.ice_timeout(10)))
loc1 = Ice.LocatorPrx.uncheckedCast(
communicator.stringToProxy("loc1:default -p 10000"))
loc2 = Ice.LocatorPrx.uncheckedCast(
communicator.stringToProxy("loc2:default -p 10000"))
test(compObj.ice_locator(None) == compObj.ice_locator(None))
test(compObj.ice_locator(loc1) == compObj.ice_locator(loc1))
test(compObj.ice_locator(loc1) != compObj.ice_locator(None))
test(compObj.ice_locator(None) != compObj.ice_locator(loc2))
test(compObj.ice_locator(loc1) != compObj.ice_locator(loc2))
test(compObj.ice_locator(None) < compObj.ice_locator(loc1))
test(not (compObj.ice_locator(loc1) < compObj.ice_locator(None)))
test(compObj.ice_locator(loc1) < compObj.ice_locator(loc2))
test(not (compObj.ice_locator(loc2) < compObj.ice_locator(loc1)))
rtr1 = Ice.RouterPrx.uncheckedCast(
communicator.stringToProxy("rtr1:default -p 10000"))
rtr2 = Ice.RouterPrx.uncheckedCast(
communicator.stringToProxy("rtr2:default -p 10000"))
test(compObj.ice_router(None) == compObj.ice_router(None))
test(compObj.ice_router(rtr1) == compObj.ice_router(rtr1))
test(compObj.ice_router(rtr1) != compObj.ice_router(None))
test(compObj.ice_router(None) != compObj.ice_router(rtr2))
test(compObj.ice_router(rtr1) != compObj.ice_router(rtr2))
test(compObj.ice_router(None) < compObj.ice_router(rtr1))
test(not (compObj.ice_router(rtr1) < compObj.ice_router(None)))
test(compObj.ice_router(rtr1) < compObj.ice_router(rtr2))
test(not (compObj.ice_router(rtr2) < compObj.ice_router(rtr1)))
ctx1 = {}
ctx1["ctx1"] = "v1"
ctx2 = {}
ctx2["ctx2"] = "v2"
test(compObj.ice_context({}) == compObj.ice_context({}))
test(compObj.ice_context(ctx1) == compObj.ice_context(ctx1))
test(compObj.ice_context(ctx1) != compObj.ice_context({}))
test(compObj.ice_context({}) != compObj.ice_context(ctx2))
test(compObj.ice_context(ctx1) != compObj.ice_context(ctx2))
test(compObj.ice_context(ctx1) < compObj.ice_context(ctx2))
test(not (compObj.ice_context(ctx2) < compObj.ice_context(ctx1)))
test(compObj.ice_preferSecure(True) == compObj.ice_preferSecure(True))
test(compObj.ice_preferSecure(True) != compObj.ice_preferSecure(False))
test(compObj.ice_preferSecure(False) < compObj.ice_preferSecure(True))
test(not (
compObj.ice_preferSecure(True) < compObj.ice_preferSecure(False)))
compObj1 = communicator.stringToProxy("foo:tcp -h 127.0.0.1 -p 10000")
compObj2 = communicator.stringToProxy("foo:tcp -h 127.0.0.1 -p 10001")
test(compObj1 != compObj2)
test(compObj1 < compObj2)
test(not (compObj2 < compObj1))
compObj1 = communicator.stringToProxy("foo@MyAdapter1")
compObj2 = communicator.stringToProxy("foo@MyAdapter2")
test(compObj1 != compObj2)
test(compObj1 < compObj2)
test(not (compObj2 < compObj1))
test(
compObj1.ice_locatorCacheTimeout(20) ==
compObj1.ice_locatorCacheTimeout(20))
test(
compObj1.ice_locatorCacheTimeout(10) !=
compObj1.ice_locatorCacheTimeout(20))
test(
compObj1.ice_locatorCacheTimeout(10) <
compObj1.ice_locatorCacheTimeout(20))
test(not (compObj1.ice_locatorCacheTimeout(20) <
compObj1.ice_locatorCacheTimeout(10)))
test(
compObj1.ice_invocationTimeout(20) == compObj1.ice_invocationTimeout(
20))
test(
compObj1.ice_invocationTimeout(10) != compObj1.ice_invocationTimeout(
20))
test(
compObj1.ice_invocationTimeout(10) < compObj1.ice_invocationTimeout(20)
)
test(not (compObj1.ice_invocationTimeout(20) <
compObj1.ice_invocationTimeout(10)))
compObj1 = communicator.stringToProxy("foo:tcp -h 127.0.0.1 -p 1000")
compObj2 = communicator.stringToProxy("foo@MyAdapter1")
test(compObj1 != compObj2)
test(compObj1 < compObj2)
test(not (compObj2 < compObj1))
endpts1 = communicator.stringToProxy(
"foo:tcp -h 127.0.0.1 -p 10000").ice_getEndpoints()
endpts2 = communicator.stringToProxy(
"foo:tcp -h 127.0.0.1 -p 10001").ice_getEndpoints()
test(endpts1 != endpts2)
test(endpts1 < endpts2)
test(not (endpts2 < endpts1))
test(endpts1 == communicator.stringToProxy(
"foo:tcp -h 127.0.0.1 -p 10000").ice_getEndpoints())
test(
compObj1.ice_encodingVersion(Ice.Encoding_1_0) ==
compObj1.ice_encodingVersion(Ice.Encoding_1_0))
test(
compObj1.ice_encodingVersion(Ice.Encoding_1_0) !=
compObj1.ice_encodingVersion(Ice.Encoding_1_1))
test(
compObj.ice_encodingVersion(Ice.Encoding_1_0) <
compObj.ice_encodingVersion(Ice.Encoding_1_1))
test(not (compObj.ice_encodingVersion(Ice.Encoding_1_1) <
compObj.ice_encodingVersion(Ice.Encoding_1_0)))
#
# TODO: Ideally we should also test comparison of fixed proxies.
#
print("ok")
sys.stdout.write("testing checked cast... ")
sys.stdout.flush()
cl = Test.MyClassPrx.checkedCast(base)
test(cl)
derived = Test.MyDerivedClassPrx.checkedCast(cl)
test(derived)
test(cl == base)
test(derived == base)
test(cl == derived)
loc = Ice.LocatorPrx.checkedCast(base)
test(loc == None)
#
# Upcasting
#
cl2 = Test.MyClassPrx.checkedCast(derived)
obj = Ice.ObjectPrx.checkedCast(derived)
test(cl2)
test(obj)
test(cl2 == obj)
test(cl2 == derived)
print("ok")
sys.stdout.write("testing checked cast with context... ")
sys.stdout.flush()
tccp = Test.MyClassPrx.checkedCast(base)
c = tccp.getContext()
test(c == None or len(c) == 0)
c = {}
c["one"] = "hello"
c["two"] = "world"
tccp = Test.MyClassPrx.checkedCast(base, c)
c2 = tccp.getContext()
test(c == c2)
print("ok")
sys.stdout.write("testing encoding versioning... ")
sys.stdout.flush()
ref20 = "test -e 2.0:default -p 12010"
cl20 = Test.MyClassPrx.uncheckedCast(communicator.stringToProxy(ref20))
try:
cl20.ice_ping()
test(false)
except Ice.UnsupportedEncodingException:
# Server 2.0 endpoint doesn't support 1.1 version.
pass
ref10 = "test -e 1.0:default -p 12010"
cl10 = Test.MyClassPrx.uncheckedCast(communicator.stringToProxy(ref10))
cl10.ice_ping()
cl10.ice_encodingVersion(Ice.Encoding_1_0).ice_ping()
cl.ice_encodingVersion(Ice.Encoding_1_0).ice_ping()
# 1.3 isn't supported but since a 1.3 proxy supports 1.1, the
# call will use the 1.1 encoding
ref13 = "test -e 1.3:default -p 12010"
cl13 = Test.MyClassPrx.uncheckedCast(communicator.stringToProxy(ref13))
cl13.ice_ping()
print("ok")
sys.stdout.write("testing opaque endpoints... ")
sys.stdout.flush()
try:
# Invalid -x option
p = communicator.stringToProxy("id:opaque -t 99 -v abc -x abc")
test(False)
except Ice.EndpointParseException:
pass
try:
# Missing -t and -v
p = communicator.stringToProxy("id:opaque")
test(False)
except Ice.EndpointParseException:
pass
try:
# Repeated -t
p = communicator.stringToProxy("id:opaque -t 1 -t 1 -v abc")
test(False)
except Ice.EndpointParseException:
pass
try:
# Repeated -v
p = communicator.stringToProxy("id:opaque -t 1 -v abc -v abc")
test(False)
except Ice.EndpointParseException:
pass
try:
# Missing -t
p = communicator.stringToProxy("id:opaque -v abc")
test(False)
except Ice.EndpointParseException:
pass
try:
# Missing -v
p = communicator.stringToProxy("id:opaque -t 1")
test(False)
except Ice.EndpointParseException:
pass
try:
# Missing arg for -t
p = communicator.stringToProxy("id:opaque -t -v abc")
test(False)
except Ice.EndpointParseException:
pass
try:
# Missing arg for -v
p = communicator.stringToProxy("id:opaque -t 1 -v")
test(False)
except Ice.EndpointParseException:
pass
try:
# Not a number for -t
p = communicator.stringToProxy("id:opaque -t x -v abc")
test(False)
except Ice.EndpointParseException:
pass
try:
# < 0 for -t
p = communicator.stringToProxy("id:opaque -t -1 -v abc")
test(False)
except Ice.EndpointParseException:
pass
try:
# Invalid char for -v
p = communicator.stringToProxy("id:opaque -t 99 -v x?c")
test(False)
except Ice.EndpointParseException:
pass
# Legal TCP endpoint expressed as opaque endpoint
p1 = communicator.stringToProxy(
"test -e 1.1:opaque -t 1 -e 1.0 -v CTEyNy4wLjAuMeouAAAQJwAAAA==")
pstr = communicator.proxyToString(p1)
test(pstr == "test -t -e 1.1:tcp -h 127.0.0.1 -p 12010 -t 10000")
# Opaque endpoint encoded with 1.1 encoding.
p2 = communicator.stringToProxy(
"test -e 1.1:opaque -e 1.1 -t 1 -v CTEyNy4wLjAuMeouAAAQJwAAAA==")
test(
communicator.proxyToString(p2) ==
"test -t -e 1.1:tcp -h 127.0.0.1 -p 12010 -t 10000")
if communicator.getProperties().getPropertyAsInt("Ice.IPv6") == 0:
# Working?
ssl = communicator.getProperties().getProperty(
"Ice.Default.Protocol") == "ssl"
tcp = communicator.getProperties().getProperty(
"Ice.Default.Protocol") == "tcp"
if tcp:
p1.ice_encodingVersion(Ice.Encoding_1_0).ice_ping()
# Two legal TCP endpoints expressed as opaque endpoints
p1 = communicator.stringToProxy(
"test -e 1.0:opaque -t 1 -e 1.0 -v CTEyNy4wLjAuMeouAAAQJwAAAA==:opaque -t 1 -e 1.0 -v CTEyNy4wLjAuMusuAAAQJwAAAA=="
)
pstr = communicator.proxyToString(p1)
test(
pstr ==
"test -t -e 1.0:tcp -h 127.0.0.1 -p 12010 -t 10000:tcp -h 127.0.0.2 -p 12011 -t 10000"
)
#
# Test that an SSL endpoint and a nonsense endpoint get written
# back out as an opaque endpoint.
#
p1 = communicator.stringToProxy(
"test -e 1.0:opaque -t 2 -e 1.0 -v CTEyNy4wLjAuMREnAAD/////AA==:opaque -t 99 -e 1.0 -v abch"
)
pstr = communicator.proxyToString(p1)
if ssl:
test(
pstr ==
"test -t -e 1.0:ssl -h 127.0.0.1 -p 10001 -t infinite:opaque -t 99 -e 1.0 -v abch"
)
elif tcp:
test(
pstr ==
"test -t -e 1.0:opaque -t 2 -e 1.0 -v CTEyNy4wLjAuMREnAAD/////AA==:opaque -t 99 -e 1.0 -v abch"
)
#
# Try to invoke on the SSL endpoint to verify that we get a
# NoEndpointException (or ConnectionRefusedException when
# running with SSL).
#
try:
p1.ice_encodingVersion(Ice.Encoding_1_0).ice_ping()
test(False)
except Ice.NoEndpointException:
test(not ssl)
except Ice.ConnectFailedException:
test(not tcp)
#
# Test that the proxy with an SSL endpoint and a nonsense
# endpoint (which the server doesn't understand either) can be
# sent over the wire and returned by the server without losing
# the opaque endpoints.
#
p2 = derived.echo(p1)
pstr = communicator.proxyToString(p2)
if ssl:
test(
pstr ==
"test -t -e 1.0:ssl -h 127.0.0.1 -p 10001 -t infinite:opaque -t 99 -e 1.0 -v abch"
)
elif tcp:
test(
pstr ==
"test -t -e 1.0:opaque -t 2 -e 1.0 -v CTEyNy4wLjAuMREnAAD/////AA==:opaque -t 99 -e 1.0 -v abch"
)
print("ok")
return cl
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.enqueue
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()
def allTests(helper, communicator):
ref = "ServerManager:{0}".format(helper.getTestEndpoint())
manager = Test.ServerManagerPrx.checkedCast(communicator.stringToProxy(ref))
locator = communicator.getDefaultLocator()
test(manager)
registry = Test.TestLocatorRegistryPrx.checkedCast(locator.getRegistry())
test(registry)
sys.stdout.write("testing stringToProxy... ")
sys.stdout.flush()
base = communicator.stringToProxy("test @ TestAdapter")
base2 = communicator.stringToProxy("test @ TestAdapter")
base3 = communicator.stringToProxy("test")
base4 = communicator.stringToProxy("ServerManager")
base5 = communicator.stringToProxy("test2")
print("ok")
sys.stdout.write("testing ice_locator and ice_getLocator... ")
sys.stdout.flush()
test(Ice.proxyIdentityEqual(base.ice_getLocator(), communicator.getDefaultLocator()))
anotherLocator = Ice.LocatorPrx.uncheckedCast(communicator.stringToProxy("anotherLocator"))
base = base.ice_locator(anotherLocator)
test(Ice.proxyIdentityEqual(base.ice_getLocator(), anotherLocator))
communicator.setDefaultLocator(None)
base = communicator.stringToProxy("test @ TestAdapter")
test(not base.ice_getLocator())
base = base.ice_locator(anotherLocator)
test(Ice.proxyIdentityEqual(base.ice_getLocator(), anotherLocator))
communicator.setDefaultLocator(locator)
base = communicator.stringToProxy("test @ TestAdapter")
test(Ice.proxyIdentityEqual(base.ice_getLocator(), communicator.getDefaultLocator()))
#
# We also test ice_router/ice_getRouter (perhaps we should add a
# test/Ice/router test?)
#
test(not base.ice_getRouter())
anotherRouter = Ice.RouterPrx.uncheckedCast(communicator.stringToProxy("anotherRouter"))
base = base.ice_router(anotherRouter)
test(Ice.proxyIdentityEqual(base.ice_getRouter(), anotherRouter))
router = Ice.RouterPrx.uncheckedCast(communicator.stringToProxy("dummyrouter"))
communicator.setDefaultRouter(router)
base = communicator.stringToProxy("test @ TestAdapter")
test(Ice.proxyIdentityEqual(base.ice_getRouter(), communicator.getDefaultRouter()))
communicator.setDefaultRouter(None)
base = communicator.stringToProxy("test @ TestAdapter")
test(not base.ice_getRouter())
print("ok")
sys.stdout.write("starting server... ")
sys.stdout.flush()
manager.startServer()
print("ok")
sys.stdout.write("testing checked cast... ")
sys.stdout.flush()
obj = Test.TestIntfPrx.checkedCast(base)
obj = Test.TestIntfPrx.checkedCast(communicator.stringToProxy("test@TestAdapter"))
obj = Test.TestIntfPrx.checkedCast(communicator.stringToProxy("test @TestAdapter"))
obj = Test.TestIntfPrx.checkedCast(communicator.stringToProxy("test@ TestAdapter"))
test(obj)
obj2 = Test.TestIntfPrx.checkedCast(base2)
test(obj2)
obj3 = Test.TestIntfPrx.checkedCast(base3)
test(obj3)
obj4 = Test.ServerManagerPrx.checkedCast(base4)
test(obj4)
obj5 = Test.TestIntfPrx.checkedCast(base5)
test(obj5)
print("ok")
sys.stdout.write("testing id@AdapterId indirect proxy... ")
sys.stdout.flush()
obj.shutdown()
manager.startServer()
try:
obj2 = Test.TestIntfPrx.checkedCast(base2)
obj2.ice_ping()
except Ice.LocalException:
test(False)
print("ok")
sys.stdout.write("testing identity indirect proxy... ")
sys.stdout.flush()
obj.shutdown()
manager.startServer()
try:
obj3 = Test.TestIntfPrx.checkedCast(base3)
obj3.ice_ping()
except Ice.LocalException as ex:
print(ex)
test(False)
try:
obj2 = Test.TestIntfPrx.checkedCast(base2)
obj2.ice_ping()
except Ice.LocalException as ex:
print(ex)
test(False)
obj.shutdown()
manager.startServer()
try:
obj2 = Test.TestIntfPrx.checkedCast(base2)
obj2.ice_ping()
except Ice.LocalException as ex:
print(ex)
test(False)
try:
obj3 = Test.TestIntfPrx.checkedCast(base3)
obj3.ice_ping()
except Ice.LocalException as ex:
print(ex)
test(False)
obj.shutdown()
manager.startServer()
try:
obj2 = Test.TestIntfPrx.checkedCast(base2)
obj2.ice_ping()
except Ice.LocalException:
test(False)
obj.shutdown()
manager.startServer()
try:
obj3 = Test.TestIntfPrx.checkedCast(base3)
obj3.ice_ping()
except Ice.LocalException:
test(False)
obj.shutdown()
manager.startServer()
try:
obj2 = Test.TestIntfPrx.checkedCast(base2)
obj2.ice_ping()
except Ice.LocalException:
test(False)
obj.shutdown()
manager.startServer()
try:
obj5 = Test.TestIntfPrx.checkedCast(base5)
obj5.ice_ping()
except Ice.LocalException:
test(False)
print("ok")
sys.stdout.write("testing reference with unknown identity... ")
sys.stdout.flush()
try:
base = communicator.stringToProxy("unknown/unknown")
base.ice_ping()
test(False)
except Ice.NotRegisteredException as ex:
test(ex.kindOfObject == "object")
test(ex.id == "unknown/unknown")
print("ok")
sys.stdout.write("testing reference with unknown adapter... ")
sys.stdout.flush()
try:
base = communicator.stringToProxy("test @ TestAdapterUnknown")
base.ice_ping()
test(False)
except Ice.NotRegisteredException as ex:
test(ex.kindOfObject == "object adapter")
test(ex.id == "TestAdapterUnknown")
print("ok")
sys.stdout.write("testing object reference from server... ")
sys.stdout.flush()
hello = obj.getHello()
hello.sayHello()
print("ok")
sys.stdout.write("testing object reference from server after shutdown... ")
sys.stdout.flush()
obj.shutdown()
manager.startServer()
hello.sayHello()
print("ok")
sys.stdout.write("testing object migration... ")
sys.stdout.flush()
hello = Test.HelloPrx.checkedCast(communicator.stringToProxy("hello"))
obj.migrateHello()
hello.ice_getConnection().close(Ice.ConnectionClose.GracefullyWithWait)
hello.sayHello()
obj.migrateHello()
hello.sayHello()
obj.migrateHello()
hello.sayHello()
print("ok")
sys.stdout.write("shutdown server... ")
sys.stdout.flush()
obj.shutdown()
print("ok")
sys.stdout.write("testing whether server is gone... ")
sys.stdout.flush()
try:
obj2.ice_ping()
test(False)
except Ice.LocalException:
pass
try:
obj3.ice_ping()
test(False)
except Ice.LocalException:
pass
try:
obj5.ice_ping()
test(False)
except Ice.LocalException:
pass
print("ok")
sys.stdout.write("testing indirect references to collocated objects... ")
sys.stdout.flush()
communicator.getProperties().setProperty("Hello.AdapterId", Ice.generateUUID())
adapter = communicator.createObjectAdapterWithEndpoints("Hello", "default")
id = Ice.Identity()
id.name = Ice.generateUUID()
adapter.add(HelloI(), id)
helloPrx = Test.HelloPrx.checkedCast(communicator.stringToProxy(Ice.identityToString(id)))
test(not helloPrx.ice_getConnection())
helloPrx = Test.HelloPrx.checkedCast(adapter.createIndirectProxy(id))
test(not helloPrx.ice_getConnection())
helloPrx = Test.HelloPrx.checkedCast(adapter.createDirectProxy(id))
test(not helloPrx.ice_getConnection())
print("ok")
sys.stdout.write("shutdown server manager... ")
sys.stdout.flush()
manager.shutdown()
print("ok")
def allTests(communicator):
oa = communicator.createObjectAdapterWithEndpoints("MyOA",
"tcp -h localhost")
oa.activate()
servant = MyObjectI.MyObjectI()
# Register default servant with category "foo"
oa.addDefaultServant(servant, "foo")
# Start test
sys.stdout.write("testing single category... ")
sys.stdout.flush()
r = oa.findDefaultServant("foo")
test(r == servant)
r = oa.findDefaultServant("bar")
test(r == None)
identity = Ice.Identity()
identity.category = "foo"
names = ("foo", "bar", "x", "y", "abcdefg")
for idx in range(0, 5):
identity.name = names[idx]
prx = Test.MyObjectPrx.uncheckedCast(oa.createProxy(identity))
prx.ice_ping()
test(prx.getName() == names[idx])
identity.name = "ObjectNotExist"
prx = Test.MyObjectPrx.uncheckedCast(oa.createProxy(identity))
try:
prx.ice_ping()
test(false)
except Ice.ObjectNotExistException:
# Expected
pass
try:
prx.getName()
test(false)
except Ice.ObjectNotExistException:
# Expected
pass
identity.name = "FacetNotExist"
prx = Test.MyObjectPrx.uncheckedCast(oa.createProxy(identity))
try:
prx.ice_ping()
test(false)
except Ice.FacetNotExistException:
# Expected
pass
try:
prx.getName()
test(false)
except Ice.FacetNotExistException:
# Expected
pass
identity.category = "bar"
for idx in range(0, 5):
identity.name = names[idx]
prx = Test.MyObjectPrx.uncheckedCast(oa.createProxy(identity))
try:
prx.ice_ping()
test(false)
except Ice.ObjectNotExistException:
# Expected
pass
try:
prx.getName()
test(false)
except Ice.ObjectNotExistException:
# Expected
pass
oa.removeDefaultServant("foo")
identity.category = "foo"
prx = Test.MyObjectPrx.uncheckedCast(oa.createProxy(identity))
try:
prx.ice_ping()
except Ice.ObjectNotExistException:
# Expected
pass
print("ok")
sys.stdout.write("testing default category... ")
sys.stdout.flush()
oa.addDefaultServant(servant, "")
r = oa.findDefaultServant("bar")
test(r == None)
r = oa.findDefaultServant("")
test(r == servant)
for idx in range(0, 5):
identity.name = names[idx]
prx = Test.MyObjectPrx.uncheckedCast(oa.createProxy(identity))
prx.ice_ping()
test(prx.getName() == names[idx])
print("ok")
def create_callback_identity(self, name):
return Ice.Identity(name, self.category_for_client)
