Ejemplo n.º 1
0
    def send_propose(self, message: ACLMessage):

        message.set_protocol(ACLMessage.FIPA_CONTRACT_NET_PROTOCOL)
        message.set_performative(ACLMessage.PROPOSE)

        response = yield AgentSession(self, message)
        return response
Ejemplo n.º 2
0
    def connectionMade(self):
        """
            Este método é executado sempre que uma conexão é executada entre 
            um cliente e um servidor
        """

        # fase de identificação do agente com o AMS
        if self.factory.state == 'IDENT':
            # cria a mensagem de registro no AMS
            msg = ACLMessage()
            msg.add_receiver(
                AID(name='AMS' + '@' + self.factory.ams['name'] + ':' + str(self.factory.ams['port'])))
            msg.set_sender(self.factory.aid)
            msg.set_performative(ACLMessage.INFORM)
            msg.set_content(dumps(self.factory.aid))

            # envia a mensagem ao AMS
            self.factory.state = 'READY'
            self.sendLine(msg.get_message())
            self.transport.loseConnection()
        else:
            peer = self.transport.getPeer()
            for message in self.factory.messages:
                if int(message[0].port) == int(peer.port):
                    self.sendLine(message[1].get_message())
                    self.factory.messages.remove(message)
                    self.transport.loseConnection()
                    break
Ejemplo n.º 3
0
    def send_agree(self, message: ACLMessage):

        message.set_protocol(ACLMessage.FIPA_SUBSCRIBE_PROTOCOL)
        message.set_performative(ACLMessage.AGREE)

        # Send message to all receivers
        self.agent.send(message)
Ejemplo n.º 4
0
    def send_inform(self, message: ACLMessage):

        message.set_protocol(ACLMessage.FIPA_REQUEST_PROTOCOL)
        message.set_performative(ACLMessage.INFORM)

        # Send message to all receivers
        self.agent.send(message)
Ejemplo n.º 5
0
    def send_subscribe(self, message: ACLMessage):

        message.set_protocol(ACLMessage.FIPA_SUBSCRIBE_PROTOCOL)
        message.set_performative(ACLMessage.SUBSCRIBE)

        response = yield AgentSession(self, message)
        return response
Ejemplo n.º 6
0
    def send_refuse(self, message: ACLMessage):

        message.set_protocol(ACLMessage.FIPA_REQUEST_PROTOCOL)
        message.set_performative(ACLMessage.REFUSE)

        # Send message to all receivers
        self.agent.send(message)
Ejemplo n.º 7
0
    def send_failure(self, message: ACLMessage):

        message.set_protocol(ACLMessage.FIPA_REQUEST_PROTOCOL)
        message.set_performative(ACLMessage.FAILURE)

        # Send message to all receivers
        self.agent.send(message)
Ejemplo n.º 8
0
    def lineReceived(self, line):
        """Este método é executado sempre que uma mesagem é recebida pelo agente Sniffer
        """

        # este método é executado caso a mensagem recebida tenha sido enviada pelo AMS
        # para atualização da tabela de agentes disponíveis
        if 'AMS' in line:

            message = ACLMessage()
            message.set_message(line)

            self.fact.ui.listWidget.clear()

            # loop for verifica se os agentes enviados na lista do AMS já estão
            # cadastrados na tabela do agente
            self.fact.table = loads(message.content)

            for agent in self.fact.table:
                serifFont = QtGui.QFont(None, 10, QtGui.QFont.Bold)
                item = QtGui.QListWidgetItem(str(agent) + '\n')
                item.setFont(serifFont)
                self.fact.ui.listWidget.addItem(item)

        # caso a mensagem recebida seja de um agente a lista de mensagens deste
        # agente é atualizada
        else:
            PeerProtocol.lineReceived(self, line)
