coursemology-evaluator 0.1.6 → 0.1.7

data/lib/coursemology/evaluator/client.rb

@@ -1,84 +1,84 @@
-# frozen_string_literal: true
-class Coursemology::Evaluator::Client
-  def self.initialize(host, api_user_email, api_token)
-    Coursemology::Evaluator::Models::Base.base_url = host
-    Coursemology::Evaluator::Models::Base.api_user_email = api_user_email
-    Coursemology::Evaluator::Models::Base.api_token = api_token
-
-    Coursemology::Evaluator::Models::Base.initialize
-  end
-
-  # @param [Boolean] one_shot If the client should only fire one request.
-  def initialize(one_shot = false)
-    @terminate = one_shot
-  end
-
-  def run
-    Signal.trap('SIGTERM', method(:on_sig_term))
-    loop(&method(:client_loop))
-  end
-
-  private
-
-  # Performs one iteration of the client loop.
-  def client_loop
-    evaluations = allocate_evaluations
-    if evaluations && !evaluations.empty?
-      on_allocate(evaluations)
-    else
-      raise StopIteration if @terminate
-
-      # :nocov:
-      # This sleep might not be triggered in the specs, because interruptions to the thread is
-      # nondeterministically run by the OS scheduler.
-      sleep(Coursemology::Evaluator.config.poll_interval)
-      # :nocov:
-    end
-
-    raise StopIteration if @terminate
-  end
-
-  # Requests evaluations from the server.
-  #
-  # @return [Array<Coursemology::Evaluator::Models::ProgrammingEvaluation>] The evaluations
-  #   retrieved from the server.
-  def allocate_evaluations
-    ActiveSupport::Notifications.instrument('allocate.client.evaluator.coursemology') do
-      languages = Coursemology::Polyglot::Language.concrete_languages.map(&:display_name)
-      Coursemology::Evaluator::Models::ProgrammingEvaluation.allocate(language: languages)
-    end
-  rescue Flexirest::HTTPUnauthorisedClientException => e
-    ActiveSupport::Notifications.publish('allocate_fail.client.evaluator.coursemology', e: e)
-    nil
-  end
-
-  # The callback for handling an array of allocated evaluations.
-  #
-  # @param [Array<Coursemology::Evaluator::Models::ProgrammingEvaluation>] evaluations The
-  #   evaluations retrieved from the server.
-  def on_allocate(evaluations)
-    evaluations.each do |evaluation|
-      on_evaluation(evaluation)
-    end
-  end
-
-  # The callback for handling an evaluation.
-  #
-  # @param [Coursemology::Evaluator::Models::ProgrammingEvaluation] evaluation The evaluation
-  #   retrieved from the server.
-  def on_evaluation(evaluation)
-    ActiveSupport::Notifications.instrument('evaluate.client.evaluator.coursemology',
-                                            evaluation: evaluation) do
-      evaluation.evaluate
-    end
-
-    ActiveSupport::Notifications.instrument('save.client.evaluator.coursemology') do
-      evaluation.save
-    end
-  end
-
-  # The callback for handling SIGTERM sent to the process.
-  def on_sig_term
-    @terminate = true
-  end
-end
+# frozen_string_literal: true
+class Coursemology::Evaluator::Client
+  def self.initialize(host, api_user_email, api_token)
+    Coursemology::Evaluator::Models::Base.base_url = host
+    Coursemology::Evaluator::Models::Base.api_user_email = api_user_email
+    Coursemology::Evaluator::Models::Base.api_token = api_token
+
+    Coursemology::Evaluator::Models::Base.initialize
+  end
+
+  # @param [Boolean] one_shot If the client should only fire one request.
+  def initialize(one_shot = false)
+    @terminate = one_shot
+  end
+
+  def run
+    Signal.trap('SIGTERM', method(:on_sig_term))
+    loop(&method(:client_loop))
+  end
+
+  private
+
+  # Performs one iteration of the client loop.
+  def client_loop
+    evaluations = allocate_evaluations
+    if evaluations && !evaluations.empty?
+      on_allocate(evaluations)
+    else
+      raise StopIteration if @terminate
+
+      # :nocov:
+      # This sleep might not be triggered in the specs, because interruptions to the thread is
+      # nondeterministically run by the OS scheduler.
+      sleep(Coursemology::Evaluator.config.poll_interval)
+      # :nocov:
+    end
+
+    raise StopIteration if @terminate
+  end
+
+  # Requests evaluations from the server.
+  #
+  # @return [Array<Coursemology::Evaluator::Models::ProgrammingEvaluation>] The evaluations
+  #   retrieved from the server.
+  def allocate_evaluations
+    ActiveSupport::Notifications.instrument('allocate.client.evaluator.coursemology') do
+      languages = Coursemology::Polyglot::Language.concrete_languages.map(&:display_name)
+      Coursemology::Evaluator::Models::ProgrammingEvaluation.allocate(language: languages)
+    end
+  rescue Flexirest::HTTPUnauthorisedClientException => e
+    ActiveSupport::Notifications.publish('allocate_fail.client.evaluator.coursemology', e: e)
+    nil
+  end
+
+  # The callback for handling an array of allocated evaluations.
+  #
+  # @param [Array<Coursemology::Evaluator::Models::ProgrammingEvaluation>] evaluations The
+  #   evaluations retrieved from the server.
+  def on_allocate(evaluations)
+    evaluations.each do |evaluation|
+      on_evaluation(evaluation)
+    end
+  end
+
+  # The callback for handling an evaluation.
+  #
+  # @param [Coursemology::Evaluator::Models::ProgrammingEvaluation] evaluation The evaluation
+  #   retrieved from the server.
+  def on_evaluation(evaluation)
+    ActiveSupport::Notifications.instrument('evaluate.client.evaluator.coursemology',
+                                            evaluation: evaluation) do
+      evaluation.evaluate
+    end
+
+    ActiveSupport::Notifications.instrument('save.client.evaluator.coursemology') do
+      evaluation.save
+    end
+  end
+
+  # The callback for handling SIGTERM sent to the process.
+  def on_sig_term
+    @terminate = true
+  end
+end

