def __init__(self): if IS_PY3: super(ProxiedTransport, self).__init__() else: Transport.__init__(self) self.realhost = None self.proxy = None
def __init__(self, url, cookiejar=None, sslverify=True, sslcafile=None, debug=0): if hasattr(Transport, "__init__"): Transport.__init__(self, use_datetime=False) self.verbose = debug self._cookiejar = cookiejar # transport constructor needs full url too, as xmlrpc does not pass # scheme to request self.scheme = urlparse(url)[0] if self.scheme not in ["http", "https"]: raise Exception("Invalid URL scheme: %s (%s)" % (self.scheme, url)) self.use_https = self.scheme == 'https' self.request_defaults = { 'cert': sslcafile if self.use_https else None, 'cookies': cookiejar, 'verify': sslverify, 'headers': { 'Content-Type': 'text/xml', 'User-Agent': self.user_agent, } } # Using an explicit Session, rather than requests.get, will use # HTTP KeepAlive if the server supports it. self.session = requests.Session()
def __init__(self, url, cookiejar=None, sslverify=True, sslcafile=None, debug=True, cert=None): if hasattr(Transport, "__init__"): Transport.__init__(self, use_datetime=False) self.verbose = debug self._cookiejar = cookiejar # transport constructor needs full url too, as xmlrpc does not pass # scheme to request self.scheme = urlparse(url)[0] if self.scheme not in ["http", "https"]: raise Exception("Invalid URL scheme: %s (%s)" % (self.scheme, url)) self.use_https = self.scheme == 'https' self.request_defaults = { 'cert': sslcafile if self.use_https else None, 'cookies': cookiejar, 'verify': sslverify, 'headers': { 'Content-Type': 'text/xml', 'User-Agent': self.user_agent, } } # Using an explicit Session, rather than requests.get, will use # HTTP KeepAlive if the server supports it. self.session = requests.Session() if cert: self.session.cert = cert
def __init__(self, secure=False, username=None, password=None): Transport.__init__(self) self.secure = secure self.username = username self.password = password
def __init__(self, config, path=None): """ :param config: The jsonrpclib configuration :param path: Path to the Unix socket (overrides the host name later) """ TransportMixIn.__init__(self, config) XMLTransport.__init__(self) # Keep track of the given path, if any self.__unix_path = os.path.abspath(path) if path else None
def __init__(self, bugzillasession): if hasattr(Transport, "__init__"): Transport.__init__(self, use_datetime=False) self.__bugzillasession = bugzillasession self.__bugzillasession.set_xmlrpc_defaults() self.__seen_valid_xml = False # Override Transport.user_agent self.user_agent = self.__bugzillasession.get_user_agent()
def __init__(self, user_agent, server='http://api.opensubtitles.org/xml-rpc', language='eng'): self.server = server self.language = language trans = Transport() trans.user_agent = user_agent self._rpc = ServerProxy(self.server, allow_none=True, transport=trans) login_response = self._rpc.LogIn('', '', language, user_agent) assert_status(login_response) self._token = login_response.get('token')
def parse_response(self, response): """parse and store cookie""" try: for header in response.msg.get_all("Set-Cookie"): cookie = header.split(";", 1)[0] cookieKey, cookieValue = cookie.split("=", 1) self._cookies[cookieKey] = cookieValue finally: return Transport.parse_response(self, response)
def __init__(self): # noinspection SpellCheckingInspection opensubtitles_ua = b'VkxzdWIgMC4xMC4y' self.ua = base64.b64decode(opensubtitles_ua).decode() self.opensubtitles_api_url = 'http://api.opensubtitles.org/xml-rpc' self.opensubtitles_lang = 'en' self.token = None self.xmlrpc_transport = Transport() self.xmlrpc_transport.user_agent = self.ua self.xmlrpc = ServerProxy(self.opensubtitles_api_url, allow_none=True, transport=self.xmlrpc_transport)
def parse_response(self, response): """parse and store cookie""" try: for header in response.getheader("set-cookie").split(", "): # filter 'expire' information if not header.startswith("D"): continue cookie = header.split(";", 1)[0] cookieKey, cookieValue = cookie.split("=", 1) self._cookies[cookieKey] = cookieValue finally: return Transport.parse_response(self, response)
def login(): transport = Transport() transport.user_agent = constants.USER_AGENT_OPENSUBS xmlrpc = ServerProxy(constants.OPENSUBTITLES_URL, allow_none=True, transport=transport) try: data = xmlrpc.LogIn(constants.USERNAME, constants.PASSWORD, constants.LANGUAGE, constants.USER_AGENT_OPENSUBS) except: logging.warning( "Error occured while establishing connection to opensubtitles...") return None, None if '200' == data.get('status').split()[0]: logging.info("Got token from opensubtitles") return data.get('token'), xmlrpc else: logging.warning( "Error occured while getting opensubtitles token. Returned status as " + data.get('status').split()[0]) return None
def __init__(self, use_datetime=0, pin='', key_name="01:01"): Transport.__init__(self, use_datetime=use_datetime) self.get_engine() cls = PKCS11Transport import getpass pin = getpass.getpass() self.cert = cls._pkcs11.load_certificate(key_name) self.key = cls._pkcs11.load_private_key(key_name, pin=pin) # Use False to prevent setting the crypto list which causes an NPE self.context = SSL.Context('tlsv1', False) # Manually load the key and cert into the context because the helper # doesn't read from the smart card or handle DER-encoded certs m2.ssl_ctx_use_pkey_privkey(self.context.ctx, self.key._ptr()) m2.ssl_ctx_use_x509(self.context.ctx, self.cert._ptr()) self.context.load_verify_locations("ca.pem", "") self.context.set_verify(SSL.verify_peer, 10) self.context.set_info_callback()
def get_host_info(self, host): host, extra_headers, x509 = Transport.get_host_info(self, host) # Set the remote host principal hostinfo = host.split(':') service = "HTTP@" + hostinfo[0] service_name = gssapi.Name(service, gssapi.NameType.hostbased_service) context = gssapi.SecurityContext(usage="initiate", name=service_name) token = context.step() token = b64encode(token).decode() extra_headers = [("Authorization", f"Negotiate {token}")] return host, extra_headers, x509
def get_host_info(self, host): host, extra_headers, x509 = Transport.get_host_info(self, host) # Set the remote host principal hostinfo = host.split(':') service = "HTTP@" + hostinfo[0] _result, context = kerberos.authGSSClientInit(service) kerberos.authGSSClientStep(context, "") extra_headers = [ ("Authorization", "negotiate %s" % kerberos.authGSSClientResponse(context)) ] return host, extra_headers, x509
def request(self, host, *args, **kwds): # Note that if the server's backlog gets filled, then it refuses # connections. for i in range(RETRIES): try: return Transport.request(self, host, *args, **kwds) except socket.timeout: logger.error("RPC to %s failed: timed out." % host) time.sleep(RETRY_DELAY) continue except socket.error as e: if e.errno == errno.ECONNREFUSED: logger.error("RPC to %s failed: connection refused." % host) continue else: logger.error("RPC to %s failed: %s" % (host, str(e))) break raise ConnectionFailed(host)
def __init__(self, timeout): Transport.__init__(self) self.timeout = timeout
def make_connection(self, host): prev = socket.getdefaulttimeout() socket.setdefaulttimeout(self.timeout) value = Transport.make_connection(self, host) socket.setdefaulttimeout(prev) return value
def __init__(self, timeout: typing.Union[int, float]=socket._GLOBAL_DEFAULT_TIMEOUT, *args, **kwargs) -> None: Transport.__init__(self, *args, **kwargs) self._timeout = timeout
def send_headers(self, connection, headers): if self._cookies: cookies = map(lambda x: x[0] + '=' + x[1], self._cookies.items()) connection.putheader("Cookie", "; ".join(cookies)) Transport.send_headers(self, connection, headers)
def send_request(self, connection, handler, request_body): Transport.send_request(self, connection, handler, request_body) # set cookie below handler if self._cookies: cookies = map(lambda x: x[0] + '=' + x[1], self._cookies.items()) connection.putheader("Cookie", "; ".join(cookies))
def __init__(self): Transport.__init__(self) self._cookies = dict()
def __init__(self, *args, **kwargs): Transport.__init__(self, *args, **kwargs) self.client = Client()
def __init__(self, config): TransportMixIn.__init__(self, config) XMLTransport.__init__(self)
from nestegg import NesteggException from requests import get, head from xmlrpc.client import ServerProxy, Transport pypi_client = ServerProxy("https://pypi.python.org/pypi", Transport()) def get_real_pkg_name(pkg_name): r = head('https://pypi.python.org/simple/{0}/'.format(pkg_name)) if r.status_code == 200: return pkg_name if 300 <= r.status_code <= 399: location = r.headers["location"] if location.startswith("/simple/"): return location.split("/")[-1] else: raise NesteggException( "Unexpected redirect from pypi: {}".format(location)) raise NesteggException( "Unable to get real package name for {} from pypi".format(pkg_name)) def get_package_details(pkg_name): real_pkg_name = get_real_pkg_name(pkg_name) releases = pypi_client.package_releases(real_pkg_name, True) print(releases) for release in releases: urls = pypi_client.release_urls(real_pkg_name, release) print(release, urls)
def __init__(self, *args, **kwargs): self.socket_path = kwargs.pop("socket_path", "") Transport.__init__(self, *args, **kwargs)
def __init__(self, ProxyServer): Transport.__init__(self) self.ProxyServer = ProxyServer
def make_connection(self, host): conn = Transport.make_connection(self, host) conn.timeout = self._timeout return conn
def __init__(self, timeout=socket._GLOBAL_DEFAULT_TIMEOUT, *args, **kwargs): Transport.__init__(self, *args, **kwargs) self._timeout = timeout
def __init__(self): TransportMixIn.__init__(self) XMLTransport.__init__(self)
def __init__(self, scheme): Transport.__init__(self) self._scheme = scheme self.verbose = 0 self._possible_bzr_transports = []
import os import sys import json import requests from zipfile import ZipFile import logging from xmlrpc.client import ServerProxy, Transport logger = logging.getLogger() OPENSUBTITLES_SERVER = 'http://api.opensubtitles.org/xml-rpc' LANGUAGE = 'en' USER_AGENT = "TemporaryUserAgent" CHUNK_SIZE = 128 t = Transport() t.user_agent = USER_AGENT xmlrpc = ServerProxy(OPENSUBTITLES_SERVER,transport=t,allow_none=True) def login(uname,pwd): try: token = xmlrpc.LogIn(uname,pwd,LANGUAGE,USER_AGENT) if '200 OK' in token['status']: return token['token'] else: return None except Exception as e: print('Login Error : {error} '.format(error = str(e)))
def __init__(self, service, uri, use_datetime=1): self.service = service self.uri = uri Transport.__init__(self, use_datetime=use_datetime)
def __init__(self, timeout=None, *args, **kwargs): Transport.__init__(self, *args, **kwargs) self.timeout = timeout
"414": SubAuthError, "415": SubAuthError, "416": SubUploadError, "429": SubServerError, "503": SubServerError, "506": SubServerError, "520": SubServerError, } _API_PROTOCOL_ERR_MAP = { 503: "503 Service Unavailable", 506: "506 Server under maintenance", 520: "520 Unknown internal error", } _client = ServerProxy(API_BASE, allow_none=True, transport=Transport()) # TODO: give a way to let lib user to set `TIMEOUT`? def request(endpoint, token, *params): """ Function to allow for robust and reusable calls to the XMLRPC API. `endpoint` is the `Endpoint` that you want to use from the opensubtitles API. `token` is the auth token that is used for any user-authenticated calls. `*params` are any additional parameters to pass to the API. Note: Retrying with exponential backoff and exposing appropriate errors are all handled automatically. """ TIMEOUT = 15 DELAY_FACTOR = 2 current_delay = 1.5