def openWriter(self, fname, xml, json=None):
        tdw = PyTango.DeviceProxy(self._sv.new_device_info_writer.name)
        self.assertTrue(ProxyHelper.wait(tdw, 10000))
        self.setProp(tdw, "writer", "h5cpp")

        tdw.FileName = fname
        self.assertEqual(tdw.state(), PyTango.DevState.ON)
        self.assertEqual(tdw.status(), self.__status[tdw.state()])

        tdw.OpenFile()

        self.assertEqual(tdw.state(), PyTango.DevState.OPEN)
        self.assertEqual(tdw.status(), self.__status[tdw.state()])

        tdw.XMLSettings = xml
        self.assertEqual(tdw.state(), PyTango.DevState.OPEN)
        self.assertEqual(tdw.status(), self.__status[tdw.state()])
        if json:
            tdw.JSONRecord = json
        self.assertEqual(tdw.status(), self.__status[tdw.state()])
        self.assertEqual(tdw.state(), PyTango.DevState.OPEN)
        tdw.OpenEntryAsynch()
        self.assertTrue(ProxyHelper.wait(tdw, 10000))
        self.assertEqual(tdw.status(), self.__status[tdw.state()])
        self.assertEqual(tdw.state(), PyTango.DevState.EXTRACT)
        return tdw
 def record(self, tdw, string):
     self.assertEqual(tdw.status(), self.__status[tdw.state()])
     self.assertEqual(tdw.state(), PyTango.DevState.EXTRACT)
     tdw.RecordAsynch(string)
     self.assertTrue(ProxyHelper.wait(tdw, 10000))
     self.assertEqual(tdw.status(), self.__status[tdw.state()])
     self.assertEqual(tdw.state(), PyTango.DevState.EXTRACT)
Пример #3
0
    def test_setData_dev_prop(self):
        device = 'stestp09/testss/s1r228'
        proxy = PyTango.DeviceProxy(device)
        self.assertTrue(ProxyHelper.wait(proxy, 10000))

        fun = sys._getframe().f_code.co_name
        print("Run: %s.%s() " % (self.__class__.__name__, fun))

        arr = {
            "DeviceBoolean": ["ScalarBoolean", "bool", "DevBoolean", True],
            # "DeviceUChar":["ScalarUChar", "uint8", "DevUChar", 23],
            "DeviceShort": ["ScalarShort", "int16", "DevShort", -123],
            "DeviceUShort": ["ScalarUShort", "uint16", "DevUShort", 1234],
            "DeviceLong": ["ScalarLong", "int64", "DevLong", -124],
            "DeviceULong": ["ScalarULong", "uint64", "DevULong", 234],
            # "DeviceLong64":["ScalarLong64", "int64", "DevLong64", 234],
            # "DeviceULong64":["ScalarULong64", "uint64", "DevULong64", 23],
            "DeviceFloat": ["ScalarFloat", "float32", "DevFloat", 12.234],
            "DeviceDouble":
            ["ScalarDouble", "float64", "DevDouble", -2.456673e+02],
            "DeviceString": ["ScalarString", "string", "DevString", "MyTrue"],
        }

        prop = self._simps.dp.get_property(list(arr.keys()))
        for k in prop.keys():
            prop[k] = [arr[k][3]]
        self._simps.dp.put_property(prop)

        for k in arr:
            mb = TgMember(k, "property")
            da = proxy.get_property(k)[k]
            mb.setData(da)
            dt = mb.getValue()
            self.checkData(dt, "SCALAR", str(arr[k][3]), 'DevString', [1, 0],
                           None, None, arr[k][4] if len(arr[k]) > 4 else 0)
