kamerling 0.0.1

data/lib/kamerling/uuid_object.rb

@@ -0,0 +1,79 @@
+module Kamerling
+  def self.UUIDObject *params
+    class_definition_from attrs_from params
+  end
+
+  private
+
+  def self.attrs_from params
+    { uuid: -> { UUID.new } }.tap do |attrs|
+      attrs.merge! params.pop if params.last.is_a? Hash
+      attrs.merge! raises_from params
+    end
+  end
+
+  def self.class_definition_from attrs
+    Class.new do
+      define_singleton_method(:attrs) { attrs }
+
+      def self.from_h hash, repos: Repos
+        args = hash.reduce({}) do |result, (key, _)|
+          result.merge from_h_mapping hash, key, repos
+        end
+        new args
+      end
+
+      def initialize args = {}
+        @values = Hash[self.class.attrs.map do |attr, default|
+          value = args.fetch attr do
+            default.respond_to?(:call) ? default.call : default
+          end
+          [attr, value]
+        end]
+      end
+
+      def == other
+        uuid == other.uuid
+      end
+
+      attrs.each do |attr, _|
+        define_method(attr)       { @values[attr]             }
+        define_method("#{attr}=") { |val| @values[attr] = val }
+      end
+
+      def to_h
+        self.class.attrs.reduce({}) do |hash, (attr, _)|
+          hash.merge to_h_mapping attr
+        end
+      end
+
+      private
+
+      def self.from_h_mapping hash, key, repos
+        case key
+        when :host, :port, :prot
+          { addr: Addr[hash[:host], hash[:port], hash[:prot].to_sym] }
+        when :client_uuid  then { client:  repos[Client][hash[key]]  }
+        when :project_uuid then { project: repos[Project][hash[key]] }
+        when :task_uuid    then { task:    repos[Task][hash[key]]    }
+        else { key => hash[key] }
+        end
+      end
+
+      def to_h_mapping attr
+        case value = @values[attr]
+        when Addr
+          { host: value.host, port: value.port, prot: value.prot.to_s }
+        when Client  then { client_uuid:  client.uuid  }
+        when Project then { project_uuid: project.uuid }
+        when Task    then { task_uuid:    task.uuid    }
+        else { attr => value }
+        end
+      end
+    end
+  end
+
+  def self.raises_from params
+    Hash[params.map { |param| [param, -> { raise "#{param} required" }] }]
+  end
+end

data/lib/kamerling/views/clients.slim

@@ -0,0 +1,6 @@
+nav
+  ul#clients
+    - clients.each do |client|
+      li
+        a data-uuid=client.uuid href="/clients/#{client.uuid}" rel='client'
+          = client.busy

data/lib/kamerling/views/layout.slim

@@ -0,0 +1,6 @@
+doctype html
+html
+  head
+    title Kamerling
+  body
+    == yield

data/lib/kamerling/views/project.slim

@@ -0,0 +1,11 @@
+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
+  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

data/lib/kamerling/views/projects.slim

@@ -0,0 +1,9 @@
+nav
+  ul#projects
+    - projects.each do |project|
+      li
+        a data-uuid=project.uuid href="/projects/#{project.uuid}" rel='project'
+          = project.name
+
+form action='/projects' method='POST'
+  input name='name'

data/lib/kamerling/views/root.slim

@@ -0,0 +1,6 @@
+nav
+  ul
+    li
+      a#clients  href='/clients'  clients
+    li
+      a#projects href='/projects' projects

data/lib/kamerling.rb

@@ -0,0 +1,29 @@
+require 'socket'
+
+require_relative 'kamerling/core_extensions'
+
+include Kamerling::CoreExtensions::Main
+
+require_relative 'kamerling/addr'
+require_relative 'kamerling/handler'
+require_relative 'kamerling/message'
+require_relative 'kamerling/net_dispatcher'
+require_relative 'kamerling/receiver'
+require_relative 'kamerling/registrar'
+require_relative 'kamerling/repo'
+require_relative 'kamerling/repos'
+require_relative 'kamerling/http_api'
+require_relative 'kamerling/server/http'
+require_relative 'kamerling/server/sock'
+require_relative 'kamerling/server/tcp'
+require_relative 'kamerling/server/udp'
+require_relative 'kamerling/server_runner'
+require_relative 'kamerling/task_dispatcher'
+require_relative 'kamerling/uuid'
+require_relative 'kamerling/uuid_object'
+require_relative 'kamerling/client'
+require_relative 'kamerling/project'
+require_relative 'kamerling/registration'
+require_relative 'kamerling/result'
+require_relative 'kamerling/task'
+require_relative 'kamerling/logging'

