mumukit 0.3.0 → 2.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 96ca9d2847fa9cf5412c483dd9e7900b0c093549
-  data.tar.gz: 07439f192678d0ac52cf8009ed2249a6955bcc88
+  metadata.gz: 3f8afb7358f144c2e25c356c70f0061144ff2f04
+  data.tar.gz: d41e834b6c92fea4897c87d46f5d3303983a8209
 SHA512:
-  metadata.gz: 7fb5c9cde7fb1e16ff83232a7b43dd11511c6ab504b07a1a72984bf36055d872fc48b51435ec027ff81a0626b5324595620cb626e776f4c2c9f17ac29bf6993d
-  data.tar.gz: f5eb3c788559964d2ac32ed272631ee3305cf17b293435d25499be1259b64122cc67c5812e76f426f2f9712cb27b3b3aa1ad8f52856d2b874a3e2fb7d8645c51
+  metadata.gz: b4830f051f2f4ede2c1a76f05306974ea4c8d05947b2a0b8e4d2f7c3b3ad5dbb32207045accb30c10815bd90dd2e6ccc8a9e982a947e48c0fd17df2582b67e63
+  data.tar.gz: d1c908995f05aeab6cd7bc6a47c4614a20ec242cb3e49fee4497060c03ebc87a3636578652a3fb3716016543861405db1c7a4cd94335772303ed5cc30a06d30a

data/bin/limit

@@ -0,0 +1,10 @@
+#!/bin/bash
+
+SIZE=$1
+shift
+TIME=$1
+shift
+COMMAND=$@
+
+ulimit -Sv $(expr 1024 \* $SIZE) -St $TIME
+sh -c "$COMMAND"

data/lib/locales/en.yml

@@ -0,0 +1,4 @@
+en:
+  mumukit:
+    memory_exceeded: Memory limit exceeded. Is your program trying to allocate to much memory?
+    time_exceeded:  Execution time limit of %{limit}s exceeded. Is your program performing an infinite loop or recursion?

data/lib/locales/es.yml

@@ -0,0 +1,4 @@
+es:
+  mumukit:
+    memory_exceeded: Limite de memoria excedido. ¿Tu programa está alocando demasiada memoria?
+    time_exceeded:  Limite de tiempo de ejecución de %{limit}s excedido. ¿Tu programa tiene recursión o bucle infinito?

data/lib/mumukit/defaults/default_expectations_hook.rb

@@ -0,0 +1,9 @@
+class Mumukit::Defaults::ExpectationsHook < Mumukit::Hook
+  def compile(request)
+    request
+  end
+
+  def run!(request)
+    []
+  end
+end

data/lib/mumukit/defaults/default_feedback_hook.rb

@@ -0,0 +1,5 @@
+class Mumukit::Defaults::FeedbackHook < Mumukit::Hook
+  def run!(request, results)
+    ''
+  end
+end

data/lib/mumukit/defaults/default_metadata_hook.rb

@@ -0,0 +1,5 @@
+class Mumukit::Defaults::MetadataHook < Mumukit::Hook
+  def metadata
+    {}
+  end
+end

data/lib/mumukit/defaults/default_query_hook.rb

@@ -0,0 +1,9 @@
+class Mumukit::Defaults::QueryHook < Mumukit::Hook
+  def compile(request)
+    request
+  end
+
+  def run!(request)
+    ['unimplemented', :aborted]
+  end
+end

data/lib/mumukit/defaults/default_test_hook.rb

@@ -0,0 +1,9 @@
+class Mumukit::Defaults::TestHook < Mumukit::Hook
+  def compile(request)
+    request
+  end
+
+  def run!(compilation)
+    ['unimplemented', :aborted]
+  end
+end

data/lib/mumukit/defaults/default_validation_hook.rb

@@ -0,0 +1,4 @@
+class Mumukit::Defaults::ValidationHook < Mumukit::Hook
+  def validate!(request)
+  end
+end

data/lib/mumukit/defaults.rb

