def auth_as_app(self) -> str:
logger.info("Getting access token for app")
self.request_time = datetime.datetime.now()
data = {'grant_type': 'client_credentials'}
pw_manager = urllib.HTTPPasswordMgrWithDefaultRealm()
pw_manager.add_password(None, constants.OAUTH_URL, self.app_id,
self.app_secret)
urllib.install_opener(
urllib.build_opener(urllib.HTTPBasicAuthHandler(pw_manager)))
request = urllib.Request(constants.OAUTH_URL,
data=data,
headers=constants.OAUTH_REQUEST_HEADERS)
try:
with urllib.request.urlopen(request) as response:
self.full_response = json.loads(response.read())
self.jwt = self.full_response["access_token"]
self.expires_in_secs = datetime.timedelta(
seconds=self.full_response["expires_in"])
self.expiry_time = self.request_time + self.expires_in_secs - constants.JWT_TOKEN_REFRESH_BUFFER
logger.log(
5,
"refreshed auth token at %s - token will expire in %s, with a buffer next refresh will be at %s",
self.request_time, self.expires_in_secs, self.expiry_time)
return self.full_response
except urllib.error.HTTPError as err:
logger.critical(
"Tried to authenticate an app, got error code %s with reason %s",
err.code, err.reason)
raise UnauthorizedRequestError()
def post_data(self, data, username, password):
utc_datetime = datetime.datetime.utcnow()
url_parameters = {
'cluster': self.elasticMonitoringCluster,
'index': self.elasticIndex,
'index_period': utc_datetime.strftime("%Y.%m.%d"),
}
url = "%(cluster)s/%(index)s-%(index_period)s/hrbdata" % url_parameters
headers = {'content-type': 'application/json'}
try:
req = Request(url)
req.add_header('Content-Type', 'application/json; charset=utf-8')
jsondata = json.dumps(data)
jsondataasbytes = jsondata.encode('utf-8')
req.add_header('Content-Length', len(jsondataasbytes))
data = urllib.parse.urlencode(data).encode("utf-8")
# req = urllib.request.urlopen(url, headers=headers, data=json.dumps(data))
if self.write_es_security_enable:
password_mgr = urllib.HTTPPasswordMgrWithDefaultRealm()
password_mgr.add_password(None, url, username, password)
handler = urllib.HTTPBasicAuthHandler(password_mgr)
opener = urllib.build_opener(handler)
urllib.install_opener(opener)
response = urllib.request.urlopen(req, jsondataasbytes)
else:
response = urllib.request.urlopen(req, jsondataasbytes)
except Exception as e:
print("Error: {}".format(str(e)))
def get_unread_msgs(user, passwd):
auth_handler = urllib.HTTPBasicAuthHandler()
auth_handler.add_password(realm='New mail feed',
uri='https://mail.google.com',
user='******'.format(user=user),
passwd=passwd)
opener = urllib.build_opener(auth_handler)
urllib.install_opener(opener)
feed = urllib.request.urlopen(FEED_URL)
return feed.read()
def handle_urlopen(self, urlData, username, password):
if self.read_es_security_enable:
password_mgr = urllib.HTTPPasswordMgrWithDefaultRealm()
password_mgr.add_password(None, urlData, username, password)
handler = urllib.HTTPBasicAuthHandler(password_mgr)
opener = urllib.build_opener(handler)
urllib.install_opener(opener)
response = urllib.request.urlopen(urlData)
else:
response = urllib.request.urlopen(urlData)
return response.read().decode('utf-8')
def __init__(self, ip_address, port, username="******", password="******"):
PowerDevice.__init__(self, ip_address, username, password)
self._ip_address = ip_address
self.port = port
# create a password manager
password_mgr = _urllib.HTTPPasswordMgrWithDefaultRealm()
password_mgr.add_password(None, 'http://' + ip_address, username, password)
handler = _urllib.HTTPBasicAuthHandler(password_mgr)
opener = _urllib.build_opener(handler)
# Now all calls to _urllib.urlopen use our opener.
_urllib.install_opener(opener)
def get_with_username_password(username, password):
# create a password manager
password_mgr = _urllib.HTTPPasswordMgrWithDefaultRealm()
password_mgr.add_password(None, 'http://' + ip_address, username, password)
handler = _urllib.HTTPBasicAuthHandler(password_mgr)
opener = _urllib.build_opener(handler)
opener.open('http://' + ip_address)
_urllib.install_opener(opener)
request = _urllib.Request('http://' + ip_address)
response = opener.open(request)
data = response.read()
return data
def http_auth_request(url, host, user, passwd, user_agent=USER_AGENT):
"""Call an HTTP server with authorization credentials using urllib.
"""
if DEBUG: http.client.HTTPConnection.debuglevel = 1
# Hook up handler/opener to urllib
password_manager = urllib.HTTPPasswordMgrWithDefaultRealm()
password_manager.add_password(None, host, user, passwd)
auth_handler = urllib.HTTPBasicAuthHandler(password_manager)
opener = urllib.build_opener(auth_handler)
urllib.install_opener(opener)
return http_request(url, user_agent)
def download_from_url(url):
proxy = env_server.get_proxy()
if proxy['enabled']:
server = proxy['server'].replace('http://', '')
proxy_dict = {
'http': 'http://{login}:{pass}@{0}'.format(server, **proxy)
}
proxy_handler = urllib2.ProxyHandler(proxy_dict)
auth = urllib2.HTTPBasicAuthHandler()
opener = urllib2.build_opener(proxy_handler, auth, urllib2.HTTPHandler)
urllib2.install_opener(opener)
def url_open_agent(url=url, timeout=1):
return urllib2.urlopen(url=url, timeout=timeout)
query_worker = gf.get_thread_worker(url_open_agent,
error_func=gf.error_handle)
query_worker.try_start()
thread_pool = query_worker.get_thread_pool()
thread_pool.waitForDone()
if query_worker.is_failed():
return False
