pants 0.1.0

data/spec/unit/pants/readers/file_reader_spec.rb

@@ -0,0 +1,94 @@
+require 'spec_helper'
+require 'pants/readers/file_reader'
+
+
+describe Pants::Readers::FileReader do
+  let(:core_stopper_callback) do
+    double "EventMachine.Callback", call: true
+  end
+
+  let(:tick_loop) do
+    tl = double "EventMachine::TickLoop"
+    tl.stub(:on_stop)
+
+    tl
+  end
+
+  before do
+    EventMachine.stub(:tick_loop).and_return(tick_loop)
+    EventMachine::Iterator.stub_chain(:new, :each)
+  end
+
+  subject do
+    Pants::Readers::FileReader.new('some file', core_stopper_callback)
+  end
+
+  describe "#start" do
+    let(:file) { double "File" }
+    let(:starter) { double "EventMachine::Callback starter" }
+    let(:stopper) { double "EventMachine::Callback stopper" }
+
+    before do
+      File.should_receive(:open).and_return(file)
+      subject.should_receive(:starter).and_return(starter)
+      subject.should_receive(:stopper).and_return(stopper)
+    end
+
+    it "defines an EventMachine Callback" do
+      EventMachine.should_receive(:Callback).times.and_yield.and_call_original
+
+      EventMachine.should_receive(:attach) do |arg1, arg2, arg3, arg4, arg5|
+        arg1.should == file
+        arg2.should == Pants::Readers::FileReaderConnection
+        arg3.should be_a EventMachine::Channel
+        arg4.should == starter
+        arg5.should == stopper
+      end
+
+      subject.start
+    end
+  end
+end
+
+describe Pants::Readers::FileReaderConnection do
+  let(:channel) { double "EventMachine::Channel" }
+  let(:starter) { double "EventMachine::Callback starter" }
+  let(:stopper) { double "EventMachine::Callback stopper" }
+
+  subject do
+    Pants::Readers::FileReaderConnection.new(1, channel, starter, stopper)
+  end
+
+  describe "#post_init" do
+    let(:starter) { double "EventMachine::Callback" }
+
+    it "tells the starter that it's started" do
+      starter.should_receive(:call)
+      subject
+    end
+  end
+
+  describe "#receive_data" do
+    let(:data) { "some data" }
+
+    before do
+      Pants::Readers::FileReaderConnection.any_instance.stub(:post_init)
+    end
+
+    it "directly writes it to the channel" do
+      channel.should_receive(:<<).with(data)
+      subject.receive_data(data)
+    end
+  end
+
+  describe "#unbind" do
+    before do
+      Pants::Readers::FileReaderConnection.any_instance.stub(:post_init)
+    end
+
+    it "tells the stopper that it's stopped" do
+      stopper.should_receive(:call)
+      subject.unbind
+    end
+  end
+end

data/spec/unit/pants/version_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+require 'pants/version'
+
+
+describe Pants do
+  specify { Pants::VERSION.should == '0.1.0' }
+end

data/spec/unit/pants/writers/base_writer_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+require 'pants/writers/base_writer'
+
+
+describe Pants::Writers::BaseWriter do
+  let(:channel) { double "EventMachine::Channel" }
+
+  subject do
+    Pants::Writers::BaseWriter.new(channel)
+  end
+
+  describe "#starter" do
+    context "@starter not yet defined" do
+      it "creates a new deferrable that sets @running to true" do
+        subject.should_not be_running
+        subject.starter.call
+        subject.should be_running
+      end
+    end
+  end
+
+  describe "#stopper" do
+    context "@stopper not yet defined and @running is true" do
+      before do
+        subject.instance_variable_set(:@running, true)
+      end
+
+      it "creates a new deferrable that sets @running to false" do
+        subject.should be_running
+        subject.stopper.call
+        subject.should_not be_running
+      end
+    end
+  end
+end

data/spec/unit/pants/writers/file_writer_spec.rb

