def knownIntermediateAsBase(self, current=None):
ki = Test.KnownIntermediate()
ki.b = "KnownIntermediate.b"
ki.ki = "KnownIntermediate.ki"
f = Ice.Future()
f.set_exception(ki)
return f
def unknownIntermediateAsBase(self, current=None):
ui = Test.UnknownIntermediate()
ui.b = "UnknownIntermediate.b"
ui.ui = "UnknownIntermediate.ui"
f = Ice.Future()
f.set_exception(ui)
return f
def knownDerivedAsKnownDerived(self, current=None):
d = Test.KnownDerived()
d.b = "KnownDerived.b"
d.kd = "KnownDerived.kd"
f = Ice.Future()
f.set_exception(d)
return f
def unknownDerivedAsBase(self, current=None):
d = Test.UnknownDerived()
d.b = "UnknownDerived.b"
d.ud = "UnknownDerived.ud"
f = Ice.Future()
f.set_exception(d)
return f
def addDownloadTask(self, url, current=None):
'''añadir tarea de descargar a la cola'''
callback = Ice.Future()
self.cola_trabajo.add(callback, url)
print('downloader {}: descargando canción de {}'.format(
self.name, url))
return callback
def ice_invoke(self, inParams, curr):
f = Ice.Future()
with self._lock:
proxy = self._objects[curr.id]
assert proxy
self._queue.add(BlobjectCall(proxy, f, inParams, curr))
return f
def knownMostDerivedAsKnownMostDerived(self, current=None):
kmd = Test.KnownMostDerived()
kmd.b = "KnownMostDerived.b"
kmd.ki = "KnownMostDerived.ki"
kmd.kmd = "KnownMostDerived.kmd"
f = Ice.Future()
f.set_exception(kmd)
return f
def throwUndeclaredC(self, a, b, c, current=None):
ex = Test.C()
ex.aMem = a
ex.bMem = b
ex.cMem = c
f = Ice.Future()
f.set_exception(ex)
return f
def knownPreservedAsKnownPreserved(self, r, current=None):
ex = Test.KnownPreservedDerived()
ex.b = "base"
ex.kp = "preserved"
ex.kpd = "derived"
f = Ice.Future()
f.set_exception(ex)
return f
def unknownMostDerived2AsBaseCompact(self, current=None):
umd2 = Test.UnknownMostDerived2()
umd2.b = "UnknownMostDerived2.b"
umd2.ui = "UnknownMostDerived2.ui"
umd2.umd2 = "UnknownMostDerived2.umd2"
f = Ice.Future()
f.set_exception(umd2)
return f
def unknownMostDerived1AsKnownIntermediate(self, current=None):
umd1 = Test.UnknownMostDerived1()
umd1.b = "UnknownMostDerived1.b"
umd1.ki = "UnknownMostDerived1.ki"
umd1.umd1 = "UnknownMostDerived1.umd1"
f = Ice.Future()
f.set_exception(umd1)
return f
def relayUnknownPreservedAsKnownPreserved(self, r, current=None):
f = Ice.Future()
try:
r.unknownPreservedAsKnownPreserved()
test(False)
except Ice.Exception as ex:
f.set_exception(ex)
return f
async def opShortIntLong(self, p1, p2, p3, current=None):
f = Ice.Future()
with self.threadLock:
thread = FutureThread(f, (p3, p1, p2, p3))
self.threads.append(thread)
thread.start()
return await f
def relayUnknownPreservedAsKnownPreserved(self, r, current):
f = Ice.Future()
try:
p = Test.RelayPrx.uncheckedCast(current.con.createProxy(r.ice_getIdentity()))
p.unknownPreservedAsKnownPreserved()
test(False)
except Ice.Exception as ex:
f.set_exception(ex)
return f
def throwBaseAsBase(self, current=None):
be = Test.BaseException()
be.sbe = "sbe"
be.pb = Test.B()
be.pb.sb = "sb"
be.pb.pb = be.pb
f = Ice.Future()
f.set_exception(be)
return f
def throwPreservedException(self, current=None):
ue = Test.PSUnknownException()
ue.p = Test.PSUnknown2()
ue.p.pi = 5
ue.p.ps = "preserved"
ue.p.pb = ue.p
f = Ice.Future()
f.set_exception(ue)
return f
def unknownPreservedAsKnownPreserved(self, r, current=None):
ex = Test.SPreserved2()
ex.b = "base"
ex.kp = "preserved"
ex.kpd = "derived"
ex.p1 = Test.SPreservedClass("bc", "spc")
ex.p2 = ex.p1
f = Ice.Future()
f.set_exception(ex)
return f
def opVoid(self, current=None):
test(current.mode == Ice.OperationMode.Normal)
f = Ice.Future()
with self.threadLock:
thread = FutureThread(f, None)
self.threads.append(thread)
thread.start()
return f
def throwAorDasAorD(self, a, current=None):
f = Ice.Future()
if a > 0:
ex = Test.A()
ex.aMem = a
f.set_exception(ex)
else:
ex = Test.D()
ex.dMem = a
f.set_exception(ex)
return f
def intfUserException(self, throw, current=None):
f = Ice.Future()
if throw:
f.set_exception(Test.TestIntfUserException())
else:
#
# Return a value so we can be sure that the stream position
# is reset correctly if finished() throws.
#
f.set_result("Hello")
return f
def add(self, delay):
future = Ice.Future()
with self._cond:
if not self._done:
entry = CallbackEntry(future, delay)
if len(self._callbacks) == 0:
self._cond.notify()
self._callbacks.append(entry)
else:
future.set_exception(Demo.RequestCanceledException())
return future
def opRequiredException(self, a, b, o, current=None):
e = Test.RequiredException()
e.a = a
e.b = b
e.o = o
if b is not Ice.Unset:
e.ss = b
if o is not Ice.Unset:
e.o2 = o
f = Ice.Future()
f.set_exception(e)
return f
def opRequiredException(self, a, b, vs, current=None):
e = Test.RequiredException()
e.a = a
e.b = b
e.vs = vs
if b is not Ice.Unset:
e.ss = b
if vs is not Ice.Unset:
e.vs2 = vs
f = Ice.Future()
f.set_exception(e)
return f
def throwUnknownDerivedAsBase(self, current=None):
d2 = Test.D2()
d2.sb = "sb d2"
d2.pb = d2
d2.sd2 = "sd2 d2"
d2.pd2 = d2
ude = Test.UnknownDerivedException()
ude.sbe = "sbe"
ude.pb = d2
ude.sude = "sude"
ude.pd2 = d2
f = Ice.Future()
f.set_exception(ude)
return f
def throwDerivedAsDerived(self, current=None):
de = Test.DerivedException()
de.sbe = "sbe"
de.pb = Test.B()
de.pb.sb = "sb1"
de.pb.pb = de.pb
de.sde = "sde1"
de.pd1 = Test.D1()
de.pd1.sb = "sb2"
de.pd1.pb = de.pd1
de.pd1.sd1 = "sd2"
de.pd1.pd1 = de.pd1
f = Ice.Future()
f.set_exception(de)
return f
def throwUndeclaredA(self, a, current=None):
ex = Test.A()
ex.aMem = a
f = Ice.Future()
f.set_exception(ex)
return f
def throwAfterException(self, current=None):
# Cannot be implemented with Futures
f = Ice.Future()
f.set_exception(Test.A())
return f
def throwLocalExceptionIdempotent(self, current=None):
f = Ice.Future()
f.set_exception(Ice.TimeoutException())
return f
def throwNonIceException(self, current=None):
f = Ice.Future()
f.set_exception(RuntimeError("12345"))
return f
def startDispatch(self, current=None):
f = Ice.Future()
with self._cond:
self._pending.append(f)
return f
