cuboid 0.0.0 → 0.0.1alpha

data/lib/cuboid/rest/server.rb

@@ -0,0 +1,165 @@
+require 'puma'
+require 'puma/minissl'
+require 'sinatra/base'
+require 'sinatra/contrib'
+
+module Cuboid
+module Rest
+
+class Server < Sinatra::Base
+    lib = Options.paths.lib
+    require lib + 'processes'
+    require lib + 'rest/server/instance_helpers'
+
+    Dir.glob( "#{File.dirname( __FILE__ )}/server/routes/*.rb" ).each { |f| require f }
+
+    helpers InstanceHelpers
+
+    register Sinatra::Namespace
+    Cuboid::Application.application.rest_services.each do |name, service|
+        namespace "/instances/:instance/#{name}" do
+            register service
+        end
+    end
+
+    register Routes::Instances
+    register Routes::Dispatcher
+    register Routes::Grid
+    register Routes::Scheduler
+
+    use Rack::Deflater
+    use Rack::Session::Pool
+
+    set :environment, :production
+
+    enable :logging
+
+    VALID_REPORT_FORMATS = %w(json xml yaml html.zip)
+
+    before do
+        protected!
+        content_type :json
+    end
+
+    helpers do
+        def max_utilization!
+            halt 503,
+                 json( error: 'Service unavailable: System is at maximum ' +
+                                  'utilization, slot limit reached.' )
+        end
+
+        def protected!
+            if !settings.respond_to?( :username )
+                settings.set :username, nil
+            end
+
+            if !settings.respond_to?( :password )
+                settings.set :password, nil
+            end
+
+            return if !settings.username && !settings.password
+            return if authorized?
+
+            headers['WWW-Authenticate'] = 'Basic realm="Restricted Area"'
+            halt 401, "Not authorized\n"
+        end
+
+        def authorized?
+            @auth ||= Rack::Auth::Basic::Request.new( request.env )
+            @auth.provided? && @auth.basic? && @auth.credentials == [
+                settings.username.to_s, settings.password.to_s
+            ]
+        end
+
+        def ensure_instance!
+            update_from_scheduler
+
+            id = params[:instance]
+
+            return if exists? id
+
+            halt 404, json( "Scan not found for id: #{h id}." )
+        end
+
+        def ensure_dispatcher!
+            return if dispatcher
+            halt 501, json( 'No Dispatcher has been set.' )
+        end
+
+        def ensure_scheduler!
+            return if scheduler
+            halt 501, json( 'No Scheduler has been set.' )
+        end
+
+        def handle_error( cleanup = nil, &block )
+            block.call
+        rescue => e
+            cleanup.call if cleanup
+
+            halt 500,
+                 json(
+                     error:       e.class,
+                     description: e.to_s,
+                     backtrace:   e.backtrace
+                 )
+        end
+
+        def h( text )
+            Rack::Utils.escape_html( text )
+        end
+    end
+
+    class <<self
+        include Cuboid::UI::Output
+
+        def reset
+            @@instances.clear
+            @@dispatchers.clear
+        end
+
+        def run!( options )
+            set :username, options[:username]
+            set :password, options[:password]
+
+            server = Puma::Server.new( self )
+            server.min_threads = 0
+            server.max_threads = 16
+
+            ssl = false
+            if options[:ssl_key] && options[:ssl_certificate]
+                ctx = Puma::MiniSSL::Context.new
+
+                ctx.key  = options[:ssl_key]
+                ctx.cert = options[:ssl_certificate]
+
+                if options[:ssl_ca]
+                    print_info 'CA provided, peer verification has been enabled.'
+
+                    ctx.ca          = options[:ssl_ca]
+                    ctx.verify_mode = Puma::MiniSSL::VERIFY_PEER |
+                        Puma::MiniSSL::VERIFY_FAIL_IF_NO_PEER_CERT
+                else
+                    print_info 'CA missing, peer verification has been disabled.'
+                end
+
+                ssl = true
+                server.binder.add_ssl_listener( options[:bind], options[:port], ctx )
+            else
+                ssl = false
+                server.add_tcp_listener( options[:bind], options[:port] )
+            end
+
+            print_status "Listening on http#{'s' if ssl}://#{options[:bind]}:#{options[:port]}"
+
+            begin
+                server.run.join
+            rescue Interrupt
+                server.stop( true )
+            end
+        end
+    end
+
+end
+
+end
+end

data/lib/cuboid/rest/server/instance_helpers.rb

@@ -0,0 +1,99 @@
+module Cuboid
+module Rest
+class Server
+
+module InstanceHelpers
+
+    @@instances   = {}
+    @@dispatchers = {}
+
+    def get_instance
+        if dispatcher
+            options = {
+              owner:   self.class.to_s,
+              helpers: {
+                    owner: {
+                        url: env['HTTP_HOST']
+                    }
+                }
+            }
+
+            if (info = dispatcher.dispatch( options ))
+                connect_to_instance( info['url'], info['token'] )
+            end
+        else
+            Processes::Instances.spawn( application: Options.paths.application )
+        end
+    end
+
+    def dispatchers
+        @@dispatchers.keys
+    end
+
+    def dispatcher
+        return if !Options.dispatcher.url
+        @dispatcher ||= connect_to_dispatcher( Options.dispatcher.url )
+    end
+
+    def unplug_dispatcher( url )
+        connect_to_dispatcher( url ).node.unplug
+
+        c = @@dispatchers.delete( url )
+        c.close if c
+    end
+
+    def connect_to_dispatcher( url )
+        @@dispatchers[url] ||= RPC::Client::Dispatcher.new( url )
+    end
+
+    def connect_to_instance( url, token )
+        RPC::Client::Instance.new( url, token )
+    end
+
+    def update_from_scheduler
+        return if !scheduler
+
+        scheduler.running.each do |id, info|
+            instances[id] ||= connect_to_instance( info['url'], info['token'] )
+        end
+
+        (scheduler.failed.keys | scheduler.completed.keys).each do |id|
+            session.delete id
+            client = instances.delete( id )
+            client.close if client
+        end
+    end
+
+    def scheduler
+        return if !Options.scheduler.url
+        @scheduler ||= connect_to_scheduler( Options.scheduler.url )
+    end
+
+    def connect_to_scheduler( url )
+        RPC::Client::Scheduler.new( url )
+    end
+
+    def instances
+        @@instances
+    end
+
+    def instance_for( id, &block )
+        cleanup = proc do
+            instances.delete( id ).close
+            session.delete id
+        end
+
+        handle_error cleanup do
+            block.call @@instances[id]
+        end
+    end
+
+    def exists?( id )
+        instances.include? id
+    end
+
+end
+
+end
+end
+end

