def __init__(
self,
agent_address: Address,
webhook_address: Address,
webhook_port: int,
webhook_url_path: str,
connection_id: PublicId,
logger: logging.Logger = _default_logger,
):
"""
Initialize a webhook channel.
:param agent_address: the address of the agent
:param webhook_address: webhook hostname / IP address
:param webhook_port: webhook port number
:param webhook_url_path: the url path to receive webhooks from
:param connection_id: the connection id
"""
self.agent_address = agent_address
self.webhook_address = webhook_address
self.webhook_port = webhook_port
self.webhook_url_path = webhook_url_path
self.webhook_site = None # type: Optional[web.TCPSite]
self.runner = None # type: Optional[web.AppRunner]
self.app = None # type: Optional[web.Application]
self.is_stopped = True
self.connection_id = connection_id
self.in_queue = None # type: Optional[asyncio.Queue] # pragma: no cover
self.logger = logger
self.logger.info("Initialised a webhook channel")
self._dialogues = HttpDialogues(str(WebhookConnection.connection_id))
def __init__(
self,
address: Address,
host: str,
port: int,
api_spec_path: Optional[str],
connection_id: PublicId,
restricted_to_protocols: Set[PublicId],
timeout_window: float = 5.0,
logger: logging.Logger = _default_logger,
):
"""
Initialize a channel and process the initial API specification from the file path (if given).
:param address: the address of the agent.
:param host: RESTful API hostname / IP address
:param port: RESTful API port number
:param api_spec_path: Directory API path and filename of the API spec YAML source file.
:param connection_id: public id of connection using this chanel.
:param restricted_to_protocols: set of restricted protocols
:param timeout_window: the timeout (in seconds) for a request to be handled.
"""
super().__init__(address=address, connection_id=connection_id)
self.host = host
self.port = port
self.server_address = "http://{}:{}".format(self.host, self.port)
self.restricted_to_protocols = restricted_to_protocols
self._api_spec = APISpec(api_spec_path, self.server_address, logger)
self.timeout_window = timeout_window
self.http_server: Optional[web.TCPSite] = None
self.pending_requests: Dict[RequestId, Future] = {}
self._dialogues = HttpDialogues(self.address)
self.logger = logger
def setup(self):
"""Initialise the test case."""
self.identity = Identity("name", address="my_key")
self.agent_address = self.identity.address
self.host = get_host()
self.port = get_unused_tcp_port()
self.api_spec_path = os.path.join(
ROOT_DIR, "tests", "data", "petstore_sim.yaml"
)
self.connection_id = HTTPServerConnection.connection_id
self.protocol_id = PublicId.from_str("fetchai/http:0.4.0")
self.configuration = ConnectionConfig(
host=self.host,
port=self.port,
api_spec_path=self.api_spec_path,
connection_id=HTTPServerConnection.connection_id,
restricted_to_protocols=set([self.protocol_id]),
)
self.http_connection = HTTPServerConnection(
configuration=self.configuration, identity=self.identity,
)
self.loop = asyncio.get_event_loop()
self.loop.run_until_complete(self.http_connection.connect())
self.connection_address = str(HTTPServerConnection.connection_id)
self._dialogues = HttpDialogues(self.connection_address)
self.original_timeout = self.http_connection.channel.RESPONSE_TIMEOUT
def setup_client(self):
"""Set up client connection."""
self.client_agent_address = "client_agent_address"
self.client_agent_identity = Identity(
"agent running client", address=self.client_agent_address)
configuration = ConnectionConfig(
host="localost",
port="8888", # TODO: remove host/port for client?
connection_id=HTTPClientConnection.connection_id,
)
self.client = HTTPClientConnection(configuration=configuration,
identity=self.client_agent_identity)
self.loop.run_until_complete(self.client.connect())
# skill side dialogues
def role_from_first_message( # pylint: disable=unused-argument
message: Message,
receiver_address: Address) -> BaseDialogue.Role:
"""Infer the role of the agent from an incoming/outgoing first message
:param message: an incoming/outgoing first message
:param receiver_address: the address of the receiving agent
:return: The role of the agent
"""
return HttpDialogue.Role.CLIENT
self._client_dialogues = HttpDialogues(
self.client_agent_address,
role_from_first_message=role_from_first_message)
def setup_server(self):
"""Set up server connection."""
self.server_agent_address = "server_agent_address"
self.server_agent_identity = Identity(
"agent running server", address=self.server_agent_address
)
self.host = get_host()
self.port = get_unused_tcp_port()
self.connection_id = HTTPServerConnection.connection_id
self.protocol_id = PublicId.from_str("fetchai/http:0.4.0")
self.configuration = ConnectionConfig(
host=self.host,
port=self.port,
api_spec_path=None, # do not filter on API spec
connection_id=HTTPServerConnection.connection_id,
restricted_to_protocols=set([self.protocol_id]),
)
self.server = HTTPServerConnection(
configuration=self.configuration, identity=self.server_agent_identity,
)
self.loop = asyncio.get_event_loop()
self.loop.run_until_complete(self.server.connect())
# skill side dialogues
self._server_dialogues = HttpDialogues(self.server_agent_address)
def __init__(self):
"""Set dialogues."""
# pylint: disable=unused-argument
def role(m: Message, addr: Address) -> Dialogue.Role:
return HttpDialogue.Role.CLIENT
self.addr = self.random_string
self.dialogues = HttpDialogues(self.addr, role_from_first_message=role)
def setup(self) -> None:
"""Noop setup."""
# pylint: disable=attribute-defined-outside-init, unused-argument
self.count: int = 0
self.rtt_total_time: float = 0.0
self.rtt_count: int = 0
self.latency_total_time: float = 0.0
self.latency_count: int = 0
def role(m: Message, addr: Address) -> Dialogue.Role:
return HttpDialogue.Role.CLIENT
self.dialogues = HttpDialogues(self.context.agent_address,
role_from_first_message=role)
def setup(self):
"""Initialise the class."""
self.address = get_host()
self.port = get_unused_tcp_port()
self.agent_identity = Identity("name", address="some string")
self.agent_address = self.agent_identity.address
configuration = ConnectionConfig(
host=self.address,
port=self.port,
connection_id=HTTPClientConnection.connection_id,
)
self.http_client_connection = HTTPClientConnection(
configuration=configuration, identity=self.agent_identity)
self.http_client_connection.loop = asyncio.get_event_loop()
self.connection_address = str(HTTPClientConnection.connection_id)
self.http_dialogs = HttpDialogues(self.connection_address)
def setup_client(self):
"""Set up client connection."""
self.client_agent_address = "client_agent_address"
self.client_agent_identity = Identity(
"agent running client", address=self.client_agent_address
)
configuration = ConnectionConfig(
host="localost",
port="8888", # TODO: remove host/port for client?
connection_id=HTTPClientConnection.connection_id,
)
self.client = HTTPClientConnection(
configuration=configuration, identity=self.client_agent_identity
)
self.client.loop = asyncio.get_event_loop()
self.loop.run_until_complete(self.client.connect())
# skill side dialogues
self._client_dialogues = HttpDialogues(self.client_agent_address)
def setup(self):
"""Initialise the class."""
self.host = get_host()
self.port = get_unused_tcp_port()
self.identity = Identity("", address="some string")
self.path = "/webhooks/topic/{topic}/"
self.loop = asyncio.get_event_loop()
configuration = ConnectionConfig(
webhook_address=self.host,
webhook_port=self.port,
webhook_url_path=self.path,
connection_id=WebhookConnection.connection_id,
)
self.webhook_connection = WebhookConnection(
configuration=configuration, identity=self.identity,
)
self.webhook_connection.loop = self.loop
self.dialogues = HttpDialogues(self.identity.address)
def setup_server(self):
"""Set up server connection."""
self.server_agent_address = "server_agent_address"
self.server_agent_identity = Identity(
"agent running server", address=self.server_agent_address)
self.host = get_host()
self.port = get_unused_tcp_port()
self.connection_id = HTTPServerConnection.connection_id
self.protocol_id = HttpMessage.protocol_id
self.configuration = ConnectionConfig(
host=self.host,
port=self.port,
api_spec_path=None, # do not filter on API spec
connection_id=HTTPServerConnection.connection_id,
restricted_to_protocols=set([self.protocol_id]),
)
self.server = HTTPServerConnection(
configuration=self.configuration,
identity=self.server_agent_identity,
)
self.loop = asyncio.get_event_loop()
self.loop.run_until_complete(self.server.connect())
# skill side dialogues
def role_from_first_message( # pylint: disable=unused-argument
message: Message,
receiver_address: Address) -> BaseDialogue.Role:
"""Infer the role of the agent from an incoming/outgoing first message
:param message: an incoming/outgoing first message
:param receiver_address: the address of the receiving agent
:return: The role of the agent
"""
return HttpDialogue.Role.SERVER
self._server_dialogues = HttpDialogues(
self.server_agent_address,
role_from_first_message=role_from_first_message)
def __init__(
self,
agent_address: Address,
address: str,
port: int,
connection_id: PublicId,
excluded_protocols: Optional[Set[PublicId]] = None,
restricted_to_protocols: Optional[Set[PublicId]] = None,
):
"""
Initialize an http client channel.
:param agent_address: the address of the agent.
:param address: server hostname / IP address
:param port: server port number
:param excluded_protocols: this connection cannot handle messages adhering to any of the protocols in this set
:param restricted_to_protocols: this connection can only handle messages adhering to protocols in this set
"""
self.agent_address = agent_address
self.address = address
self.port = port
self.connection_id = connection_id
self.restricted_to_protocols = restricted_to_protocols
self._dialogues = HttpDialogues(str(
HTTPClientConnection.connection_id))
self._in_queue = None # type: Optional[asyncio.Queue] # pragma: no cover
self._loop = (
None
) # type: Optional[asyncio.AbstractEventLoop] # pragma: no cover
self.excluded_protocols = excluded_protocols
self.is_stopped = True
self._tasks: Set[Task] = set()
self.logger = logger
self.logger.info("Initialised the HTTP client channel")