docker_toolkit 0.1.2 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c9065c8bb330bb661236077890a09b9e29231a7962ac51c907a5ad734bd952d5
-  data.tar.gz: 290f4cb58b9dbea44f6e409f624911ca9f0c661468fa937484ad151d788f82ef
+  metadata.gz: 37e19e4995dbe0cc868b51fdae6fc18b69d26e12c85a68b8364113e19b7efdf8
+  data.tar.gz: 243fb2286022970786e1cdde0bffafacf35f6d5b9dd33fb9c1f1ea1b433e5626
 SHA512:
-  metadata.gz: abb75dc06309b0b09ea590e0e4e1bf444d9c546695ab68706cb84694355ea655ce4405243d1eaf11617123243dd64406a26c3ae02a3a8419fef073bc2ac80717
-  data.tar.gz: 5ae23825dbd86459d5a2e117e46ff8e15bec266077be420ce69dd5efde75d4b0ab65e92fa91fbe9e9d4e71519bc59dc5fca0fa5117b8bc8f1280b4c11a80c420
+  metadata.gz: 0553be938e83e0d9359181234499cf1cb10cf0fe0152eab1d29c8bd33f805810da1a8eb67bc0dd0e302cacd73a1eaa02f023c82827b66cc92efc5f7e21a91d20
+  data.tar.gz: 38a0e77028d94411d4da7ceccf40a34f8b2fa87f4147842e95cbc0340b211733af572e8e817d8f4ec281557d83f80db5cf53917fd9a2b9837744916bfe61a628

data/.travis.yml

@@ -1,3 +1,4 @@
+
 language: ruby
 rvm:
   - 2.0
@@ -8,8 +9,16 @@ services:
   
 stage: test
 
+before_install:
+  - sudo apt-get install -y libxml2-dev unzip curl
+  
 script:
-  - cd docker && ./run_tests.sh
+  - gem build `ls | grep gemspec`
+  - gem install `ls | grep -e '.gem$'`
+  - curl -sSLo /tmp/consul.zip https://releases.hashicorp.com/consul/1.2.1/consul_1.2.1_linux_amd64.zip 
+  - sudo unzip -d /bin /tmp/consul.zip 
+  - bundle exec rspec
+
 
 jobs:
   include:

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    docker_toolkit (0.1.2)
+    docker_toolkit (0.1.3)
       diplomat
       json
 

data/bin/terminator.rb

@@ -0,0 +1,56 @@
+#!/usr/bin/env ruby
+require 'optparse'
+require 'English'
+
+STDOUT.sync = true
+STDERR.sync = true
+
+@opts = {
+  code: 0,
+  sleep: 1,
+  term_code: 0
+}
+
+parser = OptionParser.new do |o|
+  o.banner = 'Usage: term.rb [options]'
+
+  o.on("--exit code=#{@opts[:code]}", 'set exit code') do |code|
+    @opts[:code] = code.to_i
+  end
+
+  o.on("--sleep sec=#{@opts[:sleep]}", 'Sleep before exit') do |sec|
+    @opts[:sleep] = sec.to_i
+  end
+
+  o.on('--term', 'SIGTERM self') do
+    @opts[:term] = true
+  end
+
+  o.on("--term-code=#{@opts[:term_code]}", 'exit code when SIGTERM catched') do |code|
+    @opts[:term_code] = code.to_i
+  end
+
+  o.on('--kill', 'SIGKILL self') do
+    @opts[:kill] = true
+  end
+
+end
+parser.parse!
+
+def log msg
+  puts "[terminator]: #{msg}"
+end
+
+
+%w[INT TERM].each do |sig|
+  trap(sig) do
+    exit(@opts[:term_code])
+  end
+end 
+
+sleep @opts[:sleep]
+
+::Process.kill('KILL', $$) if @opts[:kill]
+::Process.kill('TERM', $$) if @opts[:term]
+
+exit @opts[:code]

data/docker/Dockerfile

@@ -1,4 +1,4 @@
-FROM ruby:2.5.0-alpine
+FROM mayok/alpine-ruby
 MAINTAINER Firmhouse "kinnalru@gmail.com"
 
 WORKDIR /home/app
@@ -46,6 +46,9 @@ RUN set -ex \
   
 ADD . /home/app
 
+RUN set -ex \
+  && gem build `ls | grep gemspec` \
+  && gem install `ls | grep -e '.gem$'`
 
 
 SHELL ["/bin/sh", "-c", "-l"]

data/docker_toolkit.gemspec

