Ejemplo n.º 1
0
def send_task(name, **kwargs):
    """Serialize task data and send to mule."""
    if not UWSGI:
        logger.warning("Not running within uwsgi. Task `%s` aborted", name)
    kwargs["__task_name"] = name
    data = convert_to_json(kwargs)
    uwsgi.mule_msg(data)
Ejemplo n.º 2
0
async def process_message(api, rtm, msg, loop):
    if "ok" in msg:
        return

    if msg["type"] != MsgType.MESSAGE or msg.get("subtype"):
        return

    # Don't react to bot's own messages :D
    if msg["user"] == rtm.bot_id:
        return

    print("Processing RTM message:", msg)

    text = msg["text"].strip()

    if text.startswith(rtm.bot_mention):
        bot_command = parse_command(text)
        await handle_bot_commands(api, rtm, bot_command, msg, loop)
        # Don't parse urls, the command might already did something with it
        return

    gerrit_urls = parse_gerrit_urls(text)
    if gerrit_urls:
        print(f"Found review links, adding them to queue: {gerrit_urls}")
        # with loop.create_task, it would raise an AssertionError:
        #   File "/usr/lib/python3.6/asyncio/coroutines.py", line 276, in _format_coroutine
        # assert iscoroutine(coro)
        # AssertionError
        # https://bugs.python.org/issue34071
        filtered_urls, existing_requests = await loop.run_in_executor(
            None, filter_existing_requests, gerrit_urls)
        loop.create_task(add_reaction(api, rtm, existing_requests, msg, loop))
        await loop.run_in_executor(None, save_review_requests, msg,
                                   filtered_urls)
        uwsgi.mule_msg(MuleMessage.RELOAD)
Ejemplo n.º 3
0
def convert_source(id):

    source_id = int(request.form['source_id'])
    format = request.form['format']
    # this is bit hack as user can have more roles
    role = current_user.roles[0].name
    if IN_UWSGI:
        uwsgi.mule_msg(current_user.email + '|' + role + '|' + str(source_id) +
                       '|' + format)
        task_id = ''
    else:
        global delegated_client
        if not loop.is_running():
            abort(500, 'Event loop is not running')
        with delegated_client_lock:
            if not delegated_client or not delegated_client.is_active():
                delegated_client = DelegatedClient(
                    current_app.config['DELEGATED_TOKEN'],
                    current_app.config['DELEGATED_URI'], loop)

        task_id = delegated_client.call_no_wait(current_user.email, role,
                                                'convert', source_id, format)

        if not task_id:
            abort(500, 'No task id')

    url = url_for('minimal.ebook_detail', id=id)
    flash(Markup('File was send for conversion %s- it\'ll take a while - <a href="%s">reload this page</a> later to view link to converted file' %\
                 ('' if not task_id else 'ref. %s '%task_id, url)))
    return redirect(url)
Ejemplo n.º 4
0
def convert_source(id):
    
    source_id = int(request.form['source_id'])
    format = request.form['format']
    # this is bit hack as user can have more roles
    role = current_user.roles[0].name
    if IN_UWSGI:
        uwsgi.mule_msg(current_user.email+'|'+ role +'|'+str(source_id)+'|'+format)
        task_id=''
    else:
        global delegated_client
        if not loop.is_running():
            abort(500, 'Event loop is not running')
        with delegated_client_lock:
            if not delegated_client or not delegated_client.is_active():
                delegated_client= DelegatedClient(current_app.config['DELEGATED_TOKEN'], 
                                                  current_app.config['DELEGATED_URI'], loop)
                
        task_id=delegated_client.call_no_wait(current_user.email, role, 'convert', source_id, format )
        
        if not task_id:
            abort(500, 'No task id')
    
    url = url_for('minimal.ebook_detail', id=id)
    flash(Markup('File was send for conversion %s- it\'ll take a while - <a href="%s">reload this page</a> later to view link to converted file' %\
                 ('' if not task_id else 'ref. %s '%task_id, url)))
    return redirect(url)
Ejemplo n.º 5
0
 def real_call(self, *args, **kwargs):
     uwsgi.mule_msg(
         pickle.dumps({
             'service': 'uwsgi_mulefunc',
             'func': self.fname,
             'args': args,
             'kwargs': kwargs
         }), self.mule)
 def real_call(self, *args, **kwargs):
     uwsgi.mule_msg(pickle.dumps(
         {
             'service': 'uwsgi_mulefunc',
             'func': self.fname,
             'args': args,
             'kwargs': kwargs
         }
     ), self.mule)
Ejemplo n.º 7
0
 def real_call(self, *args, **kwargs):
     uwsgi.mule_msg(
         pickle.dumps({
             "service": "uwsgi_mulefunc",
             "func": self.fname,
             "args": args,
             "kwargs": kwargs,
         }),
         self.mule,
     )
Ejemplo n.º 8
0
def handle_signal(signum, frame):
    log.info('Received signal %d, exiting', signum)
    if uwsgi and 'mule_id' in dir(uwsgi) and uwsgi.mule_id() > 0:
        farms = os.environ.get(UWSGI_FARMS_VAR, None)
        if farms:
            for farm in farms.split(','):
                uwsgi.farm_msg(farm, SHUTDOWN_MSG)
        else:
            uwsgi.mule_msg(SHUTDOWN_MSG, uwsgi.mule_id())
    exit.set()
