예제 #1
0
파일: github.py 프로젝트: spacepod/Addama
 def isMatchingIP(self, ip):
     for permitted in PERMITTED_IPS:
         match = fnmatch.filter([ip], permitted)
         if match:
             logging.info("WebHook: isMatchingIP() [%s, %s, %s]" % (ip, permitted, match))
             return True
     return False
예제 #2
0
    def get(self, identity):
        logging.info("uri=%s [%s] [%s]" % (self.request.uri, identity, self.request.arguments))

        args = self.request.arguments

        query = {}
        for key in args.keys():
            if key != "cancer":
                continue
            iargs = args[key]
            if len(iargs) == 1:
                query[key] = args[key][0].lower()
            else:
                query[key] = {"$in": map(lambda x: x.lower(), args[key])}

        if "max_rank" not in args:
            query["rank"] = {"$lt": 21}
        else:
            query["rank"] = {"$lt": int(args["max_rank"][0]) + 1}

        collection = self.open_collection("qed_lookups", "mutsig_rankings")
        items = []
        if "cancer" in query:
            items = collection.find(query)

        json_items = map(self.jsonable_item, items)
        if self.get_argument("output", "json") == "tsv":
            WriteTsv(self, json_items)
            self.set_status(200)
            return

        self.write(json.dumps({ "items": json_items }))
        self.set_status(200)
예제 #3
0
    def get(self, identity):
        logging.info("uri=%s [%s] [%s]" % (self.request.uri, identity, self.request.arguments))

        args = self.request.arguments
        ids = identity.split("/")

        query = {
            "chr": str(args["chr"][0]),
            "start": {"$gt": int(args["start"][0])},
            "end": {"$lt": int(args["end"][0])},
            "cancer": {"$in": map(lambda x: x.lower(), args["cancer"])},
            "source": {"$in": map(lambda x: x.lower(), args["source"])}
        }

        logging.info("query=%s" % str(query))

        query_limit = options.mongo_lookup_query_limit
        collection = self.open_collection(ids[1], ids[2])

        items = []
        for idx, item in enumerate(collection.find(query, {'values':0})):
            if idx > query_limit: break
            items.append(item)

        self.write(json.dumps({ "items": map(self.jsonable_item, items) }))
        self.set_status(200)
예제 #4
0
 def get(self, vcf_id, chromosome, coordinate):
     global VCF_MAP
     
     if vcf_id not in DATA_MAP:
         logging.info("Unknown VCF id \'" + vcf_id + "\'")
         raise tornado.web.HTTPError(404)
     
     file_info = DATA_MAP[vcf_id]
     file_path = file_info['path']
     lookup_fn = None
     if file_info['type'] == 'vcf':
         lookup_fn = vcf_lookup
     elif file_info['type'] == 'trio':
         lookup_fn = triotype_lookup
     else:
         logging.error("Unknown type for file " + file_path)
         raise tornado.web.HTTPError(404)
     
     try:
         result = lookup_fn(options.tabix_executable, file_path, chromosome, coordinate, coordinate)
         response = {
             "chr": result.chromosome,
             "coordinate": result.coordinate,
             "values": result.values
         }
         
         self.write(json.dumps(response, sort_keys=True))
         self.set_status(200)
     except Exception as e:
         logging.error("Running tabix failed:")
         logging.error(e)
         raise tornado.web.HTTPError(404)
예제 #5
0
def main():
    define("port", default=8321, help="Server port", type=int)
    define("verbose", default=False, help="Prints debugging statements")
    define("tabix_executable", default=".", help="Path to tabix executable")
    define("vcf_config", default=".", help="Path to VCF configuration JSON")

    tornado.options.parse_command_line()

    logging.info("Starting Tornado web server on http://localhost:%s" % options.port)
    logging.info("--tabix_executable=%s" % options.tabix_executable)
    logging.info("--vcf_config=%s" % options.vcf_config)
    logging.info("--verbose=%s" % options.verbose)

    # Try loading the VCF mapping
    logging.info("Loading VCF configuration file \'" + options.vcf_config + "\'...")
    try:
        global DATA_MAP
        DATA_MAP = parse_vcf_config(options.vcf_config)
    except Exception as e:
        logging.error("Failed to load VCF configuration file:")
        logging.error(e)
        sys.exit(1)

    application = tornado.web.Application([
        (r"/(\w+)/(X|Y|M|\d{1,2})/(\d+)", TabixLookup)
    ], **settings)
    application.listen(options.port, **server_settings)
    tornado.ioloop.IOLoop.instance().start()