Ejemplo n.º 9
0
    def connectionMade(self):
        """Este método é executado sempre que uma
        conexão é executada entre um agente no modo
        cliente e um agente no modo servidor
        """

        # fase 1 de identificação do agente com o AMS
        if self.fact.state == 'IDENT1':
            # cria a mensagem de registro no AMS
            msg = ACLMessage()
            msg.add_receiver(
                AID(
                    name='AMS' + '@' + self.fact.ams['name'] +
                    ':' + str(self.fact.ams['port'])
                ))
            msg.set_sender(self.fact.aid)
            msg.set_performative(ACLMessage.INFORM)
            msg.set_content(dumps(self.fact.aid))

            # envia a mensagem ao AMS e atualiza a flag de identificação para a
            # fase 2
            self.fact.state = 'IDENT2'
            self.send_message(msg.get_message())
        # se não é a fase de identificação 1 então o agente tenta enviar as mensagens presentes
        # na fila de envio representada pela variável self.fact.messages
        else:
            # captura o host conectado ao agente por meio do metodo
            # self.transport.getPeer()
            PeerProtocol.connectionMade(self)
Ejemplo n.º 10
0
    def lineReceived(self, line):
        """Este método é executado sempre que uma mesagem é recebida pelo agente Sniffer
        """

        # este método é executado caso a mensagem recebida tenha sido enviada pelo AMS
        # para atualização da tabela de agentes disponíveis
        if 'AMS' in line:

            message = ACLMessage()
            message.set_message(line)

            self.fact.ui.listWidget.clear()

            # loop for verifica se os agentes enviados na lista do AMS já estão
            # cadastrados na tabela do agente
            self.fact.table = loads(message.content)

            for agent in self.fact.table:
                serifFont = QtGui.QFont(None, 10, QtGui.QFont.Bold)
                item = QtGui.QListWidgetItem(str(agent) + '\n')
                item.setFont(serifFont)
                self.fact.ui.listWidget.addItem(item)

        # caso a mensagem recebida seja de um agente a lista de mensagens deste
        # agente é atualizada
        else:
            PeerProtocol.lineReceived(self, line)
Ejemplo n.º 11
0
    def on_time(self):
        super(Time, self).on_time()
        message = ACLMessage(ACLMessage.INFORM)
        message.set_protocol(ACLMessage.FIPA_SUBSCRIBE_PROTOCOL)
        message.set_content(str(sin(self.inc)))

        self.notify(message)
        self.inc += 0.1
Ejemplo n.º 12
0
    def send_not_understood(self, message: ACLMessage):

        message.set_performative(ACLMessage.NOT_UNDERSTOOD)

        # Send message to all receivers
        self.agent.send(message)

        return AgentSession(self, message)
Ejemplo n.º 13
0
    def send_subscribe(self, message: ACLMessage):

        message.set_protocol(ACLMessage.FIPA_SUBSCRIBE_PROTOCOL)
        message.set_performative(ACLMessage.SUBSCRIBE)

        # Send message to all receivers
        self.agent.send_until(message)

        return message
Ejemplo n.º 14
0
    def send_refuse(self, message: ACLMessage):

        message.set_protocol(ACLMessage.FIPA_CONTRACT_NET_PROTOCOL)
        message.set_performative(ACLMessage.REFUSE)

        # Send message to all receivers
        self.agent.send_until(message)

        return message
Ejemplo n.º 15
0
    def send_reject_proposal(self, message: ACLMessage):

        message.set_protocol(ACLMessage.FIPA_CONTRACT_NET_PROTOCOL)
        message.set_performative(ACLMessage.REJECT_PROPOSAL)

        # Send message to all receivers
        self.agent.send_until(message)

        return message
Ejemplo n.º 16
0
    def send_agree(self, message: ACLMessage):

        message.set_protocol(ACLMessage.FIPA_REQUEST_PROTOCOL)
        message.set_performative(ACLMessage.AGREE)

        # Send message to all receivers
        self.agent.send_until(message)

        return message
Ejemplo n.º 17
0
    def send_request(self, message: ACLMessage):
        # Only individual messages
        assert len(message.receivers) == 1

        message.set_protocol(ACLMessage.FIPA_REQUEST_PROTOCOL)
        message.set_performative(ACLMessage.REQUEST)

        response = yield AgentSession(self, message)
        return response
