def get_content(self):
"""Open content as a stream for reading.
See DAVResource.get_content()
"""
filestream = compat.StringIO()
tableName, primKey = self.provider._split_path(self.path)
if primKey is not None:
conn = self.provider._init_connection()
listFields = self.provider._get_field_list(conn, tableName)
csvwriter = csv.DictWriter(filestream, listFields, extrasaction="ignore")
dictFields = {}
for field_name in listFields:
dictFields[field_name] = field_name
csvwriter.writerow(dictFields)
if primKey == "_ENTIRE_CONTENTS":
cursor = conn.cursor(MySQLdb.cursors.DictCursor)
cursor.execute("SELECT * from " + self.provider._db + "." + tableName)
result_set = cursor.fetchall()
for row in result_set:
csvwriter.writerow(row)
cursor.close()
else:
row = self.provider._get_record_by_primary_key(conn, tableName, primKey)
if row is not None:
csvwriter.writerow(row)
conn.close()
# this suffices for small dbs, but
# for a production big database, I imagine you would have a FileMixin that
# does the retrieving and population even as the file object is being read
filestream.seek(0)
return filestream
def getContent(self):
"""Open content as a stream for reading.
See DAVResource.getContent()
"""
assert not self.isCollection
d = self.fctx.data()
return compat.StringIO(d)
def getContent(self):
fileLinks = [
"<a href='%s'>%s</a>\n" % (os.path.basename(f), f)
for f in self.data["resPathList"]
]
dict = self.data.copy()
dict["fileLinks"] = ", ".join(fileLinks)
if self.name == ".Info.html":
html = """\
<html><head>
<title>%(title)s</title>
</head><body>
<h1>%(title)s</h1>
<table>
<tr>
<td>Description</td>
<td>%(description)s</td>
</tr><tr>
<td>Status</td>
<td>%(status)s</td>
</tr><tr>
<td>Tags</td>
<td>%(tags)s</td>
</tr><tr>
<td>Orga unit</td>
<td>%(orga)s</td>
</tr><tr>
<td>Files</td>
<td>%(fileLinks)s</td>
</tr><tr>
<td>Key</td>
<td>%(key)s</td>
</tr>
</table>
<p>This is a virtual WsgiDAV resource called '%(title)s'.</p>
</body></html>""" % dict
elif self.name == ".Info.txt":
lines = [
self.data["title"],
"=" * len(self.data["title"]),
self.data["description"],
"",
"Status: %s" % self.data["status"],
"Orga: %8s" % self.data["orga"],
"Tags: '%s'" % "', '".join(self.data["tags"]),
"Key: %s" % self.data["key"],
]
html = "\n".join(lines)
elif self.name == ".Description.txt":
html = self.data["description"]
else:
raise DAVError(HTTP_INTERNAL_ERROR,
"Invalid artifact '%s'" % self.name)
return compat.StringIO(html)
def run_benchmarks(opts):
py_version = "{}.{}.{}".format(*sys.version_info)
print(
"#-- WsgiDAV Benchmark ---------------------------------------------")
print("Date: {}".format(datetime.date.today()))
print("WsgiDAV: {}".format(__version__))
print("Python: {}".format(py_version))
print("CherryPy: {}".format(cp_version))
print("OS: {}".format(platform.platform(aliased=True)))
if use_lxml:
from lxml.etree import LXML_VERSION as lxml_version
print("lxml: {}".format(lxml_version))
else:
print("lxml: (not installed)")
def _runner(opts):
with Timing(">>> Summary >>>:"):
_bench_litmus(opts)
_bench_script(opts)
return
if opts.get("external_server"):
_runner(opts)
else:
with WsgiDavTestServer(with_auth=False,
with_ssl=False,
profile=opts.get("profile_server")):
if opts.get("profile_client"):
import cProfile
import pstats
prof = cProfile.Profile()
prof = prof.runctx("_runner(opts)", globals(), locals())
stream = compat.StringIO()
stats = pstats.Stats(prof, stream=stream)
# stats.sort_stats("time") # Or cumulative
stats.sort_stats("cumulative") # Or time
stats.print_stats(20) # 80 = how many to print
# The rest is optional.
# stats.print_callees()
# stats.print_callers()
logging.info("Profile data:")
logging.info(stream.getvalue())
else:
_runner(opts)
return
def elementContentAsString(element):
"""Serialize etree.Element.
Note: element may contain more than one child or only text (i.e. no child
at all). Therefore the resulting string may raise an exception, when
passed back to etree.XML().
"""
if len(element) == 0:
return element.text or "" # Make sure, None is returned as ''
stream = compat.StringIO()
for childnode in element:
print(xmlToBytes(childnode, pretty_print=False), file=stream)
s = stream.getvalue()
stream.close()
return s
def get_content(self):
html = "<pre>" + pformat(self.doc) + "</pre>"
return compat.StringIO(html.encode("utf8"))
def runWSGIApp(self, application, script_name, path_info, query):
# logging.info ("Running application with SCRIPT_NAME {} PATH_INFO {}".format(
# script_name, path_info))
if self.command == "PUT":
pass # breakpoint
env = {
"wsgi.version": (1, 0),
"wsgi.url_scheme": "http",
"wsgi.input": self.rfile,
"wsgi.errors": sys.stderr,
"wsgi.multithread": 1,
"wsgi.multiprocess": 0,
"wsgi.run_once": 0,
"REQUEST_METHOD": self.command,
"SCRIPT_NAME": script_name,
"PATH_INFO": path_info,
"QUERY_STRING": query,
"CONTENT_TYPE": self.headers.get("Content-Type", ""),
"CONTENT_LENGTH": self.headers.get("Content-Length", ""),
"REMOTE_ADDR": self.client_address[0],
"SERVER_NAME": self.server.server_address[0],
"SERVER_PORT": compat.to_native(self.server.server_address[1]),
"SERVER_PROTOCOL": self.request_version,
}
for httpHeader, httpValue in self.headers.items():
if not httpHeader.lower() in ("content-type", "content-length"):
env["HTTP_{}".format(httpHeader.replace(
"-", "_").upper())] = httpValue
# Setup the state
self.wsgiSentHeaders = 0
self.wsgiHeaders = []
try:
# We have there environment, now invoke the application
_logger.debug("runWSGIApp application()...")
result = application(env, self.wsgiStartResponse)
try:
for data in result:
if data:
self.wsgiWriteData(data)
else:
_logger.debug("runWSGIApp empty data")
finally:
_logger.debug("runWSGIApp finally.")
if hasattr(result, "close"):
result.close()
except Exception:
_logger.debug("runWSGIApp caught exception...")
errorMsg = compat.StringIO()
traceback.print_exc(file=errorMsg)
logging.error(errorMsg.getvalue())
if not self.wsgiSentHeaders:
self.wsgiStartResponse("500 Server Error",
[("Content-type", "text/html")])
self.wsgiWriteData(SERVER_ERROR)
if not self.wsgiSentHeaders:
# GC issue 29 sending one byte, when content-length is '0' seems wrong
# We must write out something!
# self.wsgiWriteData (" ")
self.wsgiWriteData(b"")
return
def getContent(self):
return compat.StringIO(self.content)
