def view_kbase(server_name, url_suff, limit=1, kbase_id=None):
full_addr = server_name + url_suff["view_kbase"]
response_list = []
if kbase_id:
full_addr += kbase_id
req = HTTPRequest(full_addr, "GET")
response = req.get()
response_dict = response.json()
if response_dict.status_code == 200:
response_list.append(response_dict)
else:
full_addr += '?limit={0}'.format(limit)
req = HTTPRequest(full_addr, "GET")
response = req.get()
response_dict = response.json()
if response.status_code == 200:
response_list = [response_dict]
while response_dict.get("nextUri", 'null') != 'null':
full_addr = server_name + url_suff["view_kbase"]
full_addr += '?limit={0}'.format(limit)
full_addr += response_dict.get("nextUri")
req = HTTPRequest(full_addr, "GET")
response = req.get()
response_dict = response.json()
if response.status_code == 200:
response_list.append(response_dict)
return response_list
def view_ctg(server_name, url_suff, kbase_id, lang_code, ctg_id=None, limit=1):
full_addr = server_name + url_suff["view_ctg"]
response_list = []
if ctg_id:
full_addr += '/{categoryId}'
full_addr = full_addr.format(knowledgebaseId=kbase_id,
languageCode=lang_code,
categoryId=ctg_id)
req = HTTPRequest(full_addr, "GET")
response = req.get()
response_list.append(response.json())
else:
# if there is a limit, limit your request
full_addr += '?limit={limit_num}'
full_addr = full_addr.format(knowledgebaseId=kbase_id,
languageCode=lang_code,
categoryId=ctg_id,
limit_num=limit)
req = HTTPRequest(full_addr, "GET")
response = req.get()
response_dict = response.json()
response_list = [response_dict]
while response_dict.get("nextUri", 'null') != 'null':
full_addr = server_name + url_suff["view_ctg"]
full_addr += '?limit={0}'.format(limit)
full_addr += response["nextUri"]
req = HTTPRequest(full_addr, "GET")
response = req.get()
response_dict = response.json()
response_list.append(response_dict)
return response_list
def test_sendRequest(self):
req = HTTPRequest("tests/testReq1", isTLS=True, verify=False)
req.send()
self.assertTrue("buildVersion" in req.response.text)
req = HTTPRequest("tests/testReqPost1", isTLS=True, verify=True)
req.send()
self.assertTrue("Brainloop Web" in req.response.text)
con = Connection(isTLS=True, verify=False)
req = HTTPRequest("tests/testReqPost1", connection=con)
req.send()
self.assertTrue("Brainloop Web" in req.response.text)
req = HTTPRequest("tests/reqHEAD1", connection=con)
req.send()
self.assertTrue(req.response.status_code == 405)
def create_kbase(server_name,
url_suff,
payload_info,
org_id,
token,
kbase_responses={}):
# Check if # of databases exceeds limit (5)
if len(kbase_responses.items()) == 5:
return {},
full_addr = server_name + url_suff["create_kbase"]
req = HTTPRequest(full_addr, "POST")
for key in payload_info.keys():
req.payload_append(key, payload_info[key])
#'Content-Type': "application/json",
#'organizationid': "3ae6bd8b-23b6-47c7-a9a0-8dc56833ca18",
#'token': "eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJvcmdJZCI6IjNhZTZiZDhiLTIzYjYtNDdjNy1hOWEwLThkYzU2ODMzY2ExOCIsImV4cCI6MTU3MTUxNjYyOCwiaWF0IjoxNTcxNTEzMDI4fQ.S1mQ4sdeSaPhTCwUodVOb6QW3yOzTnQKOunSU732SSI",
#'cache-control': "no-cache",
req.add_header("Content-Type", "application/json")
req.add_header("organizationid", org_id)
req.add_header("token", token)
req.add_header("cache-control", "no-cache")
response = req.post()
print(response)
print("response: ", response.json())
def update_proxies(self, wait=True):
Logger.message('ProxyManager: Updating proxy list')
proxy_list = HTTPRequest(
self._proxies_list_url).read().splitlines(False)
if len(proxy_list) == 0:
Logger.error(
'ProxyManager: Could not retrieve proxy list from server')
if len(proxy_list) == 1:
if wait:
Logger.message(
'ProxyManager: Waiting for access to proxy list')
time.sleep(30)
self.update_proxies()
return
for proxy in proxy_list:
if proxy not in self._proxies:
self._proxies.append(proxy)
if proxy in self._deleted_proxies:
Logger.message(
'ProxyManager: Added previously removed proxy {} as suspicious'
.format(proxy))
self._suspect_proxies.append(proxy)
else:
Logger.message(
'ProxyManager: Added proxy {}'.format(proxy))
if len(self._proxies) == 0:
Logger.error('ProxyManager: Proxy list is empty')
return False
return True
def getHttp(data):
request = HTTPRequest(data)
# print request.error_code # None (check this first)
# print request.command # "GET"
print request.path # "/who/ken/trust.html"
# print request.request_version # "HTTP/1.1"
# print len(request.headers) # 3
# print request.headers.keys() # ['accept-charset', 'host', 'accept']
print request.headers['host'] # "cm.bell-labs.com"
# print request.headers;
######
# req = urllib2.Request(getIp(request.headers['host']),headers=request.headers)
# for key in request.headers:
# print key+":"+request.headers[key]
# req.add_header(key, request.headers[key])
# res = urllib2.urlopen("http://"+request.headers['host'])
# res=urllib2.urlopen(req)
# print res.info()
# return res
#####
dictHeader = {} #构造包头
for key in request.headers:
dictHeader[key] = request.headers[key]
conn = httplib.HTTPConnection(getIp(request.headers['host']))
conn.request(request.command, request.path, "", dictHeader)
r1 = conn.getresponse()
# print r1.status, r1.reason
returnData = str(request.request_version) + " " + str(
r1.status) + " " + str(r1.reason) + "\n" + str(r1.msg) + "\n" + str(
r1.read())
# print "返回的数据包包头\n"+returnData
# logCommand(returnData)
return returnData
def mod_docs(server_name, url_suff, kbase_id, lang_code, payloads, categories={}):
full_addr = server_name + url_suff["mod_docs"]
full_addr = full_addr.format(knowledgebaseID=kbase_id,
languageCode=lang_code)
responses = ()
request_count = 0
req = HTTPRequest(full_addr, "PATCH")
for payload in payloads:
request_count += 1
req.payload_append("type", "Faq")
key = "faq"
val = {"question": payload["question"],
"answer": payload["answer"],
"alternatives": payload["alternatives"]}
req.payload_append(key, val)
key = "categories"
val = []
for elem1, elem2 in categories.items():
val.append({elem1: elem2})
req.payload_append(key, val)
req.payload_append("externalUrl", "")
response = req.patch()
response_dict = response.json()
responses += ((response_dict.get('id', request_count), response.status_code), )
return responses
def search(server_name,
url_suff,
kbase_id,
req_payload,
org_id,
token,
search_size=1):
full_addr = server_name + url_suff["search"]
full_addr = full_addr.format(knowledgebaseId=kbase_id)
req = HTTPRequest(full_addr, "POST")
for key in req_payload.keys():
req.payload_append(key, req_payload[key])
req.payload_append("pageSize", search_size)
req.payload_append("pageNumber", 1)
req.payload_append("languageCode", "en-US")
req.payload_append("documentType", "Faq")
req.add_header("Content-Type", "application/json")
req.add_header("organizationid", org_id)
req.add_header("token", token)
req.add_header("cache-control", "no-cache")
response = (req.post())
print("Response status: ", response.status_code)
resp_json = response.json()
if resp_json.get("results"):
results = resp_json["results"]
else:
results = []
return results
def create_kbase(server_name, url_suff, payload_info, kbase_responses={}):
# Check if # of databases exceeds limit (5)
if len(kbase_responses.items()) == 5:
return {},
full_addr = server_name + url_suff["create_kbase"]
req = HTTPRequest(full_addr, "POST")
for key in payload_info.keys():
req.payload_append(key, payload_info[key])
response = req.post()
resp_id = response.json().get("id")
kbase_responses['status_code'] = response.status_code
if resp_id:
kbase_responses[resp_id] = (response["dateCreated"],
response["dateModified"],
response["selfUri"])
else:
return kbase_responses
return kbase_responses
def upload_doc(server_name, url_suff, kbase_id, lang_code, payload, org_id, token, categories={}):
full_addr = server_name + url_suff["upload_doc"]
full_addr = full_addr.format(knowledgebaseId=kbase_id,
languageCode=lang_code)
req = HTTPRequest(full_addr, "POST")
req.payload_append("type", "faq")
key = "faq"
val = {"question": payload["question"],
"answer": payload["answer"],
"alternatives": []}
req.payload_append(key, val)
key = "categories"
val = []
for elem1, elem2 in categories.items():
val.append({elem1: elem2})
req.payload_append(key, val)
req.payload_append("externalUrl", "")
req.add_header("Content-Type", "application/json")
req.add_header("organizationid", org_id)
req.add_header("token", token)
req.add_header("cache-control", "no-cache")
response = req.post()
print("RESPONSE CODE: ",response.status_code)
print("RESPONSE JSON: ",response.json())
return response.status_code
def sendNotify(self, method, params):
# jsonrpc: A String specifying the version of the JSON-RPC protocol.
# MUST be exactly "2.0"
# If jsonrpc is missing, the server MAY handle the Request as
# JSON-RPC V1.0-Request.
# version: String specifying the version of the JSON-RPC protocol.
# MUST be exactly "1.1"
# NOTE: We send both, to indicate that we can handle both.
#
# id: If omitted, the Request is a Notification
# NOTE: JSON-RPC 1.0 uses an id of Null for Notifications.
# method: A String containing the name of the procedure to be invoked.
# params: An Array or Object, that holds the actual parameter values
# for the invocation of the procedure. Can be omitted if
# empty.
# NOTE: JSON-RPC 1.0 only a non-empty Array is used
# From the spec of 1.1:
# The Content-Type MUST be specified and # SHOULD read
# application/json.
# The Accept MUST be specified and SHOULD read application/json.
#
msg = {
"jsonrpc": "2.0",
"version": "1.1",
"method": method,
"params": params
}
msg_data = dumps(msg)
if not HTTPRequest().asyncPost(self.url, msg_data, self, False,
"text/json", self.headers):
return -1
return 1
def handle_request(self, data):
request = HTTPRequest(data)
operations = request.method.split(
) # We assume the operands will be space seperated
n = len(operations)
if (n - 1) % 2 != 0:
return FORMAT_STRING
try:
ans = int(operations[0])
except:
return FORMAT_STRING
i = 0
try:
while i < n - 1:
if operations[i + 1] == "+":
ans += int(operations[i + 2])
elif operations[i + 1] == "-":
ans -= int(operations[i + 2])
elif operations[i + 1] == "*":
ans *= int(operations[i + 2])
elif operations[i + 1] == "/":
ans /= int(operations[i + 2])
else:
return FORMAT_STRING
i += 2
except:
return FORMAT_STRING
return str(ans).encode('utf8')
def view_kbase(server_name, url_suff, org_id, token, limit=1, kbase_id=None):
full_addr = server_name + url_suff["view_kbase"]
response_list = []
print('kbase_id in view_kbase', kbase_id)
if kbase_id:
full_addr += '/' + kbase_id
req = HTTPRequest(full_addr, "GET")
req.add_header("Content-Type", "application/json")
req.add_header("organizationid", org_id)
req.add_header("token", token)
req.add_header("cache-control", "no-cache")
response = req.get()
response_dict = response.json()
if response_dict.status_code == 200:
response_list.append(response_dict)
else:
full_addr += '?limit={0}'.format(limit)
req = HTTPRequest(full_addr, "GET")
req.add_header("Content-Type", "application/json")
req.add_header("organizationid", org_id)
req.add_header("token", token)
req.add_header("cache-control", "no-cache")
response = req.get()
print("Response:", response)
response_dict = response.json()
if response.status_code == 200:
response_list = response_dict["entities"]
print("Resp List", response_list)
# while response_dict.get("nextUri") != None:
# print("in loop")
# full_addr = server_name + url_suff["view_kbase"]
# full_addr += '?limit={0}'.format(limit)
# full_addr += response_dict.get("nextUri")
# req = HTTPRequest(full_addr, "GET")
# response = req.get()
# response_dict = response.json()
# if response.status_code == 200:
# response_list.append(response_dict)
ret_list = []
for elem in response_list:
ret_list.append(elem['id'])
return ret_list
return response_list
def delete_kbase(server_name, url_suff, kbase_id):
full_addr = server_name + url_suff["delete_kbase"]
full_addr += kbase_id
req = HTTPRequest(full_addr, "DELETE")
response = req.delete()
response_result = response.json()
response_result['status_code'] = response.status_code
return response_result
def delete_doc(server_name, url_suff, kbase_id, lang_code, doc_id):
full_addr = server_name + url_suff["delete_doc"]
full_addr = full_addr.format(knowledgebaseId=kbase_id,
languageCode=lang_code,
documentId=doc_id)
req = HTTPRequest(full_addr, "DELETE")
response = req.delete()
return response.status_code
def test_importRequest(self):
req = HTTPRequest("tests/testReq1", isTLS=True, verify=False)
self.assertEqual(req.command, "GET")
self.assertEqual(len(req.headers), 11)
req = HTTPRequest("tests/testReqPost1", isTLS=True, verify=True)
self.assertEqual(req.command, "POST")
self.assertEqual(len(req.headers), 12)
self.assertTrue("antoine.scemama" in str(req.postBody))
con = Connection(isTLS=True,
verify=False,
proxies={
'http': 'http://127.0.0.1:8080',
'https': 'http://127.0.0.1:8080',
})
req = HTTPRequest("tests/testReqPost1", connection=con)
self.assertEqual(req.command, "POST")
self.assertEqual(len(req.headers), 12)
self.assertTrue("antoine.scemama" in str(req.postBody))
def delete_ctg(server_name, url_suff, kbase_id, lang_code, ctg_id):
full_addr = server_name + url_suff["delete_ctg"]
full_addr = full_addr.format(knowledgebaseId=kbase_id,
languageCode=lang_code,
categoryId=ctg_id)
req = HTTPRequest(full_addr, "DELETE")
response = req.delete()
return response.status_code
def getURL(self, *args, **kwargs):
""" see HTTPRequest for argument list """
h = HTTPRequest(None, self.getOptions())
try:
rep = h.load(*args, **kwargs)
finally:
h.close()
return rep
def update_kbase(server_name, url_suff, payload_info, kbase_id):
full_addr = server_name + url_suff["update_kbase"]
full_addr += kbase_id
req = HTTPRequest(full_addr, "PUT")
for key in payload_info.keys():
req.payload_append(key, payload_info[key])
response = req.put()
response_result = response.json()
response_result['status_code'] = response.status_code
return response_result
def __sendRequest(self, method, params, handler):
id = pygwt.getNextHashId()
msg = {"id": id, "method": method, "params": params}
msg_data = self.parser.encode(msg)
request_info = JSONRequestInfo(id, method, handler)
if not HTTPRequest().asyncPost(self.url, msg_data,
JSONResponseTextHandler(request_info)):
return -1
return id
def update_ctg(server_name, url_suff, kbase_id, lang_code, ctg_id):
full_addr = server_name + url_suff["update_ctg"]
full_addr = full_addr.format(knowledgebaseId=kbase_id,
languageCode=lang_code,
categoryId=ctg_id)
req = HTTPRequest(full_addr, "PUT")
for key in payload_info_ctg.keys():
req.payload_append(key, payload_info_ctg[key])
response = req.put()
return response.status_code
def view_doc(server_name, url_suff, kbase_id, lang_code, doc_id):
full_addr = server_name + url_suff["view_doc"]
full_addr = full_addr.format(knowledgebaseId=kbase_id,
languageCode=lang_code,
documentId=doc_id)
req = HTTPRequest(full_addr, "GET")
response_list = []
response = req.get()
if response.status_code == 200:
response_list.append(response.json())
return response_list
def sendRequest(self, method, params, handler):
id = nextRequestID()
msg = {"jsonrpc": "2.0", "id": id, "method": method, "params": params}
msg_data = dumps(msg)
request_info = JSONRequestInfo(id, method, handler)
if not HTTPRequest().asyncPost(self.url, msg_data,
JSONResponseTextHandler(request_info),
False, self.content_type, self.headers):
return -1
return id
def load(self, base_url=None, domain=None, lang=None, onCompletion=None, onError=None):
if base_url is None:
base_url = self.base_url
if domain is None:
domain = self.domain
url = base_url
if domain is not None and lang is not None:
url = "%s/%s_%s.json" % (url, domain, lang)
self.new_catalog(base_url, domain, lang)
self._onCompletion = onCompletion
self._onError = onError
HTTPRequest().asyncGet(url, self)
def delete_kbase(org_id, token, server_name, url_suff, kbase_id):
print("IN DELETE!!!!")
full_addr = server_name + url_suff["delete_kbase"]
full_addr += kbase_id
req = HTTPRequest(full_addr, "DELETE")
req.add_header("Content-Type", "application/json")
req.add_header("organizationid", org_id)
req.add_header("token", token)
req.add_header("cache-control", "no-cache")
response = req.delete()
print("Response: ", response, ", Response Code:", response.status_code)
return response.status_code
def handle_request(self, data):
# create an instance of HTTPRequest
request = HTTPRequest(data)
# Calling the Appropriate handler
try:
handler = getattr(self, "handle_" + request.method)
except AttributeError:
handler = self.HTTP_501_handler
response = handler(request)
return response
def view_doc(server_name, url_suff, kbase_id, lang_code, doc_id, org_id, token):
full_addr = server_name + url_suff["view_doc"]
full_addr = full_addr.format(knowledgebaseId=kbase_id,
languageCode=lang_code,
documentId=doc_id)
req = HTTPRequest(full_addr, "GET")
#response_list = []
req.add_header("Content-Type", "application/json")
req.add_header("organizationid", org_id)
req.add_header("token", token)
req.add_header("cache-control", "no-cache")
response = req.get()
return response.json()
def view_docs(server_name, url_suff, kbase_id, lang_code, limit=1):
full_addr = server_name + url_suff["view_docs"]
full_addr += '?limit={limit_num}'
full_addr = full_addr.format(knowledgebaseId=kbase_id,
languageCode=lang_code,
limit_num=limit)
req = HTTPRequest(full_addr, "GET")
response = req.get()
response_dict = response.json()
response_list = [response_dict]
while response_dict.get("nextUri", 'null') != 'null':
full_addr = server_name + url_suff["view_docs"]
full_addr += '?limit={limit_num}'
full_addr = full_addr.format(knowledgebaseId=kbase_id,
languageCode=lang_code,
limit_num=limit)
full_addr += response["nextUri"]
req = HTTPRequest(full_addr, "GET")
response = req.get()
response_dict = response.json()
response_list.append(response_dict)
return response_list
def view_trained_model_list(server_name,
url_suff,
kbase_id,
lang_code,
model_limit=1):
full_addr = server_name + url_suff["view_trained_model_list"]
full_addr = full_addr.format(knowledgebaseId=kbase_id,
languageCode=lang_code,
limit=model_limit)
req = HTTPRequest(full_addr, "GET")
response = (req.get())
req_list = response.json()
def checkHeader(self):
if "\r\n\r\n" in self.header:
# end of header found, lets check it
self.logger.debug("--------------HEADER START---------------")
self.logger.debug(self.header)
self.logger.debug("---------------HEADER END----------------")
request = HTTPRequest(self.header)
if request.error_code == None:
if request.command != "ACE":
return (405, "Method Not Allowed")
if request.path != "/ace":
return (404, "Not Found")
else:
return (request.error_code, request.error_message)
return True
else:
return False