data/spec/kamerling/addr_spec.rb

@@ -0,0 +1,27 @@
+require_relative '../spec_helper'
+
+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?
+    end
+  end
+
+  describe '#to_a' do
+    it 'returns host + port for splat use' do
+      splat = *addr
+      splat.must_equal ['localhost', 1981]
+    end
+  end
+
+  describe '#to_s' do
+    it 'returns the Addr in ‘host:port (protocol)’ notation' do
+      addr.to_s.must_equal 'localhost:1981 (TCP)'
+    end
+  end
+end end

data/spec/kamerling/client_spec.rb

@@ -0,0 +1,9 @@
+require_relative '../spec_helper'
+
+module Kamerling describe Client do
+  describe '#busy' do
+    it 'defaults to false' do
+      Client.new(addr: fake(:addr)).busy.must_equal false
+    end
+  end
+end end

data/spec/kamerling/core_extensions/main_spec.rb

@@ -0,0 +1,18 @@
+require_relative '../../spec_helper'
+
+module Kamerling describe CoreExtensions::Main do
+  describe '#req' do
+    it 'raises a RuntimeError that a parameter is required' do
+      -> { CoreExtensions::Main.req(:foo) }.must_raise(RuntimeError)
+        .message.must_include 'param foo is required'
+    end
+  end
+
+  describe '#warn_off' do
+    it 'turns $VERBOSE off inside the block' do
+      assert $VERBOSE
+      CoreExtensions::Main.warn_off { refute $VERBOSE }
+      assert $VERBOSE
+    end
+  end
+end end

data/spec/kamerling/handler_spec.rb

@@ -0,0 +1,30 @@
+require_relative '../spec_helper'
+
+module Kamerling describe Handler do
+  describe '#handle' do
+    fakes :addr, :receiver, :registrar
+    let(:handler) { Handler.new receiver: receiver, registrar: registrar }
+
+    it 'handles RGST inputs' do
+      input = 'RGST' + "\0" * 12 + '16B client  UUID16B project UUID'
+      handler.handle input, addr
+      registrar.must_have_received :register, [{ addr: addr,
+        client_uuid: UUID['16B client  UUID'],
+        project_uuid: UUID['16B project UUID'] }]
+    end
+
+    it 'handles RSLT inputs' do
+      input = 'RSLT' + "\0" * 12
+      input << '16B client  UUID16B project UUID16B task    UUIDdata'
+      handler.handle input, addr
+      receiver.must_have_received :receive, [{ addr: addr,
+        client_uuid: UUID['16B client  UUID'], data: 'data',
+        task_uuid: UUID['16B task    UUID'] }]
+    end
+
+    it 'raises on unknown inputs' do
+      ex = -> { handler.handle 'MESS', addr }.must_raise Handler::UnknownInput
+      ex.message.must_equal 'MESS'
+    end
+  end
+end end

data/spec/kamerling/http_api_spec.rb