예제 #6
0
def open_collection(db_name, collection_name):
    #if options.verbose:
    logging.info("open_collection(%s)" % collection_name)

    connection = pymongo.Connection(options.mongo_lookup_uri)
    database = connection[db_name]
    return database[collection_name]
예제 #7
0
    def get(self, identity):
        logging.info("uri=%s [%s] [%s]" % (self.request.uri, identity, self.request.arguments))

        # TODO : Improve this logic to correctly parse arguments and convert to a proper mongo DB query
        args = self.request.arguments
        query = {}
        for key in args.keys():
            query[key] = args[key][0]

        ids = identity.split("/")

        db_name = ids[1]
        collection = open_collection(db_name, ids[2])

        query_limit = options.mongo_lookup_query_limit
        json_items = []
        for idx, item in enumerate(collection.find(query)):
            if idx > query_limit:  break

            json_item = self.jsonable_item(item)
            json_item["uri"] = self.request.uri + "/" + json_item["id"]
            json_items.append(json_item)

        self.write({ "items": json_items })
        self.set_status(200)
        return
예제 #8
0
    def open_collection(self, db_name, collection_name):
        #if options.verbose:
        logging.info("open_collection(%s)" % collection_name)

        connection = pymongo.Connection(options.mongo_lookup_uri)
        database = connection[db_name]
        return database[collection_name]
예제 #9
0
 def get(self, vcf_id, chromosome, start_coordinate, end_coordinate):
     global VCF_MAP
     
     if vcf_id not in DATA_MAP:
         logging.info("Unknown VCF id \'" + vcf_id + "\'")
         raise tornado.web.HTTPError(404)
     
     file_info = DATA_MAP[vcf_id]
     file_path = file_info['path']
     lookup_fn = None
     if file_info['type'] == 'tsv':
         lookup_fn = tsv_region_lookup
     else:
         logging.error("Unknown type for file " + file_path)
         raise tornado.web.HTTPError(404)
     
     try:
         # The result.values array contains dictiories, for which the keys are read from the header line
         # of the TSV file. For the header line to be included in the output of the tabix command, the "-h"
         # flag has to be included in the command line.
         result = lookup_fn(options.tabix_executable + " -h", file_path, chromosome, start_coordinate, end_coordinate)
         response = {
             "chr": result.chromosome,
             "start": result.start,
             "end": result.end,
             "values": result.values
         }
         
         self.write(json.dumps(response, sort_keys=True))
         self.set_status(200)
     except Exception as e:
         logging.error("Running tabix failed:")
         logging.error(e)
         raise tornado.web.HTTPError(404)
예제 #10
0
파일: github.py 프로젝트: spacepod/Addama
    def post(self, *args, **kwargs):
        logging.info("WebHook: post()")
        if not self.isPermittedIP():
            self.set_status(401)
            return

        http_client = tornado.httpclient.HTTPClient()

        response = http_client.fetch(options.github_repo_api_url)
        repository = json.loads(response.body)
        clone_url = repository["clone_url"].replace("https", "http")

        self.pull(clone_url, options.github_project_root, "master")

        branches_url = repository["branches_url"].replace("{/branch}", "")
        response = http_client.fetch(branches_url)
        branches = json.loads(response.body)

        write_branches = []
        for i, branch in enumerate(branches):
            branch_name = branch["name"]
            if not branch_name == "master":
                deploy_path = os.path.join(options.github_branches_root, branch_name)
                logging.info("WebHook: deploying branch [%s] to [%s]" % (branch_name, deploy_path))
                self.pull(clone_url, deploy_path, branch_name)

                write_branches.append({ "name": branch_name, "label": branch_name })

        if not options.github_branches_json_path is None:
            json.dump(write_branches, open(os.path.join(options.github_branches_json_path, "branches.json"), "w"))
