masyo 0.0.1 → 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ae12169befcce209c36fdc9159fd4a40a68dbc63
+  data.tar.gz: 2245f2c03c5ed7aaadb8aafa6deb3d53a829d469
+SHA512:
+  metadata.gz: b29e9d59053d5460a1ed347896ceb8c12e3b9aaa6cdeebcab3806620b7b450b1f1c477aac22b8acd6cf8b5b4c4a7caa57467e9f60190ef2a945391e719e1c4e1
+  data.tar.gz: bf8c1af6efbceec09099b08096616b4ac7ba7ec278219c56854160ed7abeac5cb5f25667bdc450d6eaed1a78af7ad505bb8dce5e0571d0e0ab684bc0261ad208

data/README.md

@@ -3,10 +3,14 @@
 ## Description
 Casual TCP Proxy
 
+## Install
+
+```sh
+$ gem install masyo
+```
+
 ## Usage
 
 ```sh
-$ cd /path-to-masyo
-$ bundle install --path=vendor/bundles
-$ bundle exec ruby bin/masyo -listen_port #{LISTEN_PORT} --server_host #{PROXY_TARGET_HOST} --server_port #{PROXY_TARGET_PORT}
+$ masyo -h
 ```

data/bin/masyo

@@ -5,10 +5,10 @@ require "slop"
 argv = ARGV.dup
 slop = Slop.new(:strict => true, :help => true)
 slop.banner "$ bundle exec ruby bin/masyo [options]\n"
-slop.on :b, :buffer_size=, "buffer byte size(default is 0)"
 slop.on :listen_port=, "listen port (default is 2000)"
 slop.on :server_host=, "target server host (default is \"0.0.0.0\")"
 slop.on :server_port=, "target server port (default is 24224)"
+slop.on :v, :version, "show masyo version"
 
 begin
   slop.parse!(argv)
@@ -16,18 +16,25 @@ rescue => e
   puts e
   exit!
 end
+
 options = slop.to_hash
+
 unless options[:help]
   options.delete(:help)
   options[:listen_port] = (options[:listen_port] || 2000).to_i
   options[:server_host] ||= "0.0.0.0"
   options[:server_port] = (options[:server_port] || 24224).to_i
-  options[:buffer_size] = (options[:buffer_size] || 0).to_i
 
   root = File.expand_path("../..", __FILE__)
   $LOAD_PATH.unshift root
   $LOAD_PATH.unshift File.join(root, 'lib')
 
   require "masyo"
+
+  if options[:version]
+    puts Masyo::VERSION
+    exit
+  end
+
   Masyo.run options
 end

data/lib/masyo.rb

@@ -4,38 +4,15 @@ require 'logger'
 require 'forwardable'
 
 require 'masyo/version'
-require 'masyo/server'
-require 'masyo/client'
-require 'masyo/buffer'
+require 'masyo/proxy'
 require 'extentions/tcp_socket'
 
 module Masyo
   extend self
 
   def run(opts = {})
-    opts = {
-      listen_port: 2000,
-      server_host: "0.0.0.0",
-      server_port: 24224 ,
-      buffer_size: 0
-    }.merge(opts)
     Thread.abort_on_exception = true
-
-    buffer = Buffer.new opts[:buffer_size]
-    client = Client.new(opts[:server_host], opts[:server_port], buffer)
-    Server.open(opts[:listen_port]) do |server|
-      logger.info "listen #{opts[:listen_port]} port."
-
-      server.on_read do |msg|
-        client.post msg
-      end
-
-      server.on_close {
-        client.post buffer.take!
-      }
-
-      server.start
-    end
+    Proxy.run(opts[:listen_port], opts[:server_host], opts[:server_port])
   end
 
   def logger

data/lib/masyo/proxy.rb

