Merge branch 'master' into user_exercise_feedback_backend

# Conflicts:
#	app/views/application/_navigation.html.slim

app/controllers/concerns/submission_scoring.rb

@@ -9,6 +9,14 @@ module SubmissionScoring
         assessment = assessor.assess(output)
         passed = ((assessment[:passed] == assessment[:count]) and (assessment[:score] > 0))
         testrun_output = passed ? nil : 'message: ' + output[:message].to_s + "\n stdout: " + output[:stdout].to_s + "\n stderr: " + output[:stderr].to_s
+        if !testrun_output.blank?
+          submission.exercise.execution_environment.error_templates.each do |template|
+            pattern = Regexp.new(template.signature).freeze
+            if pattern.match(testrun_output)
+              StructuredError.create_from_template(template, testrun_output)
+            end
+          end
+        end
         Testrun.new(submission: submission, cause: 'assess', file: file, passed: passed, output: testrun_output).save
         output.merge!(assessment)
         output.merge!(filename: file.name_with_extension, message: feedback_message(file, output[:score]), weight: file.weight)

app/controllers/error_template_attributes_controller.rb

@@ -0,0 +1,86 @@
+class ErrorTemplateAttributesController < ApplicationController
+  before_action :set_error_template_attribute, only: [:show, :edit, :update, :destroy]
+
+  def authorize!
+    authorize(@error_template_attributes || @error_template_attribute)
+  end
+  private :authorize!
+
+  # GET /error_template_attributes
+  # GET /error_template_attributes.json
+  def index
+    @error_template_attributes = ErrorTemplateAttribute.all.order('important DESC', :key, :id).paginate(page: params[:page])
+    authorize!
+  end
+
+  # GET /error_template_attributes/1
+  # GET /error_template_attributes/1.json
+  def show
+    authorize!
+  end
+
+  # GET /error_template_attributes/new
+  def new
+    @error_template_attribute = ErrorTemplateAttribute.new
+    authorize!
+  end
+
+  # GET /error_template_attributes/1/edit
+  def edit
+    authorize!
+  end
+
+  # POST /error_template_attributes
+  # POST /error_template_attributes.json
+  def create
+    @error_template_attribute = ErrorTemplateAttribute.new(error_template_attribute_params)
+    authorize!
+
+    respond_to do |format|
+      if @error_template_attribute.save
+        format.html { redirect_to @error_template_attribute, notice: 'Error template attribute was successfully created.' }
+        format.json { render :show, status: :created, location: @error_template_attribute }
+      else
+        format.html { render :new }
+        format.json { render json: @error_template_attribute.errors, status: :unprocessable_entity }
+      end
+    end
+  end
+
+  # PATCH/PUT /error_template_attributes/1
+  # PATCH/PUT /error_template_attributes/1.json
+  def update
+    authorize!
+    respond_to do |format|
+      if @error_template_attribute.update(error_template_attribute_params)
+        format.html { redirect_to @error_template_attribute, notice: 'Error template attribute was successfully updated.' }
+        format.json { render :show, status: :ok, location: @error_template_attribute }
+      else
+        format.html { render :edit }
+        format.json { render json: @error_template_attribute.errors, status: :unprocessable_entity }
+      end
+    end
+  end
+
+  # DELETE /error_template_attributes/1
+  # DELETE /error_template_attributes/1.json
+  def destroy
+    authorize!
+    @error_template_attribute.destroy
+    respond_to do |format|
+      format.html { redirect_to error_template_attributes_url, notice: 'Error template attribute was successfully destroyed.' }
+      format.json { head :no_content }
+    end
+  end
+
+  private
+    # Use callbacks to share common setup or constraints between actions.
+    def set_error_template_attribute
+      @error_template_attribute = ErrorTemplateAttribute.find(params[:id])
+    end
+
+    # Never trust parameters from the scary internet, only allow the white list through.
+    def error_template_attribute_params
+      params[:error_template_attribute].permit(:key, :description, :regex, :important)
+    end
+end

app/controllers/error_templates_controller.rb