@@ -0,0 +1,93 @@
+require 'nokogiri'
+
+require_relative '../spec_helper'
+
+module Kamerling describe HTTPAPI do
+  let(:app)   { HTTPAPI.set repos: repos                        }
+  let(:doc)   { Nokogiri::HTML last_response.body               }
+  let(:ecc)   { fake :project, uuid: UUID.new                   }
+  let(:gimps) { fake :project, uuid: UUID.new                   }
+  let(:repos) { fake :repos, as: :class, projects: [gimps, ecc] }
+
+  describe 'GET /' do
+    it 'contains links to clients and projects' do
+      get '/'
+      doc.at('#clients')['href'].must_equal '/clients'
+      doc.at('#projects')['href'].must_equal '/projects'
+    end
+  end
+
+  describe 'GET /clients' do
+    it 'contains links to and UUIDs of clients' do
+      fpga = fake :client, uuid: UUID.new
+      stub(repos).clients { [fpga] }
+      get '/clients'
+      links = doc.css '#clients a[rel=client]'
+      links.size.must_equal 1
+      links.at("[data-uuid='#{fpga.uuid}']")['href']
+        .must_equal "/clients/#{fpga.uuid}"
+    end
+  end
+
+  describe 'GET /projects' do
+    it 'contains links to and UUIDs of projects' do
+      get '/projects'
+      links = doc.css '#projects a[rel=project]'
+      links.size.must_equal 2
+      links.at("[data-uuid='#{gimps.uuid}']")['href']
+        .must_equal "/projects/#{gimps.uuid}"
+    end
+  end
+
+  describe 'GET /projects/{uuid}' do
+    let(:cpu) { fake :client, busy: false, uuid: UUID.new }
+    let(:gpu) { fake :client, busy: true,  uuid: UUID.new }
+    let(:three) { fake :task, done: false, uuid: UUID.new }
+    let(:seven) { fake :task, done: true,  uuid: UUID.new }
+
+    before do
+      stub(repos).project(gimps.uuid) { gimps          }
+      stub(repos).clients_for(gimps)  { [cpu, gpu]     }
+      stub(repos).tasks_for(gimps)    { [three, seven] }
+    end
+
+    it 'contains links to and info on the project’s clients' do
+      get "/projects/#{gimps.uuid}"
+      links = doc.css '#clients a[rel=client]'
+      links.size.must_equal 2
+      links.at("[data-uuid='#{cpu.uuid}']")['href']
+        .must_equal "/clients/#{cpu.uuid}"
+      links.at("[data-uuid='#{cpu.uuid}']")['data-busy'].must_equal 'false'
+      links.at("[data-uuid='#{gpu.uuid}']")['data-busy'].must_equal 'true'
+    end
+
+    it 'contains links to and info on the project’s tasks' do
+      get "/projects/#{gimps.uuid}"
+      links = doc.css '#tasks a[rel=task]'
+      links.size.must_equal 2
+      links.at("[data-uuid='#{three.uuid}']")['href']
+        .must_equal "/tasks/#{three.uuid}"
+      links.at("[data-uuid='#{three.uuid}']")['data-done'].must_equal 'false'
+      links.at("[data-uuid='#{seven.uuid}']")['data-done'].must_equal 'true'
+    end
+  end
+
+  describe 'POST /projects' do
+    it 'creates a new project with the given name and UUID' do
+      post '/projects', name: 'ECC', uuid: uuid = UUID.new
+      repos.must_have_received :<<, [Project.new(name: 'ECC', uuid: uuid)]
+    end
+
+    it 'creates a new project with a random UUID if missing' do
+      post '/projects', name: 'ECC'
+      project = Project.new name: 'ECC', uuid: any(String)
+      repos.must_have_received :<<, [project]
+    end
+
+    it 'redirects to /projects' do
+      post '/projects', name: 'ECC'
+      follow_redirect!
+      URI(last_request.url).path.must_equal '/projects'
+    end
+  end
+end end

data/spec/kamerling/logging_spec.rb

@@ -0,0 +1,73 @@
+require_relative '../spec_helper'
+
+module Kamerling describe Logging do
+  let(:logged)     { stream.tap(&:rewind).read                           }
+  let(:logger)     { Logger.new stream                                   }
+  let(:stream)     { StringIO.new                                        }
+  let(:tcp_server) { Server::TCP.new addr: Addr['localhost', 1981, :TCP] }
+  let(:udp_server) { Server::UDP.new addr: Addr['localhost', 1979, :UDP] }
+
+  before do
+    Logging.log_to logger: logger
+    tcp_server.start
+    udp_server.start
+  end
+
+  after do
+    tcp_server.stop
+    udp_server.stop
+  end
+
+  describe '.new' do
+    it 'logs TCP server starts' do
+      logged.must_include 'start localhost:1981 (TCP)'
+    end
+
+    it 'logs TCP server stops' do
+      tcp_server.stop
+      logged.must_include 'stop localhost:1981 (TCP)'
+    end
+
+    it 'logs TCP server connects' do
+      tcp_addr = TCPSocket.open(*tcp_server.addr) do |socket|
+        Addr[*socket.local_address.ip_unpack, :TCP]
+      end
+      run_all_threads
+      logged.must_include "connect #{tcp_addr}"
+    end
+
+    it 'logs TCP server receives' do
+      tcp_addr = TCPSocket.open(*tcp_server.addr) do |socket|
+        socket << 'PING'
+        Addr[*socket.local_address.ip_unpack, :TCP]
+      end
+      run_all_threads
+      logged.must_include "received #{tcp_addr} PING"
+    end
+
+    it 'logs UDP server starts' do
+      logged.must_include 'start localhost:1979 (UDP)'
+    end
+
+    it 'logs UDP server stops' do
+      udp_server.stop
+      logged.must_include 'stop localhost:1979 (UDP)'
+    end
+
+    it 'logs UDP server connects' do
+      udp_client = UDPSocket.new
+      udp_client.send 'PING', 0, *udp_server.addr
+      udp_addr = Addr['127.0.0.1', udp_client.addr[1], :UDP]
+      run_all_threads
+      logged.must_include "connect #{udp_addr}"
+    end
+
+    it 'logs TCP server receives' do
+      udp_client = UDPSocket.new
+      udp_client.send 'PING', 0, *udp_server.addr
+      udp_addr = Addr['127.0.0.1', udp_client.addr[1], :UDP]
+      run_all_threads
+      logged.must_include "received #{udp_addr} PING"
+    end
+  end
+end end

