Server: target and runner management

Author: rleh

hwut_server/api/__init__.py

@@ -1,11 +1,15 @@
 from hwut_server.api.about import mod as mod_about
 from hwut_server.api.execute import mod as mod_execute
+from hwut_server.api.runners import mod as mod_runners
+from hwut_server.api.targets import mod as mod_targets
 
 
 def register(app):
     """
     :param flask.Flask app: a Flask app
     """
 
-    app.register_blueprint(mod_execute)
     app.register_blueprint(mod_about)
+    app.register_blueprint(mod_execute)
+    app.register_blueprint(mod_runners)
+    app.register_blueprint(mod_targets)

hwut_server/api/runners.py

@@ -0,0 +1,91 @@
+from flask import Blueprint, jsonify, request, abort, redirect
+from sqlalchemy.orm.exc import MultipleResultsFound, NoResultFound
+
+from hwut_server.models import Boards, Microcontrollers
+from hwut_server.models.runners import Runners
+from hwut_server.decorators import requires_authentication, requires_superuser
+from hwut_server.utils import dict_list_extended_if_authentication
+from hwut_server.database import db
+
+mod = Blueprint('runners', __name__, url_prefix='/runners')
+
+
+@mod.route('/*', methods=['GET'], defaults={'filter_type': 'any', 'filter1': None, 'filter2': None})
+@mod.route('/<string:filter_type>/<string:filter1>', methods=['GET'], defaults={'filter2': None})
+@mod.route('/<string:filter_type>/<string:filter1>/<string:filter2>', methods=['GET'])
+def runners_list(filter_type, filter1, filter2):
+    runner_list = list()
+    if filter_type == 'any':
+        runner_list = Runners.query.all()
+    elif (filter_type == 'by_board') and (filter1 is not None) and (filter2 is None):
+        runner_list = Runners.query.filter(Runners.target_board == filter1).all()
+    elif (filter_type == 'by_microcontroller') and (filter1 is not None) and (filter2 is None):
+        runner_list = Runners.query.filter(Runners.target_microcontroller == filter1).all()
+    elif (filter_type == 'by_board_and_microcontroller') and (filter1 is not None) and (filter2 is not None):
+        runner_list = Runners.query.filter(Runners.target_microcontroller == filter1) \
+            .filter(Runners.target_board == filter1).all()
+    else:
+        abort(400)  # Bad request
+    return jsonify(dict_list_extended_if_authentication(request, runner_list))
+
+
+@mod.route('/<int:id>', methods=['GET'])
+def targets_boards_get(id):
+    try:
+        runner = Runners.query.filter(Runners.id == id).one()
+        if True:  # FIXME: if user is owner os superuser
+            return jsonify(runner.to_dict_long())
+        else:
+            return jsonify(runner.to_dict_short())
+    except:
+        abort(404)
+
+
+@mod.route('/add', methods=['PUT'])
+@requires_authentication
+def runner_create():
+    if (request.args.get('board') is None) or (request.args.get('microcontroller') is None):
+        abort(400)
+
+    # FIXME: get user
+    user = request.authorization.username
+
+    try:
+        board = Boards.query.filter(Boards.name == request.args.get('board')).one()
+    except MultipleResultsFound:
+        abort(500, 'board "{}" exists multiple time in database'.format(request.args.get('board')))
+        return
+    except NoResultFound:
+        abort(410, 'board "{}" does not exist'.format(request.args.get('board')))
+        return
+    try:
+        microcontroller = Microcontrollers.query\
+            .filter(Microcontrollers.name == request.args.get('microcontroller')).one()
+    except MultipleResultsFound:
+        abort(500, 'microcontroller exists multiple time in database')
+        return
+    except NoResultFound:
+        abort(410, 'microcontroller does not exist')
+        return
+    try:
+        runner = Runners(user, board.name, microcontroller.name)
+        db.session.add(runner)
+        db.session.commit()
+    except:
+        abort(500, 'unable to create runner')
+        return
+    return redirect(mod.url_prefix + '/' + str(runner.id), 201)
+
+
+@mod.route('/<int:id>', methods=['DELETE'])
+@requires_superuser
+def runner_delete(id):
+    try:
+        runner = Runners.query.filter(Runners.id == id).one()
+        db.session.delete(runner)
+        db.session.commit()
+        return '', 204
+    except MultipleResultsFound:
+        abort(500, 'runner exists multiple time in database')
+    except NoResultFound:
+        abort(410, 'runner does not exist')

hwut_server/api/targets.py

