def application(self, environ, start_response):
req_webob = Request(environ)
res_webob = Response()
#addr tuple as glastopf expects it
remote_addr = (req_webob.remote_addr, int(environ["REMOTE_PORT"]))
if "SERVER_NAME" in environ and "SERVER_PORT" in environ:
# we could use socket.gethostbyname to get the ip...
sensor_addr = (environ["SERVER_NAME"], environ["SERVER_PORT"])
else:
sensor_addr = ("", "")
header, body = self.honeypot.handle_request(req_webob.as_text(),
remote_addr, sensor_addr)
header_list = header.splitlines()
try:
# format: http_version status_code description
res_webob.status_code = int(header_list[0].split()[1])
except ValueError:
# ['User-agent: *', 'Disallow:']
# default 200 OK
pass
for h in header_list:
if ":" in h:
h, v = h.split(":", 1)
res_webob.headers[str(h.strip())] = str(v.strip())
# this will adjust content-length header
res_webob.charset = "utf8"
res_webob.text = body.decode("utf-8", "ignore")
#WSGI applications are not allowed to create or modify hop-by-hop headers
self.remove_hop_by_hop_headers(res_webob.headers)
return res_webob(environ, start_response)
def jresponse(status,msg,req,status_int,headers=None,statusstr='',param=None):
data = {'status':str(status),'msg':str(msg)}
if param:
data.update(param)
container_list = json.dumps(data)
if headers:
ret = Response(body=container_list, request=req,headers=headers)
else:
ret = Response(body=container_list, request=req)
ret.content_type = 'application/json'
ret.charset = 'utf-8'
ret.status_int = status_int
if statusstr:
ret.status = statusstr
if status != '0' and req.method == 'PUT':
pass
# syslog.syslog(syslog.LOG_ERR,'jresponse: status: ' + str(status_int)+' path: '+str(req.path)+' msg: '+str(msg) + ' tx_id: '+ req.environ.get('swift.trans_id',''))
# print 'jresponse: status: ' + str(status_int)+' path: '+str(req.path)+' msg: '+str(msg) + ' tx_id: '+ req.environ.get('swift.trans_id','') + ' method: '+str(req.method) + ' headers: '+str(req.headers) + ' params: '+str(req.GET)
# traceback.print_stack()
# syslog.syslog(syslog.LOG_ERR,'jresponse: '+str(traceback.extract_stack() ))
# syslog.syslog(syslog.LOG_ERR,'jresponse: '+str(traceback.print_stack() ))
return ret
def application(self, environ, start_response):
req_webob = Request(environ)
res_webob = Response()
#addr tuple as glastopf expects it
remote_addr = (req_webob.remote_addr, int(environ["REMOTE_PORT"]))
if "SERVER_NAME" in environ and "SERVER_PORT" in environ:
# we could use socket.gethostbyname to get the ip...
sensor_addr = (environ["SERVER_NAME"], environ["SERVER_PORT"])
else:
sensor_addr = ("", "")
header, body = self.honeypot.handle_request(req_webob.as_text(),
remote_addr, sensor_addr)
for h in header.splitlines():
if ":" in h:
h, v = h.split(":", 1)
res_webob.headers[str(h.strip())] = str(v.strip())
# this will adjust content-length header
res_webob.charset = "utf8"
res_webob.text = body.decode("utf-8", "ignore")
#WSGI applications are not allowed to create or modify hop-by-hop headers
self.remove_hop_by_hop_headers(res_webob.headers)
return res_webob(environ, start_response)
def json(self, req):
resp = Response()
resp.content_type = 'text/javascript'
resp.charset = 'utf-8'
alias = req.params.get('alias')
url = req.params.get('url')
path_info = req.path_info.lstrip('/')
if path_info.startswith('json/stats'):
if alias:
c = get_stats(alias)
else:
c = Params(error='You must provide an alias !')
else:
if url:
c = self.add(req, url, alias)
else:
c = Params(error='You must provide an url !')
callback =req.params.get('callback')
if callback:
callback = str(callback)
arg = req.params.get('arg')
if arg:
resp.body = '%s(%s, %s);' % (callback, json.dumps(arg), json.dumps(c))
else:
resp.body = '%s(%s);' % (callback, json.dumps(c))
else:
resp.body = json.dumps(c)
return resp
def __call__(self, environ, start_response):
req = Request(environ)
path_info = req.path_info.lstrip('/')
if path_info.startswith('json'):
resp = self.json(req)
elif path_info.startswith('stats'):
resp = Response()
alias = [p for p in path_info.split('/')[1:] if p]
if alias:
alias = '/'.join(alias)
resp.body = self.stats.render(c=get_stats(alias))
elif path_info and path_info != 'new':
resp = self.redirect(req)
elif not path_info and self.redirect_url:
resp = exc.HTTPFound(location=self.redirect_url)
else:
resp = Response()
resp.content_type = 'text/html'
resp.charset = 'utf-8'
if req.GET.get('url'):
# save
alias = req.GET.get('alias')
alias = alias and alias or None
url = req.GET.get('url')
if url:
c = self.add(req, url, alias)
else:
c = Params(error='You must provide an url !')
else:
c = Params(url=req.GET.get('post',''))
c.title = req.params.get('title', '')
c.plugin = req.params.get('p', False)
resp.body = self.index.render(c=c)
return resp(environ, start_response)
def _render_atom_feed(request, mb, messages):
entries = []
for message in messages:
renderer = _get_atom_renderer(message, request)
if renderer is not None:
entries.append(renderer)
info = MailboxInfo.get(mb)
# absolute url for requested feed
feed_url = request.url
template_info = TemplateContext(request,
{'id': feed_url,
'self_link': feed_url,
'updated': datetime.utcnow(), # XXX
'title': info.title or request.context.get_mailbox_slug(mb.name),
'entries': entries,
})
res = HttpResponse(content_type='application/atom+xml')
res.charset = 'utf-8'
res.unicode_body = request.context.render('radar/atom/atom.xml', template_info)
res.headers['etag'] = get_mailbox_etag(mb)
return res
def get_version_info(self, req, file="version"):
resp = Response()
resp.charset = 'UTF-8'
if utils.is_xml_response(req):
resp_file = os.path.join(POSSIBLE_TOPDIR,
"keystone/content/%s.xml.tpl" % file)
resp.content_type = "application/xml"
elif utils.is_atom_response(req):
resp_file = os.path.join(POSSIBLE_TOPDIR,
"keystone/content/%s.atom.tpl" % file)
resp.content_type = "application/atom+xml"
else:
resp_file = os.path.join(POSSIBLE_TOPDIR,
"keystone/content/%s.json.tpl" % file)
resp.content_type = "application/json"
hostname = req.environ.get("SERVER_NAME")
port = req.environ.get("SERVER_PORT")
if 'HTTPS' in req.environ:
protocol = 'https'
else:
protocol = 'http'
resp.unicode_body = template.template(resp_file,
PROTOCOL=protocol,
HOST=hostname,
PORT=port,
API_VERSION=version.API_VERSION,
API_VERSION_STATUS=version.API_VERSION_STATUS,
API_VERSION_DATE=version.API_VERSION_DATE)
return resp
def __call__(self, env, start_response): res = Response (content_type = 'text/plain', status = 200) req = Request (env) url = req.path_info additional_params = dict(req.params) additional_params['request'] = req additional_params['response'] = res additional_params['method'] = req.method additional_params['headers'] = req.headers found = False for handler in UrlCallableFunction.request_handlers: result = handler.call_if_matches (url, additional_params) if result: found = True if isinstance (result, str): res.text = result elif isinstance (result, dict): if 'body' in result: res.text = result['body'] if 'charset' in result: res.charset = result['charset'] if 'content_type' in result: res.content_type = result['content_type'] if 'additional_headers' in result: res.headers.update(result['additional_headers']) if 'status' in result: res.status = result['status'] break if not found: res.status = 400 return res (env, start_response)
def make_response(obj, content_type='application/json'):
res = Response(content_type=content_type)
if(content_type=="application/json"):
res.charset = 'utf8'
res.body = dumps(obj)
else:
res.body = obj
return res
def test_charset_set_charset_is_None():
res = Response()
res.charset = 'utf-8'
res._app_iter = ['123']
del res.app_iter
eq_(res._app_iter, None)
eq_(res._body, None)
eq_(res.content_length, None)
def __call__(self, environ, start_response):
res = Response()
res.text = text_type(self.body)
res.status = '200 OK'
res.content_type = 'application/json'
res.charset = 'utf-8'
res.headers.add('Content-description', 'dods_version')
res.headers.add('XDODS-Server', 'pydap/%s' % __version__)
return res(environ, start_response)
def render_template_to_response(path, **kw):
""" Render a zope.pagetemplate (ZPT) template at the package-relative path
(may also be absolute) using the kwargs in ``*kw`` as top-level
names and return a Response object. """
result = render_template(path, **kw)
#return Response(result)
response = Response(result)
response.charset = 'utf-8' # Make IE happy
return response
def __call__(self, environ, start_response):
res = Response()
res.text = text_type(self.body)
res.status = "200 OK"
res.content_type = "application/json"
res.charset = "utf-8"
res.headers.add("Content-description", "dods_version")
res.headers.add("XDODS-Server", "pydap/%s" % __version__)
return res(environ, start_response)
def challenge(self, environ, status, app_headers, forget_headers):
'''
The challenger.
'''
res = Response()
res.headerlist = [('Content-type', 'application/json')]
res.charset = 'utf8'
res.unicode_body = u"{error:'wrong credentials'}"
res.status = 403
return res
def __call__(self, environ, start_response):
res = Response()
res.body = self.body
res.status='500 Internal Error'
res.content_type = 'text/plain'
res.charset = 'utf-8'
res.headers.add('Content-description', 'dods_error')
res.headers.add('XDODS-Server', 'pydap/%s' % '.'.join(map(str, __version__)))
return res(environ, start_response)
def test_unicode_body():
res = Response()
res.charset = 'utf-8'
bbody = 'La Pe\xc3\xb1a' # binary string
ubody = unicode(bbody, 'utf-8') # unicode string
res.body = bbody
eq_(res.unicode_body, ubody)
res.ubody = ubody
eq_(res.body, bbody)
del res.ubody
eq_(res.body, '')
def __call__(self, environ, start_response):
req = Request(environ)
resp = Response()
filename = req.path_info.strip('/')
lfilename = filename.lower()
if not req.path_info.strip('/') or os.path.isdir(filename):
if filename:
filename = path(filename, 'index.html')
else:
filename = 'index.html'
body = open(filename, 'rb').read()
resp.body = body
elif os.path.isfile(filename):
if req.method.lower() == 'delete':
sh.rm(filename + '*', shell=True)
resp = exc.HTTPNoContent()
return resp(environ, start_response)
if req.path_info.endswith('.metadata'):
cfg = ConfigObject(filename=filename)
if req.method.lower() == 'get':
resp.content_type = 'application/json'
elif req.method.lower() == 'put':
data = json.loads(req.body)
cfg.metadata.update(data)
cfg.write()
metadata = dict(cfg.metadata.items())
metadata.update(tags=cfg.metadata.tags.as_list())
resp.body = json.dumps(metadata)
elif req.path_info.endswith('.js'):
resp.content_type = 'text/javascript'
elif req.path_info.endswith('.json'):
resp.content_type = 'application/json'
elif req.path_info.endswith('.css'):
resp.content_type = 'text/css'
elif lfilename.endswith('.jpg'):
resp.charset = None
resp.content_type = 'image/jpeg'
print(filename)
if not resp.content_length:
resp.app_iter = fd(filename)
elif req.path_info.startswith('/delete/'):
filename = req.path_info[8:-1]
self.delete(filename)
resp.status_int = 302
resp.location = '/' + path.dirname(filename)
else:
resp.body = str(req.path_info)
resp.last_modified = datetime.now()
return resp(environ, start_response)
def backend(self, request, environ):
"""
WSGI Response producer for HTTP POST Git Smart HTTP requests.
Reads commands and data from HTTP POST's body.
returns an iterator obj with contents of git command's
response to stdout
"""
_git_path = kallithea.CONFIG.get('git_path', 'git')
git_command = self._get_fixedpath(request.path_info)
if git_command not in self.commands:
log.debug('command %s not allowed', git_command)
return exc.HTTPMethodNotAllowed()
if 'CONTENT_LENGTH' in environ:
inputstream = FileWrapper(environ['wsgi.input'],
request.content_length)
else:
inputstream = environ['wsgi.input']
gitenv = dict(os.environ)
# forget all configs
gitenv['GIT_CONFIG_NOGLOBAL'] = '1'
cmd = [_git_path, git_command[4:], '--stateless-rpc', self.content_path]
log.debug('handling cmd %s', cmd)
try:
out = subprocessio.SubprocessIOChunker(
cmd,
inputstream=inputstream,
env=gitenv,
cwd=self.content_path,
)
except EnvironmentError as e:
log.error(traceback.format_exc())
raise exc.HTTPExpectationFailed()
if git_command in [u'git-receive-pack']:
# updating refs manually after each push.
# Needed for pre-1.7.0.4 git clients using regular HTTP mode.
from kallithea.lib.vcs import get_repo
from dulwich.server import update_server_info
repo = get_repo(self.content_path)
if repo:
update_server_info(repo._repo)
resp = Response()
resp.content_type = 'application/x-%s-result' % git_command.encode('utf8')
resp.charset = None
resp.app_iter = out
return resp
def markup_parser(request):
resp = Response()
# markup preview helper
resp.charset = 'utf-8'
markup = request.GET.get('markup', 'textile')
value = request.POST.get('data', '')
if markup == 'textile':
value = textile(value)
elif markup == 'markdown':
value = markdown.markdown(value)
elif markup == 'bbcode':
value = render_bbcode(value)
if isinstance(value, unicode):
value = value.encode('utf-8')
resp.body = value
return resp
def feed_links_opml(request):
try:
opmldata = request.POST['opmlfile']
result = {}
result['links'] = [{'url': url, 'title': title} for (url, title) in
_feeds_in_opml(opmldata.file.read()).items()];
result['error'] = False
except:
log.error("error parsing opml: %s" % traceback.format_exc())
result = {'links': [], 'error': True}
template_info = TemplateContext(request,
{'result': json.dumps(result)})
res = HttpResponse(content_type='text/html')
res.charset = 'utf-8'
res.unicode_body = request.context.render('radar/ajax_upload.html', template_info)
return res
def application(env, start_response):
res = None
path = env['PATH_INFO'].lstrip('/')
method = env['REQUEST_METHOD']
args = MultiDict(parse_qsl(env.get('QUERY_STRING', '')))
parts = path.split('/')
volume = args.get('volume')
if not volume:
volumes = cluster.get_volumes(args['key'])
for v in volumes:
if v.node is current_node and v.id in current_node.volumes:
volume = v.id
break
if volume:
v = current_node.volumes[volume]
collection = parts[0]
if method == 'PUT':
return put_file(env, start_response,
v, collection, args['key'])
elif method == 'GET':
fname, meta = v.get(collection, args['key'])
res = Response()
res.charset = None
res.headers['X-Sendfile'] = fname
res.headers['X-Crc'] = str(meta['crc'])
res.content_length = os.path.getsize(fname)
if 'ct' in meta:
res.content_type = meta['ct']
else:
collection = parts[0]
key = args['key']
v = volumes[0]
res = HTTPTemporaryRedirect(
location='http://{}/{}?key={}&volume={}'.format(v.node.id, collection, key, v.id))
for v in volumes:
res.headers.add(
'X-Location',
'http://{}/{}?key={}&volume={}'.format(v.node.id, collection, key, v.id))
if not res:
res = HTTPNotFound()
return res(env, start_response)
def get_version_info(self, req):
resp = Response()
resp.charset = "UTF-8"
if utils.is_xml_response(req):
resp_file = os.path.join(POSSIBLE_TOPDIR, "keystone/content/version.xml.tpl")
resp.content_type = "application/xml"
else:
resp_file = os.path.join(POSSIBLE_TOPDIR, "keystone/content/version.json.tpl")
resp.content_type = "application/json"
hostname = req.environ.get("SERVER_NAME")
port = req.environ.get("SERVER_PORT")
resp.unicode_body = template.template(
resp_file, HOST=hostname, PORT=port, VERSION_STATUS=VERSION_STATUS, VERSION_DATE=VERSION_DATE
)
return resp
def application(self, environ, start_response):
req_webob = Request(environ)
res_webob = Response()
#addr tuple as glastopf expects it
remote_addr = (req_webob.remote_addr, int(environ['REMOTE_PORT']))
header, body = self.honeypot.handle_request(req_webob.as_text(),
remote_addr, None)
for h in header.splitlines():
if ':' in h:
h, v = h.split(':', 1)
res_webob.headers[str(h.strip())] = str(v.strip())
#this will adjust content-length header
res_webob.charset = 'utf8'
res_webob.text = unicode(body)
#WSGI applications are not allowed to create or modify hop-by-hop headers
self.remove_hop_by_hop_headers(res_webob.headers)
return res_webob(environ, start_response)
def inforefs(self, request, unused_environ):
"""
WSGI Response producer for HTTP GET Git Smart
HTTP /info/refs request.
"""
git_command = request.GET.get('service')
if git_command not in self.commands:
log.debug('command %s not allowed', git_command)
return exc.HTTPForbidden()
# please, resist the urge to add '\n' to git capture and increment
# line count by 1.
# by git docs: Documentation/technical/http-protocol.txt#L214 \n is
# a part of protocol.
# The code in Git client not only does NOT need '\n', but actually
# blows up if you sprinkle "flush" (0000) as "0001\n".
# It reads binary, per number of bytes specified.
# if you do add '\n' as part of data, count it.
server_advert = '# service=%s\n' % git_command
packet_len = str(hex(len(server_advert) + 4)[2:].rjust(4, '0')).lower()
try:
gitenv = dict(os.environ)
# forget all configs
gitenv['RC_SCM_DATA'] = json.dumps(self.extras)
command = [self.git_path, git_command[4:], '--stateless-rpc',
'--advertise-refs', self.content_path]
out = subprocessio.SubprocessIOChunker(
command,
env=gitenv,
starting_values=[packet_len + server_advert + '0000'],
shell=False
)
except EnvironmentError:
log.exception('Error processing command')
raise exc.HTTPExpectationFailed()
resp = Response()
resp.content_type = 'application/x-%s-advertisement' % str(git_command)
resp.charset = None
resp.app_iter = out
return resp
def csv_response(rows, encoding='ISO-8859-1', filename='response.csv'):
"""Create a downloadable webob.Response instance with the given
row data as a CSV file.
"""
stream = StringIO()
writer = csv.writer(stream, dialect='excel')
for row in rows:
# Encode all columns in the row since the csv.writer cannot
# handle Unicode objects.
writer.writerow([unicode(s).encode(encoding) for s in row])
response = Response()
response.body = stream.getvalue()
stream.close()
# Set Response headers.
response.charset = encoding
response.content_type = 'text/csv'
response.content_disposition = 'attachment; filename={0}'.format(filename)
return response
def __call__(self, environ, start_response):
req = Request(environ)
if '/markup_parser.html' in req.path_info:
resp = Response()
# markup preview helper
resp.charset = 'utf-8'
markup = req.GET.get('markup', 'textile')
value = req.POST.get('data')
if markup == 'textile':
value = textile(value)
elif markup == 'markdown':
value = markdown.markdown(value)
elif markup == 'bbcode':
value = render_bbcode(value)
if isinstance(value, unicode):
value = value.encode('utf-8')
resp.body = value
else:
resp = req.get_response(self.static_app)
resp.headers['X-Salade'] = 'none'
return resp(environ, start_response)
def get_multiple_choice(self, req, file="multiple_choice", path=None):
""" Returns a multiple-choices response based on API spec
Response will include in it only one choice, which is for the
current API version. The response is a 300 Multiple Choice
response with either an XML or JSON body.
"""
if path is None:
path = ''
logger.debug("300 Multiple Choices response: %s" % path)
resp = Response(status="300 Multiple Choices")
resp.charset = 'UTF-8'
if utils.is_xml_response(req):
resp_file = os.path.join(POSSIBLE_TOPDIR,
"keystone/content/%s.xml.tpl" % file)
resp.content_type = "application/xml"
else:
resp_file = os.path.join(POSSIBLE_TOPDIR,
"keystone/content/%s.json.tpl" % file)
resp.content_type = "application/json"
hostname = req.environ.get("SERVER_NAME")
port = req.environ.get("SERVER_PORT")
if 'HTTPS' in req.environ:
protocol = 'https'
else:
protocol = 'http'
resp.unicode_body = template.template(resp_file,
PROTOCOL=protocol,
HOST=hostname,
PORT=port,
API_VERSION=version.API_VERSION,
API_VERSION_STATUS=version.API_VERSION_STATUS,
API_VERSION_DATE=version.API_VERSION_DATE,
RESOURCE_PATH=path
)
return resp
def inforefs(self, req, environ):
"""
WSGI Response producer for HTTP GET Git Smart
HTTP /info/refs request.
"""
git_command = req.GET.get('service')
if git_command not in self.commands:
log.debug('command %s not allowed', git_command)
return exc.HTTPMethodNotAllowed()
# From Documentation/technical/http-protocol.txt shipped with Git:
#
# Clients MUST verify the first pkt-line is `# service=$servicename`.
# Servers MUST set $servicename to be the request parameter value.
# Servers SHOULD include an LF at the end of this line.
# Clients MUST ignore an LF at the end of the line.
#
# smart_reply = PKT-LINE("# service=$servicename" LF)
# ref_list
# "0000"
server_advert = '# service=%s\n' % git_command
packet_len = str(hex(len(server_advert) + 4)[2:].rjust(4, '0')).lower()
_git_path = kallithea.CONFIG.get('git_path', 'git')
cmd = [_git_path, git_command[4:],
'--stateless-rpc', '--advertise-refs', self.content_path]
log.debug('handling cmd %s', cmd)
try:
out = subprocessio.SubprocessIOChunker(cmd,
starting_values=[packet_len + server_advert + '0000']
)
except EnvironmentError as e:
log.error(traceback.format_exc())
raise exc.HTTPExpectationFailed()
resp = Response()
resp.content_type = 'application/x-%s-advertisement' % str(git_command)
resp.charset = None
resp.app_iter = out
return resp
def get_version_info(self, req, file="version"):
resp = Response()
resp.charset = 'UTF-8'
if utils.is_xml_response(req):
resp_file = os.path.join(possible_topdir,
"keystone/content/%s.xml.tpl" % file)
resp.content_type = "application/xml"
else:
resp_file = os.path.join(possible_topdir,
"keystone/content/%s.json.tpl" % file)
resp.content_type = "application/json"
hostname = req.environ.get("SERVER_NAME")
port = req.environ.get("SERVER_PORT")
resp.unicode_body = template.template(resp_file,
HOST=hostname,
PORT=port,
VERSION_STATUS=config.VERSION_STATUS,
VERSION_DATE=config.VERSION_DATE)
return resp
def inforefs(self, request, environ):
"""
WSGI Response producer for HTTP GET Git Smart
HTTP /info/refs request.
"""
git_command = request.GET.get('service')
if git_command not in self.commands:
log.debug('command %s not allowed', git_command)
return exc.HTTPMethodNotAllowed()
# note to self:
# please, resist the urge to add '\n' to git capture and increment
# line count by 1.
# The code in Git client not only does NOT need '\n', but actually
# blows up if you sprinkle "flush" (0000) as "0001\n".
# It reads binary, per number of bytes specified.
# if you do add '\n' as part of data, count it.
server_advert = '# service=%s' % git_command
packet_len = str(hex(len(server_advert) + 4)[2:].rjust(4, '0')).lower()
_git_path = kallithea.CONFIG.get('git_path', 'git')
cmd = [_git_path, git_command[4:],
'--stateless-rpc', '--advertise-refs', self.content_path]
log.debug('handling cmd %s', cmd)
try:
out = subprocessio.SubprocessIOChunker(cmd,
starting_values=[packet_len + server_advert + '0000']
)
except EnvironmentError as e:
log.error(traceback.format_exc())
raise exc.HTTPExpectationFailed()
resp = Response()
resp.content_type = 'application/x-%s-advertisement' % str(git_command)
resp.charset = None
resp.app_iter = out
return resp
def test_text_set_not_unicode():
res = Response()
res.charset = 'utf-8'
assert_raises(TypeError, res.__setattr__, 'text',
'La Pe\xc3\xb1a')
def showpython(request: Request):
res = Response()
res.content_type = 'text/plain'
res.charset = 'gb2312'
res.body = 'Hello there, you are so beautiful'.encode()
return res
content_type = saxutils.escape(content_type)
xml_output.append('<object><name>%s</name><hash>%s</hash>'\
'<bytes>%d</bytes><content_type>%s</content_type>'\
'<last_modified>%s</last_modified></object>' % \
(name, etag, size, content_type, created_at))
container_list = ''.join([
'<?xml version="1.0" encoding="UTF-8"?>\n',
'<container name=%s>' % saxutils.quoteattr(container),
''.join(xml_output), '</container>'])
else:
if not container_list:
return HTTPNoContent(request=req, headers=resp_headers)
container_list = '\n'.join(r[0] for r in container_list) + '\n'
ret = Response(body=container_list, request=req, headers=resp_headers)
ret.content_type = out_content_type
ret.charset = 'utf8'
return ret
def REPLICATE(self, req):
"""
Handle HTTP REPLICATE request (json-encoded RPC calls for replication.)
"""
try:
post_args = split_path(unquote(req.path), 3)
except ValueError, err:
return HTTPBadRequest(body=str(err), content_type='text/plain',
request=req)
drive, partition, hash = post_args
if self.mount_check and not check_mount(self.root, drive):
return Response(status='507 %s is not mounted' % drive)
try:
log.error(traceback.format_exc())
raise exc.HTTPExpectationFailed()
if git_command in [u'git-receive-pack']:
# updating refs manually after each push.
# Needed for pre-1.7.0.4 git clients using regular HTTP mode.
_git_path = rhodecode.CONFIG.get('git_path', 'git')
cmd = (u'%s --git-dir "%s" '
'update-server-info' % (_git_path, self.content_path))
log.debug('handling cmd %s' % cmd)
subprocess.call(cmd, shell=True)
resp = Response()
resp.content_type = 'application/x-%s-result' % git_command.encode(
'utf8')
resp.charset = None
resp.app_iter = out
return resp
def __call__(self, environ, start_response):
request = Request(environ)
_path = self._get_fixedpath(request.path_info)
if _path.startswith('info/refs'):
app = self.inforefs
elif [a for a in self.valid_accepts if a in request.accept]:
app = self.backend
try:
resp = app(request, environ)
except exc.HTTPException, e:
resp = e
log.error(traceback.format_exc())
def test_text_get_decode():
res = Response()
res.charset = 'utf-8'
res.body = 'La Pe\xc3\xb1a'
eq_(res.text, unicode('La Pe\xc3\xb1a', 'utf-8'))
def backend(self, request, environ):
"""
WSGI Response producer for HTTP POST Git Smart HTTP requests.
Reads commands and data from HTTP POST's body.
returns an iterator obj with contents of git command's
response to stdout
"""
# TODO(skreft): think how we could detect an HTTPLockedException, as
# we probably want to have the same mechanism used by mercurial and
# simplevcs.
# For that we would need to parse the output of the command looking for
# some signs of the HTTPLockedError, parse the data and reraise it in
# pygrack. However, that would interfere with the streaming.
#
# Now the output of a blocked push is:
# Pushing to http://test_regular:[email protected]:5001/vcs_test_git
# POST git-receive-pack (1047 bytes)
# remote: ERROR: Repository `vcs_test_git` locked by user `test_admin`. Reason:`lock_auto`
# To http://test_regular:[email protected]:5001/vcs_test_git
# ! [remote rejected] master -> master (pre-receive hook declined)
# error: failed to push some refs to 'http://*****:*****@127.0.0.1:5001/vcs_test_git'
git_command = self._get_fixedpath(request.path_info)
if git_command not in self.commands:
log.debug('command %s not allowed', git_command)
return exc.HTTPForbidden()
capabilities = None
if git_command == 'git-upload-pack':
capabilities = self._get_want_capabilities(request)
if 'CONTENT_LENGTH' in environ:
inputstream = FileWrapper(request.body_file_seekable,
request.content_length)
else:
inputstream = request.body_file_seekable
resp = Response()
resp.content_type = ('application/x-%s-result' %
git_command.encode('utf8'))
resp.charset = None
pre_pull_messages = ''
if git_command == 'git-upload-pack':
status, pre_pull_messages = hooks.git_pre_pull(self.extras)
if status != 0:
resp.app_iter = self._build_failed_pre_pull_response(
capabilities, pre_pull_messages)
return resp
gitenv = dict(os.environ)
# forget all configs
gitenv['GIT_CONFIG_NOGLOBAL'] = '1'
gitenv['RC_SCM_DATA'] = json.dumps(self.extras)
cmd = [
self.git_path, git_command[4:], '--stateless-rpc',
self.content_path
]
log.debug('handling cmd %s', cmd)
out = subprocessio.SubprocessIOChunker(cmd,
inputstream=inputstream,
env=gitenv,
cwd=self.content_path,
shell=False,
fail_on_stderr=False,
fail_on_return_code=False)
if self.update_server_info and git_command == 'git-receive-pack':
# We need to fully consume the iterator here, as the
# update-server-info command needs to be run after the push.
out = list(out)
# Updating refs manually after each push.
# This is required as some clients are exposing Git repos internally
# with the dumb protocol.
cmd = [self.git_path, 'update-server-info']
log.debug('handling cmd %s', cmd)
output = subprocessio.SubprocessIOChunker(
cmd,
inputstream=inputstream,
env=gitenv,
cwd=self.content_path,
shell=False,
fail_on_stderr=False,
fail_on_return_code=False)
# Consume all the output so the subprocess finishes
for _ in output:
pass
if git_command == 'git-upload-pack':
unused_status, post_pull_messages = hooks.git_post_pull(
self.extras)
resp.app_iter = self._inject_messages_to_response(
out, capabilities, pre_pull_messages, post_pull_messages)
else:
resp.app_iter = out
return resp
def pythonhandler(request: Request):
res = Response()
res.charset = 'utf-8'
res.body = 'welcom to ma python'.encode()
return res
def pythonhandler(request):
res = Response()
res.charset = 'utf-8'
res.body = '<h1> Welcome to Python</h1>'.encode()
return res
new_req = Request(req.environ)
new_req.some_attr
req.environ['webob.adhoc_attrs']
# response
res = Response()
res.status
res.headerlist
res.body
res.status = 404
res.status
res.status_code
res.headerlist = [('Content-type', 'text/html')]
res.body = 'test'
print res
# response headers
res.headers
res = Response(content_type='text/plain', charset=None)
f = res.body_file
f.write('hey')
f.write(u'test')
f.encoding
res.charset = 'utf8'
f.encoding
f.write(u'test')
res.app_iter
res.body
# Header Getters
def GETorHEAD_base(self, req, server_type, partition, nodes, path,
attempts):
"""
Base handler for HTTP GET or HEAD requests.
:param req: webob.Request object
:param server_type: server type
:param partition: partition
:param nodes: nodes
:param path: path for the request
:param attempts: number of attempts to try
:returns: webob.Response object
"""
statuses = []
reasons = []
bodies = []
source = None
sources = []
newest = req.headers.get('x-newest', 'f').lower() in TRUE_VALUES
nodes = iter(nodes)
while len(statuses) < attempts:
try:
node = nodes.next()
except StopIteration:
break
if self.error_limited(node):
continue
try:
with ConnectionTimeout(self.app.conn_timeout):
headers = dict(req.headers)
headers['Connection'] = 'close'
conn = http_connect(node['ip'], node['port'],
node['device'], partition, req.method, path,
headers=headers,
query_string=req.query_string)
with Timeout(self.app.node_timeout):
possible_source = conn.getresponse()
# See NOTE: swift_conn at top of file about this.
possible_source.swift_conn = conn
except (Exception, Timeout):
self.exception_occurred(node, server_type,
_('Trying to %(method)s %(path)s') %
{'method': req.method, 'path': req.path})
continue
if possible_source.status == HTTP_INSUFFICIENT_STORAGE:
self.error_limit(node)
continue
if is_success(possible_source.status) or \
is_redirection(possible_source.status):
# 404 if we know we don't have a synced copy
if not float(possible_source.getheader('X-PUT-Timestamp', 1)):
statuses.append(HTTP_NOT_FOUND)
reasons.append('')
bodies.append('')
possible_source.read()
continue
if newest:
if sources:
ts = float(source.getheader('x-put-timestamp') or
source.getheader('x-timestamp') or 0)
pts = float(
possible_source.getheader('x-put-timestamp') or
possible_source.getheader('x-timestamp') or 0)
if pts > ts:
sources.insert(0, possible_source)
else:
sources.append(possible_source)
else:
sources.insert(0, possible_source)
source = sources[0]
statuses.append(source.status)
reasons.append(source.reason)
bodies.append('')
continue
else:
source = possible_source
break
statuses.append(possible_source.status)
reasons.append(possible_source.reason)
bodies.append(possible_source.read())
if is_server_error(possible_source.status):
self.error_occurred(node, _('ERROR %(status)d %(body)s ' \
'From %(type)s Server') %
{'status': possible_source.status,
'body': bodies[-1][:1024], 'type': server_type})
if source:
if req.method == 'GET' and \
source.status in (HTTP_OK, HTTP_PARTIAL_CONTENT):
if newest:
# we need to close all hanging swift_conns
sources.pop(0)
for src in sources:
self.close_swift_conn(src)
res = Response(request=req, conditional_response=True)
res.app_iter = self._make_app_iter(node, source, res)
# See NOTE: swift_conn at top of file about this.
res.swift_conn = source.swift_conn
update_headers(res, source.getheaders())
# Used by container sync feature
if res.environ is None:
res.environ = dict()
res.environ['swift_x_timestamp'] = \
source.getheader('x-timestamp')
update_headers(res, {'accept-ranges': 'bytes'})
res.status = source.status
res.content_length = source.getheader('Content-Length')
if source.getheader('Content-Type'):
res.charset = None
res.content_type = source.getheader('Content-Type')
return res
elif is_success(source.status) or is_redirection(source.status):
res = status_map[source.status](request=req)
update_headers(res, source.getheaders())
# Used by container sync feature
if res.environ is None:
res.environ = dict()
res.environ['swift_x_timestamp'] = \
source.getheader('x-timestamp')
update_headers(res, {'accept-ranges': 'bytes'})
res.content_length = source.getheader('Content-Length')
if source.getheader('Content-Type'):
res.charset = None
res.content_type = source.getheader('Content-Type')
return res
return self.best_response(req, statuses, reasons, bodies,
'%s %s' % (server_type, req.method))
def showpython(request: Request):
res = Response()
res.content_type = 'text/plain'
res.charset = 'gb2312'
res.text = 'Hello there. Nice to meet you. Sunshine boys and beautiful girls.'
return res
def test_text_set_no_charset():
res = Response()
res.charset = None
assert_raises(AttributeError, res.__setattr__, 'text', 'abc')
def test_app_error_with_bytes_message(self):
resp = Response(six.u('\xe9').encode('utf8'))
resp.charset = 'utf8'
err = webtest.AppError(to_bytes('message %s'), resp)
self.assertEqual(err.args, (six.u('message \xe9'), ))
def showpython(request: Request) -> Response:
res = Response()
res.content_type = 'text/plain'
res.charset = 'utf-8'
res.body = '<h1>Hello there, sunshine boys and beautiful girls, how are you?</h1>'
return res
def test_app_error_misc(self):
resp = Response(six.u('\xe9').encode('utf8'))
resp.charset = ''
# dont check the output. just make sure it doesn't fail
webtest.AppError(to_bytes('message %s'), resp)
webtest.AppError(six.u('messag\xe9 %s'), six.b('\xe9'))
def show_python(request: Request):
res = Response()
res.content_type = 'test/plain'
res.charset = 'utf-8'
res.body = '<h1>welcome to python</h1>'.encode()
return res
if is_subdir:
output_list.append('<subdir name="%s" />' % name)
else:
item = '<container><name>%s</name><count>%s</count>' \
'<bytes>%s</bytes></container>' % \
(name, object_count, bytes_used)
output_list.append(item)
output_list.append('</account>')
account_list = '\n'.join(output_list)
else:
if not account_list:
return HTTPNoContent(request=req, headers=resp_headers)
account_list = '\n'.join(r[0] for r in account_list) + '\n'
ret = Response(body=account_list, request=req, headers=resp_headers)
ret.content_type = out_content_type
ret.charset = 'utf-8'
return ret
def REPLICATE(self, req):
"""
Handle HTTP REPLICATE request.
Handler for RPC calls for account replication.
"""
try:
post_args = split_path(unquote(req.path), 3)
except ValueError, err:
return HTTPBadRequest(body=str(err),
content_type='text/plain',
request=req)
drive, partition, hash = post_args
if self.mount_check and not check_mount(self.root, drive):
def showpython(request: Request):
res = Response()
res.content_type = 'text/plain'
res.charset = 'gb2312'
res.body = '<h1>Hello there.</h1>'
return res
def test_unicode_body_set_no_charset():
res = Response()
res.charset = None
assert_raises(AttributeError, res.__setattr__, 'unicode_body', 'abc')
