kamerling 0.0.2 → 0.0.3

data/lib/kamerling/server/tcp.rb

@@ -1,19 +1,27 @@
-module Kamerling module Server class TCP < Sock
-  private
+require 'socket'
+require_relative '../addr'
+require_relative 'sock'
 
-  def handle_connection socket
-    client_addr = Addr[*socket.remote_address.ip_unpack, :TCP]
-    input       = socket.read
-    handle input, client_addr
-  ensure
-    socket.close
-  end
+module Kamerling
+  module Server
+    class TCP < Sock
+      private
 
-  def run_loop
-    Socket.tcp_server_loop(*addr) { |socket| handle_connection socket }
-  end
+      def handle_connection(socket)
+        client_addr = Addr[*socket.remote_address.ip_unpack, :TCP]
+        input       = socket.read
+        handle input, client_addr
+      ensure
+        socket.close
+      end
+
+      def run_loop
+        Socket.tcp_server_loop(*addr) { |socket| handle_connection socket }
+      end
 
-  def wait_till_started
-    loop { break if addr.connectable? }
+      def wait_till_started
+        loop { break if addr.connectable? }
+      end
+    end
   end
-end end end
+end

data/lib/kamerling/server/udp.rb

@@ -1,20 +1,28 @@
-module Kamerling module Server class UDP < Sock
-  private
+require 'socket'
+require_relative '../addr'
+require_relative 'sock'
 
-  def handle_connection socket
-    input, conn = socket.recvfrom 2**16
-    client_addr = Addr[conn[3], conn[1], :UDP]
-    handle input, client_addr
-  end
+module Kamerling
+  module Server
+    class UDP < Sock
+      private
 
-  def run_loop
-    socket = UDPSocket.new.tap { |server| server.bind(*addr) }
-    loop { handle_connection socket if IO.select [socket] }
-  ensure
-    socket.close if socket
-  end
+      def handle_connection(socket)
+        input, conn = socket.recvfrom 2**16
+        client_addr = Addr[conn[3], conn[1], :UDP]
+        handle input, client_addr
+      end
+
+      def run_loop
+        socket = UDPSocket.new.tap { |server| server.bind(*addr) }
+        loop { handle_connection socket if IO.select [socket] }
+      ensure
+        socket.close if socket
+      end
 
-  def wait_till_started
-    200.times { thread.run }
+      def wait_till_started
+        200.times { thread.run }
+      end
+    end
   end
-end end end
+end

data/lib/kamerling/server_runner.rb

@@ -1,48 +1,37 @@
-require 'optparse'
-
-module Kamerling class ServerRunner
-  def initialize args, classes: def_classes, orm: Sequel, repos: Repos
-    @args    = args
-    repos.db = orm.connect settings.db
-    @servers = { http: :TCP, tcp: :TCP, udp: :UDP }.map do |type, prot|
-      addr = Addr[settings.host, settings.send(type), prot]
-      classes[type].new addr: addr if addr.port
-    end.compact
-  end
-
-  def join
-    servers.each(&:join)
-  end
-
-  def start
-    servers.each(&:start)
-    self
-  end
-
-  attr_reader :args, :servers
-  private     :args, :servers
+require 'sequel'
+require_relative 'addr'
+require_relative 'repos'
+require_relative 'server/http'
+require_relative 'server/tcp'
+require_relative 'server/udp'
+require_relative 'settings'
+
+module Kamerling
+  class ServerRunner
+    def initialize(args, classes: def_classes, orm: Sequel, repos: Repos)
+      settings = Settings.new(args)
+      repos.db = orm.connect(settings.db)
+      @servers = settings.server_addrs.map do |type, addr|
+        classes[type].new(addr: addr)
+      end
+    end
 
-  private
+    def join
+      servers.each(&:join)
+    end
 
-  Settings = Struct.new(*%i(db host http tcp udp))
+    def start
+      servers.each(&:start)
+      self
+    end
 
-  def def_classes
-    { http: Server::HTTP, tcp: Server::TCP, udp: Server::UDP }
-  end
+    attr_reader :servers
+    private     :servers
 
-  def defaults
-    Settings.new 'sqlite::memory:', '127.0.0.1'
-  end
+    private
 
-  def settings
-    @settings ||= defaults.tap do |set|
-      OptionParser.new do |opt|
-        opt.on("--db #{set.db}", String, 'database') { |db| set.db = db }
-        opt.on("--host #{set.host}", String, 'host') { |host| set.host = host }
-        opt.on('--http 0', Integer, 'HTTP port') { |http| set.http = http }
-        opt.on('--tcp 0',  Integer, 'TCP port')  { |tcp|  set.tcp  = tcp  }
-        opt.on('--udp 0',  Integer, 'UDP port')  { |udp|  set.udp  = udp  }
-      end.parse! args
+    def def_classes
+      { http: Server::HTTP, tcp: Server::TCP, udp: Server::UDP }
     end
   end
-end end
+end

data/lib/kamerling/settings.rb