@@ -0,0 +1,94 @@
+from flask import Blueprint, jsonify, request, abort, redirect
+from sqlalchemy.orm.exc import MultipleResultsFound, NoResultFound
+
+from hwut_server.models.targets import Boards, Microcontrollers
+from hwut_server.decorators import requires_authentication, requires_superuser
+from hwut_server.utils import dict_list_extended_if_authentication
+from hwut_server.database import db
+
+mod = Blueprint('targets', __name__, url_prefix='/targets')
+
+
+@mod.route('/boards', methods=['GET'])
+def targets_boards():
+    return jsonify(dict_list_extended_if_authentication(request, Boards.query.all()))
+
+
+@mod.route('/boards/<string:board_name>', methods=['GET'])
+def targets_boards_get(board_name):
+    try:
+        return jsonify(Boards.query.filter(Boards.name == board_name).one().to_dict_long())
+    except:
+        abort(404)
+
+
+@mod.route('/boards/<string:board_name>', methods=['PUT'])
+@requires_authentication
+def targets_boards_create(board_name):
+    board = Boards(board_name)
+    manufacturer = request.args.get('manufacturer')
+    if manufacturer:
+        board.manufacturer = manufacturer
+    try:
+        db.session.add(board)
+        db.session.commit()
+    except:
+        return redirect(request.path, 303)
+    return targets_boards_get(board_name), 201
+
+
+@mod.route('/boards/<string:board_name>', methods=['DELETE'])
+@requires_superuser
+def targets_boards_delete(board_name):
+    try:
+        board = Boards.query.filter(Boards.name == board_name).one()
+        db.session.delete(board)
+        db.session.commit()
+        return '', 204
+    except MultipleResultsFound:
+        abort(500, 'board exists multiple time in database')
+    except NoResultFound:
+        abort(410, 'board does not exist')
+
+
+@mod.route('/microcontrollers', methods=['GET'])
+def targets_microcontrollers():
+    return jsonify(dict_list_extended_if_authentication(request, Microcontrollers.query.all()))
+
+
+@mod.route('/microcontrollers/<string:microcontroller_name>', methods=['GET'])
+def targets_microcontrollers_get(microcontroller_name):
+    try:
+        return jsonify(Microcontrollers.query.filter(Microcontrollers.name == microcontroller_name)
+                       .one().to_dict_long())
+    except:
+        abort(404)
+
+
+@mod.route('/microcontrollers/<string:microcontroller_name>', methods=['PUT'])
+@requires_authentication
+def targets_microcontrollers_create(microcontroller_name):
+    microcontroller = Microcontrollers(microcontroller_name)
+    manufacturer = request.args.get('manufacturer')
+    if manufacturer:
+        microcontroller.manufacturer = manufacturer
+    try:
+        db.session.add(microcontroller)
+        db.session.commit()
+    except:
+        return redirect(request.path, 303)
+    return targets_microcontrollers_get(microcontroller_name), 201
+
+
+@mod.route('/microcontrollers/<string:microcontroller_name>', methods=['DELETE'])
+@requires_superuser
+def targets_microcontrollers_delete(microcontroller_name):
+    try:
+        microcontroller = Microcontrollers.query.filter(Microcontrollers.name == microcontroller_name).one()
+        db.session.delete(microcontroller)
+        db.session.commit()
+        return '', 204
+    except MultipleResultsFound:
+        abort(500, 'microcontroller exists multiple time in database')
+    except NoResultFound:
+        abort(410, 'microcontroller does not exist')

hwut_server/models/__init__.py

@@ -1,2 +1,5 @@
 from .jobs import Jobs
+from .runners import Runners
+from .targets import Boards
+from .targets import Microcontrollers
 from .users import Users

hwut_server/models/jobs.py

@@ -1,16 +1,26 @@
-from sqlalchemy.orm import relationship
+from enum import Enum
 
 from hwut_server.database import db
 
 
+class JobStatus(Enum):
+    WAITING = 10
+    RUNNING = 20
+    FINISHED = 30
+
+
 class Jobs(db.Model):
     __tablename__ = 'jobs'
     id = db.Column('id', db.BigInteger, db.Sequence('jobs_id_seq'), primary_key=True, index=True, unique=True,
                    autoincrement=True)
     created = db.Column(db.TIMESTAMP, nullable=False)
     uploaded = db.Column(db.TIMESTAMP, nullable=False)
+    status = db.Column(db.Enum(JobStatus))
     name = db.Column(db.Text)
-    #executable_file = relationship("ExecutableFile", cascade="all,delete", backref="parent")
+    filename_executable = db.Column(db.Text, nullable=False)
+    filename_log = db.Column(db.Text)
+    filename_other = db.Column(db.Text)
+    owner = db.Column(db.Text, db.ForeignKey('users.name'), nullable=False)
 
     def __init__(self, created, uploaded, name):
         # 'id' auto increment

hwut_server/models/runners.py