Ejemplo n.º 18
0
 def send_message(self, receiver_agent, book):
     message = ACLMessage(ACLMessage.INFORM)
     message.set_protocol(ACLMessage.FIPA_REQUEST_PROTOCOL)
     message.add_receiver(receiver_agent)
     self.add_all_agents(message.receivers)
     if book is None:
         message.set_content('Requested book is not available')
     else:
         message.set_content(book)
     self.send(message)
Ejemplo n.º 19
0
 def inform(self, message: ACLMessage):
     """Use low-level twisted method to send message"""
     message.set_performative(ACLMessage.INFORM)
     receiver = message.receivers[0]
     try:
         self.agent.agentInstance.messages.append((receiver, message))
         reactor.connectTCP(receiver.host, receiver.port,
                            self.agent.agentInstance)
     except:
         self.agent.agentInstance.messages.pop()
Ejemplo n.º 20
0
 def update_ams(self, ams):
     super(Agent, self).update_ams(ams)
     message = ACLMessage(ACLMessage.SUBSCRIBE)
     message.set_protocol(ACLMessage.FIPA_SUBSCRIBE_PROTOCOL)
     ams_aid = AID('ams@' + self.ams['name'] + ':' + str(self.ams['port']))
     message.add_receiver(ams_aid)
     message.set_content('IDENT')
     message.set_system_message(is_system_message=True)
     self.comport_ident = SubscribeBehaviour(self, message)
     self.system_behaviours.append(self.comport_ident)
Ejemplo n.º 21
0
 def connectionLost(self, reason):
     if self.message is not None:
         try:
             message = ACLMessage()
             message.set_message(self.message)
         except:
             print('Message not understood')
             print(self.message)
             return
         return message
Ejemplo n.º 22
0
 def one_request(self, receiver):
     message = ACLMessage()
     message.add_receiver(receiver)
     while True:
         try:
             response = yield from self.req.send_request(message)
         except FipaMessageHandler as h:
             response = h.message
         except FipaProtocolComplete:
             break
     return response
Ejemplo n.º 23
0
 def clientConnectionFailed(self, connector, reason):
     for name, aid in self.table.iteritems():
         if aid.port == connector.port:
             display_message(
                 self.aid.name, 'O agente ' + aid.name + ' esta desconectado.')
             print reason
             self.table.pop(name)
             message = ACLMessage(ACLMessage.INFORM)
             message.set_sender(self.aid)
             message.set_content(dumps(self.table))
             self.protocol.broadcast_message(message)
             break
Ejemplo n.º 24
0
    def lineReceived(self, line):
        """
            Quando uma mensagem é enviada ao AMS este método é executado.
            Quando em fase de identificação, o AMS registra o agente
            em sua tabele de agentes ativos
        """
        message = ACLMessage()
        # carrega a mesagem recebida no objeto message
        message.set_message(line)

        # como o agente AMS só recebe mensagens
        self.handle_identif(loads(message.content))
Ejemplo n.º 25
0
    def lineReceived(self, line):
        """
            Quando uma mensagem é enviada ao AMS este método é executado.
            Quando em fase de identificação, o AMS registra o agente
            em sua tabele de agentes ativos
        """
        message = ACLMessage()
        # carrega a mesagem recebida no objeto message
        message.set_message(line)

        # como o agente AMS só recebe mensagens
        self.handle_identif(loads(message.content))
 def send_message(self, receiver_agent):
     message = ACLMessage(ACLMessage.INFORM)
     message.set_protocol(ACLMessage.FIPA_REQUEST_PROTOCOL)
     message.add_receiver(receiver_agent)
     self.add_all_agents(message.receivers)
     message.set_content('I have received Student Object successfully')
     self.send(message)
Ejemplo n.º 27
0
 def send_message(self, receiver_agent):
     message = ACLMessage(ACLMessage.INFORM)
     message.set_protocol(ACLMessage.FIPA_REQUEST_PROTOCOL)
     message.add_receiver(receiver_agent)
     self.add_all_agents(message.receivers)
     message.set_content(self.message)
     self.send(message)
