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 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)
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))