def test_get_ip_no_proxies(self):
Config.num_proxies = 0
request = Request(Environ(REMOTE_ADDR="1.2.3.4"))
ip = BaseHandler.get_ip(request)
self.assertEqual("1.2.3.4", ip)
def wsgi_app(self, environ, start_response):
request = Request(environ)
response = self.dispatch_request(request)
return response(environ, start_response)
def _get_werkzeug_request(path):
builder = EnvironBuilder(path=path)
env = builder.get_environ()
return Request(env)
def set_request(**kwargs): from werkzeug.test import EnvironBuilder from werkzeug.wrappers import Request builder = EnvironBuilder(**kwargs) frappe.local.request = Request(builder.get_environ())
def prepare_asset(request):
req = Request(request.environ)
data = None
# For backward compatibility
try:
data = json.loads(req.data)
except ValueError:
data = json.loads(req.form['model'])
except TypeError:
data = json.loads(req.form['model'])
def get(key):
val = data.get(key, '')
if isinstance(val, unicode):
return val.strip()
elif isinstance(val, basestring):
return val.strip().decode('utf-8')
else:
return val
if not all([get('name'), get('uri'), get('mimetype')]):
raise Exception("Not enough information provided. Please specify 'name', 'uri', and 'mimetype'.")
asset = {
'name': get('name'),
'mimetype': get('mimetype'),
'asset_id': get('asset_id'),
'is_enabled': get('is_enabled'),
'is_processing': get('is_processing'),
'nocache': get('nocache'),
}
uri = get('uri')
if uri.startswith('/'):
if not path.isfile(uri):
raise Exception("Invalid file path. Failed to add asset.")
else:
if not validate_url(uri):
raise Exception("Invalid URL. Failed to add asset.")
if not asset['asset_id']:
asset['asset_id'] = uuid.uuid4().hex
if uri.startswith('/'):
os.rename(uri, path.join(settings['assetdir'], asset['asset_id']))
uri = path.join(settings['assetdir'], asset['asset_id'])
if 'youtube_asset' in asset['mimetype']:
uri, asset['name'], asset['duration'] = download_video_from_youtube(uri, asset['asset_id'])
asset['mimetype'] = 'video'
asset['is_processing'] = 1
asset['uri'] = uri
if "video" in asset['mimetype']:
if get('duration') == 'N/A' or int(get('duration')) == 0:
asset['duration'] = int(get_video_duration(uri).total_seconds())
else:
# Crashes if it's not an int. We want that.
asset['duration'] = int(get('duration'))
# parse date via python-dateutil and remove timezone info
if get('start_date'):
asset['start_date'] = date_parser.parse(get('start_date')).replace(tzinfo=None)
else:
asset['start_date'] = ""
if get('end_date'):
asset['end_date'] = date_parser.parse(get('end_date')).replace(tzinfo=None)
else:
asset['end_date'] = ""
return asset
def set_request(**kwargs):
builder = EnvironBuilder(**kwargs)
frappe.local.request = Request(builder.get_environ())
def __call__(self, environ, start_response):
if environ["REQUEST_METHOD"] in ["POST", "DELETE", "PUT", "PATCH"]:
request = Request(environ, shallow=True)
self.logger.debug(request.headers)
return self.app(environ, start_response)
def wsgi_app(self, environ, start_response):
"""Execute this instance as a WSGI application.
See the PEP for the meaning of parameters. The separation of
__call__ and wsgi_app eases the insertion of middlewares.
"""
request = Request(environ)
request.encoding_errors = "strict"
# The problem here is that we'd like to send an infinite stream
# of events, but WSGI has been designed to handle only finite
# responses. Hence, to do this we will have to "abuse" the API
# a little. This works well with gevent's pywsgi implementation
# but it may not with others (still PEP-compliant). Therefore,
# just to be extra-safe, we will terminate the response anyway,
# after a long timeout, to make it finite.
# The first such "hack" is the mechanism to trigger the chunked
# transfer-encoding. The PEP states just that "the server *may*
# use chunked encoding" to send each piece of data we give it,
# if we don't specify a Content-Length header and if both the
# client and the server support it. According to the HTTP spec.
# all (and only) HTTP/1.1 compliant clients have to support it.
# We'll assume that the server software supports it too, and
# actually uses it (gevent does!) even if we have no way to
# check it. We cannot try to force such behavior as the PEP
# doesn't even allow us to set the Transfer-Encoding header.
# The second abuse is the use of the write() callable, returned
# by start_response, even if the PEP strongly discourages its
# use in new applications. We do it because we need a way to
# detect when the client disconnects, and we hope to achieve
# this by seeing when a call to write() fails, i.e. raises an
# exception. This behavior isn't documented by the PEP, but it
# seems reasonable and it's present in gevent (which raises a
# OSError).
# The third non-standard behavior that we expect (related to
# the previous one) is that no one in the application-to-client
# chain does response buffering: neither any middleware nor the
# server (gevent doesn't!). This should also hold outside the
# server realm (i.e. no proxy buffering) but that's definitely
# not our responsibility.
# The fourth "hack" is to avoid an error to be printed on the
# logs. If the client terminates the connection, we catch and
# silently ignore the exception and return gracefully making
# the server try to write the last zero-sized chunk (used to
# mark the end of the stream). This will fail and produce an
# error. To avoid this we detect if we're running on a gevent
# server and make it "forget" this was a chunked response.
# Check if the client will understand what we will produce.
if request.accept_mimetypes.quality("text/event-stream") <= 0:
return NotAcceptable()(environ, start_response)
# Initialize the response and get the write() callback. The
# Cache-Control header is useless for conforming clients, as
# the spec. already imposes that behavior on them, but we set
# it explicitly to avoid unwanted caching by unaware proxies and
# middlewares.
write = start_response(
"200 OK", [("Content-Type", "text/event-stream; charset=utf-8"),
("Cache-Control", "no-cache")])
# This is a part of the fourth hack (see above).
if hasattr(start_response, "__self__") and \
isinstance(start_response.__self__, WSGIHandler):
handler = start_response.__self__
else:
handler = None
# One-shot means that we will terminate the request after the
# first batch of sent events. We do this when we believe the
# client doesn't support chunked transfer. As this encoding has
# been introduced in HTTP/1.1 (as mandatory!) we restrict to
# requests in that HTTP version. Also, if it comes from an
# XMLHttpRequest it has been probably sent from a polyfill (not
# from the native browser implementation) which will be able to
# read the response body only when it has been fully received.
if environ["SERVER_PROTOCOL"] != "HTTP/1.1" or request.is_xhr:
one_shot = True
else:
one_shot = False
# As for the Server-Sent Events [1] spec., this is the way for
# the client to tell us the ID of the last event it received
# and to ask us to send it the ones that happened since then.
# [1] http://www.w3.org/TR/eventsource/
# The spec. requires implementations to retry the connection
# when it fails, adding the "Last-Event-ID" HTTP header. But in
# case of an error they stop, and we have to (manually) delete
# the EventSource and create a new one. To obtain that behavior
# again we give the "last_event_id" as a URL query parameter
# (with lower priority, to have the header override it).
last_event_id = request.headers.get("Last-Event-ID")
if last_event_id is None:
last_event_id = request.args.get("last_event_id")
# We subscribe to the publisher to receive events.
sub = self._pub.get_subscriber(last_event_id)
# Send some data down the pipe. We need that to make the user
# agent announces the connection (see the spec.). Since it's a
# comment it will be ignored.
write(b":\n")
# XXX We could make the client change its reconnection timeout
# by sending a "retry:" line.
# As a last line of defence from very bad-behaving servers we
# don't want to the request to last longer than _GLOBAL_TIMEOUT
# seconds (see above). We use "False" to just cause the control
# exit the with block, instead of raising an exception.
with Timeout(self._GLOBAL_TIMEOUT, False):
# Repeat indefinitely.
while True:
# Proxies often have a read timeout. We try not to hit
# it by not being idle for more than _PING_TIMEOUT
# seconds, sending a ping (i.e. a comment) if there's
# no real data.
try:
with Timeout(self._PING_TIMEOUT):
data = b"".join(sub.get())
got_sth = True
except Timeout:
data = b":\n"
got_sth = False
try:
with Timeout(self._WRITE_TIMEOUT):
write(data)
# The PEP doesn't tell what has to happen when a write
# fails. We're conservative, and allow any unexpected
# event to interrupt the request. We hope it's enough
# to detect when the client disconnects. It is with
# gevent, which raises an OSError. The timeout (we
# catch that too) is just an extra precaution.
except Exception:
# This is part of the fourth hack (see above).
if handler is not None:
handler.response_use_chunked = False
break
# If we decided this is one-shot, stop the long-poll as
# soon as we sent the client some real data.
if one_shot and got_sth:
break
# An empty iterable tells the server not to send anything.
return []
def application(environ, start_response):
request = Request(environ)
response = dispatch(request)
return response(environ, start_response)
def wsgi(self, environ, start_response):
return self.dispatch(Request(environ))(environ, start_response)
def get_response(ip, forwarded=None):
req_dict = {'REMOTE_ADDR': ip}
if forwarded:
req_dict['HTTP_X_FORWARDED_FOR'] = forwarded
return protected(None, Request(req_dict))
def multi_value_post_app(environ, start_response):
req = Request(environ)
assert req.form["field"] == "val1", req.form["field"]
assert req.form.getlist("field") == ["val1", "val2"], req.form.getlist("field")
response = Response("ok")
return response(environ, start_response)
def sessionmanager(environ):
_requests.request = Request(environ)
yield
_requests.request = None
def test_parse_body(self):
request = Request({})
request.form = {"foo": "bar"}
body = self.handler.parse_body(request)
self.assertEqual("bar", body["foo"])
def wsgi_handler(environ, start_response):
"""The wsgi entry point to the API."""
response = request_handler(Request(environ))
return response(environ, start_response)
def prepare_asset_v1_2(request, asset_id=None):
req = Request(request.environ)
if six.PY2:
data = json.loads(req.data)
else:
if isinstance(req.data, six.binary_type):
data = json.loads(req.data.decode())
else:
data = json.loads(req.data)
def get(key):
val = data.get(key, '')
if isinstance(val, unicode):
return val.strip()
elif isinstance(val, six.binary_type):
return val.strip().decode('utf-8')
else:
return val
if not all([
get('name'),
get('uri'),
get('mimetype'),
str(get('is_enabled')),
get('start_date'),
get('end_date')
]):
raise Exception(
"Not enough information provided. Please specify 'name', 'uri', 'mimetype', 'is_enabled', 'start_date' and 'end_date'."
) # noqa
asset = {
'name': get('name'),
'mimetype': get('mimetype'),
'is_enabled': get('is_enabled'),
'nocache': get('nocache')
}
uri = get('uri')
if uri.startswith('/'):
if not path.isfile(uri):
raise Exception("Invalid file path. Failed to add asset.")
else:
if not validate_url(uri):
raise Exception("Invalid URL. Failed to add asset.")
if not asset_id:
asset['asset_id'] = uuid.uuid4().hex
if uri.startswith('/'):
rename(uri, path.join(settings['assetdir'], asset['asset_id']))
uri = path.join(settings['assetdir'], asset['asset_id'])
if 'youtube_asset' in asset['mimetype']:
uri, asset['name'], asset['duration'] = download_video_from_youtube(
uri, asset['asset_id'])
asset['mimetype'] = 'video'
asset['is_processing'] = 1
asset['uri'] = uri
if "video" in asset['mimetype']:
if get('duration') == 'N/A' or int(get('duration')) == 0:
asset['duration'] = int(get_video_duration(uri).total_seconds())
elif get('duration'):
# Crashes if it's not an int. We want that.
asset['duration'] = int(get('duration'))
else:
asset['duration'] = 10
asset['play_order'] = get('play_order') if get('play_order') else 0
# parse date via python-dateutil and remove timezone info
asset['start_date'] = date_parser.parse(
get('start_date')).replace(tzinfo=None)
asset['end_date'] = date_parser.parse(get('end_date')).replace(tzinfo=None)
return asset
def __call__(self, environ, start_response):
request = Request(environ)
# print("chay middleware.......", request.headers.get("Authorization"))
return self.app(environ, start_response)
def wsgi_app(self, environ, start_response):
request = Request(environ)
response = self.dispatch_request(request)
request.client_session.save_cookie(response)
return response(environ, start_response)
def set_request(**kwargs):
builder = EnvironBuilder(**kwargs)
dataent.local.request = Request(builder.get_environ())
def myApp(self, env, start_response):
# Create a request object
request = Request(env)
response = self.dispatch_request(request)
return response(env, start_response)
def wsgi_app(self, environ, start_response):
request = Request(environ)
response = self.route(request)
return response(environ, start_response)
def __call__(self, environ, start_response):
return self.handle_req(Request(environ), environ, start_response)
def redirect_strip_matched_path(environ, start_response):
request = Request(environ)
path = request.path
if request.query_string:
path += "?" + request.query_string
return redirect(path, code=301)
def prepare_asset(request):
req = Request(request.environ)
data = None
data = json.loads(req.form['model']) if 'model' in req.form else req.form
def get(key):
val = data.get(key, '')
if isinstance(val, unicode):
return val.strip()
elif isinstance(val, basestring):
return val.strip().decode('utf-8')
else:
return val
if all([
get('name'),
get('uri') or req.files.get('file_upload'),
get('mimetype')
]):
asset = {
'name': get('name'),
'mimetype': get('mimetype'),
'asset_id': get('asset_id'),
'is_enabled': get('is_enabled'),
'nocache': get('nocache'),
}
uri = get('uri') or False
if not asset['asset_id']:
asset['asset_id'] = uuid.uuid4().hex
try:
file_upload = req.files.get('file_upload')
filename = file_upload.filename
except AttributeError:
file_upload = None
filename = None
if filename and 'web' in asset['mimetype']:
raise Exception(
"Invalid combination. Can't upload a web resource.")
if uri and filename:
raise Exception(
"Invalid combination. Can't select both URI and a file.")
if uri and not uri.startswith('/'):
if not validate_url(uri):
raise Exception("Invalid URL. Failed to add asset.")
else:
asset['uri'] = uri
else:
asset['uri'] = uri
if filename:
asset['uri'] = path.join(settings['assetdir'], asset['asset_id'])
file_upload.save(asset['uri'])
if "video" in asset['mimetype']:
video_duration = get_video_duration(asset['uri'])
if video_duration:
asset['duration'] = int(video_duration.total_seconds())
else:
asset['duration'] = 'N/A'
else:
# Crashes if it's not an int. We want that.
asset['duration'] = int(get('duration'))
# parse date via python-dateutil and remove timezone info
if get('start_date'):
asset['start_date'] = date_parser.parse(
get('start_date')).replace(tzinfo=None)
else:
asset['start_date'] = ""
if get('end_date'):
asset['end_date'] = date_parser.parse(
get('end_date')).replace(tzinfo=None)
else:
asset['end_date'] = ""
if not asset['asset_id']:
raise Exception
if not asset['uri']:
raise Exception
return asset
else:
raise Exception(
"Not enough information provided. Please specify 'name', 'uri', and 'mimetype'."
)
def wsgi_app(self, environ, start_response):
route = self.router.bind_to_environ(environ)
try:
endpoint, args = route.match()
except HTTPException:
return NotFound()
try:
if endpoint == 'dbfile':
return self.dbfile_handler(environ, args)
except HTTPException as e:
return e
request = Request(environ)
if request.mimetype != 'application/json':
logger.warning('Request not in JSON')
data = dict()
else:
try:
data = json.load(request.stream)
except (ValueError, TypeError):
logger.warning('JSON parse error')
data = dict()
if 'first' in data and 'last' in data:
data['first'] = int(data['first'])
data['last'] = int(data['last'])
if data['first'] < 0 or data['first'] > data['last']:
return BadRequest()
with SessionGen() as local.session:
try:
username = data['username']
token = data['token']
local.participation = self.get_participation(username, token)
local.user = local.participation.user
except (BadRequest, KeyError):
local.user = None
if local.user is None:
local.access_level = 7 # Access level of unlogged user
else:
local.access_level = local.user.social_user.access_level
try:
local.data = data
local.resp = dict()
ans = getattr(self, args['target'] + '_handler')()
local.resp['success'] = 1
except AttributeError:
logger.error('Endpoint %s not implemented yet!' % endpoint)
logger.error(traceback.format_exc())
return NotFound()
except KeyError:
logger.error(traceback.format_exc())
return BadRequest()
response = Response()
response.mimetype = 'application/json'
response.status_code = 200
if ans is None:
response.data = json.dumps(local.resp)
else:
response.data = json.dumps({'success': 0, 'error': ans})
return response
def make_req_headers(**kwargs):
environ = create_environ('/collections/obs/items',
'http://localhost:5000/')
environ.update(kwargs)
request = Request(environ)
return request.headers
def __call__(self, environ, start_response):
request = Request(environ)
response = self.dispatch_request(request)
return response(environ, start_response)
def wsgi_app(self, environ, start_response):
#self.m_sessionDict = environ['werkzeug.session']
request = Request(environ)
response = self.dispatch_request(request)
return response(environ, start_response)
def __init__(self, environ):
self.request = Request(environ)
def test_get_file_content_no_file(self):
request = Request(Environ())
request.files = {}
self.assertIsNone(BaseHandler._get_file_content(request))