Ejemplo n.º 9
0
    def add_onetime_job(self,
                        func: Union[str, FunctionType],
                        when: Optional[int] = None,
                        scheduled_by: Optional[str] = None,
                        **kwargs) -> int:
        """Schedule a job to run at a later time.

        Args:
            func: The function to call
            when: Optional number of seconds to wait before starting job
            **kwargs: Arguments to pass through to called function
        Returns:
            int: job_id
        """
        if when and isinstance(when, int):
            trigger = 'date'
            run_date = datetime.datetime.utcnow() + datetime.timedelta(
                seconds=when)
        else:
            trigger = None
            run_date = None

        with sqla_session() as session:
            job = Job()
            if run_date:
                job.scheduled_time = run_date
            session.add(job)
            session.flush()
            job_id = job.id

        kwargs['job_id'] = job_id
        kwargs['scheduled_by'] = scheduled_by
        if self.use_mule:
            try:
                import uwsgi
            except Exception as e:
                logger.exception("use_mule is set but not running in uwsgi")
                raise e
            args = dict(kwargs)
            if isinstance(func, FunctionType):
                args['func'] = str(func.__qualname__)
            else:
                args['func'] = str(func)
            args['trigger'] = trigger
            args['when'] = when
            args['id'] = str(job_id)
            uwsgi.mule_msg(json.dumps(args))
            return job_id
        else:
            self._scheduler.add_job(func,
                                    trigger=trigger,
                                    kwargs=kwargs,
                                    id=str(job_id),
                                    run_date=run_date)
            return job_id
Ejemplo n.º 10
0
def webhook():
    if not "token" in request.args:
        return render_template("403.html"), 403
    api_key = request.args["token"]

    if api_key in config["github"]:
        logging.debug("Submitting repo update for {}".format(config["github"][api_key]))
        uwsgi.mule_msg(api_key)
        return Response("Update successful", 200, mimetype="text/plain")

    return render_template("403.html"), 403
Ejemplo n.º 11
0
def _mule_msg(stream, line, mule=None):
    data = _encode_mule_msg(stream, line)
    # Unfortunately this check has to come after the marshalling
    # unless we just want to make a conservative guess
    if len(data) > max_recv_size:
        return False
    # Either deliver to a specific mule msg queue
    # or the shared queue which will be handled by
    # the first available mule (yay!)
    if mule:
        return uwsgi.mule_msg(data, mule)
    return uwsgi.mule_msg(data)
Ejemplo n.º 12
0
def process_request(json_in):
    uid = str(uuid.uuid4())
    json_in["id"] = uid
    uwsgi.queue_push(json.dumps(json_in))
    # Actual content of message does not really matter
    # This is just to triger mule execution
    uwsgi.mule_msg("s")
    while not uwsgi.cache_exists(uid, CACHE_NAME):
        continue
    res = uwsgi.cache_get(uid, CACHE_NAME)
    uwsgi.cache_del(uid, CACHE_NAME)
    return Response(response=res, status=200, mimetype="application/json")
Ejemplo n.º 13
0
    def remove_scheduled_job(self, job_id, abort_message="removed"):
        """Remove scheduled job from mule worker or local scheduler depending
        on setup."""
        if self.use_mule:
            try:
                import uwsgi
            except Exception as e:
                logger.exception("use_mule is set but not running in uwsgi")
                raise e
            args = {"scheduler_action": "remove", "id": str(job_id)}
            uwsgi.mule_msg(json.dumps(args))
        else:
            self.remove_local_job(job_id)

        with sqla_session() as session:
            job = session.query(Job).filter(Job.id == job_id).one_or_none()
            job.finish_abort(message=abort_message)
Ejemplo n.º 14
0
    def add_onetime_job(self,
                        func: Union[str, FunctionType],
                        when: Optional[int] = None,
                        **kwargs):
        """Schedule a job to run at a later time.

        Args:
            func: The function to call
            when: Optional number of seconds to wait before starting job
            **kwargs: Arguments to pass through to called function
        Returns:
            str: job_id
        """
        job = Jobtracker()
        id = job.create({'status': JobStatus.SCHEDULED})
        if when and isinstance(when, int):
            trigger = 'date'
            run_date = datetime.datetime.utcnow() + datetime.timedelta(
                seconds=when)
        else:
            trigger = None
            run_date = None
        kwargs['job_id'] = id
        if self.use_mule:
            try:
                import uwsgi
            except Exception as e:
                logger.exception("use_mule is set but not running in uwsgi")
                raise e
            args = dict(kwargs)
            if isinstance(func, FunctionType):
                args['func'] = str(func.__qualname__)
            else:
                args['func'] = str(func)
            args['trigger'] = trigger
            args['when'] = when
            args['id'] = id
            uwsgi.mule_msg(json.dumps(args))
            return id
        else:
            self._scheduler.add_job(func,
                                    trigger=trigger,
                                    kwargs=kwargs,
                                    id=id,
                                    run_date=run_date)
            return id
def handle_finish_event(db, event, rules, time_ms, time_id):
    disable_finish = db.reg_get_int('disable_finish', 0)

    if not disable_finish:
        run_id = db.run_finished(event['event_id'], time_ms)
        if run_id is None:
            db.update('times', time_id, invalid=True)
            logging.info("Finish [FALSE]: %r", time_id)
            play_sound('sounds/FalseFinish.wav')
        else:
            db.set_run_recalc(run_id)
            uwsgi.mule_msg('recalc')
            logging.info("Finish: %r", time_id)
            play_sound('sounds/CarFinished.wav')
    else:
        db.update('times', time_id, invalid=True)
        logging.info("Finish [DISABLED]: %r", time_id)
        play_sound('sounds/FalseFinish.wav')