data/lib/coursemology/evaluator/docker_container.rb

@@ -1,79 +1,79 @@
-# frozen_string_literal: true
-class Coursemology::Evaluator::DockerContainer < Docker::Container
-  class << self
-    def create(image, argv: nil)
-      pull_image(image)
-
-      ActiveSupport::Notifications.instrument('create.docker.evaluator.coursemology',
-                                              image: image) do |payload|
-        options = { 'Image' => image }
-        options['Cmd'] = argv if argv && !argv.empty?
-
-        payload[:container] = super(options)
-      end
-    end
-
-    private
-
-    # Pulls the given image from Docker Hub.
-    #
-    # This caches images for the specified time, because the overhead for querying
-    # for images is quite high.
-    #
-    # @param [String] image The image to pull.
-    def pull_image(image)
-      ActiveSupport::Notifications.instrument('pull.docker.evaluator.coursemology',
-                                              image: image) do |payload|
-        cached([:image, image], expires_in: Coursemology::Evaluator.config.image_lifetime) do
-          Docker::Image.create('fromImage' => image)
-          payload[:cached] = false
-        end
-      end
-    end
-
-    # Cache the result of the given block using the key given.
-    #
-    # @param [Array, String, Symbol] key The key to use. This will be expanded with
-    #   +ActiveSupport::Cache.expand_cache_key+.
-    # @param [Hash] options The options to use. These are the same as
-    #   +ActiveSupport::Cache::Store#fetch+.
-    def cached(key, options = {}, &proc)
-      key = ActiveSupport::Cache.expand_cache_key(key, name.underscore)
-      Coursemology::Evaluator.cache.fetch(key, options, &proc)
-    end
-  end
-
-  # Waits for the container to exit the Running state.
-  #
-  # This will time out for long running operations, so keep retrying until we return.
-  #
-  # @param [Fixnum|nil] time The amount of time to wait.
-  # @return [Fixnum] The exit code of the container.
-  def wait(time = nil)
-    container_state = info
-    while container_state.fetch('State', {}).fetch('Running', true)
-      super
-      refresh!
-      container_state = info
-    end
-
-    container_state['State']['ExitCode']
-  rescue Docker::Error::TimeoutError
-    retry
-  end
-
-  # Gets the exit code of the container.
-  #
-  # @return [Fixnum] The exit code of the container, if +wait+ was called before.
-  # @return [nil] If the container is still running, or +wait+ was not called.
-  def exit_code
-    info.fetch('State', {})['ExitCode']
-  end
-
-  def delete
-    ActiveSupport::Notifications.instrument('destroy.docker.evaluator.coursemology',
-                                            container: id) do
-      super
-    end
-  end
-end
+# frozen_string_literal: true
+class Coursemology::Evaluator::DockerContainer < Docker::Container
+  class << self
+    def create(image, argv: nil)
+      pull_image(image)
+
+      ActiveSupport::Notifications.instrument('create.docker.evaluator.coursemology',
+                                              image: image) do |payload|
+        options = { 'Image' => image }
+        options['Cmd'] = argv if argv && !argv.empty?
+
+        payload[:container] = super(options)
+      end
+    end
+
+    private
+
+    # Pulls the given image from Docker Hub.
+    #
+    # This caches images for the specified time, because the overhead for querying
+    # for images is quite high.
+    #
+    # @param [String] image The image to pull.
+    def pull_image(image)
+      ActiveSupport::Notifications.instrument('pull.docker.evaluator.coursemology',
+                                              image: image) do |payload|
+        cached([:image, image], expires_in: Coursemology::Evaluator.config.image_lifetime) do
+          Docker::Image.create('fromImage' => image)
+          payload[:cached] = false
+        end
+      end
+    end
+
+    # Cache the result of the given block using the key given.
+    #
+    # @param [Array, String, Symbol] key The key to use. This will be expanded with
+    #   +ActiveSupport::Cache.expand_cache_key+.
+    # @param [Hash] options The options to use. These are the same as
+    #   +ActiveSupport::Cache::Store#fetch+.
+    def cached(key, options = {}, &proc)
+      key = ActiveSupport::Cache.expand_cache_key(key, name.underscore)
+      Coursemology::Evaluator.cache.fetch(key, options, &proc)
+    end
+  end
+
+  # Waits for the container to exit the Running state.
+  #
+  # This will time out for long running operations, so keep retrying until we return.
+  #
+  # @param [Fixnum|nil] time The amount of time to wait.
+  # @return [Fixnum] The exit code of the container.
+  def wait(time = nil)
+    container_state = info
+    while container_state.fetch('State', {}).fetch('Running', true)
+      super
+      refresh!
+      container_state = info
+    end
+
+    container_state['State']['ExitCode']
+  rescue Docker::Error::TimeoutError
+    retry
+  end
+
+  # Gets the exit code of the container.
+  #
+  # @return [Fixnum] The exit code of the container, if +wait+ was called before.
+  # @return [nil] If the container is still running, or +wait+ was not called.
+  def exit_code
+    info.fetch('State', {})['ExitCode']
+  end
+
+  def delete
+    ActiveSupport::Notifications.instrument('destroy.docker.evaluator.coursemology',
+                                            container: id) do
+      super
+    end
+  end
+end