예제 #11
0
def main():
    tornado.options.parse_command_line()
    logging.info("Starting Tornado web server on http://localhost:%s" % options.port)
    application = tornado.web.Application([
        (r"/", MainHandler),
    ], **settings)
    application.listen(options.port, **server_settings)
    tornado.ioloop.IOLoop.instance().start()
예제 #12
0
def main():
    tornado.options.parse_command_line()
    logging.info("Starting Tornado web server on http://localhost:%s" %
                 options.port)
    application = tornado.web.Application([
        (r"/", MainHandler),
    ], **settings)
    application.listen(options.port, **server_settings)
    tornado.ioloop.IOLoop.instance().start()
예제 #13
0
    def get(self):
        logging.info("AuthWhoAmiHandler.get")

        whoami = {
            "user": "******",
            "label": "Hector Rovira"
        }
        self.write(whoami)
        self.set_status(200)
예제 #14
0
파일: mongodb.py 프로젝트: ryanbressler/QED
def SaveUserinfo(whoami, userinfo):
    logging.info("SaveUserinfo(%s)" % whoami)

    existing_user = GetUserinfo(whoami)
    userinfo["whoami"] = whoami

    collection = open_collection("private_userinfo")
    if existing_user is None:
        collection.insert(userinfo)
    else:
        collection.update(existing_user, userinfo)
    def on_message(self, message):
        logging.info("New Note %s" % message)

        newnote = message
        newnote_json = json.loads(newnote)
        newnote_json["timestamp"] = datetime.now()
        notes = get_notes_collection()
        notes.insert(newnote_json)

        for connected_user in connected_users:
            connected_user.write_message(json.dumps([newnote_json], default=json_util.default))
예제 #16
0
파일: mongodb.py 프로젝트: ITMI/QED
def SaveUserinfo(whoami, userinfo):
    logging.info("SaveUserinfo(%s)" % whoami)

    existing_user = GetUserinfo(whoami)
    userinfo["whoami"] = whoami

    collection = open_collection("private_userinfo")
    if existing_user is None:
        collection.insert(userinfo)
    else:
        collection.update(existing_user, userinfo)
예제 #17
0
def redis_listener():
	try:
		ps = r.pubsub()
		ps.subscribe(settings.REDIS['channel'])
		io_loop = tornado.ioloop.IOLoop.instance()
		for message in ps.listen():		
			for socket in LISTENERS['ws']:
				io_loop.add_callback(partial(socket.on_message,message))
	# Note: Not sure if this block will be reached at all
	except:
		logging.info('redis_listener() aborted. Stop subscribing.')
		ps.close()
예제 #18
0
파일: app.py 프로젝트: Odomontois/tomongo
def main():
    tornado.options.parse_command_line()
    tornado.web.RequestHandler.instanceNum = options.instn
    port = 9900 + options.instn
    logging.info("Starting Tornado web server on http://localhost:%s" % port)
    application = tornado.web.Application([
        (r"/",MainHandler),
        (r"/greet", Greeter),
        (r"/fingreet",MongoGreeter)
        
    ], **settings)
    application.listen(port, **server_settings)
    tornado.ioloop.IOLoop.instance().start()
    def open(self):
        logging.info("Connection opened")

        notes = get_notes_collection()

        most_recent_notes = list(
            notes.find({"loc": {"$exists": "true"}, "timestamp": {"$exists": "true"}}, limit=25).sort(
                "timestamp", DESCENDING
            )
        )

        connected_users.append(self)

        self.write_message(json.dumps(most_recent_notes, default=json_util.default))
예제 #20
0
파일: mongodb.py 프로젝트: hrovira/proforma
    def post(self, identity):
        logging.info("MongoDbHandler.post(%s)" % identity)

        ids = identity.split("/")
        if len(ids) <= 0: raise HTTPError(401)

        stored_item = json.loads(self.request.body)
        # Figure out issue where label is getting set as an array
        labels = stored_item["label"]
        if not labels is None and type(labels) is list: stored_item["label"] = labels[0]

        collection = open_collection(ids[0])
        insert_id = str(collection.insert(stored_item))

        self.write({ "id": insert_id, "uri": self.request.uri + "/" + insert_id })
        self.set_status(200)