def handle_start_event(db, event, rules, time_ms, time_id):
    next_entry_id = db.reg_get_int('next_entry_id')
    db.reg_set('next_entry_id', None)
    db.reg_set('next_entry_msg', None)
    disable_start = db.reg_get_int('disable_start', 0)

    if not disable_start:
        run_id = db.run_started(event['event_id'], time_ms, next_entry_id)
        if run_id is None:
            db.update('times', time_id, invalid=True)
            logging.info("Start [FALSE]: %r", time_id)
            play_sound('sounds/FalseStart.wav')
        else:
            db.set_run_recalc(run_id)
            uwsgi.mule_msg('recalc')
            logging.info("Start: %r", time_id)
            play_sound('sounds/CarStarted.wav')
    else:
        db.update('times', time_id, invalid=True)
        logging.info("Start [DISABLED]: %r", time_id)
        play_sound('sounds/FalseStart.wav')
Ejemplo n.º 17
0
def convert_source(id):
    token = create_token(current_user, current_app.config['SECRET_KEY'],
                         current_app.config['TOKEN_VALIDITY_HOURS'])
    source_id = int(request.form['source_id'])
    format = request.form['format']
    if IN_UWSGI:
        uwsgi.mule_msg(token + '|' + str(source_id) + '|' + format)
        task_id = ''
    else:
        if not loop.is_running():
            abort(500, 'Event loop is not running')
        client = WAMPClient(token, current_app.config['WAMP_URI'], loop=loop)
        try:
            task_id = client.call_no_wait('convert', source_id, format)
        finally:
            client.close()
        if not task_id:
            abort(500, 'No task id')

    url = url_for('minimal.ebook_detail', id=id)
    flash(Markup('File was send for conversion %s- it\'ll take a while - <a href="%s">reload this page</a> later to view link to converted file' %\
                 ('' if not task_id else 'ref. %s '%task_id, url)))
    return redirect(url)
Ejemplo n.º 18
0
def application(environ, start_response):
    """
    WSGI application to handle 404's.
    """
    # Remove wsgi.* items
    for key in environ.keys():
        if key.startswith('wsgi.'):
            del environ[key]

    # Pass data to the mule
    uwsgi.mule_msg(json.dumps(environ))

    # '' is the default route
    route_to = ''
    if environ['PATH_INFO'] in CONFIG['ROUTES'].keys():
        route_to = environ['PATH_INFO']

    status, html_file = map(str, CONFIG['ROUTES'][route_to])

    # Return data to the user
    start_response(status, [('Content-Type', 'text/html')])
    with open(html_file, 'r') as data:
        for line in data.readlines():
            yield line
Ejemplo n.º 19
0
 def control_ws(ws):
     uwsgi.mule_msg(b"bt scan on", 1)
     try:
         with app.request_context(ws.environ):
             if not session.get("logged_in"):
                 return redirect(
                     with_query_string(url_for('auth.login'), "next",
                                       request.url))
         with suppress(SystemError, OSError):
             for raw_msg in iter(ws.receive, None):
                 msg = json.loads(raw_msg.decode())
                 #for mule, dev in zip(cycle(range(1, NUM_BT_WORKERS+1)), msg["devices"]):
                 for dev in msg["devices"]:
                     uwsgi.mule_msg(b"bt send " + dev.encode() + b" " +
                                    pack("B", msg["angle"]))
     finally:
         uwsgi.mule_msg(b"bt scan off", 1)
Ejemplo n.º 20
0
 def ping_worker():
     pong.clear()
     uwsgi.mule_msg(b"bt ping", 1)
     return pong.wait(3)
Ejemplo n.º 21
0
 def spool(self, *args, **kwargs):
     kwargs.update(ud_spool_func=self.__name__)
     uwsgi.mule_msg(json.dumps(kwargs))
Ejemplo n.º 22
0
def scores_page():
  db = get_db()
  g.event = get_event(db)
  g.rules = get_rules(g.event)

  if g.event is None:
    flash("No active event!", F_ERROR)
    return redirect(url_for('events_page'))
  if g.rules is None:
    flash("Invalid rule set for active event!", F_ERROR)
    return redirect(url_for('events_page'))
  
  action = request.form.get('action')

  if action == 'event_recalc':
    db.set_event_recalc(g.event['event_id'])
    uwsgi.mule_msg('recalc')
    flash("Event scores recalculating")
    return redirect(url_for('scores_page'))

  elif action == 'entry_recalc':
    entry_id = request.form.get('entry_id')
    if not db.entry_exists(entry_id):
      flash("Invalid entry id", F_ERROR)
      return redirect(url_for('entries_page'))
    db.set_entry_recalc(entry_id)
    uwsgi.mule_msg('recalc')
    flash("Entry score recalculating")
    return redirect(url_for('scores_page'))

  elif action == 'entries_fill_dns':
    for entry_id in request.form.getlist('entry_id'):
      run_count = db.run_count(entry_id=entry_id, state=('started','finished','scored'))
      for i in range(g.rules.max_runs - run_count):
        flash("Add DNS [%s, %r]" % (entry_id,i))
        run_id = db.insert('runs', event_id=g.event['event_id'], entry_id=entry_id, recalc=1, dns_dnf=1, state='scored')
        flash("Added new run [%r]" % run_id)
      uwsgi.mule_msg('recalc')

    return redirect(url_for('scores_page'))

  elif action == 'entries_trim_dns':
    return redirect(url_for('scores_page'))
  
  elif action is not None:
    flash("Unkown form action %r" % action, F_ERROR)
    return redirect(url_for('scores_page'))

  # sort entries into car class
  g.class_entry_list = {}
  g.entry_list = db.entry_list(g.event['event_id'])
  for entry in g.entry_list:
    if entry['car_class'] not in g.class_entry_list:
      g.class_entry_list[entry['car_class']] = []
    if entry['scores_visible']:
      g.class_entry_list[entry['car_class']].append(entry)

  # sort each car class by event_time_ms and run_count
  for car_class in g.class_entry_list:
    g.class_entry_list[car_class].sort(cmp=entry_cmp)

  g.entry_run_list = {}
  for entry in g.entry_list:
    g.entry_run_list[entry['entry_id']] = db.run_list(entry_id=entry['entry_id'], state=('scored','finished','started'), limit=g.rules.max_runs)

  return render_template('admin_scores.html')
