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 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 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_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 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 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 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 test_sendWithProxy(self):
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)
req.send()
self.assertEqual(req.command, "POST")
self.assertEqual(len(req.headers), 12)
self.assertTrue("antoine.scemama" in str(req.postBody))
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 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 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 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 __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 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)
class PopulateProject():
# URL of API
API_URL = 'http://*****:*****@%s.com" % (self.randomword(randint(5,15)), self.randomword(randint(4,8)))
}
self.req.post('PersonsServlet', person)
def randomword(self, length):
return ''.join(random.choice(string.lowercase) for i in range(length))
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 create_ctg(server_name, url_suff, payload_info_ctg, kbase_id, lang_code):
full_addr = server_name + url_suff["create_ctg"]
full_addr = full_addr.format(knowledgebaseId=kbase_id,
languageCode=lang_code)
req = HTTPRequest(full_addr, "POST")
for key in payload_info_ctg.keys():
req.payload_append(key, payload_info_ctg[key])
response = req.post()
response_dict = response.json()
resp_kbase_id = response_dict.get("knowledgeBase", {}).get("id")
ctg = response_dict.get("id")
if resp_kbase_id in kbase_categories.keys():
kbase_responses[resp_kbase_id].append(ctg)
else:
kbase_responses[resp_kbase_id] = [ctg]
return response.status_code
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
def relay_request(req_str):
req = HTTPRequest(req_str)
if req.command == 'GET':
http_conn = httplib.HTTPConnection(req.headers['host'])
http_conn.connect()
http_conn.request(req.command, req.path, headers=req.headers.dict)
resp = http_conn.getresponse()
content = resp.read()
headers = resp.getheaders()
headers_str = '\n'.join(map((lambda (k, v): '%s: %s' % (k, v)), headers))
resp.version = str(float(resp.version)/10)
resp_str = 'HTTP/%s %s %s\n%s\n\n%s' % (resp.version, resp.status, resp.reason, headers_str, content)
http_conn.close()
return resp_str
else:
return None
def createRequestForDict(requestDict):
"""Create request object for a given dictionary.
Create a request object (subclass of `Request`) given the raw
dictionary as passed by the adapter.
The class of the request may be based on the contents of the
dictionary (though only `HTTPRequest` is currently created),
and the request will later determine the class of the response.
Called by `dispatchRawRequest`.
"""
format = requestDict['format']
# Maybe an EmailAdapter would make a request with a format of Email,
# and an EmailRequest would be generated. For now just CGI/HTTPRequest.
assert format == 'CGI'
request = HTTPRequest(requestDict)
# The request object is stored for tracking/debugging purposes.
requestDict['requestObject'] = request
return request
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 __init__(self): self.req = HTTPRequest(self.API_URL)
class Browser(object):
__slots__ = ("log", "options", "bucket", "cj", "_size", "http", "dl")
def __init__(self, bucket=None, options={}):
self.log = getLogger("log")
self.options = options #holds pycurl options
self.bucket = bucket
self.cj = None # needs to be setted later
self._size = 0
self.renewHTTPRequest()
self.dl = None
def renewHTTPRequest(self):
if hasattr(self, "http"): self.http.close()
self.http = HTTPRequest(self.cj, self.options)
def setLastURL(self, val):
self.http.lastURL = val
# tunnel some attributes from HTTP Request to Browser
lastEffectiveURL = property(lambda self: self.http.lastEffectiveURL)
lastURL = property(lambda self: self.http.lastURL, setLastURL)
code = property(lambda self: self.http.code)
cookieJar = property(lambda self: self.cj)
def setCookieJar(self, cj):
self.cj = cj
self.http.cj = cj
@property
def speed(self):
if self.dl:
return self.dl.speed
return 0
@property
def size(self):
if self._size:
return self._size
if self.dl:
return self.dl.size
return 0
@property
def arrived(self):
if self.dl:
return self.dl.arrived
return 0
@property
def percent(self):
if not self.size: return 0
return (self.arrived * 100) / self.size
def clearCookies(self):
if self.cj:
self.cj.clear()
self.http.clearCookies()
def clearReferer(self):
self.http.lastURL = None
def abortDownloads(self):
self.http.abort = True
if self.dl:
self._size = self.dl.size
self.dl.abort = True
def httpDownload(self,
url,
filename,
get={},
post={},
ref=True,
cookies=True,
chunks=1,
resume=False,
progressNotify=None,
disposition=False):
""" this can also download ftp """
self._size = 0
self.dl = HTTPDownload(url, filename, get, post,
self.lastEffectiveURL if ref else None,
self.cj if cookies else None, self.bucket,
self.options, progressNotify, disposition)
name = self.dl.download(chunks, resume)
self._size = self.dl.size
self.dl = None
return name
def load(self, *args, **kwargs):
""" retrieves page """
return self.http.load(*args, **kwargs)
def putHeader(self, name, value):
""" add a header to the request """
self.http.putHeader(name, value)
def addAuth(self, pwd):
"""Adds user and pw for http auth
:param pwd: string, user:password
"""
self.options["auth"] = pwd
self.renewHTTPRequest() #we need a new request
def removeAuth(self):
if "auth" in self.options: del self.options["auth"]
self.renewHTTPRequest()
def setOption(self, name, value):
"""Adds an option to the request, see HTTPRequest for existing ones"""
self.options[name] = value
def deleteOption(self, name):
if name in self.options: del self.options[name]
def clearHeaders(self):
self.http.clearHeaders()
def close(self):
""" cleanup """
if hasattr(self, "http"):
self.http.close()
del self.http
if hasattr(self, "dl"):
del self.dl
if hasattr(self, "cj"):
del self.cj
def renewHTTPRequest(self):
if hasattr(self, "http"): self.http.close()
self.http = HTTPRequest(self.cj, self.options)
class Browser(object):
__slots__ = ("log", "options", "bucket", "cj", "_size", "http", "dl")
def __init__(self, bucket=None, options={}):
self.log = getLogger("log")
self.options = options #holds pycurl options
self.bucket = bucket
self.cj = None # needs to be setted later
self._size = 0
self.renewHTTPRequest()
self.dl = None
def renewHTTPRequest(self):
if hasattr(self, "http"): self.http.close()
self.http = HTTPRequest(self.cj, self.options)
def setLastURL(self, val):
self.http.lastURL = val
# tunnel some attributes from HTTP Request to Browser
lastEffectiveURL = property(lambda self: self.http.lastEffectiveURL)
lastURL = property(lambda self: self.http.lastURL, setLastURL)
code = property(lambda self: self.http.code)
cookieJar = property(lambda self: self.cj)
def setCookieJar(self, cj):
self.cj = cj
self.http.cj = cj
@property
def speed(self):
if self.dl:
return self.dl.speed
return 0
@property
def size(self):
if self._size:
return self._size
if self.dl:
return self.dl.size
return 0
@property
def arrived(self):
if self.dl:
return self.dl.arrived
return 0
@property
def percent(self):
if not self.size: return 0
return (self.arrived * 100) / self.size
def clearCookies(self):
if self.cj:
self.cj.clear()
self.http.clearCookies()
def clearReferer(self):
self.http.lastURL = None
def abortDownloads(self):
self.http.abort = True
if self.dl:
self._size = self.dl.size
self.dl.abort = True
def httpDownload(self, url, filename, get={}, post={}, ref=True, cookies=True, chunks=1, resume=False,
progressNotify=None, disposition=False):
""" this can also download ftp """
self._size = 0
self.dl = HTTPDownload(url, filename, get, post, self.lastEffectiveURL if ref else None,
self.cj if cookies else None, self.bucket, self.options, progressNotify, disposition)
name = self.dl.download(chunks, resume)
self._size = self.dl.size
self.dl = None
return name
def load(self, *args, **kwargs):
""" retrieves page """
return self.http.load(*args, **kwargs)
def putHeader(self, name, value):
""" add a header to the request """
self.http.putHeader(name, value)
def addAuth(self, pwd):
"""Adds user and pw for http auth
:param pwd: string, user:password
"""
self.options["auth"] = pwd
self.renewHTTPRequest() #we need a new request
def removeAuth(self):
if "auth" in self.options: del self.options["auth"]
self.renewHTTPRequest()
def setOption(self, name, value):
"""Adds an option to the request, see HTTPRequest for existing ones"""
self.options[name] = value
def deleteOption(self, name):
if name in self.options: del self.options[name]
def clearHeaders(self):
self.http.clearHeaders()
def close(self):
""" cleanup """
if hasattr(self, "http"):
self.http.close()
del self.http
if hasattr(self, "dl"):
del self.dl
if hasattr(self, "cj"):
del self.cj
def renewHTTPRequest(self):
if hasattr(self, "http"): self.http.close()
self.http = HTTPRequest(self.cj, self.options)
def analize_request(request):
r = HTTPRequest(request)
print(r.raw_request())
'http': 'http://127.0.0.1:8080',
'https': 'http://127.0.0.1:8080',
})
#req=HTTPRequest("testReqPost1",connection=con)
#req.printFields()
#macro=Macro(con,"testReq1","testReqPost1")
#var1=MacroVariable(0,True,"Version\":\"","\",\"build")
#var2=MacroVariable(1,False,"username="******"&password")
#rule1=MacroRule(var1,var2)
#macro.addRule(rule1)
#macro.run()
#req.send()
req = HTTPRequest("reqPost2",
isTLS=True,
proxies={
'http': 'http://127.0.0.1:8080',
'https': 'http://127.0.0.1:8080',
},
verify=False)
#req.printFields()
req.send()
print("time", req.elapsed)
#req.replaceString("antoine","yoo")
#req.send()
#req.printFields()
#req=HTTPRequest("testReqPost1",isTLS=True,verify=False)
#req.replaceString("en-US","yo")
#req1=HTTPRequest("reqLoginBLNET1",connection=con)
#req2=HTTPRequest("reqLoginBLNET2",connection=con)
#macro=Macro(con, "reqLoginBLNET1", "reqLoginBLNET2")
def create_request(self, **kwargs):
url = "{}:{}".format(self.url, self.port)
request = HTTPRequest(url, self.method, **kwargs)
self.request = request
class TemplatePanel(ComplexPanel):
"""
Panel which allows you to attach or insert widgets into
a pre-defined template.
We don't do any caching of our own, since the browser will
do caching for us, and probably more efficiently.
"""
templateRoot = ""
"""Set staticRoot to change the base path of all the templates that are loaded; templateRoot should have a trailing slash"""
def __init__(self, templateName, allowEdit=False):
ComplexPanel.__init__(self)
self.loaded = False # Set after widgets are attached
self.widgetsAttached = False
self.id = None
self.templateName = None
self.title = None
self.elementsById = {}
self.metaTags = {}
self.body = None
self.links = []
self.forms = []
self.metaTagList = []
self.loadListeners = []
self.toAttach = []
self.toInsert = []
self.setElement(DOM.createDiv())
self.editor = None
self.allowEdit = allowEdit
if templateName:
self.loadTemplate(templateName)
def getTemplatePath(self, templateName):
return self.templateRoot+'tpl/'+templateName+'.html'
def loadTemplate(self, templateName):
self.templateName = templateName
self.id = templateName + str(hash(self))
self.httpReq = HTTPRequest()
self.httpReq.asyncGet(self.getTemplatePath(templateName), TemplateLoader(self))
def getCurrentTemplate(self):
"""Return the template that is currently loaded, or is loading"""
return self.templateName
def isLoaded(self):
"""Return True if the template is finished loading"""
return self.loaded
def areWidgetsAttached(self):
"""Return True if the template is loaded and attachWidgets() has been called"""
return self.widgetsAttached
def setTemplateText(self, text):
"""
Set the template text; if the template is not HTML, a subclass could override this
to pre-process the text into HTML before passing it to the default implementation.
"""
if self.allowEdit:
self.originalText = text
# If we have children, remove them all first since we are trashing their DOM
for child in List(self.children):
self.remove(child)
DOM.setInnerHTML(self.getElement(), text)
self.elementsById = {}
self.links = []
self.metaTags = {}
self.forms = []
self.metaTagList = []
# Make the ids unique and store a pointer to each named element
for node in DOM.walkChildren(self.getElement()):
#console.log("Passing node with name %s", node.nodeName)
if node.nodeName == "META":
name = node.getAttribute("name")
content = node.getAttribute("content")
console.log("Found meta %o name %s content %s", node, name, content)
self.metaTags[name] = content
self.metaTagList.append(node)
elif node.nodeName == "BODY":
self.body = node
elif node.nodeName == "TITLE":
self.title = DOM.getInnerText(node)
elif node.nodeName == "FORM":
self.forms.append(node)
nodeId = DOM.getAttribute(node, "id")
if nodeId:
self.elementsById[nodeId] = node
DOM.setAttribute(node, "id", self.id+":"+node.id)
nodeHref = DOM.getAttribute(node, "href")
if nodeHref:
self.links.append(node)
self.loaded = True
if self.attached:
self.attachWidgets()
self.widgetsAttached = True
if self.allowEdit:
self.editor = None
self.editButton = Label("edit "+unescape(self.templateName))
self.editButton.addStyleName("link")
self.editButton.addStyleName("ContentPanelEditLink")
self.editButton.addClickListener(EventDelegate("onClick", self, self.onEditContentClick))
ComplexPanel.insert(self, self.editButton, self.getElement(), len(self.children))
self.notifyLoadListeners()
def onError(self, html, statusCode):
if statusCode == 404 and self.allowEdit:
self.editor = None
self.originalText = ""
DOM.setInnerHTML(self.getElement(), '')
self.editButton = Label("create "+unescape(self.templateName))
self.editButton.addStyleName("link")
self.editButton.addStyleName("ContentPanelEditLink")
self.editButton.addClickListener(EventDelegate("onClick", self, self.onEditContentClick))
ComplexPanel.insert(self, self.editButton, self.getElement(), len(self.children))
return
# Show the page we got in an iframe, which will hopefully show the error better than we can.
# DOM.setInnerHTML(self.getElement(), '<iframe src="'+self.getTemplatePath(self.templateName)+'"/>')
def onTimeout(self, text):
self.onError("Page loading timed out: "+text)
def getElementsById(self):
"""Return a dict mapping an id to an element with that id inside the template; useful for post-processing"""
return self.elementsById
def getLinks(self):
"""Return a list of all the A HREF= elements found in the template."""
return self.links
def getForms(self):
"""Return a list of all the FORM elements found in the template."""
return self.forms
def onAttach(self):
if not self.attached:
SimplePanel.onAttach(self)
if self.loaded and not self.widgetsAttached:
self.attachWidgets()
self.widgetsAttached = True
def attachWidgets(self):
"""
Attach and insert widgets into the DOM now that it has been loaded. If any
widgets were attached before loading, they will have been queued and the
default implementation will attach them.
Override this in subclasses to attach your own widgets after loading.
"""
for attach in self.toAttach:
self.attach(attach.name, attach.widget)
for insert in self.toInsert:
self.insert(insert.name, insert.widget)
def getElementById(self, id):
return self.elementsById[id]
def insert(self, id, widget):
"""
Insert a widget into the element with the given id, at the end
of its children.
"""
if not self.loaded:
self.toInsert.append(PendingAttachOrInsert(id, widget))
else:
element = self.getElementById(id)
if element:
self.adopt(widget, element)
self.children.append(widget)
else:
console.error("Page error: No such element "+id)
return widget
def attachToElement(self, element, widget):
events = DOM.getEventsSunk(widget.getElement())
widget.unsinkEvents(events)
widget.setElement(element)
widget.sinkEvents(events)
self.adopt(widget, None)
self.children.append(widget)
def replaceElement(self, element, widget):
"""
Replace an existing element with the given widget
"""
DOM.getParent(element).replaceChild(widget.getElement(), element)
self.adopt(widget, None)
self.children.append(widget)
def attach(self, id, widget):
"""
Attach a widget onto the element with the given id; the element
currently associated with the widget is discarded.
"""
if not self.loaded:
self.toAttach.append(PendingAttachOrInsert(id, widget))
else:
element = self.getElementById(id)
if element:
self.attachToElement(element, widget)
else:
console.error("Page error: No such element "+id)
return widget
def getMeta(self, name):
"""
Get the value of a meta-variable found in the template, or None if
no meta tags were found with the given name.
"""
return self.metaTags.get(name)
def getTitle(self):
"""
Return a user-friendly title for the page
"""
if self.title: return self.title
else: return self.templateName
def addLoadListener(self, listener):
"""
The listener should be a function or an object implementing onTemplateLoaded.
It will be called this TemplatePanel instance after the template has been
loaded and after attachWidgets() is called.
"""
self.loadListeners.append(listener)
def removeLoadListener(self, listener):
self.loadListeners.remove(listener)
def notifyLoadListeners(self):
for listener in self.loadListeners:
if listener.onTemplateLoaded: listener.onTemplateLoaded(self)
else: listener(self)
def onEditContentClick(self, sender):
if self.editor:
editor = self.editor
self.editor = None
ComplexPanel.remove(self, editor)
self.editButton.setText("edit "+unescape(self.templateName))
else:
self.editor = RichTextEditor(self.originalText)
self.editor.addSaveListener(self)
ComplexPanel.insert(self, self.editor, self.getElement(), len(self.children))
self.editButton.setText("close editor")
def getTemplateSaveUrl(self, templateName):
"""
Get the URL to post a template to when it is saved in the editor.
"""
return self.getTemplatePath(templateName)
def saveTemplateText(self, html):
"""
Save the text. This method can be overridden to use a different
save method. The default is to POST to the template save URL, passing
a single parameter "content" with the html string.
To change the target of the POST, override getTemplateSaveUrl().
To preprocess the html, override this method in a subclass and perform
processing there.
"""
HTTPRequest().asyncPost(self.getTemplateSaveUrl(self.templateName),
"content="+encodeURIComponent(html),
ContentSaveHandler(self))
def onSave(self, sender):
"""
Called when the user clicks save in the content editor.
"""
html = self.editor.getHTML()
self.saveTemplateText(html)
def onSaveComplete(self):
"""
Called when the template was successfully POSTed to the server; it reloads the template.
Subclasses which don't use the default method of saving may want to call this after
they successfully save the template.
"""
self.loadTemplate(self.templateName)
def handleClient(self,fileDesc):
while True:
try:
currentClient = self.clients.get(fileDesc, None)
data = None
if currentClient:
data = currentClient.recv(self.size)
if data:
self.clientFiles[fileDesc].cache += data
if self.validRequestInCache(fileDesc):
break;
else:
if self.debug:
print "[handleClient] Closing Client #" + str(fileDesc)
self.poller.unregister(fileDesc)
self.closeClient(fileDesc)
return
except errno.EAGAIN:
if self.debug:
print "[RECV ERROR] Try again"
return
except errno.EWOULDBLOCK:
if self.debug:
print "[RECV ERROR] Operation would block"
return
if self.debug: print "[DATA]\n" + data + "\n"
requestData = self.removeRequestFromCache(fileDesc)
if self.debug: print "[REQUEST DATA]\n" + requestData + "\n"
request = HTTPRequest(requestData)
reqCom = request.command
if not (reqCom == 'GET' or reqCom == 'DELETE' or reqCom == 'PUT' or reqCom == 'TRACE' \
or reqCom == 'HEAD' or reqCom == 'OPTIONS' or reqCom == 'CONNECT'):
response = self.create400Response()
if self.debug:
print "*************** Sending Response ***************\n" + response + "************************************************"
self.sendResponse(fileDesc, response)
return
elif reqCom != 'GET' and reqCom != 'HEAD':
response = self.create501Response()
if self.debug:
print "*************** Sending Response ***************\n" + response + "************************************************"
self.sendResponse(fileDesc, response)
return
elif reqCom == 'GET' or reqCom == 'HEAD':
if request.headers['host'].find(":"):
host = request.headers['host'][:request.headers['host'].find(":")]
host = request.headers['host']
hostPath = self.hosts.get(host, None)
if not hostPath:
hostPath = self.hosts['default']
if not request.path:
request.path = "/index.html"
if request.path == "/":
request.path = "/index.html"
filePath = hostPath + request.path
if not os.path.isfile(filePath):
response = self.create404Response()
if self.debug:
print "*************** Sending Response ***************\n" + response + "************************************************"
self.sendResponse(fileDesc, response)
return
if not os.access(filePath, os.R_OK):
response = self.create403Response()
if self.debug:
print "*************** Sending Response ***************\n" + response + "\n************************************************"
self.sendResponse(fileDesc, response)
return
reqFile = open(filePath);
response = self.create200Response(reqFile)
if self.debug:
print "*************** Sending Response ***************\n" + response + "File Contents go here\n ************************************************"
self.sendResponse(fileDesc, response)
if reqCom == 'HEAD':
return
if request.headers.get('range', None):
rangeArray = request.headers['range'].split('=')[1].split('-')
reqFile.seek(int(rangeArray[0]))
filePiece = reqFile.read(int(rangeArray[1]) - int(rangeArray[0]))
self.sendResponse(fileDesc, filePiece)
return
while True:
filePiece = reqFile.read(self.size)
if filePiece == "":
break
self.sendResponse(fileDesc, filePiece)
def loadTemplate(self, templateName):
self.templateName = templateName
self.id = templateName + str(hash(self))
self.httpReq = HTTPRequest()
self.httpReq.asyncGet(self.getTemplatePath(templateName), TemplateLoader(self))