@@ -0,0 +1,83 @@
+# -*- coding: utf-8 -*-
+
+require 'socket'
+
+module Masyo
+  class Proxy
+    attr_accessor :proxy
+    TIMEOUT = 3
+    MAX_RECV_LEN = 1 * 1024 * 1024 * 1024
+
+    class << self
+      def run(listen_port, server_host, server_port)
+        p = new(listen_port, server_host, server_port)
+        p.run
+      rescue Interrupt
+        Masyo.logger.info "Stopping..."
+        # for sending buffer to receiver before socket close.
+        p.stop
+      end
+    end
+
+    def initialize(listen_port, server_host, server_port)
+      Masyo.logger.info "Proxy 0.0.0.0:#{listen_port} -> #{server_host}:#{server_port}"
+
+      @server_host = server_host
+      @server_port = server_port
+      @proxy = ::TCPServer.new(listen_port)
+    end
+
+    def run
+      loop {
+        break if proxy.closed?
+
+        Thread.start(proxy.accept) do |client|
+          handle client
+        end
+      }
+    end
+
+    def stop
+      proxy.close unless proxy.closed?
+    end
+
+    def handle client
+      input = receive_from client
+      response = request input
+      client.write response unless response.nil?
+    ensure
+      client.close unless client.closed?
+    end
+
+    def request msg
+      ::TCPSocket.open(@server_host, @server_port) { |socket|
+        socket.write msg
+
+        receive_from socket
+      }
+    rescue Errno::ECONNREFUSED
+      Masyo.logger.error "Fail to request to server"
+      nil
+    end
+
+    private
+
+    def receive_from socket
+      loop {
+        begin
+          s = socket.recv_nonblock(MAX_RECV_LEN)
+        rescue ::IO::WaitReadable
+          if ::IO.select([ socket ], nil, nil, TIMEOUT)
+            retry
+          else
+            # timeout!
+            break
+          end
+        else
+          break if !s || s == "" || s == "quit"
+          return s
+        end
+      }
+    end
+  end
+end

data/lib/masyo/version.rb

@@ -1,3 +1,3 @@
 module Masyo
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/spec/masyo/proxy_spec.rb

@@ -0,0 +1,26 @@
+# -*- coding: utf-8 -*-
+
+require 'spec_helper'
+
+describe Masyo::Proxy do
+  describe 'request' do
+    context 'when fail to connect to server' do
+      before do
+        ::TCPSocket.stub(:open).and_raise(Errno::ECONNREFUSED)
+        ::TCPServer.stub(:new)
+      end
+
+      let(:generate_proxy) do
+        proc { described_class.new(7777, "0.0.0.0", 7779) }
+      end
+
+      it 'log error' do
+        Masyo.logger.should_receive(:error).with("Fail to request to server")
+        generate_proxy.call.request('msg')
+      end
+      it 'return nil' do
+        expect(generate_proxy.call.request('msg')).to eq(nil)
+      end
+    end
+  end
+end

data/spec/masyo_spec.rb

@@ -5,19 +5,12 @@ require 'spec_helper'
 describe Masyo do
   describe "#run" do
     before :each do
-      Masyo::Buffer.stub(:new)
-      Masyo::Client.stub(:new)
-      Masyo::Server.stub(:open)
-    end
-
-    it "should set Thread.abort_on_exception = true" do
-      Thread.should_receive(:abort_on_exception=).with(true)
-      described_class.run
+      Masyo::Proxy.stub(:run)
     end
 
     it "should call Server.open with port" do
-      Masyo::Server.should_receive(:open).with(kind_of(Numeric))
-      described_class.run
+      Masyo::Proxy.should_receive(:run).with(7777, "0.0.0.0", 7779)
+      described_class.run(listen_port: 7777, server_host: "0.0.0.0", server_port: 7779)
     end
   end
 

metadata

@@ -1,30 +1,27 @@
 --- !ruby/object:Gem::Specification
 name: masyo
 version: !ruby/object:Gem::Version
-  version: 0.0.1
-  prerelease: 
+  version: 0.0.2
 platform: ruby
 authors:
 - Takatoshi Matsumoto
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-12-06 00:00:00.000000000 Z
+date: 2013-09-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: slop
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 description: simple tcp proxy server written in ruby
@@ -46,49 +43,40 @@ files:
 - bin/masyo
 - lib/extentions/tcp_socket.rb
 - lib/masyo.rb
-- lib/masyo/buffer.rb
-- lib/masyo/client.rb
-- lib/masyo/event.rb
-- lib/masyo/server.rb
+- lib/masyo/proxy.rb
 - lib/masyo/version.rb
 - masyo.gemspec
 - sample.god