Ejemplo n.º 23
0
def disconnect(macaddr):
    if has_uwsgi:
        uwsgi.mule_msg(b"bt disconnect " + macaddr.upper().encode(), 1)
    return render_template("ctrl/connect.html",
                           macaddr=macaddr,
                           connecting=False)
Ejemplo n.º 24
0
 def do_offload(params):
     mule_msg(dumps(params), mule)
Ejemplo n.º 25
0
def application(env, start_response):
    try:
        uwsgi.mule_msg(env['REQUEST_URI'], 1)
    except:
        pass

    req = uwsgi.workers()[uwsgi.worker_id() - 1]['requests']

    uwsgi.setprocname("worker %d managed %d requests" %
                      (uwsgi.worker_id(), req))

    try:
        gc.collect(2)
    except:
        pass
    if DEBUG:
        print(env['wsgi.input'].fileno())

    if env['PATH_INFO'] in routes:
        return routes[env['PATH_INFO']](env, start_response)

    if DEBUG:
        print(env['wsgi.input'].fileno())

    try:
        gc.collect(2)
    except:
        pass

    if DEBUG:
        print(len(gc.get_objects()))

    workers = ''
    for w in uwsgi.workers():
        apps = '<table border="1"><tr><th>id</th><th>mountpoint</th><th>startup time</th><th>requests</th></tr>'
        for app in w['apps']:
            apps += '<tr><td>%d</td><td>%s</td><td>%d</td><td>%d</td></tr>' % (
                app['id'], app['mountpoint'], app['startup_time'],
                app['requests'])
        apps += '</table>'
        workers += """
<tr>
<td>%d</td><td>%d</td><td>%s</td><td>%d</td><td>%d</td><td>%d</td><td>%s</td>
</tr>
        """ % (w['id'], w['pid'], w['status'], w['running_time'] / 1000,
               w['avg_rt'] / 1000, w['tx'], apps)

    output = """
<img src="/logo"/> version %s running on %s (remote user: %s)<br/>
<hr size="1"/>

Configuration<br/>
<iframe src="/config"></iframe><br/>

<br/>
Workers and applications<br/>
<table border="1">
<tr>
<th>wid</th><th>pid</th><th>status</th><th>running time</th><th>average</th><th>tx</th><th>apps</th>
</tr>
%s
</table>

    """ % (uwsgi.version, uwsgi.hostname, env.get('REMOTE_USER',
                                                  'None'), workers)

    start_response('200 OK', [('Content-Type', 'text/html'),
                              ('Content-Length', str(len(output)))])

    # return bytes(output.encode('latin1'))
    return output
Ejemplo n.º 26
0
def events_page():
  db = get_db()
  action = request.form.get('action')

  if action == 'activate':
    event_id = request.form.get('event_id')
    if db.event_exists(event_id):
      db.reg_set('active_event_id', event_id)
      flash("Set active event to %r" % event_id)
    else:
      flash("Invalid event_id", F_ERROR)
    return redirect(url_for('events_page'));

  elif action == 'deactivate':
    db.reg_set('active_event_id', None)
    flash("Event de-activated")
    return redirect(url_for('events_page'));

  elif action == 'update':
    event_id = request.form.get('event_id')
    if not db.event_exists(event_id):
      flash("Invalid event id", F_ERROR)
      return redirect(url_for('events_page'))
    event_data = {}
    for key in db.table_columns('events'):
      if key in ['event_id']:
        continue # ignore
      elif key in request.form:
        event_data[key] = request.form.get(key)
    db.update('events', event_id, **event_data)
    flash("Event changes saved")
    return redirect(url_for('events_page'))

  elif action == 'insert':
    event_data = {}
    for key in db.table_columns('events'):
      if key in ['event_id']:
        continue # ignore
      elif key in request.form:
        event_data[key] = request.form.get(key)
    event_id = db.insert('events', **event_data)
    flash("Added new event [%r]" % event_id)
    return redirect(url_for('events_page'))

  elif action == 'delete':
    if request.form.get('confirm_delete'):
      event_id = request.form.get('event_id')
      if db.event_exists(event_id):
        if db.reg_get('active_event_id') == event_id:
          db.reg_set('active_event_id',None)
        db.update("events", event_id, deleted=1)
        # FIXME do we need to propagate this to runs and entries?
        flash("Event deleted")
      else:
        flash("Invalid event_id for delete operation.", F_ERROR)
    else:
      flash("Delete ignored, no confirmation", F_WARN)
    return redirect(url_for('events_page'))

  elif action == 'recalc':
    event_id = request.form.get('event_id')
    if not db.event_exists(event_id):
      flash("Invalid event id", F_ERROR)
      return redirect(url_for('events_page'))
    # flag all entries for this event to be recalculated
    db.set_event_recalc(event_id)
    uwsgi.mule_msg('recalc')
    flash("Event scores recalculating")
    return redirect(url_for('events_page'))

  elif action is not None:
    flash("Invalid form action %r" % action, F_ERROR)
    return redirect(url_for('events_page'))

  g.event = get_event(db)
  g.event_list = db.select_all('events', deleted=0, _order_by='event_id')
  g.default_date = datetime.date.today().isoformat()
  g.default_season = datetime.date.today().year

  g.rule_sets = scoring_rules.get_rule_sets()
  g.default_rule_set = db.reg_get('default_rule_set')
  
  return render_template('admin_events.html')