@@ -0,0 +1,11 @@
+module Mumukit
+  module Defaults
+  end
+end
+
+require_relative './defaults/default_expectations_hook'
+require_relative './defaults/default_query_hook'
+require_relative './defaults/default_feedback_hook'
+require_relative './defaults/default_validation_hook'
+require_relative './defaults/default_test_hook'
+require_relative './defaults/default_metadata_hook'

data/lib/mumukit/env.rb

@@ -0,0 +1,11 @@
+module Mumukit
+  module Env
+    def self.env
+      Thread.current[:mumukit_env]
+    end
+
+    def self.env=(env)
+      Thread.current[:mumukit_env] = env
+    end
+  end
+end

data/lib/mumukit/hook.rb

@@ -0,0 +1,30 @@
+class Mumukit::Hook
+  attr_reader :config
+
+  include Mumukit::WithContentType
+
+  def initialize(config=nil)
+    @config = (config||{}).with_indifferent_access
+  end
+
+  def t(*args)
+    I18n.t(*args)
+  end
+
+  def method_missing(name, *args, &block)
+    super unless should_forward_to_config?(args, name, &block)
+    @config[name]
+  end
+
+  def env
+    Mumukit::Env.env
+  end
+
+  def logger
+    env['rack.logger']
+  end
+
+  def should_forward_to_config?(args, name)
+    args.length == 0 && !block_given? && @config[name]
+  end
+end

data/lib/mumukit/isolated_environment.rb

@@ -0,0 +1,51 @@
+require 'docker'
+require 'pathname'
+
+module Mumukit
+  class IsolatedEnvironment
+
+    attr_accessor :container
+
+    def configure!(*files)
+
+      filenames = files.map { |it| File.absolute_path(it.path) }
+      dirnames = filenames.map { |it| Pathname.new(it).dirname }
+
+      binds = dirnames.map { |it| "#{it}:#{it}" }
+      volumes = Hash[[dirnames.map { |it| [it, {}] }]]
+
+      command = yield(*filenames).split
+
+      self.container = Docker::Container.create(
+          'Image' => Mumukit.config.docker_image,
+          'Cmd' => command,
+          'NetworkDisabled' => true,
+          'HostConfig' => {
+              'Binds' => binds},
+          'Volumes' => volumes)
+    end
+
+    def run!
+      container.start
+      container.wait(Mumukit.config.command_time_limit)
+
+      exit = container.json['State']['ExitCode']
+      out = container.streaming_logs(stdout: true, stderr: true)
+
+      if exit == 0
+        [out, :passed]
+      else
+        [out, :failed]
+      end
+    rescue Docker::Error::TimeoutError => e
+      [I18n.t('mumukit.time_exceeded', limit: Mumukit.config.command_time_limit), :aborted]
+    end
+
+    def destroy!
+      if container
+        container.stop
+        container.delete
+      end
+    end
+  end
+end

data/lib/mumukit/metatest/checker.rb

@@ -0,0 +1,34 @@
+module Mumukit::Metatest
+  class Checker
+    def check(value, example)
+      example[:postconditions].each { |key, arg| check_assertion key, value, arg, example }
+      [example[:name], :passed, render_success_output(value)]
+    rescue => e
+      [example[:name], :failed, render_error_output(value, e.message)]
+    end
+
+    def render_success_output(value)
+      nil
+    end
+
+    def render_error_output(value, error)
+      error
+    end
+
+    def check_assertion(key, value, arg, example)
+      send "check_#{key}", value, arg
+    end
+
+    def fail(message)
+      raise Mumukit::Metatest::Failed, message
+    end
+
+    def abort(message)
+      raise Mumukit::Metatest::Aborted, message
+    end
+
+    def error(message)
+      raise Mumukit::Metatest::Errored, message
+    end
+  end
+end

data/lib/mumukit/metatest/errors.rb

@@ -0,0 +1,10 @@
+module Mumukit::Metatest
+  class Aborted < StandardError
+  end
+
+  class Errored < StandardError
+  end
+
+  class Failed < StandardError
+  end
+end