@@ -5,6 +5,7 @@ require 'docker_toolkit/version'
 Gem::Specification.new do |spec|
   spec.name          = 'docker_toolkit'
   spec.version       = DockerToolkit::VERSION
+  spec.license       = 'MIT'
   spec.authors       = ['Godko Ivan', 'Samoilenko Yuri']
   spec.email         = ['igodko@rnds.pro', 'kinnalru@gmail.com']
   spec.homepage      = 'https://github.com/RnD-Soft/docker_toolkit'

data/lib/docker_toolkit/childprocess/abstract_io.rb

@@ -0,0 +1,38 @@
+module DockerToolkit
+module ChildProcess
+  class AbstractIO
+    attr_reader :stderr, :stdout, :stdin
+
+    def inherit!
+      @stdout = STDOUT
+      @stderr = STDERR
+    end
+
+    def stderr=(io)
+      check_type io
+      @stderr = io
+    end
+
+    def stdout=(io)
+      check_type io
+      @stdout = io
+    end
+
+    #
+    # @api private
+    #
+
+    def _stdin=(io)
+      check_type io
+      @stdin = io
+    end
+
+    private
+
+    def check_type(io)
+      raise SubclassResponsibility, "check_type"
+    end
+
+  end
+end
+end

data/lib/docker_toolkit/childprocess/abstract_process.rb

@@ -0,0 +1,194 @@
+module DockerToolkit
+module ChildProcess
+  class AbstractProcess
+    POLL_INTERVAL = 0.1
+
+    attr_reader :exit_code
+
+    #
+    # Set this to true if you do not care about when or if the process quits.
+    #
+    attr_accessor :detach
+
+    #
+    # Set this to true if you want to write to the process' stdin (process.io.stdin)
+    #
+    attr_accessor :duplex
+
+    #
+    # Modify the child's environment variables
+    #
+    attr_reader :environment
+
+    #
+    # Set the child's current working directory.
+    #
+    attr_accessor :cwd
+
+    #
+    # Set this to true to make the child process the leader of a new process group
+    #
+    # This can be used to make sure that all grandchildren are killed
+    # when the child process dies.
+    #
+    attr_accessor :leader
+
+    #
+    # Create a new process with the given args.
+    #
+    # @api private
+    # @see ChildProcess.build
+    #
+
+    def initialize(args)
+      unless args.all? { |e| e.kind_of?(String) }
+        raise ArgumentError, "all arguments must be String: #{args.inspect}"
+      end
+
+      @args        = args
+      @started     = false
+      @exit_code   = nil
+      @io          = nil
+      @cwd         = nil
+      @detach      = false
+      @duplex      = false
+      @leader      = false
+      @environment = {}
+    end
+
+    #
+    # Returns a ChildProcess::AbstractIO subclass to configure the child's IO streams.
+    #
+
+    def io
+      raise SubclassResponsibility, "io"
+    end
+
+    #
+    # @return [Integer] the pid of the process after it has started
+    #
+
+    def pid
+      raise SubclassResponsibility, "pid"
+    end
+
+    #
+    # Launch the child process
+    #
+    # @return [AbstractProcess] self
+    #
+
+    def start
+      launch_process
+      @started = true
+
+      self
+    end
+
+    #
+    # Forcibly terminate the process, using increasingly harsher methods if possible.
+    #
+    # @param [Integer] timeout (3) Seconds to wait before trying the next method.
+    #
+
+    def stop(timeout = 3)
+      raise SubclassResponsibility, "stop"
+    end
+
+    #
+    # Block until the process has been terminated.
+    #
+    # @return [Integer] The exit status of the process
+    #
+
+    def wait
+      raise SubclassResponsibility, "wait"
+    end
+
+    #
+    # Did the process exit?
+    #
+    # @return [Boolean]
+    #
+
+    def exited?
+      raise SubclassResponsibility, "exited?"
+    end
+
+    #
+    # Has the process started?
+    #
+    # @return [Boolean]
+    #
+
+    def started?
+      @started
+    end
+
+    #
+    # Is this process running?
+    #
+    # @return [Boolean]
+    #
+
+    def alive?
+      started? && !exited?
+    end
+
+    #
+    # Returns true if the process has exited and the exit code was not 0.
+    #
+    # @return [Boolean]
+    #
+
+    def crashed?
+      exited? && @exit_code != 0
+    end
+
+    #
+    # Wait for the process to exit, raising a ChildProcess::TimeoutError if
+    # the timeout expires.
+    #
+
+    def poll_for_exit(timeout)
+      log "polling #{timeout} seconds for exit"
+
+      end_time = Time.now + timeout
+      until (ok = exited?) || Time.now > end_time
+        sleep POLL_INTERVAL
+      end
+
+      unless ok
+        raise TimeoutError, "process still alive after #{timeout} seconds"
+      end
+    end
+
+    private
+
+    def launch_process
+      raise SubclassResponsibility, "launch_process"
+    end
+
+    def detach?
+      @detach
+    end
+
+    def duplex?
+      @duplex
+    end
+
+    def leader?
+      @leader
+    end
+
+    def log(*args)
+      ChildProcess.logger.debug "#{self.inspect} : #{args.inspect}"
+    end
+
+    def assert_started
+      raise Error, "process not started" unless started?
+    end
+
+  end # AbstractProcess
+end # ChildProcess
+end

