kamerling 0.0.2 → 0.0.3

data/lib/kamerling/project.rb

@@ -1,3 +1,7 @@
-module Kamerling class Project < UUIDEntity
-  attribute :name, String
-end end
+require_relative 'uuid_entity'
+
+module Kamerling
+  class Project < UUIDEntity
+    attrs name: String
+  end
+end

data/lib/kamerling/receiver.rb

@@ -1,11 +1,39 @@
-module Kamerling class Receiver
-  def receive addr: req(:addr), client_uuid: req(:client_uuid),
-              data: req(:data), repos: Repos, task_uuid: req(:task_uuid)
-    client = repos[Client][client_uuid]
-    task   = repos[Task][task_uuid]
-    result = Result.new addr: addr, client: client, data: data, task: task
-    client.busy = false
-    task.done   = true
-    repos << result << client << task
+require_relative 'client'
+require_relative 'repos'
+require_relative 'result'
+require_relative 'task'
+
+module Kamerling
+  class Receiver
+    def self.receive(addr:, message:, repos: Repos)
+      new(addr: addr, message: message, repos: repos).receive
+    end
+
+    def initialize(addr:, message:, repos:)
+      @addr, @message, @repos = addr, message, repos
+    end
+
+    def receive
+      client.busy = false
+      task.done   = true
+      repos << result << client << task
+    end
+
+    attr_reader :addr, :message, :repos
+    private     :addr, :message, :repos
+
+    private
+
+    def client
+      @client ||= repos[Client][message.client_uuid]
+    end
+
+    def result
+      Result.new(addr: addr, client: client, data: message.payload, task: task)
+    end
+
+    def task
+      @task ||= repos[Task][message.task_uuid]
+    end
   end
-end end
+end

data/lib/kamerling/registrar.rb

@@ -1,9 +1,46 @@
-module Kamerling class Registrar
-  def register addr: req(:addr), client_uuid: req(:client_uuid),
-               project_uuid: req(:project_uuid), repos: Repos
-    client  = repos[Client][client_uuid]
-    project = repos[Project][project_uuid]
-    reg     = Registration.new addr: addr, client: client, project: project
-    repos[Registration] << reg
+require_relative 'client'
+require_relative 'project'
+require_relative 'registration'
+require_relative 'repos'
+require_relative 'uuid'
+
+module Kamerling
+  class Registrar
+    def self.register(addr:, message:, repos: Repos)
+      new(addr: addr, message: message, repos: repos).register
+    end
+
+    def initialize(addr:, message:, repos:)
+      @addr, @message, @repos = addr, message, repos
+    end
+
+    def register
+      client.addr = addr
+      repos << client
+      repos << registration
+    end
+
+    attr_reader :addr, :message, :repos
+    private     :addr, :message, :repos
+
+    private
+
+    def client
+      @client ||= find_or_create_client
+    end
+
+    def find_or_create_client
+      repos[Client][message.client_uuid]
+    rescue Repo::NotFound
+      Client.new(addr: addr, uuid: message.client_uuid)
+    end
+
+    def project
+      @project ||= repos[Project][message.project_uuid]
+    end
+
+    def registration
+      Registration.new(addr: addr, client: client, project: project)
+    end
   end
-end end
+end

data/lib/kamerling/registration.rb

@@ -1,12 +1,11 @@
-module Kamerling class Registration < UUIDEntity
-  attribute :addr,    Addr
-  attribute :client,  Client
-  attribute :project, Project
+require_relative 'addr'
+require_relative 'client'
+require_relative 'project'
+require_relative 'uuid_entity'
 
-  def to_h
-    super
-      .reject { |key, _| key == :addr    }.merge(addr.to_h)
-      .reject { |key, _| key == :client  }.merge(client_uuid:  client.uuid)
-      .reject { |key, _| key == :project }.merge project_uuid: project.uuid
+module Kamerling
+  class Registration < UUIDEntity
+    attrs addr: Addr, client: Client, project: Project, registered_at: Time
+    defaults registered_at: -> (*) { Time.now }
   end
-end end
+end

data/lib/kamerling/repo.rb