@@ -0,0 +1,64 @@
+from hwut_server.database import db
+from secrets import token_urlsafe
+from datetime import datetime
+
+
+class Runners(db.Model):
+    __tablename__ = 'runners'
+    id = db.Column('id', db.BigInteger, db.Sequence('runners_id_seq'), primary_key=True, index=True, unique=True,
+                   autoincrement=True)
+    token = db.Column(db.Text)
+    created = db.Column(db.DateTime, nullable=False, default=datetime.now())
+    enabled = db.Column(db.Boolean, nullable=False)
+    last_seen = db.Column(db.DateTime)
+    ping_counter = db.Column(db.BigInteger, nullable=False)
+    job_counter = db.Column(db.BigInteger, nullable=False)
+    busy = db.Column(db.Boolean, nullable=False)
+    owner = db.Column(db.Text, db.ForeignKey('users.name'), nullable=False)
+    target_board = db.Column(db.Text, db.ForeignKey('boards.name'), nullable=False)
+    target_microcontroller = db.Column(db.Text, db.ForeignKey('microcontrollers.name'), nullable=False)
+
+    def __init__(self, owner, board, microcontroller, enabled=True):
+        self.token = token_urlsafe(32)
+        self.enabled = enabled
+        self.last_seen = None
+        self.ping_counter = 0
+        self.job_counter = 0
+        self.busy = False
+        self.owner = owner
+        self.target_board = board
+        self.target_microcontroller = microcontroller
+
+    def __repr__(self):
+        return '<runner %d>' % self.id
+
+    def to_dict_short(self):
+        return {
+            'id': self.id,
+        }
+
+    def to_dict_long(self):
+        return {
+            'id': self.id,
+            'token': self.token,
+            'created': self.created,
+            'enabled': self.enabled,
+            'last_seen': self.last_seen,
+            'ping_counter': self.ping_counter,
+            'job_counter': self.job_counter,
+            'busy': self.busy,
+        }
+
+    def ping(self):
+        self.ping_counter = Runners.ping_counter + 1
+        self.last_seen = datetime.now()
+        # FIXME: Maybe do a commit here?
+
+    def acquire(self):
+        self.busy = True
+        self.job_counter = Runners.job_counter + 1
+        # FIXME: Maybe do a commit here?
+
+    def release(self):
+        self.busy = False
+        # FIXME: Maybe do a commit here?

hwut_server/models/targets.py

@@ -0,0 +1,53 @@
+from hwut_server.database import db
+
+from sqlalchemy.orm import relationship
+
+
+class Boards(db.Model):
+    __tablename__ = 'boards'
+    name = db.Column(db.Text, primary_key=True, unique=True, nullable=False)
+    manufacturer = db.Column(db.Text)
+    runners = relationship("Runners")
+
+    def __init__(self, name):
+        self.name = name
+
+    def __repr__(self):
+        return '<board %s>' % self.name
+
+    def to_dict_short(self):
+        return {
+            'name': self.name,
+        }
+
+    def to_dict_long(self):
+        return {
+            'name': self.name,
+            'manufacturer': self.manufacturer,
+            'runners': self.runners,
+        }
+
+
+class Microcontrollers(db.Model):
+    __tablename__ = 'microcontrollers'
+    name = db.Column(db.Text, primary_key=True, unique=True, nullable=False)
+    manufacturer = db.Column(db.Text)
+    runners = relationship("Runners")
+
+    def __init__(self, name):
+        self.name = name
+
+    def __repr__(self):
+        return '<microcontroller %s>' % self.name
+
+    def to_dict_short(self):
+        return {
+            'name': self.name,
+        }
+
+    def to_dict_long(self):
+        return {
+            'name': self.name,
+            'manufacturer': self.manufacturer,
+            'runners': self.runners,
+        }

hwut_server/models/users.py

@@ -1,4 +1,5 @@
 from passlib.hash import sha512_crypt
+from sqlalchemy.orm import relationship
 
 from hwut_server.database import db
 
@@ -9,11 +10,12 @@ class Users(db.Model):
     password_hash = db.Column(db.Text, nullable=False)
     rights = db.Column(db.BigInteger, nullable=False)
     enabled = db.Column(db.Boolean, nullable=False)
+    runners = relationship("Runners")
+    jobs = relationship("Jobs")
 
-    def __init__(self, name, password, rights, enabled):
-        hash = sha512_crypt.encrypt(password)
+    def __init__(self, name, password, rights, enabled=True):
         self.name = name
-        self.password_hash = hash
+        self.password_hash = sha512_crypt.encrypt(password)
         self.rights = rights
         self.enabled = enabled
 

hwut_server/utils.py

@@ -0,0 +1,11 @@
+from hwut_server.decorators import check_authentication, authenticate
+
+
+def dict_list_extended_if_authentication(r, l):
+    if r.args.get('extended') == '1':
+        if not r.authorization or \
+                not check_authentication(r.authorization.username, r.authorization.password):
+            return authenticate()
+        return [b.to_dict_long() for b in l]
+    else:
+        return [b.to_dict_short() for b in l]