예제 #21
0
def plot(timeseries,fig_name):
    matplotlib.rc('font', **settings.PLOT['font'])
    plt.figure(figsize=(14,2.5), dpi=72)	
    ax = plt.subplot(1,1,1)  
    rts = pd.rolling_mean(timeseries, settings.PLOT['rolling_mean_min'])
    plt.plot(rts.index, rts.values, settings.PLOT['fill'])
    plt.ylabel('Tweets per minute (TPM)')
    ax.fill_between(rts.index, rts.values, 0, color=settings.PLOT['fill'])
    ax.xaxis.set_major_locator(md.HourLocator(interval=settings.PLOT['xaxis_interval_hr']))
    ax.xaxis.set_major_formatter(md.DateFormatter(settings.PLOT['datetime_format']))
    ax.autoscale_view()
    plt.grid(True)
    plt.xlabel('Time (SGT)')
    fig = os.path.join(settings.SERVER['static_files_path'],'images',fig_name)
    plt.savefig(fig,bbox_inches='tight')
    logging.info('Saving %s' % fig)
예제 #22
0
파일: mongodb.py 프로젝트: hrovira/proforma
    def get(self, identity):
        logging.info("MongoDbHandler.get(%s)" % identity)

        ids = identity.split("/")
        if len(ids) == 1:
            args = self.request.arguments
            query = {}

            normalize_fn = lambda x: x.lower()

            for key in args.keys():
                iargs = args[key]
                if len(iargs) == 1:
                    query[key] = normalize_fn(args[key][0])
                else:
                    query[key] = {"$in": map(normalize_fn, args[key])}

            collection = open_collection(ids[0])
            json_items = []

            for idx, item in enumerate(collection.find(query)):
                json_item = jsonable_item(item)
                json_item["uri"] = self.request.uri + "/" + json_item["id"]
                json_items.append(json_item)

            json_items.append({
                "First Name": "Hector",
                "Last Name": "Rovira",
                "Birth Date": "03/14/13",
                "status": "incomplete"
            })

            self.write({ "items": json_items })
            self.set_status(200)
            return

        if len(ids) == 2:
            collection = open_collection(ids[0])
            item = collection.find_one({"_id": objectid.ObjectId(ids[1]) })
            if not item is None:
                json_item = jsonable_item(item)
                json_item["uri"] = self.request.uri
                self.write(json_item)
                self.set_status(200)
                return

        self.set_status(404)
예제 #23
0
 def get(self, tabix_id, chromosome, start_coordinate, end_coordinate=None):
     if end_coordinate is None:
         end_coordinate = start_coordinate
     
     if tabix_id not in self._config_map.keys():
         if options.verbose:
             logging.info("Unknown tabix loookup ID [%s]" % tabix_id)
         raise tornado.web.HTTPError(404)
     
     file_info = self._config_map[tabix_id]
     file_path = file_info['path']
     lookup_fn = None
     tabix_exe = None
     
     if file_info['type'] == 'vcf':
         lookup_fn = vcf_singleline_lookup
         tabix_exe = options.tabix_executable
     elif file_info['type'] == 'trio':
         lookup_fn = triotype_singleline_lookup
         tabix_exe = options.tabix_executable
     elif file_info['type'] == 'tsv':
         lookup_fn = tsv_region_lookup
         # For parsing the tabix output for TSV files, the header has to be included. Therefore, the "-h"
         # flag has to be included in the command line.
         tabix_exe = options.tabix_executable + " -h"
     else:
         logging.error("Unknown type for file " + file_path)
         raise tornado.web.HTTPError(404)
     
     try:
         result = lookup_fn(tabix_exe, file_path, chromosome, start_coordinate, end_coordinate)
         response = {
             "chr": result.chromosome,
             "start": result.start,
             "end": result.end,
             "values": result.values,
             "snpid": result.snpid,
             "info": result.info
         }
         
         self.write(json.dumps(response, sort_keys=True))
         self.set_status(200)
     except Exception as e:
         logging.error("Running tabix failed:")
         logging.error(e)
         raise tornado.web.HTTPError(404)
