dj2 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 2abcd8f7f5dbd7df21a2cc8f6afbee66ebb88abb
+  data.tar.gz: 5f215f25396609743e4323ffcda13ed87dc4eb6f
+SHA512:
+  metadata.gz: 48ed4c58caed77c642ec2af36090b14d4cede579ab75be28017a05dc39ac7919040d60a4422d6433351c45a75877cfd310e9ad1fc7b0c2707e54be2d40fc4ffd
+  data.tar.gz: f77a310deffca7ec6b71f6746195fbdf608902e7261f1152f2534da558a3f3e5d1701d38829d8a3f10b46287b8399360b53f7836bd875431c3ca15e5109f31e2

data/LICENSE.md

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "{}"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright {yyyy} {name of copyright owner}
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

data/README.md

@@ -0,0 +1,191 @@
+# Docker Jockey
+
+![Jockey](http://i.giphy.com/5iDijZZe6RzYQ.gif)
+
+**All you need is Docker!**
+
+This is a Docker image that will enable you to develop in all your favorite languages and all you need to install is Docker.
+You don't need to install any language runtimes or environment, just run the commands below and it will **just work**.
+
+This image was inspired by [this post about developing with Docker](https://medium.com/iron-io-blog/why-and-how-to-use-docker-for-development-a156c1de3b24).
+
+The following core  can perfpullrm the following functions:
+
+* vendor - vendors your dependencies into a /vendor directory.
+* build - builds your program using the vendored dependencies
+* run - runs your program
+* image - this will build and create a Docker image out of your program
+
+See below for more details on these commands.
+
+## Usage
+
+The usage is the same for all languages, that's the beauty of this!
+
+First, to simplify things, add this to your bashrc:
+
+```
+dj() {
+  docker run --rm -it -v /var/run/docker.sock:/var/run/docker.sock -v "$PWD":/app -v "$HOME":/root -w /app treeder/dj $@
+}
+```
+
+NOTE/WARNING: We use /root above because some things like node and git require it. Also, I tried `"$HOME":/root:ro`, but node requires write privileges on it.
+
+### ALL languages
+
+Replace the language of your choice in the commands below from this list:
+
+* go
+* ruby
+* node
+* php
+* python
+
+Here are the main commands you'll use:
+
+```sh
+# vendor
+dj LANG vendor
+# test
+dj LANG run [script.abc]
+# build Docker image
+dj LANG image username/myapp:latest
+# test image
+docker run --rm -p 8080:8080 username/myapp [script.abc]
+# push image to docker hub
+docker push username/myapp
+# check language version
+dj LANG version
+```
+
+`script.abc` is for interpreted languages, for example: `dj ruby run hello.rb`
+
+### Port mapping
+
+So you can map ports from the Docker containers to your app.
+
+Similar to Docker, use `-p` after `dj`, example:
+
+```sh
+dj -p "8080:8080" ruby run hello.rb
+```
+
+### Environment Variables
+
+Similar to Docker, use `-e` after `dj`, example:
+
+```sh
+dj -e "MYENVVAR=YO" ruby run hello.rb
+```
+
+### Language Specific Commands
+
+#### Go specific commands
+
+```sh
+# build, run already does this, but if you just want to build without running:
+dj go build
+# fmt:
+dj go fmt
+# Build static binary. This is great for making the [tiniest Docker image possible](http://www.iron.io/blog/2015/07/an-easier-way-to-create-tiny-golang-docker-images.html):
+dj go static
+# Cross compile your program into a variety of platforms (based on [this](https://medium.com/iron-io-blog/how-to-cross-compile-go-programs-using-docker-beaa102a316d#95d9):
+dj go cross
+# Build remote repo: this one will produce a binary from a GitHub repo. Equivalent to cloning, vendoring and building
+dj go remote http://github.com/org/project
+```
+
+#### Ruby:
+
+NOTE: You must add `require_relative 'bundle/bundler/setup'` to the start of Ruby program/script.
+
+```sh
+# run
+dj ruby run hello.rb
+# build image - hello.rb on the end is the script to run
+dj ruby image username/rubyapp:latest hello.rb
+```
+
+#### Node:
+
+```sh
+# run npm commands like npm start
+dj node npm start
+```
+
+#### Python:
+
+Nothing special.
+
+#### PHP:
+
+Nothing special.
+
+## Examples with various languages
+
+You can use the code in this repo for examples: https://github.com/iron-io/dockerworker
+
+## Git
+
+Just like git!
+
+```sh
+dj git COMMAND
+```
+
+Authentication? see: http://stackoverflow.com/questions/11403407/git-asks-for-username-everytime-i-push
+
+Can keep your username and password:
+
+```sh
+dj git config --global credential.helper store
+```
+
+
+## To Do
+
+See: https://github.com/treeder/devo/issues
+
+## Troubleshooting
+
+First, enable debugging by adding `-e "LOG_LEVEL=DEBUG"` to your dj docker run command.
+
+## Building Gem
+
+```sh
+bundle install
+```
+
+
+## Building as a Docker image
+
+Vendor gems:
+
+```sh
+docker run --rm -v "$PWD":/worker -w /worker iron/ruby:dev bundle install --standalone --clean
+```
+
+Testing:
+
+```sh
+docker run --rm -it -v /var/run/docker.sock:/var/run/docker.sock -v "$PWD":/app -v "$HOME":/root -w /app -e "LOG_LEVEL=DEBUG" treeder/ruby-dind ruby bin/dj COMMAND
+```
+
+Build image:
+
+```sh
+docker build -t treeder/dj:latest .
+```
+
+Tag it with the version:
+
+```sh
+docker tag treeder/dj:latest treeder/dj:$(cat version.txt)
+```
+
+Push:
+
+```sh
+docker push treeder/dj
+```

data/bin/dj

@@ -0,0 +1,32 @@
+#!/usr/bin/env ruby
+
+require 'dj'
+
+options = OpenStruct.new
+options.env_vars = []
+options.ports = []
+x = OptionParser.new do |opt|
+  opt.banner = "Usage: dj [options] LANG COMMAND [args]"
+  opt.on('-e', '--env ENVVAR', 'An environment variable to pass into container.') { |o|
+    options.env_vars << o
+  }
+  opt.on('-p', '--port PORT', 'Port mapping. Same usage as docker run -p.') { |o|
+    options.ports << o
+  }
+
+  # No argument, shows at tail.  This will print an options summary.
+  # Try it and see!
+  opt.on_tail("-h", "--help", "Show this message") do
+    puts opt
+    exit
+  end
+
+  # Another typical switch to print the version.
+  opt.on_tail("--version", "Show version") do
+    puts DockerJockey::VERSION
+    exit
+  end
+end
+x.order!
+
+DockerJockey.run(ARGV, options)

data/lib/dind.rb

@@ -0,0 +1,27 @@
+# This has helpers for running this inside a container - docker in docker
+module DockerJockey
+
+  # Gets volumes for parent container to be used in sub containers
+  def self.find_volumes
+    @volumes = "-v \"#{Dir.pwd}\":/app"
+    begin
+      puts "inspect: #{`docker inspect`}"
+      di = JSON.parse("#{`docker inspect $HOSTNAME`}")
+      # p di
+      @volumes = "--volumes-from #{di[0]['Name']}"
+      DockerJockey.docker_host = di[0]
+    rescue => ex
+      p ex
+      puts "couldn't inspect"
+    end
+
+    if ARGV.length < 1
+      DockerJockey.logger.fatal "No command provided."
+      exit
+    end
+
+    # DockerJockey.logger.debug "Options: #{options.inspect}"
+
+    DockerJockey.volumes = @volumes
+  end
+end

data/lib/dj.rb

@@ -0,0 +1,82 @@
+# require_relative '../bundle/bundler/setup'
+require 'open3'
+require 'json'
+require 'optparse'
+require 'ostruct'
+require 'docker'
+require 'logger'
+
+require_relative 'version'
+require_relative 'executor'
+require_relative 'image_helper'
+
+require_relative 'langs/ruby_helper'
+require_relative 'langs/node_helper'
+require_relative 'langs/python_helper'
+require_relative 'langs/php_helper'
+require_relative 'langs/go_helper'
+
+require_relative 'utils/git_helper'
+
+module DockerJockey
+  @@docker_host = nil
+  @@volumes = nil
+  @@logger = nil
+
+  def self.docker_host=(x)
+    @@docker_host = x
+  end
+
+  def self.docker_host
+    @@docker_host
+  end
+
+  def self.volumes=(x)
+    @@volumes = x
+  end
+
+  def self.volumes
+    @@volumes
+  end
+  def self.logger
+    @@logger
+  end
+  def self.logger=(x)
+    @@logger = x
+  end
+
+  def self.run(args, options)
+    begin
+      lang = args.shift
+      case lang
+      when 'git'
+        helper = DockerJockey::GitHelper.new
+        helper.run(args, options)
+      when 'go'
+        helper = DockerJockey::GoHelper.new
+        helper.run(args, options)
+      when 'ruby'
+        helper = DockerJockey::RubyHelper.new
+        helper.run(args, options)
+      when 'node'
+        helper = DockerJockey::NodeHelper.new
+        helper.run(args, options)
+      when 'python'
+        helper = DockerJockey::PythonHelper.new
+        helper.run(args, options)
+      when 'php'
+        helper = DockerJockey::PhpHelper.new
+        helper.run(args, options)
+      else
+        puts "ERROR: Language not supported: #{lang}"
+      end
+    # rescue SystemExit, Interrupt => ex
+      # puts "Caught #{ex}"
+    end
+  end
+
+end
+DockerJockey.logger = Logger.new(STDOUT)
+DockerJockey.logger.level = ENV['LOG_LEVEL'] ?  Logger.const_get(ENV['LOG_LEVEL'].upcase) : Logger::INFO
+
+DockerJockey.logger.debug ARGV

data/lib/docker_jockey.rb

@@ -0,0 +1,14 @@
+require_relative 'executor'
+require_relative 'image_helper'
+
+require_relative 'langs/ruby_helper'
+require_relative 'langs/node_helper'
+require_relative 'langs/python_helper'
+require_relative 'langs/php_helper'
+require_relative 'langs/go_helper'
+
+require_relative 'utils/git_helper'
+
+module DockerJockey
+
+end

data/lib/executor.rb

@@ -0,0 +1,165 @@
+
+module DockerJockey
+
+  def self.docker_exec(image, args, options)
+    docker_run(image, args, options)
+  end
+
+  def self.docker_exec_script(image, script, options)
+    # TODO: change this to use docker api, like docker exec
+    # write script and mount inside container
+    File.write('__uberscript__', script)
+    args = "chmod a+x __uberscript__ && ./__uberscript__"
+    docker_run(image, args, options)
+    File.delete('__uberscript__')
+  end
+
+  def self.docker_run(image, args, options=OpenStruct.new)
+    # mounts = DockerJockey.docker_host[]
+    if !image.include? ':'
+      image = image + ":latest" # was getting "No such image" error without this
+    end
+    DockerJockey.logger.debug("docker_exec args: #{args.inspect}")
+    cmd = args.is_a?(String) ? ['sh', '-c', "#{args}"] : args
+    coptions = {
+      'Image' => image,
+      'Cmd' => cmd,
+            # "AttachStdin": true,
+            # "Tty": true,
+      #  "OpenStdin": true,
+      #  "StdinOnce": true,
+      "AttachStdout": true,
+      "AttachStderr": true,
+      # 'Mounts' => mounts,
+      # "Env": [
+              #  "FOO=bar",
+              #  "BAZ=quux"
+      #  ],
+      'WorkingDir' => '/app',
+      'HostConfig' => {},
+    }
+    if DockerJockey.docker_host
+      # Dind version
+      coptions["HostConfig"]['VolumesFrom'] = [DockerJockey.docker_host['Name']]
+      coptions["HostConfig"]['Binds'] = DockerJockey.docker_host['HostConfig']['Binds']
+      # 'PortBindings': DockerJockey.docker_host['HostConfig']['PortBindings'],
+    else
+      coptions['Volumes'] = { '/app' => {} }
+      coptions["HostConfig"]['Binds'] = ["#{Dir.pwd}:/app"]
+    end
+
+    if options.env_vars && options.env_vars.length > 0
+      coptions['Env'] = options.env_vars
+    end
+    if options.ports && options.ports.length > 0
+      # info: http://stackoverflow.com/a/20429133/105562
+      coptions['ExposedPorts'] = {}
+      coptions['HostConfig']['PortBindings'] = {}
+      options.ports.each do |p|
+        psplit = p.split(':')
+        coptions['ExposedPorts']["#{psplit[1]}/tcp"] = {}
+        coptions['HostConfig']['PortBindings']["#{psplit[1]}/tcp"] = [{ "HostPort": "#{psplit[0]}" }]
+      end
+    end
+    # puts "container options:"
+    # p coptions
+    if !Docker::Image.exist?(image)
+      puts "Image #{image} doesn't exist, pulling..."
+      # Pull image to make sure we have it.
+      di = Docker::Image.create('fromImage' => image)
+      # Temporary hack until docker gem updated: https://github.com/swipely/docker-api/issues/369
+      # begin
+      #   Docker::Image.create('fromImage' => image_name) do |info|
+      #     yield info if block_given?
+      #   end
+      # rescue Docker::Error::NotFoundError => e
+      #   # see: https://github.com/swipely/docker-api/issues/369
+      #   # as long as this is not fixed we need to re-check on our own
+      #   # on docker-engines >= 1.10
+      #   if Gem::Version.new(Docker.version['Version']) >= Gem::Version.new('1.10.0')
+      #     Docker::Image.get(image_name)
+      #   else
+      #     raise e
+      #   end
+      # end
+    end
+    # END HACK
+
+    # Now fire it up
+    container = Docker::Container.create(coptions)
+    # Capture ctrl-c
+    Signal.trap("INT") {
+      # Ctrl-C was pressed...
+      puts "Caught interrupt - killing docker child..."
+
+      # Kill child process...
+      # p `docker kill #{cname}`
+      # Process.kill("INT", pid)
+      container.delete(:force=>true)
+      exit 0
+
+      # This prevents the process from becoming defunct
+      # oe.close
+    }
+    container.tap(&:start).streaming_logs(follow:true, stdout: true, stderr: true) { |stream, chunk|
+      # puts "#{stream}: #{chunk}" # for debugging
+      puts chunk
+    }
+    # puts "Deleting container"
+    container.delete(:force => true)
+  end
+
+  def self.popen(maincmd, cname)
+    Open3.popen2e('docker', *(maincmd)) {|i,oe,t|
+      pid = t.pid # pid of the started process.
+      # puts "pid: #{pid}"
+      i.close # ensure this exits when it's done with output
+
+      # Catch interrupts to shut down the docker process too
+      Signal.trap("INT") {
+        # Ctrl-C was pressed...
+        puts "Caught interrupt - killing docker child..."
+
+        # Kill child process...
+        p `docker kill #{cname}`
+        # Process.kill("INT", pid)
+
+        # This prevents the process from becoming defunct
+        # oe.close
+      }
+
+      begin
+        oe.each {|line|
+          if /warning/ =~ line
+            puts 'warning'
+          end
+          puts line
+        }
+      rescue IOError => ex
+        # ignore?  closed stream probably
+      end
+      oe.close
+      exit_status = t.value # Process::Status object returned.
+      # puts "exit_status: #{exit_status}"
+    }
+  end
+
+  def self.exec(cmd, args = [])
+    split = cmd.split(' ')
+    DockerJockey.logger.debug "Exec: #{(split + args).join(' ')}"
+    base = split.shift
+    Open3.popen2e(base, *(split + args)) {|i,oe,t|
+      pid = t.pid # pid of the started process.
+      i.close # ensure this exits when it's done with output
+      oe.each {|line|
+        if /warning/ =~ line
+          puts 'warning'
+        end
+        puts line
+      }
+      exit_status = t.value # Process::Status object returned.
+      # puts "exit_status: #{exit_status}"
+    }
+  end
+
+end

data/lib/image_helper.rb

@@ -0,0 +1,31 @@
+require 'fileutils'
+
+module DockerJockey
+  class ImageHelper
+    def self.build1(from, entry, args)
+      if args.length < 1
+        raise "devo: image command requires image name and filename of script to run."
+      end
+      image_name = args[0]
+      filename = args[1]
+      FileUtils.mkdir_p '/tmp/app'
+      DockerJockey.exec("cp -r . /tmp/app")
+      entrypoint = [entry]
+      entrypoint << filename if filename
+      # exec("cp /scripts/lib/Dockerfile /tmp/app")
+      File.open('/tmp/app/Dockerfile', 'w') { |file|
+        file.write("FROM #{from}
+        WORKDIR /app
+        COPY . /app/
+        ENTRYPOINT [ #{entrypoint.map{ |e| '"' + e + '"'}.join(', ') }  ]
+        ")
+      }
+      # DockerJockey.exec("cat /tmp/app/Dockerfile")
+      # DockerJockey.exec("ls -al /tmp/app")
+      FileUtils.cd('/tmp/app') do
+        DockerJockey.exec("/usr/bin/docker version")
+        DockerJockey.exec("/usr/bin/docker build -t #{image_name} .")
+      end
+    end
+  end
+end

data/lib/langs/go_helper.rb

@@ -0,0 +1,89 @@
+
+module DockerJockey
+  class GoHelper
+
+    attr_accessor :options
+
+    def run(args=[], options)
+      @options = options
+      if args.length < 1
+        raise "devo go: invalid args: #{args.inspect}"
+      end
+      case args[0]
+      when 'get', 'vendor'
+script = script_base() + '
+pwd
+cat api.go
+go get
+cp -r $p/vendor $wd
+chmod -R a+rw $wd/vendor
+' + script_cleanup()
+        # ["-w","/go/src/x/y/z","-e","GOPATH=/go/src/x/y/z/vendor:/go"]
+        DockerJockey.docker_exec_script("iron/go:dev", script, options)
+      when 'build'
+        # todo: use extra params provided by user, eg: #{args.join(' '). But need to parse -o to find output file name to copy
+        build()
+      when 'fmt'
+        DockerJockey.docker_exec("iron/go:dev", "go fmt", options)
+      when 'static'
+        static()
+      when 'run'
+        build()
+        DockerJockey.docker_exec("iron/go", "./app", options)
+      when 'image'
+        DockerJockey::ImageHelper.build1('iron/go', './app', args[1..args.length])
+      when 'version'
+        DockerJockey.docker_exec("iron/go:dev", "go version", options)
+      else
+        raise "Invalid Go command: #{args[0]}"
+      end
+    end
+    def script_base
+      script_base = '
+set -e
+#echo $PWD
+wd=$PWD
+defSrcPath="x/y/z"
+if [ -z "$SRCPATH" ]; then
+  SRCPATH=$defSrcPath
+fi
+#echo "srcpath $SRCPATH ---"
+p=/go/src/$SRCPATH
+mkdir -p $p
+ls -al
+if [ "$(ls -A $wd)" ]
+then
+  # only if files exist, errors otherwise
+  cp -r * $p
+fi
+cd $p
+export GOPATH=$p/vendor:/go
+'
+      script_base
+    end
+    def script_cleanup
+      script_cleanup = '
+rm -rf /go
+'
+      script_cleanup
+    end
+
+    def build()
+      script = script_base() + "
+      go build -o app
+      cp app $wd
+      chmod a+rwx $wd/app
+      " + script_cleanup()
+      DockerJockey.docker_exec_script("iron/go:dev", script, options)
+    end
+
+    def static()
+      script = script_base() + "
+      CGO_ENABLED=0 go build -a --installsuffix cgo --ldflags=\"-s\" -o static
+      cp static $wd
+      chmod a+rwx $wd/static
+      " + script_cleanup()
+      DockerJockey.docker_exec_script("iron/go:dev", script, options)
+    end
+  end
+end

data/lib/langs/node_helper.rb

@@ -0,0 +1,27 @@
+
+module DockerJockey
+  class NodeHelper
+
+    def run(args, options)
+      if args.length < 1
+        raise "devo node: invalid args."
+      end
+      case args[0]
+      when 'run'
+        DockerJockey.docker_exec("iron/node", "node #{args[1]}", options)
+      when 'install', 'vendor'
+        # npm install
+        DockerJockey.docker_exec("iron/node:dev", "npm install", options)
+        DockerJockey.exec("chmod -R a+rw node_modules")
+      when 'npm'
+        DockerJockey.docker_exec("iron/node:dev", "npm #{args[1]}", options)
+      when 'image'
+        DockerJockey::ImageHelper.build1('iron/node', 'node', args[1..args.length])
+      when 'version'
+        DockerJockey.docker_exec("iron/node", "node -v", options)
+      else
+        raise "Invalid node command: #{args[0]}"
+      end
+    end
+  end
+end

data/lib/langs/php_helper.rb

@@ -0,0 +1,27 @@
+
+module DockerJockey
+  class PhpHelper
+
+    def run(args, options)
+      if args.length < 1
+        raise "devo php: invalid args."
+      end
+      case args[0]
+      when 'install', 'vendor'
+        # npm install
+        DockerJockey.docker_exec("iron/php:dev", "composer install", options)
+        DockerJockey.exec("chmod -R a+rw vendor")
+      when 'run'
+        DockerJockey.docker_exec("iron/php", "php #{args[1]}", options)
+      when 'image'
+        DockerJockey::ImageHelper.build1('iron/php', 'php', args[1..args.length])
+      when 'version'
+        DockerJockey.docker_exec("iron/php", "php -v", options)
+      else
+        raise "Invalid php command: #{args[0]}"
+      end
+
+    end
+
+  end
+end

data/lib/langs/python_helper.rb

@@ -0,0 +1,27 @@
+
+module DockerJockey
+  class PythonHelper
+
+    def run(args, options)
+      if args.length < 1
+        raise "devo python: invalid args."
+      end
+      case args[0]
+      when 'install', 'vendor'
+        # npm install
+        DockerJockey.docker_exec("iron/python:2-dev", "pip install -t packages -r requirements.txt", options)
+        DockerJockey.exec("chmod -R a+rw packages")
+      when 'run'
+        DockerJockey.docker_exec("iron/python:2", "python #{args[1]}", options)
+      when 'image'
+        DockerJockey::ImageHelper.build1('iron/python:2', 'python', args[1..args.length])
+      when 'version'
+        DockerJockey.docker_exec("iron/python:2", "python --version".split(' '), options)
+      else
+        raise "Invalid python command: #{args[0]}"
+      end
+
+    end
+
+  end
+end

data/lib/langs/ruby_helper.rb

@@ -0,0 +1,33 @@
+
+module DockerJockey
+  class RubyHelper
+
+    attr_accessor :options
+
+    def run(args=[], options)
+      @options = options
+      if args.length < 1
+        raise "devo ruby: invalid args."
+      end
+      case args[0]
+      when 'bundle', 'vendor'
+        cmd = "install --standalone --clean"
+        if args[1] == "update"
+          cmd = "update"
+        end
+        DockerJockey.docker_exec("iron/ruby:dev", "bundle config --local build.nokogiri --use-system-libraries && bundle #{cmd}", options)
+        DockerJockey.exec("chmod -R a+rw bundle")
+        DockerJockey.exec("chmod -R a+rw .bundle")
+      when 'run'
+        DockerJockey.docker_exec("iron/ruby", "ruby #{args[1]}", options)
+      when 'image'
+        DockerJockey::ImageHelper.build1('iron/ruby', 'ruby', args[1..args.length])
+      when 'version'
+        DockerJockey.docker_exec("iron/ruby", "ruby -v", options)
+      else
+        raise "Invalid ruby command: #{args[0]}"
+      end
+
+    end
+  end
+end

data/lib/utils/git_helper.rb

@@ -0,0 +1,12 @@
+
+module DockerJockey
+  class GitHelper
+
+    def run(args, options)
+      DockerJockey.logger.debug args
+      DockerJockey.logger.debug options
+      # Just passing this along to git
+      DockerJockey.docker_exec("treeder/git", args, options)
+    end
+  end
+end

data/lib/version.rb

@@ -0,0 +1,3 @@
+module DockerJockey
+  VERSION = "0.0.2"
+end

metadata

@@ -0,0 +1,87 @@
+--- !ruby/object:Gem::Specification
+name: dj2
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- Travis Reeder
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2010-04-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: docker-api
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: droplet_kit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: One dev tool to rule them all.
+email: treeder@gmail.com
+executables:
+- dj
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.md
+- README.md
+- bin/dj
+- lib/dind.rb
+- lib/dj.rb
+- lib/docker_jockey.rb
+- lib/executor.rb
+- lib/image_helper.rb
+- lib/langs/go_helper.rb
+- lib/langs/node_helper.rb
+- lib/langs/php_helper.rb
+- lib/langs/python_helper.rb
+- lib/langs/ruby_helper.rb
+- lib/utils/git_helper.rb
+- lib/version.rb
+homepage: https://github.com/treeder/dj
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: Docker Jockey
+test_files: []