def invoke(self, method, httpUrl, body=None, headers={}):
connect = None
try:
uri = urlparse.urlparse(httpUrl)
if "https".__eq__(uri.scheme):
context = ssl.SSLContext(ssl.PROTOCOL_SSLv23)
context.verify_flags = ssl.CERT_NONE
connect = HTTPSConnection(uri.hostname,
uri.port,
context=context)
else:
connect = HTTPConnection(uri.hostname, uri.port)
url = uri.path + "?" + uri.query
connect.request(method, url=url, body=body, headers=headers)
response = connect.getresponse()
rHeader = {}
for k in response.headers:
rHeader[k.lower()] = response.headers.get(k)
result = response.read()
response.close()
return True, response.status, result, rHeader
except Exception as e:
logging.exception("http invoke:%s", e)
return False, 0, "", {}
finally:
if connect is not None:
connect.close()
def ensure_no_open_tickets(version):
version = "v%s" % version
conn = HTTPSConnection('api.github.com')
try:
log('Checking for open tickets on Github for version %s' % version)
log('Check if node is available')
conn.request(
'GET',
'/repos/elastic/elasticsearch/issues?state=open&labels=%s' %
version,
headers={'User-Agent': 'Elasticsearch version checker'})
res = conn.getresponse()
if res.status == 200:
issues = json.loads(res.read().decode("utf-8"))
if issues:
urls = []
for issue in issues:
urls.append(issue['html_url'])
raise RuntimeError(
'Found open issues for release version %s:\n%s' %
(version, '\n'.join(urls)))
else:
log("No open issues found for version %s" % version)
else:
raise RuntimeError(
'Failed to fetch issue list from Github for release version %s'
% version)
except socket.error as e:
log("Failed to fetch issue list from Github for release version %s' % version - Exception: [%s]"
% (version, e))
#that is ok it might not be there yet
finally:
conn.close()
def add(request):
instance = Person(verified=False, ip="127.0.0.1",
last_updated=datetime.datetime.utcfromtimestamp(0))
form = AddPersonForm(request.POST or None, instance=instance)
if form.is_valid():
person = form.save(commit=False)
ssl_context = ssl.create_default_context()
ssl_context.check_hostname = False
ssl_context.verify_mode = ssl.CERT_NONE
host = resolve_location(person)
connection = HTTPSConnection(host=host, port=8080,
context=ssl_context)
connection.request("GET", reverse("directory:info"))
response = connection.getresponse()
data = JSONParser().parse(response)
cert = connection.sock.getpeercert()
connection.close()
serializer = PublicPersonSerializer(person, data=data)
cn = None
#for key, value in cert["subject"]:
# if key == "commonName":
# cn = value
# break
#if cn == person.location and serializer.is_valid():
if serializer.is_valid():
serializer.save()
return HttpResponseRedirect(reverse("directory:index"))
context = {"form": form, "section": "directory"}
return render(request, "person_form.html", context)
def get_best_server(servers):
results = {}
for server in servers:
cum = []
url = '%s/latency.txt' % os.path.dirname(server['url'])
urlparts = urlparse(url)
for _ in range(0, 3):
try:
if urlparts[0] == 'https':
handler = HTTPSConnection(urlparts[1])
else:
handler = HTTPConnection(urlparts[1])
headers = {'User-Agent': USER_AGENT}
start = timeit.default_timer()
handler.request('GET', urlparts[2], headers=headers)
response = handler.getresponse()
total = timeit.default_timer() - start
except (HTTPError, URLError, socket.error):
cum.append(3600)
continue
text = response.read(9)
if int(response.status) == 200 and text == 'test=test'.encode():
cum.append(total)
else:
cum.append(3600)
handler.close()
avg = round(sum(cum) / 6 * 1000, 3)
results[avg] = server
fastest = sorted(results.keys())[0]
best = results[fastest]
best['latency'] = fastest
return best
def post_request(self,
data,
extra_path="",
via_proxy=False,
extra_headers=None):
all_headers = self.get_all_headers(extra_headers)
headers = {
"Content-type": "application/json, charset=UTF-8",
"Accept": "application/json,multipart/related"
}
if via_proxy:
headers["Ladon-Proxy-Path"] = "%s://%s:%d%s" % (
self.scheme.lower(), self.hostname, self.port, self.path)
if self.scheme.lower() == 'https':
conn = HTTPSConnection(self.hostname, self.port)
else:
conn = HTTPConnection(self.hostname, self.port)
req_path = self.path + '/' + extra_path
if all_headers:
headers.update(all_headers)
if req_path.endswith('/description/'):
print("GET")
conn.request("GET", req_path, data, headers)
else:
conn.request("POST", req_path, data, headers)
jsonwsp_response = self.parse_response(conn.getresponse())
conn.close()
return jsonwsp_response
def _request(self, request):
if self.useHttps:
conn = HTTPSConnection(self.host, timeout=self.requestTimeout)
else:
conn = HTTPConnection(self.host, timeout=self.requestTimeout)
if self.requestMethodGet:
conn.request('GET',
self.apiPath + "?" + urlencode({'request': request}))
response = conn.getresponse().read()
conn.close()
else:
headers = {
'Content-type': "application/x-www-form-urlencoded",
'Accept': "text/xml"
}
conn.request('POST', self.apiPath, urlencode({'request': request}),
headers)
response = conn.getresponse().read()
conn.close()
# Parse xml
try:
tree = ElementTree.fromstring(response)
except:
self.status = YastStatus.LIB_XML_PARSE_ERROR
raise Exception("Error parsing response from Yast:\n" +
response)
return tree
def check_maintainers(overlays: Iterator[Overlay]) -> Iterator[Overlay]:
try:
client = HTTPSConnection('bugs.gentoo.org')
for m in overlays:
m.check_details(client)
finally:
client.close()
def post_mp_request(self,data,files,extra_path=""):
# Create the multipart request body
buffer_fname = tempfile.mktemp()
buffer_fp = open(buffer_fname,'wb')
mpw = MultiPartWriter(buffer_fp)
mpw.add_attachment(data.encode('utf-8'),'application/json, charset=UTF-8','body')
for cid,fp in files.items():
mpw.add_attachment(fp,'application/octet-stream',cid)
mpw.done()
buffer_fp.close()
headers = {
"Content-type": b'multipart/related; boundary=' + mpw.boundary,
"Accept": b'application/json,multipart/related'}
if self.scheme.lower()=='https':
conn = HTTPSConnection(self.hostname,self.port)
else:
conn = HTTPConnection(self.hostname,self.port)
req_path = self.path + '/' + extra_path
buffer_fp = open(buffer_fname,'rb')
conn.request("POST", req_path, buffer_fp, headers)
buffer_fp.close()
jsonwsp_response = self.parse_response(conn.getresponse())
conn.close()
os.unlink(buffer_fname)
return jsonwsp_response
def _is_online(domain, sub_path, response_status, response_reason):
conn = HTTPSConnection(domain, timeout=1)
conn.request("HEAD", sub_path)
response = conn.getresponse()
conn.close()
return (response.status == response_status) and (response.reason == response_reason)
def ping_url(protocol, url):
url = to_string(url)
protocol = to_string(protocol).lower()
url_parts = url.split('/', 1)
host = url_parts[0]
if len(url_parts) == 1:
path = '/'
else:
path = '/%s' % url_parts[1]
if protocol == 'https':
connection = HTTPSConnection(host)
elif protocol == 'http':
connection = HTTPConnection(host)
else:
raise ValueError('url', 'Invalid protocol %s. Use only http or https.' % protocol)
valid_url = False
try:
connection.request('HEAD', path)
response = connection.getresponse()
except Exception:
pass
else:
if response.status != 404:
valid_url = True
finally:
connection.close()
return valid_url
def open(self, data):
if data["scheme"] == "https":
conn = HTTPSConnection(data["netloc"],
timeout=self.Parent.Configs.timeout)
else:
conn = HTTPConnection(data["netloc"],
timeout=self.Parent.Configs.timeout)
try:
conn.request("GET", data["path"], "", data["headers"])
except:
return False
try:
response = conn.getresponse()
output = {
"status": response.status,
"reason": response.reason,
"data": response.read(),
"headers": response.getheaders()
}
#Gzip error fix
for header in output['headers']:
if header[0] == 'Content-Encoding' and header[1] == 'gzip':
output['data'] = GzipFile(
fileobj=BytesIO(output['data'])).read()
output['headers'].remove(header)
except:
output = False
conn.close()
return output
def wrap(self, content):
self._LOGGING_ and self.logger.debug(
f"[{self.name}] wrap: {len(content)} bytes")
packedSotp = self.packSotp(content)
if self.proxy:
proxy_ip, proxy_port = self.proxy.split(":")
if self.ssl:
conn = HTTPSConnection(self.hostname,
self.port,
timeout=self.timeout,
context=_create_unverified_context())
else:
conn = HTTPConnection(proxy_ip, proxy_port, self.timeout)
conn.set_tunnel(self.hostname, self.port)
else:
if self.ssl:
conn = HTTPSConnection(self.hostname,
self.port,
timeout=self.timeout,
context=_create_unverified_context())
else:
conn = HTTPConnection(self.hostname, self.port, self.timeout)
data_response, code_response = self.dispatchByMethod(conn, packedSotp)
conn.close()
self.inbox.put(self.messageToWrapper((data_response, code_response)))
def post_mp_request(self, data, files, extra_path="", extra_headers={}):
# Create the multipart request body
buffer_fname = tempfile.mktemp()
buffer_fp = open(buffer_fname, 'wb')
mpw = MultiPartWriter(buffer_fp)
mpw.add_attachment(data.encode('utf-8'),
'application/json, charset=UTF-8', 'body')
for cid, fp in files.items():
mpw.add_attachment(fp, 'application/octet-stream', cid)
mpw.done()
buffer_fp.close()
headers = {
"Content-type": b'multipart/related; boundary=' + mpw.boundary,
"Accept": b'application/json,multipart/related'
}
if self.scheme.lower() == 'https':
conn = HTTPSConnection(self.hostname, self.port)
else:
conn = HTTPConnection(self.hostname, self.port)
req_path = self.path + '/' + extra_path
buffer_fp = open(buffer_fname, 'rb')
headers.update(extra_headers)
conn.request("POST", req_path, buffer_fp, headers)
buffer_fp.close()
jsonwsp_response = self.parse_response(conn.getresponse())
conn.close()
os.unlink(buffer_fname)
return jsonwsp_response
def get(self):
connection = HTTPSConnection(
self.host) if self.https else HTTPConnection(self.host)
headers = dict()
if self.username or self.password:
credentials = "{0}:{1}".format(self.username, self.password)
b64credentials = b64encode(
credentials.encode('utf8')).decode("ascii")
headers = {'Authorization': 'Basic {}'.format(b64credentials)}
try:
connection.request('GET', '/values', headers=headers)
response = connection.getresponse()
body = response.read().decode()
if 400 <= response.code < 500:
raise PilightClientError('Request rejected by pilight server',
response.code, body)
elif 500 <= response.code < 600:
raise PilightClientError('Connection to pilight server failed',
response.code, body)
else:
return self.__process_response(body)
except ConnectionError as e:
raise PilightConnectionError(
"Unable to connect to pilight server: " + str(e))
finally:
connection.close()
def get_new_cases_day(countries):
# request cases from API, limits to 200 countries, may need to be increased in certain cases
client = HTTPSConnection("api.coronatracker.com")
client.request("GET", "/v3/analytics/dailyNewStats?limit=200", '', {})
response = client.getresponse()
response = response.read().decode("utf-8")
client.close()
# transform response to list, API responds with ordered list by case numbers
parsed_json = loads(response, object_hook=lambda d: namedtuple('X', d.keys())(*d.values()))
top_five = []
for i in range(0, 5 - len(countries)):
top_five.append((parsed_json[i].country, parsed_json[i].daily_cases))
# always include requested countries, otherwise use top 5 in # of cases
counter = 0
for country in countries:
if counter == 5:
break
obj = {obj for obj in parsed_json if obj.country == country}.pop()
top_five.append((obj.country, obj.daily_cases))
counter += 1
# sort before returning
return sorted(top_five, reverse=True, key=lambda tup: tup[1])
def get2(url, username, password, user_agent=''):
"""
"""
urlparse_result = urlparse(url)
connection = HTTPSConnection(urlparse_result.netloc)
auth_encode = base64.b64encode(
bytes('{}:{}'.format(username, password), 'ascii'))
headers = {
'User-Agent': user_agent,
'Authorization': 'Basic {}'.format(auth_encode.decode('utf-8')),
}
try:
connection.request('GET', urlparse_result.path, headers=headers)
response = connection.getresponse()
content = response.read()
except Exception:
raise
else:
content = content.decode('utf-8')
return json.loads(content)
finally:
response.close()
connection.close()
def __request_google_translate__(self,targetLang='es'):
'''
Request Google Translate REST API
'''
sourceText = self.text
sourceLang = self.lang
request = {'q': sourceText, 'target': targetLang, 'format': 'text'}
if sourceLang is not None:
request['source'] = sourceLang
data=json.dumps(request)
conn= HTTPSConnection('translation.googleapis.com')
conn.request('POST','/language/translate/v2?key=%s' % GOOGLE_CLOUD_API_KEY, data, {'Content-Type': 'application/json'})
response = conn.getresponse()
data = response.read()
data = json.loads(data)
conn.close()
if response.status == 200:
data = data['data']['translations'][0]
return data
else:
raise Exception('Request failed. Message: ' + data['error']['message'])
def get_yandex_translate(self, searching_text, to_language):
try:
quoted_text = quote(u"" + searching_text + "")
req = '/api/v1.5/tr.json/translate?' \
'key=trnsl.1.1.20150629T151613Z.82119cbb3415f490.ba44aa922a8b28e549144e0e2fa6249c7508358e' \
'&text=' + quoted_text \
+ "&lang=" + to_language \
+ '&options=1'
conn = HTTPSConnection('translate.yandex.net')
conn.request("GET", req)
rez = conn.getresponse()
data = rez.read()
conn.close()
if rez.status == 200:
ddata = data.decode("utf-8")
j = simplejson.loads(ddata, )
tr_text = ''.join(j['text'])
print(tr_text)
return tr_text
else:
print("Something is wrong: " + str(rez.status) + " status code")
print(data)
except HTTPException as err:
print(err)
def post_xml(self, xml, url):
conn = HTTPSConnection(url)
conn.request("POST", '/pay/unifiedorder', xml)
response = conn.getresponse()
response_str = response.read()
conn.close()
return response_str
def __request_google_vision__(self, action='LABEL_DETECTION', n=1):
'''
Request Google Cloud Vision REST API to perform provided action
'''
# Format header and data for the request
b64 = base64.b64encode(self.data).decode('UTF-8')
content_json_obj = {'content': b64}
feature_json_obj = {'type': action, 'maxResults': n}
request = {'features': feature_json_obj, 'image': content_json_obj}
data = json.dumps({'requests': request})
# Perform request and extract response
conn = HTTPSConnection('vision.googleapis.com')
conn.request('POST',
'/v1/images:annotate?key=%s' % GOOGLE_CLOUD_API_KEY, data,
{'Content-Type': 'application/json'})
response = conn.getresponse()
data = response.read()
data = json.loads(data)
conn.close()
if response.status == 200:
return data
else:
raise Exception('Request failed. Message: ' +
data['error']['message'])
def do_PUT(self):
# retrieve the path from the HTTP request
path = self.path
# retrieve the headers from the HTTP request
headers = self.headers
#print("PATH: " + path)
# retrieve the body from the HTTP request
body = ""
if (self.headers.get('content-length') != None):
datalen = int(self.headers.get('content-length'))
body = self.rfile.read(datalen)
#print("This is the body for " + path)
#print(body)
# send an HTTP request to another server and get the response
conn = HTTPSConnection(self.headers.get('host'))
method = 'PUT'
conn.request(method, path, body, headers)
# and get the response back
res = conn.getresponse()
responseBody = res.read()
conn.close()
# set HTTP response status code and body
self.send_response(res.status, responseBody)
# set HTTP reponse headers
for i in range(0, len(res.getheaders())):
self.send_header(res.getheaders()[i][0], res.getheaders()[i][1])
self.end_headers()
def _send_post(self, url, payload={}):
payload = copy.copy(payload) # avoid modifying the original dict
# add some stuff to the payload
payload['nonce'] = int(time.time()*1e6)
body = urllib.parse.urlencode(payload).encode() # convert to bytes object
sig = hmac.new(base64.b64decode(self._secret), body, hashlib.sha512).digest()
sig_b64 = base64.b64encode(sig)
headers = {
'bitfloor-key': self._key,
'bitfloor-sign': sig_b64,
'bitfloor-passphrase': self._passphrase,
'bitfloor-version': self._api_version,
'Content-Type': 'application/x-www-form-urlencoded',
'Content-Length': len(body)
}
conn = HTTPConn(self._host, self._order_port)
conn.request("POST", url, body, headers)
resp = conn.getresponse()
s = resp.read().decode() # comes as a bytes object, decode to a string
conn.close()
return json.loads(s)
def ensure_no_open_tickets(version):
version = "v%s" % version
conn = HTTPSConnection("api.github.com")
try:
log("Checking for open tickets on Github for version %s" % version)
log("Check if node is available")
conn.request(
"GET",
"/repos/elasticsearch/elasticsearch/issues?state=open&labels=%s" % version,
headers={"User-Agent": "Elasticsearch version checker"},
)
res = conn.getresponse()
if res.status == 200:
issues = json.loads(res.read().decode("utf-8"))
if issues:
urls = []
for issue in issues:
urls.append(issue["url"])
raise RuntimeError("Found open issues for release version %s see - %s" % (version, urls))
else:
log("No open issues found for version %s" % version)
else:
raise RuntimeError("Failed to fetch issue list from Github for release version %s" % version)
except socket.error as e:
log("Failed to fetch issue list from Github for release version %s' % version - Exception: [%s]" % (version, e))
# that is ok it might not be there yet
finally:
conn.close()
def get_temperature():
# Open a connection to the domain.
conn = HTTPSConnection("forecast.weather.gov")
# Make a request to load the forecast webpage.
conn.request("GET",
"/MapClick.php?lat=42.5067&lon=-89.0379",
headers={"User-agent": "educational"})
# Get the response from the request.
resp = conn.getresponse()
# Read the content of the request payload.
body = resp.read()
# Close the connection to cleanup resources.
conn.close()
# Parse the webpage's HTML.
soup = BeautifulSoup(body, "html.parser")
# Find the HTML Element with the temperature value.
elm = soup.find("p", class_="myforecast-current-lrg")
# Return the text value of the temperature Element.
return elm.text
def do_GET(self):
# retrieve the path from the HTTP request
path = self.path
# retrieve the headers from the HTTP request
headers = self.headers
# retrieve the body from the HTTP request
body = None
if self.headers.get('content-length'):
body = self.rfile.read(int(self.headers.get('content-length')))
# send an HTTP request to another server and get the response
conn = HTTPSConnection(headers['host'])
method = 'GET'
conn.request(method, path, body, headers)
# and get the response back
res = conn.getresponse()
conn.close()
# set HTTP response status code and body
self.send_response(201, 'Welcome to DarkLab')
# set HTTP reponse headers
self.send_header('Content-type','text/html')
self.end_headers()
return
def make_request(url, method='GET', params=None, body=None, headers=None):
parse_result = urlparse(url)
protocol = parse_result.scheme
hostname = parse_result.netloc
port = None
if ':' in hostname:
hostname, port = hostname.split(':')
if protocol == 'https':
context = ssl.SSLContext()
conn = HTTPSConnection(hostname, port, context=context)
elif protocol == 'http':
conn = HTTPConnection(hostname, port)
else:
raise Exception('Unsupported protocol {}'.format(protocol))
if headers is None:
headers = {}
if method == 'POST':
if 'Content-Type' not in headers:
headers['Content-Type'] = 'application/x-www-form-urlencoded'
if params and not body:
body = urlencode(params)
request_url = f'{parse_result.path}?{parse_result.query}'
conn.request(method, request_url, body, headers)
response = conn.getresponse()
data = response.read()
conn.close()
return data
def submit_xml_request(xml_request):
"""Submit the XML request to the MAST archive.
Parameters
----------
xml_request : string
The request XML string.
Returns
-------
submission_results : httplib object
The XML request submission results.
"""
user = os.environ.get("USER")
home = os.environ.get("HOME")
signer = SignStsciRequest()
request_xml_str = signer.signRequest('{0}/.ssh/privkey.pem'.format(home), xml_request)
params = urlencode({
'dadshost': get_settings()['dads_host'],
'dadsport': 4703,
'mission':'HST',
'request': request_xml_str})
headers = {"Accept": "text/html", "User-Agent":"{0}PythonScript".format(user)}
req = HTTPSConnection(get_settings()['archive'])
req.request("POST", "/cgi-bin/dads.cgi", params, headers)
response = req.getresponse().read()
req.close()
return response
class GoogleDictionary():
def __init__(self):
self.host = 'translate.google.com'
self.connection = HTTPSConnection(self.host)
self.empty_comma = re.compile(r',(?=,)')
def lookup(self, lookedup_word, src_language='ru', dst_language='en'):
secret_token = get_current_token(lookedup_word)
url = self.format_lookup_url(lookedup_word, secret_token, src_language, dst_language)
self.connection.request("GET", url)
response = self.connection.getresponse()
response_content = response.read().decode('utf8')
#json_obj = json.loads(self.empty_comma.subn('', response_content)[0].replace(u'\xA0', u' ').replace('[,', '[1,'))
response_content = response_content.replace(',,', ',"",');
response_content = response_content.replace(',,', ',"",');
response_content = response_content.replace('[,', '["",');
response_content = response_content.replace(',]', ',""]');
response_content = response_content.replace('\xA0', ' ')
#fixed_content = self.empty_comma.subn('', response_content)[0].replace('\xA0', ' ')
return json.loads(response_content)
def format_lookup_url(self, word, secret_token, src_language, dst_language):
url = '/translate_a/single?client=t&sl={0}&tl={1}&hl=en&dt=at&dt=bd&dt=ex&' \
'dt=ld&dt=md&dt=qca&dt=rw&dt=rm&dt=ss&dt=t&ie=UTF-8&oe=UTF-8&otf=2&' \
'rom=1&ssel=3&tsel=3&kc=1&tk={2}&q={3}'.format(src_language, dst_language, secret_token, quote(word))
return url
def unpack(self, json_obj):
window_content = json_obj[0]
if len(json_obj) > 1:
article_by_pos = json_obj[1]
defs = {}
for article in article_by_pos:
pos = article[0]
definition = article[1]
defs[pos] = definition
else:
defs = { 'unk', window_content[0][0] }
return defs
def get_pronunciation_url(self, word, language):
secret_token = get_current_token(word)
url_sound ="https://translate.google.com/translate_tts?ie=UTF-8&client=t&tk={0}&tl={1}&q={2}". \
format(secret_token, language, quote(word))
return url_sound
def get_sound_file(self, word, language):
url_sound = self.get_pronunciation_url(word, language)
try:
self.connection.request("GET", url_sound)
except ImproperConnectionState: # reconnect and try again
self.connection.close()
self.connection.connect()
self.connection.request("GET", url_sound)
response = self.connection.getresponse()
content_type = response.headers['Content-Type']
return response.read(), content_type
def _is_online(domain, sub_path, response_status, response_reason):
conn = HTTPSConnection(domain, timeout=1)
conn.request("HEAD", sub_path)
response = conn.getresponse()
conn.close()
return (response.status == response_status) and (response.reason
== response_reason)
def sync_customers():
timestamp, _ = UkumpGlobal.objects.get_or_create(
key='agilecrm_customer_sync_timestamp', defaults={'value': 0})
cursor = None
rhs = timestamp.value
while True:
body = {
'page_size':
'25',
'global_sort_key':
'updated_time',
'filterJson':
json.dumps({
'rules': [{
'LHS': 'updated_time',
'CONDITION': 'AFTER',
'RHS': rhs * 1000 - 86400000
}],
'contact_type':
'PERSON'
})
}
if cursor:
body['cursor'] = cursor
cursor = None
conn = HTTPSConnection(DOMAIN)
conn.request('POST',
'/dev/api/filters/filter/dynamic-filter',
body=urlencode(body),
headers=REQUEST_HEADER)
resp = conn.getresponse()
assert resp.status == 200
bbody = resp.read()
customers_doc = json.loads(bbody.decode())
c = 0
if customers_doc:
for doc in customers_doc:
customer = Customer.objects.filter(
profile__agilecrm=doc['id']).order_by('id').first()
if customer:
c += 1
update_customer(customer, doc)
timestamp.value = max(
timestamp.value,
max(doc['updated_time'], doc['created_time']))
cursor = doc.get('cursor')
timestamp.save()
time.sleep(1.0)
if not cursor:
break
conn.close()
return c
def _send_get(self, url, payload={}):
body = urllib.parse.urlencode(payload)
conn = HTTPConn(self._host, self._data_port)
conn.request("GET", url, body)
resp = conn.getresponse()
s = resp.read().decode() # comes as a bytes-type object, decode to string
conn.close()
print(s)
return json.loads(s)
class Telegram:
def __init__(self, token):
url = 'https://api.telegram.org/bot'
self.__url = urlparse('{}{}/'.format(url, token))
self.__web = HTTPSConnection(self.__url.netloc)
def __enter__(self):
return self
def __send_req(self, target, method='GET'):
self.__web.connect()
self.__web.request(method, urljoin(self.__url.path, target))
def get_botname(self):
'Return: json data.'
self.__send_req('getMe')
data = Request(self.__web)
return data.data
def get_resp(self, limit=20):
'Return: request object.'
self.__send_req('getUpdates?' + 'limit={}'.format(limit))
return Request(self.__web)
def msg_send(self, chat_id, message):
'Return: request data.'
data = urlencode({'chat_id': chat_id, 'text': message})
self.__send_req('sendMessage?' + data, 'POST')
data = Request(self.__web)
return data.data
def msg_delete(self, chat_id, message_id):
'Return: request data.'
data = urlencode({'chat_id': chat_id, 'message_id': message_id})
self.__send_req('deleteMessage?' + data, 'POST')
data = Request(self.__web)
return data.data
def __call__(self):
'Call get_resp()'
return self.get_resp()
def __del__(self):
self.__web.close()
def __exit__(self, *exec_info):
self.__del__()
class FrankaAPI: #
def __init__(self, hostname, user, password): #构造函数，进行类变量初始化，输入主机名，账户名，密码
self._hostname = hostname #主机名
self._user = user #web网页账户
self._password = password #密码
def __enter__(self):
self._client = HTTPSConnection(
self._hostname, context=ssl._create_unverified_context())
self._client.connect() #链接
self._client.request('POST',
'/admin/api/login',
body=json.dumps({
'login':
self._user,
'password':
encode_password(self._user, self._password)
}),
headers={'content-type': 'application/json'})
self._token = self._client.getresponse().read().decode('utf8')
#print(self._token)
return self
def __exit__(self, type, value, traceback):
self._client.close()
def start_task(self, task):
self._client.request('POST',
'/desk/api/execution',
body='id=%s' % task,
headers={
'content-type':
'application/x-www-form-urlencoded',
'Cookie': 'authorization=%s' % self._token
})
return self._client.getresponse().read()
def open_brakes(self): #打开机械臂锁
self._client.request('POST',
'/desk/api/robot/open-brakes',
headers={
'content-type':
'application/x-www-form-urlencoded',
'Cookie': 'authorization=%s' % self._token
})
return self._client.getresponse().read()
def close_brakes(self): #关闭机械臂锁
self._client.request('POST',
'/desk/api/robot/close-brakes',
headers={
'content-type':
'application/x-www-form-urlencoded',
'Cookie': 'authorization=%s' % self._token
})
return self._client.getresponse().read()
def request(self, method, url, body=None):
connection = HTTPSConnection('saucelabs.com')
connection.request(method, url, body, headers=self.headers)
response = connection.getresponse()
json_data = response.read()
connection.close()
if response.status != 200:
raise Exception('%s: %s.\nSauce Status NOT OK' %
(response.status, response.reason))
return json_data
def request(self, method, url, body=None):
connection = HTTPSConnection('saucelabs.com')
connection.request(method, url, body, headers=self.headers)
response = connection.getresponse()
json_data = response.read()
connection.close()
if response.status != 200:
raise Exception('%s: %s.\nSauce Status NOT OK' %
(response.status, response.reason))
return json_data
class MyHttpCtxManagerClass:
def __init__(self, host):
self.host = host
self.connection = HTTPSConnection(self.host)
def __enter__(self):
self.connection.connect()
return self.connection
def __exit__(self, *args):
self.connection.close()
def check_updated_certs(_address, _port, certhashlist, newhash=None, timeout=config.default_timeout, connect_timeout=config.connect_timeout, traversefunc=None):
update_list = []
if None in [_address, _port]:
logging.error("address or port empty")
return None
addr, _port = url_to_ipv6(_address, _port)
cont = default_sslcont()
con = HTTPSConnection(addr, _port, context=cont, timeout=connect_timeout)
try:
con.connect()
except (ConnectionRefusedError, socket.timeout):
if not traversefunc:
logging.warning("Connection failed")
return None
# try_traverse does not work here, scnreqest creates loop
con.sock = socket.socket(socket.AF_INET6, socket.SOCK_STREAM)
con.sock.bind(('', 0))
traversefunc(("", con.sock.getsockname()[1]))
con.sock.settimeout(connect_timeout)
for count in range(0, config.traverse_retries):
try:
con.sock.connect((addr, _port))
break
except Exception:
pass
else:
logging.warning("traversal failed")
return None
con.sock.settimeout(timeout)
oldhash = dhash(ssl.DER_cert_to_PEM_cert(con.sock.getpeercert(True)).strip().rstrip())
if newhash and newhash != oldhash:
return None
oldsslcont = con.sock.context
for _hash, _security in certhashlist:
con.request("POST", "/usebroken/{hash}".format(hash=_hash), headers=cert_update_header)
con.sock = con.sock.unwrap()
con.sock = cont.wrap_socket(con.sock, server_side=False)
con.sock.do_handshake()
brokensslcert = ssl.DER_cert_to_PEM_cert(con.sock.getpeercert(True)).strip().rstrip()
con.sock = con.sock.unwrap()
# without next line the connection would be unencrypted now
con.sock = oldsslcont.wrap_socket(con.sock, server_side=False)
# con.sock.do_handshake()
ret = con.getresponse()
if ret.status != 200:
logging.info("checking cert failed, code: %s, reason: %s", ret.status, ret.reason)
continue
if con.sock and oldhash != dhash(ssl.DER_cert_to_PEM_cert(con.sock.getpeercert(True)).strip().rstrip()):
logging.error("certificate switch detected, stop checking")
break
if dhash(brokensslcert) == _hash:
update_list.append((_hash, _security))
con.close()
return update_list
def __init__(self, vidID):
conn = HTTPSConnection("www.youtube.com")
conn.request("GET", "/watch?v={}".format(vidID))
stream = conn.getresponse()
if stream.getheader("Content-Encoding") is not None:
stream = GzipFile(fileobj=stream)
self.data = str(stream.read(), "utf-8")
conn.close()
def check_maintainers(
maintainers: Iterator[Maintainer]) -> Iterator[Maintainer]:
try:
client = HTTPSConnection('bugs.gentoo.org')
for m in maintainers:
if m.check_details(client):
print(f'\033[92m\u2713 {m.name} <{m.email}>\033[0m')
else:
print(f'\033[91m\u2717 {m.name} <{m.email}>\033[0m')
yield m
finally:
client.close()
def __http_post_request(self, json_msg):
try:
headers = {"Content-type": "application/json"}
connection = HTTPSConnection(self.__hook_URL)
connection.request("POST", self.__hook_context, json_msg, headers)
response = connection.getresponse()
if response.status != 200:
raise AttributeError(f"Response body: {response.read()}")
except Exception as e:
raise e
finally:
connection.close()
def request(self, path, method, data=None):
connection = HTTPSConnection(self.domain)
try:
base64_bytes = b64encode(
("%s:%s" % (self.username, self.password)).encode("ascii")
).decode("ascii")
headers = {'Authorization': 'Basic %s' % base64_bytes, 'Content-Encoding': 'gzip'}
connection.request(method, path, headers=headers, body=data)
response = connection.getresponse()
return loads(response.read().decode())
finally:
connection.close()
def scrape(self):
'''Scrapes myPurdue for the course's information.'''
sock = HTTPSConnection(self.domain)
sock.request('GET', self.path)
try:
self.html = sock.getresponse().read()
self.html = self.html.decode()
except:
print('Error connecting to myPurdue:')
raise
finally:
sock.close()
def emit(self, record):
message = self.format(record)
if record.levelno >= self.mention_level and self.mention_level is not None:
message = "<@&{0}> {1}".format(self.mention_id, message)
url = self.urls[record.levelno]
body = json.dumps({"content": message})
headers = {'Content-Type': 'application/json'}
con = HTTPSConnection('discordapp.com')
con.request('POST', url, body, headers)
# Tell the server we're done with the request
con.getresponse()
con.close()
def getReport(self, reportFormat, options=None, user=None, hash=None):
self.status = YastStatus.SUCCESS
try:
user, hash = self._verifyLogin(user, hash)
# Request report
resp = self._request(
'<request req="report.getReport">' + '<user><![CDATA[' + user +
']]></user>' + '<hash><![CDATA[' + hash + ']]></hash>' +
'<reportFormat>' + reportFormat + '</reportFormat>' +
('' if options == None else
('<timeFrom>' + str(options['timeFrom']) +
'</timeFrom>' if 'timeFrom' in options else '') +
('<timeTo>' + str(options['timeTo']) +
'</timeTo>' if 'timeTo' in options else '') +
('<typeId>' + str(options['typeId']) +
'</typeId>' if 'typeId' in options else '') +
('<parentId>' + str(options['parentId']) +
'</parentId>' if 'parentId' in options else '') +
('<groupBy><![CDATA[' + options['groupBy'] +
']]></groupBy>' if 'groupBy' in options else '') +
('<constraints><![CDATA[' + options['constraints'] +
']]></constraints>' if 'constraints' in options else '')) +
'</request>')
self._verifyStatus(resp)
fields = self._getXmlFields(resp)
# Download
if self.useHttps:
conn = HTTPSConnection(self.host)
else:
conn = HTTPConnection(self.host)
conn.request(
'GET',
self.dlPath + "?" + urlencode({
'type': 'report',
'id': fields['reportId'],
'hash': fields['reportHash'],
'user': user,
'userhash': hash
}))
file = conn.getresponse().read()
conn.close()
return file
except:
if self.status == YastStatus.SUCCESS:
self.status = YastStatus.LIB_EXCEPTION
if self.propagateExceptions:
raise
return False
def __init__(self, video_id):
self.video_id = video_id
conn = HTTPSConnection("www.youtube.com")
conn.request("GET", "/watch?v={}".format(video_id))
stream = conn.getresponse()
encoding = stream.getheader("Content-Encoding")
if encoding is not None and encoding.lower().find("gzip") > -1:
stream = GzipFile(fileobj=stream)
self.data = str(stream.read(), "utf-8")
conn.close()
def getFieldData(authorization):
authstring = 'Bearer ' + authorization
connection = HTTPSConnection('hackillinois.climate.com')
headers = {'Authorization': authstring,
'Content-type': 'application/json',
'Accept': 'application/json'}
connection.request('GET', '/api/fields?includeBoundary=true', headers=headers)
response = connection.getresponse()
data = response.read().decode()
print(data)
connection.close()
return json.loads(data)
def post_request(self,data,extra_path=""):
headers = {
"Content-type": "application/json, charset=UTF-8",
"Accept": "application/json,multipart/related" }
if self.scheme.lower()=='https':
conn = HTTPSConnection(self.hostname,self.port)
else:
conn = HTTPConnection(self.hostname,self.port)
req_path = self.path + '/' + extra_path
conn.request("POST", req_path, data, headers)
jsonwsp_response = self.parse_response(conn.getresponse())
conn.close()
return jsonwsp_response
def request(method, url, timeout=None):
scheme, host, path, params, query, fragment = urlparse(url)
connection = None
try:
if scheme == 'https':
connection = HTTPSConnection(host, timeout=timeout)
else:
connection = HTTPConnection(host, timeout=timeout)
connection.request(method, url)
return connection.getresponse()
finally:
if connection:
connection.close()
def fetchFile(self, server, path):
"Fetch file using httplib module."
print("downloading http://%s%s" % (server, path))
req = HTTPSConnection(server)
req.putrequest('GET', path)
req.putheader('Host', server)
req.putheader('Accept', 'text/svg')
req.endheaders()
r1 = req.getresponse()
data = r1.read().decode('utf-8')
req.close()
return data
def open(self, data):
if data["scheme"] == "https":
conn = HTTPSConnection(data["netloc"], timeout=self.Parent.Configs.timeout)
else:
conn = HTTPConnection(data["netloc"], timeout=self.Parent.Configs.timeout)
try:
conn.request("GET", data["path"], "", data["headers"])
except:
return False
try:
response = conn.getresponse()
output = {"status":response.status, "reason":response.reason, "data":response.read(), "headers":response.getheaders()}
except:
output = False
conn.close()
return output
def getUserId(authorization, email):
authstring = 'Bearer ' + authorization
connection = HTTPSConnection('hackillinois.climate.com')
headers = {'Authorization': authstring,
'Content-type': 'application/json',
'Accept': 'application/json'}
#email = email.replace("@",
connection.request('GET', '/users/details?email='+email, headers=headers)
response = connection.getresponse()
data = response.read().decode()
print(data)
connection.close()
the_json = json.loads(data)
if 'id' in the_json:
return the_json['id']
else:
return 0
def makeGetRequest(url):
start_index = url.find("://")+3;
stem_index = url.find("/", start_index)
base = url[start_index:stem_index]
stem = url[stem_index:]
filename = url[url.rfind("/")+1:]
print("base: " + base)
print("stem: " + stem)
h1 = HTTPSConnection(base);
h1.request("GET", stem)
res = h1.getresponse()
print("res status: {0}".format(res.status))
data = res.read();
h1.close()
return (data, filename);
def post_request(self,data,extra_path="",via_proxy=False,extra_headers=None):
headers = {
"Content-type": "application/json, charset=UTF-8",
"Accept": "application/json,multipart/related" }
if via_proxy:
headers["Ladon-Proxy-Path"] = "%s://%s:%d%s" % (
self.scheme.lower(),self.hostname,self.port,self.path)
if self.scheme.lower()=='https':
conn = HTTPSConnection(self.hostname,self.port)
else:
conn = HTTPConnection(self.hostname,self.port)
req_path = self.path + '/' + extra_path
if extra_headers:
headers.update(extra_headers)
conn.request("POST", req_path, data, headers)
jsonwsp_response = self.parse_response(conn.getresponse())
conn.close()
return jsonwsp_response
def process_message(self, peer, mailfrom, rcpttos, message_data):
p = Popen(['python', 'mailtojson.py', '-p'], stdout=PIPE, stdin=PIPE, stderr=STDOUT)
mailtojson_stdout = p.communicate(input=bytes(message_data, 'UTF-8'))[0]
#print(mailtojson_stdout.decode())
mailtojson_stdout = json.loads(mailtojson_stdout.decode())
mailtojson_stdout['_peer'] = peer;
mailtojson_stdout['_mailfrom'] = mailfrom;
mailtojson_stdout['_rcpttos'] = rcpttos;
mailtojson_stdout['_smtpuser'] = authSMTP.username;
mailtojson_stdout['_smtppass'] = authSMTP.password;
conn = HTTPSConnection("www.sendsecure.org")
headers = { "charset" : "utf-8", "Content-Type": "application/json", "User-Agent": "SendSecure/MailEncode 1.0" }
postJson = json.dumps(mailtojson_stdout, ensure_ascii = False)
conn.request("POST", "/smtp_post.php", postJson.encode('utf-8'), headers)
response = conn.getresponse()
print(response.read())
conn.close()
def getReport(self, reportFormat, options=None, user=None, hash=None):
self.status = YastStatus.SUCCESS
try:
user, hash = self._verifyLogin(user, hash)
# Request report
resp = self._request('<request req="report.getReport">' +
'<user><![CDATA[' + user + ']]></user>' +
'<hash><![CDATA[' + hash + ']]></hash>' +
'<reportFormat>' + reportFormat + '</reportFormat>' +
('' if options == None else
('<timeFrom>' + str(options['timeFrom']) + '</timeFrom>' if 'timeFrom' in options else '') +
('<timeTo>' + str(options['timeTo']) + '</timeTo>' if 'timeTo' in options else '') +
('<typeId>' + str(options['typeId']) + '</typeId>' if 'typeId' in options else '') +
('<parentId>' + str(options['parentId']) + '</parentId>' if 'parentId' in options else '') +
('<groupBy><![CDATA[' + options['groupBy'] + ']]></groupBy>' if 'groupBy' in options else '') +
('<constraints><![CDATA[' + options['constraints'] + ']]></constraints>' if 'constraints' in options else '')) +
'</request>')
self._verifyStatus(resp)
fields = self._getXmlFields(resp)
# Download
if self.useHttps:
conn = HTTPSConnection(self.host)
else:
conn = HTTPConnection(self.host)
conn.request('GET', self.dlPath + "?" + urlencode({'type': 'report',
'id': fields['reportId'],
'hash': fields['reportHash'],
'user': user,
'userhash': hash}))
file = conn.getresponse().read()
conn.close()
return file
except:
if self.status == YastStatus.SUCCESS:
self.status = YastStatus.LIB_EXCEPTION
if self.propagateExceptions:
raise
return False
def send_request(role, method, type, name, attrib, value, value_type):
host = role.ip + ":" + role.serverport
auth = b64encode((role.backend_name + ":" + role.backend_pass).encode()).decode()
uri = "/" + type + ("/" + name) if name != None else "" + ("/" + attrib) if attrib != None else ""
header = {"Authorization": "Basic " + auth}
if value_type != None:
header["Content-type"] = value_type
client = HTTPSConnection(host, timeout=5)
try:
print("Send request: %s %s" % (host, uri))
client.request(method, uri, value, header)
response = client.getresponse()
client.close()
print("Get response: %s %s %s" % (response.status, response.reason, response.read().decode()))
return response
except:
print("Send error: %s %s" % (host, uri))
role.active = False
return None
def connect(self, srvhost, srvport):
self.con = ssl._create_unverified_context(protocol=ssl.PROTOCOL_TLSv1, cafile=ca_crt)
from http.client import HTTPSConnection
c = HTTPSConnection(srvhost, port=srvport, context=self.con)
try:
c.connect()
except ConnectionRefusedError as e:
raise ConnectException("Cannot connect to 'https://%s:%d/'. %s" % (srvhost, srvport, e))
except:
raise ConnectException("Connect to 'https://%s:%d/' failed. Unknown error." % (srvhost, srvport))
finally:
c.close()
try:
self.proxy = ServerProxy("https://%s:%d/" % (srvhost, srvport),
context=self.con)
except:
raise ConnectException(
"Connect to crtyptoTank server at 'https://%s:%d/' failed. Unknown error." % (srvhost, srvport)
)
def delete_request(self, user_id, request_id):
"""Deletes the Request with the given ID for the given user."""
conn = HTTPSConnection('graph.facebook.com')
url = '/%s_%s?%s' % (
request_id,
user_id,
urlencode({'access_token': self.access_token}),
)
conn.request('DELETE', url)
response = conn.getresponse()
data = response.read()
response = _parse_json(data)
# Raise an error if we got one, but don't not if Facebook just
# gave us a Bool value
if (response and isinstance(response, dict) and response.get("error")):
raise GraphAPIError(response)
conn.close()
def fetchFile(self, url):
"Get content with some given URL, uncompress if needed."
parsed = urlparse(url)
conn = HTTPSConnection(parsed.netloc)
conn.request("GET", parsed.path)
r1 = conn.getresponse()
if (r1.status, r1.reason) == (200, "OK"):
data = r1.read()
if r1.getheader("content-encoding") == "gzip":
zbuf = io.BytesIO(data)
zfile = gzip.GzipFile(mode="rb", fileobj=zbuf)
data = zfile.read()
zfile.close()
data = data.decode('utf-8')
else:
data = None
conn.close()
return data
def call(self, method='', params=None):
""" Call T411 API """
if params is not None:
params = urlencode(params)
headers = HTTP_HEADERS
if method != 'auth':
headers['Authorization'] = self._token
conn = HTTPSConnection(API_URL)
conn.request('POST', '/%s' % method, body=params, headers=headers)
r = conn.getresponse()
if r.status == HTTP_OK:
#import pdb; pdb.set_trace()
rt = r.read()
try:
pass
rt = rt.decode('utf-8')
conn.close()
except:
conn.close()
return rt
else:
conn.close()
return False