Ejemplo n.º 28
0
    def send_message(self):
        try:
            message = ACLMessage(ACLMessage.INFORM)
            message.set_protocol(ACLMessage.FIPA_REQUEST_PROTOCOL)
            message.add_receiver(self.computer_agent)
            self.add_all_agents(message.receivers)
            print("Human's Turn")
            i = None
            j = None
            #check wrong inputs by human
            while (True):
                digit = True
                in_range = True
                new_pos = True
                pos = input('Enter your position:')
                if not pos.isdigit():
                    digit = False
                    print("Please enter a digit!")
                    continue

                pos = int(pos)
                if (pos < 1 or pos > 9):
                    in_range = False
                    print("Enter between 1-9")
                    continue

            # mapping the position entered with board position
                if (pos <= 3):
                    i = 0
                elif (pos > 3 and pos <= 6):
                    i = 1
                else:
                    i = 2

                if (pos % 3 == 0):
                    j = 2
                else:
                    j = pos % 3 - 1
                if (board[i][j] != '_'):
                    new_pos = False
                    print("Already occupied!")
                    continue
                break

            board[i][j] = 'X'
            print_board()
            result = finished()

            if (result == 'X'):
                print("You won !")
                sys.exit()
            elif (result == "Tie"):
                print("Tie\n")
                sys.exit()

            message.set_content('Human Agent played "X" at position' +
                                str(pos))
            self.send(message)
        except:
            print("")
Ejemplo n.º 29
0
    def send_message(self, receiver_agent):
        try:
            message = ACLMessage(ACLMessage.INFORM)
            message.set_protocol(ACLMessage.FIPA_REQUEST_PROTOCOL)
            message.add_receiver(receiver_agent)
            self.add_all_agents(message.receivers)
            print("Computer's Turn")

            start = time.time()
            (m, pos_x, pos_y) = maximize()
            finish = time.time()
            print("time =", round((finish - start), 5), "sec")
            board[pos_x][pos_y] = 'O'
            print_board()
            result = finished()
            if (result == 'O'):
                print("Computer won !")
                sys.exit()
            elif (result == "Tie"):
                print("tie")
                sys.exit()

            message.set_content('Computer Agent played "O" at position')
            self.send(message)
        except:
            print("")
Ejemplo n.º 30
0
    def connectionLost(self, reason):
        """Este método executa qualquer coisa quando uma conexão é perdida

        :param reason: Identifica o problema na perda de conexão
        """
        if self.message is not None:
            message = PeerProtocol.connectionLost(self, reason)

            # envia mensagem recebida para o AMS

            # montagem da mensagem a ser enviada ao AMS
            _message = ACLMessage(ACLMessage.INFORM)
            ams_aid = AID(name='AMS@' + self.fact.ams['name'] + ':' +
                          str(self.fact.ams['port']))
            _message.add_receiver(ams_aid)
            _message.set_sender(self.fact.aid)
            _message.set_content(dumps({'ref': 'MESSAGE', 'message': message}))
            # fim da montagem da mensagem

            # armazenamento da mensagem para envio
            self.fact.messages.append((ams_aid, _message))

            # estabelecimento de conexão com AMS
            reactor.connectTCP(self.fact.ams['name'],
                               int(self.fact.ams['port']), self.fact)

            # execução do comportamento Agent.react à mensagem
            # recebida
            self.message = None
            self.fact.react(message)
Ejemplo n.º 31
0
 def send_message(self):
     message = ACLMessage(ACLMessage.QUERY_IF)
     message.set_protocol(ACLMessage.FIPA_QUERY_PROTOCOL)
     message.add_receiver(self.receiver_agent)
     self.add_all_agents(message.receivers)
     message.set_content(self.message)
     self.send(message)