Ejemplo n.º 27
0
def timing_page():
  db = get_db()
  g.event = get_event(db)
  g.rules = get_rules(g.event)

  if g.event is None:
    flash("No active event!", F_ERROR)
    return redirect(url_for('events_page'))
  if g.rules is None:
    flash("Invalid rule set for active event!", F_ERROR)
    return redirect(url_for('events_page'))


  if 'entry_filter' in request.args:
    session['entry_filter'] = request.args.get('entry_filter')
    if session['entry_filter'] not in (None, 'all', 'noassign'):
      try:
        session['entry_filter'] = int(session['entry_filter'])
      except ValueError:
        flash("Invalid entry filter", F_ERROR)
        session['entry_filter'] = None

  if 'started_filter' in request.args:
    session['started_filter'] = bool(request.args.get('started_filter'))

  if 'finished_filter' in request.args:
    session['finished_filter'] = bool(request.args.get('finished_filter'))

  if 'scored_filter' in request.args:
    session['scored_filter'] = bool(request.args.get('scored_filter'))

  if 'tossout_filter' in request.args:
    session['tossout_filter'] = bool(request.args.get('tossout_filter'))

  if 'run_limit' in request.args:
    session['run_limit'] = parse_int(request.args.get('run_limit'), 20)

  action = request.form.get('action')

  if action == 'toggle_start':
    db.reg_toggle('disable_start', True)
    return redirect(url_for('timing_page'))

  elif action == 'toggle_finish':
    db.reg_toggle('disable_finish', True)
    return redirect(url_for('timing_page'))

  elif action == 'set_next':
    if request.form.get('next'):
      db.reg_set('next_entry_id',request.form.get('next'))
      db.reg_set('next_entry_msg', None)
    return redirect(url_for('timing_page'))

  elif action == 'clear_next':
    db.reg_set('next_entry_id', None)
    db.reg_set('next_entry_msg', None)
    return redirect(url_for('timing_page'))

  elif action == 'set_filter':
    session['entry_filter'] = request.form.get('entry_filter')
    session['started_filter'] = bool(request.form.get('started_filter'))
    session['finished_filter'] = bool(request.form.get('finished_filter'))
    session['scored_filter'] = bool(request.form.get('scored_filter'))
    session['tossout_filter'] = bool(request.form.get('tossout_filter'))
    session['run_limit'] = parse_int(request.form.get('run_limit'), 20)

    if session['entry_filter'] not in (None, 'all', 'noassign'):
      try:
        session['entry_filter'] = int(session['entry_filter'])
      except ValueError:
        flash("Invalid entry filter", F_ERROR)
        session['entry_filter'] = None

    return redirect(url_for('timing_page'))

  elif action == 'reset_filter':
    session['entry_filter'] = None
    session['started_filter'] = True
    session['finished_filter'] = True
    session['scored_filter'] = True
    session['tossout_filter'] = True
    session['run_limit'] = 20
    return redirect(url_for('timing_page'))

  elif action == 'set_max_runs': # FIXME consider removing this so we only set max runs on events page
    try:
      max_runs = int(request.form.get('max_runs',''))
    except ValueError:
      flash("Invalid max runs", F_ERROR)
    else:
      db.update('events', g.event['event_id'], max_runs=max_runs)
      # make sure we recalculate all entries event totals based on new max runs
      # this is mainly needed with drop runs > 0
      db.set_event_recalc(g.event['event_id'])
      uwsgi.mule_msg('recalc')
      flash("Event scores recalculating")
    return redirect(url_for('timing_page'))

  elif action == 'update':
    run_id = request.form.get('run_id')
    if not db.run_exists(run_id):
      flash("Invalid run id", F_ERROR)
      return redirect(url_for('timing_page'))
    run_data = {'dns_dnf':0} # add default for dns_dnf checkboxes if not selected
    for key in db.table_columns('runs') + ['start_time','finish_time','split_1_time','split_2_time']:
      if key in ['run_id']:
        continue # ignore
      elif key == 'start_time':
        try:
          run_data['start_time_ms'] = parse_time_ex(request.form.get(key))
        except:
          logging.debug(request.form.get(key))
          flash("Invalid start time, start time not changed.", F_ERROR)
      elif key == 'finish_time':
        if request.form.get('old_state') != 'started':
          try:
            run_data['finish_time_ms'] = parse_time_ex(request.form.get(key))
          except:
            logging.debug(request.form.get(key))
            flash("Invalid finish time, finish time not changed.", F_ERROR)
      elif key == 'split_1_time':
        try:
          run_data['split_1_time_ms'] = parse_time_ex(request.form.get(key))
        except:
          logging.debug(request.form.get(key))
          flash("Invalid split 1 time, split 1 time not changed.", F_ERROR)
      elif key == 'split_2_time':
        try:
          run_data['split_2_time_ms'] = parse_time_ex(request.form.get(key))
        except:
          logging.debug(request.form.get(key))
          flash("Invalid split 2 time, split 2 time not changed.", F_ERROR)
      elif key == 'state' and request.form.get('state') == request.form.get('old_state'):
        pass # ignore setting state so we dont clobber a finish
      elif key == 'entry_id' and request.form.get(key) == 'None':
        run_data[key] = None
      elif key == 'dns_dnf' and request.form.get(key) and request.form.get('state') == 'started':
        pass # ignore setting dns_dnf if we are still in the started state
      elif key in request.form:
        run_data[key] = clean_str(request.form.get(key))

    if request.form.get('state') == 'started' and run_data.get('start_time_ms') == 0:
      run_data['start_time_ms'] = None
    if request.form.get('state') == 'started' and run_data.get('finsih_time_ms') == 0:
      run_data['finish_time_ms'] = None

    if run_data.get('state', request.form.get('old_state')) == 'scored' and run_data.get('finish_time_ms') is None and run_data.get('dns_dnf') == 0:
      flash("Invalid raw time, unable to set state to 'scored'", F_ERROR)
      flash("Setting state to 'finished'", F_WARN)
      run_data['state'] = 'finished'

    db.update('runs', run_id, **run_data)
    flash("Run changes saved")

    old_entry_id = request.form.get('old_entry_id')
    if old_entry_id != request.form.get('entry_id') and old_entry_id != 'None':
      db.set_entry_recalc(old_entry_id)
      uwsgi.mule_msg('recalc')
      flash("Old entry recalc")

    db.set_run_recalc(run_id)
    uwsgi.mule_msg('recalc')
    flash("Run recalc")

    if 'entry_id' in run_data and run_data['entry_id'] is not None:
      db.set_entry_recalc(run_data['entry_id'])
      uwsgi.mule_msg('recalc')
      flash("Entry recalc")

    return redirect(url_for('timing_page'))

  elif action == 'insert':
    run_data = {}
    for key in db.table_columns('runs'):
      if key in ['run_id']:
        continue # ignore
      elif key in request.form:
        run_data[key] = clean_str(request.form.get(key))
    run_id = db.insert('runs', **run_data)
    db.set_run_recalc(run_id)
    uwsgi.mule_msg('recalc')
    flash("Added new run [%r]" % run_id)
    return redirect(url_for('timing_page'))

  elif action is not None:
    flash("Invalid form action %r" % action, F_ERROR)
    return redirect(url_for('timing_page'))

  if 'entry_filter' not in session:
    session['entry_filter'] = None
  if 'started_filter' not in session:
    session['started_filter'] = True
  if 'finished_filter' not in session:
    session['finished_filter'] = True
  if 'scored_filter' not in session:
    session['scored_filter'] = True
  if 'tossout_filter' not in session:
    session['tossout_filter'] = True
  if 'hide_invalid_times' not in session:
    session['hide_invalid_times'] = False
  if 'run_limit' not in session:
    session['run_limit'] = 20

  state_filter = []
  if session['started_filter']:
    state_filter += ['started']
  if session['finished_filter']:
    state_filter += ['finished']
  if session['scored_filter']:
    state_filter += ['scored']
  if session['tossout_filter']:
    state_filter += ['tossout']
  
  g.run_list = db.run_list(event_id=g.event['event_id'], entry_id=session['entry_filter'], state=state_filter, sort='d', limit=session['run_limit'])
  g.entry_list = db.entry_list(g.event['event_id'])

  g.cars_started = db.run_count(event_id=g.event['event_id'], state='started')
  g.cars_finished = db.run_count(event_id=g.event['event_id'], state='finished')
  
  g.disable_start = db.reg_get_int('disable_start', 0)
  g.disable_finish = db.reg_get_int('disable_finish', 0)
  
  g.next_entry_id = db.reg_get_int('next_entry_id')
  g.next_entry = db.select_one('entries', entry_id=g.next_entry_id)
  if g.next_entry_id is None:
    g.next_entry_run_number = None
  else:
    # FIXME change this to max of run_number instead of count
    g.next_entry_run_number = 1 + db.run_count(entry_id=g.next_entry_id, state=('started','finished','scored'))
  
  g.barcode_scanner_status = db.reg_get('barcode_scanner_status')
  g.tag_heuer_status = db.reg_get('tag_heuer_status')
  g.rfid_reader_status = db.reg_get('rfid_reader_status')

  # FIXME change how watchdog is handled
  g.hardware_ok = True
  g.start_ready = g.hardware_ok and (g.tag_heuer_status == 'Open') and not g.disable_start
  g.finish_ready = g.hardware_ok and (g.tag_heuer_status == 'Open') and not g.disable_finish

  g.run_group = db.reg_get('run_group')
  g.next_entry_msg = db.reg_get('next_entry_msg')

  # create car description strings for entries
  g.car_dict = {}
  for entry in g.entry_list:
    g.car_dict[entry['entry_id']] = "%s %s %s %s" % (entry['car_color'], entry['car_year'], entry['car_make'], entry['car_model'])

  return render_template('admin_timing.html')