-- spec/masyo/buffer_spec.rb
-- spec/masyo/client_spec.rb
-- spec/masyo/event_spec.rb
-- spec/masyo/server_spec.rb
+- spec/masyo/proxy_spec.rb
 - spec/masyo_spec.rb
 - spec/spec_helper.rb
 - tmp/.gitkeep
 - vendor/bundles/.gitkeep
 homepage: https://github.com/ToQoz/Masyo
 licenses: []
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.23
+rubygems_version: 2.0.2
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: masyo
 test_files:
-- spec/masyo/buffer_spec.rb
-- spec/masyo/client_spec.rb
-- spec/masyo/event_spec.rb
-- spec/masyo/server_spec.rb
+- spec/masyo/proxy_spec.rb
 - spec/masyo_spec.rb
 - spec/spec_helper.rb
+has_rdoc: 

data/lib/masyo/buffer.rb

@@ -1,33 +0,0 @@
-# -*- coding: utf-8 -*-
-
-module Masyo
-  class BufferOverflowException < StandardError; end
-
-  class Buffer
-    attr_accessor :maxlen, :buffer
-
-    def initialize(maxlen = 0)
-      @maxlen = maxlen
-      @buffer = ""
-    end
-
-    def take!
-      b = buffer
-      clear!
-      b
-    end
-
-    def push(str)
-      if buffer.bytesize + str.bytesize <= maxlen
-        self.buffer += str
-      else
-        raise BufferOverflowException
-      end
-    end
-    alias_method :<<, :push
-
-    def clear!
-      self.buffer = ""
-    end
-  end
-end

data/lib/masyo/client.rb

@@ -1,50 +0,0 @@
-# -*- coding: utf-8 -*-
-
-require 'socket'
-
-module Masyo
-  class Client
-    def initialize(host, port, buffer)
-      @host = host
-      @port = port
-      @buffer = buffer
-
-      if buffer.maxlen > 0
-        extend BufferedClient 
-      else
-        extend PlainClient 
-      end
-    end
-
-    extend ::Forwardable
-    def_delegators :Masyo, :logger
-  end
-
-  module PlainClient
-    def post(msg)
-      ::TCPSocket.open(@host, @port) { |socket|
-        socket.write msg
-      }
-    end
-  end
-
-  module BufferedClient
-    def post(msg)
-      ::TCPSocket.open(@host, @port) { |socket|
-        begin
-          buffer << msg
-        rescue BufferOverflowException
-          # clear buffer
-          socket.write buffer.take!
-          begin
-            buffer << msg
-          rescue BufferOverflowException
-            # post without using buffer
-            #
-            socket.write msg
-          end
-        end
-      }
-    end
-  end
-end

data/lib/masyo/event.rb

@@ -1,29 +0,0 @@
-# -*- coding: utf-8 -*-
-
-module Masyo
-  module Event
-
-    def self.included(base)
-      base.event_types.each do |e|
-        base.class_eval {
-          define_method("on_#{e}") do |&handler|
-            events[e] ||= []
-            events[e] << handler
-          end
-        }
-      end
-    end
-
-    def events
-      @events ||= {}
-    end
-
-    def trigger_event(name, *arg)
-      if events[name]
-        events[name].each do |f|
-          f.call *arg
-        end
-      end
-    end
-  end
-end

data/lib/masyo/server.rb