Ejemplo n.º 32
0
    def handle_request(self, message):

        # carrega o conteudo da mensagem recebida
        self.content = json.loads(message.content)

        if self.content['ref'] == 'R_04':
            display_message(self.agent.aid.name, 'Mensagem REQUEST recebida')

            # cria resposta para a mensagem recebida
            resposta = message.create_reply()
            resposta.set_performative(ACLMessage.INFORM)
            content = json.dumps({'ref': 'R_04'}, indent=4)
            resposta.set_content(content)
            self.agent.send(resposta)

            rams_desener = self.encontrar_rams_desener()

            message = ACLMessage(ACLMessage.CFP)
            message.set_protocol(ACLMessage.FIPA_CONTRACT_NET_PROTOCOL)
            message.set_content(json.dumps({'ref': 'CN_01',
                                            'dados': pickle.dumps(rams_desener)
                                            },
                                indent=4))

            for agente in self.agent.topologia['alimentadores'].keys():
                if self.agent.aid.localname not in agente:
                    message.add_receiver(AID(agente))

            # lança comportamento ContractNet na versão Iniciante
            comp = CompContNet1(self.agent, message)
            self.agent.behaviours.append(comp)
            comp.on_start()
Ejemplo n.º 33
0
        def individual_request(receiver):
            message = ACLMessage()
            message.set_ontology(swc.__name__)
            message.set_content(message_content)
            message.add_receiver(receiver)

            while True:
                try:
                    response = yield from self.p_command.send_request(message)
                    display_message(
                        self.aid.name,
                        f'[Comando de Chave] Inform: {response.content}')
                except FipaRefuseHandler as h:
                    response = h.message
                    display_message(
                        self.aid.name,
                        f'[Comando de Chave] Refuse: {response.content}')
                except FipaFailureHandler as h:
                    response = h.message
                    display_message(
                        self.aid.name,
                        f'[Comando de Chave] Failure: {response.content}')
                except FipaAgreeHandler:
                    pass
                except FipaProtocolComplete:
                    break
            return response
Ejemplo n.º 34
0
    def __init__(self, host, port, session, main_ams=True, debug=False):
        self.ams_aid = AID('ams@' + str(host) + ':' + str(port))
        super(AMS, self).__init__(self.ams_aid, debug=debug)
        self.ams = {'name': str(host), 'port': str(port)}
        super(AMS, self).update_ams(self.ams)
        self.host = host
        self.port = port
        self.session = session
        self.main_ams = main_ams

        self.agents_conn_time = dict()
        self.comport_ident = PublisherBehaviour(self)

        # message to check the connection.
        message = ACLMessage(ACLMessage.REQUEST)
        message.set_protocol(ACLMessage.FIPA_REQUEST_PROTOCOL)
        self.add_all(message)
        message.set_content('CONNECTION')
        message.set_system_message(is_system_message=True)

        self.comport_conn_verify = CompConnectionVerify(self, message)
        self.comport_send_conn_messages = ComportSendConnMessages(
            self, message, 4.0)
        self.comport_conn_verify_timed = ComportVerifyConnTimed(self, 10.0)
        self.comport_conn_verify_reg = CompVerifyRegister(self)

        self.system_behaviours.append(self.comport_ident)
        self.system_behaviours.append(self.comport_conn_verify)
        self.system_behaviours.append(self.comport_send_conn_messages)
        self.system_behaviours.append(self.comport_conn_verify_timed)
        self.system_behaviours.append(self.comport_conn_verify_reg)
        self.on_start()
Ejemplo n.º 35
0
 def send_response(self, response, sender):
     
     answer = ACLMessage(ACLMessage.ACCEPT_PROPOSAL)
     answer.set_protocol(ACLMessage.FIPA_CONTRACT_NET_PROTOCOL)
     answer.set_content(pickle.dumps(response))
     answer.add_receiver(sender)
     self.agent.send(answer)
Ejemplo n.º 36
0
 def notify(self):
     message = ACLMessage(ACLMessage.INFORM)
     message.set_protocol(ACLMessage.FIPA_SUBSCRIBE_PROTOCOL)
     message.set_content(dumps(self.agent.agentInstance.table))
     message.set_system_message(is_system_message=True)
     self.STATE = 0
     super(PublisherBehaviour, self).notify(message)