data/lib/mumukit/metatest/framework.rb

@@ -0,0 +1,20 @@
+module Mumukit::Metatest
+  class Framework
+    def initialize(options={})
+      @runner = options[:runner]
+      @checker = options[:checker]
+    end
+
+    def test(compilation, examples)
+      [examples.map { |it| example(compilation, it) }]
+    rescue Aborted => e
+      [e.message, :aborted]
+    rescue Errored => e
+      [e.message, :errored]
+    end
+
+    def example(compilation, example)
+      @checker.check(@runner.run(compilation, example), example)
+    end
+  end
+end

data/lib/mumukit/metatest/identity_runner.rb

@@ -0,0 +1,7 @@
+module Mumukit::Metatest
+  class IdentityRunner
+    def run(it, _example)
+      it
+    end
+  end
+end

data/lib/mumukit/metatest.rb

@@ -0,0 +1,7 @@
+module Mumukit::Metatest
+end
+
+require_relative './metatest/errors'
+require_relative './metatest/checker'
+require_relative './metatest/framework'
+require_relative './metatest/identity_runner'

data/lib/mumukit/request_validation_error.rb

@@ -0,0 +1,4 @@
+module Mumukit
+  class RequestValidationError < StandardError
+  end
+end

data/lib/mumukit/runner.rb

@@ -0,0 +1,33 @@
+class Mumukit::Runner
+  attr_reader :name, :runtime
+
+  def initialize(name)
+    @name = name
+  end
+
+  def configure
+    @config ||= self.class.default_config.clone
+    yield @config
+  end
+
+  def configure_runtime(config)
+    @runtime = Mumukit::Runtime.new(config)
+  end
+
+  def config
+    @config or raise 'This runner has not being configured yet'
+  end
+
+  def prefix
+    name.camelize
+  end
+
+  def self.default_config
+    @default_config
+  end
+
+  def self.configure_defaults
+    @default_config ||= OpenStruct.new
+    yield @default_config
+  end
+end

data/lib/mumukit/runtime/info.rb

@@ -0,0 +1,30 @@
+module Mumukit::RuntimeInfo
+  def info
+    {
+        name: Mumukit.runner_name,
+        version: (File.read('version') rescue 'master'),
+        escualo_base_version: ENV['ESCUALO_BASE_VERSION'],
+        escualo_service_version: ENV['ESCUALO_SERVICE_VERSION'],
+        mumukit_version: Mumukit::VERSION,
+        output_content_type: Mumukit.config.content_type,
+        comment_type: Mumukit.config.comment_type,
+        features: {
+            query: query_hook?,
+            expectations: expectations_hook?,
+            feedback: feedback_hook?,
+            secure: validation_hook?,
+            stateful: Mumukit.config.stateful,
+            preprocessor: Mumukit.config.preprocessor_enabled,
+
+            sandboxed: any_hook_include?([:test, :query], Mumukit::Templates::WithIsolatedEnvironment),
+            structured: any_hook_include?([:test], Mumukit::Templates::WithStructuredResults) || Mumukit.config.structured
+        }
+    }
+  end
+
+  private
+
+  def any_hook_include?(hooks, mixin)
+    hooks.any? { |it| hook_includes?(it, mixin) }
+  end
+end

data/lib/mumukit/runtime/runtime.rb

@@ -0,0 +1,35 @@
+class Mumukit::Runtime
+  include Mumukit::RuntimeShortcuts
+  include Mumukit::RuntimeInfo
+
+  def initialize(config)
+    @config = config
+    @hook_classes = {}
+  end
+
+  def hook_defined?(hook_name)
+    hook_name.to_default_mumukit_hook_class rescue raise "Wrong hook #{hook_name}"
+
+    Kernel.const_defined? hook_name.to_mumukit_hook_class_name
+  end
+
+  def hook_includes?(hook_name, mixin)
+    hook_class(hook_name).included_modules.include?(mixin)
+  end
+
+  def new_hook(hook_name)
+    hook_class(hook_name).new(@config)
+  end
+
+  private
+
+  def hook_class(hook_name)
+    @hook_classes[hook_name] ||=
+        if hook_defined? hook_name
+          hook_name.to_mumukit_hook_class
+        else
+          hook_name.to_default_mumukit_hook_class
+        end
+  end
+end
+

