Python Message.setMethod方法代码示例

# 需要导入模块: from Message import Message [as 别名]
# 或者: from Message.Message import setMethod [as 别名]
    def getMessage(self):
	'''
	This method is responsible for getting messages from 
	the socket.
	'''
	foundIdx = self._streamStaged.find("Method")
	if (foundIdx == 0):
	    foundIdx2 = self._streamStaged.find("Method", foundIdx + 1)
	    if (foundIdx2 != -1):
		message = Message(self._streamStaged[foundIdx : foundIdx2 - 1])
		# Even that the message could have errors is complete
		self._streamStaged = self._streamStaged[foundIdx2 : ]
	    else:
		message = Message(self._streamStaged)
		if (message.isComplete( len(self._streamStaged) )):
		    self._streamStaged = ''
		else:
		    message = None
	else:
	    if (len(self._streamStaged) == 0):
		message = None
	    else:
		# The message is not well formed, so we create a message with method not specified
		message = Message('')
		message.setMethod(Message.UNDEFINED)
		self._streamStaged = self._streamStaged[foundIdx :]
	return message

# 需要导入模块: from Message import Message [as 别名]
# 或者: from Message.Message import setMethod [as 别名]
def send_availability(strProv,strResource, quantity):
    messageAvail = Message('')
    messageAvail.setMethod(Message.SEND_AVAILABILITY)
    messageAvail.setParameter('Provider', strProv)
    messageAvail.setParameter('Resource', strResource)
    messageAvail.setParameter('Quantity', quantity)
    return messageAvail

# 需要导入模块: from Message import Message [as 别名]
# 或者: from Message.Message import setMethod [as 别名]
def getAvailability(strProvider, serviceStr, bidId):
    messageGetAvailability = Message('')
    messageGetAvailability.setMethod(Message.GET_AVAILABILITY)
    messageGetAvailability.setParameter('Provider', strProvider)       
    messageGetAvailability.setParameter('Service', serviceStr)
    messageGetAvailability.setParameter('Bid', bidId)
    return messageGetAvailability

# 需要导入模块: from Message import Message [as 别名]
# 或者: from Message.Message import setMethod [as 别名]
def purchaseService4(serviceId, bidId, quantity, delay, price):
    messagePurchase = Message('')
    messagePurchase.setMethod(Message.RECEIVE_PURCHASE)
    uuidId = uuid.uuid1()   # make a UUID based on the host ID and current time
    idStr = str(uuidId)
    messagePurchase.setParameter('Id', idStr)       
    messagePurchase.setParameter('Service', serviceId)
    messagePurchase.setParameter('Bid', bidId)
    messagePurchase.setParameter('Quantity', quantity)
    messagePurchase.setParameter('8', price) # Price decision variable
    messagePurchase.setParameter('7', delay) # Delay decision variable
    return messagePurchase

# 需要导入模块: from Message import Message [as 别名]
# 或者: from Message.Message import setMethod [as 别名]
 def messagePeriod(self,period):
     periodEnd = Message("")
     periodEnd.setMethod(Message.END_PERIOD)
     periodEnd.setParameter("Period", period)
     return periodEnd

# 需要导入模块: from Message import Message [as 别名]
# 或者: from Message.Message import setMethod [as 别名]
 def messageBids(self, period, body):
     bidsMes = Message("")
     bidsMes.setMethod(Message.RECEIVE_BID_INFORMATION)
     bidsMes.setParameter("Period", period)
     bidsMes.setBody(body)
     return bidsMes