Пример #4
0
    def test_setData_command(self):
        fun = sys._getframe().f_code.co_name
        print("Run: %s.%s() " % (self.__class__.__name__, fun))

        device = 'stestp09/testss/s1r228'
        proxy = PyTango.DeviceProxy(device)
        self.assertTrue(ProxyHelper.wait(proxy, 10000))
        arr = {
            "GetBoolean": ["ScalarBoolean", "bool", "DevBoolean", True],
            #  "GetUChar":["ScalarUChar", "uint8", "DevUChar", 23],
            "GetShort": ["ScalarShort", "int16", "DevShort", -123],
            "GetUShort": ["ScalarUShort", "uint16", "DevUShort", 1234],
            "GetLong": ["ScalarLong", "int64", "DevLong", -124],
            "GetULong": ["ScalarULong", "uint64", "DevULong", 234],
            "GetLong64": ["ScalarLong64", "int64", "DevLong64", 234],
            "GetULong64": ["ScalarULong64", "uint64", "DevULong64", 23],
            "GetFloat": ["ScalarFloat", "float32", "DevFloat", 12.234, 1e-5],
            "GetDouble":
            ["ScalarDouble", "float64", "DevDouble", -2.456673e+02, 1e-14],
            "GetString": ["ScalarString", "string", "DevString", "MyTrue"],
        }

        for k in arr:
            self._simps.dp.write_attribute(arr[k][0], arr[k][3])

        for k in arr:
            mb = TgMember(k, "command")
            cd = proxy.command_query(k)
            da = proxy.command_inout(k)
            mb.setData(da, cd)
            dt = mb.getValue()
            self.checkData(dt, "SCALAR", arr[k][3], arr[k][2], [1, 0], None,
                           None, arr[k][4] if len(arr[k]) > 4 else 0)
Пример #5
0
    def test_setData_scalar(self):
        fun = sys._getframe().f_code.co_name
        print("Run: %s.%s() " % (self.__class__.__name__, fun))

        device = 'stestp09/testss/s1r228'
        proxy = PyTango.DeviceProxy(device)
        self.assertTrue(ProxyHelper.wait(proxy, 10000))
        arr1 = {
            "ScalarBoolean": ["bool", "DevBoolean", True],
            "ScalarUChar": ["uint8", "DevUChar", 23],
            "ScalarShort": ["int16", "DevShort", -123],
            "ScalarUShort": ["uint16", "DevUShort", 1234],
            "ScalarLong": ["int64", "DevLong", -124],
            "ScalarULong": ["uint64", "DevULong", 234],
            "ScalarLong64": ["int64", "DevLong64", 234],
            "ScalarULong64": ["uint64", "DevULong64", 23],
            "ScalarFloat": ["float32", "DevFloat", 12.234, 1e-5],
            "ScalarDouble": ["float64", "DevDouble", -2.456673e+02, 1e-14],
            "ScalarString": ["string", "DevString", "MyTrue"],
        }

        arr2 = {
            "State": ["string", "DevState", PyTango._PyTango.DevState.ON],
        }

        arr3 = {
            "ScalarEncoded": [
                "string", "DevEncoded",
                ("UTF8", b"Hello UTF8! Pr\xc3\xb3ba \xe6\xb5\x8b")
            ],
            "SpectrumEncoded": [
                "string", "DevEncoded",
                ('INT32', b'\xd2\x04\x00\x00.\x16\x00\x00-'
                 b'\x00\x00\x00Y\x01\x00\x00')
            ],
        }

        for k in arr1:
            self._simps.dp.write_attribute(k, arr1[k][2])

        arr = dict(arr1, **(arr2))

        for k in arr:

            mb = TgMember(k)
            da = proxy.read_attribute(k)
            mb.setData(da)
            dt = mb.getValue()
            self.checkData(dt, "SCALAR", arr[k][2], arr[k][1], [1, 0], None,
                           None, arr[k][3] if len(arr[k]) > 3 else 0)

        if not PYTG_BUG_213:
            for k in arr3:
                mb = TgMember(k, encoding=arr3[k][2][0])
                da = proxy.read_attribute(k)
                mb.setData(da)
                dp = DecoderPool()
                dt = mb.getValue(dp)
                self.checkData(dt, "SCALAR", arr3[k][2], arr3[k][1], [1, 0],
                               arr3[k][2][0], dp)
Пример #6
0
    def test_getData_default(self):
        fun = sys._getframe().f_code.co_name
        print("Run: %s.%s() " % (self.__class__.__name__, fun))

        dname = 'writer'
        device = 'stestp09/testss/s1r228'
        # ctype = 'command'
        # atype = 'attribute'
        # host = self._dbhost
        # port = '10000'
        # encoding = 'UTF8'
        # group = 'common_motors'

        proxy = PyTango.DeviceProxy(device)
        self.assertTrue(ProxyHelper.wait(proxy, 10000))

        mb = TgMember(dname)
        mb.getData(proxy)
        self.myAssertRaise(DataSourceSetupError, mb.getValue)

        mb = TgMember('ScalarString')
        mb.getData(proxy)
        dt = mb.getValue()
        self.checkData(dt, "SCALAR", "Hello!", "DevString", [1, 0], None, None)

        mb = TgMember('ScalarString')
        mb.getData(proxy)
        dt = mb.getValue()
        self.checkData(dt, "SCALAR", "Hello!", "DevString", [1, 0], None, None)

        dt = mb.getValue()
        self.checkData(dt, "SCALAR", "Hello!", "DevString", [1, 0], None, None)

        mb.reset()
        self.myAssertRaise(DataSourceSetupError, mb.getValue)
