flatware 0.4.0 → 2.0.0.rc1

data/lib/flatware/poller.rb

@@ -1,35 +0,0 @@
-module Flatware
-  class Poller
-    attr_reader :sockets, :zmq_poller
-    def initialize(*sockets)
-      @sockets    = sockets
-      @zmq_poller = ZMQ::Poller.new
-      register_sockets
-    end
-
-    def each(&block)
-      while (result = zmq_poller.poll) != 0
-        raise Error, ZMQ::Util.error_string, caller if result == -1
-        for socket in zmq_poller.readables.map &find_wrapped_socket
-          yield socket
-        end
-      end
-    end
-
-    private
-
-    def find_wrapped_socket
-      ->(s) do
-        sockets.find do |socket|
-          socket.socket == s
-        end
-      end
-    end
-
-    def register_sockets
-      sockets.each do |socket|
-        zmq_poller.register_readable socket.socket
-      end
-    end
-  end
-end

data/lib/flatware/processor_info.rb

@@ -1,24 +0,0 @@
-module Flatware
-  class ProcessorInfo
-    def count
-      case operating_system
-      when 'Darwin'
-        `hostinfo`.match(/^(?<processors>\d+) processors are logically available\.$/)[:processors].to_i
-      when 'Linux'
-        `grep --count '^processor' /proc/cpuinfo`.to_i
-      end
-    end
-
-    def operating_system
-      `uname`.chomp
-    end
-
-    def self.count
-      new.count
-    end
-
-    def self.operating_system
-      new.operating_system
-    end
-  end
-end

data/lib/flatware/rspec.rb

@@ -1,28 +0,0 @@
-require 'rspec/core'
-require 'rspec/expectations'
-require 'flatware/rspec/cli'
-
-module Flatware
-  module RSpec
-    require 'flatware/rspec/formatters/console'
-    require 'flatware/rspec/formatter'
-
-    def self.extract_jobs_from_args(args, workers:)
-
-      options = ::RSpec::Core::ConfigurationOptions.new(args)
-      configuration = ::RSpec::Core::Configuration.new
-      def configuration.command() 'rspec' end
-      options.configure(configuration)
-      configuration.files_to_run.uniq.map do |file|
-        Job.new(file, args)
-      end
-    end
-
-    def self.run(job, options={})
-      runner = ::RSpec::Core::Runner
-      def runner.trap_interrupt() end
-
-      runner.run(%w[--format Flatware::RSpec::Formatter] + Array(job), $stderr, $stdout)
-    end
-  end
-end

data/lib/flatware/rspec/checkpoint.rb

@@ -1,29 +0,0 @@
-require 'flatware/rspec/examples_notification'
-
-module Flatware
-  module RSpec
-    class Checkpoint
-      attr_reader :summary, :failures_notification
-
-      def initialize(summary, failures_notification)
-        @summary, @failures_notification = summary, ExamplesNotification.new(failures_notification.failure_notifications)
-      end
-
-      def +(other)
-        self.class.new summary + other.summary, failures_notification + other.failures_notification
-      end
-
-      def failures?
-        summary.failure_count > 0
-      end
-
-      def failure_notifications
-        failures_notification.failure_notifications
-      end
-
-      def fully_formatted_failed_examples(*args)
-        failures_notification.fully_formatted_failed_examples(*args)
-      end
-    end
-  end
-end

data/lib/flatware/rspec/cli.rb

@@ -1,16 +0,0 @@
-require 'flatware/cli'
-
-module Flatware
-  class CLI
-    worker_option
-    method_option 'dispatch-endpoint', type: :string, default: 'ipc://dispatch'
-    method_option 'sink-endpoint', type: :string, default: 'ipc://task'
-    desc "rspec [FLATWARE_OPTS]", "parallelizes rspec"
-    def rspec(*rspec_args)
-      jobs = RSpec.extract_jobs_from_args rspec_args, workers: workers
-      Flatware.verbose = options[:log]
-      Worker.spawn count: workers, runner: RSpec, dispatch: options['dispatch-endpoint'], sink: options['sink-endpoint']
-      start_sink jobs: jobs, workers: workers, formatter: Flatware::RSpec::Formatters::Console.new($stdout, $stderr)
-    end
-  end
-end

data/lib/flatware/rspec/example_notification.rb