# 需要导入模块: from Message import Message [as 别名]
# 或者: from Message.Message import setMethod [as 别名]
def test_bid_capacity():
    try:
        # Connect to Clock server and send data
        print 'Connecting Host:', HOST, ' Port:', PORT
        sock.connect((HOST, PORT))
        sock.sendall(message1.__str__())

        received = ""
        received = sock.recv(4096)
        recMsg = Message(received)
        if (recMsg.isMessageStatusOk()):
            connect = Message("")
            connect.setMethod(Message.GET_SERVICES)
            connect.setParameter("Service",serviceId)
            sock.sendall(connect.__str__())
            received = sock.recv(4096)
            serviceResponse = Message(received)
            if (serviceResponse.isMessageStatusOk() == False):
                print 'Service not received'
            else:
                print 'Successful Clock Server Connection'
                #print "Sent:     {}".format(message1.__str__())
                #print "Received: {}".format(received)

                # Connect to market Place server and send data
                print 'Connecting Host:', HOST2, ' Port:', PORT2
                sock2.connect((HOST2, PORT2))
                sock2.sendall(message1.__str__())
                received = sock2.recv(4096)
                recMsg = Message(received)
                if (recMsg.isMessageStatusOk()):                    
                    # sends the message with the port connect. This assumes that
                    # the program socket_server.py was previously executed.
                    port_message = Message("")
                    port_message.setMethod(Message.SEND_PORT)
                    port_message.setParameter("Port", agent_properties.l_port_provider)
                    port_message.setParameter("Type", "provider")
                    port_message.setParameter("CapacityType","bid")

                    sock2.sendall(port_message.__str__())
                    received = sock2.recv(4096)
                    recMsg = Message(received)
                    if (recMsg.isMessageStatusOk()):
                        pass

                    message, bidId1 = createCapacitatedBid(strProv, serviceId, str(0.155), str(17.5),str(10))
                    sock2.sendall(message.__str__())
                    verifyBid(sock2)

                    message, bidId2 = createCapacitatedBid(strProv, serviceId, str(0.15), str(18),str(15))
                    sock2.sendall(message.__str__())
                    verifyBid(sock2)

                    message, bidId3 = createCapacitatedBid(strProv, serviceId, str(0.145), str(19),str(20))
                    sock2.sendall(message.__str__())
                    verifyBid(sock2)

                    # Number of units consumed: 5
                    message = purchase(serviceId, bidId1, str(5), str(0.155), str(17.5))
                    sock2.sendall(message.__str__())
                    verifyPurchase(sock2,5)
                    
                    qtyAvail = 10
                    message = getAvailability(strProv,serviceId, bidId1)
                    sock2.sendall(message.__str__())
                    qtyAvail = round(qtyAvail - 5, 2)
                    verifyAvailability(sock2, qtyAvail)

                    # Number of units consumed: 5
                    message = purchase(serviceId, bidId1, str(7), str(0.155), str(17.5))
                    sock2.sendall(message.__str__())
                    verifyPurchase(sock2,5)

                    message = getAvailability(strProv,serviceId, bidId1)
                    sock2.sendall(message.__str__())
                    qtyAvail = 0
                    verifyAvailabilityMessage(sock2, qtyAvail)

    finally:
        sock.shutdown(socket.SHUT_WR)
        sock.close()
        sock2.shutdown(socket.SHUT_WR)
        sock2.close()