Пример #7
0
    def test_setData_image(self):
        fun = sys._getframe().f_code.co_name
        print("Run: %s.%s() " % (self.__class__.__name__, fun))

        device = 'stestp09/testss/s1r228'
        proxy = PyTango.DeviceProxy(device)
        self.assertTrue(ProxyHelper.wait(proxy, 10000))
        arr = {
            "ImageBoolean": ["bool", "DevBoolean", True, [1, 0]],
            "ImageUChar": ["uint8", "DevUChar", 23, [1, 0]],
            "ImageShort": ["int16", "DevShort", -123, [1, 0]],
            "ImageUShort": ["uint16", "DevUShort", 1234, [1, 0]],
            "ImageLong": ["int64", "DevLong", -124, [1, 0]],
            "ImageULong": ["uint64", "DevULong", 234, [1, 0]],
            "ImageLong64": ["int64", "DevLong64", 234, [1, 0]],
            "ImageULong64": ["uint64", "DevULong64", 23, [1, 0]],
            "ImageFloat": ["float32", "DevFloat", 12.234, [1, 0], 1e-5],
            "ImageDouble":
            ["float64", "DevDouble", -2.456673e+02, [1, 0], 1e-14],
            "ImageString": ["string", "DevString", "MyTrue", [1, 0]],
        }

        for k in arr:

            mlen = [
                self.__rnd.randint(1, 10),
                self.__rnd.randint(1, 10),
                self.__rnd.randint(0, 3)
            ]
            if arr[k][1] != "DevBoolean":
                arr[k][2] = [[
                    arr[k][2] * self.__rnd.randint(0, 3)
                    for r in range(mlen[1])
                ] for c in range(mlen[0])]
            else:
                mlen = [self.__rnd.randint(1, 10), self.__rnd.randint(1, 10)]
                if arr[k][1] == 'DevBoolean':
                    arr[k][2] = [[(True if self.__rnd.randint(0, 1) else False)
                                  for c in range(mlen[1])]
                                 for r in range(mlen[0])]

            arr[k][3] = [mlen[0], mlen[1]]
            self._simps.dp.write_attribute(k, arr[k][2])

        for k in arr:
            mb = TgMember(k)
            da = proxy.read_attribute(k)
            mb.setData(da)
            dt = mb.getValue()
            self.checkData(dt, "IMAGE", arr[k][2], arr[k][1], arr[k][3], None,
                           None, arr[k][4] if len(arr[k]) > 4 else 0)
    def closeWriter(self, tdw, json=None):
        self.assertEqual(tdw.state(), PyTango.DevState.EXTRACT)

        if json:
            tdw.JSONRecord = json
        self.assertEqual(tdw.status(), self.__status[tdw.state()])
        self.assertEqual(tdw.state(), PyTango.DevState.EXTRACT)
        tdw.CloseEntryAsynch()
        self.assertTrue(ProxyHelper.wait(tdw, 10000))
        self.assertEqual(tdw.status(), self.__status[tdw.state()])
        self.assertEqual(tdw.state(), PyTango.DevState.OPEN)

        tdw.CloseFile()
        self.assertEqual(tdw.state(), PyTango.DevState.ON)
        self.assertEqual(tdw.status(), self.__status[tdw.state()])
Пример #9
0
class GeneralClientProxy:
	def __init__(self,connection):
		self.__proxyHelper = ProxyHelper(connection)
	def destroy(self,type,name):
		return self.__proxyHelper.doOp("DESTROY", 0, None, type, name)
	def txnBegin(self):
		return self.__proxyHelper.doOp("TRXBEGIN", 0, None)
	def txnCommit(self):
		return self.__proxyHelper.doOp("TRXCOMMIT", 0, None)
	def txnRollback(self):
		return self.__proxyHelper.doOp("TRXROLLBACK", 0, None)
	def instances(self):
		return self.__proxyHelper.doOp("INSTANCES", 0, None)
	def members(self):
		return self.__proxyHelper.doOp("MEMBERS", 0, None)
	def ping(self):
		return self.__proxyHelper.doOp("PING", 0, None)
	def clusterTime(self):
		raise NotImplementedError
	def partitions(self):
		raise NotImplementedError
Пример #10
0
 def __init__(self , name , connection):
     self.__name = name
     self.__proxyHelper = ProxyHelper(connection)
Пример #11
0
class MapClientProxy:
    def __init__(self , name , connection):
        self.__name = name
        self.__proxyHelper = ProxyHelper(connection)
    def addListener(self, listener, key=None, includeValue=False):
        """ If key is provided listener will be notified only for the key,
        otherwise it will notified for all entries in the map 
        If includeValue set to True it will bring  values for the keys with the event"""
        self.__listenerManager = ListenerManager(self.__proxyHelper)
        listener.listenerManager = self.__listenerManager
        listener.key = key
        listener.name = self.__name
        self.__listenerManager.addListenerOp(listener, key, includeValue, self.__name)
    def removeListener(self, listener, key=None):
        self.__listenerManager.removeListenerOp(listener, key, self.__name)    
    def put(self, key, value, ttl=0):
        self.__proxyHelper.check(key)
        self.__proxyHelper.check(value)
        return self.__proxyHelper.doOp("MPUT", 2, (key, value), self.__name, str(ttl))
    def putIfAbsent(self, key, value, ttl=0):
        self.__proxyHelper.check(key)
        self.__proxyHelper.check(value)
        return self.__proxyHelper.doOp("MPUTIFABSENT", 2, (key, value), self.__name, str(ttl))
    def putTransient(self, key, value, ttl=0):
        self.__proxyHelper.check(key)
        self.__proxyHelper.check(value)
        return self.__proxyHelper.doOp("MPUTTRANSIENT", 2, (key, value), self.__name, str(ttl))
    def putAll(self, entries):
        return self.__proxyHelper.doOp("MPUTALL", 2 * len(entries), entries, self.__name)    
    def putAndUnlock(self, key, value):
        self.__proxyHelper.check(key)
        self.__proxyHelper.check(value)
        return self.__proxyHelper.doOp("MPUTANDUNLOCK", 2, (key, value), self.__name)
    def set(self, key, value, ttl=0):
        self.__proxyHelper.check(key)
        self.__proxyHelper.check(value)
        return self.__proxyHelper.doOp("MSET", 2, (key, value), self.__name, str(ttl))
    def get(self, key):
        self.__proxyHelper.check(key)
        return self.__proxyHelper.doOp("MGET", 1, key, self.__name)
    def getAll(self, keys): #com.hazelcast.nio.Data cannot be cast to java.lang.Comparable
        for key in keys:
            self.__proxyHelper.check(key)
        return self.__proxyHelper.doOp("MGETALL", len(keys), keys, self.__name)
    def tryPut(self, key, value, timeout):
        self.__proxyHelper.check(key)
        self.__proxyHelper.check(value)
        return self.__proxyHelper.doOp("MTRYPUT", 2, (key, value), self.__name, str(timeout))
    def tryLock(self, key, timeout): # not yet implemented on the server side
        self.__proxyHelper.check(key)
        return self.__proxyHelper.doOp("MTRYLOCK", 1, key, self.__name, str(timeout))
    def isKeyLocked(self, key): # server handler doesn't give reply
        self.__proxyHelper.check(key)
        return self.__proxyHelper.doOp("MISKEYLOCKED", 1, key, self.__name)
    def lock(self, key, timeout):
        self.__proxyHelper.check(key)
        return self.__proxyHelper.doOp("MLOCK", 1, key, self.__name, str(timeout))
    def unLock(self, key):
        self.__proxyHelper.check(key)
        return self.__proxyHelper.doOp("MUNLOCK", 1, key, self.__name)
    def lockMap(self, timeout):
        return self.__proxyHelper.doOp("MLOCKMAP", 0, None, self.__name, str(timeout))
    def unlockMap(self, timeout):
        return self.__proxyHelper.doOp("MUNLOCKMAP", 0, None, self.__name, str(timeout))
    def forceUnlock(self, key): 
        self.__proxyHelper.check(key)
        return self.__proxyHelper.doOp("MFORCEUNLOCK", 1, key, self.__name)
    def containsKey(self, key):  
        self.__proxyHelper.check(key)
        return self.__proxyHelper.doOp("MCONTAINSKEY", 1, key, self.__name)
    def containsValue(self, value):   
        self.__proxyHelper.check(value)
        return self.__proxyHelper.doOp("MCONTAINSVALUE", 1, value, self.__name)
    def keySet(self):
        return self.__proxyHelper.doOp("KEYSET", 0, None, "map", self.__name)
    def remove(self, key):
        self.__proxyHelper.check(key)
        return self.__proxyHelper.doOp("MREMOVE", 1, key , self.__name)
    def removeIfSame(self, key, value):
        self.__proxyHelper.check(key)
        self.__proxyHelper.check(value)
        return self.__proxyHelper.doOp("MREMOVEIFSAME", 2, (key, value), self.__name,)
    def replaceIfNotNull(self, key, value):
        self.__proxyHelper.check(key)
        self.__proxyHelper.check(value)
        return self.__proxyHelper.doOp("MREPLACEIFNOTNULL", 2, (key, value), self.__name,)
    def replaceIfSame(self, key, oldValue, newValue): # ERROR 0 java.lang.String cannot be cast to com.hazelcast.impl.Keys 
        self.__proxyHelper.check(key)
        self.__proxyHelper.check(oldValue)
        self.__proxyHelper.check(newValue)
        return self.__proxyHelper.doOp("MREPLACEIFSAME", 3, (key, oldValue, newValue), self.__name,)
    def flush(self):
        return self.__proxyHelper.doOp("MFLUSH", 0, None, self.__name)
    def evict(self, key):  
        self.__proxyHelper.check(key)
        return self.__proxyHelper.doOp("MEVICT", 1, key, self.__name)
Пример #12
0
class MapClientProxy:
    # TODO : extract all data from calling method after making the call.
    # TODO : add noreply option
    def __init__(self , name , connection):
        self.__name = name
        self.__proxyHelper = ProxyHelper(connection)
   
    def addListener(self, listener, key=None, includeValue=False):
        """ If key is provided listener will be notified only for the key,
        otherwise it will notified for all entries in the map 
        If includeValue set to True it will bring  values for the keys with the event"""
        self.__listenerManager = ListenerManager()
        self.__listenerManager.setProxyHelper(self.__proxyHelper)
        listener.listenerManager = self.__listenerManager
        listener.key = key
        listener.name = self.__name
        self.__listenerManager.addListenerOp(listener, key, includeValue, self.__name)
    
    def removeListener(self, listener, key=None):
        self.__listenerManager.removeListenerOp(listener, key, self.__name)   
    
    def put(self, key, value, ttl=0):
        self.__proxyHelper.check(key)
        self.__proxyHelper.check(value)
        response = self.__proxyHelper.doOp("MPUT", 2, (key, value), self.__name, str(ttl))
        return self.__proxyHelper.readSingleObjectResponse(response)
    
    def putIfAbsent(self, key, value, ttl=0):
        self.__proxyHelper.check(key)
        self.__proxyHelper.check(value)
        response = self.__proxyHelper.doOp("MPUTIFABSENT", 2, (key, value), self.__name, str(ttl))
        return self.__proxyHelper.readSingleObjectResponse(response)

    def putTransient(self, key, value, ttl=0):
        self.__proxyHelper.check(key)
        self.__proxyHelper.check(value)
        response = self.__proxyHelper.doOp("MPUTTRANSIENT", 2, (key, value), self.__name, str(ttl))
        return self.__proxyHelper.readSingleObjectResponse(response)
    
    def putAll(self, entries):
        response = self.__proxyHelper.doOp("MPUTALL", 2 * len(entries), entries, self.__name)    
        return self.__proxyHelper.readOKResponse(response)
    
    def putAndUnlock(self, key, value):
        self.__proxyHelper.check(key)
        self.__proxyHelper.check(value)
        response = self.__proxyHelper.doOp("MPUTANDUNLOCK", 2, (key, value), self.__name)
        return self.__proxyHelper.readOKResponse(response)

    def size(self):
        response = self.__proxyHelper.doOp("MSIZE", 0 , None , self.__name)
        return self.__proxyHelper.readSingleIntResponse(response)
    
    def set(self, key, value, ttl=0):
        self.__proxyHelper.check(key)
        self.__proxyHelper.check(value)
        response = self.__proxyHelper.doOp("MSET", 2, (key, value), self.__name, str(ttl))
        return self.__proxyHelper.readOKResponse(response)
    
    def get(self, key):
        self.__proxyHelper.check(key)
        response = self.__proxyHelper.doOp("MGET", 1, key, self.__name)
        return self.__proxyHelper.readSingleObjectResponse(response)
    
    def getAll(self, keys): 
        for key in keys:
            self.__proxyHelper.check(key)
        response = self.__proxyHelper.doOp("MGETALL", len(keys), keys, self.__name)
        keys = response["binaryData"][::2]
        values = response["binaryData"][1::2]
        result = dict(zip(keys,values))
        return result
    
    def tryLockAndGet(self, key, timeout):
        self.__proxyHelper.check(key)
        response = self.__proxyHelper.doOp("MTRYLOCKANDGET", 1, key, self.__name, str(timeout))
        return self.__proxyHelper.readSingleObjectResponse(response)

    def tryPut(self, key, value, timeout):
        self.__proxyHelper.check(key)
        self.__proxyHelper.check(value)
        response = self.__proxyHelper.doOp("MTRYPUT", 2, (key, value), self.__name, str(timeout))
        return self.__proxyHelper.readSingleBoolResponse(response)
   
    def tryLock(self, key, timeout): 
        self.__proxyHelper.check(key)
        response =  self.__proxyHelper.doOp("MTRYLOCK", 1, key, self.__name, str(timeout))
        return self.__proxyHelper.readSingleBoolResponse(response)

    def tryRemove(self, key, timeout):
        self.__proxyHelper.check(key)
        response = self.__proxyHelper.doOp("MTRYREMOVE", 1, key, self.__name, str(timeout))
        return self.__proxyHelper.readSingleObjectResponse(response)

    def isKeyLocked(self, key): 
        self.__proxyHelper.check(key)
        response =  self.__proxyHelper.doOp("MISKEYLOCKED", 1, key, self.__name)
        return self.__proxyHelper.readSingleBoolResponse(response)

    def lock(self, key):
        self.__proxyHelper.check(key)
        response = self.__proxyHelper.doOp("MLOCK", 1, key, self.__name)
        return self.__proxyHelper.readSingleBoolResponse(response)

    def unLock(self, key):
        self.__proxyHelper.check(key)
        response = self.__proxyHelper.doOp("MUNLOCK", 1, key, self.__name)
        return self.__proxyHelper.readOKResponse(response)

    def lockMap(self, timeout):
        response = self.__proxyHelper.doOp("MLOCKMAP", 0, None, self.__name, str(timeout))
        return self.__proxyHelper.readSingleBoolResponse(response)

    def unlockMap(self, timeout):
        return self.__proxyHelper.doOp("MUNLOCKMAP", 0, None, self.__name, str(timeout))
   
    def forceUnlock(self, key): 
        self.__proxyHelper.check(key)
        response = self.__proxyHelper.doOp("MFORCEUNLOCK", 1, key, self.__name)
        return self.__proxyHelper.readOKResponse(response)   
    
    def containsKey(self, key):  
        self.__proxyHelper.check(key)
        response = self.__proxyHelper.doOp("MCONTAINSKEY", 1, key, self.__name)
        return self.__proxyHelper.readSingleBoolResponse(response)
   
    def containsValue(self, value):   
        self.__proxyHelper.check(value)
        response =  self.__proxyHelper.doOp("MCONTAINSVALUE", 1, value, self.__name)
        return self.__proxyHelper.readSingleBoolResponse(response)

    def keySet(self):
        response = self.__proxyHelper.doOp("KEYSET", 0, None, "map", self.__name)
        return response["binaryData"]
    
    def remove(self, key):
        self.__proxyHelper.check(key)
        response = self.__proxyHelper.doOp("MREMOVE", 1, key , self.__name)
        return self.__proxyHelper.readSingleObjectResponse(response)
    
    def removeIfSame(self, key, value):
        self.__proxyHelper.check(key)
        self.__proxyHelper.check(value)
        response =  self.__proxyHelper.doOp("MREMOVEIFSAME", 2, (key, value), self.__name,)
        return self.__proxyHelper.readSingleBoolResponse(response)
    
    def replaceIfNotNull(self, key, value):
        self.__proxyHelper.check(key)
        self.__proxyHelper.check(value)
        return self.__proxyHelper.doOp("MREPLACEIFNOTNULL", 2, (key, value), self.__name,)
    
    def replaceIfSame(self, key, oldValue, newValue): # ERROR 0 java.lang.String cannot be cast to com.hazelcast.impl.Keys 
        self.__proxyHelper.check(key)
        self.__proxyHelper.check(oldValue)
        self.__proxyHelper.check(newValue)
        return self.__proxyHelper.doOp("MREPLACEIFSAME", 3, (key, oldValue, newValue), self.__name,)
    
    def flush(self):
        response = self.__proxyHelper.doOp("MFLUSH", 0, None, self.__name) 
        return self.__proxyHelper.readOKResponse(response)
    
    def evict(self, key):  
        self.__proxyHelper.check(key)
        response = self.__proxyHelper.doOp("MEVICT", 1, key, self.__name)
        return self.__proxyHelper.readSingleBoolResponse(response)
Пример #13
0
	def __init__(self,connection):
		self.__proxyHelper = ProxyHelper(connection)
Пример #14
0
class GeneralClientProxy:
    def __init__(self, connection):
        self.__proxyHelper = ProxyHelper(connection)

    def destroy(self, type, name):
        response = self.__proxyHelper.doOp("DESTROY", 0, None, type, name)
        return self.__proxyHelper.readOKResponse(response)

    def txnBegin(self):
        response = self.__proxyHelper.doOp("TRXBEGIN", 0, None)
        return self.__proxyHelper.readOKResponse(response)

    def txnCommit(self):
        response = self.__proxyHelper.doOp("TRXCOMMIT", 0, None)
        return self.__proxyHelper.readOKResponse(response)

    def txnRollback(self):
        response = self.__proxyHelper.doOp("TRXROLLBACK", 0, None)
        return self.__proxyHelper.readOKResponse(response)

    def instances(self):
        response = self.__proxyHelper.doOp("INSTANCES", 0, None)
        response = response["commandLine"].split()
        types = response[1::2]
        names = response[2::2]
        return dict(zip(names, types))

    def members(self):
        response = self.__proxyHelper.doOp("MEMBERS", 0, None)
        response = response["commandLine"].split()
        return response[1:]

    def ping(self):  # we are getting unknown_error
        response = self.__proxyHelper.doOp("PING", 0, None)
        return self.__proxyHelper.readOKResponse(response)

    def clusterTime(self):
        response = self.__proxyHelper.doOp("CLUSTERTIME", 0, None)
        milis = self.__proxyHelper.readSingleIntResponse(response)
        return time.gmtime(
            (milis / 1000)
        )  # hazelcast returns time in miliseconds granularity but built in python methods in seconds granularity.

    def partitions(self, key=None):
        if key is None:
            response = self.__proxyHelper.doOp("PARTITIONS", 0, None)
        else:
            response = self.__proxyHelper.doOp("PARTITIONS", 1, key)
        response = response["commandLine"].split()
        pids = response[1::2]
        pids = [int(x) for x in pids]  # convert string keys to int
        addresses = response[2::2]
        return dict(zip(pids, addresses))
