def handle_message(self, body, message):
print('Received message: {0!r}'.format(body))
submission_id = body['args'][0]
test_f, sol_f, lang = get_test_and_solution(submission_id)
docker = Docker()
test = open('/app/evaluator_tests/' + test_f)
solution = open('/app/evaluator_submissions/' + sol_f)
out = docker.run(lang, test, solution)
metadata = json.loads(out)
try:
if metadata['score']:
status = 'P'
else:
status = 'F'
score = metadata['score']
except KeyError:
status = 'F'
score = 0
if update_submission(submission_id, score, out, status):
message.ack()
class Modulator:
def __init__(self):
self.config = Config()
self.util = Utility()
self.docker = Docker()
def _load_configuration_dict(self, node):
return self.util._load_json(node)
def _get_players(self):
socketio.emit('players', {'players': self.config.players})
def _set_parameters(self, nc):
d = {}
for n in range(int(nc['node_counts'])):
d[n] = self._load_configuration_dict(n)
socketio.emit('parms', d)
def _filter(self, k):
def walk(k):
with Config().tsfiles.open("r") as f:
ts = [
line.rstrip('\n') for line in f
if k['name'].lower() in line.lower()
]
ts.sort()
return ts
socketio.emit('report_filter', {'node': k['node'], 'ts': walk(k)})
def _watch(self):
cnts = self.config.nodecounts
docker_state = ['0' for i in range(cnts)]
state = [path(f"modulator.playing.{b}").exists() for b in range(cnts)]
for b in range(cnts):
d = self._load_configuration_dict(str(b))
docker_state[b] = d['docker']
socketio.emit('report_watch', {
'state': state,
'docker_state': docker_state
})
for i, b in enumerate(state):
if b:
player = f"player{i+1}"
socketio.emit(
f"{player}_name",
{player: path(f"modulator.playing.{i}").read_text()})
def _get_mediainfo(self, ts):
cmd = ("mediainfo --Output=\"General;%OverallBitRate%\""
f" \"{ts['filename']}\"")
rate = str(self.util._execute(cmd)).strip()
if len(rate) > 0:
res = int(rate)
if res > 0:
if res > (4 * 10**7):
res = 23052768
socketio.emit('report_mediainfo', {'playrate': res})
def _docker_state(self, d):
n = self.util._load_json(d['node'])
n.update({'docker': d['docker']})
self.util._dump_json(d['node'], n)
def _set_overtime(self, ot):
n = self.util._load_json(ot['node'])
n.update({'ot': ot['ot']})
self.util._dump_json(ot['node'], n)
def _play(self, n):
n = json.loads(n)
slot, docker, rf = n["slot"], n["docker"], n['rf']
cmd = (f"{self.config.modhome}/ModulatorConsole "
f"dvb-t "
f"-r {self.config.ipaddr} "
f"--slot {slot} "
f"--playback play "
f"--mode loop "
f"--file \"{n['file']}\" "
f"--bw {n['bw']} "
f"--const {n['const']} "
f"--coderate {n['coderate']} "
f"--guard {n['guard']} "
f"--tx {n['tx']} "
f"--cell-id {n['cellid']} "
f"--playrate {n['playrate']} "
f"--rf {int(rf) * 10**6} ")
if int(docker):
print("docker is enabled")
result = self.docker.run(int(n['slot']))
print('docker result:', result)
socketio.emit('report_docker_start', {
'status': result,
'slot': slot
})
else:
res = self.util._execute(cmd)
path(f"modulator.playing.{slot}").write_text(n["player"])
self.util._dump_json(slot, n)
socketio.emit(
'response',
{'status': ['PLAYING',
int(n['slot']), n['player'], n['docker']]})
def _stop(self, n):
n = json.loads(n)
slot = n["slot"]
cmd = (f"{self.config.modhome}/ModulatorConsole "
f"dvb-t "
f"-r {self.config.ipaddr} "
f"--slot {n['slot']} "
f"--playback stop ")
d = self.util._load_json(slot)
docker = d['docker']
if int(docker):
result = self.docker.stop(n)
print('docker result:', result)
d.update({'docker': '0'})
self.util._dump_json(slot, d)
socketio.emit('report_docker_stop', {
'status': result,
'slot': slot
})
res = self.util._execute(cmd)
path(f"modulator.playing.{n['slot']}").unlink()
socketio.emit('response',
{'status': ['STOPPED', int(n['slot']), '', 0]})
import os
from docker import Docker
from docker import Repl
docker = Docker('logging-example')
repl = Repl(docker)
try:
volume_name = 'logging-example'
docker.volumeCreate(['--driver', 'local', volume_name])
docker.run([
'--name', 'plath', '-d', '--mount',
f'type=volume,src={volume_name},dst=/data',
'dockerinaction/ch4_writer_a'
])
some_data = docker.run([
'--rm', '--mount', f'type=volume,src={volume_name},dst=/data',
'alpine:latest', 'head', '/data/logA'
])
print(f'Did we get data?\n{some_data}')
log_a_path = docker.volumeInspect(
['--format', '"{{json .Mountpoint}}"', volume_name])
print(f'Logging file source path:\n{log_a_path}')
repl.cmdloop('Logging...')
except Exception as err:
print(f'Error running logging example\n{err}')
docker.cleanup()
import os
from docker import Docker
from docker import Repl
config_src = os.path.abspath('resources\\ch3_nginx.conf')
config_dest = '/etc/nginx/conf.d/default.conf'
log_src = os.path.abspath('resources\\ch3_nginx.log')
log_dest = '/var/log/nginx/custom.host.access.log'
docker = Docker('dia-nginx')
repl = Repl(docker)
try:
docker.run([
'-d', '--name', 'diaweb', '--mount',
f'type=bind,src={config_src},dst={config_dest},readonly=true',
'--mount', f'type=bind,src={log_src},dst={log_dest}', '-p', '80:80',
'nginx:latest'
])
repl.cmdloop('Running nginx...')
except Exception as err:
print('Error running nginx:\n{0}'.format(err))
docker.cleanup()