data/lib/docker_toolkit/childprocess/errors.rb

@@ -0,0 +1,28 @@
+module DockerToolkit
+module ChildProcess
+  class Error < StandardError
+  end
+
+  class TimeoutError < Error
+  end
+
+  class SubclassResponsibility < Error
+  end
+
+  class InvalidEnvironmentVariable < Error
+  end
+
+  class LaunchError < Error
+  end
+
+  class MissingPlatformError < Error
+    def initialize
+      message = "posix_spawn is not yet supported on #{ChildProcess.platform_name} (#{RUBY_PLATFORM}), falling back to default implementation. " +
+                "If you believe this is an error, please file a bug at http://github.com/enkessler/childprocess/issues"
+
+      super(message)
+    end
+
+  end
+end
+end

data/lib/docker_toolkit/childprocess/jruby/io.rb

@@ -0,0 +1,17 @@
+module DockerToolkit
+module ChildProcess
+  module JRuby
+    class IO < AbstractIO
+      private
+
+      def check_type(output)
+        unless output.respond_to?(:to_outputstream) && output.respond_to?(:write)
+          raise ArgumentError, "expected #{output.inspect} to respond to :to_outputstream"
+        end
+      end
+
+    end # IO
+  end # Unix
+end # ChildProcess
+end
+

data/lib/docker_toolkit/childprocess/jruby/process.rb

@@ -0,0 +1,161 @@
+require "java"
+
+module DockerToolkit
+module ChildProcess
+  module JRuby
+    class Process < AbstractProcess
+      def initialize(args)
+        super(args)
+
+        @pumps = []
+      end
+
+      def io
+        @io ||= JRuby::IO.new
+      end
+
+      def exited?
+        return true if @exit_code
+
+        assert_started
+        @exit_code = @process.exitValue
+        stop_pumps
+
+        true
+      rescue java.lang.IllegalThreadStateException => ex
+        log(ex.class => ex.message)
+        false
+      ensure
+        log(:exit_code => @exit_code)
+      end
+
+      def stop(timeout = nil)
+        assert_started
+
+        @process.destroy
+        wait # no way to actually use the timeout here..
+      end
+
+      def wait
+        if exited?
+          exit_code
+        else
+          @process.waitFor
+
+          stop_pumps
+          @exit_code = @process.exitValue
+        end
+      end
+
+      #
+      # Only supported in JRuby on a Unix operating system, thanks to limitations
+      # in Java's classes
+      #
+      # @return [Integer] the pid of the process after it has started
+      # @raise [NotImplementedError] when trying to access pid on non-Unix platform
+      #
+      def pid
+        if @process.getClass.getName != "java.lang.UNIXProcess"
+          raise NotImplementedError, "pid is only supported by JRuby child processes on Unix"
+        end
+
+        # About the best way we can do this is with a nasty reflection-based impl
+        # Thanks to Martijn Courteaux
+        # http://stackoverflow.com/questions/2950338/how-can-i-kill-a-linux-process-in-java-with-sigkill-process-destroy-does-sigter/2951193#2951193
+        field = @process.getClass.getDeclaredField("pid")
+        field.accessible = true
+        field.get(@process)
+      end
+
+      private
+
+      def launch_process(&blk)
+        pb = java.lang.ProcessBuilder.new(@args)
+
+        pb.directory java.io.File.new(@cwd || Dir.pwd)
+        set_env pb.environment
+
+        begin
+          @process = pb.start
+        rescue java.io.IOException => ex
+          raise LaunchError, ex.message
+        end
+
+        setup_io
+      end
+
+      def setup_io
+        if @io
+          redirect(@process.getErrorStream, @io.stderr)
+          redirect(@process.getInputStream, @io.stdout)
+        else
+          @process.getErrorStream.close
+          @process.getInputStream.close
+        end
+
+        if duplex?
+          io._stdin = create_stdin
+        else
+          @process.getOutputStream.close
+        end
+      end
+
+      def redirect(input, output)
+        if output.nil?
+          input.close
+          return
+        end
+
+        @pumps << Pump.new(input, output.to_outputstream).run
+      end
+
+      def stop_pumps
+        @pumps.each { |pump| pump.stop }
+      end
+
+      def set_env(env)
+        merged = ENV.to_hash
+
+        @environment.each { |k, v| merged[k.to_s] = v }
+
+        merged.each do |k, v|
+          if v
+            env.put(k, v.to_s)
+          elsif env.has_key? k
+            env.remove(k)
+          end
+        end
+
+        removed_keys = env.key_set.to_a - merged.keys
+        removed_keys.each { |k| env.remove(k) }
+      end
+
+      def create_stdin
+        output_stream = @process.getOutputStream
+
+        stdin = output_stream.to_io
+        stdin.sync = true
+        stdin.instance_variable_set(:@childprocess_java_stream, output_stream)
+
+        class << stdin
+          # The stream provided is a BufferedeOutputStream, so we
+          # have to flush it to make the bytes flow to the process
+          def __childprocess_flush__
+            @childprocess_java_stream.flush
+          end
+
+          [:flush, :print, :printf, :putc, :puts, :write, :write_nonblock].each do |m|
+            define_method(m) do |*args|
+              super(*args)
+              self.__childprocess_flush__
+            end
+          end
+        end
+
+        stdin
+      end
+
+    end # Process
+  end # JRuby
+end # ChildProcess
+end

