ng 0.0.1

data/.gitignore

@@ -0,0 +1,19 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+log
+test.rb

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in ng.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,23 @@
+Copyright (c) 2012 Ryan Taylor Long
+
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,29 @@
+# ng - Pure-Ruby Nailgun client port
+
+Eliminates the need to shell-out when using Nailgun
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'ng'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install ng
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"

data/lib/nailgun/client/chunk.rb

@@ -0,0 +1,25 @@
+module Nailgun
+  class Client
+    class Chunk
+      attr_reader :content, :type
+
+      def initialize(type, content)
+        @content = content.to_s
+        @type = type
+      end
+
+      def header
+        ChunkHeader.new(type, length)
+      end
+
+      def length
+        content.length
+      end
+
+      def to_s
+        header.to_s + content
+      end
+
+    end
+  end
+end

data/lib/nailgun/client/chunk_header.rb

@@ -0,0 +1,18 @@
+module Nailgun
+  class Client
+    class ChunkHeader
+      def initialize(type, content_length)
+        @type = Nailgun::CHUNK_TYPES[type]
+        @content_length = content_length
+      end
+
+      def to_a
+        [@content_length, @type]
+      end
+
+      def to_s
+        to_a.pack('NA')
+      end
+    end
+  end
+end

data/lib/nailgun/client.rb

@@ -0,0 +1,194 @@
+require_relative 'client/chunk'
+require_relative 'client/chunk_header'
+require 'socket'
+require 'io/wait'
+require 'logger'
+require 'timeout'
+
+module Nailgun
+  class Client
+    LOGGER = Logger.new('log')
+
+    attr_reader :opts, :socket
+
+    # Public: Convinience method to instantiate and run the command
+    #
+    # command - see #run
+    # args - see #run
+    # opts = {} -  see #initialize
+    #
+    # Returns the duplicated String.
+    def self.run(command, args, opts = {})
+      self.new(opts).run(command, args)
+    end
+
+    # Public: Initialize a Client.
+    #
+    # opts = {} - a Hash of options to override the defaults in Nailgun::DEFAULTS
+    def initialize(opts = {})
+      @opts = Nailgun::DEFAULTS.merge(opts)
+      @socket = TCPSocket.new(*@opts.values_at(:hostname, :port))
+      debug "Opened new #{@socket.inspect}"
+    end
+
+    # Public: Run a command on the Client instance
+    #
+    # command - the command string
+    # *args - any arguments to send
+    def run(command, *args)
+      receive_loop # start the loop
+
+      send_args     args.flatten
+      send_env      opts[:env]
+      send_dir      opts[:dir]
+      send_command  command
+      send_stdin    opts[:stdin]
+
+      receive_loop.join
+      return nil
+    end
+
+    # Public: Start the receiver loop Thread, memoize it, and return the Thread
+    #
+    # Returns the Thread object, whose value will eventually be the exit status from the Nailgun
+    # server
+    def receive_loop
+      @loop ||= Thread.new {
+        catch(:exit) do
+          loop { receive_chunk }
+        end
+      }
+    end
+
+    private
+
+    # Private: Send the argument chunks
+    #
+    # *args - an Array of the arguments to send
+    def send_args(*args)
+      args.flatten.each do |arg|
+        send_chunk :arg, arg
+      end
+    end
+
+    # Private: Send the environment vars.
+    #
+    # env - a Hash in the format of Ruby's ENV constant
+    def send_env(env)
+      env.each do |var|
+        send_chunk :env, var.join(?=)
+      end
+    end
+
+    # Private: Send the working directory
+    #
+    # dir - the working directory
+    def send_dir(dir)
+      send_chunk :dir, dir.to_s
+    end
+
+    # Private: Send the command to be run
+    #
+    # command - the Nail command (usually a Java class name)
+    def send_command(command)
+      send_chunk :cmd, command
+    end
+
+    # Private: Send the STDIN stream for the Nail to read from.
+    #
+    # io = nil - an IO of the stdin stream to send.
+    def send_stdin(io = nil)
+      unless io.nil?
+        begin
+          send_chunk :stdin, io.read(2048)
+        end until io.eof?
+        io.close
+      end
+      send_chunk :stdin_eof
+    end
+
+    # Private: Send a chunk. Used by the higher-level methods
+    #
+    # type - the chunk type
+    # content = nil - the actual content
+    def send_chunk(type, content = nil)
+      chunk = Chunk.new(type, content).to_s
+      debug "Sending #{type} chunk: #{content.inspect}"
+      socket.write chunk
+    end
+
+    # Private: get the next chunk from the socket, and then determine what to do with it.
+    def receive_chunk
+      Timeout.timeout(Nailgun::TIMEOUT, Nailgun::TimeoutError) do
+        length, type = receive_header
+        if length == 0
+          debug "Received #{type} chunk with no content"
+        else
+          debug "About to read #{type} chunk (#{length} B). Content follows (until <<<< END CHUNK >>>>) "
+
+          content = socket.read(length)
+
+          LOGGER << (content + "<<<< END CHUNK >>>>\n")
+        end
+
+        handle_chunk(type, content)
+      end
+    end
+
+    # Private: Block while waiting for a header for the next chunk
+    #
+    # Returns [length, type]
+    def receive_header
+      socket.read(Nailgun::CHUNK_HEADER_LEN).unpack('NA')
+    end
+
+    # Private: Determine what to do with the received chunk
+    #
+    # type - chunk type
+    # content - chunk content
+    def handle_chunk(type, content)
+      case t = Nailgun::CHUNK_TYPES.key(type)
+      when :stdout, :stderr
+        opts[t].write content
+      when :exit
+        socket.close
+        handle_exit(content.to_i)
+      else
+        raise Nailgun::UnexpectedChunktypeError.new([type, content].join(?;))
+      end
+    end
+
+    def handle_exit(code)
+      if code == 0
+        throw :exit
+      elsif ex = Nailgun::EXIT_CODE_EXCEPTIONS[code]
+        raise ex.new
+      else
+        raise Nailgun::OtherError.new(code.to_s)
+      end
+    end
+
+    # Private: Debug log message
+    def debug(message)
+      LOGGER.debug(message)
+    end
+
+    # Extend the return value with a success? method akin to Process::Status, which I can't figure
+    # out how to instantiate manually
+    class ExitStatus
+      def initialize(value)
+        @val = value
+      end
+      def success?
+        @val == 0
+      end
+      def method_missing(*args)
+        @val.send(*args)
+      end
+      def inspect
+        @val.inspect
+      end
+    end
+
+  end
+end