data/lib/cuboid/rest/server/routes/dispatcher.rb

@@ -0,0 +1,41 @@
+module Cuboid
+module Rest
+class Server
+module Routes
+
+module Dispatcher
+
+    def self.registered( app )
+
+        app.get '/dispatcher/url' do
+            ensure_dispatcher!
+
+            json Options.dispatcher.url
+        end
+
+        app.put '/dispatcher/url' do
+            url = ::JSON.load( request.body.read ) || {}
+
+            handle_error do
+                connect_to_dispatcher( url ).alive?
+
+                @dispatcher = nil
+                Options.dispatcher.url = url
+                json nil
+            end
+        end
+
+        app.delete '/dispatcher/url' do
+            ensure_dispatcher!
+
+            json @dispatcher = Options.dispatcher.url = nil
+        end
+
+    end
+
+end
+
+end
+end
+end
+end

data/lib/cuboid/rest/server/routes/grid.rb

@@ -0,0 +1,41 @@
+module Cuboid
+module Rest
+class Server
+module Routes
+
+module Grid
+
+    def self.registered( app )
+
+        app.get '/grid' do
+            ensure_dispatcher!
+
+            handle_error do
+                json [Options.dispatcher.url] + dispatcher.statistics['node']['neighbours']
+            end
+        end
+
+        app.get '/grid/:dispatcher' do |url|
+            ensure_dispatcher!
+
+            handle_error { json connect_to_dispatcher( url ).statistics }
+        end
+
+        app.delete '/grid/:dispatcher' do |url|
+            ensure_dispatcher!
+
+            handle_error do
+                unplug_dispatcher( url )
+            end
+
+            json nil
+        end
+
+    end
+
+end
+
+end
+end
+end
+end

data/lib/cuboid/rest/server/routes/instances.rb

@@ -0,0 +1,131 @@
+module Cuboid
+module Rest
+class Server
+module Routes
+
+module Instances
+
+    def self.registered( app )
+
+        # List instances.
+        app.get '/instances' do
+            update_from_scheduler
+
+            json instances.keys.inject({}){ |h, k| h.merge! k => {} }
+        end
+
+        # Create
+        app.post '/instances' do
+            max_utilization! if !dispatcher && System.max_utilization?
+
+            options = ::JSON.load( request.body.read ) || {}
+
+            instance = get_instance
+            max_utilization! if !instance
+
+            handle_error proc { instance.shutdown } do
+                instance.run( options )
+            end
+
+            instances[instance.token] = instance
+
+            json id: instance.token
+        end
+
+        # Progress
+        app.get '/instances/:instance' do
+            ensure_instance!
+
+            session[params[:instance]] ||= {
+                seen_errors:  0,
+            }
+
+            data = instance_for( params[:instance] ) do |instance|
+                instance.progress(
+                    with:    [
+                                 errors:  session[params[:instance]][:seen_errors],
+                             ]
+                )
+            end
+
+            session[params[:instance]][:seen_errors] += data[:errors].size
+
+            json data
+        end
+
+        app.put '/instances/:instance/scheduler' do |instance|
+            ensure_scheduler!
+            ensure_instance!
+
+            handle_error do
+                instance = instances.delete( instance )
+                instance.close
+
+                json scheduler.attach( instance.url, instance.token )
+            end
+        end
+
+        app.get '/instances/:instance/summary' do
+            ensure_instance!
+
+            instance_for( params[:instance] ) do |instance|
+                json instance.progress
+            end
+        end
+
+        app.get '/instances/:instance/report.crf' do
+            ensure_instance!
+            content_type 'application/octet-stream'
+
+            instance_for( params[:instance] ) do |instance|
+                instance.generate_report.to_crf
+            end
+        end
+
+        app.get '/instances/:instance/report.json' do
+            ensure_instance!
+
+            instance_for( params[:instance] ) do |instance|
+                instance.generate_report.to_rpc_data.to_json
+            end
+        end
+
+        app.put '/instances/:instance/pause' do
+            ensure_instance!
+
+            instance_for( params[:instance] ) do |instance|
+                json instance.pause!
+            end
+        end
+
+        app.put '/instances/:instance/resume' do
+            ensure_instance!
+
+            instance_for( params[:instance] ) do |instance|
+                json instance.resume!
+            end
+        end
+
+        # Abort/shutdown
+        app.delete '/instances/:instance' do
+            ensure_instance!
+            id = params[:instance]
+
+            instance = instances[id]
+            handle_error { instance.shutdown }
+
+            instances.delete( id ).close
+
+            session.delete params[:instance]
+
+            json nil
+        end
+
+    end
+
+end
+
+end
+end
+end
+end