Ejemplo n.º 28
0
Archivo: uwsgi.py Proyecto: esho/spire
 def send(self, message):
     uwsgi.mule_msg(message, self.id)
Ejemplo n.º 29
0
 def send_message(self, msg):
     if self.uwsgi_available:
         uwsgi.mule_msg(msg)
     else:
         print('warning: uwsgi not available')
Ejemplo n.º 30
0
 def log_uwsgi(self, sender, response, **kwargs):
     msg = self.create_log_message(response)
     picklestring = pickle.dumps(msg)
     uwsgi.mule_msg(picklestring,1)
Ejemplo n.º 31
0
 def execute_async(self):
     mule_id = self.setup.get('mule', self.default_mule_id)
     return uwsgi.mule_msg(self.get_message_content(), mule_id)
Ejemplo n.º 32
0
def application(env, start_response):

    try:
        uwsgi.mule_msg(env["REQUEST_URI"], 1)
    except:
        pass

    req = uwsgi.workers()[uwsgi.worker_id() - 1]["requests"]

    uwsgi.setprocname("worker %d managed %d requests" % (uwsgi.worker_id(), req))

    gc.collect(2)
    if DEBUG:
        print(env["wsgi.input"].fileno())

    if routes.has_key(env["PATH_INFO"]):
        return routes[env["PATH_INFO"]](env, start_response)

    start_response("200 OK", [("Content-Type", "text/html")])

    if DEBUG:
        print(env["wsgi.input"].fileno())

    gc.collect(2)

    if DEBUG:
        print(len(gc.get_objects()))

    workers = ""
    for w in uwsgi.workers():
        apps = '<table border="1"><tr><th>id</th><th>mountpoint</th><th>requests</th></tr>'
        for app in w["apps"]:
            apps += "<tr><td>%d</td><td>%s</td><td>%d</td></tr>" % (app["id"], app["mountpoint"], app["requests"])
        apps += "</table>"
        workers += """
<tr>
<td>%d</td><td>%d</td><td>%s</td><td>%d</td><td>%d</td><td>%d</td><td>%s</td>
</tr>
        """ % (
            w["id"],
            w["pid"],
            w["status"],
            w["running_time"] / 1000,
            w["avg_rt"] / 1000,
            w["tx"],
            apps,
        )

    return """
<img src="/logo"/> version %s<br/>
<hr size="1"/>

Configuration<br/>
<iframe src="/config"></iframe><br/>

<br/>

Dynamic options<br/>
<iframe src="/options"></iframe><br/>

<br/>
Workers and applications<br/>
<table border="1">
<tr>
<th>wid</th><th>pid</th><th>status</th><th>running time</th><th>average</th><th>tx</th><th>apps</th>
</tr>
%s
</table>

    """ % (
        uwsgi.version,
        workers,
    )