@@ -1,73 +0,0 @@
-# -*- coding: utf-8 -*-
-
-require 'socket'
-require 'masyo/event'
-
-module Masyo
-  class Server
-    attr_accessor :tcp_server, :socket_to_client
-    TO_CLIENT_SOCKET_TIMEOUT = 3
-
-    class << self
-      def event_types
-        [ :read, :close ]
-      end
-
-      def open(*args)
-        raise ArgumentError, "wrong number of arguments (#{args.size} for 1..2)" if args.size <= 0 || args.size >= 2
-
-        server = new(args.first)
-        return server unless block_given?
-        begin
-          yield server
-        ensure
-          # for sending buffer to server before socket close.
-          server.trigger_event :close
-          server.close unless server.closed?
-        end
-      end
-    end
-
-    include Event
-
-    def initialize(port)
-      raise ArgumentError, "#{port} is not a Integer" unless port.is_a? Integer
-      @tcp_server = ::TCPServer.new(port)
-    end
-
-    def start
-      loop {
-        Thread.start(tcp_server.accept) do |to_client|
-          handle_request to_client
-        end
-      }
-    end
-
-    def handle_request(to_client)
-      begin
-        loop {
-          begin
-            input = to_client.recv_nonblock(2048)
-          rescue ::IO::WaitReadable
-            if ::IO.select([ to_client ], nil, nil, TO_CLIENT_SOCKET_TIMEOUT)
-              retry
-            else
-              # timeout!
-              break
-            end
-          else
-            break if !input || input == "" || input == "quit"
-
-            trigger_event :read, input
-          end
-        }
-      ensure
-        to_client.close_immediately unless to_client.closed?
-      end
-    end
-
-    extend ::Forwardable
-    def_delegators :tcp_server, :close, :closed?
-    def_delegators :Masyo, :logger
-  end
-end

data/spec/masyo/buffer_spec.rb

@@ -1,54 +0,0 @@
-# -*- coding: utf-8 -*-
-
-require 'spec_helper'
-
-describe Masyo::Buffer do
-  let (:instance) { described_class.new 100 }
-
-  describe '#initialize' do
-    context 'when given a number for args' do
-      it 'should set it to maxlen' do
-        described_class.new(100).maxlen.should eq(100)
-      end
-    end
-    context 'when given none for args' do
-      it 'should set 0 to maxlen' do
-        described_class.new.maxlen.should eq(0)
-      end
-    end
-  end
-
-  describe '#clear!' do
-    it 'should clear buffer' do
-      instance.buffer = "toqoz.should be_cool."
-      instance.clear!
-      instance.buffer.should eq("")
-
-    end
-  end
-
-  describe '#take!' do
-    it 'should return buffer and clear buffer' do
-      instance.buffer = "toqoz.should be_cool."
-      instance.take!.should eq("toqoz.should be_cool.")
-      instance.buffer.should eq("")
-    end
-  end
-
-  describe '#push' do
-    context 'when given string `don\'t` over buffer' do
-      it 'should add string as buffer' do
-        str = Array.new(100, "a").join("")
-        instance.push str
-        instance.buffer.should eq(str)
-      end
-    end
-    context 'when given string over buffer' do
-      it 'raise error' do
-        proc {
-          instance.push Array.new(101, "a").join("")
-        }.should raise_error(Masyo::BufferOverflowException)
-      end
-    end
-  end
-end

data/spec/masyo/client_spec.rb

@@ -1,36 +0,0 @@
-# -*- coding: utf-8 -*-
-
-require 'spec_helper'
-
-describe Masyo::Client do
-  describe '#initialize' do
-    let(:buffered_client) {
-      buffer = double(maxlen: 100)
-      described_class.new("0.0.0.0", 8080, buffer)
-    }
-    let(:plain_client) {
-      buffer = double(maxlen: 0)
-      described_class.new("0.0.0.0", 8080, buffer)
-    }
-
-    context 'when buffer_size > 0' do
-      it 'should use BufferedClient#post as #post' do
-        buffered_client.method("post").owner.should eq(Masyo::BufferedClient)
-      end
-    end
-
-    context 'when buffer_size == 0' do
-      it 'should use PlainClient#post as #post' do
-        plain_client.method("post").owner.should eq(Masyo::PlainClient)
-      end
-    end
-  end
-  
-  describe '#post' do
-    let (:instance) { described_class.new("0.0.0.0", 8212, double(maxlen: 10)) }
-    it 'should call TCPSocket.open' do
-      TCPSocket.should_receive(:open).with(kind_of(String), kind_of(Numeric))
-      instance.post("dummy message")
-    end
-  end
-end

data/spec/masyo/event_spec.rb