@@ -1,21 +0,0 @@
-require 'rspec/core/formatters/console_codes'
-
-module Flatware
-  module RSpec
-    class ExampleNotification
-      attr_reader :formatted
-      def initialize(notification)
-        @formatted = notification.fully_formatted '!', default_colorizer
-      end
-
-      def fully_formatted(i, _=nil)
-        formatted.sub '!', i.to_s
-      end
-
-      private
-      def default_colorizer
-        ::RSpec::Core::Formatters::ConsoleCodes
-      end
-    end
-  end
-end

data/lib/flatware/rspec/examples_notification.rb

@@ -1,24 +0,0 @@
-require 'flatware/rspec/example_notification'
-module Flatware
-  module RSpec
-    class ExamplesNotification
-      attr_reader :failure_notifications
-
-      def initialize(failure_notifications)
-        @failure_notifications = failure_notifications.map(&ExampleNotification.method(:new))
-      end
-
-      def +(other)
-        self.class.new failure_notifications + other.failure_notifications
-      end
-
-      def fully_formatted_failed_examples(*)
-        formatted = "\n\nFailures:\n"
-        failure_notifications.each_with_index do |failure, index|
-          formatted << failure.fully_formatted(index.next)
-        end
-        formatted
-      end
-    end
-  end
-end

data/lib/flatware/rspec/formatter.rb

@@ -1,50 +0,0 @@
-require 'flatware/rspec/checkpoint'
-require 'flatware/rspec/summary'
-require 'rspec/core/formatters/console_codes'
-
-module Flatware
-  module RSpec
-    ProgressMessage = Struct.new(:progress)
-
-    class Formatter
-      attr_reader :summary, :output
-
-      def initialize(stdout)
-        @output = stdout
-      end
-
-      def example_passed(example)
-        send_progress :passed
-      end
-
-      def example_failed(example)
-        send_progress :failed
-      end
-
-      def example_pending(example)
-        send_progress :pending
-      end
-
-      def dump_summary(summary)
-        @summary = Summary.from_notification(summary)
-      end
-
-      def dump_failures(failure_notification)
-        @failure_notification = failure_notification
-      end
-
-      def close(*)
-        Sink::client.checkpoint Checkpoint.new(summary, @failure_notification)
-        @failure_notification = nil
-      end
-
-      private
-
-      def send_progress(status)
-        Sink::client.progress ProgressMessage.new status
-      end
-    end
-
-    ::RSpec::Core::Formatters.register Formatter, :example_passed, :example_failed, :example_pending, :dump_summary, :dump_failures, :close
-  end
-end

data/lib/flatware/rspec/formatters/console.rb

@@ -1,33 +0,0 @@
-module Flatware::RSpec::Formatters
-  class Console
-    attr_reader :formatter
-
-    def initialize(out, err)
-      ::RSpec::configuration.tty = true
-      ::RSpec::configuration.color = true
-      @formatter = ::RSpec::Core::Formatters::ProgressFormatter.new(out)
-    end
-
-    def progress(result)
-      formatter.send(message_for(result),nil)
-    end
-
-    def summarize(checkpoints)
-      result = checkpoints.reduce :+
-      if result
-        formatter.dump_failures result
-        formatter.dump_summary result.summary
-      end
-    end
-
-    private
-
-    def message_for(result)
-      {
-        passed:  :example_passed,
-        failed:  :example_failed,
-        pending: :example_pending
-      }.fetch result.progress
-    end
-  end
-end

data/lib/flatware/rspec/summary.rb

@@ -1,40 +0,0 @@
-require 'rspec/core/notifications'
-module Flatware
-  module RSpec
-    Summary = Struct.new(:duration, :examples, :failed_examples, :pending_examples, :load_time)
-
-    class Example
-      attr_reader :location_rerun_argument, :full_description
-      def initialize(rspec_example)
-        @full_description        = rspec_example.full_description
-        @location_rerun_argument = rspec_example.location_rerun_argument
-      end
-    end
-
-    class Summary
-      def +(other)
-        self.class.new duration + other.duration,
-          examples + other.examples,
-          failed_examples + other.failed_examples,
-          pending_examples + other.pending_examples,
-          load_time + other.load_time
-      end
-
-      def fully_formatted
-        ::RSpec::Core::Notifications::SummaryNotification.new(duration, examples, failed_examples, pending_examples, load_time).fully_formatted
-      end
-
-      def failure_count
-        failed_examples.size
-      end
-
-      def self.from_notification(summary)
-        serialized_examples = [summary.examples, summary.failed_examples, summary.pending_examples].map do |examples|
-          examples.map(&Example.method(:new))
-        end
-
-        new summary.duration, *serialized_examples, summary.load_time
-      end
-    end
-  end
-end