예제 #24
0
    def get(self, identity):
        logging.info("uri=%s [%s] [%s]" % (self.request.uri, identity, self.request.arguments))

        args = self.request.arguments

        ids = identity.split("/")

        feature_matrix_name = ids[1]
        gene_label_1 = args['gene1'][0]
        gene_label_2 = args['gene2'][0]
        cancer_label = args['cancer'][0].lower()

        # Get feature IDs
        fmx_collection = self.open_feature_matrix_collection("qed_lookups", "fmx_" + feature_matrix_name)
        pairwise_collection = self.open_pairwise_collection("qed_lookups", "pw_" + feature_matrix_name + "_" + cancer_label)

        features_1 = filter(self.feature_filter_fn, fmx_collection.find({"cancer": cancer_label, "gene": gene_label_1}))
        features_2 = filter(self.feature_filter_fn, fmx_collection.find({"cancer": cancer_label, "gene": gene_label_2}))
        feature_ids_1 = map(lambda f: f['id'], features_1)
        feature_ids_2 = map(lambda f: f['id'], features_2)

        # Get pairwise values
        pairwise_results = []
        for id1, id2 in product(feature_ids_1, feature_ids_2):
            pw = self.get_pairwise_result(pairwise_collection, id1, id2)
            if pw is not None:
                pairwise_results.append(pw)

        result = {
            "features": {
                gene_label_1: map(self.jsonable_item, features_1),
                gene_label_2: map(self.jsonable_item, features_2)
            },
            "pairwise_results": map(self.jsonable_item, pairwise_results)
        }

        log_msg = "Features found: "
        log_msg += gene_label_1 + ": " + str(len(feature_ids_1))
        log_msg += "\t" + gene_label_2 + ": " + str(len(feature_ids_2))
        log_msg += "\tPairwise results: " + str(len(pairwise_results))

        logging.info(log_msg)

        self.write(json.dumps(result))
        self.set_status(200)
예제 #25
0
    def get(self, identity):
        logging.info("uri=%s [%s] [%s]" % (self.request.uri, identity, self.request.arguments))

        ids = identity.split("/")
        db_name = ids[1]
        collection = self.open_collection(db_name, ids[2])

        # TODO : Improve this logic to correctly parse arguments and convert to a proper mongo DB query
        args = self.request.arguments
        query = {}

        case_sensitive_lookups = frozenset(options.case_sensitive_lookups)
        normalize_fn = None
        if db_name in case_sensitive_lookups:
            normalize_fn = lambda x: x
        else:
            normalize_fn = lambda x: x.lower()

        for key in args.keys():
            if key != "output":
                iargs = args[key]
                if len(iargs) == 1:
                    query[key] = normalize_fn(args[key][0])
                else:
                    query[key] = {"$in": map(normalize_fn, args[key])}

        query_limit = options.mongo_lookup_query_limit
        json_items = []
        for idx, item in enumerate(collection.find(query)):
            if idx > query_limit:
                break

            json_item = self.jsonable_item(item)
            json_item["uri"] = self.request.uri + "/" + json_item["id"]
            json_items.append(json_item)

        if self.get_argument("output", "json") == "tsv":
            WriteTsv(self, json_items)
            self.set_status(200)
            return

        self.write({"items": json_items})
        self.set_status(200)
        return
예제 #26
0
    def get(self, identity):
        logging.info("uri=%s [%s] [%s]" % (self.request.uri, identity, self.request.arguments))

        args = self.request.arguments

        cancer_mappings= {
            "brca": "brca_pw_manuscript"
        }

        gene = args["gene"][0]
        source = args["source"][0]
        dataset = cancer_mappings[args["cancer"][0]]
        logging.info("query=[%s][%s][%s]" % (gene, source, dataset))

        cli = HTTPClient()
        response = cli.fetch("http://explorer.cancerregulome.org/data/distributed_select/?q=%2Bf1source%3A%22" + source + "%22%2Bf1label%3A(%22" + gene + "%22)%20%2Blogged_pvalue%3A%5B6%20TO%20*%5D&sort=logged_pvalue%20desc&rows=200&fl=alias1%2Calias2%2Cf1qtinfo%2Cf2qtinfo%2Clink_distance%2Clogged_pvalue%2Ccorrelation%2Cnum_nonna&wt=json&fq=%2Bdataset%3A" + dataset)
        cli.close()
        self.write(response.body)
        self.set_status(200)
