def get_ama_model():
data = redis_get(AMA, None)
if data:
redis.set(AMA, 'None')
if data == 'None':
return None
return data
def start_user_app_request(username, userid, app_name, params, expires):
queue = SchedulerState.get_user_queue()
c_app = SchedulerState.get_current_app()
removed_previous = True
# New request from the same user sweeps older ones
for i, job in enumerate(queue):
if job['userid'] == userid:
del queue[i]
removed_previous = True
# New request from the same user makes the current app expiring
if c_app and c_app.get('userid', False) == userid:
c_app['expire_at'] = str(datetime.datetime.now())
SchedulerState.set_current_app(c_app)
removed_previous = True
app_struct = {'name': app_name,
'username': username,
'userid': userid,
'params': params,
'started_wait_at': datetime.datetime.now().isoformat(),
'expires': expires,
'task_id': None,
'last_alive': time.time(),
'expire_at': None}
queue.append(app_struct)
redis.set(SchedulerState.KEY_USERS_Q, json.dumps(queue))
return True, removed_previous
def start_forced_fap(fap):
SchedulerState.clear_user_app_queue()
SchedulerState.set_app_started_at()
name = fap['name']
params = fap['params']
app = {
'name': name,
'username': '******',
'userid': '>>>>FORCED<<<<',
'params': fap['params'],
'task_id': start_forced_fap.request.id,
'last_alive': time.time(),
'started_at': datetime.datetime.utcnow().isoformat(),
'is_default': False,
'is_forced': True,
'expire_at':
str(datetime.datetime.utcnow() + datetime.timedelta(weeks=52))
}
SchedulerState.set_current_app(app)
SchedulerState.set_event_lock(False)
fap = globals()[name](app['username'], app['userid'])
try:
fap.run(params=params)
return True
finally:
fap.close()
redis.set(SchedulerState.KEY_FORCED_APP, 'False')
SchedulerState.set_current_app({})
def update_geometry(r=None, c=None, d=None):
redis.set(SchedulerState.KEY_GEOMETRY,
json.dumps({
'rows': r,
'cols': c,
'disabled': d
}))
def set_grantUser(user): # user : { 'id': string, 'username': string}
logging.info("Granting {}".format(user))
redis.set(KEY_GRANTUSER,
json.dumps({
'id': user['id'],
'username': user['username']
}))
def should_get_deco():
data = redis_get(GET_DECO, None)
if data:
redis.set(GET_DECO, 'None')
if data == 'None':
return False
return True
def set_forced_app_request(app_name, params):
# from apps.fap import Fap
if SchedulerState.get_forced_app():
return False
redis.set(SchedulerState.KEY_FORCED_APP_REQUEST, json.dumps({'name': app_name, 'params': params}))
return True
def get_data():
data = redis_get(KEY_WS_SEND, None)
if data:
redis.set(KEY_WS_SEND, None)
if data == 'None':
return None
return data
def pop_user_app_queue(queue=None):
if not queue:
queue = SchedulerState.get_user_app_queue()
if not queue:
return
p = queue.pop(0)
redis.set(SchedulerState.KEY_USERS_Q, json.dumps(queue))
return p
def set_sundown(day, at):
table = json.loads(redis.get(SchedulerState.KEY_DAY_TABLE))
table[day][SchedulerState.KEY_ON_TIME] = day + 'T' + at + ':00'
dumped = json.dumps(table)
with open(SchedulerState.CITY, 'w') as f:
f.write(dumped)
redis.set(SchedulerState.KEY_DAY_TABLE, dumped)
def send_pixels(pixels):
print_flush(
"###############################################################################"
)
print_flush("Send : [pixels={0}]".format(pixels))
print_flush(
"###############################################################################"
)
redis.set(PIXELS, json.dumps(pixels))
def send_data(code, message, username='', userid=''):
redis.set(
KEY_WS_SEND,
json.dumps({
'code': code,
'message': message,
'username': username,
'userid': userid
}))
def send_esp_state(esp_state):
print_flush(
"###############################################################################"
)
print_flush("Send : [esp_state = {0}]".format(esp_state))
print_flush(
"###############################################################################"
)
redis.set(ADDR, json.dumps(esp_state))
def send_pos_unk(pos_unknown):
print_flush(
"###############################################################################"
)
print_flush("Send : [pos_unknown={0}]".format(pos_unknown))
print_flush(
"###############################################################################"
)
redis.set(POS_UNK, json.dumps(pos_unknown))
def remove_user_position(user):
queue = SchedulerState.get_user_queue()
userid = user['userid']
for u in list(queue):
if u['userid'] == userid:
queue.remove(u)
redis.set(SchedulerState.KEY_USERS_Q, json.dumps(queue))
return True
return False
def send_ama_model(ama_model):
print_flush(
"###############################################################################"
)
print_flush("Send : [matrix type = {0}]".format(ama_model))
print_flush(
"###############################################################################"
)
redis.set(AMA, json.dumps({'ama': ama_model}))
def send_deco(deconnected_pixels):
print_flush(
"###############################################################################"
)
print_flush(
"Send : [pixels_deconnected={0}]".format(deconnected_pixels))
print_flush(
"###############################################################################"
)
redis.set(DECO, json.dumps(deconnected_pixels))
def get_user_position(user):
queue = SchedulerState.get_user_queue()
i = 1
userid = user['userid']
for u in queue:
if u['userid'] == userid:
u['last_alive'] = time.time()
redis.set(SchedulerState.KEY_USERS_Q, json.dumps(queue))
return i
i += 1
return -1
def get_day_table():
session = session_factory()
dates = session.query(SunriseSunset).all()
sunset = {}
for date in dates:
sunset[date.date] = {
"sunset": date.sunset,
"sunrise": date.sunrise
}
redis.set(SchedulerState.KEY_DAY_TABLE, json.dumps(sunset))
session.close()
def __init__(self):
clear_all_task()
redis.set(SchedulerState.KEY_USERS_Q, '[]')
redis.set(SchedulerState.KEY_FORCED_APP, False)
self.frontage = Frontage()
self.current_app_state = None
self.queue = None
self.count = 0
self.apps = OrderedDict([(app, globals()[app]('', '')) for app in get_app_names()])
SchedulerState.set_registered_apps(self.apps)
def __init__(self):
clear_all_task()
redis.set(SchedulerState.KEY_USERS_Q, '[]')
redis.set(SchedulerState.KEY_FORCED_APP, 'False')
Websock.set_grantUser({'id': "turnoff", 'username': "******"})
self.frontage = Frontage(SchedulerState.get_rows(),
SchedulerState.get_cols())
self.current_app_state = None
self.queue = None
self.count = 0
self.apps = OrderedDict([(app, globals()[app]('', ''))
for app in get_app_names()])
SchedulerState.set_registered_apps(self.apps)
def get_next_default_app():
apps = SchedulerState.get_default_scheduled_apps()
num_apps = len(apps)
if num_apps == 0:
return None
index = int(redis_get(SchedulerState.KEY_DEFAULT_APP_CURRENT_INDEX, 0))
index = (index + 1) % num_apps
redis.set(SchedulerState.KEY_DEFAULT_APP_CURRENT_INDEX, index)
try:
app = apps[index]
except IndexError:
return None
else:
return app
def send_data(code, message, username='', userid=''):
print_flush(
"###############################################################################"
)
print_flush(
"Send : [code={0}] [message={1}] [username={2}] [userid={3}]".
format(code, message, username, userid))
print_flush(
"###############################################################################"
)
redis.set(
KEY_WS_SEND,
json.dumps({
'code': code,
'message': message,
'username': username,
'userid': userid
}))
def set_expire(value=True):
redis.set(SchedulerState.KEY_NOTICE_EXPIRE, value)
def set_expire_soon(value=True):
redis.set(SchedulerState.KEY_NOTICE_EXPIRE_SOON, value)
def set_current_app(app_struct):
redis.set(
SchedulerState.KEY_CURRENT_RUNNING_APP,
json.dumps(app_struct))
def clear_user_app_queue():
redis.set(SchedulerState.KEY_USERS_Q, '[]')
def set_event_lock(val):
redis.set(SchedulerState.KEY_EVENT_LOCK, val)
def set_app_started_at():
redis.set(
SchedulerState.KEY_APP_STARTED_AT,
datetime.datetime.now().isoformat())
def stop_app_request(user):
# Store the user who initiated the request
redis.set(SchedulerState.KEY_STOP_APP_REQUEST, json.dumps(user))