data/spec/kamerling/message_spec.rb

@@ -0,0 +1,70 @@
+require_relative '../spec_helper'
+
+module Kamerling describe Message do
+  let(:mess) do
+    Message.new "DATA\0\0\0\0\0\0\0\0\0\0\0\0" \
+      '16B client  UUID16B project UUID16B task    UUIDsome payload'
+  end
+
+  describe '.[]' do
+    it 'constructs a new message' do
+      client  = fake :client,  uuid: UUID.new
+      project = fake :project, uuid: UUID.new
+      task    = fake :task,    uuid: UUID.new
+      message = Message[client: client, payload: 'pay', project: project,
+        task: task, type: :DATA]
+      message.client_uuid.must_equal client.uuid
+      message.project_uuid.must_equal project.uuid
+      message.task_uuid.must_equal task.uuid
+      message.payload.must_equal 'pay'
+      message.type.must_equal :DATA
+    end
+  end
+
+  describe '.new' do
+    it 'raises on unknown message types' do
+      -> { Message.new 'MESS age' }.must_raise Message::UnknownType
+    end
+
+    it 'doesn’t raise on empty messages' do
+      Message.new ''
+    end
+  end
+
+  describe '#client_uuid' do
+    it 'returns the client UUID' do
+      mess.client_uuid.must_equal '31364220-636c-6965-6e74-202055554944'
+    end
+  end
+
+  describe '#payload' do
+    it 'returns the result payload' do
+      mess.payload.must_equal 'some payload'
+    end
+  end
+
+  describe '#project_uuid' do
+    it 'returns the project UUID' do
+      mess.project_uuid.must_equal '31364220-7072-6f6a-6563-742055554944'
+    end
+  end
+
+  describe '#task_uuid' do
+    it 'returns the task UUID' do
+      mess.task_uuid.must_equal '31364220-7461-736b-2020-202055554944'
+    end
+  end
+
+  describe '#to_s' do
+    it 'returns the raw bytes' do
+      mess.to_s.must_equal "#{mess.type}\0\0\0\0\0\0\0\0\0\0\0\0" +
+        '16B client  UUID16B project UUID16B task    UUIDsome payload'
+    end
+  end
+
+  describe '#type' do
+    it 'returns the message type' do
+      mess.type.must_match(/\A[A-Z]{4}\z/)
+    end
+  end
+end end

data/spec/kamerling/net_dispatcher_spec.rb

@@ -0,0 +1,21 @@
+require_relative '../spec_helper'
+
+module Kamerling describe NetDispatcher do
+  describe '#dispatch' do
+    it 'dispatches messages to TCP clients' do
+      server = TCPServer.open 0
+      thread = Thread.new { server.accept.read }
+      addr   = Addr[server.addr[3], server.addr[1], :TCP]
+      NetDispatcher.new.dispatch addr, 'foo'
+      thread.value.must_equal 'foo'
+    end
+
+    it 'dispatches messages to UDP clients' do
+      server = UDPSocket.new.tap { |s| s.bind '127.0.0.1', 0 }
+      thread = Thread.new { server.recvfrom(2**16).first }
+      addr   = Addr[server.addr[3], server.addr[1], :UDP]
+      NetDispatcher.new.dispatch addr, 'foo'
+      thread.value.must_equal 'foo'
+    end
+  end
+end end

