def do_PUT(self):
if (self.path == "/src/tasks.json"):
form = cgi.FieldStorage(
fp=self.rfile,
headers=self.headers,
environ={'REQUEST_METHOD':'PUT', 'CONTENT_TYPE':self.headers['Content-Type']}
)
tasks = []
i = 0;
while (form.getfirst("tasklist[" + str(i) + "][id]") is not None):
isComplete = False
isDeleted = False
complete_str = form.getfirst("tasklist[" + str(i) + "][isComplete]")
if (complete_str == 'true'):
isComplete = True
delete_str = form.getfirst("tasklist[" + str(i) + "][isDeleted]")
if (delete_str == 'true'):
isDeleted = True
tasks.append({
u"id": int(form.getfirst("tasklist[" + str(i) + "][id]")),
u"isComplete": isComplete,
u"isDeleted": isDeleted,
u"text": form.getfirst("tasklist[" + str(i) + "][text]"),
u"dateDue": form.getfirst("tasklist[" + str(i) + "][dateDue]")
})
i += 1
with open('./src/tasks.json', 'w') as outfile:
json.dump(tasks, outfile)
sendJSON(self)
else:
SimpleHTTPRequestHandler.do_PUT(self)
def __init__(self, request, client_address, server):
try:
SimpleHTTPRequestHandler.__init__(self, request, client_address,
server)
except Exception as e:
DEBUG("Request from client %s has failed." % (client_address[0]))
DEBUG(str(e))
def __init__(self, *args, **kwargs):
"""
:arg root: The path to the folder to serve
"""
self.root = kwargs.pop('root') # required kwarg
SimpleHTTPRequestHandler.__init__(self, *args, **kwargs)
def do_HEAD(self):
if is_static_path(self.path):
# noinspection PyAttributeOutsideInit
self.path = self._translate_overlay_path(self.path)
SimpleHTTPRequestHandler.do_HEAD(self)
else:
self.send_error(405)
def do_HEAD(self):
if is_proxied(self.path):
self.do_proxied()
elif self.path == "/config.js":
self.do_config_js()
else:
SimpleHTTPRequestHandler.do_HEAD(self)
def do_GET(self):
try:
print("-> GET" + str(self.__dict__))
SimpleHTTPRequestHandler.do_GET(self)
except:
print("Unexpected error:" + str(sys.exc_info()[0]))
raise
def send_head(self):
content_type = 'text/html; charset=utf-8'
param = ''
req_path = self.path
if req_path.find('?') > 0:
req_path, param = req_path.split('?')
if req_path in ('/'):
self.path = '/www/index.html'
return SimpleHTTPRequestHandler.send_head(self)
elif req_path in ('/curr'):
iplist = [[ip.duration, ip.ip, ip.country, ip.timeString] for ip in gIpScanner.currBuff]
html = json.dumps({'name': 'curr', 'data': iplist, 'columns': ['duration', 'ip', 'country', 'time']})
elif req_path in ('/average'):
history = [[ip.duration, ip.ip, ip.country, ip.timeString] for ip in gIpScanner.avgBuff]
html = json.dumps({'name': 'history', 'data': history, 'columns': ['average', 'ip', 'country', 'time']})
elif req_path in ('/ip_history'):
param = param.strip()
data = [
[ip.duration, ip.ip, ip.country, ip.timeString]
for ip in gIpScanner.historyBuff
if not param or ip.ip == param
]
html = json.dumps({'name': 'ip_history', 'data': data, 'columns': ['t', 'ip', 'country', 'time']})
elif req_path in ('/ss'):
html = json.dumps({'status': gIpScanner.status})
else:
return SimpleHTTPRequestHandler.send_head(self)
f = StringIO.StringIO(html)
self.send_response(200)
self.send_header("Content-type", content_type)
self.send_header("Content-Length", str(f.len))
self.send_header("Last-Modified", self.date_time_string())
self.end_headers()
return f
def do_GET(self):
if not self.server.keys:
if __name__ == '__main__':
Handler.do_GET(self)
return True
auth_header = self.headers.get('Authorization')
if auth_header is None:
self.send_auth_request()
self.wfile.write('<h1>Authorization Required</h1>'.encode())
print('no auth header received')
return False
elif auth_header[len('Basic '):] in self.server.keys:
if __name__ == '__main__':
Handler.do_GET(self)
return True
else:
self.send_auth_request()
self.wfile.write('<h1>Authorization Required</h1>'.encode())
auth = re.sub('^Basic ', '', auth_header)
print('Authentication failed! %s' %
base64.b64decode(auth).decode())
return False
def do_GET(self):
""" Overrides SimpleHTTPRequestHandler.do_GET() to handle
PyBBIO function calls. """
url = self.raw_requestline.split(' ')[1]
if ('?' in url):
# We've received a request for a PyBBIO function call,
# parse out parameters:
url = url.split('?')[1]
params = urlparse.parse_qs(url)
function_id = params['function_id'][0]
# This should be a key in the FUNCTION_STRINGS dictionary:
if (function_id in FUNCTION_STRINGS):
function = FUNCTION_STRINGS[function_id]
if ("entry_text" in params):
# This is a request from a text entry, so we also need to
# parse out the text to be passed to the function:
text = params['entry_text'][0]
if (text == " "):
# An empty text box is converted into a space character
# by the Javascript, because otherwise the parsed url
# would not have an entry_text param and we'd get errors
# trying to call the function; convert it back:
text = ""
# If we inserted the text into the function string and
# evaluated it at this point, the text received would be
# evaluated by Python, which we really don't want. If we
# put it in an extra set of quotes it will evaluate to a
# string correctly:
text = "'%s'" % text
function = function % (text)
# Evaluate the function string and capture the return value
# in a string (which will be an empty string if function has
# no return value):
response = str(eval(function))
else:
# The function id is not in the dictionary. This happens if
# the server has restarted, which generates new function ids,
# and the page has not been refreshed.
response = "*Refresh page*"
# Send the HTTP headers:
self.send_response(200)
self.send_header('Content-Type', 'text/html')
# Our length is simply the length of our function return value:
self.send_header("Content-length", len(response))
self.send_header('Server', 'PyBBIO Server')
self.end_headers()
# And finally we write the response:
self.wfile.write(response)
return
# If we get here there's no function id in the request, which
# means it's a normal page request; let SimpleHTTPRequestHandler
# handle it the standard way:
SimpleHTTPRequestHandler.do_GET(self)
def setup(self):
'''Sets a timeout on the socket
Abandon request handling when client has not responded
for socket_timeout time.
'''
self.request.settimeout(self.socket_timeout)
SimpleHTTPRequestHandler.setup(self)
def do_GET(self):
try:
global TICKET
global MASTER_ADRESS
if self.path == "/write":
answer = "KO" if TICKET < datetime.now() else "OK"
self.send_response(200)
self.send_header("Content-type", "text/html")
self.end_headers()
self.wfile.write(answer)
# '<br />TICKET : ' + TICKET.strftime("%d/%m/%y %H:%M") +
# '<br />now : ' + datetime.now().strftime("%d/%m/%y %H:%M"))
#print 'GET : ' + TICKET.strftime("%d/%m/%y %H:%M")
elif self.path == "/set-new-ticket":
referer_url = self.headers.getheader('referer')
print referer_url
print MASTER_ADRESS
if referer_url == MASTER_ADRESS:
TICKET = datetime.now() + TICKET_LIVE_TIME
self.send_response(200)
self.send_header("Content-type", "text/html")
self.end_headers()
else:
self.send_error(404,"File Not Found: %s" % self.path)
else:
SimpleHTTPRequestHandler.do_GET(self)
except IOError:
self.send_error(404,"File Not Found: %s" % self.path)
def send_head(self):
body = None
if self.path=='/':
body = self.parse_index()
else:
try:
spell_end = self.path.index('/', 1)
except:
return SimpleHTTPRequestHandler.send_head(self)
if spell_end>1:
spell_name = unquote_plus(self.path[1:spell_end])
for spell in self.json_data:
if spell['title']==spell_name:
body = self.parse_spell(spell)
elif spell['title'].lower()==spell_name:
body = self.parse_spell(spell)
if body is None:
self.send_error(404, "Spell '%s' not found." % spell_name)
return None
# Send body or default handler
if body:
self.send_response(200)
self.send_header("Content-type", "text/html")
self.send_header("Content-Length", str(len(body)))
self.end_headers()
return StringIO(body)
else:
return SimpleHTTPRequestHandler.send_head(self)
def handle(self):
global active
debug("$$$$$$$$$$$$$$$$$$$$$$$$$\n")
active += 1
SimpleHTTPRequestHandler.handle(self)
active -= 1
debug("$$$$$$$$$$$$$$$$$$$$$$$$$ ACTIVE: %0d\n" % active)
def __init__(self, *args, **kwargs):
self.server_version = "IvrSimulator/"
self.sys_version = ""
statistical.inc_tas_requests()
SimpleHTTPRequestHandler.__init__(self, *args, **kwargs)
def do_GET(self):
if len(self.path.split('?',1))>1:
arg=self.path.split('?',1)[1]
args=arg.split('&')
cmd=args[0].split('=',1)
print "arg=%s args=%s cmd=%s" % (arg, args, cmd)
if args[0]=='lastsnap':
self.serve_file('/tmp/motion/lastsnap.jpg');
elif cmd[0]=='cmd':
ret=("executing "+cmd[1])
fnc=({ #http://stackoverflow.com/a/60211/781312
'serverStop': self.serverStop
,'serverStart': self.serverStart
,'cleanHistory': self.cleanHistory
}[cmd[1]])
ret+=fnc()
self.serve_content(ret)
else:
data=arg
self.send_response(200)
self.send_header("Content-Length", len(data))
self.send_header("Last-Modified", self.date_time_string())
self.end_headers()
self.wfile.write(data);
# except Exception, e:
else:
print self.path
SimpleHTTPRequestHandler.do_GET(self)
def do_GET(self, method="GET"):
self.wfile = FileWrapper(self.wfile)
SimpleHTTPRequestHandler.do_GET(self)
print ""
print self._heading("HTTP Response")
print self.wfile
def do_GET(s):
job = re.compile('^/jobs/[0-9]+$')
joblist = re.compile('^/jobs/?$')
if (s.path == '/stats/heap' and 'guppy' in sys.modules):
s.send_response(200)
s.send_header('Content-Type:', 'text/plain')
s.end_headers()
s.wfile.write(hpy().heap())
elif job.match(s.path):
s.send_response(200)
s.send_header('Content-Type:', 'application/json')
s.end_headers()
id = int(s.path.split('/')[2])
result = dict()
result['command'] = s.server.hbq.commands[id].args
result['status'] = s.server.hbq.commands[id].status
result['stdout'] = s.server.hbq.commands[id].stdout
s.wfile.write(json.dumps(result))
elif joblist.match(s.path):
s.send_response(200)
s.send_header('Content-Type:', 'application/json')
s.end_headers()
result = dict()
for i, cmd in enumerate([[x.args, x.status]
for x in s.server.hbq.commands]):
result[i] = dict(command=" ".join(cmd[0]), status=cmd[1])
s.wfile.write(json.dumps(result))
else:
SimpleHTTPRequestHandler.do_GET(s)
def handle(self):
#needed when wfile is used, or when self.close_connection is not used
#
#catch errors in SimpleHTTPRequestHandler.handle() after socket disappeared
#due to loss of network connection
self.log_message("handle entry on worker thread %d" %
threading.current_thread().ident)
try:
SimpleHTTPRequestHandler.handle(self)
except (socket.error, ) as err:
self.log_message(
"handle(): Exception: in SimpleHTTPRequestHandler.handle(): %s"
% str(err.args))
print(
"handle(): Exception: in SimpleHTTPRequestHandler.handle(): %s"
% str(err.args))
except (TypeError, ) as err:
self.log_message(
"handle(): Exception: in SimpleHTTPRequestHandler.handle(): %s"
% str(err))
print(
"handle(): Exception: in SimpleHTTPRequestHandler.handle(): %s"
% str(err))
self.log_message("handle done on worker thread %d" %
threading.current_thread().ident)
def __init__(self, wikidb, conf, links_cache, request, client_address,
server):
# pullcord is currently offline
# self.reporturl = 'pullcord.laptop.org:8000'
self.reporturl = False
self.ip = conf['ip']
self.port = conf['port']
self.lang = conf['lang']
self.templateprefix = conf['templateprefix']
self.templateblacklist = set(conf['templateblacklist'])
self.wpheader = conf['wpheader']
self.wpfooter = conf['wpfooter']
self.resultstitle = conf['resultstitle']
self.base_path = os.path.dirname(conf['path'])
self.links_cache = links_cache
self._xo_color = conf['xocolor']
if 'editdir' in conf:
self.editdir = conf['editdir']
else:
self.editdir = False
if 'giturl' in conf:
self.giturl = conf['giturl']
else:
self.giturl = False
self.wikidb = wikidb
self.client_address = client_address
SimpleHTTPRequestHandler.__init__(
self, request, client_address, server)
def do_GET(self):
print 'PATH: ', self.path[:5]
if self.path[:5] == '/data':
print 'path:', self.path
self.path = DATA_DIR + self.path[5:]
print 'new path:', self.path
Handler.do_GET(self)
def __init__(self, wikidb, index, conf, request, client_address, server):
# pullcord is currently offline
# self.reporturl = 'pullcord.laptop.org:8000'
self.reporturl = False
self.index = index
self.port = conf['port']
self.lang = conf['lang']
self.templateprefix = conf['templateprefix']
self.templateblacklist = set(conf['templateblacklist'])
self.wpheader = conf['wpheader']
self.wpfooter = conf['wpfooter']
self.resultstitle = conf['resultstitle']
if 'editdir' in conf:
self.editdir = conf['editdir']
else:
self.editdir = False
if 'giturl' in conf:
self.giturl = conf['giturl']
else:
self.giturl = False
# init search index
self.base_path = os.path.dirname(conf['path'])
self.ix = open_dir(os.path.join(self.base_path, "index_dir"))
self.wikidb = wikidb
self.client_address = client_address
SimpleHTTPRequestHandler.__init__(self, request, client_address,
server)
def __init__(self, *args, **kwargs):
self.config = config
self._logger = logging.getLogger(__name__)
self.api = FSRest()
self.close_mjpeg_stream = False
self.ROUTES = (
# [url_prefix , directory_path]
['/upload/preview/', ''],
['/settings.mjpeg', ''],
['/adjustment.mjpeg', ''],
['/scans', self.config.folders.scans],
['/scan', self.config.folders.scans],
['', self.config.folders.www
], # empty string for the 'default' match
)
try:
SimpleHTTPRequestHandler.__init__(self, *args, **kwargs)
except StandardError, e:
self.close_mjpeg_stream = True
#self.scanprocessor.stop()
self._logger.debug("MJPEG Stream closed by client.")
def end_headers(self):
query_components = parse_qs(urlparse(self.path).query)
if 't' in query_components.keys():
v = query_components['t'][0]
print v
self.send_header('Content-Type',v)
SimpleHTTPRequestHandler.end_headers(self)
def __init__(self, request, client_address, server):
self.builder = server.builder
if PY2:
SimpleHTTPRequestHandler.__init__(self, request, client_address,
server)
else:
super().__init__(request, client_address, server)
def do_HEAD(self):
if is_proxied(self.path):
self.do_proxied()
elif self.path == "/config.js":
self.do_config_js()
else:
SimpleHTTPRequestHandler.do_HEAD(self)
def __init__(self, wikidb, conf, links_cache, request, client_address,
server):
# pullcord is currently offline
# self.reporturl = 'pullcord.laptop.org:8000'
self.reporturl = False
self.ip = conf['ip']
self.port = conf['port']
self.lang = conf['lang']
self.templateprefix = conf['templateprefix']
self.templateblacklist = set(conf['templateblacklist'])
self.wpheader = conf['wpheader']
self.wpfooter = conf['wpfooter']
self.resultstitle = conf['resultstitle']
self.base_path = os.path.dirname(conf['path'])
self.links_cache = links_cache
self._xo_color = conf['xocolor']
if 'editdir' in conf:
self.editdir = conf['editdir']
else:
self.editdir = False
if 'giturl' in conf:
self.giturl = conf['giturl']
else:
self.giturl = False
self.wikidb = wikidb
self.client_address = client_address
SimpleHTTPRequestHandler.__init__(self, request, client_address,
server)
def do_POST(self):
# pylint: disable=E1101
if self.path == '/RPC2':
SimpleJSONRPCRequestHandler.do_POST(self)
else:
__pychecker__ = 'no-classattr'
SimpleHTTPRequestHandler.do_POST(self)
def __init__(self, wikidb, conf, links_cache, request, client_address, server):
# pullcord is currently offline
# self.reporturl = 'pullcord.laptop.org:8000'
self.reporturl = False
self.port = conf["port"]
self.lang = conf["lang"]
self.templateprefix = conf["templateprefix"]
self.templateblacklist = set(conf["templateblacklist"])
self.wpheader = conf["wpheader"]
self.wpfooter = conf["wpfooter"]
self.resultstitle = conf["resultstitle"]
self.base_path = os.path.dirname(conf["path"])
self.links_cache = links_cache
if "editdir" in conf:
self.editdir = conf["editdir"]
else:
self.editdir = False
if "giturl" in conf:
self.giturl = conf["giturl"]
else:
self.giturl = False
self.wikidb = wikidb
self.client_address = client_address
SimpleHTTPRequestHandler.__init__(self, request, client_address, server)
def __init__(self, handlers, browser, *args, **kwargs):
'''Initialises handler for use with BaseHTTPRequestHandler
handlers - mapping of paths to handler objects;
browser - browser for downloading .torrent files from topic urls.
There should be '*' handler in handlers dict.
There should be page_template.auth_path in handlers dict for authetification.
On request server checks if user if authorized (via cookie).
If not - it draws authorisation page from page_template.authorize, or
processes authorisation via page_template.auth_handler path.
If the user is authorized server checks path and calls
corresponding handler's process method. If no such path->handler
mapping - then it calls '*' handler.
Cause this class needs to initialise parent's class, please wrap it
with functools like:
functools.partial(tserv.TorrentServHandler, handlers, browser)
'''
self.handlers = handlers
self.browser = browser
self.body = None
BaseRequestHandler.__init__(self, *args, **kwargs)
def do_GET(s):
job = re.compile('^/jobs/[0-9]+$')
joblist = re.compile('^/jobs/?$')
if (s.path == '/stats/heap' and 'guppy' in sys.modules):
s.send_response(200)
s.send_header('Content-Type:', 'text/plain')
s.end_headers()
s.wfile.write(hpy().heap())
elif job.match(s.path):
s.send_response(200)
s.send_header('Content-Type:', 'application/json')
s.end_headers()
id = int(s.path.split('/')[2])
result = dict()
result['command'] = s.server.hbq.commands[id].args
result['status'] = s.server.hbq.commands[id].status
result['stdout'] = s.server.hbq.commands[id].stdout
s.wfile.write(json.dumps(result))
elif joblist.match(s.path):
s.send_response(200)
s.send_header('Content-Type:', 'application/json')
s.end_headers()
result = dict()
for i, cmd in enumerate([[x.args, x.status]
for x in s.server.hbq.commands]):
result[i] = dict(command=" ".join(cmd[0]), status=cmd[1])
s.wfile.write(json.dumps(result))
else:
SimpleHTTPRequestHandler.do_GET(s)
def setup(self):
'''Sets a timeout on the socket
Abandon request handling when client has not responded
for socket_timeout time.
'''
self.request.settimeout(self.socket_timeout)
SimpleHTTPRequestHandler.setup(self)
def do_GET(self):
if self.headers.get("Upgrade", None) == "websocket":
WebSocketHandler(self, lambda msg: self.__handle_websocket_message(msg)).run()
#This handler is in websocket mode now.
#do_GET only returns after client close or socket error.
else:
SimpleHTTPRequestHandler.do_GET(self)
def __init__(self, handlers, browser, *args, **kwargs):
'''Initialises handler for use with BaseHTTPRequestHandler
handlers - mapping of paths to handler objects;
browser - browser for downloading .torrent files from topic urls.
There should be '*' handler in handlers dict.
There should be page_template.auth_path in handlers dict for authetification.
On request server checks if user if authorized (via cookie).
If not - it draws authorisation page from page_template.authorize, or
processes authorisation via page_template.auth_handler path.
If the user is authorized server checks path and calls
corresponding handler's process method. If no such path->handler
mapping - then it calls '*' handler.
Cause this class needs to initialise parent's class, please wrap it
with functools like:
functools.partial(tserv.TorrentServHandler, handlers, browser)
'''
self.handlers = handlers
self.browser = browser
self.body = None
BaseRequestHandler.__init__(
self, *args, **kwargs
)
def do_GET(self):
if root_redir and self.path == '/':
self.send_response(301)
self.send_header("Location", root_redir)
self.end_headers()
return
SimpleHTTPRequestHandler.do_GET(self)
def handle_one_request(self):
# try:
if self.handshake_done:
self.read_next_message()
# a read or a write timed out. Discard this connection
else:
SimpleHTTPRequestHandler.handle_one_request(self)
def do_GET(self):
if os.path.splitext(self.path)[1] == '.html':
self.send_response(200)
self.send_header("Content-type", 'text/html')
self.send_header("Last-Modified", self.date_time_string())
self.end_headers()
self.wfile.write(
'<!DOCTYPE html><html><head><meta charset="utf-8"><script src="../ckeditor/ckeditor.js"></script></head><body><textarea cols="1" id="editor1" name="editor1" rows="1"></textarea><script>CKEDITOR.replace("editor1",{on: {}});</script></body></html>'
)
elif os.path.splitext(self.path)[1] == '.jpg':
try:
bI = _gdI[self.path[1:]]
except:
with io.BytesIO() as bIO:
ip = photos.pick_image(show_albums=True)
ip.save(bIO, ip.format)
bI = bIO.getvalue()
_gdI[self.path[1:]] = bI
self.send_response(200)
self.send_header("Content-type", 'image/jpeg')
self.send_header("Content-Length", str(len(bI)))
self.send_header("Last-Modified", self.date_time_string())
self.end_headers()
self.wfile.write(bI)
else:
SimpleHTTPRequestHandler.do_GET(self)
def do_GET(self):
if not self._isAuthorized():
self.send_response(401, 'Unauthorized')
self.send_header('WWW-Authenticate', 'Basic realm="Test"')
self.end_headers()
return
SimpleHTTPRequestHandler.do_GET(self)
def do_GET(self, method="GET"):
self.wfile = FileWrapper(self.wfile)
SimpleHTTPRequestHandler.do_GET(self)
print ""
print self._heading("HTTP Response")
print self.wfile
def do_GET(self): if(VALID_FILE_REGEX.search(self.path) != None or self.path == "/"): self.path = FILE_PATH+self.path SimpleHTTPRequestHandler.do_GET(self) else: self.send_response(404) self.end_headers()
def __init__(self, *args, **kwargs):
"""
:arg root: The path to the folder to serve
"""
self.root = kwargs.pop('root') # required kwarg
SimpleHTTPRequestHandler.__init__(self, *args, **kwargs)
def do_GET(self):
if self.path.startswith('/assets'):
with FileLock(common.LOCK_FILE):
SimpleHTTPRequestHandler.do_GET(self)
elif self.path.startswith('/addrag'):
self.sendOk()
elif self.path == '/statsrotate':
statsrotate()
self.sendOk()
elif self.path.startswith('/log'):
qs = self.path[self.path.index('?')+1:]
parsed = parse_qs(qs)
parsed['ts'] = str(int(time.time()))
# Remove cachebuster
if '_' in parsed:
del parsed['_']
try:
fields_to_write = [
BOARD_ID,
parsed['ts'],
parsed['id'][0],
parsed['event'][0],
parsed['state'][0]
]
except Exception, e:
print "Oops", e
self.sendResponse("Stuff missing", 400)
return
line = ','.join(fields_to_write)
with stats_lock:
main_stats.write(line)
main_stats.write("\n")
main_stats.flush()
self.sendOk()
def do_GET(self):
if not self._isAuthorized():
self.send_response(401, 'Unauthorized')
self.send_header('WWW-Authenticate', 'Basic realm="Test"')
self.end_headers()
return
SimpleHTTPRequestHandler.do_GET(self)
def do_GET(self):
''' Present frontpage with user authentication. '''
if self.headers.getheader('Authorization') is None:
self.do_authhead()
self.wfile.write('no auth header received')
elif self.headers.getheader('Authorization') == 'Basic ' + self.KEY:
SimpleHTTPRequestHandler.do_GET(self)
else:
self.do_authhead()
self.wfile.write(self.headers.getheader('Authorization'))
self.wfile.write('not authenticated')
if self.path == '/':
self.path = "index.html"
return SimpleHTTPRequestHandler.do_GET(self)
if self.path == "/tank-service":
os.system("sudo systemctl restart tankmanager.service")
logging.info("Tank manager service is reload")
self._set_response()
if self.path == "/reboot":
os.system("sudo reboot")
logging.info("System reboot")
self._set_response()
def send_head(self):
body = None
if self.path == '/':
body = self.parse_index()
else:
try:
spell_end = self.path.index('/', 1)
except:
return SimpleHTTPRequestHandler.send_head(self)
if spell_end > 1:
spell_name = unquote_plus(self.path[1:spell_end])
for spell in self.json_data:
if spell['title'] == spell_name:
body = self.parse_spell(spell)
elif spell['title'].lower() == spell_name:
body = self.parse_spell(spell)
if body is None:
self.send_error(404, "Spell '%s' not found." % spell_name)
return None
# Send body or default handler
if body:
self.send_response(200)
self.send_header("Content-type", "text/html")
self.send_header("Content-Length", str(len(body)))
self.end_headers()
return StringIO(body)
else:
return SimpleHTTPRequestHandler.send_head(self)
def do_GET(self):
"""Serve a GET request."""
#print ' '
#print '==================================================='
#print 'HTTP Request GET >>> %s' % self.path
PrintD(self, 'do_GET', {'Request': self.path})
PrintD(self, 'do_GET', {'IP address': '(%s %s)' % self.client_address})
reqeust = None
try:
reqeust = self.__ParseServiceRequest(self.path)
except:
PrintD(self, 'do_GET', {'Failed to parse request': None}, 1)
if (reqeust != None):
result = False
data = None
try:
result, data = self.OnReqService(reqeust)
if (result == True and data != None):
self.__CreateResponse(data)
else:
SimpleHTTPRequestHandler.do_GET(self)
#self.send_error(405, "Method Not Allowed")
except Exception as e:
PrintD(self, 'do_GET', {'OnReqService Problem': e}, 2)
else:
f = self.send_head()
if f:
self.copyfile(f, self.wfile)
f.close()
def __init__(self, req, client_addr, server):
try:
SimpleHTTPRequestHandler.__init__(self, req, client_addr, server)
self.server = server
self.req = req
except socket.error:
pass
def do_HEAD(self):
parsed_path = urlparse.urlparse(self.path)
if parsed_path.path.startswith("/echo"):
message = '\n'.join([
'CLIENT VALUES:',
'client_address=%s (%s)' % (self.client_address,
self.address_string()),
'command=%s' % self.command,
'path=%s' % self.path,
'real path=%s' % parsed_path.path,
'query=%s' % parsed_path.query,
'request_version=%s' % self.request_version,
'',
'HEADERS:',
'%s' % self.headers,
])
self.send_response(200)
self.end_headers()
self.wfile.write(message)
elif parsed_path.path.startswith("/redirect"):
self.send_response(301)
self.send_header('Location', "/echo")
self.end_headers()
else:
SimpleHTTPRequestHandler.do_HEAD(self)
return
def do_GET(self):
"""Serve a GET request."""
#print ' '
#print '==================================================='
#print 'HTTP Request GET >>> %s' % self.path
PrintD(self, 'do_GET', {'Request':self.path})
PrintD(self, 'do_GET', {'IP address':'(%s %s)' % self.client_address})
reqeust = None
try:
reqeust = self.__ParseServiceRequest(self.path)
except:
PrintD(self, 'do_GET', {'Failed to parse request':None}, 1)
if (reqeust != None):
result = False
data = None
try:
result, data = self.OnReqService(reqeust)
if (result == True and data != None):
self.__CreateResponse(data)
else:
SimpleHTTPRequestHandler.do_GET(self)
#self.send_error(405, "Method Not Allowed")
except Exception as e:
PrintD(self, 'do_GET', {'OnReqService Problem':e}, 2)
else:
f = self.send_head()
if f:
self.copyfile(f, self.wfile)
f.close()
def do_GET(self):
if '.ico' in self.path or '.png' in self.path:
SimpleHTTPRequestHandler.do_GET(self)
else:
self._writeheaders()
with open("BASEHTML.html",'r') as f:
self.wfile.write(f.read().decode('utf-8').replace('twitterid',TwitterID).encode('utf-8'))
def do_GET(self):
# file request?
try:
# which pieces were requested?
if True or os.path.dirname( self.path.strip() ) in self.server.available_files:
if self.path.endswith("done"):
# receiver is done with this file
#del self.server.available_files[ os.path.dirname( self.path.strip() ) ]
self.send_response( 200 )
else:
# file has been made available
SimpleHTTPRequestHandler.do_GET(self)
return
else:
self.send_response(404) # nothing to send
return
except Exception, inst:
iftlog.exception( "Could not fully transmit " + self.path, inst)
self.send_response(404)
return
def do_HEAD(self):
if is_static_path(self.path):
# noinspection PyAttributeOutsideInit
self.path = self._translate_overlay_path(self.path)
SimpleHTTPRequestHandler.do_HEAD(self)
else:
self.send_error(405)
def do_HEAD(self):
parsed_path = urlparse.urlparse(self.path)
if parsed_path.path.startswith("/echo"):
message = '\n'.join([
'CLIENT VALUES:',
'client_address=%s (%s)' %
(self.client_address, self.address_string()),
'command=%s' % self.command,
'path=%s' % self.path,
'real path=%s' % parsed_path.path,
'query=%s' % parsed_path.query,
'request_version=%s' % self.request_version,
'',
'HEADERS:',
'%s' % self.headers,
])
self.send_response(200)
self.end_headers()
self.wfile.write(message)
elif parsed_path.path.startswith("/redirect"):
self.send_response(301)
self.send_header('Location', "/echo")
self.end_headers()
else:
SimpleHTTPRequestHandler.do_HEAD(self)
return
def do_GET(self):
"""Serve a GET request."""
if not self.allow_path():
self.send_error(403)
elif self.is_brat():
self.run_brat_direct()
else:
SimpleHTTPRequestHandler.do_GET(self)
def log_request(self, code='-', size='-'):
# Don't log HEAD requests because these are very spammy with livejs turned on
if self.command == 'HEAD':
return
if platform.python_version_tuple()[0] == '2':
SimpleHTTPRequestHandler.log_request(self, code, size)
else:
super().log_request(code, size)
def do_GET(self):
if self.headers.get("Upgrade", None) == "websocket":
WebSocketHandler(
self, lambda msg: self.__handle_websocket_message(msg)).run()
#This handler is in websocket mode now.
#do_GET only returns after client close or socket error.
else:
SimpleHTTPRequestHandler.do_GET(self)
def do_GET(self):
"""Serve a GET request."""
if not self.allow_path():
self.send_error(403)
elif self.is_brat():
self.run_brat_direct()
else:
SimpleHTTPRequestHandler.do_GET(self)
def __init__(self, req, client_addr, server):
# self._request = req
# self._address = client_addr
self._logger = PytoLogging(self.__class__.__name__)
self._api = PytomationAPI()
self._server = server
SimpleHTTPRequestHandler.__init__(self, req, client_addr, server)
def log_request(self, code='-', size='-'):
# Don't log HEAD requests because these are very spammy with livejs turned on
if self.command == 'HEAD':
return
if platform.python_version_tuple()[0] == '2':
SimpleHTTPRequestHandler.log_request(self, code, size)
else:
super().log_request(code, size)
def do_GET(self):
""" Handle http requests to serve html/image files only """
print(self.path, self.translate_path(self.path))
permitted_extensions = ['.html','.png','.svg','.jpg', '.js']
if not os.path.splitext(self.path)[1] in permitted_extensions:
self.send_error(404, 'File Not Found/Allowed')
else:
SimpleHTTPRequestHandler.do_GET(self)