def remote_webapp (environ, start_response):
routes = {
'buttons': view_buttons,
'inputs': view_inputs,
'press': lambda: press(shift_path_info (environ)),
'status': projector_status,
'input': lambda: set_input(shift_path_info (environ)),
'on': on,
'off': off,
'': index
}
result = None
base_path = shift_path_info (environ)
if base_path not in routes:
status = '404 Not Found'
headers = [('Content-type', 'text/html')]
result = str(WebException (status))
else:
try:
handler = routes[base_path]
result = handler()
status = '200 OK' # HTTP Status
if type(result) != str and type(result) != unicode:
headers = [('Content-type', 'text/html')]
else:
headers = [('Content-type', 'application/json')]
except WebException, ex:
status = ex.code
headers = [('Content-type', 'text/html')]
result = str(ex)
except:
def __call__(self, environ, start_response):
if self.prefix and not environ['PATH_INFO'].startswith(self.prefix):
return self._error(start_response, 400, "bad request")
shift_path_info(environ)
qs = parse_qs(environ.get('QUERY_STRING'), strict_parsing=True)
if 'auth_token' not in qs:
if self.need_auth(environ):
return self._error(start_response, 401, "unauthorized",
"Missing Authentication Token.")
else:
token = qs['auth_token'][0]
try:
self.verify_token(environ, token)
except Unauthorized:
return self._error(
start_response, 401, "unauthorized",
"Incorrect password or login.")
# remove auth token from query string.
del qs['auth_token']
qs_str = ''
if qs:
qs_str = reduce(lambda x, y: '&'.join([x, y]),
map(lambda (x, y): '='.join([x, str(y)]),
qs.iteritems()))
environ['QUERY_STRING'] = qs_str
return self.app(environ, start_response)
def dispatch(self, env, start_resp):
"Dispatch both on resources and sub applications"
reqmeth = env['REQUEST_METHOD']
script_name = env.get('SCRIPT_NAME', '')
path_info = env.get('PATH_INFO', '')
fullpath = script_name + path_info
for (path, meth), obj in self._registry.iteritems():
mo = re.match(path, path_info)
print 'checking %s with %s, %s' % (path_info, path, mo)
if mo:
if not isinstance(obj, self.Binding): # assume WSGI app
shift_path_info(env) # subdispatch
res = obj
else: # true resource
resource = obj.resource
if resource is None:
res = Response('Unbound Resource', '500 ERR')
elif meth not in ('ALL', reqmeth):
res = Response('Method Not Allowed', '405 ERR')
else: # call the resource
res = safecall(
self.call_hook, resource, self.Request(env),
mo.groups(), obj.content_type, path)
break
else: # no match, no break
res = Response('Unknown resource %r' % fullpath, '404 Not Found')
return res(env, start_resp)
def static(environ, start_response):
# shift PATH_INFO /static/foo ----> /foo
# then skip first '/'
# and merge with static_root
shift_path_info(environ)
filename = os.path.abspath(os.path.join(static_root,
environ['PATH_INFO'][1:]))
return sendfile(fname, start_response)
def __call__(self, environ, start_response):
"""Dispatch to the method named by the next bit of PATH_INFO."""
name = shift_path_info(dict(SCRIPT_NAME=environ["SCRIPT_NAME"], PATH_INFO=environ["PATH_INFO"]))
callable = getattr(self, name or "index", None)
if callable is not None and self._is_exposed(callable):
shift_path_info(environ)
return callable(environ, start_response)
else:
return self._not_found(environ, start_response)
def select_app(environ,start_response):
active_app=apps[None]
path=environ['PATH_INFO']
for app in apps:
if app is None: continue
if path=='/'+app or path.startswith('/'+app+'/'):
shift_path_info(environ)
active_app=apps[app]
break
return active_app(environ,start_response)
def __call__(self, environ, start_response):
"""do WSGI request dispatching"""
spi = int(self.config.get("shift_path_info", 0))
for i in range(0,spi):
shift_path_info(environ)
request = self.request_class(environ)
try:
response = self.process_request(request)
except Exception, e:
response = self.handle_exception(request, e)
def simple_dispatch(environ, start_response):
status = '200 OK' # HTTP Status
headers = [('Content-type', 'text/html')] # HTTP Headers
start_response(status, headers)
environ["parsed_params"] = urlparse.parse_qs(environ["QUERY_STRING"],keep_blank_values=True)
# a wsgi app is supposed to return an iterable;
# yielding lets you stream, rather than generate everything at once.
# yield repr(environ)
dbname = shift_path_info(environ)
myname = environ["SCRIPT_NAME"]
print >> environ['wsgi.errors'], dbname
if not dbname: return
else:
dbfile = "/var/lib/philologic/databases/" + dbname + "/toms.db"
toms = SqlToms(dbfile,7)
print >> environ['wsgi.errors'],"opened toms"
obj = []
count = 0
while True:
p = shift_path_info(environ)
if p:
obj.append(p)
else:
break
yield "looking up %s" % str(obj)
filename = ""
start = 0
end = 0
length = 0
for r in range(1,len(obj) + 1):
parent = obj[:r]
yield str(parent)
if parent in toms:
yield "retreiving %s" % repr(parent)
o = toms[parent]
filename = o["filename"] or filename
start = o["start"] or start
end = o["end"] or end
yield repr((filename,length,start,end))
file = "/var/lib/philologic/databases/%s/TEXT/%s" % (dbname,filename)
fh = open(file)
fh.seek(start)
chunk = fh.read(end - start)
if "word_offset" in environ["parsed_params"]:
word_offset = int(environ["parsed_params"]["word_offset"][0])
if word_offset >= start and word_offset <= end:
breakpoint = word_offset - start
left = chunk[:breakpoint]
rest = chunk[breakpoint:]
word,right = re.split("[\s.;:,<>?!]",rest,1)
yield f.format(left + "<span rend='preserve' class='hilite'>" + word + "</span> " + right)
return
yield f.format(chunk)
def handle_request(self, env, start):
parts = env["PATH_INFO"].split("/")[1:]
locale = None
if len(parts):
locale = to_gettext_locale(parts[0])
if locale:
env = dict(env)
shift_path_info(env)
self.maybe_apply_translation(env, locale)
if "translation" in env or locale == NULL_LOCALE:
return self.file_server.handle_request(env, start)
def app(environ, start_response):
parts = environ['PATH_INFO'].split('/')[1:]
if len(parts) >= 2 and parts[0] == multiplex_dir:
app = multiplex_apps.get(parts[1])
if len(parts) > 2 and app:
shift_path_info(environ)
shift_path_info(environ)
return app(environ, start_response)
else:
start_response('404 Not Found',
[('Content-Type', 'text/plain')])
return ['Not Found']
return default_app(environ, start_response)
def __call__(self, environ, start_response):
"""Dispatch to the method named by the next bit of PATH_INFO."""
# Predict the path shift to get the callable name.
name = shift_path_info(dict(SCRIPT_NAME=environ['SCRIPT_NAME'],
PATH_INFO=environ['PATH_INFO']))
# If there is such a callable and it is exposed...
callable = getattr(self, name or 'index', None)
if callable is not None and self._is_exposed(callable):
# ... shift the path and call the callable.
shift_path_info(environ)
return callable(environ, start_response)
else:
# ... or call self._not_found (
return self._not_found(environ, start_response)
def __init__(self, environ):
ctrlr_class = shift_path_info(environ)
ctrlr_action = shift_path_info(environ)
if ctrlr_class == '' or ctrlr_class == None:
ctrlr_class = 'home'
if ctrlr_action == '' or ctrlr_action == None:
ctrlr_action = 'index'
# Class Members
self.ctrlr_file = 'controller.' + ctrlr_class
self.ctrlr_class = ctrlr_class
self.ctrlr_action = ctrlr_action
def application(env, start):
env['htmlpad.etherpad'] = 'etherpad.mozilla.org:9000'
## ianb: cwd sensitive:
static_files_dir = os.path.join('htmlpad.org', 'static-files')
# Clearing the template cache on each request allows developers
# to iterate quickly.
htmlpad.template_cache = {}
if env['PATH_INFO'].startswith('/static-files/'):
shift_path_info(env)
return static_file(env, start, static_files_dir)
else:
return htmlpad.application(env, start)
def strip_app(environ,start_response):
if environ['PATH_INFO']=='/':
environ['PATH_INFO']='/index.html'
if environ['PATH_INFO'].startswith('/api'):
shift_path_info(environ)
else:
try:
filename=os.path.join(os.getcwd(),'client','html',environ['PATH_INFO'][1:])
f=open(filename,'rb')
except fnfError:
start_response("404 NOT FOUND",[])
return []
start_response("200 OK",[])
return f
return matomat_wsgi.application(environ,start_response)
def __call__(environ, start_response):
"""Handle a HTTP request."""
from wsgiref.util import application_uri, shift_path_info
from urlparse import urljoin
try:
import swat
except ImportError as e:
print("NO SWAT: %r" % e)
have_swat = False
else:
have_swat = True
orig_path = environ['PATH_INFO']
name = shift_path_info(environ)
if name == "":
if have_swat:
start_response('301 Redirect',
[('Location', urljoin(application_uri(environ), 'swat')),])
return []
else:
return render_placeholder(environ, start_response)
elif have_swat and name == "swat":
return swat.__call__(environ, start_response)
else:
status = '404 Not found'
response_headers = [('Content-type', 'text/html')]
start_response(status, response_headers)
return ["The path %s (%s) was not found" % (orig_path, name)]
def handle(self, request):
'''Handle a request, parse and validate arguments and dispatch the request'''
entity = pop_path_info(request.environ)
if not entity:
return self.handle_index()
if entity not in [ 'release', 'release-group' ]:
return Response (
status=400, response=
"Only release and release-group entities are currently supported")
req_mbid = shift_path_info(request.environ)
if not req_mbid:
return Response (status=400, response="no MBID specified.")
if not re.match('[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$', req_mbid):
return Response (status=400, response="invalid MBID specified.")
mbid = self.resolve_mbid (entity, req_mbid)
filename = pop_path_info(request.environ)
if entity == 'release-group':
return self.handle_release_group (request, mbid, filename)
else:
return self.handle_release (request, mbid, filename)
def post_resource():
ctype = environ.get('CONTENT_TYPE', 'application/unknown')
clen = int(environ.get('CONTENT_LENGTH', None))
if not clen:
start_response("411 Length Required", [('Content-Type','text/plain')])
return ["Length Required"]
key = shift_path_info(environ)
now = datetime.now().isoformat()
md = {
CREATED: now,
UPDATED: now,
CONTENT_LENGTH: clen,
CONTENT_TYPE: ctype,
}
#md = self.standard_index
content = environ['wsgi.input'].read(clen)
id = drv.create_resource(content, metadata=md)
msg = 'Adding %i' % id
new_uri = str(id)
headers = [('Content-Type', 'text/plain')]
headers.append(('Location', new_uri))
headers.append(('Content-Location', new_uri))
#environ['akara.etag'] = compute_etag(content)
headers.append(('Content-Length', str(len(msg))))
start_response("201 Created", headers)
return msg
def app(environ, start_response):
path = shift_path_info(environ)
print(path)
if path == 'api':
return mxreverse(environ, start_response)
start_response('301 Moved', [('Location', '/page/index.html')])
return [b'']
def get_file(environ, start_response):
'''
GETting the collection resource itself returns a simple file listing.
GETting a subsidiary resource returns the file
'''
print >> sys.stderr, 'GRIPPO', environ['PATH_INFO']
if environ['PATH_INFO'] == '/':
#Get index
start_response(status_response(httplib.OK), [("Content-Type", "text/plain")])
return '\n'.join(os.listdir(BASE)) + '\n'
resource_fname = shift_path_info(environ)
#Not needed because the shift_path_info will ignore anything after the '/' and they'll probably get a 404
#'..' will not be expanded by os.path.join
#if "/" in resource_fname:
# start_response(status_response(httplib.BAD_REQUEST), [("Content-Type", "text/plain")])
# return 'You must not include forward slashes in your request (%s)'%resource_fname
resource_path = os.path.join(BASE, resource_fname)
print >> sys.stderr, 'Getting the file at: ', resource_fname
try:
f = open(resource_path, 'rb')
#FIXME: do it chunk by chunk
rbody = f.read()
#FIXME: work out content type mappings (perhaps by file extension)
start_response(status_response(httplib.OK), [("Content-Type", "text/plain")])
return rbody
except IOError:
rbody = four_oh_four.substitute(fronturl=request_uri(environ), backurl=resource_fname)
start_response(status_response(httplib.NOT_FOUND), [("Content-Type", "text/html")])
return rbody
def switch(env, conn):
id_ = shift_path_info(env)
if id_ != None and id_ != "":
switch = conn.db.rfstats.find_one(id_)
return (200, json.dumps(switch["data"], default=bson.json_util.default), JSON)
else:
return (404, "Switch not specified", JSON)
def messages(env, conn):
channel = shift_path_info(env)
if channel != None and channel != "":
# TODO: escape parameters
messages = []
try:
table = getattr(conn.db, channel);
except:
return (404, "Invalid channel", JSON)
request = parse_qs(env["QUERY_STRING"])
limit = 50
query = {}
if "limit" in request:
limit = request["limit"][0]
if "types" in request:
types = request["types"][0]
query["$or"] = []
for type_ in types.split(","):
try:
value = int(type_)
except:
continue
query["$or"].append({"type": value})
for doc in table.find(query, limit=limit, sort=[("$natural", pymongo.DESCENDING)]):
messages.append(doc)
return (200, json.dumps(messages, default=bson.json_util.default), JSON)
else:
return (404, "Channel not specified", JSON)
def bookings_room_page(environ):
"""Provide a list of bookings by room, showing user and date/time
"""
room_id = int(shift_path_info(environ))
room = get_room(room_id)
html = "<table>"
html += "<tr><td>User</td><td>Date</td><td>Times</td></tr>"
for booking in get_bookings_for_room(room_id):
html += "<tr><td>{user_name}</td><td>{booked_on}</td><td>{booked_from} - {booked_to}</td></tr>".format(
user_name=booking['user_name'],
booked_on=booking['booked_on'],
booked_from=booking['booked_from'] or "",
booked_to=booking['booked_to'] or ""
)
html += "</table>"
html += "<hr/>"
html += '<form method="POST" action="/add-booking">'
html += '<input type="hidden" name="room_id" value="{room_id}"/>'.format(room_id=room_id)
html += '<label for="user_id">User:</label> <select name="user_id">'
for user in get_users():
html += '<option value="{id}">{name}</option>'.format(**user)
html += '</select>'
html += ' | '
html += '<label for="booked_on">On</label> <input type="text" name="booked_on" value="{today}"/>'.format(today=datetime.date.today())
html += ' <label for="booked_from">between</label> <input type="text" name="booked_from" />'
html += ' <label for="booked_to">and</label> <input type="text" name="booked_to" />'
html += '<input type="submit" name="submit" value="Add Booking"/></form>'
return page("Bookings for %s" % room['name'], html)
def checkShift(self,sn_in,pi_in,part,sn_out,pi_out):
env = {'SCRIPT_NAME':sn_in,'PATH_INFO':pi_in}
util.setup_testing_defaults(env)
self.assertEqual(util.shift_path_info(env),part)
self.assertEqual(env['PATH_INFO'],pi_out)
self.assertEqual(env['SCRIPT_NAME'],sn_out)
return env
def handle(self, request):
"""Handle a request, parse and validate arguments and dispatch the request."""
entity = pop_path_info(request.environ)
if request.method == "OPTIONS":
return self.handle_options(request, entity)
if not entity:
return self.handle_index()
elif entity == "robots.txt":
return self.handle_robots()
elif entity == "main.css":
return self.handle_css()
elif entity == "img":
return self.handle_svg_img(pop_path_info(request.environ))
elif entity == "js":
return self.handle_js(pop_path_info(request.environ))
elif entity == "api":
return self.handle_api(request)
self.validate_entity(entity)
req_mbid = shift_path_info(request.environ)
self.validate_mbid(req_mbid)
mbid = self.resolve_mbid(entity, req_mbid)
filename = pop_path_info(request.environ)
if entity == "release-group":
return self.handle_release_group(request, mbid, filename)
else:
return self.handle_release(request, mbid, filename)
def serve_under_prefix(self, environ, start_response):
prefix = shift_path_info(environ)
if prefix != self.PREFIX:
start_response('404 Not Found', [])
return []
else:
return self.application(environ, start_response)
def checkShift(self, sn_in, pi_in, part, sn_out, pi_out):
env = {"SCRIPT_NAME": sn_in, "PATH_INFO": pi_in}
util.setup_testing_defaults(env)
self.assertEqual(util.shift_path_info(env), part)
self.assertEqual(env["PATH_INFO"], pi_out)
self.assertEqual(env["SCRIPT_NAME"], sn_out)
return env
def webapp(environ, start_response):
"""Serve simple pages, based on whether the URL requests
users, rooms or bookings. For now, just serve the Home page
"""
setup_testing_defaults(environ)
#
# Assume we're going to serve a valid HTML page
#
status = '200 OK'
headers = [('Content-type', 'text/html; charset=utf-8')]
#
# Pick up the first segment on the path and pass
# the rest along.
#
# ie if we're looking for /users/1/bookings,
# param1 will be "users", and the remaining path will
# be "/1/bookings".
#
param1 = shift_path_info(environ)
if param1 == "":
data = index_page(environ)
elif param1 == "users":
data = users_page(environ)
elif param1 == "rooms":
data = rooms_page(environ)
else:
status = '404 Not Found'
data = "Not Found: %s" % param1
start_response(status, headers)
return [data.encode("utf-8")]
def __call__(self, env, resp):
name = shift_path_info(env)
app = self.pages.get(name)
if not app:
resp('404 ERR', [('Content-type', 'text/plain')])
return ['Page %s not found' % name]
return app(env, resp)
def _wsgi_app(self, environ, start_response):
if self._apps:
app_route = shift_path_info(environ)
if app_route in self._apps:
environ['SCRIPT_NAME'] = ''
return self._apps[app_route](environ, start_response)
start_response('404 NOT FOUND', [('Content-type', 'text/plain'), ])
return ['no application deployed'.encode('utf-8')]
def application(env, resp):
"""Return the JQuery-enhanced HTML page and dispatch on the
static directory too"""
name = shift_path_info(env)
if name == 'static':
return static(env, resp)
resp('200 OK', [('Content-type', 'text/html')])
return [html % (js, body)]
def scope_app(environ, start_response):
root = shift_path_info(environ)
index, count = map(int, root.split('of'))
url = 'http:/' + environ['PATH_INFO']
if 'QUERY_STRING' in environ:
url += '?' + environ['QUERY_STRING']
start_response("200 OK", [('Content-Type', "text/xml")])
return parse_scope(url, index, count)
def Dispatcher(env, resp):
'''Send requests to handlers based on the first path component.'''
page = util.shift_path_info(env)
if page in DISPATCH:
return DISPATCH[page](env, resp)
else:
status = '404 Not Found'
headers = [('Content-type', 'text/plain')]
resp(status, headers)
return ['Not Found: ' + page]
def handle(environ, start_response):
chunk_num = shift_path_info(environ)
msg = self.messages[chunk_msg]
chunks = msg.setdefault("chunks", {})
with closing(stream_from_wsgi_environ(environ)) as stream:
data = stream.read()
chunks[chunk_num] = zlib.compress(data) if not environ.get(
'HTTP_CONTENT_ENCODING', None) else data
start_response('202 Accepted', [])
return []
def __call__(self, environ, start_response):
orig_path = environ.get('PATH_INFO')
orig_script_name = environ.get('SCRIPT_NAME')
path_part = (shift_path_info(environ) or '').lower()
if path_part in self._other_apps:
return self._other_apps[path_part](environ, start_response)
else:
environ['PATH_INFO'] = orig_path
environ['SCRIPT_NAME'] = orig_script_name
return self._root_app(environ, start_response)
def shift(self):
environ = self.environ
part = shift_path_info(environ)
if part or part is None:
return part
# We got an empty string, so we just hit a trailing slash;
# replace it with the default method:
environ['SCRIPT_NAME'] += self.policy.defaultMethod
return self.policy.defaultMethod
def _wsgi_app(self, environ, start_response):
if self._apps:
app_route = shift_path_info(environ)
if app_route in self._apps:
environ['SCRIPT_NAME'] = ''
return self._apps[app_route](environ, start_response)
start_response('404 NOT FOUND', [
('Content-type', 'text/plain'),
])
return ['no application deployed'.encode('utf-8')]
def philo_dispatcher(environ, start_response):
environ["parsed_params"] = urlparse.parse_qs(environ["QUERY_STRING"],
keep_blank_values=True)
cgi = environ["parsed_params"]
dbname = shift_path_info(environ)
environ["philologic_dbname"] = dbname
myname = environ["SCRIPT_NAME"]
print >> sys.stderr, myname
dbfile = "/var/lib/philologic/databases/" + dbname
print >> sys.stderr, dbfile
try:
db = PhiloDB(dbfile, 7)
except OperationalError:
return
environ["philologic_dbname"] = dbname
if environ["PATH_INFO"]:
print >> sys.stderr, "scanning path info"
scanned = environ["PATH_INFO"].split("/")
scanned = [i for i in scanned if i is not ""]
print >> sys.stderr, "%s scanned." % repr(scanned)
if "children" in scanned:
environ["philologic_id"] = environ["PATH_INFO"]
return object_children_service(environ, start_response)
elif "form" in scanned:
return form_service(environ, start_response)
elif scanned:
environ["philologic_id"] = environ["PATH_INFO"]
print >> sys.stderr, "passing to object formatter"
return object_service(environ, start_response)
if "query" in cgi and cgi["query"][0]:
if "report" in cgi:
if cgi["report"][0] == "frequency":
if "json" in cgi:
if "field" in cgi and cgi["field"][0] == "collocates":
from colloc_json_service import colloc_json_service
return colloc_json_service(environ, start_response)
return freq_json_service(environ, start_response)
return freq_service(environ, start_response)
elif cgi["report"][0] == "collocation":
if "json" in cgi:
from colloc_json_service import colloc_json_service
return colloc_json_service(environ, start_response)
return colloc_service(environ, start_response)
return conc_service(environ, start_response)
elif "colloc_filter" in cgi:
return colloc_filter_service(environ, start_response)
else:
return conc_service(environ, start_response)
else:
return cite_list_service(environ, start_response)
def handle_options(self, request, entity):
"""Repond to OPTIONS requests with a status code of 200 and the allowed
request methods.
"""
if request.environ["SERVER_PROTOCOL"] != "HTTP/1.1":
# OPTIONS does not exist in HTTP/1.0
raise NotImplemented()
if entity:
if not entity == '*':
self.validate_entity(entity)
elif pop_path_info(request.environ) is not None:
# There's more than a single asterisk in the request uri
raise BadRequest()
else:
return Response(status=200,
headers=[("Allow", "GET, HEAD, OPTIONS")])
req_mbid = shift_path_info(request.environ)
self.validate_mbid(req_mbid)
image_id = shift_path_info(request.environ)
if image_id and image_id is not None:
image_id = splitext(image_id)[0]
_split = image_id.split('-')
if len(_split) > 0:
id_text = _split[0]
try:
int(id_text)
except ValueError:
if id_text not in ('front', 'back'):
raise BadRequest()
else:
get_sentry().captureException()
if len(_split) > 1:
size = _split[1]
if size not in ('250', '500'):
raise BadRequest()
return Response(status=200, headers=[("Allow", "GET, HEAD, OPTIONS")])
def __call__(self, environ, start_response):
if self.prefix and not environ['PATH_INFO'].startswith(self.prefix):
return self._error(start_response, 400, "bad request")
auth = environ.get('HTTP_AUTHORIZATION')
if not auth:
return self._error(start_response, 401, "unauthorized",
"Missing Basic Authentication.")
scheme, encoded = auth.split(None, 1)
if scheme.lower() != 'basic':
return self._error(start_response, 401, "unauthorized",
"Missing Basic Authentication")
user, password = encoded.decode('base64').split(':', 1)
try:
self.verify_user(environ, user, password)
except Unauthorized:
return self._error(start_response, 401, "unauthorized",
"Incorrect password or login.")
del environ['HTTP_AUTHORIZATION']
shift_path_info(environ)
return self.app(environ, start_response)
def dump(env, start_response):
start_response('200 OK', [('Content-Type', 'text/html')])
yield b'<pre>'
for key in env:
yield key.encode('utf-8') + b':' + str(env[key]).encode('utf-8') + b'\n'
yield b'\n'
yield b'request_uri=' + util.request_uri(env).encode('utf-8') + b'\n'
yield b'application_uri=' + util.application_uri(env).encode('utf-8') + b'\n'
path = util.shift_path_info(env)
while (path):
yield b'path=' + path.encode('utf-8') + b'\n'
path = util.shift_path_info(env)
args = parse.parse_qs(env['QUERY_STRING'])
for key in args:
yield key.encode('utf-8') + b': ' + b' '.join([value.encode('utf-8') for value in args[key]])
return []
def endpoint_lookup(self, environ, start_response):
org_code = shift_path_info(environ)
workflow_id = shift_path_info(environ)
if not org_code or not workflow_id:
return _not_found(environ, start_response)
result = {
"query_id":
"{ts:%Y%m%d%H%M%S%f}_{rnd:06x}_{ts:%s}".format(
ts=datetime.datetime.now(), rnd=random.randint(0, 0xffffff)),
"results": [{
"address":
"{}HC001".format(org_code),
"description":
"{} {} endpoint".format(org_code, workflow_id),
"endpoint_type":
"MESH"
}]
}
return _ok('application/json', [json.dumps(result).encode('UTF-8')],
start_response)
def bookings_page(environ):
"""Provide a list of all bookings by a user or room, showing
the other thing (room or user) and the date/time
"""
category = shift_path_info(environ)
if category == "user":
return bookings_user_page(environ)
elif category == "room":
return bookings_room_page(environ)
else:
return "No such booking category"
def rezervacije_page(environ):
category = shift_path_info(environ)
if not category:
return all_rezervacije_page(environ)
elif category == "korisnik":
return rezervacije_korisnik_page(environ)
elif category == "restoran":
return rezervacije_restorani_page(environ)
else:
return "page not found"
def _dispatch(self, env, start_response):
part = shift_path_info(env)
method = getattr(
self, '_%s_%s' % (env['REQUEST_METHOD'], part.replace('.', '_')),
None)
if len(env['PATH_INFO'].split('/')) == 1 and method:
return method(env, start_response)
start_response(utils.status(404), [])
return []
def handle(self, environ):
'''Handle a request, parse and validate arguments and dispatch the request'''
entity = shift_path_info(environ)
if not entity:
return self.handle_index()
mbid = shift_path_info(environ)
if not mbid:
return ["400 no MBID specified.", ""]
if not re.match('[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$', mbid):
return ["400 invalid MBID specified.", ""]
filename = shift_path_info(environ)
if not filename:
return self.handle_dir(entity, mbid)
if not entity or entity != 'release':
return ["400 Only release entities are supported currently", ""]
(code, response) = self.handle_redirect(entity, mbid.lower(), filename.encode('utf8'))
return code, response
def get_resource():
key = shift_path_info(environ)
content1, metadata = drv.get_resource(key)
if content1 is None:
#404 error
start_response('404 Not Found', [('content-type', 'text/html')])
response = four_oh_four.substitute(url=request_uri(environ))
return response
start_response('200 OK',
[('content-type', str(metadata[CONTENT_TYPE]))])
return content1.encode('utf-8')
def handle_namespace(environ, computer, namespace):
if not namespace:
wmi_connection = wmi.WMI(computer, namespace="root/cimv2")
for setting in wmi_connection.Win32_WMISetting():
namespace = setting.ASPScriptDefaultNamespace
break
wmi_connection = wmi.WMI(computer, namespace=namespace, find_classes=True)
wmi_class = shift_path_info(environ)
if wmi_class:
doc_wmi_class(computer, namespace, wmi_class, wmi_connection)
else:
doc_namespace(computer, namespace, wmi_connection)
def outbox(self, environ, start_response):
chunk_msg = shift_path_info(environ)
if chunk_msg == 'tracking':
return self.tracking(environ, start_response)
if chunk_msg:
return self.upload_chunk(chunk_msg)(environ, start_response)
try:
recipient = environ["HTTP_MEX_TO"]
sender = environ["HTTP_MEX_FROM"]
mailbox_id = environ["mesh.mailbox"]
assert mailbox_id == sender
except Exception as e:
traceback.print_exc()
start_response("417 Expectation Failed",
[('Content-Type', 'application/json')])
return [
json.dumps({
"errorCode": "02",
"errorDescription": str(e),
"errorEvent": "COLLECT",
"messageID": "99999"
})
]
mailbox = self.messages.setdefault(recipient, OrderedDict())
with closing(stream_from_wsgi_environ(environ)) as stream:
data = stream.read()
if not data:
start_response("417 Expectation Failed",
[('Content-Type', 'application/json')])
return [
json.dumps({
"errorCode": "02",
"errorDescription":
"Data file is missing or inaccessible.",
"errorEvent": "COLLECT",
"messageID": "99999"
}).encode("utf-8")
]
headers = {
_OPTIONAL_HEADERS[key]: value
for key, value in environ.items() if key in _OPTIONAL_HEADERS
}
msg_id = self.make_message_id()
headers['Mex-MessageID'] = msg_id
mailbox[msg_id] = {"headers": headers, "data": data}
self.messages[msg_id] = mailbox[msg_id]
return _ok("application/json",
[json.dumps({
"messageID": msg_id
}).encode("UTF-8")], start_response)
def target(environ):
wiki_id = shift_path_info(environ)
full_incoming_request = request_uri(environ)
if wiki_id not in TARGET_WIKIS:
raise BadTargetError(fronturl=request_uri(environ), target=wiki_id)
original_page = join(TARGET_WIKIS[wiki_id].rstrip('/') + '/',
environ['PATH_INFO'].lstrip('/'))
#relative_to_wrapped = relativize(, full_incoming_request)
if len(environ['PATH_INFO']) > 0:
wrapped_wiki_base = full_incoming_request[:-len(environ['PATH_INFO'])]
else:
wrapped_wiki_base = full_incoming_request
return wiki_id, TARGET_WIKIS[wiki_id], TARGET_WIKI_OPENERS.get(
wiki_id), original_page, wrapped_wiki_base
def bookings_room_page(environ):
"""Provide a list of bookings by room, showing user and date/time
"""
room_id = int(shift_path_info(environ))
html = "<table>"
html += "<tr><td>User</td><td>Date</td><td>Times</td></tr>"
for booking in get_bookings_for_room(room_id):
html += "<tr><td>{user_name}</td><td>{booked_on}</td><td>{booked_from} - {booked_to}</td></tr>".format(
user_name=booking['user_name'],
booked_on=booking['booked_on'],
booked_from=booking['booked_from'] or "",
booked_to=booking['booked_to'] or "")
html += "</table>"
return page("Bookings for room %d" % room_id, html)
def bookings_user_page(environ):
"""Provide a list of bookings by user, showing room and date/time
"""
user_id = int(shift_path_info(environ))
html = "<table>"
html += "<tr><td>Room</td><td>Date</td><td>Times</td></tr>"
for booking in get_bookings_for_user(user_id):
html += "<tr><td>{room_name}</td><td>{booked_on}</td><td>{booked_from} - {booked_to}</td></tr>".format(
room_name=booking['room_name'],
booked_on=booking['booked_on'],
booked_from=booking['booked_from'] or "",
booked_to=booking['booked_to'] or "")
html += "</table>"
return page("Bookings for user %d" % user_id, html)
def webapp(environ, start_response):
"""Serve simple pages, based on whether the URL requests
users, rooms or bookings. For now, just serve the Home page
"""
setup_testing_defaults(environ)
#
# Assume we're going to serve a valid HTML page
#
status = '200 OK'
headers = [('Content-type', 'text/html; charset=utf-8')]
#
# Pick up the first segment on the path and pass
# the rest along.
#
# ie if we're looking for /users/1/bookings,
# param1 will be "users", and the remaining path will
# be "/1/bookings".
#
param1 = shift_path_info(environ)
if param1 == "":
data = index_page(environ)
elif param1 == "users":
data = users_page(environ)
elif param1 == "rooms":
data = rooms_page(environ)
elif param1 == "bookings":
data = bookings_page(environ)
elif param1 == "add-user":
add_user(environ)
status = "301 Redirect"
headers.append(("Location", "/users"))
data = ""
elif param1 == "add-room":
add_room(environ)
status = "301 Redirect"
headers.append(("Location", "/rooms"))
data = ""
elif param1 == "add-booking":
add_booking(environ)
status = "301 Redirect"
headers.append(("Location", environ.get("HTTP_REFERER", "/bookings")))
data = ""
else:
status = '404 Not Found'
data = "Not Found: %s" % param1
start_response(status, headers)
return [data.encode("utf-8")]
def scope_app(environ, start_response):
root = shift_path_info(environ)
if root == 'obj':
return object_app(environ, start_response)
search_params = {} # parse query string
qs = environ.get('QUERY_STRING', "").split('&')
ql = [map(unquote_plus, comp.split('=', 1)) for comp in qs if '=' in comp]
search_params.update(ql)
search_params['media'] = "photos"
search_params['sort'] = "date-posted-asc"
start_response("200 OK", [('Content-Type', "text/xml")])
return FlickrObjList(search_params)
def getsubpage(self, root, env, resp):
script_name = util.shift_path_info(env)
if not script_name: # We've arrived!
resp('200 OK', [('content-type', 'text/html')])
return root
try:
page = getattr(root, script_name)
except AttributeError:
resp('404 Not Found', [('content-type', 'text/plain')])
return lambda: ['missing page %r' % script_name]
exposed = getattr(page, 'exposed', False)
if not exposed:
resp('404 Not Found', [('content-type', 'text/plain')])
return lambda: ['%r is not exposed!' % script_name]
return self.getsubpage(page, env, resp)
def __call__(self, environ, start_response):
headers = []
for middleware in self.settings.MIDDLEWARE_CLASSES:
Middleware = dynamic_import(middleware)
middleware_instance = Middleware(environ, start_response)
if middleware_instance.is_valid():
return middleware_instance.get_response()
url = "/{0}".format(shift_path_info(environ))
headers.append(('Content-type', 'text/html'))
view = self.urls.get(url)
if view:
start_response("200 OK", headers)
return view()
start_response("404 Not Found", headers)
return "Erro 404 - Page not found"
def _dispatch(self, env, start_response):
if len(env['PATH_INFO'].split('/')) > 2:
part = shift_path_info(env)
if part in self.services:
return self.services[part]._dispatch(env, start_response)
elif part in self.devices:
return self.devices[part]._dispatch(env, start_response)
start_response(utils.status(404), [])
return []
return super(BaseDevice, self)._dispatch(env, start_response)
def app(environ, start_response):
computer = shift_path_info(environ)
if computer == "favicon.ico":
start_response("404 Not Found", [("Content-Type", "text/plain")])
return []
elif computer:
start_response("200 OK",
[("Content-Type", "text/html; charset=utf-8")])
handle_computer(environ, computer)
return (unicode(d).encode("utf8") + unicode("\n").encode("utf8")
for d in doc)
else:
start_response("301 Moved Permanently",
[("Location", "/localhost"),
("Content-Type", "text/plain")])
return ["Redirected to /localhost"]
def scope_app(environ, start_response):
root = shift_path_info(environ)
if root == 'obj':
return object_app(environ, start_response)
querydict = {}
qs = environ.get('QUERY_STRING', '').split('&')
ql = [ map(unquote_plus, comp.split('=', 1)) for comp in qs if '=' in comp ]
for k,v in ql: querydict.setdefault(k, []).append(v)
image_id = 'com.ibm.mirage.sha1id/' + root.lower()
start_response("200 OK", [('Content-Type', "text/xml")])
return MirageListVerbose(image_id,
querydict.get('path', ['*']),
querydict.get('user', None))
def web_handler(self, environ, start_response):
"""Application called when we interact with the webserver."""
pth = shift_path_info(environ)
if pth == '':#Root page
response_body = self.index()
else:
response_body = self.device_operation(pth, environ)
status = '200 OK'
# Now content type is text/html
response_headers = [('Content-Type', 'text/html'),
('Content-Length', str(len(response_body)))]
start_response(status, response_headers)
return [response_body]
def handle(environ, start_response):
requested_mailbox = shift_path_info(environ)
authorization_header = environ.get("HTTP_AUTHORIZATION", "")
if not authorization_header.startswith("NHSMESH "):
return _not_authorized(environ, start_response)
auth_data = authorization_header[8:]
mailbox, nonce, nonce_count, ts, hashed = auth_data.split(":")
expected_password = "******"
hash_data = ":".join(
[mailbox, nonce, nonce_count, expected_password, ts])
myhash = hmac.HMAC(self._shared_key, hash_data.encode("ASCII"),
sha256).hexdigest()
if myhash == hashed and mailbox == requested_mailbox:
environ["mesh.mailbox"] = mailbox
return handler(environ, start_response)
else:
return _forbidden(environ, start_response)