@@ -0,0 +1,104 @@
+class ErrorTemplatesController < ApplicationController
+  before_action :set_error_template, only: [:show, :edit, :update, :destroy, :add_attribute, :remove_attribute]
+
+  def authorize!
+    authorize(@error_templates || @error_template)
+  end
+  private :authorize!
+
+  # GET /error_templates
+  # GET /error_templates.json
+  def index
+    @error_templates = ErrorTemplate.all.order(:execution_environment_id, :name).paginate(page: params[:page])
+    authorize!
+  end
+
+  # GET /error_templates/1
+  # GET /error_templates/1.json
+  def show
+    authorize!
+  end
+
+  # GET /error_templates/new
+  def new
+    @error_template = ErrorTemplate.new
+    authorize!
+  end
+
+  # GET /error_templates/1/edit
+  def edit
+    authorize!
+  end
+
+  # POST /error_templates
+  # POST /error_templates.json
+  def create
+    @error_template = ErrorTemplate.new(error_template_params)
+    authorize!
+
+    respond_to do |format|
+      if @error_template.save
+        format.html { redirect_to @error_template, notice: 'Error template was successfully created.' }
+        format.json { render :show, status: :created, location: @error_template }
+      else
+        format.html { render :new }
+        format.json { render json: @error_template.errors, status: :unprocessable_entity }
+      end
+    end
+  end
+
+  # PATCH/PUT /error_templates/1
+  # PATCH/PUT /error_templates/1.json
+  def update
+    authorize!
+    respond_to do |format|
+      if @error_template.update(error_template_params)
+        format.html { redirect_to @error_template, notice: 'Error template was successfully updated.' }
+        format.json { render :show, status: :ok, location: @error_template }
+      else
+        format.html { render :edit }
+        format.json { render json: @error_template.errors, status: :unprocessable_entity }
+      end
+    end
+  end
+
+  # DELETE /error_templates/1
+  # DELETE /error_templates/1.json
+  def destroy
+    authorize!
+    @error_template.destroy
+    respond_to do |format|
+      format.html { redirect_to error_templates_url, notice: 'Error template was successfully destroyed.' }
+      format.json { head :no_content }
+    end
+  end
+
+  def add_attribute
+    authorize!
+    @error_template.error_template_attributes << ErrorTemplateAttribute.find(params['error_template_attribute_id'])
+    respond_to do |format|
+      format.html { redirect_to @error_template }
+      format.json { head :no_content }
+    end
+  end
+
+  def remove_attribute
+    authorize!
+    @error_template.error_template_attributes.delete(ErrorTemplateAttribute.find(params['error_template_attribute_id']))
+    respond_to do |format|
+      format.html { redirect_to @error_template }
+      format.json { head :no_content }
+    end
+  end
+
+  private
+    # Use callbacks to share common setup or constraints between actions.
+    def set_error_template
+      @error_template = ErrorTemplate.find(params[:id])
+    end
+
+    # Never trust parameters from the scary internet, only allow the white list through.
+    def error_template_params
+      params[:error_template].permit(:name, :execution_environment_id, :signature, :description, :hint)
+    end
+end

app/controllers/submissions_controller.rb

@@ -6,7 +6,7 @@ class SubmissionsController < ApplicationController
   include SubmissionScoring
   include Tubesock::Hijack
 
-  before_action :set_submission, only: [:download, :download_file, :render_file, :run, :score, :show, :statistics, :stop, :test]
+  before_action :set_submission, only: [:download, :download_file, :render_file, :run, :score, :extract_errors, :show, :statistics, :stop, :test]
   before_action :set_docker_client, only: [:run, :test]
   before_action :set_files, only: [:download, :download_file, :render_file, :show]
   before_action :set_file, only: [:download_file, :render_file]
@@ -191,6 +191,9 @@ class SubmissionsController < ApplicationController
   end
 
   def kill_socket(tubesock)
+    # search for errors and save them as StructuredError (for scoring runs see submission_scoring.rb)
+    extract_errors
+
     # save the output of this "run" as a "testrun" (scoring runs are saved in submission_scoring.rb)
     save_run_output
 
@@ -199,6 +202,17 @@ class SubmissionsController < ApplicationController
     tubesock.close
   end
 
+  def extract_errors
+    if !@message_buffer.blank?
+      @submission.exercise.execution_environment.error_templates.each do |template|
+        pattern = Regexp.new(template.signature).freeze
+        if pattern.match(@message_buffer)
+          StructuredError.create_from_template(template, @message_buffer)
+        end
+      end
+    end
+  end
+
   def handle_message(message, tubesock, container)
     @run_output ||= ""
     # Handle special commands first