# 需要导入模块: from Message import Message [as 别名]
# 或者: from Message.Message import setMethod [as 别名]
def test_bulk_capacity_service4():

    message1= Message('')
    message1.setMethod(Message.CONNECT)
    strProv = "Provider8"
    serviceId = "4" # Priority_Class_Streaming
    message1.setParameter("Agent", strProv)

    try:
        # Connect to Clock server and send data
        print 'Connecting Host:', HOST, ' Port:', PORT
        sock.connect((HOST, PORT))
        sock.sendall(message1.__str__())

        received = ""
        received = sock.recv(4096)
        recMsg = Message(received)
        if (recMsg.isMessageStatusOk()):
            connect = Message("")
            connect.setMethod(Message.GET_SERVICES)
            connect.setParameter("Service",serviceId)
            sock.sendall(connect.__str__())
            received = sock.recv(4096)
            serviceResponse = Message(received)
            if (serviceResponse.isMessageStatusOk() == False):
                print 'Service not received'
            else:
                print 'Successful Clock Server Connection'
                #print "Sent:     {}".format(message1.__str__())
                #print "Received: {}".format(received)

                # Connect to market Place server and send data
                print 'Connecting Host:', HOST2, ' Port:', PORT2
                sock2.connect((HOST2, PORT2))
                sock2.sendall(message1.__str__())
                received = sock2.recv(4096)
                recMsg = Message(received)
                if (recMsg.isMessageStatusOk()):                    
                    # sends the message with the port connect. This assumes that
                    # the program socket_server.py was previously executed.
                    port_message = Message("")
                    port_message.setMethod(Message.SEND_PORT)
                    port_message.setParameter("Port", agent_properties.l_port_provider)
                    port_message.setParameter("Type", "provider")
                    port_message.setParameter("CapacityType","bulk")


                    print 'recMsg', port_message.__str__()

                    sock2.sendall(port_message.__str__())
                    received = sock2.recv(4096)
                    recMsg = Message(received)

                    print 'recMsg', recMsg.__str__()

                    if (recMsg.isMessageStatusOk()):
                        pass
                    time.sleep(1)    

                    print 'Successful Market Place Server Connection'

                    # send the provider availability
                    resource = "2"
                    message = send_availability(strProv,resource, str(120))
                    print 'message to send:' + message.__str__()

                    sock2.sendall(message.__str__())                
                    received = sock2.recv(4096)
                    print received
                    recMsg= Message(received)
                    if (not recMsg.isMessageStatusOk()):
                        raise FoundationException("error in sending availability")

                    print "It is connected to the agent server"     
                    # creates bids for the service 01
                    message, bidId1 = createBidService4(strProv, serviceId, str(0), str(0.324563087213))
                    sock2.sendall(message.__str__())
                    verifyBid(sock2)

                    # Number of resource used: 28.386816*(1 + 1)= 13.66
                    message = purchaseService4(serviceId, bidId1, str(28.386816), str(0), str(0.324563087213))
                    sock2.sendall(message.__str__())
                    received = sock2.recv(16800)
                    messagePur1 = Message(received)
                    if (not messagePur1.isMessageStatusOk()):
                        raise FoundationException("error in creating purchase" + messagePur1.__str__())
                    else:
                        print 'Message arrived \n' + messagePur1.__str__() 

                    message = getAvailability(strProv,serviceId,'')                
                    sock2.sendall(message.__str__())
                    qtyAvail = 120 - (28.386816*2)
                    qtyAvail = round(qtyAvail,2)
                    verifyAvailability(sock2, qtyAvail)

                    # Number of resource used: 66.749068 *(1 + 1)= 133.498136, as there are not enough quantities, the the server only purchase 31
                    message = purchaseService4(serviceId, bidId1, str(66.749068), str(0), str(0.324563087213))
                    sock2.sendall(message.__str__())
                    verifyPurchase(sock2,31.613184)
                    
#.........这里部分代码省略.........