@@ -1,32 +1,39 @@
-module Kamerling class Repo
-  NotFound = Class.new RuntimeError
+require 'sequel'
+require_relative 'mapper'
 
-  def initialize klass, source
-    @klass, @source = klass, source
-  end
+module Kamerling
+  class Repo
+    NotFound = Class.new(RuntimeError)
 
-  def << object
-    hash = object.to_h
-    warn_off { source << hash }
-  rescue Sequel::UniqueConstraintViolation
-    warn_off { source.where(uuid: object.uuid).update hash }
-  end
+    def initialize(klass, source, mapper: Mapper)
+      @klass  = klass
+      @mapper = mapper
+      @source = source
+    end
 
-  def [] uuid
-    hash = warn_off { source[uuid: uuid] }
-    fail NotFound, "#{klass} with UUID #{uuid}" unless hash
-    klass.from_h hash
-  end
+    def <<(object)
+      hash = mapper.to_h(object)
+      warn_off { source << hash }
+    rescue Sequel::UniqueConstraintViolation
+      warn_off { source.where(uuid: object.uuid).update hash }
+    end
 
-  def all
-    source.all.map { |hash| klass.from_h hash }
-  end
+    def [](uuid)
+      hash = warn_off { source[uuid: uuid] }
+      fail NotFound, "#{klass} with UUID #{uuid}" unless hash
+      mapper.from_h(klass, hash)
+    end
 
-  def related_to object
-    key = "#{object.class.name.split('::').last.downcase}_uuid".to_sym
-    source.where(key => object.uuid).map { |hash| klass.from_h hash }
-  end
+    def all
+      source.all.map { |hash| mapper.from_h(klass, hash) }
+    end
+
+    def related_to(object)
+      key = "#{object.class.name.split('::').last.downcase}_uuid".to_sym
+      source.where(key => object.uuid).map { |hash| mapper.from_h(klass, hash) }
+    end
 
-  attr_reader :klass, :source
-  private     :klass, :source
-end end
+    attr_reader :klass, :mapper, :source
+    private     :klass, :mapper, :source
+  end
+end

data/lib/kamerling/repos.rb

@@ -1,65 +1,72 @@
 warn_off { require 'sequel' }
+require_relative 'client'
+require_relative 'project'
+require_relative 'registration'
+require_relative 'repo'
+require_relative 'task'
 
 Sequel.extension :migration
 
-module Kamerling class Repos
-  class << self
-    attr_writer :repos
+module Kamerling
+  class Repos
+    class << self
+      attr_writer :repos
 
-    def << object
-      repos[object.class] << object
-      self
-    end
+      def <<(object)
+        repos[object.class] << object
+        self
+      end
 
-    def [] klass
-      repos[klass]
-    end
+      def [](klass)
+        repos[klass]
+      end
 
-    def clients
-      repos[Client].all
-    end
+      def clients
+        repos[Client].all
+      end
 
-    def clients_for project
-      repos[Registration].related_to(project).map(&:client)
-    end
+      def clients_for(project)
+        repos[Registration].related_to(project).map(&:client)
+      end
 
-    def db= db
-      warn_off { Sequel::Migrator.run db, "#{__dir__}/migrations" }
-      @repos = nil
-      @db    = db
-    end
+      def db=(db)
+        warn_off { Sequel::Migrator.run db, "#{__dir__}/migrations" }
+        @repos = nil
+        @db    = db
+      end
 
-    def free_clients_for project
-      clients_for(project).reject(&:busy)
-    end
+      def free_clients_for(project)
+        clients_for(project).reject(&:busy)
+      end
 
-    def next_task_for project
-      repos[Task].related_to(project).reject(&:done).first
-    end
+      def next_task_for(project)
+        repos[Task].related_to(project).reject(&:done).first
+      end
 
-    def project project_uuid
-      repos[Project][project_uuid]
-    end
+      def project(project_uuid)
+        repos[Project][project_uuid]
+      end
 
-    def projects
-      repos[Project].all
-    end
+      def projects
+        repos[Project].all
+      end
 
-    def tasks_for project
-      repos[Task].related_to project
-    end
+      def tasks_for(project)
+        repos[Task].related_to(project)
+      end
 
