def render_PUT(self, request):
#take parameters. In this case, the content for update the file
args = http.parse_qs(request.content.read(), 1)
if not args:
return resource.ErrorPage(400, "INCORRECT PARAMETERS", "Supervise parameters, you not put anything to update ").render(request)
try:
_, file_resource, file_id, _ = split_path(request.path, 4, 4, True)
except:
return resource.ErrorPage(400, "INCORRECT PARAMETERS", "Supervise parameters, the correct form is api/file/file_id/data ").render(request)
# We look up the name of file, and full path, to update it.
message = api_library.get_metadata(1234, file_id)
if not message:
return resource.ErrorPage(404, "NOT FOUND", "File or folder not found at the specified path:" + request.path).render(request)
message = json.loads(message)
# Create new version to save old content version
#TODO: Define mimetype, size and chunk
message_new_version = api_library.update_data(1234, message["id"], message["parent"], None, None, None)
if not message_new_version:
return resource.ErrorPage(404, "NOT FOUND", "Some problem to create a new version of file").render(request)
# TODO: Using name and full path update the file into DB, using new version.
request.setHeader("content-type", "application/json")
request.finish()
return server.NOT_DONE_YET
def render(self, resrc):
"""
Ask a resource to render itself.
@param resrc: a L{twisted.web.resource.IResource}.
"""
try:
body = resrc.render(self)
except UnsupportedMethod, e:
allowedMethods = e.allowedMethods
if (self.method == "HEAD") and ("GET" in allowedMethods):
# We must support HEAD (RFC 2616, 5.1.1). If the
# resource doesn't, fake it by giving the resource
# a 'GET' request and then return only the headers,
# not the body.
log.msg("Using GET to fake a HEAD request for %s" %
(resrc,))
self.method = "GET"
self._inFakeHead = True
body = resrc.render(self)
if body is NOT_DONE_YET:
log.msg("Tried to fake a HEAD request for %s, but "
"it got away from me." % resrc)
# Oh well, I guess we won't include the content length.
else:
self.setHeader('content-length', str(len(body)))
self._inFakeHead = False
self.method = "HEAD"
self.write('')
self.finish()
return
if self.method in (supportedMethods):
# We MUST include an Allow header
# (RFC 2616, 10.4.6 and 14.7)
self.setHeader('Allow', ', '.join(allowedMethods))
s = ('''Your browser approached me (at %(URI)s) with'''
''' the method "%(method)s". I only allow'''
''' the method%(plural)s %(allowed)s here.''' % {
'URI': escape(self.uri),
'method': self.method,
'plural': ((len(allowedMethods) > 1) and 's') or '',
'allowed': string.join(allowedMethods, ', ')
})
epage = resource.ErrorPage(http.NOT_ALLOWED,
"Method Not Allowed", s)
body = epage.render(self)
else:
epage = resource.ErrorPage(
http.NOT_IMPLEMENTED, "Huh?",
"I don't know how to treat a %s request." %
(escape(self.method),))
body = epage.render(self)
def render(self, resrc):
"""
Ask a resource to render itself.
@param resrc: a L{twisted.web.resource.IResource}.
"""
try:
body = resrc.render(self)
except UnsupportedMethod, e:
sAllowedMethodList = e.allowedMethods
if (self.method == "HEAD") and ("GET" in sAllowedMethodList):
# We must support HEAD (RFC 2616, 5.1.1). If the
# resource doesn't, fake it by giving the resource
# a 'GET' request and then return only the headers,
# not the body.
log.Info("Using GET to fake a HEAD request for %s" % resrc)
self.method = "GET" #来自http.Request
self._inFakeHead = True #来自web.server.Request
body = resrc.render(self)
if body is NOT_DONE_YET:
log.Info("Tried to fake a HEAD request for %s, but it got away from me." % resrc)
# Oh well, I guess we won't include the content length.
else:
self.setHeader("content-length", str(len(body)))
self._inFakeHead = False
self.method = "HEAD"
self.write("")
self.finish()
return
if self.method in SUPPORT_METHOD_LIST:
# We MUST include an Allow header
# (RFC 2616, 10.4.6 and 14.7)
self.setHeader('Allow', ', '.join(sAllowedMethodList))
s = ("""Your browser approached me (at %(URI)s) with"""
""" the method "%(method)s". I only allow"""
""" the method%(plural)s %(allowed)s here.""" % {
"URI" : escape(self.uri),
"method" : self.method,
"plural" : ((len(sAllowedMethodList) > 1) and "s") or "",
"allowed" : string.join(sAllowedMethodList, ", ")
})
epage = resource.ErrorPage(http.NOT_ALLOWED, "Method Not Allowed", s)
body = epage.render(self)
else:
epage = resource.ErrorPage(
http.NOT_IMPLEMENTED, "Huh?",
"I don't know how to treat a %s request." %
(escape(self.method),))
body = epage.render(self)
def render_DELETE(self, request):
try:
_, _, folder_id = split_path(request.path, 3, 3, True)
except:
return resource.ErrorPage(400, "INCORRECT PARAMETERS", "It's mandatory to enter a folder_id. ").render(request)
message = api_library.delete_item(123, folder_id)
if not message:
return resource.ErrorPage(404, "NOT FOUND", "File or folder not found at the specified path:" + request.path).render(request)
request.setHeader("content-type", "application/json")
request.write(message)
request.finish()
return server.NOT_DONE_YET
def getChild(self, path, request):
if path == "events":
# Server-Sent Events use a GET with a use-once URL, not a token
return self.event_dispatcher
# everything else requires a token, check it here
payload = json.loads(request.content.read())
if not equal(payload["token"], self.access_token):
return resource.ErrorPage(http.UNAUTHORIZED, "bad token",
"Invalid token")
rclass = handlers.get(path)
if not rclass:
return resource.ErrorPage(http.NOT_FOUND, "unknown method",
"Unknown method")
r = rclass(self.db, self.agent, self.event_dispatcher, payload)
return r
def getChild(self, name, txrequest):
target = self.get_target()
try:
newtarget = getattr(target, to_native_str(name))
return ControlResource(self.crawler, newtarget)
except AttributeError:
return resource.ErrorPage(404, "No Such Resource", "No such child resource.")
def render_POST(self, request):
def started(result):
request.finish()
def stopped(result):
request.finish()
data = json.loads(request.content.getvalue())
action = data.get("action", None)
s = supervisor.get()
if action is None:
return resource.ErrorPage(http.BAD_REQUEST,
http.RESPONSES[http.BAD_REQUEST],
"action required")
elif action.lower() == "start":
d = s.startMinecraft(jar=settings.config["minecraft"]["jar"],
path=settings.config["minecraft"]["home"])
d.addCallback(started)
elif action.lower() == "stop":
d = s.stopMinecraft()
d.addCallback(stopped)
return server.NOT_DONE_YET
def getChild(self, name, request):
target = self.get_target()
try:
newtarget = getattr(target, name)
return JsonRpcResource(self.crawler, newtarget)
except AttributeError:
return resource.ErrorPage(404, "No Such Resource", "No such child resource.")
def processEnded(self, reason):
if reason.value.exitCode != 0:
self._log.error(
"CGI {uri} exited with exit code {exitCode}",
uri=self.request.uri,
exitCode=reason.value.exitCode,
)
if self.errortext:
self._log.error(
"Errors from CGI {uri}: {errorText}",
uri=self.request.uri,
errorText=self.errortext,
)
if self.handling_headers:
self._log.error(
"Premature end of headers in {uri}: {headerText}",
uri=self.request.uri,
headerText=self.headertext,
)
if not self._requestFinished:
self.request.write(
resource.ErrorPage(
http.INTERNAL_SERVER_ERROR,
"CGI Script Error",
"Premature end of script headers.",
).render(self.request))
if not self._requestFinished:
self.request.unregisterProducer()
self.request.finish()
def handle_request(self, request):
try:
username = request.args['user'][0]
cxn = yield txmongo.MongoConnection()
# Don't yield the user query
user_defer = cxn.pycon.users.find_one({'name': username})
# Go ahead with the translation regardless of
# whether we find a user.
input_str = request.args['data'][0]
from txtranslator import TranslatorClient
client = TranslatorClient(SVC_HOST, SVC_PORT)
output_defer = client.translate2(input_str)
# Wait until we have both results.
output_str = yield output_defer
user = yield user_defer
if user:
request.write("%s: %s" % (str(user['name']), output_str))
else:
request.write("User '%s' not found!" % username)
except Exception, err:
print err
request.write(resource.ErrorPage(500, "Internal Server Error.", err).render(request))
def __init__(self, res, realm):
HTTPRootResource.__init__(self, res)
self.realm = realm
self.authorized = False
self.unauthorizedResource = resource.ErrorPage(
http.UNAUTHORIZED, "Access denied",
"Authentication credentials invalid!")
def __init__(self, master):
self.master = master
master.web = self
server.Site.__init__(
self,
resource.ErrorPage(500, "Internal Server Error",
"Web module failed to load"))
def render(self, request):
path = self.path
if os_path.isfile(path):
lastComponent = path.split('/')[-1]
# Set the Header according to what's requested
if lastComponent in AppTextHeaderFiles:
request.setHeader('Content-Type', 'application/text')
elif lastComponent in TextHtmlHeaderFiles or (
path.endswith(".html.xml")
and lastComponent != "updates.html.xml"):
request.setHeader('Content-Type', 'text/html; charset=UTF-8')
elif lastComponent in TextJavascriptHeaderFiles:
request.setHeader('Content-Type',
'text/javascript; charset=UTF-8')
elif lastComponent not in NoExplicitHeaderFiles:
request.setHeader('Content-Type',
'application/xhtml+xml; charset=UTF-8')
# now go and write the Output
# request.finish() is called inside webif.py (requestFinish() which is called via renderPage())
webif.renderPage(request, path, self.session) # login?
request.setResponseCode(http.OK)
elif os_path.isdir(path) and self.addSlash is True:
uri = "%s/" % (request.path)
request.redirect(uri)
return ""
else:
return resource.ErrorPage(
http.NOT_FOUND, "Error 404 - Page not found",
"The requested resource is not available").render(request)
return server.NOT_DONE_YET
def _get_renderer(self, fmt):
"""
Get the renderer for the indicated format.
:param str fmt: The format. If a method with a prefix of ``render_``
and a suffix of this format (upper-cased) is found, it will be
used.
:return: A callable which takes a twisted.web Request and renders a
response.
"""
renderer = None
if fmt is not None:
try:
renderer = getattr(self, "render_{}".format(fmt.upper()))
except AttributeError:
return resource.ErrorPage(
http.BAD_REQUEST,
"Bad Format",
"Unknown {} value: {!r}".format(self.formatArgument, fmt),
).render
if renderer is None:
renderer = self.render_HTML
return renderer
def g(self, request):
try:
return f(self, request)
except Exception as e:
description, status = humanize_exception(e)
return resource.ErrorPage(status, "Error",
description).render(request)
def __init__(self, res):
print "[HTTPRootResource}.__init__"
resource.Resource.__init__(self)
self.resource = res
self.sessionInvalidResource = resource.ErrorPage(
http.PRECONDITION_FAILED, "Precondition failed!",
"sessionid is missing, invalid or expired!")
self._sessions = {}
def unauthorizedPage(self):
"""
Page to render when there is no valid token.
This makes use of L{TokenResource.unauthorizedMessage} by default.
"""
return resource.ErrorPage(
UNAUTHORIZED, "Unauthorized", self.unauthorizedMessage()
)
def getChild(self, esid, request):
try:
# esid tokens are single-use
self.unclaimed_event_channels.remove(esid) # can raise KeyError
return self.event_channels[esid]
except KeyError:
return resource.ErrorPage(http.UNAUTHORIZED, "bad esid",
"Invalid esid")
def render_GET(self, request):
try:
_, file_resource, file_id, resource, version, _ = split_path(request.path, 4, 6, True)
except:
return resource.ErrorPage(400, "INCORRECT PARAMETERS", "Supervise parameters, something is wrong").render(request)
metadata = api_library.get_metadata(1234, file_id, include_chunks=True, specific_version=version)
if not metadata:
return resource.ErrorPage(404, "NOT FOUND", "File or folder not found at the specified path:" + request.path).render(request)
# TODO: using metadata, where we can find the name and path of file, return content of file with DB
content = 'There are the content of specific version of file'
request.setHeader("content-type", "application/json")
request.setHeader("content-length", len(content))
request.write(content)
request.finish()
return server.NOT_DONE_YET
def render_GET(self, request):
try:
request.setResponseCode(200)
request.setHeader(b'content-type', b'text/plain')
content = 'I am stat\n'
return content.encode('ascii')
except Exception as e:
return resource.ErrorPage(500, 'Error',
'Message: {}'.format(e)).render(request)
def _eb_getFileAlias(self, failure):
err = failure.trap(NotFound, DisconnectionError)
if err == DisconnectionError:
return resource.ErrorPage(
503, 'Database unavailable',
'A required database is unavailable.\n'
'See https://twitter.com/launchpadstatus '
'for maintenance and outage notifications.')
else:
return fourOhFour
def getChildWithDefault(self, name, request):
"""
This should never be called; it's simply required to implement the
:py:class:`twisted.web.resource.IResource` interface. Just returns
a 404.
See: :py:meth:`twisted.web.resource.IResource.getChildWithDefault`
"""
return resource.ErrorPage(NOT_FOUND, "No Such Resource",
"No Such Resource")
def failed(self, failure):
#XXX: Argh. FIXME.
failure = str(failure)
self.request.write(
resource.ErrorPage(
http.INTERNAL_SERVER_ERROR, "Server Connection Lost",
"Connection to distributed server lost:" +
util._PRE(failure)).render(self.request))
self.request.finish()
self._log.info(failure)
class HTTPNoListingFileService(static.File):
"""Similar to twisted.web.static.File except that instead of listing the
content of directories, it returns a 403 Forbidden.
"""
_FORBIDDEN_RESOURCE = resource.ErrorPage(
http.FORBIDDEN, 'Forbidden', 'Directory listing not permitted.')
_NOT_ALLOWED_RESOURCE = resource.ErrorPage(http.NOT_ALLOWED,
'Method Not Allowed',
'Method not allowed.')
def directoryListing(self):
return self._FORBIDDEN_RESOURCE
def getChild(self, path, request):
if request.method != 'GET':
return self._NOT_ALLOWED_RESOURCE
else:
return static.File.getChild(self, path, request)
def render_GET(self, request):
args = clear_args(request.args)
try:
include_deleted = args.get('include_deleted')
except:
include_deleted = False
try:
_, _, folder_id, _ = split_path(request.path, 4, 4, True)
except:
return resource.ErrorPage(400, "INCORRECT PARAMETERS", "No tindrie que entra mai aqui ").render(request)
message = api_library.get_folder_contents(123, folder_id, include_deleted)
if not message:
return resource.ErrorPage(404, "NOT FOUND", "File or folder not found at the specified path:" + request.path).render(request)
request.setHeader("content-type", "application/json")
request.write(message)
request.finish()
return server.NOT_DONE_YET
def render(self, request):
if request.getClientIP() == "127.0.0.1":
return self.resource.render(request)
if self.login(request.getUser(), request.getPassword()) == False:
request.setHeader('WWW-authenticate',
'Basic realm="%s"' % ("OpenWebif"))
errpage = resource.ErrorPage(http.UNAUTHORIZED, "Unauthorized",
"401 Authentication required")
return errpage.render(request)
else:
return self.resource.render(request)
def ResourceTemplate(path, registry):
from quixote import ptl_compile
glob = {'__file__': _coerceToFilesystemEncoding("", path),
'resource': resource.ErrorPage(500, "Whoops! Internal Error",
rpyNoResource),
'registry': registry}
e = ptl_compile.compile_template(open(path), path)
code = compile(e, "<source>", "exec")
eval(code, glob, glob)
return glob['resource']
def render_POST(self, request):
self.number_requests += 1
try:
data_str = cgi.escape(request.content.read())
logger.debug('post request data string: "{}"'.format(data_str))
data_dict = json.loads(data_str)
except ValueError as e:
return resource.ErrorPage(
400, 'BAD_REQUEST',
'Message: invalid json document').render(request)
try:
jsonschema.validate(data_dict, self.schema)
except jsonschema.ValidationError as e:
return resource.ErrorPage(
400, 'BAD_REQUEST',
'Message: invalid json document').render(request)
try:
num_notif = 0
for notif in data_dict:
self.queue.put(notif)
num_notif += 1
request.setResponseCode(202)
request.setHeader(b'content-type', b'application/json')
result = {
'msg_accepted': num_notif,
'queue_pending': self.queue.size(),
'total_requests': self.number_requests
}
content = json.dumps(result,
ensure_ascii=True,
indent=4,
separators=(',', ': '),
sort_keys=True)
logger.debug('response string: "{}"'.format(content))
return content.encode('ascii')
except Exception as e:
return resource.ErrorPage(500, 'Error',
'Message: {}'.format(e)).render(request)
def render_GET(self, request):
# Check that the 'name' URL param was passed.
name = request.args.get('name', None)
if name is None:
return resource.ErrorPage(400, "Bad Request",
"Missing 'name' param.").render(request)
name = name[0]
delay_seconds = 2
print "Delaying for %s seconds." % delay_seconds
# Delay requires a callback
reactor.callLater(delay_seconds, delayed_render, request, name)
return NOT_DONE_YET
def render_GET(self, request):
try:
_, _, file_id, resource, version = split_path(request.path, 4, 5, True)
except:
return resource.ErrorPage(400, "INCORRECT PARAMETERS", "en principi no tindrie que passar aixo jaja").render(request)
# if version alone return all versions metadata
if not version:
message = api_library.get_versions(1234, file_id)
if not message:
return resource.ErrorPage(404, "NOT FOUND", "File or folder not found at the specified path:" + request.path).render(request)
request.write(message)
request.finish()
return server.NOT_DONE_YET
# if version/id return information about specific version
message = api_library.get_metadata(1234, file_id, specific_version=version)
if not message:
return resource.ErrorPage(404, "NOT FOUND", "File or folder not found at the specified path:" + request.path).render(request)
request.write(message)
request.finish()
return server.NOT_DONE_YET
'''