data/lib/docker_toolkit/childprocess/jruby/pump.rb

@@ -0,0 +1,55 @@
+module DockerToolkit
+module ChildProcess
+  module JRuby
+    class Pump
+      BUFFER_SIZE = 2048
+
+      def initialize(input, output)
+        @input  = input
+        @output = output
+        @stop   = false
+      end
+
+      def stop
+        @stop = true
+        @thread && @thread.join
+      end
+
+      def run
+        @thread = Thread.new { pump }
+
+        self
+      end
+
+      private
+
+      def pump
+        buffer = Java.byte[BUFFER_SIZE].new
+
+        until @stop && (@input.available == 0)
+          read, avail = 0, 0
+
+          while read != -1
+            avail = [@input.available, 1].max
+            avail = BUFFER_SIZE if avail > BUFFER_SIZE
+            read = @input.read(buffer, 0, avail)
+
+            if read > 0
+              @output.write(buffer, 0, read)
+              @output.flush
+            end
+          end
+
+          sleep 0.1
+        end
+
+        @output.flush
+      rescue java.io.IOException => ex
+        ChildProcess.logger.debug ex.message
+        ChildProcess.logger.debug ex.backtrace
+      end
+
+    end # Pump
+  end # JRuby
+end # ChildProcess
+end

data/lib/docker_toolkit/childprocess/jruby.rb

@@ -0,0 +1,58 @@
+require 'java'
+require 'jruby'
+
+class Java::SunNioCh::FileChannelImpl
+  field_reader :fd
+end
+
+class Java::JavaIo::FileDescriptor
+  if ChildProcess.os == :windows
+    field_reader :handle
+  end
+
+  field_reader :fd
+end
+
+module DockerToolkit
+module ChildProcess
+  module JRuby
+    def self.posix_fileno_for(obj)
+      channel = ::JRuby.reference(obj).channel
+      begin
+        channel.getFDVal
+      rescue NoMethodError
+        fileno = channel.fd
+        if fileno.kind_of?(Java::JavaIo::FileDescriptor)
+          fileno = fileno.fd
+        end
+
+        fileno == -1 ? obj.fileno : fileno
+      end
+    rescue
+      # fall back
+      obj.fileno
+    end
+
+    def self.windows_handle_for(obj)
+      channel = ::JRuby.reference(obj).channel
+      fileno = obj.fileno
+
+      begin
+        fileno = channel.getFDVal
+      rescue NoMethodError
+        fileno = channel.fd if channel.respond_to?(:fd)
+      end
+
+      if fileno.kind_of? Java::JavaIo::FileDescriptor
+        fileno.handle
+      else
+        Windows::Lib.handle_for fileno
+      end
+    end
+  end
+end
+end
+
+require "docker_toolkit/childprocess/jruby/pump"
+require "docker_toolkit/childprocess/jruby/io"
+require "docker_toolkit/childprocess/jruby/process"