Ejemplo n.º 33
0
 def real_call(self, *args, **kwargs):
     uwsgi.mule_msg(
         pickle.dumps({"service": "uwsgi_mulefunc", "func": self.fname, "args": args, "kwargs": kwargs}), self.mule
     )
Ejemplo n.º 34
0
def application(env, start_response):
    try:
        uwsgi.mule_msg(env['REQUEST_URI'], 1)
    except:
        pass

    req = uwsgi.workers()[uwsgi.worker_id()-1]['requests']

    uwsgi.setprocname("worker %d managed %d requests" % (uwsgi.worker_id(), req))

    try:
        gc.collect(2)
    except:
        pass
    if DEBUG:
        print(env['wsgi.input'].fileno())

    if env['PATH_INFO'] in routes:
        return routes[env['PATH_INFO']](env, start_response)


    if DEBUG:
        print(env['wsgi.input'].fileno())

    try:
        gc.collect(2)
    except:
        pass

    if DEBUG:
        print(len(gc.get_objects()))

    workers = ''
    for w in uwsgi.workers():
        apps = '<table border="1"><tr><th>id</th><th>mountpoint</th><th>startup time</th><th>requests</th></tr>'
        for app in w['apps']:
            apps += '<tr><td>%d</td><td>%s</td><td>%d</td><td>%d</td></tr>' % (app['id'], app['mountpoint'], app['startup_time'], app['requests']) 
        apps += '</table>'
        workers += """
<tr>
<td>%d</td><td>%d</td><td>%s</td><td>%d</td><td>%d</td><td>%d</td><td>%s</td>
</tr>
        """ % (w['id'], w['pid'], w['status'], w['running_time']/1000, w['avg_rt']/1000, w['tx'], apps)

    output = """
<img src="/logo"/> version %s running on %s (remote user: %s)<br/>
<hr size="1"/>

Configuration<br/>
<iframe src="/config"></iframe><br/>

<br/>

Dynamic options<br/>
<iframe src="/options"></iframe><br/>

<br/>
Workers and applications<br/>
<table border="1">
<tr>
<th>wid</th><th>pid</th><th>status</th><th>running time</th><th>average</th><th>tx</th><th>apps</th>
</tr>
%s
</table>

    """ % (uwsgi.version, uwsgi.hostname, env.get('REMOTE_USER','None'), workers)

    start_response('200 OK', [('Content-Type', 'text/html'), ('Content-Length', str(len(output)) )])

    #return bytes(output.encode('latin1'))
    return output
Ejemplo n.º 35
0
def bluetooth_restart():
    if has_uwsgi:
        uwsgi.mule_msg(b"bt restart", 1)
    return redirect(url_for(".bluetooth"))
Ejemplo n.º 36
0
def reload_mule(sender, **kwargs):
    from bot import MuleMessage
    uwsgi.mule_msg(MuleMessage.RELOAD)