data/lib/nailgun/version.rb

@@ -0,0 +1,3 @@
+module Nailgun
+  VERSION = '0.0.1'
+end

data/lib/nailgun.rb

@@ -0,0 +1,49 @@
+require_relative 'nailgun/version'
+require_relative 'nailgun/client'
+
+module Nailgun
+
+  DEFAULTS = {
+    hostname:  'localhost',
+    port:      2113,
+    stdin:     nil,
+    stdout:    STDOUT,
+    stderr:    STDERR,
+    env:       ENV,
+    dir:       Dir.pwd
+  }.freeze
+
+  CHUNK_HEADER_LEN = 5
+
+  TIMEOUT = 5
+
+  TimeoutError             = Class.new(StandardError)
+  SocketFailedError        = Class.new(StandardError)
+  ConnectFailedError       = Class.new(StandardError)
+  UnexpectedChunktypeError = Class.new(StandardError)
+  ServerExceptionError     = Class.new(StandardError)
+  ConnectionBrokenError    = Class.new(StandardError)
+  BadArgumentsError        = Class.new(StandardError)
+  OtherError               = Class.new(StandardError)
+
+  EXIT_CODE_EXCEPTIONS = {
+    999 => SocketFailedError,
+    998 => ConnectFailedError,
+    997 => UnexpectedChunktypeError,
+    996 => ServerExceptionError,
+    995 => ConnectionBrokenError,
+    994 => BadArgumentsError
+  }.freeze
+
+  CHUNK_TYPES = {
+    stdin:     '0',
+    stdout:    '1',
+    stderr:    '2',
+    stdin_eof: '.',
+    arg:       'A',
+    env:       'E',
+    dir:       'D',
+    cmd:       'C',
+    exit:      'X'
+  }.freeze
+end

data/ng.gemspec

@@ -0,0 +1,17 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/nailgun/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ['Ryan Taylor Long']
+  gem.email         = ['ryan@rtlong.com']
+  gem.description   = %q{Pure-Ruby Nailgun client port}
+  gem.summary       = %q{Eliminates the need to shell-out when using Nailgun}
+  gem.homepage      = ''
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = 'ng'
+  gem.require_paths = ['lib']
+  gem.version       = Nailgun::VERSION
+end

metadata

@@ -0,0 +1,57 @@
+--- !ruby/object:Gem::Specification
+name: ng
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Ryan Taylor Long
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-10-18 00:00:00.000000000 Z
+dependencies: []
+description: Pure-Ruby Nailgun client port
+email:
+- ryan@rtlong.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/nailgun.rb
+- lib/nailgun/client.rb
+- lib/nailgun/client/chunk.rb
+- lib/nailgun/client/chunk_header.rb
+- lib/nailgun/version.rb
+- ng.gemspec
+homepage: ''
+licenses: []
+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
+signing_key: 
+specification_version: 3
+summary: Eliminates the need to shell-out when using Nailgun
+test_files: []
+has_rdoc: