Ejemplo n.º 1
0
    def testEncodingWithExtensionAndPayload(self):
        msg=ClientMessage()
        vr=0
        optype=200
        corrID=0
        parID=-1

        msg.version=vr
        msg.optype=optype
        msg.correlation=corrID
        msg.partition=parID
        msg.addExtension(bytearray(ctypes.c_uint32(4203239)))
        msg.setPayload(bytearray(ctypes.c_uint32(4203239)))

        frame = bytearray()
        #Create a byte array of size 18


        frame+=bytearray(ctypes.c_int32(18+4+4))
        frame+=bytearray(ctypes.c_uint8(vr))
        frame+=bytearray(ctypes.c_uint8(192))
        frame+=bytearray(ctypes.c_uint16(optype))
        frame+=bytearray(ctypes.c_int32(corrID))
        frame+=bytearray(ctypes.c_int32(parID))
        frame+=bytearray(ctypes.c_uint16(26))
        frame+=bytearray(ctypes.c_uint32(4203239))
        frame+=bytearray(ctypes.c_uint32(4203239))


        encodedMsg=msg.encodeMessage()


        self.assertEqual(frame,encodedMsg)
Ejemplo n.º 2
0
def destroyProxy(name,service):
    msg=ClientMessage()
    msg.optype=0x6
    newtitle=name.encode("UTF8")

    newbody=service.encode("UTF8")
    payload=bytearray(ctypes.c_uint32(len(newtitle)))+newtitle+bytearray(ctypes.c_uint32(len(newbody)))+newbody
    msg.setPayload(payload)
    return msg
Ejemplo n.º 3
0
 def encodeRequest(cls, name):
     clientMessage = ClientMessage()
     clientMessage.setOperationType(TopicAddMessageListenerCodec.REQUEST_TYPE.id)
     clientMessage.setRetryable(TopicAddMessageListenerCodec.RETRYABLE)
     clientMessage.set(name)
     clientMessage.updateSize()
     return clientMessage
 def encodeRequest(cls, name):
     clientMessage = ClientMessage()
     clientMessage.setOperationType(SemaphoreAvailablePermitsCodec.REQUEST_TYPE)
     clientMessage.setRetryable(SemaphoreAvailablePermitsCodec.RETRYABLE)
     clientMessage.set(name)
     clientMessage.updateSize()
     return clientMessage
 def encodeRequest(cls, name):
     clientMessage = ClientMessage()
     clientMessage.setOperationType(AtomicReferenceIsNullCodec.REQUEST_TYPE)
     clientMessage.setRetryable(AtomicReferenceIsNullCodec.RETRYABLE)
     clientMessage.set(name)
     clientMessage.updateSize()
     return clientMessage
 def encodeRequest(cls, name):
     clientMessage = ClientMessage()
     clientMessage.setOperationType(AtomicLongIncrementAndGetCodec.REQUEST_TYPE)
     clientMessage.setRetryable(AtomicLongIncrementAndGetCodec.RETRYABLE)
     clientMessage.set(name)
     clientMessage.updateSize()
     return clientMessage
 def encodeRequest(cls, name):
     clientMessage = ClientMessage()
     clientMessage.setOperationType(ListIteratorCodec.REQUEST_TYPE)
     clientMessage.setRetryable(ListIteratorCodec.RETRYABLE)
     clientMessage.set(name)
     clientMessage.updateSize()
     return clientMessage
 def encodeRequest(cls, name):
     clientMessage = ClientMessage()
     clientMessage.setOperationType(LockGetRemainingLeaseTimeCodec.REQUEST_TYPE)
     clientMessage.setRetryable(LockGetRemainingLeaseTimeCodec.RETRYABLE)
     clientMessage.set(name)
     clientMessage.updateSize()
     return clientMessage
Ejemplo n.º 9
0
    def publish(self,data):
        msg=topiccodec.TopicPublishCodec.encodeRequest(self.title,data)
        self.connection.sendPackage(msg.encodeMessage())
        response=self.connection.waitAndGetPackage()
        msg2=ClientMessage.decodeMessage(response)

        return topiccodec.TopicPublishCodec.decodeResponse(msg2)
Ejemplo n.º 10
0
    def removeMessageListener(self):
        msg=topiccodec.TopicRemoveMessageListenerCodec.encodeRequest(self.title, registrationId)
        self.connection.sendPackage(msg.encodeMessage())
        response=self.connection.waitAndGetPackage()
        msg2=ClientMessage.decodeMessage(response)

        return topiccodec.TopicRemoveMessageListenerCodec.decodeResponse(msg2)
    def encodeResponse(cls, response):
        clientMessage = ClientMessage()
        clientMessage.setOperationType(ListGetCodec.RESPONSE_TYPE)
        response_isNull=None
        if response is None:
            response_isNull = True
            clientMessage.set(response_isNull)
        else:
            response_isNull= False
            clientMessage.set(response_isNull)
        clientMessage.set(response)

        return clientMessage
 def ValuesWithPredicate(self,   predicate):
     msg=mapcodec.MapValuesWithPredicateCodec.encodeRequest( encode.encodestring(self.title), predicate)
     retryable=msg.retryable
     self.connection.adjustCorrelationId(msg)
     correlationid=msg.correlation
     self.connection.sendPackage(msg.encodeMessage())
     response=self.connection.getPackageWithCorrelationId(correlationid,retryable)
     msg2=ClientMessage.decodeMessage(response)
     return mapcodec.MapValuesWithPredicateCodec.decodeResponse(msg2).list
 def Unlock(self,   key, threadId):
     msg=mapcodec.MapUnlockCodec.encodeRequest( encode.encodestring(self.title), key, encode.encodeint64(threadId))
     retryable=msg.retryable
     self.connection.adjustCorrelationId(msg)
     correlationid=msg.correlation
     self.connection.sendPackage(msg.encodeMessage())
     response=self.connection.getPackageWithCorrelationId(correlationid,retryable)
     msg2=ClientMessage.decodeMessage(response)
     return mapcodec.MapUnlockCodec.decodeResponse(msg2)
 def SubmitToKey(self,   entryProcessor, key):
     msg=mapcodec.MapSubmitToKeyCodec.encodeRequest( encode.encodestring(self.title), entryProcessor, key)
     retryable=msg.retryable
     self.connection.adjustCorrelationId(msg)
     correlationid=msg.correlation
     self.connection.sendPackage(msg.encodeMessage())
     response=self.connection.getPackageWithCorrelationId(correlationid,retryable)
     msg2=ClientMessage.decodeMessage(response)
     return mapcodec.MapSubmitToKeyCodec.decodeResponse(msg2).response
 def RemovePartitionLostListener(self,   registrationId):
     msg=mapcodec.MapRemovePartitionLostListenerCodec.encodeRequest( encode.encodestring(self.title), encode.encodestring(registrationId))
     retryable=msg.retryable
     self.connection.adjustCorrelationId(msg)
     correlationid=msg.correlation
     self.connection.sendPackage(msg.encodeMessage())
     response=self.connection.getPackageWithCorrelationId(correlationid,retryable)
     msg2=ClientMessage.decodeMessage(response)
     return mapcodec.MapRemovePartitionLostListenerCodec.decodeResponse(msg2).response
 def GetAll(self,   keys, expiryPolicy):
     msg=cachecodec.CacheGetAllCodec.encodeRequest( encode.encodestring(self.title), keys, expiryPolicy)
     retryable=msg.retryable
     self.connection.adjustCorrelationId(msg)
     correlationid=msg.correlation
     self.connection.sendPackage(msg.encodeMessage())
     response=self.connection.receivePackageWithCorrelationId(correlationid,retryable)
     msg2=ClientMessage.decodeMessage(response)
     return cachecodec.CacheGetAllCodec.decodeResponse(msg2).entrySet
 def RemoveInvalidationListener(self,   registrationId):
     msg=cachecodec.CacheRemoveInvalidationListenerCodec.encodeRequest( encode.encodestring(self.title), encode.encodestring(registrationId))
     retryable=msg.retryable
     self.connection.adjustCorrelationId(msg)
     correlationid=msg.correlation
     self.connection.sendPackage(msg.encodeMessage())
     response=self.connection.receivePackageWithCorrelationId(correlationid,retryable)
     msg2=ClientMessage.decodeMessage(response)
     return cachecodec.CacheRemoveInvalidationListenerCodec.decodeResponse(msg2).response
 def ListenerRegistration(self,   listenerConfig, register, hostname, port):
     msg=cachecodec.CacheListenerRegistrationCodec.encodeRequest( encode.encodestring(self.title), listenerConfig, encode.encodeboolean(register), encode.encodestring(hostname), encode.encodeint32(port))
     retryable=msg.retryable
     self.connection.adjustCorrelationId(msg)
     correlationid=msg.correlation
     self.connection.sendPackage(msg.encodeMessage())
     response=self.connection.receivePackageWithCorrelationId(correlationid,retryable)
     msg2=ClientMessage.decodeMessage(response)
     return cachecodec.CacheListenerRegistrationCodec.decodeResponse(msg2)
 def LoadAll(self,   keys, replaceExistingValues):
     msg=cachecodec.CacheLoadAllCodec.encodeRequest( encode.encodestring(self.title), keys, encode.encodeboolean(replaceExistingValues))
     retryable=msg.retryable
     self.connection.adjustCorrelationId(msg)
     correlationid=msg.correlation
     self.connection.sendPackage(msg.encodeMessage())
     response=self.connection.receivePackageWithCorrelationId(correlationid,retryable)
     msg2=ClientMessage.decodeMessage(response)
     return cachecodec.CacheLoadAllCodec.decodeResponse(msg2)
 def CreateConfig(self,  cacheConfig, createAlsoOnOthers):
     msg=cachecodec.CacheCreateConfigCodec.encodeRequest( cacheConfig, encode.encodeboolean(createAlsoOnOthers))
     retryable=msg.retryable
     self.connection.adjustCorrelationId(msg)
     correlationid=msg.correlation
     self.connection.sendPackage(msg.encodeMessage())
     response=self.connection.receivePackageWithCorrelationId(correlationid,retryable)
     msg2=ClientMessage.decodeMessage(response)
     return cachecodec.CacheCreateConfigCodec.decodeResponse(msg2)
 def GetAll(self,  ):
     msg=setcodec.SetGetAllCodec.encodeRequest( encode.encodestring(self.title))
     retryable=msg.retryable
     self.connection.adjustCorrelationId(msg)
     correlationid=msg.correlation
     self.connection.sendPackage(msg.encodeMessage())
     response=self.connection.receivePackageWithCorrelationId(correlationid,retryable)
     msg2=ClientMessage.decodeMessage(response)
     return setcodec.SetGetAllCodec.decodeResponse(msg2).list
 def Destroy(self,  ):
     msg=cachecodec.CacheDestroyCodec.encodeRequest( encode.encodestring(self.title))
     retryable=msg.retryable
     self.connection.adjustCorrelationId(msg)
     correlationid=msg.correlation
     self.connection.sendPackage(msg.encodeMessage())
     response=self.connection.receivePackageWithCorrelationId(correlationid,retryable)
     msg2=ClientMessage.decodeMessage(response)
     return cachecodec.CacheDestroyCodec.decodeResponse(msg2).response
 def GetAndReplace(self,   key, value, expiryPolicy, completionId):
     msg=cachecodec.CacheGetAndReplaceCodec.encodeRequest( encode.encodestring(self.title), key, value, expiryPolicy, encode.encodeint32(completionId))
     retryable=msg.retryable
     self.connection.adjustCorrelationId(msg)
     correlationid=msg.correlation
     self.connection.sendPackage(msg.encodeMessage())
     response=self.connection.receivePackageWithCorrelationId(correlationid,retryable)
     msg2=ClientMessage.decodeMessage(response)
     return cachecodec.CacheGetAndReplaceCodec.decodeResponse(msg2).response
 def AddIndex(self,   attribute, ordered):
     msg=mapcodec.MapAddIndexCodec.encodeRequest( encode.encodestring(self.title), encode.encodestring(attribute), encode.encodeboolean(ordered))
     retryable=msg.retryable
     self.connection.adjustCorrelationId(msg)
     correlationid=msg.correlation
     self.connection.sendPackage(msg.encodeMessage())
     response=self.connection.getPackageWithCorrelationId(correlationid,retryable)
     msg2=ClientMessage.decodeMessage(response)
     return mapcodec.MapAddIndexCodec.decodeResponse(msg2)
 def Clear(self,  ):
     msg=mapcodec.MapClearCodec.encodeRequest( encode.encodestring(self.title))
     retryable=msg.retryable
     self.connection.adjustCorrelationId(msg)
     correlationid=msg.correlation
     self.connection.sendPackage(msg.encodeMessage())
     response=self.connection.getPackageWithCorrelationId(correlationid,retryable)
     msg2=ClientMessage.decodeMessage(response)
     return mapcodec.MapClearCodec.decodeResponse(msg2)
 def RemoveAll(self,   completionId):
     msg=cachecodec.CacheRemoveAllCodec.encodeRequest( encode.encodestring(self.title), encode.encodeint32(completionId))
     retryable=msg.retryable
     self.connection.adjustCorrelationId(msg)
     correlationid=msg.correlation
     self.connection.sendPackage(msg.encodeMessage())
     response=self.connection.receivePackageWithCorrelationId(correlationid,retryable)
     msg2=ClientMessage.decodeMessage(response)
     return cachecodec.CacheRemoveAllCodec.decodeResponse(msg2)
 def ExecuteOnAllKeys(self,   entryProcessor):
     msg=mapcodec.MapExecuteOnAllKeysCodec.encodeRequest( encode.encodestring(self.title), entryProcessor)
     retryable=msg.retryable
     self.connection.adjustCorrelationId(msg)
     correlationid=msg.correlation
     self.connection.sendPackage(msg.encodeMessage())
     response=self.connection.getPackageWithCorrelationId(correlationid,retryable)
     msg2=ClientMessage.decodeMessage(response)
     return mapcodec.MapExecuteOnAllKeysCodec.decodeResponse(msg2).entrySet
 def LoadGivenKeys(self,   keys, replaceExistingValues):
     msg=mapcodec.MapLoadGivenKeysCodec.encodeRequest( encode.encodestring(self.title), keys, encode.encodeboolean(replaceExistingValues))
     retryable=msg.retryable
     self.connection.adjustCorrelationId(msg)
     correlationid=msg.correlation
     self.connection.sendPackage(msg.encodeMessage())
     response=self.connection.getPackageWithCorrelationId(correlationid,retryable)
     msg2=ClientMessage.decodeMessage(response)
     return mapcodec.MapLoadGivenKeysCodec.decodeResponse(msg2)
 def ManagementConfig(self,   isStat, enabled, hostname, port):
     msg=cachecodec.CacheManagementConfigCodec.encodeRequest( encode.encodestring(self.title), encode.encodeboolean(isStat), encode.encodeboolean(enabled), encode.encodestring(hostname), encode.encodeint32(port))
     retryable=msg.retryable
     self.connection.adjustCorrelationId(msg)
     correlationid=msg.correlation
     self.connection.sendPackage(msg.encodeMessage())
     response=self.connection.receivePackageWithCorrelationId(correlationid,retryable)
     msg2=ClientMessage.decodeMessage(response)
     return cachecodec.CacheManagementConfigCodec.decodeResponse(msg2).response
 def EntryProcessor(self,   key, entryProcessor, arguments, completionId):
     msg=cachecodec.CacheEntryProcessorCodec.encodeRequest( encode.encodestring(self.title), key, entryProcessor, arguments, encode.encodeint32(completionId))
     retryable=msg.retryable
     self.connection.adjustCorrelationId(msg)
     correlationid=msg.correlation
     self.connection.sendPackage(msg.encodeMessage())
     response=self.connection.receivePackageWithCorrelationId(correlationid,retryable)
     msg2=ClientMessage.decodeMessage(response)
     return cachecodec.CacheEntryProcessorCodec.decodeResponse(msg2).response