data/lib/mumukit/runtime/shortcuts.rb

@@ -0,0 +1,12 @@
+module Mumukit::RuntimeShortcuts
+  def method_missing(name, *args, &block)
+    n = name.to_s
+    if n =~ /(.*)_hook\?/
+      hook_defined? $1.to_sym
+    elsif  n =~ /(.*)_hook/
+      new_hook $1.to_sym
+    else
+      super
+    end
+  end
+end

data/lib/mumukit/runtime/symbol.rb

@@ -0,0 +1,17 @@
+class Symbol
+  def to_mumukit_hook_class_name
+    "#{Mumukit.prefix}#{to_simple_mumukit_hook_class_name}"
+  end
+
+  def to_simple_mumukit_hook_class_name
+    "#{to_s.camelize.to_sym}Hook"
+  end
+
+  def to_mumukit_hook_class
+    Kernel.const_get to_mumukit_hook_class_name
+  end
+
+  def to_default_mumukit_hook_class
+    Kernel.const_get "Mumukit::Defaults::#{to_simple_mumukit_hook_class_name}"
+  end
+end

data/lib/mumukit/runtime.rb

@@ -0,0 +1,4 @@
+require_relative './runtime/symbol'
+require_relative './runtime/info'
+require_relative './runtime/shortcuts'
+require_relative './runtime/runtime'

data/lib/mumukit/server/app.rb

@@ -0,0 +1,71 @@
+require 'sinatra/base'
+require 'yaml'
+require 'json'
+
+
+class Mumukit::Server::App < Sinatra::Base
+  configure do
+    set :mumuki_url, 'http://mumuki.io'
+    set :show_exceptions, :after_handler
+    enable :logging
+  end
+
+  configure :development do
+    set :config_filename, 'config/development.yml'
+  end
+
+  configure :production do
+    set :config_filename, 'config/production.yml'
+  end
+
+  runtime_config = YAML.load_file(settings.config_filename) rescue nil
+
+  Mumukit.configure_runtime(runtime_config)
+
+  set :server, Mumukit::Server::TestServer.new
+
+  before do
+    content_type 'application/json'
+  end
+
+  before do
+    Mumukit::Env.env = env
+    server.start_request!(parse_request)
+  end
+
+  helpers do
+    def server
+      settings.server
+    end
+
+    def parse_request
+      @parsed_request ||= server.parse_request(request)
+    end
+  end
+
+  get '/info' do
+    JSON.generate(server.info(request.url))
+  end
+
+  post '/test' do
+    JSON.generate(server.test!(parse_request))
+  end
+
+  post '/query' do
+    JSON.generate(server.query!(parse_request))
+  end
+
+  get '/*' do
+    redirect settings.mumuki_url
+  end
+
+  error StandardError do
+    content_type :json
+    status 200
+
+    message = Mumukit::ContentType::Plain.format_exception env['sinatra.error']
+    logger.error "Unhandled error #{message}"
+
+    {status: :errored, exit: message}.to_json
+  end
+end

data/lib/mumukit/server/response_builder.rb