-    private
+      private
 
-    def db
-      @db ||= self.db = Sequel.sqlite
-    end
+      def db
+        @db ||= self.db = Sequel.sqlite
+      end
 
-    def repos
-      @repos ||= Hash.new do |repos, klass|
-        table = "#{klass.name.split('::').last.downcase}s".to_sym
-        repos[klass] = Repo.new klass, warn_off { db[table] }
+      def repos
+        @repos ||= Hash.new do |repos, klass|
+          table = "#{klass.name.split('::').last.downcase}s".to_sym
+          repos[klass] = Repo.new(klass, warn_off { db[table] })
+        end
       end
     end
   end
-end end
+end

data/lib/kamerling/result.rb

@@ -1,13 +1,12 @@
-module Kamerling class Result < UUIDEntity
-  attribute :addr,   Addr
-  attribute :client, Client
-  attribute :data,   String
-  attribute :task,   Task
+require_relative 'addr'
+require_relative 'client'
+require_relative 'task'
+require_relative 'uuid_entity'
 
-  def to_h
-    super
-      .reject { |key, _| key == :addr   }.merge(addr.to_h)
-      .reject { |key, _| key == :client }.merge(client_uuid: client.uuid)
-      .reject { |key, _| key == :task   }.merge task_uuid:   task.uuid
+module Kamerling
+  class Result < UUIDEntity
+    attrs addr: Addr, client: Client, data: String, received_at: Time,
+          task: Task
+    defaults received_at: -> (*) { Time.now }
   end
-end end
+end

data/lib/kamerling/server/http.rb

@@ -1,26 +1,33 @@
-module Kamerling module Server class HTTP
-  attr_reader :addr
+require 'rack'
+require_relative '../http_api'
 
-  def initialize addr: req(:addr)
-    @addr = addr
-  end
+module Kamerling
+  module Server
+    class HTTP
+      attr_reader :addr
 
-  def join
-    thread.join
-  end
+      def initialize(addr:)
+        @addr = addr
+      end
 
-  def start
-    @thread = Thread.new do
-      Rack::Handler::WEBrick.run HTTPAPI, Host: addr.host, Port: addr.port
-    end
-    loop { break if addr.connectable? }
-    self
-  end
+      def join
+        thread.join
+      end
 
-  def stop
-    thread.exit.join
-  end
+      def start
+        @thread = Thread.new do
+          Rack::Handler::WEBrick.run HTTPAPI, Host: addr.host, Port: addr.port
+        end
+        loop { break if addr.connectable? }
+        self
+      end
+
+      def stop
+        thread.exit.join
+      end
 
-  attr_reader :thread
-  private     :thread
-end end end
+      attr_reader :thread
+      private     :thread
+    end
+  end
+end

data/lib/kamerling/server/sock.rb

@@ -1,32 +1,40 @@
-module Kamerling module Server class Sock
-  attr_reader :addr
+require_relative '../handler'
+require_relative '../message'
 
-  def initialize addr: req(:addr), handler: Handler.new
-    @addr    = addr
-    @handler = handler
-  end
+module Kamerling
+  module Server
+    class Sock
+      attr_reader :addr
 
-  def join
-    thread.join
-  end
+      def initialize(addr:, handler: Handler.new)
+        @addr    = addr
+        @handler = handler
+      end
 
-  def start
-    @thread = Thread.new { run_loop }
-    wait_till_started
-    self
-  end
+      def join
+        thread.join
+      end
 
-  def stop
-    thread.exit.join
-  end
+      def start
+        @thread = Thread.new { run_loop }
+        wait_till_started
+        self
+      end
+
+      def stop
+        thread.exit.join
+      end
 
-  attr_reader :handler, :thread
-  private     :handler, :thread
+      attr_reader :handler, :thread
+      private     :handler, :thread
 
-  private
+      private
 
-  def handle input, client_addr
-    handler.handle input, client_addr
-  rescue Handler::UnknownInput
+      def handle(input, client_addr)
+        handler.handle Message.parse(input), client_addr
+      rescue Message::UnknownType
+        nil
+      end
+    end
   end
-end end end
+end