def query(self, query, ts_start, ts_end): # target = 'summarize({},"{}","avg")'.format( # query, '99year') @TODO remove if not needed # build graphite url args = { '__auth_token': self.token, 'target': query, 'format': 'json', 'from': str(ts_start), 'until': str(ts_end), } url = '{}/render?'.format(self.url) for k, v in args.items(): url += '{}={}&'.format(quote(k), quote(v)) # Basic auth header password_mgr = HTTPPasswordMgrWithDefaultRealm() password_mgr.add_password( None, self.graphite_url, self.username, self.password, ) auth_handler = HTTPBasicAuthHandler(password_mgr) opener = build_opener(auth_handler) install_opener(opener) result = json.loads(urlopen(url).read().decode('utf-8')) return result
def foreach(self, server): """Helper function to iterate Graphite metrics using foreach_path We will return an empty element even though foreach_path is not set for convenience of the caller. """ if self.foreach_path: formatter = AttributeFormatter() params = formatter.vformat('query=' + self.foreach_path, (), server) password_mgr = HTTPPasswordMgrWithDefaultRealm() password_mgr.add_password( None, settings.GRAPHITE_URL, settings.GRAPHITE_USER, settings.GRAPHITE_PASSWORD, ) auth_handler = HTTPBasicAuthHandler(password_mgr) url = '{0}/metrics/find?{1}'.format(settings.GRAPHITE_URL, params) with build_opener(auth_handler).open(url) as response: return json.loads(response.read().decode()) return [{ 'id': '', 'leaf': 0, 'context': {}, 'text': '', 'expandable': 0, 'allowChildren': 0, }]
def download(self, source, dest): """ Download an archive file. :param str source: URL pointing to an archive file. :param str dest: Local path location to download archive file to. """ # propogate all exceptions # URLError, OSError, etc proto, netloc, path, params, query, fragment = urlparse(source) if proto in ('http', 'https'): auth, barehost = splituser(netloc) if auth is not None: source = urlunparse( (proto, barehost, path, params, query, fragment)) username, password = splitpasswd(auth) passman = HTTPPasswordMgrWithDefaultRealm() # Realm is set to None in add_password to force the username and password # to be used whatever the realm passman.add_password(None, source, username, password) authhandler = HTTPBasicAuthHandler(passman) opener = build_opener(authhandler) install_opener(opener) response = urlopen(source) try: with open(dest, 'wb') as dest_file: dest_file.write(response.read()) except Exception as e: if os.path.isfile(dest): os.unlink(dest) raise e
def _install_opener(self): self.opener = None if self.username != "": self.password_mgr = HTTPPasswordMgrWithDefaultRealm() self.password_mgr.add_password(None, self.baseurlauth, self.username, self.password) self.auth_handler = HTTPBasicAuthHandler(self.password_mgr) if self.ssl is True: if self.cafile == "": self.context = ssl.create_default_context() self.context.check_hostname = False self.context.verify_mode = ssl.CERT_NONE else: self.context = ssl.create_default_context() self.context.load_verify_locations(cafile=self.cafile) self.context.verify_mode = ssl.CERT_REQUIRED self.https_handler = HTTPSHandler(context=self.context) if self.username != "": self.opener = build_opener(self.https_handler, self.auth_handler) else: self.opener = build_opener(self.https_handler) else: if self.username != "": self.opener = build_opener(self.auth_handler) if self.opener is not None: self.log.debug("Setting up opener on: {}".format(self.baseurlauth)) install_opener(self.opener)
def execute(self, method, *args, **kwargs): header = { 'Content-Type' : 'application/json', 'User-Agent' : 'python-xbmc' } # Params are given as a dictionnary if len(args) == 1: args=args[0] params = kwargs # Use kwargs for param=value style else: args = kwargs params={} params['jsonrpc']='2.0' params['id']=self.id self.id +=1 params['method']=method params['params']=args values=json.dumps(params) # HTTP Authentication password_mgr = HTTPPasswordMgrWithDefaultRealm() password_mgr.add_password(None, self.url, self.username, self.password) auth_handler = HTTPBasicAuthHandler(password_mgr) opener = build_opener(auth_handler) install_opener(opener) data = values req = Request(self.url, data.encode('utf-8'), header) response = urlopen(req) the_page = response.read() if len(the_page) > 0 : return json.load(StringIO(the_page.decode('utf-8'))) else: return None # for readability
def unavco_dl(d, opt_dict): user_name = password_config.unavuser user_password = password_config.unavpass url = d['downloadUrl'] passman = HTTPPasswordMgrWithDefaultRealm() passman.add_password(None, 'https://imaging.unavco.org/data/sar/lts', user_name, user_password) authhandler = HTTPDigestAuthHandler(passman) opener = build_opener(authhandler) filename = os.path.basename(url) try: f = opener.open(url) except HTTPError as e: print(e) return dl_file_size = int(f.info()['Content-Length']) if os.path.exists(filename): file_size = os.path.getsize(filename) if dl_file_size == file_size: print("%s already downloaded" % filename) f.close() return start = time.time() CHUNK = 256 * 10240 with open(filename, 'wb') as fp: while True: chunk = f.read(CHUNK) if not chunk: break fp.write(chunk) total_time = time.time() - start mb_sec = (os.path.getsize(filename) / (1024 * 1024.0)) / total_time print("%s download time: %.2f secs (%.2f MB/sec)" % (filename, total_time, mb_sec)) f.close()
def open(self, url='', user=None, password=None, auth=HTTPBasicAuthHandler): if self.connected: raise WSException('Already connected') try: passwords = HTTPPasswordMgrWithDefaultRealm() passwords.add_password(None, url, user, password) if user and password: self.opener = build_opener(WSRedirectHandler(), auth(passwords)) else: self.opener = build_opener(WSRedirectHandler()) self.opener.open(url) # remove this. (urllib2 ugly code !) #install_opener(self.opener) self.connected = True self.url = url except HTTPError as e: raise WSException('Connection error to {}'.format(url), e) from e except URLError as e: raise WSException('Connection error to {}'.format(url), e) from e return self
def set_proxy(proxy, user=None, password=""): """ Set the HTTP proxy for Python to download through. If ``proxy`` is None then tries to set proxy from environment or system settings. :param proxy: The HTTP proxy server to use. For example: 'http://proxy.example.com:3128/' :param user: The username to authenticate with. Use None to disable authentication. :param password: The password to authenticate with. """ from nltk import compat if proxy is None: # Try and find the system proxy settings try: proxy = getproxies()["http"] except KeyError: raise ValueError("Could not detect default proxy settings") # Set up the proxy handler proxy_handler = ProxyHandler({"https": proxy, "http": proxy}) opener = build_opener(proxy_handler) if user is not None: # Set up basic proxy authentication if provided password_manager = HTTPPasswordMgrWithDefaultRealm() password_manager.add_password(realm=None, uri=proxy, user=user, passwd=password) opener.add_handler(ProxyBasicAuthHandler(password_manager)) opener.add_handler(ProxyDigestAuthHandler(password_manager)) # Overide the existing url opener install_opener(opener)
def urlopen(url, headers=None, data=None, timeout=None): """ An URL opener with the User-agent set to gPodder (with version) """ username, password = username_password_from_url(url) if username is not None or password is not None: url = url_strip_authentication(url) password_mgr = HTTPPasswordMgrWithDefaultRealm() password_mgr.add_password(None, url, username, password) handler = HTTPBasicAuthHandler(password_mgr) opener = build_opener(handler) else: opener = build_opener() if headers is None: headers = {} else: headers = dict(headers) headers.update({'User-agent': USER_AGENT}) request = Request(url, data=data, headers=headers) if timeout is None: return opener.open(request) else: return opener.open(request, timeout=timeout)
def _setup_url_opener_if_necessary(self): if self._url_opener is not None: return kwargs = dict() # disable SSL verification if requested if not self._verify_ssl_certificates: ssl_hosts = [ server for server in self._servers if server.url.startswith('https') ] if ssl_hosts: context = ssl.create_default_context() context.check_hostname = False context.verify_mode = ssl.CERT_NONE kwargs['context'] = context # setup URL openers - add pre-emptive basic authentication http_handler = HTTPHandler() https_handler = HTTPSHandler(**kwargs) password_manager = HTTPPasswordMgrWithDefaultRealm() auth_handlers = [] # setup auth handler if we have any servers requiring authentication for server in self._servers: if server.username: password_manager.add_password(None, server.url, server.username, server.password) if password_manager.passwd: auth_handler = PreemptiveBasicAuthHandler(password_manager) auth_handlers.append(auth_handler) self._url_opener = build_opener(http_handler, https_handler, *auth_handlers)
def init_auth(user, password, url): """ Init authentication """ pass_mgr = HTTPPasswordMgrWithDefaultRealm() pass_mgr.add_password(None, url, user, password) auth_handler = HTTPBasicAuthHandler(pass_mgr) opener = build_opener(auth_handler) install_opener(opener)
def basic_authentication_opener_factory( registry_url: str, username: str, password: str, ) -> OpenerDirector: """ Return an opener director that authenticates requests using the Basic scheme. Args: registry_url (str): The URL of the container registry API. username (str): A username used for Basic authentication when retrieving an access token. password (str): A password used for Basic authentication when retrieving an access token. Returns: OpenerDirector: A director for making HTTP requests. It's main method is `open`. """ opener = opener_factory() password_manager = HTTPPasswordMgrWithDefaultRealm() password_manager.add_password( None, # type: ignore registry_url, username, password, ) opener.add_handler(HTTPBasicAuthHandler(password_manager)) return opener
def __init__(self, cachedir='/tmp', api_host_options={}, urllist=[], http_debug=False, cookiejar=None, offline=False, enable_cpio=True): # set up progress bar callback self.progress_obj = None if sys.stdout.isatty(): self.progress_obj = create_text_meter(use_pb_fallback=False) self.cachedir = cachedir self.urllist = urllist self.http_debug = http_debug self.offline = offline self.cpio = {} self.enable_cpio = enable_cpio passmgr = HTTPPasswordMgrWithDefaultRealm() for host in api_host_options: passmgr.add_password(None, host, api_host_options[host]['user'], api_host_options[host]['pass']) openers = (HTTPBasicAuthHandler(passmgr), ) if cookiejar: openers += (HTTPCookieProcessor(cookiejar), ) self.gr = OscFileGrabber(progress_obj=self.progress_obj)
def authenticate(self, username, password): manager = HTTPPasswordMgrWithDefaultRealm() manager.add_password(None, BASE_URL_AUTHENTICATED, username, password) handler = HTTPBasicAuthHandler(manager) self.baseurl = BASE_URL_AUTHENTICATED self.opener.add_handler(handler)
def graph(request): """Proxy Graphite graphs We don't want to bother the user with authenticating to Graphite. Instead, here we download the graph using our credentials and pass it to the user. """ password_mgr = HTTPPasswordMgrWithDefaultRealm() password_mgr.add_password( None, settings.GRAPHITE_URL, settings.GRAPHITE_USER, settings.GRAPHITE_PASSWORD, ) auth_handler = HTTPBasicAuthHandler(password_mgr) url = '{0}/render?{1}'.format(settings.GRAPHITE_URL, request.GET.urlencode()) # If the Graphite server fails, we would return proper server error # to the user instead of failing. This is not really a matter for # the user as they would get a 500 in any case, but it is a matter for # the server. We expect any kind of IO error in here, but the socket # errors are more likely to happen. Graphite has the tendency to return # empty result with 200 instead of proper error codes. try: with build_opener(auth_handler).open(url) as response: return HttpResponse(response.read(), content_type='image/png') except IOError as error: return HttpResponseServerError(str(error))
def __init__(self, server, directory="", username=None, password=None, proxy="", timeout=10, apipath=None, useHTTPS=True, source=__name__): """ parameters * server (string) name of the server the account is located on * directory (string) if the friendica instance is located in a subdirectory, specify it here * apipath (string) alternatively to calculate the API path from server name and installation directory you can specify the path here * username (string) account name => username@servername * password (string) the password for the account * proxy (string) this proxy will be used for connections to the server * timeout (integer) seconds to wait for the response during network requests, default is 10 seconds * useHTTPS (boolean) use HTTPS (true) or not (false) default is to use HTTPS and will fallback to HTTP if that does not work * source (string) this string will be used as source string, e.g. client name, when publishing things """ self.server = server self.directory = directory if (apipath == None): self.apipath = self.server + '/' + directory if len(directory): if not (directory[-1] == '/'): self.apipath = self.apipath + '/' self.apipath = self.apipath + 'api' else: self.apipath = apipath self.username = username self.password = password self.proxy = proxy self.timeout = timeout self.useHTTPS = useHTTPS self.source = source self.cj = CookieJar() self.pwd_mgr = HTTPPasswordMgrWithDefaultRealm() self.pwd_mgr.add_password(None, self.protocol() + self.apipath, self.username, self.password) self.handler = HTTPBasicAuthHandler(self.pwd_mgr) if not self.proxy: self.opener = build_opener(self.handler, HTTPCookieProcessor(self.cj)) else: self.proxy_handler = ProxyHandler({'http': proxy, 'https': proxy}) self.opener = build_opener(self.proxy_handler, self.handler, HTTPCookieProcessor(self.cj))
def __init__(self, url, user=None, password=None): self.user = user self.password = password self.url = url password_manager = HTTPPasswordMgrWithDefaultRealm() password_manager.add_password(None, url, user, password) auth_manager = HTTPBasicAuthHandler(password_manager) self.opener = build_opener(auth_manager)
def set_authentication(self, uri, login, password): password_manager = HTTPPasswordMgrWithDefaultRealm() password_manager.add_password(realm=None, uri=uri, user=login, passwd=password) self.http_opener = build_opener( HTTPBasicAuthHandler(password_manager), HTTPDigestAuthHandler(password_manager))
def create_opener(aur_server_tag: str) -> OpenerDirector: server = _aur_server(aur_server_tag) password_manager = HTTPPasswordMgrWithDefaultRealm() password_manager.add_password(realm=None, uri=server.address, user=server.user, passwd=server.password) handler = HTTPBasicAuthHandler(password_manager) return build_opener(handler)
def get_web_page(url, username=None, password=None, login_url=None): """Get url page possible with username and password. """ if login_url: # Login via a form cookies = HTTPCookieProcessor() opener = build_opener(cookies) install_opener(opener) opener.open(login_url) try: token = [ x.value for x in cookies.cookiejar if x.name == 'csrftoken' ][0] except IndexError: return False, "no csrftoken" params = dict( username=username, password=password, this_is_the_login_form=True, csrfmiddlewaretoken=token, ) encoded_params = urlencode(params) with contextlib.closing(opener.open(login_url, encoded_params)) as f: f.read() elif username is not None: # Login using basic auth # Create password manager passman = HTTPPasswordMgrWithDefaultRealm() passman.add_password(None, url, username, password) # create the handler authhandler = HTTPBasicAuthHandler(passman) opener = build_opener(authhandler) install_opener(opener) try: pagehandle = urlopen(url) except HTTPError as e: msg = ('The server couldn\'t fulfill the request. ' 'Error code: %s' % e.status_code) e.args = (msg, ) raise except URLError as e: msg = f'Could not open URL "{url}": {e}' e.args = (msg, ) raise else: page = pagehandle.read() return page
def __init__(self, *, username='******', password='******', top_level_url="https://urs.earthdata.nasa.gov/"): auth_manager = HTTPPasswordMgrWithDefaultRealm() auth_manager.add_password(None, top_level_url, username, password) handler = HTTPBasicAuthHandler(auth_manager) self.opener = urllib.request.build_opener( handler, HTTPCookieProcessor(CookieJar()))
def open(request): request = request_vim_to_python(request) rhandler = HTTPRedirectHandler() rhandler.max_redirections = request['max_redirect'] opener = build_opener(rhandler) if request['username']: passmgr = HTTPPasswordMgrWithDefaultRealm() passmgr.add_password( None, request['url'], request['username'], request['password'], ) opener.add_handler(HTTPBasicAuthHandler(passmgr)) opener.add_handler(HTTPDigestAuthHandler(passmgr)) req = Request( url=request['url'], data=request['data'], headers=request['headers'], method=request['method'], ) if request['gzip_decompress']: req.add_header('Accept-encoding', 'gzip') try: res = retry(tries=request['retry'])(opener.open)( req, timeout=request['timeout']) except HTTPError as e: res = e if not hasattr(res, 'version'): # urllib2 does not have 'version' field import httplib res.version = httplib.HTTPConnection._http_vsn response_status = "HTTP/%s %d %s\n" % ( '1.1' if res.version == 11 else '1.0', res.code, res.msg, ) response_headers = str(res.headers) response_body = res.read() if (request['gzip_decompress'] and res.headers.get('Content-Encoding') == 'gzip'): response_body = gzip_decompress(response_body) if hasattr(res.headers, 'get_content_charset'): # Python 3 response_encoding = res.headers.get_content_charset() else: # Python 2 response_encoding = res.headers.getparam('charset') response_body = response_body.decode(response_encoding) return ( request['url'], response_status + response_headers, response_body, )
def authorize(): mal_config = read_mal_config() pass_manager = HTTPPasswordMgrWithDefaultRealm() pass_manager.add_password(None, 'http://myanimelist.net/api', mal_config['UserName'], mal_config['Password']) auth_handler = HTTPBasicAuthHandler(pass_manager) opener = build_opener(auth_handler) install_opener(opener)
def index(username, password): global url p = HTTPPasswordMgrWithDefaultRealm() p.add_password(None, url, username, password) auth_handler = HTTPBasicAuthHandler(p) opener = build_opener(auth_handler) try: result = opener.open(url) html = result.read().decode('utf-8') print(html) except URLError as e: print(e.reason)
def url_get(url, user, password): top_level_url = url.rsplit('/', 1) password_mgr = HTTPPasswordMgrWithDefaultRealm() password_mgr.add_password(None, top_level_url, user, password) handler = HTTPBasicAuthHandler(password_mgr) opener = build_opener(handler) opener.open(url) install_opener(opener) return urlopen(url)
def __init__(self, username, password=None): """Class to store info required to connect to the web server""" # Get password if necessary if password is None: password = getpass() # Get URL for the database self.db_url = "http://virgodb.dur.ac.uk:8080/Eagle/" # Set up authentication and cookies self.password_mgr = HTTPPasswordMgrWithDefaultRealm() self.password_mgr.add_password(None, self.db_url, username, password) self.opener = OpenerDirector() self.auth_handler = HTTPBasicAuthHandler(self.password_mgr) self.cookie_handler = HTTPCookieProcessor(cookie_jar)
def authenticated_urlopen(location): """ A wrapper around urlopen adding authentication information if provided by the user. """ passman = HTTPPasswordMgrWithDefaultRealm() server_name = urlparse.urlsplit(location).netloc access = get_server_access(server_name) if access is not None: user = access.username password = access.password if user is not None and password is not None: passman.add_password(None, location, user, password) authhandler = HTTPBasicAuthHandler(passman) opener = build_opener(authhandler) install_opener(opener) return urlopen(location)
def get_port_info_from_url(port): url = 'http://192.168.38.128:8181/restconf/operational/opendaylight-inventory:nodes/node/' + str( port.node) + '/node-connector/' + str(port) + '/' username = '******' password = '******' p = HTTPPasswordMgrWithDefaultRealm() p.add_password(None, url, username, password) handler = HTTPBasicAuthHandler(p) opener = build_opener(handler) install_opener(opener) content = urlopen(url).read() #print(content) data = content.decode("utf-8") print(data) filename = 'port_info.json' with open(filename, 'w') as outfile: json.dump(data, outfile) with fileinput.FileInput(filename, inplace=True) as file: for line in file: print(line.replace("\\", "").replace("\"{", "{").replace("}\"", "}"), end='') client = MongoClient('localhost', 27017) db = client.nets db.port_info.remove({}) mongoimport('localhost', 27017, 'nets', 'port_info', 'port_info.json') datos = {} link_down = query_get_link_down_port_info() datos["link-down"] = link_down blocked = query_get_blocked_port_info() datos["blocked"] = blocked tbytes = query_get_bytes_transmitted_port_info() datos["tbytes"] = tbytes rbytes = query_get_bytes_received_port_info() datos["rbytes"] = rbytes drops = query_get_receive_drops_port_info() datos["drops"] = drops print(datos) return datos
def __init__(self, device_data): """Set up how we are going to connect to the ICS Calendar""" self.name = device_data[CONF_NAME] self.url = device_data[CONF_URL] self.include_all_day = device_data[CONF_INCLUDE_ALL_DAY] self.event = None if device_data[CONF_USERNAME] != '' \ and device_data[CONF_PASSWORD] != '': passman = HTTPPasswordMgrWithDefaultRealm() passman.add_password(None, self.url, device_data[CONF_USERNAME], device_data[CONF_PASSWORD]) basicAuthHandler = HTTPBasicAuthHandler(passman) digestAuthHandler = HTTPDigestAuthHandler(passman) opener = build_opener(digestAuthHandler, basicAuthHandler) install_opener(opener)
def init_auth(user, password, url, use_ssl=False): """ Init authentication """ pass_mgr = HTTPPasswordMgrWithDefaultRealm() pass_mgr.add_password(None, url, user, password) auth_handler = HTTPBasicAuthHandler(pass_mgr) if use_ssl: import ssl from urllib.request import HTTPSHandler opener = build_opener(auth_handler, HTTPSHandler(context=ssl._create_unverified_context())) else: opener = build_opener(auth_handler) install_opener(opener)