def __init__(self, url=None, connector=None, session=None, ssl_context=None, api_version='v1.35'): docker_host = url # rename if docker_host is None: docker_host = os.environ.get('DOCKER_HOST', None) if docker_host is None: for sockpath in _sock_search_paths: if sockpath.is_socket(): docker_host = 'unix://' + str(sockpath) break self.docker_host = docker_host assert _rx_version.search(api_version) is not None, \ 'Invalid API version format' self.api_version = api_version if docker_host is None: raise ValueError( "Missing valid docker_host." "Either DOCKER_HOST or local sockets are not available.") if connector is None: if _rx_tcp_schemes.search(docker_host): if os.environ.get('DOCKER_TLS_VERIFY', '0') == '1': ssl_context = self._docker_machine_ssl_context() docker_host = _rx_tcp_schemes.sub('https://', docker_host) else: ssl_context = None connector = aiohttp.TCPConnector(ssl_context=ssl_context) self.docker_host = docker_host elif docker_host.startswith('unix://'): connector = aiohttp.UnixConnector(docker_host[7:]) # dummy hostname for URL composition self.docker_host = "unix://localhost" else: raise ValueError('Missing protocol scheme in docker_host.') self.connector = connector if session is None: session = aiohttp.ClientSession(connector=self.connector) self.session = session self.events = DockerEvents(self) self.containers = DockerContainers(self) self.swarm = DockerSwarm(self) self.services = DockerServices(self) self.tasks = DockerTasks(self) self.images = DockerImages(self) self.volumes = DockerVolumes(self) self.networks = DockerNetworks(self) self.nodes = DockerSwarmNodes(self) self.system = DockerSystem(self) # legacy aliases self.pull = self.images.pull self.push = self.images.push
async def is_portal(): logger.debug("Connecting to captive portal socket...") conn = aiohttp.UnixConnector(path=app["captive-portal"]) async with aiohttp.ClientSession(connector=conn) as session: async with session.get('http://localhost/portal') as resp: logger.debug("Received captive portal response: %s", resp.status) return await resp.json()
def _get_conn( self, remote_runner_mapping: t.Dict[str, str] = Provide[ DeploymentContainer.remote_runner_mapping], ) -> "BaseConnector": import aiohttp if (self._loop is None or self._conn is None or self._conn.closed or self._loop.is_closed()): self._loop = asyncio.get_event_loop() bind_uri = remote_runner_mapping[self._runner.name] parsed = urlparse(bind_uri) if parsed.scheme == "file": path = uri_to_path(bind_uri) self._conn = aiohttp.UnixConnector( path=path, loop=self._loop, limit=self._runner.batch_options.max_batch_size * 2, keepalive_timeout=self._runner.batch_options.max_latency_ms * 1000 * 10, ) self._addr = "http://127.0.0.1:8000" # addr doesn't matter with UDS elif parsed.scheme == "tcp": self._conn = aiohttp.TCPConnector( loop=self._loop, limit=self._runner.batch_options.max_batch_size * 2, verify_ssl=False, keepalive_timeout=self._runner.batch_options.max_latency_ms * 1000 * 10, ) self._addr = f"http://{parsed.netloc}" else: raise ValueError(f"Unsupported bind scheme: {parsed.scheme}") return self._conn
async def start(self): if self.lxd_url.scheme == "unix": path = Path(self.lxd_url.path) if not path.is_socket(): raise RuntimeError("Path %s is not a unix socket" % path) connector = aiohttp.UnixConnector(path=str(path)) self._ssl_context = None self.lxd_url = URL.build( scheme="http", host="lxd", user=self.lxd_url.user or "", password=self.lxd_url.password or "", query_string=self.lxd_url.query_string or "", authority=self.lxd_url.authority or "", port=self.lxd_url.port, path="/", ) else: connector = aiohttp.TCPConnector() self._ssl_context = ssl.SSLContext() self._ssl_context.load_verify_locations( str(self.lxd_cert.expanduser()), ) self._ssl_context.load_cert_chain( str(self.client_cert.expanduser()), str(self.client_key.expanduser()), ) self._client = aiohttp.ClientSession( connector=connector, connector_owner=True, raise_for_status=True, ) await super().start()
async def logs(cont, name): conn = aiohttp.UnixConnector(path="/var/run/docker.sock") async with aiohttp.ClientSession(connector=conn) as session: async with session.get( f"http://xx/containers/{cont}/logs?follow=1&stdout=1") as resp: async for line in resp.content: print(name, line)
async def get_page_task(): conn = aiohttp.UnixConnector(socket_path) async with aiohttp.ClientSession(connector=conn, auto_decompress=False) as session: # proxy the request to the module async with session.get('http://localhost/') as resp: return await resp.text()
def __init__(self, opts): if is_linux_tty(): self.input_filter = KeyCodesFilter() else: self.input_filter = DummyKeycodesFilter() self.help_menu = HelpMenu(self) super().__init__(opts) self.interactive = None self.server_updated = None self.restarting_server = False self.global_overlays = [] try: self.our_tty = os.ttyname(0) except OSError: self.our_tty = "not a tty" self.conn = aiohttp.UnixConnector(self.opts.socket) self.client = make_client_for_conn(API, self.conn, self.resp_hook) self.error_reporter = ErrorReporter( self.context.child("ErrorReporter"), self.opts.dry_run, self.root, self.client) self.note_data_for_apport("SnapUpdated", str(self.updated)) self.note_data_for_apport("UsingAnswers", str(bool(self.answers)))
def __init__(self, host: str = 'localhost', port: int = 8086, mode: str = 'async', output: str = 'raw', db: Optional[str] = None, *, ssl: bool = False, unix_socket: Optional[str] = None, username: Optional[str] = None, password: Optional[str] = None, database: Optional[str] = None, loop: Optional[asyncio.BaseEventLoop] = None, ): """ The InfluxDBClient object holds information necessary to interact with InfluxDB. It is async by default, but can also be used as a sync/blocking client. When querying, responses are returned as raw JSON by default, but can also be wrapped in easily iterable wrapper object or be parsed to Pandas DataFrames. The three main public methods are the three endpoints of the InfluxDB API, namely: 1) InfluxDBClient.ping 2) InfluxDBClient.write 3) InfluxDBClient.query See each of the above methods documentation for further usage details. See also: https://docs.influxdata.com/influxdb/latest/tools/api/ :param host: Hostname to connect to InfluxDB. :param port: Port to connect to InfluxDB. :param mode: Mode in which client should run. Available options are: 'async', 'blocking' and 'dataframe'. - 'async': Default mode. Each query/request to the backend will - 'blocking': Behaves in sync/blocking fashion, similar to the official InfluxDB-Python client. :param output: Output format of the response received from InfluxDB. - 'raw': Default format. Returns JSON as received from InfluxDB. - 'iterable': Wraps the raw response in a `InfluxDBResult` or `InfluxDBChunkedResult`, which can be used for easier iteration over retrieved data points. - 'dataframe': Parses results into Pandas DataFrames. Not compatible with chunked responses. :param db: Default database to be used by the client. :param ssl: If https should be used. :param unix_socket: Path to the InfluxDB Unix domain socket. :param username: Username to use to connect to InfluxDB. :param password: User password. :param database: Default database to be used by the client. This field is for argument consistency with the official InfluxDB Python client. :param loop: Asyncio event loop. """ self._loop = asyncio.get_event_loop() if loop is None else loop self._connector = aiohttp.UnixConnector(path=unix_socket, loop=self._loop) if unix_socket else None self._auth = aiohttp.BasicAuth(username, password) if username and password else None self._session = aiohttp.ClientSession(loop=self._loop, auth=self._auth, connector=self._connector) self._url = f'{"https" if ssl else "http"}://{host}:{port}/{{endpoint}}' self.host = host self.port = port self._mode = None self._output = None self._db = None self.tag_cache = defaultdict(lambda: defaultdict(dict)) self.mode = mode self.output = output self.db = database or db
async def run(self): await self.load_images() self.real_cam.start() if self.socket != "": conn = aiohttp.UnixConnector(path=self.socket) else: conn = None async with aiohttp.ClientSession(connector=conn) as session: t0 = time.monotonic() print_fps_period = 1 frame_count = 0 while True: frame = self.real_cam.read() if frame is None: await asyncio.sleep(0.1) continue frame = await self.mask_frame(session, frame) self.put_frame(frame) frame_count += 1 td = time.monotonic() - t0 if td > print_fps_period: self.current_fps = frame_count / td print("FPS: {:6.2f}".format(self.current_fps), end="\r") frame_count = 0 t0 = time.monotonic()
def __ensure_session(self) -> aiohttp.ClientSession: if not self.__http_session: if self.__unix_path: self.__http_session = aiohttp.ClientSession( connector=aiohttp.UnixConnector(path=self.__unix_path)) else: self.__http_session = aiohttp.ClientSession() return self.__http_session
async def start_ap(): await sleep(1) logger.debug("Connecting to captive portal socket...") conn = aiohttp.UnixConnector(path=app["captive-portal"]) async with aiohttp.ClientSession(connector=conn) as session: async with session.get('http://localhost/start-ap') as resp: logger.debug("Received captive portal response: %s", resp.status) return resp.status
def initSession(self): if self.s is None: if self.url.startswith("unix:"): conn = aiohttp.UnixConnector(path=self.url[5:]) self.s = aiohttp.ClientSession(connector=conn) self.url = "http://unixsocket/" else: self.s = aiohttp.ClientSession()
def test_unix_connector_not_found(loop): connector = aiohttp.UnixConnector('/' + uuid.uuid4().hex, loop=loop) req = ClientRequest( 'GET', URL('http://www.python.org'), loop=loop, ) with pytest.raises(aiohttp.ClientConnectorError): loop.run_until_complete(connector.connect(req))
async def subscription_PUT(self, socket_path: str) -> None: log.debug('added subscription %s', socket_path) conn = aiohttp.UnixConnector(socket_path) client = make_client_for_conn(NetEventAPI, conn) lock = asyncio.Lock() self.clients[socket_path] = (client, conn, lock) self.app.aio_loop.create_task( self._call_client(client, conn, lock, "route_watch", self.network_event_receiver.default_routes))
def __make_http_session(self) -> aiohttp.ClientSession: kwargs: Dict = { "headers": { "User-Agent": htclient.make_user_agent("KVMD"), }, "timeout": aiohttp.ClientTimeout(total=self.__timeout), "connector": aiohttp.UnixConnector(path=self.__unix_path) } return aiohttp.ClientSession(**kwargs)
def get_conn(self) -> "BaseConnector": import aiohttp if self._conn is None or self._conn.closed: if self.outbound_unix_socket: self._conn = aiohttp.UnixConnector(path=self.outbound_unix_socket,) else: self._conn = aiohttp.TCPConnector(limit=30) return self._conn
def __init__( self, host: str = 'localhost', port: int = 8086, mode: str = 'async', db: str = 'testdb', *, ssl: bool = False, unix_socket: Optional[str] = None, username: Optional[str] = None, password: Optional[str] = None, database: Optional[str] = None, loop: Optional[asyncio.BaseEventLoop] = None, ): """ The InfluxDBClient object holds information necessary to interact with InfluxDB. It is async by default, but can also be used as a sync/blocking client and even generate Pandas DataFrames from queries. The three main public methods are the three endpoints of the InfluxDB API, namely: 1) InfluxDBClient.ping 2) InfluxDBClient.write 3) InfluxDBClient.query See each of the above methods documentation for further usage details. See also: https://docs.influxdata.com/influxdb/latest/tools/api/ :param host: Hostname to connect to InfluxDB. :param port: Port to connect to InfluxDB. :param mode: Mode in which client should run. Available options are: 'async', 'blocking' and 'dataframe'. - 'async': Default mode. Each query/request to the backend will - 'blocking': Behaves in sync/blocking fashion, similar to the official InfluxDB-Python client. - 'dataframe': Behaves in a sync/blocking fashion, but parsing results into Pandas DataFrames. Similar to InfluxDB-Python's `DataFrameClient`. :param db: Default database to be used by the client. :param ssl: If https should be used. :param unix_socket: Path to the InfluxDB Unix domain socket. :param username: Username to use to connect to InfluxDB. :param password: User password. :param database: Default database to be used by the client. This field is for argument consistency with the official InfluxDB Python client. :param loop: Event loop used for processing HTTP requests. """ self._loop = asyncio.get_event_loop() if loop is None else loop self._connector = aiohttp.UnixConnector( path=unix_socket, loop=self._loop) if unix_socket else None self._auth = aiohttp.BasicAuth( username, password) if username and password else None self._session = aiohttp.ClientSession(loop=self._loop, auth=self._auth, connector=self._connector) self._url = f'{"https" if ssl else "http"}://{host}:{port}/{{endpoint}}' self.host = host self.port = port self.db = database or db self._mode = None self.mode = mode
async def request_coroutine(): if socktype == 'unix': connector = aiohttp.UnixConnector(path=path) elif socktype == 'tcp': connector = None # This will transform into TCP. else: raise Exception(f"impossible socktype ({socktype!r})") async with aiohttp.ClientSession(auth=auth, connector=connector) as session: c = util.JsonRPCClient(session, server_url) return await c.request(endpoint, *args)
def __ensure_http_session(self) -> aiohttp.ClientSession: if not self.__http_session: kwargs: Dict = { "headers": {"User-Agent": htclient.make_user_agent("KVMD")}, "timeout": aiohttp.ClientTimeout(total=self.__timeout), } if self.__unix_path: kwargs["connector"] = aiohttp.UnixConnector(path=self.__unix_path) self.__http_session = aiohttp.ClientSession(**kwargs) return self.__http_session
def __make_session(self) -> aiohttp.ClientSession: kwargs: Dict = { "timeout": aiohttp.ClientTimeout( connect=self.__timeout, sock_read=self.__timeout, ), } if self.__unix_path: kwargs["connector"] = aiohttp.UnixConnector(path=self.__unix_path) return aiohttp.ClientSession(**kwargs)
def __make_http_session(self) -> aiohttp.ClientSession: kwargs: Dict = { "headers": {"User-Agent": self.__user_agent}, "timeout": aiohttp.ClientTimeout( connect=self.__timeout, sock_read=self.__timeout, ), } if self.__unix_path: kwargs["connector"] = aiohttp.UnixConnector(path=self.__unix_path) return aiohttp.ClientSession(**kwargs)
def __init__(self, *args, loop=None, **kwargs): super(HTTPClient, self).__init__(*args, **kwargs) self._loop = loop or asyncio.get_event_loop() if 'unix://' in self.base_uri: pr = urllib.parse.urlparse(self.base_uri) self.base_uri = 'http://consul' connector = aiohttp.UnixConnector(loop=self._loop, path=pr.path) else: connector = aiohttp.TCPConnector(loop=self._loop, verify_ssl=self.verify) self._session = aiohttp.ClientSession(connector=connector)
def test_unix_connector_permission(loop): loop.create_unix_connection = make_mocked_coro( raise_exception=PermissionError()) connector = aiohttp.UnixConnector('/' + uuid.uuid4().hex, loop=loop) req = ClientRequest( 'GET', URL('http://www.python.org'), loop=loop, ) with pytest.raises(aiohttp.ClientConnectorError): loop.run_until_complete(connector.connect(req))
def get_client(self): if self._client is None: jar = aiohttp.DummyCookieJar() if self.outbound_unix_socket: conn = aiohttp.UnixConnector(path=self.outbound_unix_socket,) else: conn = aiohttp.TCPConnector(limit=30) self._client = aiohttp.ClientSession( connector=conn, auto_decompress=False, cookie_jar=jar, ) return self._client
async def client(request, unix_socket, event_loop): conn = aiohttp.UnixConnector(path=unix_socket) session = aiohttp.ClientSession(connector=conn) def close(): async def aclose(): await session.close() event_loop.run_until_complete(aclose()) request.addfinalizer(close) return session
def init(cfg: Config, app: web.Application) -> None: global http, host, config config = cfg host = cfg["docker.host"] if host.startswith("unix://"): http = aiohttp.ClientSession(connector=aiohttp.UnixConnector(path=host[len("unix://"):]), loop=asyncio.get_event_loop()) host = "unix://localhost" else: http = aiohttp.ClientSession(loop=asyncio.get_event_loop()) host = URL(host) app.add_routes(routes)
def _make_session(self, user: str, passwd: str) -> aiohttp.ClientSession: kwargs: Dict = { "headers": { "X-KVMD-User": user, "X-KVMD-Passwd": passwd, "User-Agent": self.__user_agent, }, "timeout": aiohttp.ClientTimeout(total=self.__timeout), } if self.__unix_path: kwargs["connector"] = aiohttp.UnixConnector(path=self.__unix_path) return aiohttp.ClientSession(**kwargs)
async def _wait_container(self): with aiohttp.UnixConnector('/var/run/docker.sock') as conn: timeout = aiohttp.ClientTimeout(total=self.time) async with aiohttp.ClientSession(connector=conn, timeout=timeout) as session: async with session.post( 'http://localhost/containers/{}/wait'.format( self._container.id)) as resp: try: return False, await resp.json() except asyncio.TimeoutError: return True, None
def _serve(self, *args): with serve("-q", *args) as (loop, server): host, port = parse_sockname(server.sockets[0].getsockname()) if host == "unix": connector = aiohttp.UnixConnector(path=port, loop=loop) else: connector = aiohttp.TCPConnector(loop=loop) session = loop.run_until_complete(create_client_session(connector=connector, loop=loop)) try: yield TestClient(self, loop, host, port, session) finally: loop.run_until_complete(session.close()) connector.close()
def _run_server(self, *args, **kwargs): with run_server(*args, **kwargs) as (loop, site): host, port = parse_sockname(site._server.sockets[0].getsockname()) if host == "unix": connector = aiohttp.UnixConnector(path=port, loop=loop) else: connector = aiohttp.TCPConnector(loop=loop) session = aiohttp.ClientSession(connector=connector, loop=loop) try: yield TestClient(self, loop, host, port, session) finally: loop.run_until_complete(session.close()) connector.close()