Ejemplo n.º 37
0
    def lineReceived(self, line):
        """
            Este método é executado sempre que uma mesagem é recebida pelo agente Sniffer
        """

        message = ACLMessage()
        message.set_message(line)

        display_message(self.factory.aid.name,
                        'Mensagem recebida de: ' + str(message.sender.name))

        # este método é executado caso a mensagem recebida tenha sido enviada pelo AMS
        # para atualização da tabela de agentes disponíveis
        if 'AMS' in message.sender.name:
            self.factory.ui.listWidget.clear()

            # loop for verifica se os agentes enviados na lista do AMS já estão
            # cadastrados na tabela do agente
            self.factory.table = loads(message.content)

            for agent in self.factory.table:
                serifFont = QtGui.QFont(None, 10, QtGui.QFont.Bold)
                item = QtGui.QListWidgetItem(str(agent) + '\n')
                item.setFont(serifFont)
                self.factory.ui.listWidget.addItem(item)

        # caso a mensagem recebida seja de um agente a lista de mensagens deste
        # agente é atualizada
        elif message.performative == ACLMessage.INFORM:

            display_message(
                self.factory.aid.name, 'Lista de Mensagens Recebida')

            agent = message.sender.name
            for i in self.factory.agents_messages:
                if agent == i:
                    messages = self.factory.agents_messages[i]
                    messages.extend(loads(message.content))
                    self.factory.agents_messages[i] = messages
                    break
            else:
                self.factory.agents_messages[agent] = loads(message.content)

            print self.factory.agents_messages[agent]
            self.show_messages(self.factory.agents_messages[agent])
Ejemplo n.º 38
0
    def onItemChanged(self, current, previous):
        for name, aid in self.table.iteritems():
            if name in current.text() and not ('Sniffer' in name):
                message = ACLMessage(ACLMessage.REQUEST)
                message.set_sender(self.aid)
                message.add_receiver(aid)
                message.set_content('Request messages history')

                self.messages.append((aid, message))

                reactor.connectTCP(aid.host, aid.port, self)
                break
Ejemplo n.º 39
0
    def __init__(self, aid):
        super(AgenteIniciante, self).__init__(aid=aid, debug=False)

        message = ACLMessage(ACLMessage.CFP)
        message.set_protocol(ACLMessage.FIPA_CONTRACT_NET_PROTOCOL)
        message.set_content('60.0')
        message.add_receiver(AID('AP1'))
        message.add_receiver(AID('AP2'))

        comp = CompContNet1(self, message)
        self.behaviours.append(comp)
        self.call_later(2.0, comp.on_start)
Ejemplo n.º 40
0
    def connectionMade(self):
        """
            Este método é executado sempre que uma conexão é executada entre
            um cliente e um servidor
        """

        # fase de identificação do agente com o AMS
        if self.fact.state == 'IDENT':
            # cria a mensagem de registro no AMS
            msg = ACLMessage()
            msg.add_receiver(
                AID(name='AMS' + '@' + self.fact.ams['name'] + ':' + str(self.fact.ams['port'])))
            msg.set_sender(self.fact.aid)
            msg.set_performative(ACLMessage.INFORM)
            msg.set_content(dumps(self.fact.aid))

            # envia a mensagem ao AMS
            self.fact.state = 'READY'
            self.sendLine(msg.get_message())
            self.transport.loseConnection()
            display_message(self.fact.aid.localname, "Mensagem de autenticacao enviada")
        else:
            PeerProtocol.connectionMade(self)
Ejemplo n.º 41
0
    def __init__(self, aid):
        super(AgenteRelogio, self).__init__(aid=aid)

        # mensagem que requisita horario do horario
        message = ACLMessage(ACLMessage.REQUEST)
        message.set_protocol(ACLMessage.FIPA_REQUEST_PROTOCOL)
        message.add_receiver(AID(name='horario'))
        message.set_content('time')

        self.comport_request = CompRequest2(self, message)
        self.comport_temp = ComportTemporal(self, 1.0, message)

        self.behaviours.append(self.comport_request)
        self.behaviours.append(self.comport_temp)