@@ -0,0 +1,62 @@
+class Mumukit::Server::ResponseBuilder
+
+  def add_test_results(r)
+    @response = base_response(r)
+  end
+
+  def add_query_results(r)
+    @response = unstructured_base_response(r)
+  end
+
+  def add_expectation_results(r)
+    @response.merge!(expectationResults: r) if r.present?
+  end
+
+
+  def add_feedback(f)
+    @response.merge!(feedback: f) if f.present?
+  end
+
+  def build
+    @response
+  end
+
+  def self.build(&block)
+    builder = new
+    builder.instance_eval(&block)
+    builder.build
+  end
+
+  private
+
+  def base_response(test_results)
+    if structured_test_result?(test_results)
+      structured_base_response(test_results)
+    elsif unstructured_test_result?(test_results)
+      unstructured_base_response(test_results)
+    else
+      raise "Invalid test results format: #{test_results}. You must either return [results_array] or [results_string, status]"
+    end
+  end
+
+  def structured_test_result?(test_results)
+    test_results.size == 1 && test_results[0].is_a?(Array)
+  end
+
+  def unstructured_test_result?(test_results)
+    test_results.size == 2 && test_results[0].is_a?(String)
+  end
+
+  def structured_base_response(test_results)
+    {testResults: test_results[0].map { |title, status, result|
+      {title: title,
+       status: status,
+       result: result} }}
+  end
+
+  def unstructured_base_response(test_results)
+    {exit: test_results[1],
+     out: test_results[0]}
+  end
+
+end

data/lib/mumukit/server/test_server.rb

@@ -0,0 +1,118 @@
+require 'yaml'
+require 'ostruct'
+
+class Mumukit::Server::TestServer
+
+  include Mumukit::WithContentType
+
+  def runtime
+    Mumukit.runtime
+  end
+
+  def info(url)
+    runtime.info.merge(runtime.metadata_hook.metadata).merge(url: url)
+  end
+
+  def start_request!(_request)
+  end
+
+  def parse_request(sinatra_request)
+    OpenStruct.new parse_request_headers(sinatra_request).merge(parse_request_body(sinatra_request))
+  end
+
+  def parse_request_headers(sinatra_request)
+    {}
+  end
+
+  def parse_request_body(sinatra_request)
+    JSON.parse(sinatra_request.body.read).tap do |it|
+      I18n.locale = it['locale'] || :en
+    end rescue {}
+  end
+
+  def test!(request)
+    respond_to(request) do |r|
+      test_results = run_tests! r
+      expectation_results = run_expectations! r
+
+      results = OpenStruct.new(test_results: test_results,
+                               expectation_results: expectation_results)
+
+      feedback = run_feedback! r, results
+
+      Mumukit::Server::ResponseBuilder.build do
+        add_test_results(test_results)
+        add_expectation_results(expectation_results)
+        add_feedback(feedback)
+      end
+    end
+  end
+
+  def query!(request)
+    respond_to(request) do |r|
+      results = run_query!(r)
+      Mumukit::Server::ResponseBuilder.build do
+        add_query_results(results)
+      end
+    end
+  end
+
+  def run_query!(request)
+    compile_and_run runtime.query_hook, request
+  end
+
+  def run_tests!(request)
+    return ['', :passed] if request.test.blank?
+
+    compile_and_run runtime.test_hook, request
+  end
+
+  def run_expectations!(request)
+    if request.expectations
+      compile_and_run runtime.expectations_hook, request
+    else
+      []
+    end
+  end
+
+  def run_feedback!(request, results)
+    runtime.feedback_hook.run!(request, results)
+  end
+
+  private
+
+  def compile_and_run(hook, request)
+    compilation = hook.compile(preprocess request)
+    hook.run!(compilation)
+  end
+
+  def preprocess(request)
+    if Mumukit.config.preprocessor_enabled
+      directives_pipeline.transform(request)
+    else
+      request
+    end
+  end
+
+  def directives_pipeline
+    @pipeline ||= Mumukit::Directives::Pipeline.new(
+        [Mumukit::Directives::Sections.new,
+         Mumukit::Directives::Interpolations.new('test'),
+         Mumukit::Directives::Interpolations.new('extra'),
+         Mumukit::Directives::Flags.new],
+        Mumukit.config.comment_type)
+  end
+
+  def validate_request!(request)
+    runtime.validation_hook.validate! request
+  end
+
+  def respond_to(request)
+    yield request.tap { |r| validate_request! r }
+  rescue Mumukit::RequestValidationError => e
+    {exit: :aborted, out: e.message}
+  rescue Exception => e
+    {exit: :errored, out: content_type.format_exception(e)}
+  end
+
+end