data/lib/coursemology/evaluator/logging.rb

@@ -1,12 +1,12 @@
-# frozen_string_literal: true
-module Coursemology::Evaluator::Logging
-  extend ActiveSupport::Autoload
-
-  eager_autoload do
-    autoload :ClientLogSubscriber
-    autoload :DockerLogSubscriber
-  end
-end
-
-# Define +Rails+ to trick ActiveSupport into logging to our logger.
-Rails = Coursemology::Evaluator
+# frozen_string_literal: true
+module Coursemology::Evaluator::Logging
+  extend ActiveSupport::Autoload
+
+  eager_autoload do
+    autoload :ClientLogSubscriber
+    autoload :DockerLogSubscriber
+  end
+end
+
+# Define +Rails+ to trick ActiveSupport into logging to our logger.
+Rails = Coursemology::Evaluator

data/lib/coursemology/evaluator/logging/client_log_subscriber.rb

@@ -1,25 +1,25 @@
-# frozen_string_literal: true
-class Coursemology::Evaluator::Logging::ClientLogSubscriber < ActiveSupport::LogSubscriber
-  def publish(name, *args)
-    send(name.split('.').first, *args)
-  end
-
-  def allocate(event)
-    info color("Client: Allocate (#{event.duration.round(1)}ms)", MAGENTA)
-  end
-
-  def allocate_fail(e:)
-    error color("Client: Allocate failed: #{e.message}", RED)
-  end
-
-  def evaluate(event)
-    info "#{color("Client: Evaluate (#{event.duration.round(1)}ms)", CYAN)} "\
-      "#{event.payload[:evaluation].language.class.display_name}"
-  end
-
-  def save(event)
-    info color("Client: Save (#{event.duration.round(1)}ms)", GREEN)
-  end
-end
-
-Coursemology::Evaluator::Logging::ClientLogSubscriber.attach_to(:'client.evaluator.coursemology')
+# frozen_string_literal: true
+class Coursemology::Evaluator::Logging::ClientLogSubscriber < ActiveSupport::LogSubscriber
+  def publish(name, *args)
+    send(name.split('.').first, *args)
+  end
+
+  def allocate(event)
+    info color("Client: Allocate (#{event.duration.round(1)}ms)", MAGENTA)
+  end
+
+  def allocate_fail(e:)
+    error color("Client: Allocate failed: #{e.message}", RED)
+  end
+
+  def evaluate(event)
+    info "#{color("Client: Evaluate (#{event.duration.round(1)}ms)", CYAN)} "\
+      "#{event.payload[:evaluation].language.class.display_name}"
+  end
+
+  def save(event)
+    info color("Client: Save (#{event.duration.round(1)}ms)", GREEN)
+  end
+end
+
+Coursemology::Evaluator::Logging::ClientLogSubscriber.attach_to(:'client.evaluator.coursemology')

data/lib/coursemology/evaluator/logging/docker_log_subscriber.rb

@@ -1,21 +1,21 @@
-# frozen_string_literal: true
-class Coursemology::Evaluator::Logging::DockerLogSubscriber < ActiveSupport::LogSubscriber
-  def pull(event)
-    cached = event.payload[:cached].nil? || event.payload[:cached] ? 'Cached ' : ''
-    header_colour = cached ? GREEN : YELLOW
-    info "#{color("#{cached}Docker Pull (#{event.duration.round(1)}ms)", header_colour)} "\
-      "#{event.payload[:image]}"
-  end
-
-  def create(event)
-    info "#{color("Docker Create (#{event.duration.round(1)}ms)", MAGENTA)} "\
-      "#{event.payload[:image]} => #{event.payload[:container].id}"
-  end
-
-  def destroy(event)
-    info "#{color("Docker Destroy (#{event.duration.round(1)}ms)", CYAN)} "\
-      "#{event.payload[:container]}"
-  end
-end
-
-Coursemology::Evaluator::Logging::DockerLogSubscriber.attach_to(:'docker.evaluator.coursemology')
+# frozen_string_literal: true
+class Coursemology::Evaluator::Logging::DockerLogSubscriber < ActiveSupport::LogSubscriber
+  def pull(event)
+    cached = event.payload[:cached].nil? || event.payload[:cached] ? 'Cached ' : ''
+    header_colour = cached ? GREEN : YELLOW
+    info "#{color("#{cached}Docker Pull (#{event.duration.round(1)}ms)", header_colour)} "\
+      "#{event.payload[:image]}"
+  end
+
+  def create(event)
+    info "#{color("Docker Create (#{event.duration.round(1)}ms)", MAGENTA)} "\
+      "#{event.payload[:image]} => #{event.payload[:container].id}"
+  end
+
+  def destroy(event)
+    info "#{color("Docker Destroy (#{event.duration.round(1)}ms)", CYAN)} "\
+      "#{event.payload[:container]}"
+  end
+end
+
+Coursemology::Evaluator::Logging::DockerLogSubscriber.attach_to(:'docker.evaluator.coursemology')

data/lib/coursemology/evaluator/models.rb

@@ -1,7 +1,7 @@
-# frozen_string_literal: true
-module Coursemology::Evaluator::Models
-  extend ActiveSupport::Autoload
-
-  autoload :Base
-  autoload :ProgrammingEvaluation
-end
+# frozen_string_literal: true
+module Coursemology::Evaluator::Models
+  extend ActiveSupport::Autoload
+
+  autoload :Base
+  autoload :ProgrammingEvaluation
+end