Пример #15
0
class QueueClientProxy:
    def __init__(self , name , connection):
        self.__name = name
        self.__proxyHelper = ProxyHelper(connection)
    def addListener(self, listener, includeValue=True):
        self.__listenerManager = ListenerManager(self.__proxyHelper)
        listener.listenerManager = self.__listenerManager
        listener.name = self.__name
        self.__listenerManager.addListenerOp(listener, None, includeValue, self.__name)
    def offer(self, element, timeout=0):
        self.__proxyHelper.check(element)
        return self.__proxyHelper.doOp("QOFFER", 1, element, self.__name, str(timeout))
    def put(self, element):
        return self.__proxyHelper.doOp("QPUT", 0, None, self.__name)
    def poll(self, timeout=0):
        return self.__proxyHelper.doOp("QPOLL", 0, None, self.__name, str(timeout))
    def take(self, timeout=0):
        return self.__proxyHelper.doOp("QTAKE", 0, None, self.__name)
    def size(self):
        return self.__proxyHelper.doOp("QSIZE", 0, None, self.__name)
    def peek(self):
        return self.__proxyHelper.doOp("QPEEK", 0, None, self.__name)
    def remove(self, element):
        self.__proxyHelper.check(element)
        return self.__proxyHelper.doOp("QREMOVE", 1, element, self.__name)
    def remainingCapacity(self):
        return self.__proxyHelper.doOp("QREMCAPACITY", 0, None, self.__name)
    def entries(self):
        return self.__proxyHelper.doOp("QENTRIES", 0, None, self.__name)