@@ -0,0 +1,28 @@
+require 'optparse'
+require_relative 'addr'
+require_relative 'value'
+
+module Kamerling
+  class Settings < Value
+    vals db: String, host: String, http: Integer, tcp: Integer, udp: Integer
+
+    def initialize(args)
+      super db: 'sqlite::memory:', host: '127.0.0.1'
+      OptionParser.new do |opt|
+        opt.on("--db #{db}", String, 'database') { |db|   self.db   = db   }
+        opt.on("--host #{host}", String, 'host') { |host| self.host = host }
+        opt.on('--http 0', Integer, 'HTTP port') { |http| self.http = http }
+        opt.on('--tcp 0',  Integer, 'TCP port')  { |tcp|  self.tcp  = tcp  }
+        opt.on('--udp 0',  Integer, 'UDP port')  { |udp|  self.udp  = udp  }
+      end.parse! args
+    end
+
+    def server_addrs
+      {
+        http: Addr[host, http, :TCP],
+        tcp:  Addr[host, tcp,  :TCP],
+        udp:  Addr[host, udp,  :UDP],
+      }.select { |_, addr| addr.port }
+    end
+  end
+end

data/lib/kamerling/task.rb

@@ -1,9 +1,9 @@
-module Kamerling class Task < UUIDEntity
-  attribute :data,    String
-  attribute :done,    Boolean, default: false
-  attribute :project, Project
+require_relative 'project'
+require_relative 'uuid_entity'
 
-  def to_h
-    super.reject { |key, _| key == :project }.merge project_uuid: project.uuid
+module Kamerling
+  class Task < UUIDEntity
+    attrs data: String, done: Boolean, project: Project
+    defaults done: false
   end
-end end
+end

data/lib/kamerling/task_dispatcher.rb

@@ -1,29 +1,38 @@
-module Kamerling class TaskDispatcher
-  def initialize net_dispatcher: NetDispatcher, repos: Repos
-    @net_dispatcher = net_dispatcher
-    @repos          = repos
-  end
+require_relative 'dispatch'
+require_relative 'message'
+require_relative 'net_dispatcher'
+require_relative 'repos'
+
+module Kamerling
+  class TaskDispatcher
+    def initialize(net_dispatcher: NetDispatcher, repos: Repos)
+      @net_dispatcher = net_dispatcher
+      @repos          = repos
+    end
 
-  def dispatch
-    repos.projects.each do |project|
-      repos.free_clients_for(project).each do |client|
-        task = repos.next_task_for(project)
-        dispatch_task client: client, project: project, task: task if task
+    def dispatch_all
+      repos.projects.each do |project|
+        repos.free_clients_for(project).each do |client|
+          task = repos.next_task_for(project)
+          dispatch_task client: client, project: project, task: task if task
+        end
       end
     end
-  end
 
-  attr_reader :net_dispatcher, :repos
-  private     :net_dispatcher, :repos
+    attr_reader :net_dispatcher, :repos
+    private     :net_dispatcher, :repos
 
-  private
+    private
 
-  def dispatch_task client: req(:client), project: req(:project),
-                    task: req(:task)
-    message = Message[client: client, payload: task.data, project: project,
-                      task: task, type: :DATA]
-    net_dispatcher.dispatch client.addr, message.to_s
-    client.busy = true
-    repos << client
+    def dispatch_task(client:, project:, task:)
+      message = Message.build(client: client, payload: task.data,
+                              project: project, task: task, type: :DATA)
+      dispatch = Dispatch.new(addr: client.addr, client: client,
+                              project: project, task: task)
+      net_dispatcher.dispatch client.addr, message
+      client.busy = true
+      repos << client
+      repos << dispatch
+    end
   end
-end end
+end

data/lib/kamerling/uuid.rb

@@ -1,17 +1,19 @@
 require 'securerandom'
 
-module Kamerling module UUID
-  module_function
+module Kamerling
+  module UUID
+    module_function
 
-  def [] bin
-    bin.unpack('H8H4H4H4H12').join '-'
-  end
+    def [](bin)
+      bin.unpack('H8H4H4H4H12').join('-')
+    end
 
-  def bin uuid
-    [uuid.tr('-', '')].pack 'H*'
-  end
+    def bin(uuid)
+      [uuid.tr('-', '')].pack('H*')
+    end
 
-  def new
-    SecureRandom.uuid
+    def new
+      SecureRandom.uuid
+    end
   end
-end end
+end

data/lib/kamerling/uuid_entity.rb

@@ -1,15 +1,29 @@
+require 'equalizer'
 require 'virtus'
+require_relative 'uuid'
 
-module Kamerling class UUIDEntity
-  include Equalizer.new :uuid
+module Kamerling
+  class UUIDEntity
+    include Equalizer.new(:uuid)
 
-  include Virtus.model
+    include Virtus.model
 
-  attribute :uuid, String, default: -> * { UUID.new }
+    attribute :uuid, String, default: -> (*) { UUID.new }
 