예제 #27
0
파일: rt_pairwise.py 프로젝트: ITMI/QED
def main():
    tornado.options.parse_command_line()

    logging.info("Starting Tornado web server on http://localhost:%s" % options.port)
    logging.info("--data_path=%s" % options.data_path)
    logging.info("--executable=%s" % options.executable)
    logging.info("--verbose=%s" % options.verbose)

    application = tornado.web.Application([
        (r"/", RealtimePairwise),
        (r"/svc/rt_pairwise", RealtimePairwise),
    ], **settings)
    application.listen(options.port, **server_settings)
    tornado.ioloop.IOLoop.instance().start()
예제 #28
0
def main():
    parse_command_line()
    if not options.config_file is None:
        parse_config_file(options.config_file)
        parse_command_line()

    if not options.client_secret is None:
        settings["cookie_secret"] = options.client_secret

    logging.info("Starting tornadoweb on http://localhost:%s" % options.port)
    if not options.config_file is None:
        logging.info("--config_file=%s" % options.config_file)

    application = Application([
        (r"/auth/whoami", AuthWhoAmiHandler),
        (r"/auth/signout", AuthSignoutHandler),
        (r"/dao/?(.*)", MongoDbHandler),
        (r"/", RootHandler),
        (r"/(.*)", StaticFileHandler, {"path": "_public"})
    ], **settings)
    application.listen(options.port, **server_settings)

    IOLoop.instance().start()
예제 #29
0
파일: mongodb.py 프로젝트: ITMI/QED
def GetUserinfo(whoami):
    logging.info("GetUserinfo(%s)" % whoami)

    collection = open_collection("private_userinfo")
    return collection.find_one({ "whoami": whoami })
예제 #30
0
from tornado.options import logging
from tornado import httpserver, ioloop


def handle_request(request):
    message = """
                   <!DOCTYPE html>
                   <html lang="en">
                   <head>
 <title>Good to see it. - test designed By Richard, </title>
                   <meta charset="UTF-8" />
                   </head>
                   <body>
    It's good to see it here. Server has been started in master branch.
                   </body>
                   </html>
                   """

    request.write("HTTP/1.1 200 OK\r\nContent-Length: %d\r\n\r\n%s" % (len(message), message))
    request.finish()


if __name__ == "__main__":
    logging.info("Now I am at master branch! In the first commit")
    http_server = httpserver.HTTPServer(handle_request)
    http_server.listen(8888)
    ioloop.IOLoop.instance().start()


# master.py ended here
예제 #31
0
파일: tornadoapp.py 프로젝트: ITMI/QED
def main():
    tornado.options.parse_command_line()
    if not options.config_file is None:
        tornado.options.parse_config_file(options.config_file)
        tornado.options.parse_command_line()

    settings["cookie_secret"] = options.client_secret

    logging.info("Starting Tornado web server on http://localhost:%s" % options.port)
    logging.info("--data_path=%s" % options.data_path)
    logging.info("--client_host=%s" % options.client_host)
    logging.info("--authorized_users=%s" % options.authorized_users)
    logging.info("--mongo_uri=%s" % options.mongo_uri)
    logging.info("--mongo_lookup_uri=%s" % options.mongo_lookup_uri)
    logging.info("--mongo_lookup_query_limit=%s" % options.mongo_lookup_query_limit)

    if not options.config_file is None:
        logging.info("--config_file=%s" % options.config_file)

    application = tornado.web.Application([
        (r"/", MainHandler),
        (r"/data?(.*)", LocalFileHandler),
        (r"/auth/signin/google", GoogleOAuth2Handler),
        (r"/auth/signin/google/oauth2_callback", GoogleOAuth2Handler),
        (r"/auth/signout/google", GoogleSignoutHandler),
        (r"/auth/whoami", WhoamiHandler),
        (r"/auth/providers", AuthProvidersHandler),
        (r"/storage/(.*)", MongoDbStorageHandler),
        (r"/lookups?(.*)", MongoDbLookupHandler),
        (r"/mutsig_rankings?(.*)", MongoDbMutSigHandler),
        (r"/pw_lookups?(.*)", MongoDbMutSigHandler),
        (r"/features_by_location?(.*)", MongoDbFeaturesByLocationHandler),
        (r"/RE/query/?(.*)", RegulomeExplorerDbQueryHandler)
    ], **settings)
    application.listen(options.port, **server_settings)
    tornado.ioloop.IOLoop.instance().start()