Ejemplo n.º 42
0
    def filter(self, message):
        state = True
        
        if self.conversationID != None and self.conversationID != message.conversationID:
            state = False
        
        if self.sender != None and self.sender != message.sender:
            state = False
        
        if self.performative != None and self.performative != message.performative:
            state = False
        
        if self.protocol != None and self.protocol != message.protocol:
            state = False
            
        return state

if __name__ == '__main__':
    message = ACLMessage(ACLMessage.REQUEST)
    message.set_sender(AID('lucas'))
    message.add_receiver('allana')
    message.set_protocol(ACLMessage.FIPA_REQUEST_PROTOCOL)
    
    filtro = Filter()
    filtro.set_protocol(ACLMessage.FIPA_REQUEST_PROTOCOL)
    
    if filtro.filter(message):
        print message.as_xml()
    else:
        print 'A mensagem foi barrada pelo protocolo'
Ejemplo n.º 43
0
    def __init__(self, aid):
        super(AgenteParticipante, self).__init__(aid)

        self.protocol = SubscribeParticipant(self)
        self.timed = Time(self, self.protocol.notify)

        self.behaviours.append(self.protocol)
        self.behaviours.append(self.timed)

if __name__ == '__main__':

    set_ams('localhost', 5000, debug=False)

    editor = AgenteParticipante(AID('editor'))
    editor.ams = {'name': 'localhost', 'port': 5000}

    msg = ACLMessage(ACLMessage.SUBSCRIBE)
    msg.set_protocol(ACLMessage.FIPA_SUBSCRIBE_PROTOCOL)
    msg.set_content('Pedido de subscricao')
    msg.add_receiver('editor')

    ass1 = AgenteInitiator(AID('assinante_1'), msg)
    ass1.ams = {'name': 'localhost', 'port': 5000}

    ass2 = AgenteInitiator(AID('assinante_2'), msg)
    ass2.ams = {'name': 'localhost', 'port': 5000}

    agentes = [editor, ass1, ass2]

    start_loop(agentes, gui=True)
Ejemplo n.º 44
0
    def handle_identif(self, aid):
        """
            handle_identif
            --------------

            Este método é utilizado para cadastrar o agente que esta se identificando
            na tabela de agentes ativos.
        """
        if aid.name in self.factory.table:
            display_message(
                'AMS', 'Falha na Identificacao do agente ' + aid.name)

            # prepara mensagem de resposta
            message = ACLMessage(ACLMessage.REFUSE)
            message.set_sender(self.factory.aid)
            message.add_receiver(aid)
            message.set_content(
                'Ja existe um agente com este identificador. Por favor, escolha outro.')
            # envia mensagem
            self.sendLine(message.get_message())
            return
        self.aid = aid
        self.factory.table[self.aid.name] = self.aid
        display_message(
            'AMS', 'Agente ' + aid.name + ' identificado com sucesso')

        # prepara mensagem de resposta
        message = ACLMessage(ACLMessage.INFORM)
        message.set_sender(self.factory.aid)
        for receiver in self.factory.table.values():
            message.add_receiver(receiver)

        message.set_content(dumps(self.factory.table))
        self.broadcast_message(message)