-  class << self
-    alias_method :from_h, :new
-  end
+    def self.attrs(hash = {})
+      hash.each { |name, klass| attribute name, klass }
+    end
+
+    def self.defaults(hash = {})
+      hash.each do |name, default|
+        warn_off { attribute name, attribute_set[name].type, default: default }
+      end
+    end
 
-  alias_method :to_h, :attributes
-end end
+    def to_h
+      attributes.map do |key, value|
+        value.is_a?(UUIDEntity) ? [key, value.to_h] : [key, value]
+      end.to_h
+    end
+  end
+end

data/lib/kamerling/value.rb

@@ -0,0 +1,13 @@
+require 'virtus'
+
+module Kamerling
+  class Value
+    include Virtus.value_object
+
+    def self.vals(hash = {})
+      values do
+        hash.each { |name, klass| attribute name, klass }
+      end
+    end
+  end
+end

data/lib/kamerling/views/clients.slim

@@ -2,5 +2,7 @@ nav
   ul#clients
     - clients.each do |client|
       li
-        a data-uuid=client.uuid href="/clients/#{client.uuid}" rel='client'
+        a(data-addr=client.addr data-busy=client.busy.to_s data-class='client'
+          data-type=client.type data-uuid=client.uuid
+          href="/clients/#{client.uuid}")
           = client.busy

data/lib/kamerling/views/project.slim

@@ -2,10 +2,14 @@ nav
   ul#clients
     - clients.each do |client|
       li
-        a data-busy=client.busy.to_s data-uuid=client.uuid href="/clients/#{client.uuid}" rel='client'
-          = client.busy
+        a(data-busy=client.busy.to_s data-class='client' data-type=client.type
+          data-uuid=client.uuid href="/clients/#{client.uuid}")
+          = client.uuid
+        = "busy: #{client.busy.to_s}"
   ul#tasks
     - tasks.each do |task|
       li
-        a data-done=task.done.to_s data-uuid=task.uuid href="/tasks/#{task.uuid}" rel='task'
-          = task.done
+        a(data-class='task' data-done=task.done.to_s data-uuid=task.uuid
+          href="/tasks/#{task.uuid}")
+          = task.uuid
+        = "done: #{task.done.to_s}"

data/lib/kamerling/views/projects.slim

@@ -2,8 +2,14 @@ nav
   ul#projects
     - projects.each do |project|
       li
-        a data-uuid=project.uuid href="/projects/#{project.uuid}" rel='project'
+        a(data-class='project' data-uuid=project.uuid
+          href="/projects/#{project.uuid}")
           = project.name
 
 form action='/projects' method='POST'
   input name='name'
+  input name='uuid' type='hidden' value=Kamerling::UUID.new
+  input type='submit' value='create'
+
+form action='/projects/dispatch' method='POST'
+  input type='submit' value='dispatch'

data/spec/kamerling/addr_spec.rb

@@ -1,33 +1,43 @@
+require 'socket'
 require_relative '../spec_helper'
+require_relative '../../lib/kamerling/addr'
 
-module Kamerling describe Addr do
-  let(:addr) { Addr['localhost', 1981, :TCP] }
+module Kamerling
+  describe Addr do
+    let(:addr) { Addr['localhost', 1981, :TCP] }
 
-  describe '#connectable?' do
-    it 'is a predicate whether the (TCP) address is connectable' do
-      server = TCPServer.new(*addr)
-      addr.must_be :connectable?
-      server.close
-      addr.wont_be :connectable?
+    describe '#connectable?' do
+      it 'is a predicate whether the (TCP) address is connectable' do
+        server = TCPServer.new(*addr)
+        addr.must_be :connectable?
+        server.close
+        addr.wont_be :connectable?
+      end
     end
-  end
 
-  describe '#to_a' do
-    it 'returns host + port for splat use' do
-      splat = *addr
-      splat.must_equal ['localhost', 1981]
+    describe '#to_a' do
+      it 'returns host + port for splat use' do
+        splat = *addr
+        splat.must_equal ['localhost', 1981]
+      end
     end
-  end
 
-  describe '#to_h' do
-    it 'returns a Hash with Integer and String values' do
-      addr.to_h.must_equal host: 'localhost', port: 1981, prot: 'TCP'
+    describe '#to_h' do
+      it 'returns a Hash with Integer and String values' do
+        addr.to_h.must_equal host: 'localhost', port: 1981, prot: 'TCP'
+      end
+    end
+
+    describe '#to_s' do
+      it 'returns the Addr in URI notation' do
+        addr.to_s.must_equal 'tcp://localhost:1981'
+      end
     end
-  end
 
-  describe '#to_s' do
-    it 'returns the Addr in ‘host:port (protocol)’ notation' do
-      addr.to_s.must_equal 'localhost:1981 (TCP)'
+    describe '#uri' do
+      it 'returns and URI representation of the Addr' do
+        addr.uri.must_equal URI.parse('tcp://localhost:1981')
+      end
     end
   end
-end end
+end