예제 #32
0
def main():
    tornado.options.parse_command_line()
    if not options.config_file is None:
        tornado.options.parse_config_file(options.config_file)
        tornado.options.parse_command_line()

    settings["cookie_secret"] = options.client_secret

    logging.info("Starting Tornado web server on http://localhost:%s" %
                 options.port)
    logging.info("--data_path=%s" % options.data_path)
    logging.info("--client_host=%s" % options.client_host)
    logging.info("--authorized_users=%s" % options.authorized_users)
    logging.info("--mongo_uri=%s" % options.mongo_uri)
    logging.info("--mongo_lookup_uri=%s" % options.mongo_lookup_uri)
    logging.info("--mongo_lookup_query_limit=%s" %
                 options.mongo_lookup_query_limit)

    if not options.config_file is None:
        logging.info("--config_file=%s" % options.config_file)

    application = tornado.web.Application(
        [(r"/", MainHandler), (r"/data?(.*)", LocalFileHandler),
         (r"/auth/signin/google", GoogleOAuth2Handler),
         (r"/auth/signin/google/oauth2_callback", GoogleOAuth2Handler),
         (r"/auth/signout/google", GoogleSignoutHandler),
         (r"/auth/whoami", WhoamiHandler),
         (r"/auth/providers", AuthProvidersHandler),
         (r"/storage/(.*)", MongoDbStorageHandler),
         (r"/lookups?(.*)", MongoDbLookupHandler)], **settings)
    application.listen(options.port, **server_settings)
    tornado.ioloop.IOLoop.instance().start()
예제 #33
0
파일: mongodb.py 프로젝트: ryanbressler/QED
def GetUserinfo(whoami):
    logging.info("GetUserinfo(%s)" % whoami)

    collection = open_collection("private_userinfo")
    return collection.find_one({ "whoami": whoami })
예제 #34
0
import tornado.web
from tornado.options import define, options, logging


define('port', default=8888, help='run on the given port', type=int)
# Set up logging location
tornado.options.options['log_file_prefix'].set(settings.SERVER['log_file_prefix'])

# Register handlers for each application
handlers = [
	(r'/stream', stream.WebHandler), # Register a handler for real-time TPM
	(r'/ws_stream', stream.WSHandler), # Register a handler for real-time TPM Websocket
	(r'/(.*)', tornado.web.StaticFileHandler, {'path': settings.SERVER['static_files_path']},), # Register a handler for a base directory for static files, e.g., images, scripts, etc.
]
settings = dict(
		template_path=os.path.join(os.path.dirname(__file__),'static/templates'),
		debug='True',
	)
application = tornado.web.Application(handlers,**settings)

# Start HTTP server
if __name__ == '__main__':
	threading.Thread(target=stream.redis_listener).start()

	tornado.options.parse_command_line() # Enable pretty console logging
	logging.info('Starting Tornado server on port %s' % options.port)
	http_server = tornado.httpserver.HTTPServer(application)
	http_server.listen(options.port)
	tornado.ioloop.IOLoop.instance().start()
	
	
예제 #35
0
    def open_collection(self, mongo_uri, db_name, collection_name):
        logging.info("open_collection(%s)" % collection_name)

        connection = pymongo.Connection(mongo_uri)
        database = connection[db_name]
        return database[collection_name]