@@ -0,0 +1,71 @@
+require 'spec_helper'
+require 'pants/writers/file_writer'
+
+
+describe Pants::Writers::FileWriter do
+  let(:channel) { EventMachine::Channel.new }
+
+  subject do
+    Pants::Writers::FileWriter.new(file, channel)
+  end
+
+  describe "#stop" do
+    let(:file) do
+      c = double "File"
+      c.should_receive(:closed?).and_return(false)
+      c.should_receive(:close)
+
+      c
+    end
+
+    let(:stopper) do
+      s = double "EventMachine::Callback"
+      s.should_receive(:call)
+
+      s
+    end
+
+    before do
+      File.stub(:open)
+      subject.instance_variable_set(:@file, file)
+    end
+
+    it "closes the file and calls succeed on the stopper" do
+      subject.should_receive(:stopper).and_return(stopper)
+      subject.stop
+    end
+  end
+
+  describe "#start" do
+    let(:data) do
+      '0' * 100
+    end
+
+    let(:file) do
+      f = double "File"
+      f.should_receive(:write_nonblock).once.with(data).and_return(data.size)
+      f.should_receive(:closed?).and_return(true)
+
+      f
+    end
+
+    let(:tick_loop) do
+      t = double "EventMachine::TickLoop"
+      t.should_receive(:on_stop).and_yield
+
+      t
+    end
+
+    before do
+      File.should_receive(:open).and_return(file)
+    end
+
+    it "subscribes to the channel and writes data as it comes in" do
+      EM.should_receive(:defer).and_yield
+      channel.should_receive(:subscribe).and_yield(data).and_call_original
+      EventMachine.should_receive(:tick_loop).and_yield.and_return(tick_loop)
+
+      subject.start
+    end
+  end
+end

data/spec/unit/pants/writers/udp_writer_spec.rb

@@ -0,0 +1,146 @@
+require 'spec_helper'
+require 'pants/writers/udp_writer'
+
+
+describe Pants::Writers::UDPWriter do
+  let(:channel) { double "EventMachine::Channel" }
+  let(:ip) { '127.0.0.1' }
+  let(:port) { 1234 }
+  before { subject.stub(:log) }
+
+  subject do
+    Pants::Writers::UDPWriter.new(ip, port, channel)
+  end
+
+  describe "#start" do
+    let(:starter) do
+      s = double "EventMachine::Callback"
+      s.should_receive(:call)
+
+      s
+    end
+
+    let(:tick_loop) do
+      t = double "EventMachine::TickLoop"
+      t.should_receive(:on_stop).and_yield
+
+      t
+    end
+
+    before do
+      subject.stub(:starter).and_return(starter)
+    end
+
+    it "opens a datagram socket on 0.0.0.0 then calls succeed on the starter" do
+      EventMachine.should_receive(:defer).and_yield
+      EventMachine.should_receive(:open_datagram_socket).with(
+        '0.0.0.0', 0, Pants::Writers::UDPWriterConnection, channel, ip, port
+      ).and_return(true)
+      EventMachine.should_receive(:tick_loop).and_yield.and_return(tick_loop)
+
+      subject.start
+    end
+  end
+
+  describe "#stop" do
+    let(:connection) do
+      c = double "EventMachine::Connection"
+      c.should_receive(:close_connection_after_writing)
+
+      c
+    end
+
+    let(:stopper) do
+      s = double "EventMachine::Callback"
+      s.should_receive(:call)
+
+      s
+    end
+
+    before do
+      subject.instance_variable_set(:@connection, connection)
+      subject.stub(:stopper).and_return(stopper)
+    end
+
+    it "closes the socket and calls succeed on the stopper" do
+      subject.stop
+    end
+  end
+end
+
+describe Pants::Writers::UDPWriterConnection do
+  let(:channel) { EventMachine::Channel.new }
+  let(:port) { 1234 }
+  let(:ip) { '127.0.0.1' }
+
+  subject do
+    Pants::Writers::UDPWriterConnection.new(1, channel, ip, port)
+  end
+
+  describe "#initialize" do
+    before do
+      Pants::Writers::UDPWriterConnection.any_instance.stub(:post_init)
+    end
+
+    context "multicast IP address" do
+      let(:ip) { '224.0.0.1' }
+
+      it "sets up the socket to do multicast" do
+        Pants::Writers::UDPWriterConnection.any_instance.
+          should_receive(:setup_multicast_socket).with(ip)
+
+        Pants::Writers::UDPWriterConnection.new(0, channel, ip, port)
+      end
+    end
+
+    context "unicast IP address" do
+      let(:ip) { '223.0.0.1' }
+
+      it "does not set up the socket to do multicast" do
+        Pants::Writers::UDPWriterConnection.any_instance.
+          should_not_receive(:setup_multicast_socket)
+
+        Pants::Writers::UDPWriterConnection.new(0, channel, ip, port)
+      end
+    end
+  end
+
+  describe "#post_init" do
+    around(:each) do |example|
+      EM.run do
+        example.run
+        EM.stop
+      end
+    end
+
+    before do
+      channel.should_receive(:subscribe).and_yield(data).and_call_original
+    end
+
+    context "data is bigger than PACKET_SPLIT_THRESHOLD" do
+      let(:data) do
+        "0" * Pants::Writers::UDPWriterConnection::PACKET_SPLIT_THRESHOLD * split_count
+      end
+
+      let(:split_count) { 3 }
+
+      it "splits the data by PACKET_SPLIT_SIZE and sends each chunk" do
+        subject.should_receive(:send_datagram).exactly(split_count + 1).times
+        channel << data
+        subject
+      end
+    end
+
+    context "data is smaller than PACKET_SPLIT_THRESHOLD" do
+      let(:data) do
+        "0" * 100
+      end
+
+      it "sends the data as it is" do
+        subject.should_receive(:send_datagram).once.with(data, ip, port)
+        channel << data
+        subject
+      end
+    end
+  end
+end

