def identify(self, environ):
path_info = environ['PATH_INFO']
query = parse_dict_querystring(environ)
if path_info == self.logout_handler_path:
# we've been asked to perform a logout
form = parse_formvars(environ)
form.update(query)
referer = environ.get('HTTP_REFERER', '/')
environ['repoze.who.application'] = HTTPUnauthorized()
# invalidate the session
identity = environ.get('repoze.who.identity')
if identity:
self.forget(environ, identity)
return None
elif path_info == self.login_handler_path:
# we've been asked to perform a login
form = parse_formvars(environ)
form.update(query)
credentials = self._getCredentials(form)
referer = environ.get('HTTP_REFERER', '/')
environ['repoze.who.application'] = HTTPFound(referer)
if 'login' not in credentials or 'password' not in credentials:
return None
return credentials
def identify(self, environ):
path_info = environ['PATH_INFO']
query = parse_dict_querystring(environ)
if path_info == self.logout_handler_path:
# we've been asked to perform a logout
form = parse_formvars(environ)
form.update(query)
referer = environ.get('HTTP_REFERER', '/')
environ['repoze.who.application'] = HTTPUnauthorized()
return None
elif path_info == self.login_handler_path:
# we've been asked to perform a login
form = parse_formvars(environ)
form.update(query)
try:
max_age = form.get('max_age', None)
credentials = {
'login':form['login'],
'password':form['password'],
'realm':form['realm'],
}
except KeyError:
credentials = None
if credentials is not None:
max_age = form.get('max_age', None)
if max_age is not None:
credentials['max_age'] = max_age
referer = environ.get('HTTP_REFERER', '/')
environ['repoze.who.application'] = HTTPFound(referer)
return credentials
def identify(self, environ):
path_info = environ['PATH_INFO']
query = parse_dict_querystring(environ)
if path_info == self.logout_handler_path:
# we've been asked to perform a logout
form = parse_formvars(environ)
form.update(query)
referer = environ.get('HTTP_REFERER', '/')
environ['repoze.who.application'] = HTTPUnauthorized()
return None
elif path_info == self.login_handler_path:
# we've been asked to perform a login
form = parse_formvars(environ)
form.update(query)
try:
max_age = form.get('max_age', None)
credentials = {
'login': form['login'],
'password': form['password'],
'realm': form['realm'],
}
except KeyError:
credentials = None
if credentials is not None:
max_age = form.get('max_age', None)
if max_age is not None:
credentials['max_age'] = max_age
referer = environ.get('HTTP_REFERER', '/')
environ['repoze.who.application'] = HTTPFound(referer)
return credentials
def wrapped_function(environ, start_response):
# Get the request information with Paste
req = request.parse_formvars(environ, include_get_vars).mixed()
# Start the coroutine. When it's done, we'll send the response back via
# HTTP.
response_coro = coroutine.Coroutine(func(**req))
def completion_handler(retval, exc_info):
"""
Called when any coroutine-based page completes. Applies all
postprocessing steps, and returns the page to the browser.
"""
if exc_info:
# Shit
raise exc_info[0], exc_info[1], exc_info[2]
# Handle all the postprocessing steps
if hasattr(func, "chiral_postprocessors"):
for postproc in func.chiral_postprocessors:
retval = postproc(retval)
# Return it to the browser
start_response("200 OK", {})
return [ retval ], None
response_coro.add_completion_callback(completion_handler)
environ["chiral.http.set_coro"](response_coro)
return [""]
def get_context(environ):
"""Figure out the CGI variables passed to this script"""
form = parse_formvars(environ)
if "year" in form:
year1 = form.get("year")
year2 = year1
else:
year1 = form.get("year1")
year2 = form.get("year2")
month1 = form.get("month1")
month2 = form.get("month2")
day1 = form.get("day1")
day2 = form.get("day2")
hour1 = form.get("hour1")
hour2 = form.get("hour2")
minute1 = form.get("minute1")
minute2 = form.get("minute2")
sts = utc(int(year1), int(month1), int(day1), int(hour1), int(minute1))
ets = utc(int(year2), int(month2), int(day2), int(hour2), int(minute2))
if ets < sts:
s = ets
ets = sts
sts = s
form["fmt"] = form.get("fmt", "shp")
form["sts"] = sts
form["ets"] = ets
return form
def application(environ, start_response):
"""Go Main Go."""
form = parse_formvars(environ)
try:
lat = float(form.get("lat"))
lon = float(form.get("lon"))
except (ValueError, TypeError):
headers = [("Content-type", "text/plain")]
start_response("500 Internal Server Error", headers)
return [b"API FAIL!"]
fn = spiral(lon, lat)
if fn is None:
headers = [("Content-type", "text/plain")]
start_response("500 Internal Server Error", headers)
return [b"API FAIL!"]
headers = [
("Content-type", "application/octet-stream"),
(
"Content-Disposition",
"attachment; filename=%s" % (fn.split("/")[-1], ),
),
]
start_response("200 OK", headers)
return [open(fn, "rb").read()]
def application(environ, start_response):
"""Main()"""
headers = [("Content-type", "application/json")]
form = parse_formvars(environ)
network = form.get("network", "IACLIMATE").upper()
month = int(form.get("month", 1))
day = int(form.get("day", 1))
syear = int(form.get("syear", 1800))
eyear = int(form.get("eyear", datetime.datetime.now().year + 1))
cb = form.get("callback", None)
mckey = "/geojson/climodat_dayclimo/%s/%s/%s/%s/%s" % (
network,
month,
day,
syear,
eyear,
)
mc = memcache.Client(["iem-memcached:11211"], debug=0)
res = mc.get(mckey)
if not res:
res = run(network, month, day, syear, eyear)
mc.set(mckey, res, 86400)
if cb is None:
data = res
else:
data = "%s(%s)" % (html_escape(cb), res)
start_response("200 OK", headers)
return [data.encode("ascii")]
def __call__(self, environ, start_response):
# log form fields
pprint(parse_formvars(environ))
# response
# TODO: to format as ushahidi do
start_response('200 OK', [('content-type', 'application/json')])
#pprint(environ)
#import pdb; pdb.set_trace()
CATEGORIES['payload']['domain']= environ.get('HTTP_ORIGIN')
if environ.get('REQUEST_METHOD','') == 'POST':
#~ import pdb; pdb.set_trace()
if environ['paste.parsed_formvars'][0].has_key('task'):
result = CATEGORIES
else:
result = { "payload": {
"domain": environ.get('HTTP_ORIGIN'),
"success":"true"
},
"error":{ "code":"0",
"message":"No Error"}
}
elif environ.get('REQUEST_METHOD','') == 'GET' and \
environ.get('QUERY_STRING', '') == 'task=categories':
result = CATEGORIES
else:
result = {"status": "ok", "now": int(time.time())}
return json.dumps(result)
def tilecache(request, *xtra):
try:
path_info = host = ""
if "HTTP_X_FORWARDED_HOST" in request.META:
host = "http://" + request.META["HTTP_X_FORWARDED_HOST"]
elif "HTTP_HOST" in request.META:
host = "http://" +request.META["HTTP_HOST"]
host += request.META["SCRIPT_NAME"]
req_method = request.META["REQUEST_METHOD"]
path_info = request.META["PATH_INFO"]
fields = parse_formvars(request.META)
##### test configs for changes #####
myservice.checkchange()
format, image = myservice.dispatchRequest( fields, path_info, req_method, host )
headers = [( 'Content-Type', format.encode('utf-8') )]
except TileCacheException, E:
return HttpResponseServerError(["An error occurred: %s\n%s\n" % (
str(E),
"".join(traceback.format_tb(sys.exc_traceback)))])
def app(environ, start_response):
cfg = ConfigParser()
cfg.read('crowd.properties')
fields = parse_formvars(environ)
if environ['REQUEST_METHOD'] == 'POST':
cc = CrowdPy()
cc.createClient()
cc.authenticateApplication()
headers = []
headers.append(('content-type','text/html'))
try:
authenticated = cc.authenticatePrincipal(fields['usernname'],fields['password'])
cookieInfo = cc.getCookieInfo()
if cookieInfo.domain is None:
domain = cfg.get('default','domain.name')
else:
domain = cookieInfo.domain
headers.append(('Set-Cookie','crowd.token_key=' + authenticated + ';path=/;domain='+ domain +';expires=Sat, 7-Feb-2012 03:10:00' ))
except WebFault:
start_response('200 OK', headers)
return ['Invalid username/password']
start_response('200 OK', headers)
return ['Hello, ', fields['usernname'], ' You are valid user!']
else:
start_response('200 OK', [('content-type', 'text/html')])
cookies = request.get_cookie_dict(environ)
if 'crowd.token_key' in cookies.keys():
cc = CrowdPy()
cc.createClient()
cc.authenticateApplication()
isValid = cc.isValidPrincipalToken(cookies['crowd.token_key'])
return 'Already Authenticated'
return ['<form method="POST">User-name: <input type="text" '
'name="usernname"><br> Password : <input type="password" name="password" > <input type="submit"></form>']
def application(environ, start_response):
"""Do Fun things"""
form = parse_formvars(environ)
cb = form.get("callback", None)
huc12 = form.get("huc12", "000000000000")[:12]
mode = form.get("mode", "daily")
fmt = form.get("format", "json")
if fmt == "json":
headers = [("Content-Type", "application/vnd.geo+json")]
elif fmt == "xlsx":
headers = [
("Content-Type", EXL),
("Content-disposition", f"attachment; Filename=dep{huc12}.xlsx"),
]
start_response("200 OK", headers)
mckey = f"/geojson/huc12_events/{huc12}/{mode}/{fmt}"
mc = Client(["iem-memcached", 11211])
res = mc.get(mckey)
if res is None:
res = do(huc12, mode, fmt)
if fmt == "xlsx":
mc.close()
return [res]
mc.set(mckey, res, 15)
else:
res = res.decode("utf-8")
mc.close()
if cb is not None:
res = f"{cb}({res})"
return [res.encode("ascii")]
def application(environ, start_response):
"""Answer request."""
fields = parse_formvars(environ)
sid = fields.get("station", "")[:4]
if len(sid) == 3:
sid = "K" + sid
ts = parse_time(fields.get("ts"))
pressure = int(fields.get("pressure", -1))
cb = fields.get("callback")
mckey = "/json/raob/%s/%s/%s?callback=%s" % (
ts.strftime("%Y%m%d%H%M"),
sid,
pressure,
cb,
)
mc = memcache.Client(["iem-memcached:11211"], debug=0)
res = mc.get(mckey)
if not res:
res = run(ts, sid, pressure)
mc.set(mckey, res)
if cb is None:
data = res
else:
data = "%s(%s)" % (html_escape(cb), res)
headers = [("Content-type", "application/json")]
start_response("200 OK", headers)
return [data.encode("ascii")]
def application(environ, start_response):
""" see how we are called """
fields = parse_formvars(environ)
dt = fields.get("dt", datetime.date.today().strftime("%Y-%m-%d"))
ts = datetime.datetime.strptime(dt, "%Y-%m-%d")
cb = fields.get("callback", None)
fmt = fields.get("fmt", "geojson")
headers = []
if fmt == "geojson":
headers.append(("Content-type", "application/vnd.geo+json"))
else:
headers.append(("Content-type", "text/plain"))
mckey = "/geojson/cli/%s?callback=%s&fmt=%s" % (
ts.strftime("%Y%m%d"),
cb,
fmt,
)
mc = memcache.Client(["iem-memcached:11211"], debug=0)
res = mc.get(mckey)
if not res:
res = get_data(ts, fmt)
mc.set(mckey, res, 300)
if cb is None:
data = res
else:
data = "%s(%s)" % (html_escape(cb), res)
start_response("200 OK", headers)
return [data.encode("ascii")]
def wsgiHandler (environ, start_response, service):
from paste.request import parse_formvars
try:
path_info = host = ""
if "PATH_INFO" in environ:
path_info = environ["PATH_INFO"]
if "HTTP_X_FORWARDED_HOST" in environ:
host = "http://" + environ["HTTP_X_FORWARDED_HOST"]
elif "HTTP_HOST" in environ:
host = "http://" + environ["HTTP_HOST"]
host += environ["SCRIPT_NAME"]
req_method = environ["REQUEST_METHOD"]
fields = parse_formvars(environ)
format, image = service.dispatchRequest( fields, path_info, req_method, host )
headers = [('Content-Type',format)]
if format.startswith("image/"):
if service.cache.sendfile:
headers.append(('X-SendFile', image))
if service.cache.expire:
headers.append(('Expires', email.Utils.formatdate(time.time() + service.cache.expire, False, True)))
start_response("200 OK", headers)
if service.cache.sendfile and format.startswith("image/"):
return []
else:
return [image]
except TileCacheException, E:
start_response("404 Tile Not Found", [('Content-Type','text/plain')])
return ["An error occurred: %s" % (str(E))]
def identify(self, environ):
query = parse_dict_querystring(environ)
# If the extractor finds a special query string on any request,
# it will attempt to find the values in the input body.
if query.get(self.login_form_qs):
form = parse_formvars(environ)
from StringIO import StringIO
# XXX we need to replace wsgi.input because we've read it
# this smells funny
environ['wsgi.input'] = StringIO()
form.update(query)
try:
login = form['login']
password = form['password']
realm = form['realm']
except KeyError:
return None
del query[self.login_form_qs]
environ['QUERY_STRING'] = urllib.urlencode(query)
environ['repoze.who.application'] = HTTPFound(
construct_url(environ))
credentials = {'login':login, 'password':password, 'realm':realm}
max_age = form.get('max_age', None)
if max_age is not None:
credentials['max_age'] = max_age
return credentials
return None
def application(environ, start_response):
"""Answer request."""
fields = parse_formvars(environ)
station = fields.get("station", "KDSM")[:4]
year = int(fields.get("year", 2019))
cb = fields.get("callback")
fmt = fields.get("fmt", "json")
headers = []
if fmt == "json":
headers.append(("Content-type", "application/json"))
else:
headers.append(("Content-type", "text/plain"))
mckey = "/json/cli/%s/%s?callback=%s&fmt=%s" % (station, year, cb, fmt)
mc = memcache.Client(["iem-memcached:11211"], debug=0)
res = mc.get(mckey)
if not res:
res = get_data(station, year, fmt)
mc.set(mckey, res, 300)
if cb is None:
data = res
else:
data = "%s(%s)" % (html_escape(cb), res)
start_response("200 OK", headers)
return [data.encode("ascii")]
def identify(self, environ):
query = parse_dict_querystring(environ)
# If the extractor finds a special query string on any request,
# it will attempt to find the values in the input body.
if query.get(self.login_form_qs):
form = parse_formvars(environ)
from StringIO import StringIO
# XXX we need to replace wsgi.input because we've read it
# this smells funny
environ['wsgi.input'] = StringIO()
form.update(query)
credentials = self._getCredentials(form)
del query[self.login_form_qs]
environ['QUERY_STRING'] = urllib.urlencode(query)
environ['repoze.who.application'] = HTTPFound(
construct_url(environ))
if 'login' not in credentials or 'password' not in credentials:
return None
return credentials
return None
def application(environ, start_response):
"""Answer request."""
fields = parse_formvars(environ)
ts = fields.get("ts", None)
lat = float(fields.get("lat", 0))
lon = float(fields.get("lon", 0))
if ts is None:
ts = datetime.datetime.utcnow()
else:
ts = datetime.datetime.strptime(ts, "%Y%m%d%H%M")
ts = ts.replace(tzinfo=pytz.UTC)
cb = fields.get("callback")
if lat != 0 and lon != 0:
mckey = ("/json/spcwatch/%.4f/%.4f") % (lon, lat)
else:
mckey = "/json/spcwatch/%s" % (ts.strftime("%Y%m%d%H%M"),)
mc = memcache.Client(["iem-memcached:11211"], debug=0)
res = mc.get(mckey)
if not res:
if lat != 0 and lon != 0:
res = pointquery(lon, lat)
else:
res = dowork(ts)
mc.set(mckey, res)
if cb is None:
data = res
else:
data = "%s(%s)" % (html_escape(cb), res)
headers = [("Content-type", "application/vnd.geo+json")]
start_response("200 OK", headers)
return [data.encode("ascii")]
def identify(self, environ):
path_info = environ['PATH_INFO']
query = parse_dict_querystring(environ)
# we've been asked to perform a login
if self.login_handler_match(path_info):
body = environ['wsgi.input'].read()
stream = environ['wsgi.input'] = StringIO(body)
form = parse_formvars(environ)
form.update(query)
stream.seek(0)
# extract username and password
for key in self.username:
if key in form:
login = form[key]; break
else:
return None
for key in self.password:
if key in form:
password = form[key]; break
else:
return None
return {
'login': login,
'password': password,
}
def application(environ, start_response):
"""Answer request."""
fields = parse_formvars(environ)
year = int(fields.get("year", 2015))
fmt = fields.get("format", "json")
if fmt not in ["json", "html"]:
headers = [("Content-type", "text/plain")]
start_response("500 Internal Server Error", headers)
msg = "Invalid format provided."
return [msg.encode("ascii")]
cb = fields.get("callback", None)
headers = []
if fmt == "json":
headers.append(("Content-type", "application/json"))
else:
headers.append(("Content-type", "text/html"))
mckey = "/json/vtec_max_etn/%s/%s" % (year, fmt)
mc = memcache.Client(["iem-memcached:11211"], debug=0)
res = mc.get(mckey)
if res is None:
res = run(year, fmt)
mc.set(mckey, res, 3600)
if cb is None:
data = res
else:
data = "%s(%s)" % (html_escape(cb), res)
start_response("200 OK", headers)
return [data.encode("ascii")]
def application(environ, start_response):
"""Yawn"""
form = parse_formvars(environ)
year = int(form.get("year", 2018))
etn = int(form.get("etn", 1))
return [main(year, etn, start_response)]
def identify(self, environ):
query = parse_dict_querystring(environ)
# If the extractor finds a special query string on any request,
# it will attempt to find the values in the input body.
if query.get(self.login_form_qs):
form = parse_formvars(environ)
from StringIO import StringIO
# XXX we need to replace wsgi.input because we've read it
# this smells funny
environ['wsgi.input'] = StringIO()
form.update(query)
try:
login = form['login']
password = form['password']
except KeyError:
return None
del query[self.login_form_qs]
environ['QUERY_STRING'] = urllib.urlencode(query)
environ['repoze.who.application'] = HTTPFound(
construct_url(environ))
credentials = {'login':login, 'password':password}
max_age = form.get('max_age', None)
if max_age is not None:
credentials['max_age'] = max_age
return credentials
return None
def application(environ, start_response):
"""Go main go"""
props = get_properties()
form = parse_formvars(environ)
if "address" in form:
address = form["address"]
elif "street" in form and "city" in form:
address = "%s, %s" % (form["street"], form["city"])
else:
start_response("200 OK", [("Content-type", "text/plain")])
return [b"APIFAIL"]
req = requests.get(
SERVICE,
params=dict(
address=address, key=props["google.maps.key2"], sensor="true"
),
timeout=10,
)
data = req.json()
sio = StringIO()
if data["results"]:
sio.write(
"%s,%s"
% (
data["results"][0]["geometry"]["location"]["lat"],
data["results"][0]["geometry"]["location"]["lng"],
)
)
else:
sio.write("ERROR")
start_response("200 OK", [("Content-type", "text/plain")])
return [sio.getvalue().encode("ascii")]
def authenticate(self, environ, identity):
log.info('In authenticate()')
def set_error(msg):
log.info(msg)
err = 1
environ['FAS_AUTH_ERROR'] = err
# HTTPForbidden ?
err_app = HTTPFound(err_goto + '?' + 'came_from=' +
quote_plus(came_from))
environ['repoze.who.application'] = err_app
err_goto = '/login'
default_came_from = '/'
if 'SCRIPT_NAME' in environ:
sn = environ['SCRIPT_NAME']
err_goto = sn + err_goto
default_came_from = sn + default_came_from
query = parse_dict_querystring(environ)
form = parse_formvars(environ)
form.update(query)
came_from = form.get('came_from', default_came_from)
try:
auth_params = {
'username': identity['login'],
'password': identity['password']
}
except KeyError:
try:
auth_params = {'session_id': identity['session_id']}
except:
# On error we return None which means that auth failed
set_error('Parameters for authenticating not found')
return None
try:
user_data = self._retrieve_user_info(environ, auth_params)
except AuthError as e:
set_error('Authentication failed: %s' % exception_to_bytes(e))
log.warning(e)
return None
except Exception as e:
set_error('Unknown auth failure: %s' % exception_to_bytes(e))
return None
if user_data:
try:
del user_data[1]['password']
environ['CSRF_AUTH_SESSION_ID'] = user_data[0]
return user_data[1]['username']
except ValueError:
set_error('user information from fas not in expected format!')
return None
except Exception:
pass
set_error('An unknown error happened when trying to log you in.'
' Please try again.')
return None
def wsgiHandler (environ, start_response, service):
from paste.request import parse_formvars
try:
path_info = host = ""
if "PATH_INFO" in environ:
path_info = environ["PATH_INFO"]
if "HTTP_X_FORWARDED_HOST" in environ:
host = "http://" + environ["HTTP_X_FORWARDED_HOST"]
elif "HTTP_HOST" in environ:
host = "http://" + environ["HTTP_HOST"]
host += environ["SCRIPT_NAME"]
req_method = environ["REQUEST_METHOD"]
fields = parse_formvars(environ)
format, image = service.dispatchRequest( fields, path_info, req_method, host )
start_response("200 OK", [('Content-Type',format)])
return [image]
except TileCacheException, E:
start_response("404 Tile Not Found", [('Content-Type','text/plain')])
return ["An error occurred: %s" % (str(E))]
def application(environ, start_response):
"""Answer request."""
fields = parse_formvars(environ)
pgconn = get_dbconn("afos")
acursor = pgconn.cursor()
pid = fields.get("product_id", "201302241937-KSLC-NOUS45-PNSSLC")
cb = fields.get("callback")
utc = datetime.datetime.strptime(pid[:12], "%Y%m%d%H%M")
utc = utc.replace(tzinfo=pytz.UTC)
pil = pid[-6:]
root = {"products": []}
acursor.execute(
"""
SELECT data from products where pil = %s and
entered = %s
""",
(pil, utc),
)
for row in acursor:
root["products"].append({"data": row[0]})
if cb is None:
data = json.dumps(root)
else:
data = "%s(%s)" % (html_escape(cb), json.dumps(root))
headers = [("Content-type", "application/json")]
start_response("200 OK", headers)
return [data.encode("ascii")]
def __call__(self, environ, start_response):
fields = parse_formvars(environ)
obj = self.find_object(self.root, environ)
response_body = obj(**fields.mixed())
start_response('200 OK', [('content-type', 'text/html')])
return [response_body]
def application(environ, start_response):
status = '200 OK'
output = b'Hello World!'
if environ["REQUEST_METHOD"] == "POST":
s = 3
post_env = environ.copy()
post_env['QUERY_STRING'] = ''
form = cgi.FieldStorage(fp=environ['wsgi.input'],
environ=post_env,
keep_blank_values=True)
#output = b''+form["word"].value
#output = form.getvalue('word')
#output = str.encode(output)
content_length = int(environ['CONTENT_LENGTH'])
output = environ['wsgi.input'].read(content_length)
fields = request.parse_formvars(environ)
field = fields['word']
## output = str.encode(fields)
#temp = parse_qs(output)
#temp = parse_qs(environ['QUERY_STRING'])
#output = temp.get('word',[''])[0]
#output = str.encode(output)
#output = output.word.value #can't get it to work with forms :/
#print(b'bloop')
## #form = cgi.FieldStorage()
## #q = form.getvalue('q')
##
response_headers = [('Content-type', 'text/plain'),
('Content-Length', str(len(output)))]
start_response(status, response_headers)
return [output]
def identify(self, environ):
if environ['PATH_INFO'] == self.login_handler_path:
## We are on the URL where repoze.who processes authentication. ##
form = parse_formvars(environ)
try:
credentials = {
'login': form['login'],
'password': form['password']
}
except KeyError:
credentials = None
# destination is the post-login page
destination = self._get_full_path(self.post_login_url, environ)
# all variables from query string are kept in query string
destination = self._replace_qs(destination, environ.get('QUERY_STRING'))
environ['repoze.who.application'] = HTTPFound(destination)
return credentials
elif environ['PATH_INFO'] == self.logout_handler_path:
## We are on the URL where repoze.who logs the user out. ##
# let's throw an exception to get challenged
environ['repoze.who.application'] = HTTPUnauthorized()
return None
def application(environ, start_response):
"""Answer request."""
fields = parse_formvars(environ)
feedtype = fields.get("feedtype", "IDS|DDPLUS").upper()[:32]
cb = fields.get("callback")
service = fields.get("service", "geojson")
mckey = "/services/idd.py?service=%s&feedtype=%saa" % (service, feedtype)
mc = memcache.Client(["localhost:11211"], debug=0)
res = mc.get(mckey)
if not res:
if service == "geojson":
res = run(feedtype)
expire = 180
else:
res = stats()
expire = 3600
mc.set(mckey, res, expire)
if cb is None:
data = res
else:
data = "%s(%s)" % (cb, res)
headers = [("Content-type", "application/vnd.geo+json")]
start_response("200 OK", headers)
return [data.encode("ascii", "ignore")]
def __call__(self, environ, start_response):
fields = parse_formvars(environ)
print(fields)
obj = self.find_object(self.root, environ)
response_body = obj(**fields.mixed())
start_response('200 OK', [('content-type', 'text/html')])
return [response_body]
def _parse_params(self, environ):
# Try to find the parameters in various sources,
# reflecting preference order:
# Query string
params = dict(parse_querystring(environ))
# POST body
request = Request(environ)
if request.content_type == 'application/x-www-form-urlencoded':
body = request.body
params.update(parse_formvars(environ, include_get_vars=False))
request.body = body
# Authorization header
auth_header = AUTHORIZATION(environ)
if auth_header:
try:
params.update(oauth2.Request._split_header(auth_header))
except:
pass
# Remove the non-oauth params
if params:
for key in params.keys():
if not (key.startswith('oauth_') or key == 'realm'):
del params[key]
return dict(params)
def _parse_params(self, environ):
# Try to find the parameters in various sources,
# reflecting preference order:
# Query string
params = dict(parse_querystring(environ))
# POST body
request = Request(environ)
if request.content_type == 'application/x-www-form-urlencoded':
body = request.body
params.update(parse_formvars(environ, include_get_vars=False))
request.body = body
# Authorization header
auth_header = AUTHORIZATION(environ)
if auth_header:
try:
params.update(oauth2.Request._split_header(auth_header))
except:
pass
# Remove the non-oauth params
if params:
for key in params.keys():
if not (key.startswith('oauth_') or key == 'realm'):
del params[key]
return dict(params)
def get_context(environ):
"""Figure out the CGI variables passed to this script"""
form = parse_formvars(environ)
if "year" in form:
year1 = form.get("year")
year2 = year1
else:
year1 = form.get("year1")
year2 = form.get("year2")
month1 = form.get("month1")
month2 = form.get("month2")
day1 = form.get("day1")
day2 = form.get("day2")
hour1 = form.get("hour1")
hour2 = form.get("hour2")
minute1 = form.get("minute1")
minute2 = form.get("minute2")
sts = utc(int(year1), int(month1), int(day1), int(hour1), int(minute1))
ets = utc(int(year2), int(month2), int(day2), int(hour2), int(minute2))
if ets < sts:
sts, ets = ets, sts
radar = form.getall("radar")
fmt = form.get("fmt", "shp")
return dict(sts=sts, ets=ets, radar=radar, fmt=fmt)
def application(environ, start_response):
"""Answer request."""
fields = parse_formvars(environ)
if environ["REQUEST_METHOD"] not in ["GET", "POST"]:
headers = [("Content-type", "text/plain")]
start_response("500 Internal Server Error", headers)
data = "Invalid Request"
return [data.encode("ascii")]
cb = fields.get("callback")
mckey = "/json/tms.json"
mc = memcache.Client(["iem-memcached:11211"], debug=0)
res = mc.get(mckey)
if not res:
res = run()
mc.set(mckey, res, 15)
if cb is None:
data = res
else:
data = "%s(%s)" % (html_escape(cb), res)
headers = [("Content-type", "application/json")]
start_response("200 OK", headers)
return [data.encode("ascii")]
def application(environ, start_response):
"""Answer request."""
fields = parse_formvars(environ)
if environ["REQUEST_METHOD"] not in ["GET", "POST"]:
headers = [("Content-type", "text/plain")]
start_response("500 Internal Server Error", headers)
data = "Invalid Request"
return [data.encode("ascii")]
operation = fields.get("operation", "list")
callback = fields.get("callback")
data = ""
if callback is not None:
data += "%s(" % (html_escape(callback), )
if operation == "list":
data += json.dumps(list_files(fields))
elif operation == "available":
data += json.dumps(available_radars(fields))
elif operation == "products":
data += json.dumps(list_products(fields))
if callback is not None:
data += ")"
headers = [("Content-type", "application/json")]
start_response("200 OK", headers)
return [data.encode("ascii")]
def application(environ, start_response):
"""Answer request."""
fields = parse_formvars(environ)
station = fields.get("station", "AMW")
network = fields.get("network", "IA_ASOS")
date = fields.get("date", "2016-01-01")
cb = fields.get("callback", None)
hostname = os.environ.get("SERVER_NAME", "")
mckey = "/json/obhistory/%s/%s/%s" % (station, network, date)
mc = memcache.Client(["iem-memcached:11211"], debug=0)
res = mc.get(mckey) if hostname != "iem.local" else None
if not res:
res = workflow(station, network, date).replace("NaN", "null")
mc.set(mckey, res, 3600)
if cb is None:
data = res
else:
data = "%s(%s)" % (html_escape(cb), res)
headers = [("Content-type", "application/json")]
start_response("200 OK", headers)
return [data.encode("ascii")]
def application(environ, start_response):
"""Do Workflow"""
headers = [("Content-type", "application/vnd.geo+json")]
form = parse_formvars(environ)
group = form.get("group", "coop")
cb = form.get("callback", None)
dt = form.get("dt", datetime.date.today().strftime("%Y-%m-%d"))
ts = datetime.datetime.strptime(dt, "%Y-%m-%d")
ts = ts.replace(hour=12, tzinfo=pytz.utc)
mckey = "/geojson/7am/%s/%s" % (dt, group)
mc = memcache.Client(["iem-memcached:11211"], debug=0)
res = mc.get(mckey)
if not res:
res = router(group, ts)
mc.set(mckey, res, 15)
if cb is None:
data = res
else:
data = "%s(%s)" % (html_escape(cb), res)
start_response("200 OK", headers)
return [data.encode("ascii")]
def identify(self, environ):
path_info = environ['PATH_INFO']
query = parse_dict_querystring(environ)
# This will handle the logout request.
if path_info == self._logout_url:
# set in environ for self.challenge() to find later
environ['repoze.who.application'] = HTTPUnauthorized()
return None
elif path_info == self._login_url:
form = parse_formvars(environ)
form.update(query)
try:
credentials = {
'login': form['login'],
'password': form['password']
}
except KeyError:
credentials = None
def auth_resp(environ, start_response):
import json
resp = {"success": True}
resp_str = json.dumps(resp)
content_length = CONTENT_LENGTH.tuples(str(len(resp_str)))
content_type = CONTENT_TYPE.tuples('application/json')
headers = content_length + content_type
start_response('200 OK', headers)
return [resp_str]
environ['repoze.who.application'] = auth_resp
return credentials
def application(environ, start_response):
"""Answer request."""
fields = parse_formvars(environ)
state = fields.get("state", "IA")[:2]
year = int(fields.get("year", 2015))
phenomena = fields.get("phenomena", "SV")[:2]
significance = fields.get("significance", "W")[:1]
cb = fields.get("callback")
mckey = "/json/vtec_events_bystate/%s/%s/%s/%s" % (
state,
year,
phenomena,
significance,
)
mc = memcache.Client(["iem-memcached:11211"], debug=0)
res = mc.get(mckey)
if not res:
res = run(state, year, phenomena, significance)
mc.set(mckey, res, 60)
if cb is None:
data = res
else:
data = "%s(%s)" % (html_escape(cb), res)
headers = [("Content-type", "application/json")]
start_response("200 OK", headers)
return [data.encode("ascii")]
def mainApp(environ, start_response):
global requestCount
requestCount += 1
fields = parse_formvars(environ)
method = environ["REQUEST_METHOD"]
path = (environ.get("SCRIPT_NAME", "") + environ.get("PATH_INFO", ""))
options = environ.get("options", {})
host = environ["SERVER_NAME"]
port = environ["SERVER_PORT"]
#print "host='%s', port='%s'" % (host,port)
errors = environ["wsgi.errors"]
args = fields.mixed()
filenames = {}
for k, v in args.iteritems():
if type(v) is types.InstanceType:
filenames[k] = v
cookies = environ.get("HTTP_COOKIE", "")
if cookies.find("=")!=-1:
cookies = dict([cookie.split("=") for cookie in cookies.split("; ")])
else:
cookies = {}
sessionId = cookies.get("SESSION", None)
requestData = serverRequestData(path=path, method=method, args=args, \
session=None, sessionId=sessionId, filenames=filenames, port=port)
responseData = serverResponseData()
threadName = threading.currentThread().getName()
timeStr = time.strftime("%H:%M.%S")
if path.startswith("/testing/"):
getTestData(fields, environ, requestData, responseData, cookies)
else:
global iceRequest
if iceRequest is None:
baseUrl = "http://%s:%s/" % (host, port)
iceRequest = ice_request.iceRequest(baseUrl=baseUrl)
IceCommon.isServer = True
gTime.setup()
gTime.mark("Start request")
iceRequest.processRequest(requestData, responseData) #, request
#responseData.contentType = "text/html"
#responseData.write("TestingTwo")
gTime.stopAll()
if gTime.isHtmlPage:
if gTime.enabled:
print gTime
else:
print "Done."
contentType = responseData.contentType
data = responseData.data
#contentType = "text/html"
#data = "Testing one"
start_response("200 OK", [("content-type", contentType), \
("Set-Cookie", "SESSION=%s" % requestData.sessionId)])
return [data]
def caller(func, *args, **kargs):
perm()
# Remove login credentials
form = parse_formvars(request.environ, include_get_vars=True)
if form.pop('do_login__', None):
form.pop('login', None)
form.pop('password', None)
return func(*args, **kargs)
def app(environ, start_response):
fields = parse_formvars(environ)
if environ["REQUEST_METHOD"] == "POST":
start_response("200 OK", [("content-type", "text/html")])
return ["Hello", fields["name"], "!"]
else:
start_response("200 OK", [("content-type", "text/html")])
return ['<form method="POST">Name:<input type="text" ' 'name="name"><input type="submit"></form>']
def app(environ, start_response):
fields = parse_formvars(environ)
path = environ['PATH_INFO']
Separators = re.compile('/')
PathList = Separators.split(path)
#print len(PathList)
if path == "/":
start_response('200 OK', [('content-type', 'text/html')])
return ['<center> Welcome to Hot-Pi. </br> Call set/pi#/<number>/ to set a temp </br> Call get/pi# to get the temp</br> Call get_plan/pi# to get the policy</center>']
elif PathList[1] == "set":
pinum = PathList[2]
temp = float(PathList[3])
start_response('200 OK', [('content-type', 'text/xml')])
pydict[pinum] = temp
return ['<pi>'+'<pinumber>'+str(pinum)+'</pinumber><temp>'+ str(temp)+'</temp></pi>']
elif PathList[1] == "set_ambient_temperature":
pinum = PathList[2]
temp = float(PathList[3])
start_response('200 OK', [('content-type', 'text/xml')])
pydictA[pinum] = temp
return ['<pi>'+'<pinumber>'+str(pinum)+'</pinumber><AmbientTemp>'+ str(temp)+'</AmbientTemp></pi>']
elif PathList[1] == "get":
start_response('200 OK', [('content-type', 'text/xml')])
pinum = PathList[2]
if pinum in pydict:
return [str(pydict[pinum])] #['<pi>'+'<pinumber>'+str(pinum)+'</pinumber><temp>'+ str(pydict[pinum])+'</temp></pi>']
else:
return ['<pi>'+'<pinumber>'+str(pinum)+'</pinumber><temp>NO TEMP</temp></pi>']
elif PathList[1] == "get_plan":
start_response('200 OK', [('content-type', 'text/xml')])
pinum = PathList[2]
if pinum in pydict:
print getWeatherUndergroundForecastArray()
return ['<pi>'+'<pinumber>'+str(pinum)+'</pinumber><temp>'+ str(pydict[pinum])+'</temp></pi>']
else:
return ['<pi>'+'<pinumber>'+str(pinum)+'</pinumber><temp>NO Policy</temp></pi>']
else:
start_response('200 OK', [('content-type', 'text/xml')])
return ['<error> Not a valid request. For information about our API service please check our web site at http://www.intelligence.tuc.gr/renes. </error>']
def authenticate(self, environ, identity):
log.info('In authenticate()')
def set_error(msg):
log.info(msg)
err = 1
environ['FAS_AUTH_ERROR'] = err
# HTTPForbidden ?
err_app = HTTPFound(err_goto + '?' +
'came_from=' + quote_plus(came_from))
environ['repoze.who.application'] = err_app
err_goto = '/login'
default_came_from = '/'
if 'SCRIPT_NAME' in environ:
sn = environ['SCRIPT_NAME']
err_goto = sn + err_goto
default_came_from = sn + default_came_from
query = parse_dict_querystring(environ)
form = parse_formvars(environ)
form.update(query)
came_from = form.get('came_from', default_came_from)
try:
auth_params = {'username': identity['login'],
'password': identity['password']}
except KeyError:
try:
auth_params = {'session_id': identity['session_id']}
except:
# On error we return None which means that auth failed
set_error('Parameters for authenticating not found')
return None
try:
user_data = self._retrieve_user_info(environ, auth_params)
except AuthError as e:
set_error('Authentication failed: %s' % exception_to_bytes(e))
log.warning(e)
return None
except Exception as e:
set_error('Unknown auth failure: %s' % exception_to_bytes(e))
return None
if user_data:
try:
del user_data[1]['password']
environ['CSRF_AUTH_SESSION_ID'] = user_data[0]
return user_data[1]['username']
except ValueError:
set_error('user information from fas not in expected format!')
return None
except Exception:
pass
set_error('An unknown error happened when trying to log you in.'
' Please try again.')
return None
def __call__(self, environ, start_response):
# log form fields
pprint(parse_formvars(environ))
# response
# TODO: to format as ushahidi do
start_response('200 OK', [('content-type', 'application/json')])
#pprint(environ)
#import pdb; pdb.set_trace()
if environ.get('REQUEST_METHOD','') == 'POST':
result = { "payload": {
"domain": environ.get('HTTP_ORIGIN'),
"success":"true"
},
"error":{ "code":"0",
"message":"No Error"}
}
elif environ.get('REQUEST_METHOD','') == 'GET' and \
environ.get('QUERY_STRING', '') == 'task=categories':
result = { "payload": {
"domain": environ.get('HTTP_ORIGIN'),
"categories":[
{"category":
{ "id":"1",
"parent_id":"0",
"title":"Category 1",
"description":"Category 1",
"color":"9900CC","position":"0"}},
{"category":
{ "id":"2",
"parent_id":"0",
"title":"Category 2",
"description":"Category 2",
"color":"3300FF",
"position":"0"}},
{"category":
{ "id":"3",
"parent_id":"0",
"title":"Category 3",
"description":"Category 3",
"color":"663300",
"position":"0"}},
{"category":
{ "id":"4",
"parent_id":"0",
"title":"Trusted Reports",
"description":"Reports from trusted reporters",
"color":"339900","position":"0"}}
]},
"error":{"code":"0","message":"No Error"}
}
else:
result = {"status": "ok", "now": int(time.time())}
return json.dumps(result)
def __call__(self, env, start_response):
'''Handle HTTP request per `WSGI`__.
__ http://www.python.org/dev/peps/pep-0333/
:param env: access to HTTP request
:type env: Dict[String, String]
:param start_response: access to start HTTP response
:type start_response: (String, Seq[(String, String)]) => Unit
:rtype: Iterable[String]
.. note:: We ignore extra HTTP request parameters.
'''
if env['REQUEST_METHOD'] != 'POST':
start_response('405 method not allowed',
[('content-type', 'text/plain')])
log.error('app called with non-POST method: %s',
env['REQUEST_METHOD'])
return ['Bzzt. We only do POST.']
args = parse_formvars(env)
identity = lambda x: x
try:
[username, password] = [
args.pop(k) for k in self.mandatory_params]
log.info('Request from %s.', username)
mvalues = dict([
(k, (txform or identity)(args[k]))
for (k, txform) in self._sub_params])
except (KeyError, ValueError) as ex:
start_response('400 bad request',
[('content-type', 'text/plain')])
log.error('incorrect credentials for %s', username)
return ['Incorrect parameters:', str(ex)]
self._log_request(username, dict(args))
try:
#log.info('env=%s', env)
#log.info('start_response=%s', start_response)
#log.info('username=%s', username)
#log.info('password=%s', password)
#log.info('mvalues=%s', mvalues)
return self._subApp(env, start_response,
username, password,
**mvalues)
except NotAuthorized:
start_response('403 not authorized',
[('content-type', 'text/plain')])
return ['incorrect credentials']
# For debugging, catch IOError instead
except Exception, ex:
log.critical('Error:', exc_info=ex)
start_response('500 I tried.',
[('content-type', 'text/plain')])
return ['error:', str(ex)]
def handle_post_request(environ, start_response):
if environ["PATH_INFO"] in router:
path = environ["PATH_INFO"]
fields = parse_formvars(environ)
start_response("200 OK", [("content-type", "text/html")])
return router[path].post(fields)
else:
start_response("200 OK", [("content-type", "text/html")])
return ["ERROR 404"]
def application(environ, start_response):
form = request.parse_formvars(environ, include_get_vars=True)
status = "200 OK"
form["environ"] = environ
try:
res = func(*args, **form.mixed())
except ValueError, ve:
status = "500 Server Error"
res = "<html>There was an error: %s</html>" % html_quote(ve)
def identify(self, environ):
form = parse_formvars(environ, include_get_vars=False)
if form.get(self.login_form_qs, None):
try:
login = form['login']
password = form['password']
except KeyError:
return None
return dict(login=login, password=password)
def app(environ, start_response):
fields = parse_formvars(environ)
if environ['REQUEST_METHOD'] == 'POST':
start_response('200 OK', [('content-type', 'text/html')])
return ['<h1>Hello, ', fields['name'], '!</h1>']
else:
start_response('200 OK', [('content-type', 'text/html')])
return ['<form method="POST">Name: <input type="text" '
'name="name"><input type="submit"></form>']
def analyse(env):
if (env['REQUEST_METHOD'] == 'POST'):
fields = request.parse_formvars(env)
input_data = json.loads(fields.get('input', '[]'))
# I dunno lol
return json.dumps({"decision": "REPORT", "cheatPercent": len(input_data)})
else:
return json.dumps({"decision": "NO-ACTION", "cheatPercent": 0})
def start_tests(self,environ,start_response):
param_string = parse_formvars(environ)['params']
try:
self.parse_settings(param_string)
SeleniumStarter().start()
start_response('200 Ok', [('content-type', 'text/html')])
return ["OK"]
except Exception as e:
start_response('200 Ok', [('content-type', 'text/html')])
return ["ERROR"]
def wsgiHandler (environ, start_response, service):
from paste.request import parse_formvars
try:
path_info = host = ""
if "PATH_INFO" in environ:
path_info = environ["PATH_INFO"]
if "HTTP_X_FORWARDED_HOST" in environ:
host = "http://" + environ["HTTP_X_FORWARDED_HOST"]
elif "HTTP_HOST" in environ:
host = "http://" + environ["HTTP_HOST"]
host += environ["SCRIPT_NAME"]
req_method = environ["REQUEST_METHOD"]
fields = parse_formvars(environ)
format, image = service.dispatchRequest( fields, path_info, req_method, host )
headers = [('Content-Type',format)]
if format.startswith("image/"):
if service.cache.sendfile:
headers.append(('X-SendFile', image))
if service.cache.expire:
headers.append(('Expires', email.Utils.formatdate(time.time() + service.cache.expire, False, True)))
# Hack start. Expire added to layers
if format.startswith("image/"):
if service.cache.sendfile:
headers.append(('X-SendFile', image))
layer_expire = None
if fields.has_key('layers') or fields.has_key('LAYERS'):
layers = fields.get('layers', fields.get('LAYERS'))
# single layers only
if not ',' in layers:
layer = service.layers[layers]
if layer.expire:
layer_expire = long(layer.expire)
headers.append(('Expires', email.Utils.formatdate(time.time() + layer_expire, False, True)))
if service.cache.expire and not layer_expire:
headers.append(('Expires', email.Utils.formatdate(time.time() + service.cache.expire, False, True)))
# Hack end
start_response("200 OK", headers)
if service.cache.sendfile and format.startswith("image/"):
return []
else:
return [image]
except TileCacheException, E:
start_response("404 Tile Not Found"+str(E), [('Content-Type','text/plain')])
return ["An error occurred: %s" % (str(E))]
def define(env):
if (env['REQUEST_METHOD'] == 'POST'):
fields = request.parse_formvars(env)
input_data = json.loads(fields.get('input', '[]'))
client = MongoClient()
db = client.tensorFlow
collection = db.gameData
collection.insert(input_data)
return json.dumps({"nbAdded": len(input_data)})
else:
return json.dumps({"nbAdded": 0})
def __call__(self, environ, start_response):
fields = parse_formvars(environ)
obj = self.find_object(self.root, environ)
response_body = "as per usual"
if obj:
try:
response_body = obj(**fields.mixed())
start_response('200 OK', [('content-type', 'text/html')])
except:
start_response('400 Bad Request', [('content-type', 'text/html')])
else:
start_response('400 Bad Request', [('content-type', 'text/html')])
return response_body
def render(environ,start_response):
fields = parse_formvars(environ)
start_response('200 OK', [('content-type', 'text/html')])
##
env = jinja2.Environment(loader=jinja2.DictLoader(tmpls))
ctx = dict()
ctx["title"] = "Processes"
#ps = sp.Popen(["ps","aux"],stdout=sp.PIPE)
ps = sp.Popen(["ps","-A","-F","-w","--sort=-rss"],stdout=sp.PIPE)
ctx["pslist"] = cgi.escape(ps.communicate()[0])
##
apage = env.get_template("page_pslist")
return apage.render(ctx)
