def call_fip_worker_leave(fip, lip): requests_unixsocket.monkeypatch() payload = {'FloatingIP': fip, 'LocalIP': lip} r = requests.post(URL_NETWORK_DRIVER_LEAVE, data=json.dumps(payload)) if r.status_code != 200: return False return True
def __init__( self, fps: int, width: int, height: int, codec: str, scale_factor: float, no_background: bool, background_blur: int, background_keep_aspect: bool, use_foreground: bool, hologram: bool, tiling: bool, bodypix_url: str, socket: str, background_image: str, foreground_image: str, foreground_mask_image: str, webcam_path: str, v4l2loopback_path: str, use_akvcam: bool, ) -> None: self.no_background = no_background self.use_foreground = use_foreground self.hologram = hologram self.tiling = tiling self.background_blur = background_blur self.background_keep_aspect = background_keep_aspect self.background_image = background_image self.foreground_image = foreground_image self.foreground_mask_image = foreground_mask_image self.scale_factor = scale_factor self.real_cam = RealCam(webcam_path, width, height, fps, codec) # In case the real webcam does not support the requested mode. self.width = self.real_cam.get_frame_width() self.height = self.real_cam.get_frame_height() self.use_akvcam = use_akvcam if not use_akvcam: self.fake_cam = pyfakewebcam.FakeWebcam(v4l2loopback_path, self.width, self.height) else: self.fake_cam = AkvCameraWriter(v4l2loopback_path, self.width, self.height) self.foreground_mask = None self.inverted_foreground_mask = None self.session = requests.Session() if bodypix_url.startswith("/"): print("Looks like you want to use a unix socket") # self.session = requests_unixsocket.Session() self.bodypix_url = "http+unix:/" + bodypix_url self.socket = bodypix_url requests_unixsocket.monkeypatch() else: self.bodypix_url = bodypix_url self.socket = "" # self.session = requests.Session() self.images: Dict[str, Any] = {} self.image_lock = asyncio.Lock()
def test_unix_domain_adapter_monkeypatch(): with UnixSocketServerThread() as usock_thread: with requests_unixsocket.monkeypatch('http+unix://'): urlencoded_usock = requests.compat.quote_plus(usock_thread.usock) url = 'http+unix://%s/path/to/page' % urlencoded_usock for method in ['get', 'post', 'head', 'patch', 'put', 'delete', 'options']: logger.debug('Calling session.%s(%r) ...', method, url) r = getattr(requests, method)(url) logger.debug( 'Received response: %r with text: %r and headers: %r', r, r.text, r.headers) assert r.status_code == 200 assert r.headers['server'] == 'waitress' assert r.headers['X-Transport'] == 'unix domain socket' assert r.headers['X-Requested-Path'] == '/path/to/page' assert r.headers['X-Socket-Path'] == usock_thread.usock assert isinstance(r.connection, requests_unixsocket.UnixAdapter) assert r.url == url if method == 'head': assert r.text == '' else: assert r.text == 'Hello world!' for method in ['get', 'post', 'head', 'patch', 'put', 'delete', 'options']: with pytest.raises(requests.exceptions.InvalidSchema): getattr(requests, method)(url)
def aptly_call(self, path): """Runs a GET request on aptly using the given path.""" endpoint = self.config['api']['endpoint'] with requests_unixsocket.monkeypatch(): url = f'{endpoint}/{path}' r = requests.get(url) return r.json()
def test_peercreds_unix_sock_with_lookup(peercreds_enabled_server_and_client): """Check that ``PEERCRED`` resolution works when enabled.""" httpserver, testclient = peercreds_enabled_server_and_client httpserver.peercreds_resolve_enabled = True bind_addr = httpserver.bind_addr if isinstance(bind_addr, six.binary_type): bind_addr = bind_addr.decode() unix_base_uri = 'http+unix://{}'.format( bind_addr.replace('\0', '%00').replace('/', '%2F'), ) import grp import pwd expected_textcreds = ( pwd.getpwuid(os.getuid()).pw_name, grp.getgrgid(os.getgid()).gr_name, ) expected_textcreds = '!'.join(map(str, expected_textcreds)) with requests_unixsocket.monkeypatch(): peercreds_text_resp = requests.get(unix_base_uri + PEERCRED_TEXTS_URI) peercreds_text_resp.raise_for_status() assert peercreds_text_resp.text == expected_textcreds
def test_peercreds_unix_sock_with_lookup(peercreds_enabled_server): """Check that ``PEERCRED`` resolution works when enabled.""" httpserver = peercreds_enabled_server httpserver.peercreds_resolve_enabled = True bind_addr = httpserver.bind_addr if isinstance(bind_addr, six.binary_type): bind_addr = bind_addr.decode() # pylint: disable=possibly-unused-variable quoted = urllib.parse.quote(bind_addr, safe='') unix_base_uri = 'http+unix://{quoted}'.format(**locals()) import grp import pwd expected_textcreds = ( pwd.getpwuid(os.getuid()).pw_name, grp.getgrgid(os.getgid()).gr_name, ) expected_textcreds = '!'.join(map(str, expected_textcreds)) with requests_unixsocket.monkeypatch(): peercreds_text_resp = requests.get(unix_base_uri + PEERCRED_TEXTS_URI) peercreds_text_resp.raise_for_status() assert peercreds_text_resp.text == expected_textcreds
def test_unix_domain_adapter_monkeypatch(): with UnixSocketServerThread() as usock_thread: with requests_unixsocket.monkeypatch('http+unix://'): urlencoded_usock = requests.compat.quote_plus(usock_thread.usock) url = 'http+unix://%s/path/to/page' % urlencoded_usock for method in [ 'get', 'post', 'head', 'patch', 'put', 'delete', 'options' ]: logger.debug('Calling session.%s(%r) ...', method, url) r = getattr(requests, method)(url) logger.debug( 'Received response: %r with text: %r and headers: %r', r, r.text, r.headers) assert r.status_code == 200 assert r.headers['server'] == 'waitress' assert r.headers['X-Transport'] == 'unix domain socket' assert r.headers['X-Requested-Path'] == '/path/to/page' assert r.headers['X-Socket-Path'] == usock_thread.usock assert isinstance(r.connection, requests_unixsocket.UnixAdapter) assert r.url == url if method == 'head': assert r.text == '' else: assert r.text == 'Hello world!' for method in ['get', 'post', 'head', 'patch', 'put', 'delete', 'options']: with pytest.raises(requests.exceptions.InvalidSchema): getattr(requests, method)(url)
def test_unix_socket() -> None: sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) file_name = "test.socket" if os.path.exists(file_name): os.remove(file_name) sock.bind(file_name) with run_bokeh_serve(["--unix-socket", file_name, "--glob", APPS]) as (p, nbsr): # The server is not ready is binds to the unix socket # very quickly, having some sleep helps with requests_unixsocket.monkeypatch(): for t in range(1, 11): time.sleep(1) try: r = requests.get( f"http+unix://{file_name.replace('/', '%2F')}/line_on_off" ) assert r.status_code == 200 break except: if t == 10: assert False pass os.remove(file_name)
def __init__(self, fps: int, width: int, height: int, scale_factor: float, no_background: bool, background_blur: int, use_foreground: bool, hologram: bool, tiling: bool, bodypix_url: str, socket: str, background_image: str, foreground_image: str, foreground_mask_image: str, webcam: int) -> None: self.no_background = no_background self.use_foreground = use_foreground self.hologram = hologram self.tiling = tiling self.background_blur = background_blur self.background_image = background_image self.foreground_image = foreground_image self.foreground_mask_image = foreground_mask_image self.scale_factor = scale_factor self.real_cam = RealCam(webcam, width, height, fps) # In case the real webcam does not support the requested mode. self.width = self.real_cam.get_frame_width() self.height = self.real_cam.get_frame_height() self.fake_cam = pyvirtualcam.Camera(width=640, height=480, fps=30) self.foreground_mask = None self.inverted_foreground_mask = None self.session = requests.Session() if bodypix_url.startswith('/'): print("Looks like you want to use a unix socket") # self.session = requests_unixsocket.Session() self.bodypix_url = "http+unix:/" + bodypix_url self.socket = bodypix_url requests_unixsocket.monkeypatch() else: self.bodypix_url = bodypix_url self.socket = "" # self.session = requests.Session() self.images: Dict[str, Any] = {} self.image_lock = asyncio.Lock()
def accounting(p): print "*** accounting ***" # radiusd.radlog(radiusd.L_INFO, '*** radlog call in accounting (0) ***') # print print "NAS request", p # NAS with requests_unixsocket.monkeypatch(): response = requests.post( 'http+unix://%2Fvar%2Fwww%2Fbilling%2Fbilling.sock/radius_accounting/', json=p, timeout=3) print "response code:", response.status_code if not response.status_code == 200: return radiusd.RLM_MODULE_REJECT return radiusd.RLM_MODULE_OK
def test_peercreds_unix_sock(peercreds_enabled_server_and_client): """Check that peercred lookup works when enabled.""" httpserver, testclient = peercreds_enabled_server_and_client unix_base_uri = 'http+unix://{}'.format( httpserver.bind_addr.replace('/', '%2F'), ) expected_peercreds = os.getpid(), os.getuid(), os.getgid() expected_peercreds = '|'.join(map(str, expected_peercreds)) with requests_unixsocket.monkeypatch(): peercreds_resp = requests.get(unix_base_uri + PEERCRED_IDS_URI) peercreds_resp.raise_for_status() assert peercreds_resp.text == expected_peercreds peercreds_text_resp = requests.get(unix_base_uri + PEERCRED_TEXTS_URI) assert peercreds_text_resp.status_code == 500
def authorize(p): print "*** authorize ***" print "NAS request:", p with requests_unixsocket.monkeypatch(): response = requests.post( 'http+unix://%2Fvar%2Fwww%2Fbilling%2Fbilling.sock/radius_authorize/', json=p, timeout=3) print print "response code:", response.status_code if not response.status_code == 200: return radiusd.RLM_MODULE_REJECT parsed_response = response.json() print "parsed response:", parsed_response reply = tuple((str(key), str(value)) for key, value in parsed_response["reply"].items()) print "reply: ", reply config = tuple((str(key), str(value)) for key, value in parsed_response["config"].items()) print "config: ", config return (radiusd.RLM_MODULE_OK, reply, config)
def test_unix_domain_adapter_monkeypatch(): with UnixSocketServerThread() as usock_thread: with requests_unixsocket.monkeypatch('http+unix://'): urlencoded_usock = requests.compat.quote_plus(usock_thread.usock) url = 'http+unix://%s/path/to/page' % urlencoded_usock logger.debug('Calling requests.get(%r) ...', url) r = requests.get(url) logger.debug('Received response: %r with text: %r and headers: %r', r, r.text, r.headers) assert r.status_code == 200 assert r.headers['server'] == 'waitress' assert r.headers['X-Transport'] == 'unix domain socket' assert r.headers['X-Requested-Path'] == '/path/to/page' assert r.headers['X-Socket-Path'] == usock_thread.usock assert isinstance(r.connection, requests_unixsocket.UnixAdapter) assert r.url == url assert r.text == 'Hello world!' with pytest.raises(requests.exceptions.InvalidSchema): requests.get(url)
def test_peercreds_unix_sock_with_lookup(peercreds_enabled_server_and_client): """Check that peercred resolution works when enabled.""" httpserver, testclient = peercreds_enabled_server_and_client httpserver.peercreds_resolve_enabled = True unix_base_uri = 'http+unix://{}'.format( httpserver.bind_addr.replace('/', '%2F'), ) import grp import pwd expected_textcreds = ( pwd.getpwuid(os.getuid()).pw_name, grp.getgrgid(os.getgid()).gr_name, ) expected_textcreds = '!'.join(map(str, expected_textcreds)) with requests_unixsocket.monkeypatch(): peercreds_text_resp = requests.get(unix_base_uri + PEERCRED_TEXTS_URI) peercreds_text_resp.raise_for_status() assert peercreds_text_resp.text == expected_textcreds
def test_peercreds_unix_sock(peercreds_enabled_server): """Check that ``PEERCRED`` lookup works when enabled.""" httpserver = peercreds_enabled_server bind_addr = httpserver.bind_addr if isinstance(bind_addr, six.binary_type): bind_addr = bind_addr.decode() quoted = urllib.parse.quote(bind_addr, safe='') unix_base_uri = 'http+unix://{quoted}'.format(**locals()) expected_peercreds = os.getpid(), os.getuid(), os.getgid() expected_peercreds = '|'.join(map(str, expected_peercreds)) with requests_unixsocket.monkeypatch(): peercreds_resp = requests.get(unix_base_uri + PEERCRED_IDS_URI) peercreds_resp.raise_for_status() assert peercreds_resp.text == expected_peercreds peercreds_text_resp = requests.get(unix_base_uri + PEERCRED_TEXTS_URI) assert peercreds_text_resp.status_code == 500
def test_unix_domain_adapter_monkeypatch(): with UnixSocketServerThread() as usock_thread: with requests_unixsocket.monkeypatch('http+unix://'): urlencoded_usock = requests.compat.quote_plus(usock_thread.usock) url = 'http+unix://%s/path/to/page' % urlencoded_usock logger.debug('Calling requests.get(%r) ...', url) r = requests.get(url) logger.debug( 'Received response: %r with text: %r and headers: %r', r, r.text, r.headers) assert r.status_code == 200 assert r.headers['server'] == 'waitress' assert r.headers['X-Transport'] == 'unix domain socket' assert r.headers['X-Requested-Path'] == '/path/to/page' assert r.headers['X-Socket-Path'] == usock_thread.usock assert isinstance(r.connection, requests_unixsocket.UnixAdapter) assert r.url == url assert r.text == 'Hello world!' with pytest.raises(requests.exceptions.InvalidSchema): requests.get(url)
def _post(self, payload: Dict[str, Any]) -> Optional[Any]: """Posts request to server. Args: payload: dictionary containing rpc params Returns: result from rpc call Raises: RuntimeError: An error from the server. HTTPError: An error communicating with server. """ for i in range(_MAX_RETRIES): if self.url.startswith(_UNIX_URL_PREFIX): with requests_unixsocket.monkeypatch(): response = requests.post(self.url, json=payload) else: response = requests.post(self.url, json=payload) if response.status_code != requests.codes.ok: #response.raise_for_status() print(f'error from server: {response}') time.sleep(_RETRY_DELAY_SEC) continue json_response = response.json() if 'result' not in json_response: #raise RuntimeError(f'response from server: {json_response}') print(f'error: bad response from server: {json_response}') time.sleep(_RETRY_DELAY_SEC) continue #print(f'response:\n{json_response["result"]}') return json_response['result'] raise RuntimeError(f'error: retry count exceeded')
import os import site import sys import urllib site.main() # to be PEP-8 compliant, the imports must be indented if True: import requests import requests_unixsocket import pbs import pwd import copy requests_unixsocket.monkeypatch() # ============================================================================ # Utility functions # ============================================================================ class OfflineError(Exception): """ Exception that will offline the node and reject the event """ def __init__(self, msg): super().__init__(pbs.event().job.id + ': ' + msg)
def fetch_url(url): # Lazily import so it is not required at the module level if os.name != 'nt': import requests_unixsocket with requests_unixsocket.monkeypatch(): return requests.get(url)
from collections import namedtuple from enum import Enum import requests import requests_unixsocket from six.moves.urllib import parse try: from ws4py.client import WebSocketBaseClient _ws4py_installed = True except ImportError: # pragma: no cover WebSocketBaseClient = object _ws4py_installed = False from pylxd import exceptions, managers requests_unixsocket.monkeypatch() LXD_PATH = '.config/lxc/' SNAP_ROOT = os.path.expanduser('~/snap/lxd/current/') APT_ROOT = os.path.expanduser('~/') CERT_FILE_NAME = 'client.crt' KEY_FILE_NAME = 'client.key' # check that the cert file and key file exist at the appopriate path if os.path.exists(os.path.join( SNAP_ROOT, LXD_PATH, CERT_FILE_NAME)): # pragma: no cover CERTS_PATH = os.path.join(SNAP_ROOT, LXD_PATH) # pragma: no cover else: # pragma: no cover CERTS_PATH = os.path.join(APT_ROOT, LXD_PATH) # pragma: no cover Cert = namedtuple('Cert', ['cert', 'key']) # pragma: no cover DEFAULT_CERTS = Cert(
def api_get(url, headers={}): url = "{}/{}".format(FLEET_API, url) with requests_unixsocket.monkeypatch(): r = requests.get(url) r.raise_for_status() return r.json()
def fetch_url(url): with requests_unixsocket.monkeypatch(): return requests.get(url)
def main(): parser = ArgParser(prog="remote_sge") parser.add_argument('test_server', help="Command to run") parser.add_argument('configdir', help=CONFIGDIR_HELP) parser.add_argument('-H', '--host', help="Hostname. Default: localhost", default="localhost") parser.add_argument('-p', '--port', help="Port to connect to. Default: 443", default="443") parser.add_argument( '-s', '--socket', help="Path to Unix domain socket to connect to. Default: None." + " If supplied, -h and -p are ignored and unix domain socket will be " + "connected to rather than a TCP connection. Requires the " + "requests-unixsocket package which must be installed manually.") parser.add_argument( '-k', '--key', help= "Path to client private key. Default is $configdir/certs/client.key", default=None) parser.add_argument( '-c', '--cert', help= "Path to client certificate. Default is $configdir/certs/client.crt", default=None) args = parser.parse_args() configdir = abspath(expandvars(expanduser(args.configdir))) if not exists(configdir): raise NotFound("Couldn't find configdir you gave.") if args.key: key = args.key else: key = join(configdir, 'certs', 'client.key') if args.cert: cert = args.cert else: cert = join(configdir, 'certs', 'client.crt') if args.socket: import requests_unixsocket from urllib.parse import urlencode requests_unixsocket.monkeypatch() response = requests.get("http+unix://%s/" % urlencode(args.socket)) else: params = dict(cert=(cert, key), verify=False) response = requests.get("https://%s:%s/" % (args.host, args.port), **params) if response.status_code == 200: print("It works!") else: print("Responded with %s" % response.status_code) print("Response body: " + response.text)