# 需要导入模块: from Message import Message [as 别名]
# 或者: from Message.Message import setMethod [as 别名]
def test_bulk_capacity():
    try:
        # Connect to Clock server and send data
        print 'Connecting Host:', HOST, ' Port:', PORT
        sock.connect((HOST, PORT))
        sock.sendall(message1.__str__())

        received = ""
        received = sock.recv(4096)
        recMsg = Message(received)
        if (recMsg.isMessageStatusOk()):
            connect = Message("")
            connect.setMethod(Message.GET_SERVICES)
            connect.setParameter("Service",serviceId)
            sock.sendall(connect.__str__())
            received = sock.recv(4096)
            serviceResponse = Message(received)
            if (serviceResponse.isMessageStatusOk() == False):
                print 'Service not received'
            else:
                print 'Successful Clock Server Connection'
                #print "Sent:     {}".format(message1.__str__())
                #print "Received: {}".format(received)

                # Connect to market Place server and send data
                print 'Connecting Host:', HOST2, ' Port:', PORT2
                sock2.connect((HOST2, PORT2))
                sock2.sendall(message1.__str__())
                received = sock2.recv(4096)
                recMsg = Message(received)
                if (recMsg.isMessageStatusOk()):            		
                    # sends the message with the port connect. This assumes that
                    # the program socket_server.py was previously executed.
                    port_message = Message("")
                    port_message.setMethod(Message.SEND_PORT)
                    port_message.setParameter("Port", agent_properties.l_port_provider)
                    port_message.setParameter("Type", "provider")
                    port_message.setParameter("CapacityType","bulk")


                    print 'recMsg', port_message.__str__()

                    sock2.sendall(port_message.__str__())
                    received = sock2.recv(4096)
                    recMsg = Message(received)

                    print 'recMsg', recMsg.__str__()

                    if (recMsg.isMessageStatusOk()):
                        pass
                    time.sleep(1)    

                    print 'Successful Market Place Server Connection'
                    resource = "1"
                    # send the provider availability
                    message = send_availability(strProv,resource, str(100))
                    print 'message to send:' + message.__str__()

                    sock2.sendall(message.__str__())                
                    received = sock2.recv(4096)
                    print received
                    recMsg= Message(received)
                    if (not recMsg.isMessageStatusOk()):
                        raise FoundationException("error in sending availability")

                    print "It is connected to the agent server"		
                    # creates bids for the service 01
                    message, bidId1 = createBid(strProv, serviceId, str(0.145), str(20))
                    sock2.sendall(message.__str__())
                    verifyBid(sock2)

                    # Number of resource used: 10*(0.4 + 1*(0.916666667)= 13.66
                    message = purchase(serviceId, bidId1, str(10), str(0.145), str(20))
                    sock2.sendall(message.__str__())
                    received = sock2.recv(16800)
                    messagePur1 = Message(received)
                    if (not messagePur1.isMessageStatusOk()):
                        raise FoundationException("error in creating purchase")

                    message = getAvailability(strProv,serviceId,'')                
                    sock2.sendall(message.__str__())
                    qtyAvail = round(100 - 13.166,2)
                    verifyAvailability(sock2, qtyAvail)

                    message, bidId2 = createBid(strProv, serviceId, str(0.16), str(18))
                    sock2.sendall(message.__str__())
                    verifyBid(sock2)

                    # Number of resource used: 5*(0.4 + 1*(0.6667))=5.333
                    message = purchase(serviceId, bidId2, str(5), str(0.16), str(18))
                    sock2.sendall(message.__str__())
                    verifyPurchase(sock2,5)

                    message = getAvailability(strProv,serviceId,'')                
                    sock2.sendall(message.__str__())
                    qtyAvail = round(qtyAvail - 5.333,2)
                    verifyAvailability(sock2, qtyAvail)

                    message, bidId3 = createBid(strProv, serviceId, str(0.15), str(21))
                    sock2.sendall(message.__str__())
#.........这里部分代码省略.........

# 需要导入模块: from Message import Message [as 别名]
# 或者: from Message.Message import setMethod [as 别名]
    for bidXmlNode in bidXmLNodes:
        bid = Bid()
        bid.setFromXmlNode(bidXmlNode)
        val_return.append(bid)
    logging.info('Ending handleFront')
    return val_return
		 


sys.path.insert(1,'/home/network_agents_ver2_python/agents/foundation')

HOST, PORT = agent_properties.addr_clock_server, agent_properties.clock_listening_port # clock server port
HOST2, PORT2 = agent_properties.addr_mktplace_isp , agent_properties.mkt_place_listening_port # market server port

message1= Message('')
message1.setMethod(Message.CONNECT)
strProv = "Provider3"
serviceId = "1" # Movie Streaming
message1.setParameter("Agent", strProv)

# Create a socket (SOCK_STREAM means a TCP socket)
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock2 = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

def createBid(strProv, serviceId, delay, price):
    bid = Bid()
    uuidId = uuid.uuid1()	# make a UUID based on the host ID and current time
    idStr = str(uuidId)
    bid.setValues(idStr, strProv, serviceId)
    bid.setDecisionVariable("1", price)     # Price
    bid.setDecisionVariable("2", delay)  # Delay