data/spec/unit/pants_spec.rb

@@ -0,0 +1,6 @@
+require 'spec_helper'
+require "pants"
+
+
+describe Pants do
+end

data/tasks/pantsmark.thor

@@ -0,0 +1,66 @@
+#!/usr/bin/env ruby
+
+require 'thor'
+require 'benchmark'
+require './lib/pants'
+require 'bundler/setup'
+
+
+class Pantsmark < Thor
+  desc "file_copy [FILE]", "Copies [FILE] --times number of times and benchmarks it"
+  method_option :times, type: :numeric, :default => 100
+  def file_copy(file_path)
+    Benchmark.bm do |x|
+      Pants.log = false
+
+      x.report("\tpants:") do
+        Pants.read(file_path) do |tee|
+          options[:times].times do |i|
+            tee.write_to("pants_test#{i}")
+          end
+        end
+      end
+
+      options[:times].times do |i|
+        result = %x[diff "#{file_path}" pants_test#{i}]
+        puts "Diff result: #{result}" unless result.empty?
+      end
+
+      x.report(" FileUtils.cp:") do
+        threads = []
+
+        options[:times].times do |i|
+          threads << Thread.new do
+            FileUtils.cp('pants_test1', "fu_cp_test#{i}")
+          end
+
+          threads.last.join
+        end
+      end
+
+      x.report("           cp:") do
+        threads = []
+
+        options[:times].times do |i|
+          threads << Thread.new do
+            `cp pants_test1 cp_test#{i}`
+          end
+
+          threads.last.join
+        end
+      end
+    end
+  rescue
+    FileUtils.rm_rf(Dir["./pants_test*"])
+    FileUtils.rm_rf(Dir["./fu_cp_test*"])
+    FileUtils.rm_rf(Dir["./cp_test*"])
+
+    raise
+  ensure
+    FileUtils.rm_rf(Dir["./pants_test*"])
+    FileUtils.rm_rf(Dir["./fu_cp_test*"])
+    FileUtils.rm_rf(Dir["./cp_test*"])
+  end
+end
+
+Pantsmark.start

data/test_readers.rb

@@ -0,0 +1,43 @@
+require_relative './lib/pants'
+
+
+Pants.log = true
+
+#EM.threadpool_size = 200
+#EM.kqueue
+#EM.epoll
+
+orig_file = 'spec/support/pants.wav'
+dest_file = 'dest_test_file'
+#Pants.read('udp://127.0.0.1:1234') do |reader|
+Pants.read(orig_file) do |reader|
+  10.times do |i|
+    reader.add_writer(dest_file)
+    reader.add_writer("udp://127.0.0.1:#{1235 + i}")
+  end
+  reader.add_writer('udp://10.221.222.90:9000')
+end
+
+if defined? orig_file
+  pants_file_size = File.stat(dest_file).size
+  orig_file_size = File.stat(orig_file).size
+  puts "Pants file size: #{pants_file_size}"
+  puts "Original file size: #{orig_file_size}"
+  puts "Difference: #{orig_file_size - pants_file_size}"
+end
+
+#==============
+core = Pants::Core.new
+udp_reader = core.read 'udp://127.0.0.1:1234'
+udp_reader.write_to 'udp://127.0.0.1:1235'
+
+udp_reader2 = core.add_reader(Pants::Readers::UDPReader, '127.0.0.1', 1234)
+udp_reader2.add_writer(Pants::Writers::UDPWriter, '127.0.0.1', 1235)
+
+udp_reader3 = Pants::Readers::UDPReader.new('127.0.0.1', 1234, core.callback)
+udp_writer3 = Pants::Writers::UDPWriter.new('127.0.0.1', 1235, udp_reader3.write_to_channel)
+core.add_reader(udp_reader3)
+udp_reader3.add_writer(udp_writer3)
+
+seam = udp_reader.add_seam(Pants::SimpleSeam)
+seam.write_to 'my_file'