kamerling 0.0.2 → 0.0.3

data/lib/kamerling/core_extensions/main.rb

@@ -1,17 +1,17 @@
-module Kamerling module CoreExtensions module Main
-  module_function
+module Kamerling
+  module CoreExtensions
+    module Main
+      module_function
 
-  def req param
-    method   = caller.first[/`(.*)'$/, 1]
-    callsite = is_a?(Class) ? "#{name}.#{method}" : "#{self.class}##{method}"
-    fail "#{callsite}: param #{param} is required"
+      def warn_off
+        verbose  = $VERBOSE
+        $VERBOSE = false
+        yield
+      ensure
+        $VERBOSE = verbose
+      end
+    end
   end
+end
 
-  def warn_off
-    verbose  = $VERBOSE
-    $VERBOSE = false
-    yield
-  ensure
-    $VERBOSE = verbose
-  end
-end end end
+include Kamerling::CoreExtensions::Main

data/lib/kamerling/dispatch.rb

@@ -0,0 +1,13 @@
+require_relative 'addr'
+require_relative 'client'
+require_relative 'project'
+require_relative 'task'
+require_relative 'uuid_entity'
+
+module Kamerling
+  class Dispatch < UUIDEntity
+    attrs addr: Addr, client: Client, dispatched_at: Time, project: Project,
+          task: Task
+    defaults dispatched_at: -> (*) { Time.now }
+  end
+end

data/lib/kamerling/handler.rb

@@ -1,29 +1,20 @@
-module Kamerling class Handler
-  UnknownInput = Class.new RuntimeError
+require_relative 'receiver'
+require_relative 'registrar'
 
-  def initialize receiver: Receiver.new, registrar: Registrar.new
-    @receiver, @registrar = receiver, registrar
-  end
-
-  def handle input, addr
-    process Message.new(input), addr
-  rescue Message::UnknownType => exception
-    raise UnknownInput, exception.message
-  end
-
-  attr_reader :receiver, :registrar
-  private     :receiver, :registrar
-
-  private
+module Kamerling
+  class Handler
+    def initialize(receiver: Receiver, registrar: Registrar)
+      @receiver, @registrar = receiver, registrar
+    end
 
-  def process message, addr
-    case message.type
-    when :RGST
-      registrar.register addr: addr, client_uuid: message.client_uuid,
-                         project_uuid: message.project_uuid
-    when :RSLT
-      receiver.receive addr: addr, client_uuid: message.client_uuid,
-                       data: message.payload, task_uuid: message.task_uuid
+    def handle(message, addr)
+      case message.type
+      when :RGST then registrar.register addr: addr, message: message
+      when :RSLT then receiver.receive   addr: addr, message: message
+      end
     end
+
+    attr_reader :receiver, :registrar
+    private     :receiver, :registrar
   end
-end end
+end

data/lib/kamerling/http_api.rb

@@ -1,38 +1,54 @@
 require 'forwardable'
 require 'sinatra/base'
 require 'slim'
-
-module Kamerling class HTTPAPI < Sinatra::Base
-  extend Forwardable
-
-  configure { set repos: Repos }
-
-  get '/' do
-    slim :root
-  end
-
-  get '/clients' do
-    warn_off { slim :clients, locals: { clients: repos.clients } }
-  end
-
-  get '/projects' do
-    warn_off { slim :projects, locals: { projects: repos.projects } }
+require_relative 'project'
+require_relative 'repos'
+require_relative 'task_dispatcher'
+require_relative 'uuid'
+
+module Kamerling
+  class HTTPAPI < Sinatra::Base
+    extend Forwardable
+
+    delegate %i(task_dispatcher repos) => :settings
+
+    configure { set task_dispatcher: TaskDispatcher.new, repos: Repos }
+
+    get '/' do
+      render_template :root
+    end
+
+    get '/clients' do
+      render_template :clients, locals: { clients: repos.clients }
+    end
+
+    get '/projects' do
+      render_template :projects, locals: { projects: repos.projects }
+    end
+
+    get '/projects/:project_uuid' do
+      project = repos.project(params['project_uuid'])
+      clients = repos.clients_for(project)
+      tasks   = repos.tasks_for(project)
+      render_template :project, locals: { clients: clients, tasks: tasks }
+    end
+
+    post '/projects' do
+      name = params.fetch('name')
+      uuid = params.fetch('uuid')
+      repos << Project.new(name: name, uuid: uuid)
+      redirect '/projects'
+    end
+
+    post '/projects/dispatch' do
+      task_dispatcher.dispatch_all
+      redirect '/projects'
+    end
+
+    private
+
+    def render_template(template, locals: {})
+      warn_off { slim template, locals: locals }
+    end
   end
-
-  get '/projects/:project_uuid' do
-    project = repos.project params['project_uuid']
-    clients = repos.clients_for project
-    tasks   = repos.tasks_for project
-    warn_off { slim :project, locals: { clients: clients, tasks: tasks } }
-  end
-
-  post '/projects' do
-    uuid = params.fetch('uuid') { UUID.new }
-    repos << Project.new(name: params['name'], uuid: uuid)
-    redirect '/projects'
-  end
-
-  private
-
-  delegate repos: :settings
-end end
+end

data/lib/kamerling/logging.rb

@@ -1,32 +1,52 @@
 require 'after_do'
 require 'logger'
+require_relative 'net_dispatcher'
+require_relative 'server/sock'
 
-module Kamerling module Logging
-  module_function
+module Kamerling
+  class Logging
+    def self.log_to(logger = Logger.new($stdout))
+      new logger
+    end
 
-  def log_to logger = Logger.new($stdout)
-    log_dispatcher_to logger
-    log_server_to     logger
-  end
+    def initialize(logger)
+      @logger = logger
+      log_dispatcher
+      log_server
+    end
+
+    attr_reader :logger
+    private     :logger
 
-  class << self
     private
 
-    def log_dispatcher_to logger
+    def log_dispatcher
       NetDispatcher.singleton_class.extend AfterDo
-      NetDispatcher.singleton_class.before :dispatch do |addr, bytes|
-        logger.debug "sent #{addr} #{bytes}"
+      NetDispatcher.singleton_class.before(:dispatch) do |addr, message|
+        logger.debug "sent #{addr} #{message.to_hex}"
       end
     end
 
-    def log_server_to logger
+    def log_server
       Server::Sock.extend AfterDo
+      log_server_lifecycle
+      log_server_communication
+    end
+
+    def log_server_communication
+      Server::Sock.before(:handle) do |input, client_addr|
+        begin
+          logger.info "connect #{client_addr}"
+          logger.debug "received #{client_addr} #{Message.parse(input).to_hex}"
+        rescue Message::UnknownType
+          logger.debug "received #{client_addr} unknown message type"
+        end
+      end
+    end
+
+    def log_server_lifecycle
       Server::Sock.before(:start) { |srv| logger.info "start #{srv.addr}" }
       Server::Sock.after(:stop)   { |srv| logger.info "stop #{srv.addr}"  }
-      Server::Sock.before :handle do |input, client_addr|
-        logger.info "connect #{client_addr}"
-        logger.debug "received #{client_addr} #{input}"
-      end
     end
   end
-end end
+end

data/lib/kamerling/mapper.rb

@@ -0,0 +1,33 @@
+require_relative 'addr'
+
+module Kamerling
+  module Mapper
+    module_function
+
+    def from_h(klass, hash, repos: Repos)
+      attributes = hash.map do |key, value|
+        case key
+        when :host, :port, :prot then [:addr, Addr.new(hash)]
+        when /_uuid$/            then object_pair_from(key, value, repos)
+        else                          [key, value]
+        end
+      end.to_h
+      klass.new(attributes)
+    end
+
+    def object_pair_from(key, value, repos)
+      type = key[/(.*)_uuid$/, 1].to_sym
+      [type, repos[Kamerling.const_get(type.capitalize)][value]]
+    end
+
+    def to_h(object)
+      object.to_h.reduce({}) do |hash, (key, value)|
+        hash.merge case value
+                   when Addr then value.to_h
+                   when Hash then { :"#{key}_uuid" => value[:uuid] }
+                   else           { key => value }
+                   end
+      end
+    end
+  end
+end

data/lib/kamerling/message.rb

@@ -1,47 +1,60 @@
-module Kamerling class Message
-  UnknownType = Class.new RuntimeError
+require 'equalizer'
+require_relative 'uuid'
 
-  def self.[] client: req(:client), payload: req(:payload),
-              project: req(:project), task: req(:task), type: req(:type)
-    new "#{type}\0\0\0\0\0\0\0\0\0\0\0\0" + UUID.bin(client.uuid) +
-      UUID.bin(project.uuid) + UUID.bin(task.uuid) + payload
-  end
+module Kamerling
+  class Message
+    KNOWN_TYPES = %i(DATA PING RGST RSLT)
+    UnknownType = Class.new(RuntimeError)
 
-  def initialize raw
-    @raw = raw
-    type = raw[0..3]
-    known_types = %w(DATA PING RGST RSLT)
-    fail UnknownType, type unless known_types.include? type or type.empty?
-  end
+    include Equalizer.new(:raw)
 
-  def == other
-    raw == other.raw
-  end
+    def self.build(client:, payload:, project:, task:, type:)
+      new([type, "\0\0\0\0\0\0\0\0\0\0\0\0", UUID.bin(client.uuid),
+           UUID.bin(project.uuid), UUID.bin(task.uuid), payload].join)
+    end
 
-  def client_uuid
-    UUID[raw[16..31]]
-  end
+    def self.parse(raw)
+      new(raw)
+    end
 
-  def payload
-    raw[64..-1]
-  end
+    def initialize(raw)
+      @raw = raw
+      fail UnknownType, type unless KNOWN_TYPES.include?(type) or type.empty?
+    end
 
-  def project_uuid
-    UUID[raw[32..47]]
-  end
+    def client_type
+      raw[4..7].to_sym
+    end
 
-  def task_uuid
-    UUID[raw[48..63]]
-  end
+    def client_uuid
+      UUID[raw[16..31]]
+    end
 
-  def to_s
-    raw
-  end
+    def payload
+      raw[64..-1]
+    end
 
-  def type
-    raw[0..3].to_sym
-  end
+    def project_uuid
+      UUID[raw[32..47]]
+    end
+
+    def task_uuid
+      UUID[raw[48..63]]
+    end
+
+    def to_hex
+      raw.unpack('H*').first.scan(/../).join(' ')
+    end
 
-  attr_reader :raw
-  private     :raw
-end end
+    def to_s
+      raw
+    end
+
+    def type
+      raw[0..3].to_sym
+    end
+
+    attr_reader :raw
+    protected   :raw
+  end
+end

data/lib/kamerling/migrations/2_results_received_at.rb

@@ -0,0 +1,7 @@
+Sequel.migration do
+  change do
+    alter_table :results do
+      add_column :received_at, :timestamp
+    end
+  end
+end

data/lib/kamerling/migrations/3_dispatches.rb

@@ -0,0 +1,17 @@
+Sequel.migration do
+  change do
+    create_table :dispatches do
+      uuid      :uuid,          primary_key: true
+      inet      :host,          null: false
+      integer   :port,          null: false
+      string    :prot,          null: false
+      timestamp :dispatched_at, null: false
+      foreign_key :client_uuid,  :clients,  index: true, null: false,
+                                            type: :uuid
+      foreign_key :project_uuid, :projects, index: true, null: false,
+                                            type: :uuid
+      foreign_key :task_uuid,    :tasks,    index: true, null: false,
+                                            type: :uuid
+    end
+  end
+end

data/lib/kamerling/migrations/4_registrations_registered_at.rb

@@ -0,0 +1,7 @@
+Sequel.migration do
+  change do
+    alter_table :registrations do
+      add_column :registered_at, :timestamp
+    end
+  end
+end

data/lib/kamerling/migrations/5_clients_type.rb

@@ -0,0 +1,7 @@
+Sequel.migration do
+  change do
+    alter_table :clients do
+      add_column :type, :string
+    end
+  end
+end

data/lib/kamerling/net_dispatcher.rb

@@ -1,10 +1,15 @@
-module Kamerling module NetDispatcher
-  module_function
+require 'socket'
 
-  def dispatch addr, bytes
-    case addr.prot
-    when :TCP then TCPSocket.open(*addr) { |socket| socket << bytes }
-    when :UDP then UDPSocket.new.send bytes, 0, *addr
+module Kamerling
+  module NetDispatcher
+    module_function
+
+    def dispatch(addr, message)
+      bytes = message.to_s
+      case addr.prot
+      when :TCP then TCPSocket.open(*addr) { |socket| socket << bytes }
+      when :UDP then UDPSocket.new.send bytes, 0, *addr
+      end
     end
   end
-end end
+end