def __listen_console(job_id):
logger.debug('listen:console for %s', job_id)
token = get_token()
if not job_id:
logger.debug('job_id not set')
return flask_socketio.disconnect()
try:
uuid.UUID(job_id)
except:
logger.debug('job_id not a uuid')
return flask_socketio.disconnect()
conn = dbpool.get()
try:
if token['type'] not in ('project', 'project-token'):
logger.debug('only project token allowed')
return flask_socketio.disconnect()
project_id = token['project']['id']
build = conn.execute_one('''
SELECT id
FROM job
WHERE project_id = %s AND id = %s
''', [project_id, job_id])
if not build:
logger.debug('job does not belong to project')
return flask_socketio.disconnect()
finally:
dbpool.put(conn)
flask_socketio.join_room(job_id)
def __handle_event(event, socketio, client_manager):
job_id = event['job_id']
console_id = event['id']
if not client_manager.has_clients(job_id):
return
logger.info('start console %s', console_id)
conn = dbpool.get()
try:
r = conn.execute_one(
'''
SELECT output FROM console WHERE id = %s
''', [console_id])
logger.info('retrived console %s', console_id)
if not r:
return
r = r[0]
socketio.emit('notify:console', {
'data': r,
'job_id': job_id
},
room=job_id)
finally:
dbpool.put(conn)
logger.info('stop console %s', console_id)
def opa_push_all():
db = dbpool.get()
try:
opa_push_collaborator_data(db)
opa_push_project_data(db)
finally:
dbpool.put(db)
def handle(event):
db = dbpool.get()
try:
handle_job_update(db.conn, event)
except Exception as e:
logger.error(e)
finally:
dbpool.put(db)
def before_request():
g.db = dbpool.get()
def release_db():
db = getattr(g, 'db', None)
if not db:
return
dbpool.put(db)
g.db = None
g.release_db = release_db
def before_request():
def release_db():
db = getattr(g, 'db', None)
if not db:
return
dbpool.put(db)
g.db = None
g.release_db = release_db
g.db = dbpool.get()
g.token = normalize_token(get_token())
check_request_authorization()
def run(self):
# TODO: Delete storage objects: uploads, outputs
# TODO: Delete images from registry
while True:
db = dbpool.get()
try:
logger.info('Starting next GC run')
self._gc(db)
logger.info('Finished GC run')
logger.info('')
except Exception as e:
logger.exception(e)
finally:
dbpool.put(db)
time.sleep(3600)
def __listen_dashboard_console(job_id):
logger.debug('listen:console for %s', job_id)
if not job_id:
logger.debug('job_id not set')
return flask_socketio.disconnect()
try:
uuid.UUID(job_id)
except:
logger.debug('job_id not a uuid')
return flask_socketio.disconnect()
conn = dbpool.get()
try:
u = conn.execute_one_dict(
'''
SELECT p.public, j.project_id
FROM project p
INNER JOIN job j
ON j.project_id = p.id
AND j.id = %s
''', [job_id])
if not u:
logger.warn('job not found')
return flask_socketio.disconnect()
if not u['public']:
token = get_token()
if token['type'] == 'user':
user_id = token['user']['id']
collaborator = is_collaborator(user_id,
u['project_id'],
db=conn)
if not collaborator:
logger.warn('not a collaborator')
return flask_socketio.disconnect()
else:
logger.debug('only user token allowed')
return flask_socketio.disconnect()
finally:
dbpool.put(conn)
flask_socketio.join_room(job_id)
def __listen_jobs(project_id):
logger.debug('listen:jobs for %s', project_id)
if not project_id:
logger.debug('project_id not set')
return flask_socketio.disconnect()
try:
uuid.UUID(project_id)
except:
logger.debug('project_id not a uuid')
return flask_socketio.disconnect()
conn = dbpool.get()
try:
p = conn.execute_one_dict(
'''
SELECT public
FROM project
WHERE id = %s
''', [project_id])
if not p['public']:
token = get_token()
if token['type'] == 'user':
user_id = token['user']['id']
collaborator = is_collaborator(user_id,
project_id,
db=conn)
if not collaborator:
logger.warn('not a collaborator')
return flask_socketio.disconnect()
else:
logger.debug('only user token allowed')
return flask_socketio.disconnect()
finally:
dbpool.put(conn)
flask_socketio.join_room(project_id)
def __listen_dashboard_console(job_id):
logger.debug('listen:dashboard-console for %s', job_id)
if not job_id:
logger.debug('job_id not set')
return flask_socketio.disconnect()
try:
uuid.UUID(job_id)
except:
logger.debug('job_id not a uuid')
return flask_socketio.disconnect()
conn = dbpool.get()
try:
u = conn.execute_one_dict(
'''
SELECT p.public, j.project_id
FROM project p
INNER JOIN job j
ON j.project_id = p.id
AND j.id = %s
''', [job_id])
if not u:
logger.warn('job not found')
return flask_socketio.disconnect()
if not sio_is_authorized(
['listen:dashboard-console', u['project_id'], job_id]):
return flask_socketio.disconnect()
except:
logger.exception("Exception occured")
return flask_socketio.disconnect()
finally:
dbpool.put(conn)
flask_socketio.join_room(job_id)
def __listen_build(build_id):
logger.debug('listen:build for %s', build_id)
if not build_id:
logger.debug('build_id not set')
return flask_socketio.disconnect()
try:
uuid.UUID(build_id)
except:
logger.debug('build_id not a uuid')
return flask_socketio.disconnect()
if not sio_is_authorized(['listen:build', build_id]):
return flask_socketio.disconnect()
conn = dbpool.get()
try:
token = normalize_token(get_token())
project_id = token['project']['id']
build = conn.execute_one(
'''
SELECT id
FROM build
WHERE project_id = %s AND id = %s
''', [project_id, build_id])
if not build:
logger.debug('build does not belong to project')
return flask_socketio.disconnect()
except:
logger.exception("Exception occured")
return flask_socketio.disconnect()
finally:
dbpool.put(conn)
flask_socketio.join_room(build_id)
def sio_is_authorized(path):
g.db = dbpool.get()
try:
# Assemble Input Data for Open Policy Agent
opa_input = {
"input": {
"method": "WS",
"path": path,
"token": normalize_token(get_token())
}
}
authorized = opa_do_auth(opa_input)
if not authorized:
logger.warn("Unauthorized socket.io access attempt")
return False
return True
except RequestException as e:
logger.error(e)
return False
finally:
dbpool.put(g.db)
g.db = None
def __handle_event(event, socketio):
job_id = event['job_id']
db = dbpool.get()
try:
job = db.execute_one_dict(
'''
SELECT id, state, to_char(start_date, 'YYYY-MM-DD HH24:MI:SS') start_date, type, dockerfile,
to_char(end_date, 'YYYY-MM-DD HH24:MI:SS') end_date,
name, cpu, memory, dependencies, to_char(created_at, 'YYYY-MM-DD HH24:MI:SS') created_at, message,
project_id, build_id
FROM job
WHERE id = %s
''', [job_id])
if not job:
return
project_id = job['project_id']
build_id = job['build_id']
project = db.execute_one_dict(
'''
SELECT id, name, type
FROM project
WHERE id = %s
''', [project_id])
if not project:
return
build = db.execute_one_dict(
'''
SELECT id, build_number, restart_counter, commit_id
FROM build
WHERE id = %s
''', [build_id])
commit_id = build['commit_id']
commit = None
pr = None
if project['type'] in ('gerrit', 'github'):
commit = db.execute_one_dict(
'''
SELECT
c.id,
split_part(c.message, '\n', 1) as message,
c.author_name,
c.author_email,
c.author_username,
c.committer_name,
c.committer_email,
c.committer_username,
c.url,
c.branch,
c.pull_request_id
FROM commit c
WHERE c.id = %s
AND c.project_id = %s
''', [commit_id, project_id])
pull_request_id = commit['pull_request_id']
pr = db.execute_one_dict(
'''
SELECT title, url
FROM pull_request
WHERE id = %s
AND project_id = %s
''', [pull_request_id, project_id])
finally:
dbpool.put(db)
msg = {
'type': event['type'],
'data': {
'build': build,
'project': project,
'commit': commit,
'pull_request': pr,
'job': job
}
}
socketio.emit('notify:job', msg, room=build_id)
socketio.emit('notify:job', msg, room=project_id)
def before_request():
g.db = dbpool.get()