@@ -1,65 +0,0 @@
-# -*- coding: utf-8 -*-
-
-require 'spec_helper'
-
-describe Masyo::Event do
-  let(:instance) do
-    mod = described_class
-    Class.new {
-      class << self
-        def event_types
-          [ :xxx ]
-        end
-      end
-
-      include mod
-    }.new
-  end
-
-  describe '.included' do
-    context 'when included' do
-      it 'define methods for event_types(return by base class methods)' do
-        instance.respond_to?(:on_xxx).should be_true
-      end
-    end
-  end
-
-  describe '#on_*' do
-    describe '#on_xxx' do
-      it 'should store given block as event callback' do
-        callback = proc {}
-        instance.on_xxx(&callback)
-        instance.events.should eq({ xxx: [ callback ] })
-      end
-    end
-    context '#on_invalid_event' do
-      it 'should `not` store given block as event callback' do
-        proc {
-          callback = proc {}
-          instance.on_invalid_event(&callback)
-        }.should raise_error(NoMethodError)
-
-        instance.events.should eq({})
-      end
-    end
-  end
-
-  describe '#trigger_event' do
-    context 'when given exist event anme' do
-      it 'should trigger all event for #{name}(first args)' do
-        callback = proc {}
-        callback.should_receive(:call)
-        instance.on_xxx(&callback)
-        instance.trigger_event :xxx
-      end
-    end
-    context 'when given `not` exist event anme' do
-      it 'should not trigger all event for #{name}(first args)' do
-        callback = proc {}
-        callback.should_not_receive(:call)
-        instance.on_invalid_event(&callback) rescue
-        instance.trigger_event :invalid_event
-      end
-    end
-  end
-end

data/spec/masyo/server_spec.rb

@@ -1,87 +0,0 @@
-# -*- coding: utf-8 -*-
-
-require 'spec_helper'
-
-describe Masyo::Server do
-  let (:instance) { described_class.new(8183) }
-  let (:logger) { double(info: true, error: true) }
-
-  after(:each) do
-    instance.close
-  end
-
-  describe '.open' do
-    context 'when given over 2 args' do
-      it 'should recieve ArgumentError' do
-        proc { described_class.open(8183, "hoge", "foo") }.should raise_error(ArgumentError)
-      end
-    end
-    context 'when given non-number value as first arg' do
-      it 'should recieve ArgumentError' do
-        proc { described_class.open("9090") }.should raise_error(ArgumentError)
-      end
-    end
-  end
-
-  describe '#initialize' do
-    it 'store ::TCPServer as instance variable' do
-      instance.tcp_server.is_a?(::TCPServer).should be_true
-    end
-  end
-
-  describe '#handle_request' do
-    let (:socket) { double(close_immediately: nil, closed?: false) }
-
-    context 'when BasicSocket#recv_nonblock raise IO::WaitReadable' do
-      before :each do
-        socket.stub(:recv_nonblock).and_raise(StandardError.new.extend(IO::WaitReadable))
-      end
-
-      it 'should call IO.select.' do
-        IO.should_receive(:select).
-          with([ socket ], nil, nil, described_class::TO_CLIENT_SOCKET_TIMEOUT).
-          and_return(false)
-        instance.handle_request(socket)
-      end
-    end
-
-    context "when BasicSocket#recv_nonblock don't raise IO::WaitReadable" do
-      let (:input) { "dummy_input" }
-
-      before :each do
-        socket.stub(:recv_nonblock).and_return(input, "")
-      end
-
-      context 'and when input is not false, nil, "", "quit"' do
-        it 'should call trigger_event with :read as first arg, and input as second arg' do
-          instance.should_receive(:trigger_event).with(:read, input)
-          proc {
-            instance.handle_request(socket)
-          }.should_not raise_error
-        end
-      end
-    end
-
-    context 'when raise Exception except IO::WaitReadable' do
-      it 'should close socket and not catch Exceptions.' do
-        socket.stub(:recv_nonblock).and_raise(StandardError)
-        socket.should_receive(:close_immediately)
-
-        proc {
-          instance.handle_request(socket)
-        }.should raise_error(StandardError)
-      end
-    end
-  end
-end
-
-describe ::TCPServer do
-  describe '#close_immediately' do
-    it 'should receive setsockopt with relavant options and close' do
-      socket = described_class.new(8183)
-      socket.should_receive(:setsockopt).with(Socket::SOL_SOCKET, Socket::SO_LINGER, [1,0].pack('ii'))
-      socket.should_receive(:close)
-      socket.close_immediately
-    end
-  end
-end