def start(self): """ When the bus starts, the plugin is also started and we load the Django application. We then mount it on the CherryPy engine for serving as a WSGI application. We let CherryPy serve the application's static files. """ cherrypy.log("Loading and serving the Django application") cherrypy.tree.graft(WSGIHandler()) # Serve the content files static_handler = cherrypy.tools.staticdir.handler( section="/", dir=os.path.split(settings.CONTENT_ROOT)[1], root=os.path.abspath(os.path.split(settings.CONTENT_ROOT)[0]) ) cherrypy.tree.mount(static_handler, settings.CONTENT_URL) # Serve the static media files static_handler = cherrypy.tools.staticdir.handler( section="/", dir=os.path.split(settings.MEDIA_ROOT)[1], root=os.path.abspath(os.path.split(settings.MEDIA_ROOT)[0]) ) cherrypy.tree.mount(static_handler, settings.MEDIA_URL) # Serve the static admin media. From django's internal (django.core.servers.basehttp) admin_static_dir = os.path.join(django.__path__[0], 'contrib', 'admin', 'static') admin_static_handler = cherrypy.tools.staticdir.handler( section='/', dir='admin', root=admin_static_dir ) cherrypy.tree.mount(admin_static_handler, urlparse.urljoin(settings.STATIC_URL, 'admin'))
def __init__(self, app, config, mount): """ :arg app: reference to application object; passed to all entities. :arg config: reference to configuration; passed to all entities. :arg str mount: API URL mount point; passed to all entities.""" RESTApi.__init__(self, app, config, mount) cherrypy.log("ReqMgr entire configuration:\n%s" % Configuration.getInstance()) cherrypy.log("ReqMgr REST hub configuration subset:\n%s" % config) # Makes raw format as default # self.formats.insert(0, ('application/raw', RawFormat())) self._add({"about": Info(app, IndividualCouchManager(config), config, mount), "info": Info(app, IndividualCouchManager(config), config, mount), "app_config": ReqMgrConfigData(app, IndividualCouchManager(config), config, mount), "request": Request(app, IndividualCouchManager(config), config, mount), "cmsswversions": CMSSWVersions(app, IndividualCouchManager(config), config, mount), "wmagentconfig": WMAgentConfig(app, IndividualCouchManager(config), config, mount), "permissions": PermissionsConfig(app, IndividualCouchManager(config), config, mount), "campaignconfig": WMAgentConfig(app, IndividualCouchManager(config), config, mount), "unifiedconfig": UnifiedConfig(app, IndividualCouchManager(config), config, mount), "status": RequestStatus(app, IndividualCouchManager(config), config, mount), "type": RequestType(app, IndividualCouchManager(config), config, mount), "spec_template": RequestSpec(app, IndividualCouchManager(config), config, mount), "workload_config": WorkloadConfig(app, IndividualCouchManager(config), config, mount), "splitting": WorkloadSplitting(app, IndividualCouchManager(config), config, mount), "wmstats_info": WMStatsInfo(app, IndividualCouchManager(config), config, mount), "proc_status": ProcessMatrix(app, self, config, mount) })
def _start(self): # Output config options to log if cherrypy.config.get("server.logConfigOptions", True): cherrypy.config.outputConfigMap() try: configure() for func in cherrypy.server.onStartServerList: func() self.start_http_server() self.state = STARTED if self.blocking: # Block forever (wait for KeyboardInterrupt or SystemExit). while True: time.sleep(.1) if self.interrupt: raise self.interrupt except KeyboardInterrupt: cherrypy.log("<Ctrl-C> hit: shutting down server", "HTTP") self.stop() except SystemExit: cherrypy.log("SystemExit raised: shutting down server", "HTTP") self.stop()
def __init__(self): cherrypy.log("Initializing Webserver") cherrypy.config.update({'request.error_response': self.handle_error}) cherrypy.config.update({'error_page.404': self.error_404}) cherrypy.config.update({'error_page.401': self.error_401}) self.sensors = SensorsPage() self.zones = ZonesPage() self.setups = SetupsPage() self.alarms = AlarmsPage() self.workers = WorkersPage() self.actions = ActionsPage() self.notifiers = NotifiersPage() self.sensorparams = SensorParamsPage() self.actionparams = ActionParamsPage() self.notifierparams = NotifierParamsPage() self.logs = LogEntriesPage() self.setupszones = SetupsZonesPage() self.workersactions = WorkersActionsPage() self.alarmdata = AlarmDataPage() self.connect() cherrypy.log("Finished initialization")
def addautoreloaddir(root, verbose=False): for path, dirs, files in os.walk(root): for filename in glob.glob(os.path.join(path,"*")): if not ".svn" in filename: if verbose: cherrypy.log("Adding %s to autoreload files" % filename, "ENGINE") cherrypy.engine.autoreload.files.add(filename)
def trap(self, func, *args, **kwargs): try: return func(*args, **kwargs) except self.throws: raise except StopIteration: raise except: tb = _cperror.format_exc() #print('trapped (started %s):' % self.started_response, tb) _cherrypy.log(tb, severity=40) if not _cherrypy.request.show_tracebacks: tb = "" s, h, b = _cperror.bare_error(tb) if self.started_response: # Empty our iterable (so future calls raise StopIteration) self.iter_response = iter([]) else: self.iter_response = iter(b) try: self.start_response(s, h, _sys.exc_info()) except: # "The application must not trap any exceptions raised by # start_response, if it called start_response with exc_info. # Instead, it should allow such exceptions to propagate # back to the server or gateway." # But we still log and call close() to clean up ourselves. _cherrypy.log(traceback=True, severity=40) raise if self.started_response: return ntob("").join(b) else: return b
def _update(self, passwords, contacts, deletions): """Perform an actual database update for `passwords`, `contacts` and `deletions`. Only statements needing to be executed are executed. Commits automatically at the end if necessary.""" if passwords: self.api.executemany("""merge into user_passwd u using dual on (u.username = :username) when not matched then insert (username, passwd) values (:username, :passwd) when matched then update set u.passwd = :passwd """, passwords) for contact in contacts: try: self.api.execute("""merge into contact c using dual on (c.username = :username) when not matched then insert (id, username, forename, surname, email, dn) values (contact_sq.nextval, :username, :forename, :surname, :email, :dn) when matched then update set c.forename = :forename, c.surname = :surname, c.email = :email, c.dn = :dn """, contact) except Exception, e: # Ignore constraint errors for individual users instead of failing cherrypy.log("WARNING: failed to update user %s, DN %s: %s" %(contact['username'], contact['dn'], str(e))) continue
def getSeqs(sequences): ''' In this function, we "clean up" a FASTA file. The input is a FASTA file containing the 16S rDNA sequences of all the OTUs in the microbiome study the user is exploring. This function makes sure that each genomic sequence only spans one line in the file. :param sequences: FASTA file with 16S dRNA sequences spanning multiple lines in addition to the sequence identifier line. :returns seqs: list of 16s dRNA sequences in the FASTA format spanning only one line in addition to the sequence identifier line. ''' cherrypy.log("We are now going to clean up the FASTA file given (%s) so that each DNA sequence does not span multiple lines."%sequences) userSeqs = open(sequences,'r') seq = '' for line in userSeqs: if line.startswith('>'): seq += '+++++\n' seq += line else: seq += line.rstrip() seqs = seq.split('+++++\n') userSeqs.close() cherrypy.log("Clean up is finished. We are ready to fetch only the representative OTU sequences that we are interested in using in the rest of our analysis." ) return seqs
def getUniqueOTU(corrs): ''' In this function we use a file with three columns: columns 1 and 2 are lists of identifiers of OTUs from the microbiome study the user is interested in exploring. The third column has some value of associaltion between each pair of OTUs. The usual measure is correlation or co-occurrence, but it can be any measure of association really. This function goes through all the identifiers and creates a list of unique identifiers in the table, that is, all the different OTUs that are going to be part of the analsysi. :param corrs: file with the values of association between pairs of OTUs :returns uniqueOTUs: list with unique identifiers of OTUs ''' cherrypy.log('We started the function to get the list of all unique OTUs from the file that lists how pairs of OTUs are correlated. The file we are using is %s .' %corrs) correlations = open(corrs,'r') correlations.readline() OTUs = [] for line in correlations: line = line.rstrip().split() OTUs.append(line[0]) OTUs.append(line[1]) uniqueOTUs = list(set(OTUs)) cherrypy.log('We created a list with %d unique OTUS.' %len(uniqueOTUs)) return uniqueOTUs
def _handleAssignmentStateTransition(self, workload, request_args, dn): req_status = request_args["RequestStatus"] if req_status == "assigned" and not request_args.get('Team', '').strip(): raise InvalidSpecParameterValue("Team must be set during workflow assignment: %s" % request_args) if ('SoftTimeout' in request_args) and ('GracePeriod' in request_args): request_args['SoftTimeout'] = int(request_args['SoftTimeout']) #TODO: not sure why GracePeriod when passed from web ingerface but convert here request_args['GracePeriod'] = int(request_args['GracePeriod']) request_args['HardTimeout'] = request_args['SoftTimeout'] + request_args['GracePeriod'] #Only allow extra value update for assigned status cherrypy.log("INFO: Assign request, input args: %s ..." % request_args) try: workload.updateArguments(request_args) except Exception as ex: msg = traceback.format_exc() cherrypy.log("Error for request args %s: %s" % (request_args, msg)) raise InvalidSpecParameterValue(str(ex)) # validate/update OutputDatasets after ProcessingString and AcquisionEra is updated request_args['OutputDatasets'] = workload.listOutputDatasets() validateOutputDatasets(request_args['OutputDatasets'], workload.getDbsUrl()) # legacy update schema to support ops script loadRequestSchema(workload, request_args) report = self.reqmgr_db_service.updateRequestProperty(workload.name(), request_args, dn) workload.saveCouch(self.config.couch_host, self.config.couch_reqmgr_db) return report
def file_ranges(): # Apache compatibility: yield ntob('\r\n') for start, stop in r: if debug: cherrypy.log( 'Multipart; start: %r, stop: %r' % ( start, stop), 'TOOLS.STATIC') yield ntob('--' + boundary, 'ascii') yield ntob('\r\nContent-type: %s' % content_type, 'ascii') yield ntob( '\r\nContent-range: bytes %s-%s/%s\r\n\r\n' % ( start, stop - 1, content_length), 'ascii') fileobj.seek(start) gen = file_generator_limited(fileobj, stop - start) for chunk in gen: yield chunk yield ntob('\r\n') # Final boundary yield ntob('--' + boundary + '--', 'ascii') # Apache compatibility: yield ntob('\r\n')
def _connect(force=False): """ ensure that _db points to an active database connection """ global _db try: if force or not _db or not _db.ping(): print(dict(config['mysql'])) mysql = config['mysql'] host = mysql['host'] port = mysql['port'] user = mysql['username'] passwd = mysql['password'] db = mysql['database'] _db = pymysql.connect( host = host, port = int(port), user = user, passwd = passwd, db = db ) _db.autocommit(True) except Exception as e: import traceback cherrypy.log(traceback.format_exc()) if not force: _connect(force=True)
def init(storage_type = 'ram', path = None, path_header = None, name = 'session_id', timeout = 60, domain = None, secure = False, clean_freq = 5, persistent = True, debug = False, **kwargs): request = cherrypy.serving.request if hasattr(request, '_session_init_flag'): return request._session_init_flag = True id = None if name in request.cookie: id = request.cookie[name].value if debug: cherrypy.log('ID obtained from request.cookie: %r' % id, 'TOOLS.SESSIONS') storage_class = storage_type.title() + 'Session' storage_class = globals()[storage_class] if not hasattr(cherrypy, 'session'): if hasattr(storage_class, 'setup'): storage_class.setup(**kwargs) kwargs['timeout'] = timeout kwargs['clean_freq'] = clean_freq cherrypy.serving.session = sess = storage_class(id, **kwargs) sess.debug = debug def update_cookie(id): cherrypy.serving.response.cookie[name] = id sess.id_observers.append(update_cookie) if not hasattr(cherrypy, 'session'): cherrypy.session = cherrypy._ThreadLocalProxy('session') if persistent: cookie_timeout = timeout else: cookie_timeout = None set_response_cookie(path=path, path_header=path_header, name=name, timeout=cookie_timeout, domain=domain, secure=secure)
def getPage(self,pageName=None,language=None): self.init() ds = DataStore() r = ds.getPage(pageName,language) ds.close() ds = DataStore() layout = ds.getPage('layout',self.language) ds.close() res = {} cherrypy.log("layout"*20) cherrypy.log(str(layout)) for one in r: res[one[5]]=one[2] for one in layout: res[one[5]]=one[2] if self.session.get('user'): res['user']='******'; else: res['user']='******'; self.addTodoPerexes(res) return res
def __call__(self): context = {} try: r = self.next_handler() context.update(r) except ValueError, e: cherrypy.log('%s (handler for "%s" returned "%s")\n' % (e, self.template_name, repr(r)), traceback=True)
def _GetConstrainedPort(self, f=None, bandwidth=None, latency=None, loss=None, new_port=False, **kwargs): """Creates or gets a port with specified network constraints. See ServeConstrained() for more details. """ # Validate inputs. isdigit() guarantees a natural number. bandwidth = self._ParseIntParameter( bandwidth, 'Invalid bandwidth constraint.', lambda x: x > 0) latency = self._ParseIntParameter( latency, 'Invalid latency constraint.', lambda x: x >= 0) loss = self._ParseIntParameter( loss, 'Invalid loss constraint.', lambda x: x <= 100 and x >= 0) redirect_port = self._options.port if self._options.local_server_port: redirect_port = self._options.local_server_port start_time = time.time() # Allocate a port using the given constraints. If a port with the requested # key and kwargs already exist then reuse that port. constrained_port = self._port_allocator.Get( cherrypy.request.remote.ip, server_port=redirect_port, interface=self._options.interface, bandwidth=bandwidth, latency=latency, loss=loss, new_port=new_port, file=f, **kwargs) cherrypy.log('Time to set up port %d = %.3fsec.' % (constrained_port, time.time() - start_time)) if not constrained_port: raise cherrypy.HTTPError(503, 'Service unavailable. Out of ports.') return constrained_port
def Main(): """Configure and start the ConstrainedNetworkServer.""" options = ParseArgs() try: traffic_control.CheckRequirements() except traffic_control.TrafficControlError as e: cherrypy.log(e.msg) return cherrypy.config.update({'server.socket_host': '::', 'server.socket_port': options.port}) if options.threads: cherrypy.config.update({'server.thread_pool': options.threads}) if options.socket_timeout: cherrypy.config.update({'server.socket_timeout': options.socket_timeout}) # Setup port allocator here so we can call cleanup on failures/exit. pa = PortAllocator(options.port_range, expiry_time_secs=options.expiry_time) try: cherrypy.quickstart(ConstrainedNetworkServer(options, pa)) finally: # Disable Ctrl-C handler to prevent interruption of cleanup. signal.signal(signal.SIGINT, lambda signal, frame: None) pa.Cleanup(all_ports=True)
def start(self): msgq = self.msgq nextpipe = None while True: m = msgq.get() if m == MSG_PLAYER_PLAY: if self.play_pipe is not None: nextpipe = msgq.get() self._stop() else: self._play(msgq.get()) elif m == MSG_PLAYER_STOP: self._stop() elif m == MSG_PLAYER_PIPE_STOPPED: self.error = msgq.get() self.play_thread.join() cherrypy.log("PIPE STOPPED") if nextpipe is not None: self._play(nextpipe) nextpipe = None else: self.play_pipe = None self.play_thread = None elif m == MSG_PLAYER_QUIT: self._stop() break
def build(self): """ program build/update """ # store common file path in variables tgz_file = self.dl_dir + "io_png.tar.gz" prog_file = self.bin_dir + "axpb" log_file = self.base_dir + "build.log" # get the latest source archive build.download("https://tools.ipol.im/wiki/doc/" + "io_png.tar.gz" , tgz_file) # test if the dest file is missing, or too old if (os.path.isfile(prog_file) and ctime(tgz_file) < ctime(prog_file)): cherrypy.log("not rebuild needed", context='BUILD', traceback=False) else: # extract the archive build.extract(tgz_file, self.src_dir) # build the program build.run("make -j4 -C %s %s" % (self.src_dir + "io_png", os.path.join("example", "axpb")), stdout=log_file) # save into bin dir if os.path.isdir(self.bin_dir): shutil.rmtree(self.bin_dir) os.mkdir(self.bin_dir) shutil.copy(self.src_dir + os.path.join("io_png", "example", "axpb"), prog_file) # cleanup the source dir shutil.rmtree(self.src_dir) return
def response_headers(headers=None, debug=False): """Set headers on the response.""" if debug: cherrypy.log('Setting response headers: %s' % repr(headers), 'TOOLS.RESPONSE_HEADERS') for name, value in (headers or []): cherrypy.serving.response.headers[name] = value
def build_demoUtils(self): """ built the demo auxiliary programs (stored with the demo) """ ## store common file path in variables tgz_file = self.base_dir + "support/demoUtils.tar.gz" prog_file = self.bin_dir + "plambda" log_file = self.base_dir + "build_utils.log" ## test if the dest file is missing, or too old if (os.path.isfile(prog_file) and ctime(tgz_file) < ctime(prog_file)): cherrypy.log("no rebuild needed", context='BUILD', traceback=False) else: # extract the archive build.extract(tgz_file, self.src_dir) # build the program build.run("cd %s; cmake ." % (self.src_dir +"demoUtils"), stdout=log_file) build.run("make -C %s" % (self.src_dir +"demoUtils"), stdout=log_file) # save into bin dir #try: import glob for f in glob.glob(os.path.join(self.src_dir, "demoUtils", "bin", "*")): shutil.copy(f, self.bin_dir) #except: # print("some error occurred copying files") # cleanup the source dir shutil.rmtree(self.src_dir) return
def modified_since(path, stat=None): """Check whether a file has been modified since the date provided in 'If-Modified-Since' It doesn't check if the file exists or not Return True if has been modified, False otherwise """ # serveFile already creates a stat object so let's not # waste our energy to do it again if not stat: try: stat = os.stat(path) except OSError: if cherrypy.config.get("server.log_file_not_found", False): cherrypy.log(" NOT FOUND file: %s" % path, "DEBUG") raise cherrypy.NotFound() response = cherrypy.response strModifTime = httptools.HTTPDate(time.gmtime(stat.st_mtime)) if cherrypy.request.headers.has_key("If-Modified-Since"): if cherrypy.request.headers["If-Modified-Since"] == strModifTime: response.status = "304 Not Modified" response.body = None if getattr(cherrypy, "debug", None): cherrypy.log(" Found file (304 Not Modified): %s" % path, "DEBUG") return False response.headers["Last-Modified"] = strModifTime return True
def connection_log(self, action): """Logs actions on the sqlite3 connection :param str action: is the action on the connection """ if cherrypy is not None: # This happens while everything is being deleted cherrypy.log('Connection {0} with timestamp {1}'.format(action, self.timestamp))
def update(self,handle=None,email=None,password1=None, password2=None,action=None,user_id=None): """ users can only edit themselves """ # if they don't supply the user id, we are editing current user if user_id: user = m.User.get(user_id) else: user = cherrypy.request.user try: if action: # update what we were passed if handle and user.handle != handle: if m.User.get_by(handle=handle): raise e.ValidationException('Handle taken') user.handle = handle if email: cherrypy.log('email:%s' % email) user.email_address = email if password1: if password1 != password2: raise e.ValidationException('Passwords do not match') user.password = password1 # save our changes m.session.commit() # take a look redirect('/user/%s' % user.id) except e.ValidationException, ex: add_flash('error','%s' % ex)
def create_or_update_ref_datastream(self, uri, ref): '''Create or update a datastream with an externally referenced content. @param uri (string) URI of the datastream node to be created or updated. @param ref (string) External source as a HTTP URL. @eturn (string) New datasteram URI if a new one is crated. ''' cherrypy.log('Creating an externally referenced node: ' + uri) # Check that external reference exists check = self.request('head',ref, headers=self.headers) check.raise_for_status() res = self.request('put', uri, headers = dict(chain( self.headers.items(), [('content-type', 'message/external-body; access-type=URL; URL="{}"'.format(ref))] )) ) res.raise_for_status() #cherrypy.log('Create/update datastream response:' + str(res.status_code)) cherrypy.log('Response headers for reference DS:' + str(res.headers)) if 'location' in res.headers: return res.headers['location']
def build_demo(self): """ download and built the demo auxiliary programs """ ## store common file path in variables tgz_file = self.dl_dir + "imscript.tar.gz" prog_file = self.bin_dir + "plambda" log_file = self.base_dir + "build_imscript.log" ## get the latest source archive build.download(app.xlink_src_demo, tgz_file) ## test if the dest file is missing, or too old if (os.path.isfile(prog_file) and ctime(tgz_file) < ctime(prog_file)): cherrypy.log("no rebuild needed", context='BUILD', traceback=False) else: # extract the archive build.extract(tgz_file, self.src_dir) # build the program build.run("make -j CFLAGS=-O3 -C %s" % (self.src_dir +"imscript"), stdout=log_file) # save into bin dir #try: for f in glob.glob(os.path.join(self.src_dir, "imscript", "bin", "*")): shutil.copy(f, self.bin_dir) #except: # print("some error occurred copying files") # cleanup the source dir shutil.rmtree(self.src_dir) return
def build_algo(self): """ program build/update """ ## store common file path in variables tgz_file = self.dl_dir + "tvl1flow_3.tar.gz" prog_file = self.bin_dir + "tvl1flow" log_file = self.base_dir + "build.log" ## get the latest source archive build.download(app.xlink_src, tgz_file) ## test if the dest file is missing, or too old if (os.path.isfile(prog_file) and ctime(tgz_file) < ctime(prog_file)): cherrypy.log("no rebuild needed", context='BUILD', traceback=False) else: # extract the archive build.extract(tgz_file, self.src_dir) # build the program build.run("make -C %s" % (self.src_dir +"tvl1flow_3"), stdout=log_file) # save into bin dir #if os.path.isdir(self.bin_dir): # shutil.rmtree(self.bin_dir) #try: shutil.copy(self.src_dir + os.path.join("tvl1flow_3", "tvl1flow"), prog_file) #except: # print("some error occurred copying files") # cleanup the source dir shutil.rmtree(self.src_dir) return
def init_plugins(self, pluginlist): """ Initialize plugins. Assumes that each plugin contains a class of the same name as the file. If it does, this function attaches an instance of that class to self, and adds that instance to the plugins array. """ plugindir = config('plugin_dir', None) if not plugindir or not os.path.isdir(plugindir): cpy.log("Invalid Plugin Directory, no plugins loaded") return else: sys.path.append(plugindir) #XXX: Should we just scan for *.py files in the plugin dir? Should the # mechanism to remove a plugin be renaming it or taking it out of # conf? for p in pluginlist: try: mod = __import__(p) if not hasattr(self, p): instance = getattr(mod, p)(self) setattr(self, p, instance) self.plugins.append(instance) cpy.log("successfully imported plugin module %s" % p) else: raise ImportError #bare except, because the modules could raise any number of errors #on import, and we want them not to kill our server except: cpy.log("import failed on module %s, module not loaded" % p) cpy.log("%s" % sys.exc_info()[0]) cpy.log("%s" % traceback.format_exc())
def json_out(content_type='application/json', debug=False, handler=json_handler): """Wrap request.handler to serialize its output to JSON. Sets Content-Type. If the given content_type is None, the Content-Type response header is not set. Provide your own handler to use a custom encoder. For example cherrypy.config['tools.json_out.handler'] = <function>, or @json_out(handler=function). You must be using Python 2.6 or greater, or have the 'simplejson' package importable; otherwise, ValueError is raised during processing. """ request = cherrypy.serving.request # request.handler may be set to None by e.g. the caching tool # to signal to all components that a response body has already # been attached, in which case we don't need to wrap anything. if request.handler is None: return if debug: cherrypy.log('Replacing %s with JSON handler' % request.handler, 'TOOLS.JSON_OUT') request._json_inner_handler = request.handler request.handler = handler if content_type is not None: if debug: cherrypy.log('Setting Content-Type to %s' % content_type, 'TOOLS.JSON_OUT') cherrypy.serving.response.headers['Content-Type'] = content_type
def allow(methods=None, debug=False): """Raise 405 if request.method not in methods (default ['GET', 'HEAD']). The given methods are case-insensitive, and may be in any order. If only one method is allowed, you may supply a single string; if more than one, supply a list of strings. Regardless of whether the current method is allowed or not, this also emits an 'Allow' response header, containing the given methods. """ if not isinstance(methods, (tuple, list)): methods = [methods] methods = [m.upper() for m in methods if m] if not methods: methods = ['GET', 'HEAD'] elif 'GET' in methods and 'HEAD' not in methods: methods.append('HEAD') cherrypy.response.headers['Allow'] = ', '.join(methods) if cherrypy.request.method not in methods: if debug: cherrypy.log('request.method %r not in methods %r' % (cherrypy.request.method, methods), 'TOOLS.ALLOW') raise cherrypy.HTTPError(405) else: if debug: cherrypy.log('request.method %r in methods %r' % (cherrypy.request.method, methods), 'TOOLS.ALLOW')
def stop(self): cherrypy.log("stopping ticker") self.running = False
def validate_etags(autotags=False, debug=False): """Validate the current ETag against If-Match, If-None-Match headers. If autotags is True, an ETag response-header value will be provided from an MD5 hash of the response body (unless some other code has already provided an ETag header). If False (the default), the ETag will not be automatic. WARNING: the autotags feature is not designed for URL's which allow methods other than GET. For example, if a POST to the same URL returns no content, the automatic ETag will be incorrect, breaking a fundamental use for entity tags in a possibly destructive fashion. Likewise, if you raise 304 Not Modified, the response body will be empty, the ETag hash will be incorrect, and your application will break. See :rfc:`2616` Section 14.24. """ response = cherrypy.serving.response # Guard against being run twice. if hasattr(response, 'ETag'): return status, reason, msg = _httputil.valid_status(response.status) etag = response.headers.get('ETag') # Automatic ETag generation. See warning in docstring. if etag: if debug: cherrypy.log('ETag already set: %s' % etag, 'TOOLS.ETAGS') elif not autotags: if debug: cherrypy.log('Autotags off', 'TOOLS.ETAGS') elif status != 200: if debug: cherrypy.log('Status not 200', 'TOOLS.ETAGS') else: etag = response.collapse_body() etag = '"%s"' % md5(etag).hexdigest() if debug: cherrypy.log('Setting ETag: %s' % etag, 'TOOLS.ETAGS') response.headers['ETag'] = etag response.ETag = etag # "If the request would, without the If-Match header field, result in # anything other than a 2xx or 412 status, then the If-Match header # MUST be ignored." if debug: cherrypy.log('Status: %s' % status, 'TOOLS.ETAGS') if status >= 200 and status <= 299: request = cherrypy.serving.request conditions = request.headers.elements('If-Match') or [] conditions = [str(x) for x in conditions] if debug: cherrypy.log('If-Match conditions: %s' % repr(conditions), 'TOOLS.ETAGS') if conditions and not (conditions == ['*'] or etag in conditions): raise cherrypy.HTTPError( 412, 'If-Match failed: ETag %r did ' 'not match %r' % (etag, conditions)) conditions = request.headers.elements('If-None-Match') or [] conditions = [str(x) for x in conditions] if debug: cherrypy.log('If-None-Match conditions: %s' % repr(conditions), 'TOOLS.ETAGS') if conditions == ['*'] or etag in conditions: if debug: cherrypy.log('request.method: %s' % request.method, 'TOOLS.ETAGS') if request.method in ('GET', 'HEAD'): raise cherrypy.HTTPRedirect([], 304) else: raise cherrypy.HTTPError( 412, 'If-None-Match failed: ETag %r ' 'matched %r' % (etag, conditions))
def download(self, public=None, private=None, nocache=None, nostore=None, notransform=None, mustrevalidate=None, maxage=None, pragma=None, expires=None, disposition='inline', format='pdf'): resp = cherrypy.response format = format.lower().strip() disposition = 'inline' if disposition == 'inline' else 'attachment' cache_control = [] if public == 'on': cherrypy.log("Setting Cache-Control: public") cache_control.append('public') if private == 'on': cherrypy.log("Setting Cache-Control: private") cache_control.append('private') if nocache == 'on': cherrypy.log("Setting Cache-Control: no-cache") cache_control.append('no-cache') if nostore == 'on': cherrypy.log("Setting Cache-Control: no-store") cache_control.append('no-store') if notransform == 'on': cherrypy.log("Setting Cache-Control: no-transform") cache_control.append('no-transform') if mustrevalidate == 'on': cherrypy.log("Setting Cache-Control: must-revalidate") cache_control.append('must-revalidate') if maxage is not None and maxage.strip().isidigit(): maxage = int(maxage.strip()) cherrypy.log("Setting Cache-Control: max-age=%d" % (maxage, )) cache_control.append('max-age=%d' % (maxage, )) if pragma == 'on': cherrypy.log("Setting Pragma: no-cache") resp.headers['Pragma'] = 'no-cache' if cache_control: resp.headers['Cache-Control'] = ', '.join(cache_control) if expires is not None: expires = parse_expires(expires) cherrypy.log("Setting Expires: %r" % (expires, )) resp.headers['Expires'] = expires if format in FORMATS: resp.headers['Content-Type'] = FORMATS.get(format, 'pdf') filename = "test.%s" % (format, ) cherrypy.log("Setting Content-Disposition: %s; filename=%s" % (disposition, filename)) resp.headers['Content-Disposition'] = "%s; filename=%s" % ( disposition, filename) outfile = open(filename, 'rb') return file2Generator(outfile) else: outfile = open('download.html', 'rb') return file2Generator(outfile)
def get(invalid_methods=("POST", "PUT", "DELETE"), debug=False, **kwargs): """Try to obtain cached output. If fresh enough, raise HTTPError(304). If POST, PUT, or DELETE: * invalidates (deletes) any cached response for this resource * sets request.cached = False * sets request.cacheable = False else if a cached copy exists: * sets request.cached = True * sets request.cacheable = False * sets response.headers to the cached values * checks the cached Last-Modified response header against the current If-(Un)Modified-Since request headers; raises 304 if necessary. * sets response.status and response.body to the cached values * returns True otherwise: * sets request.cached = False * sets request.cacheable = True * returns False """ request = cherrypy.serving.request response = cherrypy.serving.response if not hasattr(cherrypy, "_cache"): # Make a process-wide Cache object. cherrypy._cache = kwargs.pop("cache_class", MemoryCache)() # Take all remaining kwargs and set them on the Cache object. for k, v in kwargs.items(): setattr(cherrypy._cache, k, v) cherrypy._cache.debug = debug # POST, PUT, DELETE should invalidate (delete) the cached copy. # See http://www.w3.org/Protocols/rfc2616/rfc2616-sec13.html#sec13.10. if request.method in invalid_methods: if debug: cherrypy.log('request.method %r in invalid_methods %r' % (request.method, invalid_methods), 'TOOLS.CACHING') cherrypy._cache.delete() request.cached = False request.cacheable = False return False if 'no-cache' in [e.value for e in request.headers.elements('Pragma')]: request.cached = False request.cacheable = True return False cache_data = cherrypy._cache.get() request.cached = bool(cache_data) request.cacheable = not request.cached if request.cached: # Serve the cached copy. max_age = cherrypy._cache.delay for v in [e.value for e in request.headers.elements('Cache-Control')]: atoms = v.split('=', 1) directive = atoms.pop(0) if directive == 'max-age': if len(atoms) != 1 or not atoms[0].isdigit(): raise cherrypy.HTTPError( 400, "Invalid Cache-Control header") max_age = int(atoms[0]) break elif directive == 'no-cache': if debug: cherrypy.log( 'Ignoring cache due to Cache-Control: no-cache', 'TOOLS.CACHING') request.cached = False request.cacheable = True return False if debug: cherrypy.log('Reading response from cache', 'TOOLS.CACHING') s, h, b, create_time = cache_data age = int(response.time - create_time) if (age > max_age): if debug: cherrypy.log('Ignoring cache due to age > %d' % max_age, 'TOOLS.CACHING') request.cached = False request.cacheable = True return False # Copy the response headers. See # https://bitbucket.org/cherrypy/cherrypy/issue/721. response.headers = rh = httputil.HeaderMap() for k in h: dict.__setitem__(rh, k, dict.__getitem__(h, k)) # Add the required Age header response.headers["Age"] = str(age) try: # Note that validate_since depends on a Last-Modified header; # this was put into the cached copy, and should have been # resurrected just above (response.headers = cache_data[1]). cptools.validate_since() except cherrypy.HTTPRedirect: x = sys.exc_info()[1] if x.status == 304: cherrypy._cache.tot_non_modified += 1 raise # serve it & get out from the request response.status = s response.body = b else: if debug: cherrypy.log('request is not cached', 'TOOLS.CACHING') return request.cached
home_dir = '/Users/bobby/Downloads' #home_dir = '/home/stufs1/vgottipati' translate_folder = home_dir + '/tensorflow/tensorflow/models/rnn/translate' translate_args = '--decode --data_dir {0} --train_dir {1} --size=256 --num_layers=1 --steps_per_checkpoint=10000' trump_args = (translate_folder + '/trump_data_dir', translate_folder + '/trump_checkpoint_dir') trump_bot_cmd = 'python ' + translate_folder + '/translate.py ' + ( translate_args.format(*trump_args)) trump_bot = Popen(trump_bot_cmd.split(), shell=False, stdin=PIPE, stdout=PIPE) # flush out the intial info line trump_bot.stdout.readline() cherrypy.log('Started Trump bot') clinton_args = (translate_folder + '/clinton_data_dir', translate_folder + '/clinton_checkpoint_dir') clinton_bot_cmd = 'python ' + translate_folder + '/translate.py ' + ( translate_args.format(*clinton_args)) clinton_bot = Popen(clinton_bot_cmd.split(), shell=False, stdin=PIPE, stdout=PIPE) # flush out the intial info line clinton_bot.stdout.readline() cherrypy.log('Started Clinton bot') con = sqlite3.connect(home_dir + '/feedback_v2.db', isolation_level=None,
def find_acceptable_charset(self): request = cherrypy.serving.request response = cherrypy.serving.response if self.debug: cherrypy.log('response.stream %r' % response.stream, 'TOOLS.ENCODE') if response.stream: encoder = self.encode_stream else: encoder = self.encode_string if "Content-Length" in response.headers: # Delete Content-Length header so finalize() recalcs it. # Encoded strings may be of different lengths from their # unicode equivalents, and even from each other. For example: # >>> t = u"\u7007\u3040" # >>> len(t) # 2 # >>> len(t.encode("UTF-8")) # 6 # >>> len(t.encode("utf7")) # 8 del response.headers["Content-Length"] # Parse the Accept-Charset request header, and try to provide one # of the requested charsets (in order of user preference). encs = request.headers.elements('Accept-Charset') charsets = [enc.value.lower() for enc in encs] if self.debug: cherrypy.log('charsets %s' % repr(charsets), 'TOOLS.ENCODE') if self.encoding is not None: # If specified, force this encoding to be used, or fail. encoding = self.encoding.lower() if self.debug: cherrypy.log('Specified encoding %r' % encoding, 'TOOLS.ENCODE') if (not charsets) or "*" in charsets or encoding in charsets: if self.debug: cherrypy.log('Attempting encoding %r' % encoding, 'TOOLS.ENCODE') if encoder(encoding): return encoding else: if not encs: if self.debug: cherrypy.log( 'Attempting default encoding %r' % self.default_encoding, 'TOOLS.ENCODE') # Any character-set is acceptable. if encoder(self.default_encoding): return self.default_encoding else: raise cherrypy.HTTPError( 500, self.failmsg % self.default_encoding) else: for element in encs: if element.qvalue > 0: if element.value == "*": # Matches any charset. Try our default. if self.debug: cherrypy.log( 'Attempting default encoding due ' 'to %r' % element, 'TOOLS.ENCODE') if encoder(self.default_encoding): return self.default_encoding else: encoding = element.value if self.debug: cherrypy.log( 'Attempting encoding %s (qvalue >' '0)' % element, 'TOOLS.ENCODE') if encoder(encoding): return encoding if "*" not in charsets: # If no "*" is present in an Accept-Charset field, then all # character sets not explicitly mentioned get a quality # value of 0, except for ISO-8859-1, which gets a quality # value of 1 if not explicitly mentioned. iso = 'iso-8859-1' if iso not in charsets: if self.debug: cherrypy.log('Attempting ISO-8859-1 encoding', 'TOOLS.ENCODE') if encoder(iso): return iso # No suitable encoding found. ac = request.headers.get('Accept-Charset') if ac is None: msg = "Your client did not send an Accept-Charset header." else: msg = "Your client sent this Accept-Charset header: %s." % ac msg += " We tried these charsets: %s." % ", ".join( self.attempted_charsets) raise cherrypy.HTTPError(406, msg)
def gzip(compress_level=5, mime_types=['text/html', 'text/plain'], debug=False): """Try to gzip the response body if Content-Type in mime_types. cherrypy.response.headers['Content-Type'] must be set to one of the values in the mime_types arg before calling this function. The provided list of mime-types must be of one of the following form: * type/subtype * type/* * type/*+subtype No compression is performed if any of the following hold: * The client sends no Accept-Encoding request header * No 'gzip' or 'x-gzip' is present in the Accept-Encoding header * No 'gzip' or 'x-gzip' with a qvalue > 0 is present * The 'identity' value is given with a qvalue > 0. """ request = cherrypy.serving.request response = cherrypy.serving.response set_vary_header(response, "Accept-Encoding") if not response.body: # Response body is empty (might be a 304 for instance) if debug: cherrypy.log('No response body', context='TOOLS.GZIP') return # If returning cached content (which should already have been gzipped), # don't re-zip. if getattr(request, "cached", False): if debug: cherrypy.log('Not gzipping cached response', context='TOOLS.GZIP') return acceptable = request.headers.elements('Accept-Encoding') if not acceptable: # If no Accept-Encoding field is present in a request, # the server MAY assume that the client will accept any # content coding. In this case, if "identity" is one of # the available content-codings, then the server SHOULD use # the "identity" content-coding, unless it has additional # information that a different content-coding is meaningful # to the client. if debug: cherrypy.log('No Accept-Encoding', context='TOOLS.GZIP') return ct = response.headers.get('Content-Type', '').split(';')[0] for coding in acceptable: if coding.value == 'identity' and coding.qvalue != 0: if debug: cherrypy.log('Non-zero identity qvalue: %s' % coding, context='TOOLS.GZIP') return if coding.value in ('gzip', 'x-gzip'): if coding.qvalue == 0: if debug: cherrypy.log('Zero gzip qvalue: %s' % coding, context='TOOLS.GZIP') return if ct not in mime_types: # If the list of provided mime-types contains tokens # such as 'text/*' or 'application/*+xml', # we go through them and find the most appropriate one # based on the given content-type. # The pattern matching is only caring about the most # common cases, as stated above, and doesn't support # for extra parameters. found = False if '/' in ct: ct_media_type, ct_sub_type = ct.split('/') for mime_type in mime_types: if '/' in mime_type: media_type, sub_type = mime_type.split('/') if ct_media_type == media_type: if sub_type == '*': found = True break elif '+' in sub_type and '+' in ct_sub_type: ct_left, ct_right = ct_sub_type.split('+') left, right = sub_type.split('+') if left == '*' and ct_right == right: found = True break if not found: if debug: cherrypy.log('Content-Type %s not in mime_types %r' % (ct, mime_types), context='TOOLS.GZIP') return if debug: cherrypy.log('Gzipping', context='TOOLS.GZIP') # Return a generator that compresses the page response.headers['Content-Encoding'] = 'gzip' response.body = compress(response.body, compress_level) if "Content-Length" in response.headers: # Delete Content-Length header so finalize() recalcs it. del response.headers["Content-Length"] return if debug: cherrypy.log('No acceptable encoding found.', context='GZIP') cherrypy.HTTPError(406, "identity, gzip").set_response()
def acquire_lock(self): """Acquire an exclusive lock on the currently-loaded session data.""" self.locked = True self.locks.setdefault(self.id, threading.RLock()).acquire() if self.debug: cherrypy.log('Lock acquired.', 'TOOLS.SESSIONS')
def check_session(session, can_refresh=False): """If session is None, fills it. :param cherrypy.Session session: the current session :param bool can_refresh: tells the function if it is safe to refresh and close the old database :returns: ErrorInfo of the session :rtype: ErrorInfo """ if session: cherrypy.log('Getting global lock: 1') GLOBAL_LOCK.acquire() if session.get('lock') is None: session['lock'] = threading.Lock() cherrypy.log('Releasing global lock: 1') GLOBAL_LOCK.release() cherrypy.log('Getting session lock') session['lock'].acquire() if session.get('info') is None: session['info'] = ErrorInfo() theinfo = session.get('info') else: cherrypy.log('Getting global lock: 2') GLOBAL_LOCK.acquire() global GLOBAL_INFO if GLOBAL_INFO is None: GLOBAL_INFO = ErrorInfo() theinfo = GLOBAL_INFO cherrypy.log('Releasing global lock: 2') GLOBAL_LOCK.release() # If session ErrorInfo is old, set up another connection if can_refresh and theinfo.timestamp < time.time() - \ 60*serverconfig.config_dict()['refresh_period']: theinfo.teardown() theinfo.setup() if session: cherrypy.log('Releasing session lock') session['lock'].release() return theinfo
def init(storage_type='ram', path=None, path_header=None, name='session_id', timeout=60, domain=None, secure=False, clean_freq=5, persistent=True, httponly=False, debug=False, **kwargs): """Initialize session object (using cookies). storage_type One of 'ram', 'file', 'postgresql', 'memcached'. This will be used to look up the corresponding class in cherrypy.lib.sessions globals. For example, 'file' will use the FileSession class. path The 'path' value to stick in the response cookie metadata. path_header If 'path' is None (the default), then the response cookie 'path' will be pulled from request.headers[path_header]. name The name of the cookie. timeout The expiration timeout (in minutes) for the stored session data. If 'persistent' is True (the default), this is also the timeout for the cookie. domain The cookie domain. secure If False (the default) the cookie 'secure' value will not be set. If True, the cookie 'secure' value will be set (to 1). clean_freq (minutes) The poll rate for expired session cleanup. persistent If True (the default), the 'timeout' argument will be used to expire the cookie. If False, the cookie will not have an expiry, and the cookie will be a "session cookie" which expires when the browser is closed. httponly If False (the default) the cookie 'httponly' value will not be set. If True, the cookie 'httponly' value will be set (to 1). Any additional kwargs will be bound to the new Session instance, and may be specific to the storage type. See the subclass of Session you're using for more information. """ request = cherrypy.serving.request # Guard against running twice if hasattr(request, "_session_init_flag"): return request._session_init_flag = True # Check if request came with a session ID id = None if name in request.cookie: id = request.cookie[name].value if debug: cherrypy.log('ID obtained from request.cookie: %r' % id, 'TOOLS.SESSIONS') # Find the storage class and call setup (first time only). storage_class = storage_type.title() + 'Session' storage_class = globals()[storage_class] if not hasattr(cherrypy, "session"): if hasattr(storage_class, "setup"): storage_class.setup(**kwargs) # Create and attach a new Session instance to cherrypy.serving. # It will possess a reference to (and lock, and lazily load) # the requested session data. kwargs['timeout'] = timeout kwargs['clean_freq'] = clean_freq cherrypy.serving.session = sess = storage_class(id, **kwargs) sess.debug = debug def update_cookie(id): """Update the cookie every time the session id changes.""" cherrypy.serving.response.cookie[name] = id sess.id_observers.append(update_cookie) # Create cherrypy.session which will proxy to cherrypy.serving.session if not hasattr(cherrypy, "session"): cherrypy.session = cherrypy._ThreadLocalProxy('session') if persistent: cookie_timeout = timeout else: # See http://support.microsoft.com/kb/223799/EN-US/ # and http://support.mozilla.com/en-US/kb/Cookies cookie_timeout = None set_response_cookie(path=path, path_header=path_header, name=name, timeout=cookie_timeout, domain=domain, secure=secure, httponly=httponly)
def evalPython(self, funcBody): cherrypy.log("function body:" + funcBody) ns = {} code = compile(funcBody, '<string>', 'exec') exec code in ns return ns['result']
def delete(self): """Delete stored session data.""" self._delete() if self.debug: cherrypy.log('Deleted session %s.' % self.id, 'TOOLS.SESSIONS')
def cmd(self, comando): cherrypy.log("Yacare[cmd]: %s"%comando) respuesta=self._enviar_comando(comando, {}) return respuesta
def run(self, method, path, query_string, req_protocol, headers, rfile): """Process the Request. (Core) method, path, query_string, and req_protocol should be pulled directly from the Request-Line (e.g. "GET /path?key=val HTTP/1.0"). path should be %XX-unquoted, but query_string should not be. headers should be a list of (name, value) tuples. rfile should be a file-like object containing the HTTP request entity. When run() is done, the returned object should have 3 attributes: status, e.g. "200 OK" header_list, a list of (name, value) tuples body, an iterable yielding strings Consumer code (HTTP servers) should then access these response attributes to build the outbound stream. """ self.stage = 'run' try: self.error_response = cherrypy.HTTPError(500).set_response self.method = method path = path or "/" self.query_string = query_string or '' # Compare request and server HTTP protocol versions, in case our # server does not support the requested protocol. Limit our output # to min(req, server). We want the following output: # request server actual written supported response # protocol protocol response protocol feature set # a 1.0 1.0 1.0 1.0 # b 1.0 1.1 1.1 1.0 # c 1.1 1.0 1.0 1.0 # d 1.1 1.1 1.1 1.1 # Notice that, in (b), the response will be "HTTP/1.1" even though # the client only understands 1.0. RFC 2616 10.5.6 says we should # only return 505 if the _major_ version is different. rp = int(req_protocol[5]), int(req_protocol[7]) sp = int(self.server_protocol[5]), int(self.server_protocol[7]) self.protocol = min(rp, sp) # Rebuild first line of the request (e.g. "GET /path HTTP/1.0"). url = path if query_string: url += '?' + query_string self.request_line = '%s %s %s' % (method, url, req_protocol) self.header_list = list(headers) self.rfile = rfile self.headers = http.HeaderMap() self.cookie = Cookie.SimpleCookie() self.handler = None # path_info should be the path from the # app root (script_name) to the handler. self.script_name = self.app.script_name self.path_info = pi = path[len(self.script_name):] self.stage = 'respond' self.respond(pi) except self.throws: raise except: if self.throw_errors: raise else: # Failure in setup, error handler or finalize. Bypass them. # Can't use handle_error because we may not have hooks yet. cherrypy.log(traceback=True, severity=40) if self.show_tracebacks: body = format_exc() else: body = "" r = bare_error(body) response = cherrypy.response response.status, response.header_list, response.body = r if self.method == "HEAD": # HEAD requests MUST NOT return a message-body in the response. cherrypy.response.body = [] try: cherrypy.log.access() except: cherrypy.log.error(traceback=True) if cherrypy.response.timed_out: raise cherrypy.TimeoutError() return cherrypy.response
def on_connect(self, client, userdata, flags, rc): applyai.log("Connected with result code "+str(rc), self.logname) # Subscribing in on_connect() means that if we lose the connection and # reconnect then subscriptions will be renewed. client.subscribe("$SYS/#")
def postData(self, funcBody, funcData): cherrypy.log("function data:" + funcData) return xpathTest.extractPost(funcData)
def respond(self): req = self.req try: # Obtain a Request object from CherryPy local = req.server.bind_addr local = httputil.Host(local[0], local[1], '') remote = req.conn.remote_addr, req.conn.remote_port remote = httputil.Host(remote[0], remote[1], '') scheme = req.scheme sn = cherrypy.tree.script_name(req.uri or '/') if sn is None: self.send_response('404 Not Found', [], ['']) else: app = cherrypy.tree.apps[sn] method = req.method path = req.path qs = req.qs or '' headers = req.inheaders.items() rfile = req.rfile prev = None try: redirections = [] while True: request, response = app.get_serving( local, remote, scheme, 'HTTP/1.1') request.multithread = True request.multiprocess = False request.app = app request.prev = prev # Run the CherryPy Request object and obtain the # response try: request.run(method, path, qs, req.request_protocol, headers, rfile) break except cherrypy.InternalRedirect: ir = sys.exc_info()[1] app.release_serving() prev = request if not self.recursive: if ir.path in redirections: raise RuntimeError( 'InternalRedirector visited the same ' 'URL twice: %r' % ir.path) else: # Add the *previous* path_info + qs to # redirections. if qs: qs = '?' + qs redirections.append(sn + path + qs) # Munge environment and try again. method = 'GET' path = ir.path qs = ir.query_string rfile = io.BytesIO() self.send_response(response.output_status, response.header_list, response.body) finally: app.release_serving() except: tb = format_exc() # print tb cherrypy.log(tb, 'NATIVE_ADAPTER', severity=logging.ERROR) s, h, b = bare_error() self.send_response(s, h, b)
def main(self, params): params['status'] = 0 frameInSource = self.getCfgVal('frameIn') frameInChannel = self.getCfgVal('channel') frameIn = self.store.fetchFrameOut(frameInSource, frameInChannel) frameOut = frameIn.copy() plan = params['plan'] order = params['order'] record = params['record'] # get the date string date = record['date'].split('T')[0] zeit = record['date'].split('T')[1] # create stats directory if required path = '../projects/' + self.project + '/stats/' + record['part'] if not os.path.isdir(path): os.mkdir(path) path += '/' + date if not os.path.isdir(path): os.mkdir(path) filename = record['part'] + '~' + record['order'] + '.json' path += '/' + filename # save to stats self.writeStatsFile(path, record) # TODO Watermark images make to flexible txt = 'applyAI Vision ' txt += record['date'].replace('T',' ') txt += '/' + record['part'] txt += '/' + record['order'] txt += '/' + record['machine'] txt += '/' + str(record['status']) for v in record['values']: txt += '/' + str(v['v']) # Watermark image if required if self.getCfgVal('watermark') == 'Standard': cv2.putText(frameOut, txt, (10, frameOut.shape[0]-20), cv2.FONT_HERSHEY_SIMPLEX, 1, (255,255,255), 1) # TODO if nok and selected archive image(s) # create image directory if required path = '../projects/' + self.project + '/images/' + record['part'] if not os.path.isdir(path): os.mkdir(path) path += '/' + date if not os.path.isdir(path): os.mkdir(path) support = (self.getCfgVal('imageStorageType') == 'Support') applyai.log('Support flag: ' + str(support), self.logname) #support = False self.store.updateFrameOut(self.name, 0, frameOut) if self.getCfgVal('saveImages') == '100%': self.flushImages(path, zeit, support) elif (record['status'] != 0 and self.getCfgVal('saveImages') == 'NOK'): self.flushImages(path, zeit, support) # TODO demoVar replace with some global counter #demoVar = int(self.getCfgVal('demo')) #demoVar += 1 #self.setCfgVal('demo', demoVar) #cv2.putText(frameOut, 'demoVar:' + str(demoVar), (100, 200), cv2.FONT_HERSHEY_SIMPLEX, 3, (0,255,0), 5) params['record'] = record params['targets'] = self.targets.fetch() self.mqttPublish(params) return params
def getHTML(self, params): """ Run Widget 5 and generate HTML output for Results tab. """ # Validate input parameters. if not exists(params['analysis_folder']): try: makedirs(params['analysis_folder']) except Exception as e: cherrypy.log( 'Widget 5: Error creating folder "{0}" for analysis files: {1}' .format(params['analysis_folder'], e)) return 'Sorry, something went wrong creating the folder "{0}" for the analysis files. Make sure ' \ 'the path to the file is correct.<br><br>Exception: {1}'.format(params['analysis_folder'], e) if not exists(params['diet_file']): cherrypy.log('Widget 5: diet file "{0}" was not found'.format( params['diet_file'])) return 'Sorry, diet file "{0}" was not found. Make sure the path to the file is correct.' \ .format(params['diet_file']) pair_models_file = join(params['analysis_folder'], params['pair_models_file']) if not exists(pair_models_file): cherrypy.log('Widget 5: pair list file "{0}" was not found'.format( pair_models_file)) return 'Sorry, pair list file "{0}" was not found. Make sure the path to the file is correct.' \ .format(pair_models_file) # Calculate growth rates for the two species models. try: with open(pair_models_file, 'r') as handle: pair_models = [line.strip() for line in handle] cherrypy.log( "Widget 5: Starting calculating growth rates for {0} pair models" .format(len(pair_models))) medium = read_diet_file(params['diet_file']) growth_rates = calculate_growth_rates(pair_models, medium) output_file = join(params['analysis_folder'], params['growth_rates_file']) growth_rates.to_csv(output_file, index=False) cherrypy.log("Widget 5: Finished calculating growth rates") except Exception as e: cherrypy.log( "Widget 5: Error calculating growth rates: {0}".format(e)) return "Sorry, something went wrong. Make sure the path to your file is correct.<br><br>" \ "Exception: {0}".format(e) # Generate the output for the Results tab. text = [ "Here's a glimpse of what the first few lines of your growth rates file look like.<br><br>" ] with open(output_file, 'r') as handle: for index in range(15): text.append(handle.readline()) return text
def more(self): with open("more.html", "r") as file: cherrypy.log("Visitor Log Entry") return "Your visit has been logged." return file.read()
def log_request_headers(debug=False): """Write request headers to the cherrypy error log.""" h = [" %s: %s" % (k, v) for k, v in cherrypy.serving.request.header_list] cherrypy.log('\nRequest Headers:\n' + '\n'.join(h), "HTTP")
def submitaction(user, workflows, action, session=None, **kwargs): """Writes the action to Unified and notifies the user that this happened :param str user: is the user that submitted the action :param str workflows: is the original workflow name or workflows :param str action: is the suggested action for Unified to take :param cherrypy.Session session: the current session :param kwargs: can include various reasons and additional datasets :returns: a tuple of workflows, reasons, and params for the action :rtype: list, str, list of dicts, dict """ cherrypy.log('args: {0}'.format(kwargs)) dotasks = kwargs.get('dotasks', []) if not isinstance(dotasks, list): dotasks = [dotasks] reasons, params = extract_reasons_params(action, **kwargs) cherrypy.log('Parameters: {0}'.format(params)) coll = get_actions_collection() error_info = check_session(session) # Let's define some lambdas to use to filter our ACDCs (sanity checks) # First a quick shorthand for workflow parameters get_params = lambda wkf: error_info.get_workflow( wkf).get_workflow_parameters() # We want request type to be resubmission in our ACDC is_resub = lambda wkf: \ get_params(wkf)['RequestType'] == 'Resubmission' # We want our ACDC to be submitted after the original request is_new = lambda wkf, workflow: \ datetime.datetime(*(get_params(wkf)['RequestDate'])) > \ datetime.datetime(*(get_params(workflow)['RequestDate'])) if not isinstance(workflows, list): workflows = [workflows] for workflow in workflows: wf_params = dict(params) step_list = error_info.get_step_list(workflow) short_step_list = ['/'.join(step.split('/')[2:]) for step in step_list] # For recovery, get the proper sites and parameters out for each step if action in ['acdc', 'recovery']: all_steps = wf_params.pop('AllSteps', {}) banned_sites = wf_params.pop('Ban', {'sites': []})['sites'] # Fill empty parameters for each step from AllSteps for short_step_name, step_name in zip(short_step_list, step_list): # Get any existing thing (most likely not there) step_params = wf_params.get(short_step_name, {}) for key, val in all_steps.iteritems(): # This also includes if the key value is set but blank if not step_params.get(key): step_params[key] = val wf_params[short_step_name] = step_params # Set the sites if kwargs.get('method', 'Manual') != 'Manual': # Banned sites would show up under 'AllSteps' wf_params[short_step_name]['sites'] = \ [site for site in \ check_session(session).get_workflow(workflow).\ site_to_run(step_name) if site not in banned_sites] # Only keep the workflow parameters with steps that occur in given workflow wf_params = {key: wf_params[key] for key in wf_params \ if key in short_step_list and \ (key in dotasks or not dotasks)} document = { 'Action': action, 'Parameters': wf_params, 'Reasons': [reason['long'] for reason in reasons], 'user': user, 'ACDCs': [wkf for wkf in error_info.get_prepid( error_info.get_workflow(workflow).get_prep_id()).get_workflows() \ if wkf != workflow and is_resub(wkf) and is_new(wkf, workflow)] } cherrypy.log('About to insert workflow: %s action: %s' % (workflow, document)) coll.update_one({'workflow': workflow}, { '$set': { 'timestamp': int(time.time()), 'parameters': document, 'acted': 0 } }, upsert=True) return workflows, reasons, params
def proxy(base=None, local='X-Forwarded-Host', remote='X-Forwarded-For', scheme='X-Forwarded-Proto', debug=False): """Change the base URL (scheme://host[:port][/path]). For running a CP server behind Apache, lighttpd, or other HTTP server. If you want the new request.base to include path info (not just the host), you must explicitly set base to the full base path, and ALSO set 'local' to '', so that the X-Forwarded-Host request header (which never includes path info) does not override it. Regardless, the value for 'base' MUST NOT end in a slash. cherrypy.request.remote.ip (the IP address of the client) will be rewritten if the header specified by the 'remote' arg is valid. By default, 'remote' is set to 'X-Forwarded-For'. If you do not want to rewrite remote.ip, set the 'remote' arg to an empty string. """ request = cherrypy.serving.request if scheme: s = request.headers.get(scheme, None) if debug: cherrypy.log('Testing scheme %r:%r' % (scheme, s), 'TOOLS.PROXY') if s == 'on' and 'ssl' in scheme.lower(): # This handles e.g. webfaction's 'X-Forwarded-Ssl: on' header scheme = 'https' else: # This is for lighttpd/pound/Mongrel's 'X-Forwarded-Proto: https' scheme = s if not scheme: scheme = request.base[:request.base.find("://")] if local: lbase = request.headers.get(local, None) if debug: cherrypy.log('Testing local %r:%r' % (local, lbase), 'TOOLS.PROXY') if lbase is not None: base = lbase.split(',')[0] if not base: port = request.local.port if port == 80: base = '127.0.0.1' else: base = '127.0.0.1:%s' % port if base.find("://") == -1: # add http:// or https:// if needed base = scheme + "://" + base request.base = base if remote: xff = request.headers.get(remote) if debug: cherrypy.log('Testing remote %r:%r' % (remote, xff), 'TOOLS.PROXY') if xff: if remote == 'X-Forwarded-For': # See http://bob.pythonmac.org/archives/2005/09/23/apache-x-forwarded-for-caveat/ xff = xff.split(',')[-1].strip() request.remote.ip = xff
def accept(media=None, debug=False): """Return the client's preferred media-type (from the given Content-Types). If 'media' is None (the default), no test will be performed. If 'media' is provided, it should be the Content-Type value (as a string) or values (as a list or tuple of strings) which the current resource can emit. The client's acceptable media ranges (as declared in the Accept request header) will be matched in order to these Content-Type values; the first such string is returned. That is, the return value will always be one of the strings provided in the 'media' arg (or None if 'media' is None). If no match is found, then HTTPError 406 (Not Acceptable) is raised. Note that most web browsers send */* as a (low-quality) acceptable media range, which should match any Content-Type. In addition, "...if no Accept header field is present, then it is assumed that the client accepts all media types." Matching types are checked in order of client preference first, and then in the order of the given 'media' values. Note that this function does not honor accept-params (other than "q"). """ if not media: return if isinstance(media, basestring): media = [media] request = cherrypy.serving.request # Parse the Accept request header, and try to match one # of the requested media-ranges (in order of preference). ranges = request.headers.elements('Accept') if not ranges: # Any media type is acceptable. if debug: cherrypy.log('No Accept header elements', 'TOOLS.ACCEPT') return media[0] else: # Note that 'ranges' is sorted in order of preference for element in ranges: if element.qvalue > 0: if element.value == "*/*": # Matches any type or subtype if debug: cherrypy.log('Match due to */*', 'TOOLS.ACCEPT') return media[0] elif element.value.endswith("/*"): # Matches any subtype mtype = element.value[:-1] # Keep the slash for m in media: if m.startswith(mtype): if debug: cherrypy.log('Match due to %s' % element.value, 'TOOLS.ACCEPT') return m else: # Matches exact value if element.value in media: if debug: cherrypy.log('Match due to %s' % element.value, 'TOOLS.ACCEPT') return element.value # No suitable media-range found. ah = request.headers.get('Accept') if ah is None: msg = "Your client did not send an Accept header." else: msg = "Your client sent this Accept header: %s." % ah msg += (" But this resource only emits these media types: %s." % ", ".join(media)) raise cherrypy.HTTPError(406, msg)
def log(self, msg): """Instruct the server to log the provided message to its error logs. """ return cherrypy.log(msg)
def log_traceback(severity=logging.ERROR, debug=False): """Write the last error's traceback to the cherrypy error log.""" cherrypy.log("", "HTTP", severity=severity, traceback=True)
def build(self): """ program build/update """ # store common file path in variables tgz_file = self.dl_dir + self.demo_src_filename prog_names = ["pgm2freeman", "displayContours", "extract3D"] script_names = ["convert.sh", "convertFig.sh", "transformBG.sh"] prog_bin_files = [] for a_prog in prog_names: prog_bin_files.append(self.bin_dir + a_prog) log_file = self.base_dir + "build.log" # get the latest source archive build.download(self.xlink_src, tgz_file) # test if the dest file is missing, or too old if (os.path.isfile(prog_bin_files[0]) and ctime(tgz_file) < ctime(prog_bin_files[0])): cherrypy.log("not rebuild needed", context='BUILD', traceback=False) else: # extract the archive build.extract(tgz_file, self.src_dir) # build the program os.mkdir(self.src_dir + self.demo_src_dir + "/build") build.run("cd %s; cmake .. -DBUILD_EXAMPLES=false \ -DCMAKE_BUILD_TYPE=Release \ -DDGTAL_BUILD_TESTING=false;\ make -j 4" %(self.src_dir+ self.demo_src_dir + "/build")\ , stdout=log_file) # save into bin dir if os.path.isdir(self.bin_dir): shutil.rmtree(self.bin_dir) os.mkdir(self.bin_dir) for i in range(0, len(prog_bin_files)): shutil.copy( self.src_dir + os.path.join(self.demo_src_dir, "build", "demoIPOL_ExtrConnectedReg", prog_names[i]), prog_bin_files[i]) for s_name in script_names: shutil.copy( self.src_dir + os.path.join(self.demo_src_dir, "demoIPOL_ExtrConnectedReg", s_name), self.bin_dir) # copy Dynamic lib shutil.copy( self.src_dir + self.demo_src_dir + "/build/src/libDGtal.so", self.bin_dir) shutil.copy( self.src_dir + self.demo_src_dir + "/build/src/libDGtalIO.so", self.bin_dir) # cleanup the source dir shutil.rmtree(self.src_dir) return
def append_headers(header_list, debug=False): if debug: cherrypy.log( 'Extending response headers with %s' % repr(header_list), 'TOOLS.APPEND_HEADERS') cherrypy.serving.response.header_list.extend(header_list)
def delete(self, filename): try: os.unlink(os.path.join(self.commentdir, filename)) except OSError: cpy.log("unable to delete file %s" % filename)
def ws(self): cherrypy.log("Handler created: %s" % repr(cherrypy.request.ws_handler))