Ejemplo n.º 37
0
def penalties_page():
  db = get_db()
  g.event = get_event(db)
  g.rules = get_rules(g.event)

  if g.event is None:
    flash("No active event!", F_ERROR)
    return redirect(url_for('events_page'))
  if g.rules is None:
    flash("Invalid rule set for active event!", F_ERROR)
    return redirect(url_for('events_page'))

  action = request.form.get('action')

  if action == 'insert':
    entry_id = request.form.get('entry_id')
    penalty_time = request.form.get('penalty_time')
    penalty_note = request.form.get('penalty_note')

    if not db.entry_exists(entry_id):
      flash("Invalid entry id", F_ERROR)
      return redirect(url_for('penalties_page'))

    try:
      time_ms = parse_time_ex(penalty_time)
    except:
      flash("Invalid penalty time", F_ERROR)
      return redirect(url_for('penalties_page'))
    
    if time_ms is None:
      time_ms = 0

    db.insert('penalties', event_id=g.event['event_id'], entry_id=entry_id, time_ms=time_ms, penalty_note=penalty_note)
    flash("Penalty added")

    db.set_entry_recalc(entry_id)
    uwsgi.mule_msg('recalc')
    flash("Entry recalculating")

    return redirect(url_for('penalties_page'))

  elif action == 'update':
    penalty_id = request.form.get('penalty_id')
    entry_id = request.form.get('entry_id')
    penalty_time = request.form.get('penalty_time')
    penalty_note = request.form.get('penalty_note')
    old_penalty = db.select_one('penalties', penalty_id=penalty_id)

    if penalty_id is None:
      flash("Invalid penalty id", F_ERROR)
      return redirect(url_for('penalties_page'))

    if not db.entry_exists(entry_id):
      flash("Invalid entry id", F_ERROR)
      return redirect(url_for('penalties_page'))

    try:
      time_ms = parse_time_ex(penalty_time)
    except:
      flash("Invalid penalty time", F_ERROR)
      return redirect(url_for('penalties_page'))

    if time_ms is None:
      time_ms = 0

    db.update('penalties', penalty_id, entry_id=entry_id, time_ms=time_ms, penalty_note=penalty_note)
    flash("Penalty updated")

    if old_penalty['entry_id'] != parse_int(entry_id):
      # update previous entry
      flash("old entry recalc, %r != %r" % (old_penalty['entry_id'],entry_id))
      db.set_entry_recalc(old_penalty['entry_id'])
      uwsgi.mule_msg('recalc')

    # update current entry
    db.set_entry_recalc(entry_id)
    uwsgi.mule_msg('recalc')
    flash("entry recalc")

    return redirect(url_for('penalties_page'))

  elif action == 'delete':
    penalty_id = request.form.get('penalty_id')
    old_penalty = db.select_one('penalties', penalty_id=penalty_id)

    if old_penalty is None:
      flash("Invalid penalty id", F_ERROR)
      return redirect(url_for('penalties_page'))

    db.update('penalties', penalty_id, deleted=1)
    flash("Penalty deleted")

    # update previous entry
    flash("old entry recalc")
    db.set_entry_recalc(old_penalty['entry_id'])
    uwsgi.mule_msg('recalc')

    return redirect(url_for('penalties_page'))

  elif action is not None:
    flash("Unkown form action %r" % action, F_ERROR)
    return redirect(url_for('penalties_page'))

  g.penalty_list = db.select_all('penalties', event_id=g.event['event_id'], deleted=0, _order_by="penalty_id")
  g.entry_list = db.entry_list(g.event['event_id'])

  return render_template('admin_penalties.html')
Ejemplo n.º 38
0
    def add_onetime_job(self,
                        func: Union[str, FunctionType],
                        when: Optional[int] = None,
                        scheduled_by: Optional[str] = None,
                        **kwargs) -> int:
        """Schedule a job to run at a later time on the mule worker or
        local scheduler depending on setup.

        Some extra checks against kwargs are performed here. If kwarg
        with name 'dry_run' is included, (dry_run) is appended to function
        name. If kwarg job_comment or job_ticket_ref are included, those
        fields in the job will be populated.

        Args:
            func: The function to call
            when: Optional number of seconds to wait before starting job
            scheduled_by: Username that scheduled the job
            **kwargs: Arguments to pass through to called function
        Returns:
            int: job_id
        """
        if when and isinstance(when, int):
            trigger = 'date'
            run_date = datetime.datetime.utcnow() + datetime.timedelta(
                seconds=when)
        else:
            trigger = None
            run_date = None

        if isinstance(func, FunctionType):
            func_qualname = str(func.__qualname__)
        else:
            func_qualname = str(func)
        func_name = func_qualname.split(':')[-1]

        try:
            json.dumps(kwargs)
        except TypeError as e:
            raise TypeError("Job args must be JSON serializable: {}".format(e))

        # Append (dry_run) to function name if set, so we can distinguish dry_run jobs
        try:
            if kwargs['kwargs']['dry_run']:
                func_name += " (dry_run)"
        except Exception:
            pass

        with sqla_session() as session:
            job = Job()
            if run_date:
                job.scheduled_time = run_date
            job.function_name = func_name
            if scheduled_by is None:
                scheduled_by = 'unknown'
            job.scheduled_by = scheduled_by
            job_comment = kwargs['kwargs'].pop('job_comment', None)
            if job_comment and isinstance(job_comment, str):
                job.comment = job_comment[:255]
            job_ticket_ref = kwargs['kwargs'].pop('job_ticket_ref', None)
            if job_ticket_ref and isinstance(job_comment, str):
                job.ticket_ref = job_ticket_ref[:32]
            job.start_arguments = kwargs['kwargs']
            session.add(job)
            session.flush()
            job_id = job.id

        kwargs['job_id'] = job_id
        kwargs['scheduled_by'] = scheduled_by
        if self.use_mule:
            try:
                import uwsgi
            except Exception as e:
                logger.exception("use_mule is set but not running in uwsgi")
                raise e
            args = dict(kwargs)
            args['func'] = func_qualname
            args['trigger'] = trigger
            args['when'] = when
            args['id'] = str(job_id)
            uwsgi.mule_msg(json.dumps(args))
            return job_id
        else:
            self.add_local_job(func,
                               trigger=trigger,
                               kwargs=kwargs,
                               id=str(job_id),
                               run_date=run_date,
                               name=func_qualname)
            return job_id
Ejemplo n.º 39
0
 def execute_async(self):
     mule_id = self.setup.get('mule', self.default_mule_id)
     return uwsgi.mule_msg(self.get_message_content(), mule_id)