data/spec/kamerling/receiver_spec.rb

@@ -0,0 +1,22 @@
+require_relative '../spec_helper'
+
+module Kamerling describe Receiver do
+  describe '#receive' do
+    fakes :addr, :client, :task
+
+    it 'saves the result and updates client and task' do
+      repos = fake :repos, as: :class
+      stub(repos).<<(any_args) { repos }
+      stub(repos).[](Client)   { fake :repo, :[] => client }
+      stub(repos).[](Task)     { fake :repo, :[] => task   }
+      Receiver.new.receive addr: addr, client_uuid: client.uuid, data: 'data',
+        repos: repos, task_uuid: task.uuid
+      client.must_have_received :busy=, [false]
+      task.must_have_received   :done=, [true]
+      repos.must_have_received :<<, [client]
+      repos.must_have_received :<<, [task]
+      repos.must_have_received :<<, [Result.new(addr: addr, client: client,
+        data: 'data', task: task, uuid: anything)]
+    end
+  end
+end end

data/spec/kamerling/registrar_spec.rb

@@ -0,0 +1,16 @@
+require_relative '../spec_helper'
+
+module Kamerling describe Registrar do
+  describe '#register' do
+    fakes :addr, :client, :project, :repo
+
+    it 'registers that the given client can do the given project' do
+      repos = { Client => { client.uuid => client },
+        Project => { project.uuid => project }, Registration => repo }
+      Registrar.new.register addr: addr, client_uuid: client.uuid,
+        project_uuid: project.uuid, repos: repos
+      repo.must_have_received :<<, [Registration.new(addr: addr,
+        client: client, project: project, uuid: anything)]
+    end
+  end
+end end

data/spec/kamerling/repo_spec.rb

@@ -0,0 +1,60 @@
+require_relative '../spec_helper'
+
+module Kamerling describe Repo do
+  Tune = Kamerling.UUIDObject :genre
+
+  describe '#<<' do
+    it 'passes the Hash version of an object to the source' do
+      tune   = Tune.new genre: :chap_hop
+      source = fake Sequel::Dataset
+      mock(source) << { genre: :chap_hop, uuid: tune.uuid }
+      Repo.new(Tune, source) << tune
+    end
+
+    it 'updates the source’s version if it exists there' do
+      dataset = fake Sequel::Dataset
+      source  = fake Sequel::Dataset
+      tune    = Tune.new genre: :chap_hop
+      stub(source).<<(tune.to_h) { raise Sequel::UniqueConstraintViolation }
+      stub(source).where(uuid: tune.uuid) { dataset }
+      Repo.new(Tune, source) << tune
+      dataset.must_have_received :update, [tune.to_h]
+    end
+  end
+
+  describe '#[]' do
+    it 'hydrates the object found in the repo' do
+      uuid   = UUID.new
+      source = { { uuid: uuid } => { genre: :chap_hop, uuid: uuid } }
+      Repo.new(Tune, source)[uuid]
+        .must_equal Tune.new genre: :chap_hop, uuid: uuid
+    end
+
+    it 'raises NotFound if the object is not found in the repo' do
+      -> { Repo.new(Tune, {})[UUID.new] }.must_raise Repo::NotFound
+    end
+  end
+
+  describe '#all' do
+    it 'returns all objects' do
+      tune = Tune.new genre: :chap_hop, uuid: UUID.new
+      source = fake Sequel::Dataset,
+        all: [{ genre: :chap_hop, uuid: tune.uuid }]
+      Repo.new(Tune, source).all.must_equal [tune]
+    end
+  end
+
+  describe '#related_to' do
+    it 'returns objects related to the given object' do
+      tunes   = [Tune.new(genre: :ragga), Tune.new(genre: :reggae)]
+      project = fake :project, uuid: UUID.new
+      results = [
+        { genre: :ragga, uuid: tunes.first.uuid },
+        { genre: :reggae, uuid: tunes.last.uuid },
+      ]
+      source = fake Sequel::Dataset
+      stub(source).where(project_uuid: project.uuid) { results }
+      Repo.new(Tune, source).related_to(project).must_equal tunes
+    end
+  end
+end end