forked from Screenly/Anthias
-
Notifications
You must be signed in to change notification settings - Fork 0
/
server.py
executable file
·395 lines (304 loc) · 10.7 KB
/
server.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
#!/usr/bin/env python
# -*- coding: utf8 -*-
__author__ = "WireLoad Inc"
__copyright__ = "Copyright 2012-2016, WireLoad Inc"
__license__ = "Dual License: GPLv2 and Commercial License"
from datetime import datetime, timedelta
from functools import wraps
from hurry.filesize import size
from os import path, makedirs, statvfs, mkdir, getenv
from sh import git
import sh
from subprocess import check_output
import json
import os
import traceback
import uuid
from bottle import route, run, request, error, static_file, response, auth_basic
from bottle import HTTPResponse
from bottlehaml import haml_template
from lib import db
from lib import queries
from lib import assets_helper
from lib import diagnostics
from lib.utils import json_dump
from lib.utils import get_node_ip
from lib.utils import validate_url
from lib.utils import url_fails
from lib.utils import get_video_duration
from dateutil import parser as date_parser
from settings import settings, DEFAULTS, CONFIGURABLE_SETTINGS
from werkzeug.wrappers import Request
################################
# Utilities
################################
def make_json_response(obj):
response.content_type = "application/json"
return json_dump(obj)
def api_error(error):
response.content_type = "application/json"
response.status = 500
return json_dump({'error': error})
def is_up_to_date():
"""
Determine if there is any update available.
Used in conjunction with check_update() in viewer.py.
"""
sha_file = os.path.join(settings.get_configdir(), 'latest_screenly_sha')
# Until this has been created by viewer.py,
# let's just assume we're up to date.
if not os.path.exists(sha_file):
return True
try:
with open(sha_file, 'r') as f:
latest_sha = f.read().strip()
except:
latest_sha = None
if latest_sha:
branch_sha = git('rev-parse', 'HEAD')
return branch_sha.stdout.strip() == latest_sha
# If we weren't able to verify with remote side,
# we'll set up_to_date to true in order to hide
# the 'update available' message
else:
return True
def template(template_name, **context):
"""Screenly template response generator. Shares the
same function signature as Bottle's template() method
but also injects some global context."""
# Add global contexts
context['up_to_date'] = is_up_to_date()
context['default_duration'] = settings['default_duration']
context['use_24_hour_clock'] = settings['use_24_hour_clock']
context['template_settings'] = {
'imports': ['from lib.utils import template_handle_unicode'],
'default_filters': ['template_handle_unicode'],
}
return haml_template(template_name, **context)
################################
# Model
################################
def check(user, passwd):
return settings.check_user(user, passwd)
################################
# API
################################
def prepare_asset(request):
req = Request(request.environ)
data = None
data = json.loads(req.form['model']) if 'model' in req.form else req.form
def get(key):
val = data.get(key, '')
if isinstance(val, unicode):
return val.strip()
elif isinstance(val, basestring):
return val.strip().decode('utf-8')
else:
return val
if all([get('name'),
get('uri') or req.files.get('file_upload'),
get('mimetype')]):
asset = {
'name': get('name'),
'mimetype': get('mimetype'),
'asset_id': get('asset_id'),
'is_enabled': get('is_enabled'),
'nocache': get('nocache'),
}
uri = get('uri') or False
if not asset['asset_id']:
asset['asset_id'] = uuid.uuid4().hex
try:
file_upload = req.files.get('file_upload')
filename = file_upload.filename
except AttributeError:
file_upload = None
filename = None
if filename and 'web' in asset['mimetype']:
raise Exception("Invalid combination. Can't upload a web resource.")
if uri and filename:
raise Exception("Invalid combination. Can't select both URI and a file.")
if uri and not uri.startswith('/'):
if not validate_url(uri):
raise Exception("Invalid URL. Failed to add asset.")
else:
asset['uri'] = uri
else:
asset['uri'] = uri
if filename:
asset['uri'] = path.join(settings['assetdir'], asset['asset_id'])
file_upload.save(asset['uri'])
if "video" in asset['mimetype']:
video_duration = get_video_duration(asset['uri'])
if video_duration:
asset['duration'] = int(video_duration.total_seconds())
else:
asset['duration'] = 'N/A'
else:
# Crashes if it's not an int. We want that.
asset['duration'] = int(get('duration'))
# parse date via python-dateutil and remove timezone info
if get('start_date'):
asset['start_date'] = date_parser.parse(get('start_date')).replace(tzinfo=None)
else:
asset['start_date'] = ""
if get('end_date'):
asset['end_date'] = date_parser.parse(get('end_date')).replace(tzinfo=None)
else:
asset['end_date'] = ""
if not asset['asset_id']:
raise Exception
if not asset['uri']:
raise Exception
return asset
else:
raise Exception("Not enough information provided. Please specify 'name', 'uri', and 'mimetype'.")
@route('/api/assets', method="GET")
@auth_basic(check)
def api_assets():
assets = assets_helper.read(db_conn)
return make_json_response(assets)
# api view decorator. handles errors
def api(view):
@wraps(view)
def api_view(*args, **kwargs):
try:
return make_json_response(view(*args, **kwargs))
except HTTPResponse:
raise
except Exception as e:
traceback.print_exc()
return api_error(unicode(e))
return api_view
@route('/api/assets', method="POST")
@auth_basic(check)
@api
def add_asset():
asset = prepare_asset(request)
if url_fails(asset['uri']):
raise Exception("Could not retrieve file. Check the asset URL.")
return assets_helper.create(db_conn, asset)
@route('/api/assets/:asset_id', method="GET")
@auth_basic(check)
@api
def edit_asset(asset_id):
return assets_helper.read(db_conn, asset_id)
@route('/api/assets/:asset_id', method=["PUT", "POST"])
@auth_basic(check)
@api
def edit_asset(asset_id):
return assets_helper.update(db_conn, asset_id, prepare_asset(request))
@route('/api/assets/:asset_id', method="DELETE")
@auth_basic(check)
@api
def remove_asset(asset_id):
asset = assets_helper.read(db_conn, asset_id)
try:
if asset['uri'].startswith(settings['assetdir']):
os.remove(asset['uri'])
except OSError:
pass
assets_helper.delete(db_conn, asset_id)
response.status = 204 # return an OK with no content
@route('/api/assets/order', method="POST")
@auth_basic(check)
@api
def playlist_order():
assets_helper.save_ordering(db_conn, request.POST.get('ids', '').split(','))
################################
# Views
################################
@route('/')
@auth_basic(check)
def viewIndex():
return template('index')
@route('/settings', method=["GET", "POST"])
@auth_basic(check)
def settings_page():
context = {'flash': None}
if request.method == "POST":
for field, default in CONFIGURABLE_SETTINGS.items():
value = request.POST.get(field, default)
if isinstance(default, bool):
value = value == 'on'
settings[field] = value
try:
settings.save()
sh.sudo('systemctl', 'kill', '--signal=SIGUSR2', 'screenly-viewer.service')
context['flash'] = {'class': "success", 'message': "Settings were successfully saved."}
except IOError as e:
context['flash'] = {'class': "error", 'message': e}
except sh.ErrorReturnCode_1 as e:
context['flash'] = {'class': "error", 'message': e}
else:
settings.load()
for field, default in DEFAULTS['viewer'].items():
context[field] = settings[field]
return template('settings', **context)
@route('/system_info')
@auth_basic(check)
def system_info():
viewlog = check_output(['sudo', 'systemctl', 'status', 'screenly-viewer.service', '-n', '20']).split('\n')
loadavg = diagnostics.get_load_avg()['15 min']
display_info = diagnostics.get_monitor_status()
# Calculate disk space
slash = statvfs("/")
free_space = size(slash.f_bavail * slash.f_frsize)
# Get uptime
uptime_in_seconds = diagnostics.get_uptime()
system_uptime = timedelta(seconds=uptime_in_seconds)
return template(
'system_info',
viewlog=viewlog,
loadavg=loadavg,
free_space=free_space,
uptime=system_uptime,
display_info=display_info
)
@route('/splash_page')
def splash_page():
my_ip = get_node_ip()
if my_ip:
ip_lookup = True
# If we bind on 127.0.0.1, `enable_ssl.sh` has most likely been
# executed and we should access over SSL.
if settings.get_listen_ip() == '127.0.0.1':
url = 'https://{}'.format(my_ip)
else:
url = "http://{}:{}".format(my_ip, settings.get_listen_port())
else:
ip_lookup = False
url = "Unable to look up your installation's IP address."
return template('splash_page', ip_lookup=ip_lookup, url=url)
@error(403)
def mistake403(code):
return 'The parameter you passed has the wrong format!'
@error(404)
def mistake404(code):
return 'Sorry, this page does not exist!'
################################
# Static
################################
@route('/static/:path#.+#', name='static')
def static(path):
return static_file(path, root='static')
if __name__ == "__main__":
# Make sure the asset folder exist. If not, create it
if not path.isdir(settings['assetdir']):
mkdir(settings['assetdir'])
# Create config dir if it doesn't exist
if not path.isdir(settings.get_configdir()):
makedirs(settings.get_configdir())
with db.conn(settings['database']) as conn:
global db_conn
db_conn = conn
with db.cursor(db_conn) as c:
c.execute(queries.exists_table)
if c.fetchone() is None:
c.execute(assets_helper.create_assets_table)
run(
host=settings.get_listen_ip(),
port=settings.get_listen_port(),
server='gunicorn',
timeout=240,
)