def __init__(self, shard, contest):
logger.initialize(ServiceCoord("ContestWebServer", shard))
self.contest = contest
# This is a dictionary (indexed by username) of pending
# notification. Things like "Yay, your submission went
# through.", not things like "Your question has been replied",
# that are handled by the db. Each username points to a list
# of tuples (timestamp, subject, text).
self.notifications = {}
parameters = {
"login_url": "/",
"template_path": os.path.join(os.path.dirname(__file__), "templates", "contest"),
"static_path": os.path.join(os.path.dirname(__file__), "static"),
"cookie_secret": base64.b64encode(config.secret_key),
"debug": config.tornado_debug,
}
parameters["is_proxy_used"] = config.is_proxy_used
WebService.__init__(
self,
config.contest_listen_port[shard],
_cws_handlers,
parameters,
shard=shard,
listen_address=config.contest_listen_address[shard],
)
self.file_cacher = FileCacher(self)
self.evaluation_service = self.connect_to(ServiceCoord("EvaluationService", 0))
self.scoring_service = self.connect_to(ServiceCoord("ScoringService", 0))
def __init__(self, shard):
logger.initialize(ServiceCoord("AdminWebServer", shard))
# A list of pending notifications.
self.notifications = []
parameters = {
"login_url": "/",
"template_path": os.path.join(os.path.dirname(__file__),
"templates", "admin"),
"static_path": os.path.join(os.path.dirname(__file__),
"static"),
"cookie_secret": base64.b64encode(config.secret_key),
"debug": config.tornado_debug,
}
WebService.__init__(self,
config.admin_listen_port,
_aws_handlers,
parameters,
shard=shard,
custom_logger=logger,
listen_address=config.admin_listen_address)
self.file_cacher = FileCacher(self)
self.evaluation_service = self.connect_to(
ServiceCoord("EvaluationService", 0))
self.scoring_service = self.connect_to(
ServiceCoord("ScoringService", 0))
self.resource_services = []
for i in xrange(get_service_shards("ResourceService")):
self.resource_services.append(self.connect_to(
ServiceCoord("ResourceService", i)))
self.logservice = self.connect_to(ServiceCoord("LogService", 0))
def main():
parser = ArgumentParser()
parser.add_argument("--standalone", action="store_true")
parser.add_argument("--debug", action="store_true")
opts = parser.parse_args()
if opts.standalone:
Control.STANDALONE = True
if opts.debug:
Control.logger.setLevel(logging.DEBUG)
try:
request = WebService.Request(Control.STANDALONE, Control.logger)
if request.logLevel > 1:
Control.logger.setLevel(logging.DEBUG)
Control.logger.info("%s request from %s", request.type, request.client)
Control.logger.debug("Request body:\n%s", request.message)
if request.type == "Ticket":
response = check_ticket(Ticket(request.doc))
elif request.type == "Manifest":
response = make_delta(Manifest(request.doc))
else:
error = "Don't understand %r" % request.type
response = WebService.ErrorResponse(error, Control.logger)
except Exception as e:
response = WebService.ErrorResponse(str(e), Control.logger)
Control.logger.debug("Response:\n%s\n", response.body)
if Control.STANDALONE:
sys.stdout.write(response.body)
else:
response.send()
def get_defect(mergedDefectDO, scope):
try:
return WebService.DefectHandler(mergedDefectDO,
projectId=scope.projectId,
projectDOs=scope.projectDOs,
scope=scope.triage_scope())
except UnboundLocalError:
return WebService.DefectHandler(mergedDefectDO,
scope=scope.triage_scope())
def check_ticket(client_ticket):
server_ticket = load_server_manifest(include_file_list=False).ticket
Control.logger.debug("client_ticket.host: %s", client_ticket.host, 2)
Control.logger.debug("server_ticket.host: %s", server_ticket.host, 2)
Control.logger.debug("client_ticket.checksum: %s", client_ticket.checksum)
Control.logger.debug("server_ticket.checksum: %s" % server_ticket.checksum)
Control.logger.debug("client_ticket.timestamp: %s",
client_ticket.timestamp)
Control.logger.debug("server_ticket.timestamp: %s",
server_ticket.timestamp)
response = etree.Element("Current")
response.text = (client_ticket == server_ticket) and "Y" or "N"
return WebService.Response(response, Control.logger)
def make_delta(client_manifest):
server_manifest = load_server_manifest()
client_files = {}
server_files = {}
to_be_installed = []
to_be_deleted = []
manifest_name = None
for f in client_manifest.files:
client_files[f.name.upper()] = f
for f in server_manifest.files:
server_files[f.name.upper()] = f
for key in server_files:
serverFile = server_files[key]
if "CDRMANIFEST.XML" in key:
manifest_name = serverFile.name
if key not in client_files:
Control.logger.debug("adding new client file %s", serverFile.name)
to_be_installed.append(serverFile.name)
elif client_files[key] != serverFile:
Control.logger.debug("adding changed client file %s",
serverFile.name)
to_be_installed.append(serverFile.name)
for key in client_files:
if key not in server_files:
name = client_files[key].name
Control.logger.debug("client file %s to be deleted", name)
to_be_deleted.append(name)
updates = etree.Element("Updates")
if to_be_installed:
if manifest_name and manifest_name not in to_be_installed:
to_be_installed.append(manifest_name)
Control.logger.debug("sending %d files to be installed",
len(to_be_installed))
zip_file = base64.encodestring(build_zip_file(to_be_installed))
etree.SubElement(updates, "ZipFile", encoding="base64").text = zip_file
if to_be_deleted:
Control.logger.debug("%d files will be removed", len(to_be_deleted))
deletions = etree.SubElement(updates, "Delete")
for name in to_be_deleted:
etree.SubElement(deletions, "File").text = name
return WebService.Response(updates, Control.logger)
#print node.toxml()
if node.nodeType == node.TEXT_NODE:
rc.append(node.data)
return ''.join(rc)
def getNodeText(element, nodename):
try:
return getText((element.getElementsByTagName(nodename)[0]).childNodes)
except IndexError:
return None
if __name__ == '__main__':
wsOpts = WebService.WSOpts()
parser = wsOpts.get_common_opts()
parser.add_option("--inputfile",
dest="inputfile",
help="XML file exported from CIM")
parser.add_option("--debug",
action="store_true",
dest="debug",
help="XML file exported from CIM")
(options, args) = parser.parse_args()
if not options.inputfile:
print "Input file of defects to be exported must be specified"
sys.exit(-1)
reload(sys)
sys.setdefaultencoding("latin-1")
def scrapeHeadlines(text):
headlines = "";
lines = text.splitlines()
for line in lines:
if (string.find(line, "<a href") == 0):
pos1 = string.find(line, "<b>")
if pos1 > 0:
pos2 = string.find(line, "</b>")
if pos2 > 0:
headlines += line[pos1+len("<b>"):pos2] + ".\n"
return headlines
print '--- Creating Headline Web Service'
news_service = WebService.ServiceProxy("http://www.soapclient.com/xml/SQLDataSoap.WSDL");
print '--- Calling Headline Web Service'
news = news_service.ProcessSRL("NEWS.SRI", "yahoo", "");
headlines = scrapeHeadlines(news)
print '--- Got headlines in English'
print headlines
print '--- Creating Translation Web Service'
babel_service = WebService.ServiceProxy("http://www.xmethods.net/sd/BabelFishService.wsdl");
print '--- Calling Translation Web Service'
translation = babel_service.BabelFish("en_fr", headlines)
print '--- Translated headlines:'
print translation
print '--- Done!'
def defect_scope(self, client):
return WebService.OptionsProcessor(self.options, client)
def __init__(self, reporters):
self._p = WebService.WSOpts().get_common_opts()
# use --test flag to avoid sending e-mail while debugging this script
self._p.set_defaults(testing="false")
self._p.set_defaults(raw="false")
self._p.set_defaults(quiet="false")
self._p.add_option("--test",
action="store_true",
dest="testing",
help="Testing flag: no mail just echo to stdout")
self._p.add_option("--dest",
dest="reporter",
default='subscribers',
help="Send to whom? " + ','.join(reporters.keys()))
self._p.add_option(
"--unassigned-to",
dest="unassigned_to",
default=None,
help="Send report of unassigned defects to this user")
self._p.add_option("--format",
dest="format",
default='table',
help="Report format (%s)" %
(','.join(templates.available_formats.keys()), ))
self._p.add_option("--chart_field",
dest="field",
default='',
help="Primary field for chart")
self._p.add_option("--chart_stack_field",
dest="stack_field",
default='',
help="Stacking field for chart")
self._p.add_option("--title",
dest="title",
default=None,
help="Title for chart")
self._p.add_option("--raw",
action='store_true',
dest="raw",
help="Exclude headers in CSV output")
self._p.add_option("--quiet",
action='store_true',
dest="quiet",
help="Exclude unnecessary script output.")
# Make sure we validate options
def validate_reporter(options, args):
try:
reporters[options.reporter]
except KeyError:
return ['Unknown "--dest" value ' + options.reporter]
self._p.add_validator(validate_reporter)
def validate_format(options, args):
global render_email
try:
render_email = templates.available_formats[options.format]
except KeyError:
return ['Unknown "--format" value ' + options.format]
self._p.add_validator(validate_format)
def main(dev):
if dev != True:
check_admin()
kill_self()
add_hosts()
WebService.run_app()
# -*- encoding: utf-8 -*-
import sys
sys.dont_write_bytecode = True
from WebService import *
from TranslationService import *
import requests_cache
print("Setting up cache")
requests_cache.install_cache('translation.cache', backend='sqlite')
web = WebService("0.0.0.0", 11000)
web.start()