Ejemplo n.º 45
0
    def handle_all_proposes(self, proposes):
        """
        """

        super(CompContNet1, self).handle_all_proposes(proposes)

        melhor_propositor = None
        maior_potencia = 0.0
        demais_propositores = list()
        display_message(self.agent.aid.name, 'Analisando propostas...')

        i = 1

        # lógica de seleção de propostas pela maior potência disponibilizada
        for message in proposes:
            content = message.content
            potencia = float(content)
            display_message(self.agent.aid.name,
                            'Analisando proposta {i}'.format(i=i))
            display_message(self.agent.aid.name,
                            'Potencia Ofertada: {pot}'.format(pot=potencia))
            i += 1
            if potencia > maior_potencia:
                if melhor_propositor is not None:
                    demais_propositores.append(melhor_propositor)

                maior_potencia = potencia
                melhor_propositor = message.sender
            else:
                demais_propositores.append(message.sender)

        display_message(self.agent.aid.name,
                        'A melhor proposta foi de: {pot} VA'.format(
                            pot=maior_potencia))

        if demais_propositores != []:
            display_message(self.agent.aid.name,
                            'Enviando respostas de recusa...')
            resposta = ACLMessage(ACLMessage.REJECT_PROPOSAL)
            resposta.set_protocol(ACLMessage.FIPA_CONTRACT_NET_PROTOCOL)
            resposta.set_content('')
            for agente in demais_propositores:
                resposta.add_receiver(agente)

            self.agent.send(resposta)

        if melhor_propositor is not None:
            display_message(self.agent.aid.name,
                            'Enviando resposta de aceitacao...')

            resposta = ACLMessage(ACLMessage.ACCEPT_PROPOSAL)
            resposta.set_protocol(ACLMessage.FIPA_CONTRACT_NET_PROTOCOL)
            resposta.set_content('OK')
            resposta.add_receiver(melhor_propositor)
            self.agent.send(resposta)
Ejemplo n.º 46
0
Archivo: peer.py Proyecto: lucassm/Pade
 def connectionLost(self, reason):
     if self.message is not None:
         message = ACLMessage()
         message.set_message(self.message)
         return message
Ejemplo n.º 47
0
    def lineReceived(self, line):
        """Este método é executado sempre que uma
        nova mensagem é recebida pelo agente,
        tanto no modo cliente quanto no modo servidor

        :param line: mensagem recebida pelo agente
        """

        # TODO: Melhorar o armazenamento e a troca deste tipo de mensagem
        # entre o agente e o agente Sniffer

        # fase 2 de identificação do agente com o AMS. Nesta fase o agente AMS retorna uma mensagem
        # ao agente com uma tabela de todos os agentes presentes na rede
        if self.fact.state == 'IDENT2' and 'AMS' in line:
            message = ACLMessage()
            message.set_message(line)

            self.fact.table = loads(message.content)

            if self.fact.debug:
                display_message(
                    self.fact.aid.name, 'Tabela atualizada: ' + str(self.fact.table.keys()))
            else:
                pass

            # alteração do estado de em fase de identificação
            # para pronto para receber mensagens
            self.fact.state = 'READY'
            self.fact.on_start()
            # self.transport.loseConnection()
        # caso o agente não esteja na fase 2 de identificação, então estará na fase
        # de recebimento de mensagens, e assim estará pronto para executar seus
        # comportamentos
        else:
            # este método é executado caso a mensagem recebida tenha sido enviada pelo AMS
            # para atualização da tabela de agentes disponíveis
            if 'AMS' in line:
                message = ACLMessage()
                message.set_message(line)
                self.fact.table = loads(message.content)
                if self.fact.debug:
                    display_message(
                        self.fact.aid.name, 'Tabela atualizada: ' + str(self.fact.table.keys()))
                else:
                    pass
                self.transport.loseConnection()
            # este método é executado caso a mensagem recebida tenha sido enviada pelo Agente Sniffer
            # que requisita a tabela de mensagens do agente
            elif 'Sniffer' in line:
                # se for a primeira mensagem recebida do agente Sniffer, então seu endereço, isto é nome
                # e porta, é armazenado na variável do tipo dicionário
                # self.fact.sniffer
                message = ACLMessage()
                message.set_message(line)

                if self.fact.debug:
                    display_message(
                        self.fact.aid.name, 'Solicitação do Sniffer Recebida')
                else:
                    pass

                self.sniffer_message(message)
                self.transport.loseConnection()
            # recebe uma parte da mensagem enviada
            else:
                PeerProtocol.lineReceived(self, line)