data/lib/flatware/socket.rb

@@ -1,181 +0,0 @@
-require 'ffi-rzmq'
-require 'securerandom'
-require 'logger'
-
-module Flatware
-  Error = Class.new StandardError
-
-  Job = Struct.new :id, :args do
-    attr_accessor :worker
-    attr_writer :failed
-
-    def failed?
-      !!@failed
-    end
-  end
-
-  extend self
-
-  def logger
-    @logger ||= Logger.new($stderr)
-  end
-
-  def logger=(logger)
-    @logger = logger
-  end
-
-  def socket(*args)
-    context.socket(*args)
-  end
-
-  def close(force: false)
-    @ignore_errors = true if force
-    context.close(force: force)
-    @context = nil
-  end
-
-  def close!
-    close force: true
-  end
-
-  def socket_error
-    raise(Error, ZMQ::Util.error_string, caller) unless @ignore_errors
-  end
-
-  def log(*message)
-    if Exception === message.first
-      logger.error message.first
-    elsif verbose?
-      logger.info ([$0] + message).join(' ')
-    end
-    message
-  end
-
-  attr_writer :verbose
-  def verbose?
-    !!@verbose
-  end
-
-  def context
-    @context ||= begin
-                   @ignore_errors = nil
-                   Context.new
-                 end
-  end
-
-  class Context
-    attr_reader :sockets, :c
-
-    def initialize
-      @c = ZMQ::Context.new
-      @sockets = []
-    end
-
-    def socket(zmq_type, options={})
-      Socket.new(c.socket(zmq_type)).tap do |socket|
-        sockets.push socket
-        if port = options[:connect]
-          socket.connect port
-        end
-        if port = options[:bind]
-          socket.bind port
-        end
-      end
-    end
-
-    def close(force: false)
-      sockets.each do |socket|
-        socket.setsockopt ZMQ::LINGER, 0
-      end if force
-      sockets.each(&:close)
-      Flatware::socket_error unless c.terminate == 0
-      Flatware.log "terminated context"
-    end
-  end
-
-  class Socket
-    attr_reader :socket
-
-    def initialize(socket)
-      @socket = socket
-    end
-
-    def setsockopt(*args)
-      socket.setsockopt(*args)
-    end
-
-    def name
-      socket.name
-    end
-
-    def send(message)
-      result = socket.send_string(Marshal.dump(message))
-      Flatware::socket_error if result == -1
-      Flatware.log "#@type #@port send #{message}"
-      message
-    end
-
-    def connect(port)
-      @type = 'connected'
-      @port = port
-      Flatware::socket_error unless socket.connect(port) == 0
-      Flatware.log "connect #@port"
-    end
-
-    def monitor
-      name = "inproc://monitor#{SecureRandom.hex(10)}"
-      LibZMQ.zmq_socket_monitor(socket.socket, name, ZMQ::EVENT_ALL)
-      Monitor.new(name)
-    end
-
-    class Monitor
-      def initialize(port)
-        @socket = Flatware.socket ZMQ::PAIR
-        @socket.connect port
-      end
-
-      def recv
-        bytes = @socket.recv marshal: false
-        data = LibZMQ::EventData.new FFI::MemoryPointer.from_string bytes
-        event[data.event]
-      end
-
-      private
-
-      def event
-        ZMQ.constants.select do |c|
-          c.to_s =~ /^EVENT/
-        end.map do |s|
-          {s => ZMQ.const_get(s)}
-        end.reduce(:merge).invert
-      end
-    end
-
-    def bind(port)
-      @type = 'bound'
-      @port = port
-      Flatware::socket_error unless socket.bind(port) == 0
-      Flatware.log "bind #@port"
-    end
-
-    def close
-      Flatware::socket_error unless socket.close == 0
-      Flatware.log "close #@type #@port"
-    end
-
-    def recv(block: true, marshal: true)
-      message = ''
-      if block
-       result = socket.recv_string(message)
-       Flatware::socket_error if result == -1
-      else
-        socket.recv_string(message, ZMQ::NOBLOCK)
-      end
-      if message != '' and marshal
-        message = Marshal.load(message)
-      end
-      Flatware.log "#@type #@port recv #{message}"
-      message
-    end
-  end
-end