docker-dev 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b790b0f51b1657492a1aa2ab4f6528f6b3d2ab48
+  data.tar.gz: a8a10e13b6483b0b41f7a8cc87f61e68807e616f
+SHA512:
+  metadata.gz: 38f16ae99fcc1296a1768d2b6f34be5b17996e481dace95dfbdcbdc5aa5e2959c95548292c77ebad000905a23ec8a78089d35d399c1b5022016417fdb4d0b1c6
+  data.tar.gz: c16ed1806dc1b618c3744acba0455695a46e560b50563fb1bcfa1a44e2b0cb9a6719bae1ddb7c2d9cdb09e9add7e5c85b6d9631d53f8a00d354ed8aeb4ffbe98

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 John Hager
+
+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,19 @@
+###To Build an App
+_This should be done everytime you change the Gemfile or do something
+that would force you to restart the Rails Sever_
+```
+rake docker:build /path/to/app
+```
+
+###To Run an App
+_After the app has be built, you can run it with:_
+```
+rake docker:run /path/to/app
+```
+
+###To Stop all Running Containers and then Remove all Containers
+_Be careful, because this will remove all your Docker Containers,
+not just the ones run from the commands above_
+```
+rake docker:cleanup
+```

data/helpers.rake

@@ -0,0 +1,33 @@
+require_relative 'lib/docker'
+
+include Docker::Helpers
+
+def get_args(num_args)
+  # See this link for explanation of this black magic:
+  # http://itshouldbeuseful.wordpress.com/2011/11/07/passing-parameters-to-a-rake-task/
+  args = ARGV.last(num_args)
+  yield(args)
+  args.each { |arg| task arg.to_sym {} }
+end
+
+def build_docker_app_image(type, app_path)
+  full_path_and_name(app_path) do |path, name|
+    `docker build -t jphager2/#{type}-#{name} #{path}`
+  end
+end
+
+# You Can't overwrite rake tasks (yet)
+# Paths Can't be relative (try to source them)
+namespace :docker do
+  desc "Stop all running docker containers and then remove them"
+  task :cleanup do
+    Docker.containers.each { |c| c.remove! }
+  end
+
+  desc "Remove all nameless docker images (repositories, tags)"
+  task :nameless do
+    Docker.images(:repository).select {|r| r.id == "<none>"}.each do |r|
+      r.remove_image!
+    end
+  end
+end

data/lib/docker/container.rb

@@ -0,0 +1,114 @@
+module Docker
+  class Container
+    include Docker::Equality
+
+    attr_reader :id, :removal_instructions
+    def initialize(id)
+      @id = Docker::ID(id) 
+    end
+
+    def self.run(image, flags = "", command = "", path = nil)
+      path  = Docker::PATH(path)
+      flags = "#{flags} -e DOCKER_TYPE=#{self}"
+      flags = "#{flags} -e LOCAL_PATH=#{path.path}" if path
+
+      id = Docker::ID(`docker run #{flags} #{image} #{command}`)
+
+      # Nasty hack to return a removed container if the --rm flag
+      # is passed and the container alread exited
+      return new(nil).disable! unless id || flags !~ /--rm/
+
+      id ||= Docker.containers(:stopped).first.id
+
+      new(id) 
+    end
+
+    def self.load_from(container)
+      new(container.id) if container.from_a?(self)
+    end
+
+    def logs
+      @logs || `docker logs #{id}` # @logs given with #disable!
+    end
+
+    def inspekt
+      Docker.inspekt(id)
+    end
+
+    def to_klass
+      return self unless klass = from_klass
+      klass.load_from(self)
+    end
+
+    def from_klass
+      return nil unless klass = env["DOCKER_TYPE"]
+      Kernel.const_get(klass)
+    end
+
+    def path
+      Docker::PATH(env["LOCAL_PATH"])
+    end
+
+    def add_removal_instructions(&block)
+      @removal_instructions = Proc.new { block.call(self) }
+      self
+    end
+
+    def attach!
+      `docker attach --sig-proxy=false #{id}`
+    end
+
+    def remove!
+      @logs = logs
+      @removal_instructions.call if @removal_instructions
+      `docker rm -f #{id}`
+      disable!
+      id
+    end
+
+    def disable!
+      self.instance_eval { 
+        undef :attach!
+        undef :remove!
+        undef :add_removal_instructions
+      }
+      self.instance_eval { def state; @id; end } 
+      @id   = 'REMOVED'
+      self
+    end
+
+    def from_a?(klass)
+      env["DOCKER_TYPE"] == klass.to_s
+    end
+
+    def removed?
+      id == "REMOVED"
+    end
+
+    def exists_in?(state)
+      Docker.containers(state).any?  { |container| container == self }
+    end
+
+    def up?; running?; end
+    def ip; ip_address; end
+    alias_method :to_s, :id
+
+    def method_missing(method, *args, &block)
+      super if removed?
+      inspekt_methods = [:env, :state, :ports, :ip_address, :name]
+      state_methods   = [:running? , :stopped?, :paused?]
+      action_methods  = [:stop!, :start!, :restart!, :pause!, :unpause!]
+      if inspekt_methods.include?(method)
+        inspekt.__send__(method) 
+      elsif state_methods.include?(method)
+        method = method.to_s.delete('?').to_sym
+        exists_in?(method) 
+      elsif action_methods.include?(method)
+        method = method.to_s.delete('!').to_sym
+        `docker #{method} #{id}`
+      else
+        super
+      end
+    end
+  end
+end

data/lib/docker/equality.rb

@@ -0,0 +1,11 @@
+module Docker
+  module Equality
+    def ==(other)
+      # this seems unconfident, but it is because I want to be able
+      # to create containers with shortened ID's (for now)
+      min = [id.length, other.id.length].min
+      id[0...min] == other.id[0...min] 
+    end
+  end
+end
+

data/lib/docker/helpers.rb

@@ -0,0 +1,12 @@
+module Docker
+  module Helpers
+
+    def rails_image(name)
+      "#{USER_NAME}/rails-#{name}"
+    end
+
+    def rails_server(name)
+      "rails-server-#{name}"
+    end
+  end
+end

data/lib/docker/id.rb

@@ -0,0 +1,33 @@
+module Docker
+  class Id
+    def self.create(id)
+      id = new(id)
+      id.id.empty? ? nil : id
+    end
+
+    attr_reader :id
+    def initialize(id)
+      @id = id.to_s[0..11]
+      validate!
+    end
+
+    alias_method :to_s, :id
+    alias_method :to_str, :id
+
+    def validate!
+      valid = id.length >= 12 && 
+        id =~ /^[0-9a-z]+$/ && id !~ /^[^0-9a-z]$/ &&
+        id =~/[0-9]/ && id =~ /[a-z]/
+      valid ? id : (@id = '')
+    end
+
+    def method_missing(method, *args, &block)
+      if id.respond_to?(method)
+        id.__send__(method, *args, &block)
+      else
+        super
+      end
+    end
+  end
+end
+

data/lib/docker/image.rb

@@ -0,0 +1,38 @@
+module Docker
+  class Image
+    extend Docker::Helpers
+    extend Docker::Equality
+
+    attr_reader :id
+    def initialize(id)
+      @id = id[0..11]
+    end
+
+    def self.build(path, name)
+      name = "#{Docker::USER_NAME}/#{name}" 
+      repo, tag = name.split(':')
+      id = `docker build -t #{name} #{path}`[-13..-2]
+      tag ? Tag.new(repo, tag) : Repository.new(id, repo)
+    end
+
+    def remove!
+      `docker rmi #{id}`
+    end
+
+    def inspekt
+      Docker.inspekt(id)
+    end
+
+    def image_id
+      id
+    end
+
+    def to_s
+      id
+    end
+
+    def repositories 
+      Docker.images.select { |repo| repo == self }
+    end
+  end
+end

data/lib/docker/inspect.rb

@@ -0,0 +1,45 @@
+require 'json'
+
+module Docker
+  class Inspect
+
+    attr_reader :inspekt
+    def initialize(id)
+      @id = id[0..11]
+      @inspekt = JSON.load(`docker inspect #{@id}`).first
+    end
+
+    def name
+      inspekt["Name"][1..-1]
+    end
+    
+    def env
+      inspekt["Config"]["Env"].each_with_object({}) do |e,h| 
+        pair = e.split('=') 
+        h[pair.first] = pair.last
+      end
+    end
+
+    def ip_address
+      inspekt["NetworkSettings"]["IPAddress"]
+    end
+
+    def ports
+      inspekt["NetworkSettings"]["Ports"]
+    end
+
+    def state 
+      inspekt["State"]
+    end
+
+    def to_s
+      inspekt.to_s
+    end
+  end
+
+  class NullInspect
+    def method_missing(*)
+      return nil
+    end
+  end
+end

data/lib/docker/interactive.rb

@@ -0,0 +1,14 @@
+module Docker
+  module Interactive
+    extend self
+
+    def warn(command)
+      Kernel.warn (
+        "Interactive containers cannot (yet) be run within this " +
+        "library. Please copy the following command into a new "  +
+        "shell:\n\n\t#{command}"
+      )
+    end
+
+  end
+end

data/lib/docker/path.rb

@@ -0,0 +1,19 @@
+module Docker
+  class Path
+
+    attr_reader :path, :name
+    def initialize(path)
+      raise "Bad Path: Directory Not Found" unless Dir.exist?(path)
+      @path = File.expand_path(path)
+      @name = @path.sub(/\/$/, '').sub(/.+\//, '')
+    end
+
+    def to_s
+      @path
+    end
+
+    def to_dpath
+      self
+    end
+  end
+end

data/lib/docker/postgres.rb

@@ -0,0 +1,15 @@
+module Docker
+  class Postgres < Container
+
+    def self.run(name, version = '9.3.5')
+      pg = Docker.find_container(name: name)
+      if pg
+        pg.start! if pg.stopped? 
+      else
+        pg = super("postgres:#{version}", "-d --name #{name}")
+        sleep 3
+      end
+      pg
+    end
+  end
+end

data/lib/docker/rails/console.rb

@@ -0,0 +1,30 @@
+module Docker
+  module Rails
+    class Console < Docker::Container
+
+      extend Docker::Helpers
+      
+      def initialize(id)
+        super
+      end
+
+      def self.run(path, postgres)
+        image   = "#{rails_image(path.name)}"
+        options = "-it --name rails-console-#{path.name} " +
+                  "--rm -e PG_HOST=#{postgres.ip} "         + 
+                  "--link db:db -v #{path}:/usr/src/app"
+        command = 'rails console'
+
+        docker_cmd = "docker run #{options} #{image} #{command}"
+        Docker::Interactive.warn(docker_cmd)
+        docker_cmd
+      end
+
+      def self.load(id, path)
+        run(path)
+      end
+    end
+  end
+end
+
+

data/lib/docker/rails/server.rb

@@ -0,0 +1,53 @@
+module Docker
+  module Rails
+    class Server < Docker::Container
+
+      extend Docker::Helpers
+      
+      def initialize(id)
+        super
+      end
+
+      def self.run(path, postgres)
+        server = existing_server(path) 
+        return server if server
+        migrate_database!(path, postgres)
+        server = super(
+          "#{rails_image(path.name)}", 
+          "-d --name #{rails_server(path.name)} --link db:db "  +
+          "-e PG_HOST=#{postgres.ip} -v #{path}:/usr/src/app",
+          nil,
+          path
+        )
+        self.load(server.id, path)
+      end
+
+      def self.load_from(container)
+        load(container.id, container.path)
+      end
+
+      def self.load(id, path)
+        server = new(id)
+        Docker::Rails.add_default_instructions_to(server, path)
+      end
+
+      def self.migrate_database!(path, postgres)
+        ['create', 'migrate'].each do |cmd|
+          Docker.run(
+            "#{rails_image(path.name)}", 
+            "--rm --link db:db -e PG_HOST=#{postgres.ip} " + 
+            "-v #{path}:/usr/src/app",
+            "rake db:#{cmd}"
+          )
+        end
+      end
+
+      def self.existing_server(path)
+        server = Rails.find_server(path)
+        return server if server && server.up?
+        server.remove! if server
+        nil
+      end
+    end
+  end
+end

data/lib/docker/rails.rb

@@ -0,0 +1,54 @@
+module Docker
+  module Rails
+
+    extend Helpers
+    extend Docker
+    extend self
+
+    def build(app_path)
+      path = Docker::PATH(app_path)
+      Image.build(path, "rails-#{path.name}")
+    end
+
+    def postgres
+      Docker::Postgres.run('db')
+    end
+
+    def run(app_path, options = "", command = "")
+      path = Docker::PATH(app_path)
+      image = rails_image(path.name)
+      options = "#{options} -v #{path}:/usr/src/app"
+      Docker::Container.run(image, options, command, path)
+    end
+
+    def run_server(app_path)
+      path = Docker::PATH(app_path)
+      Docker::Rails::Server.run(path, postgres)
+    end
+
+    def run_console(app_path)
+      path = Docker::PATH(app_path)
+      Docker::Rails::Console.run(path, postgres)
+    end
+
+    def add_default_instructions_to(server, path)
+      path = Docker::PATH(path)
+      server.add_removal_instructions do |container|
+        # Give all users Read/Write Access to App
+        Docker.run(
+          "#{rails_image(path.name)}", 
+          "--rm -v #{path}:/usr/src/app",
+          "chmod -R a+rw /usr/src/app"
+        )
+        # Remove the tmp dir files and sub directories
+        `rm -rf #{path}/tmp/*`
+      end
+    end
+
+    def find_server(path)
+      path   = Docker::PATH(path)
+      server = Docker.find_container(name: rails_server(path.name))
+      Rails::Server.load(server.id, path) if server
+    end
+  end
+end

data/lib/docker/rake.rb

@@ -0,0 +1,10 @@
+module Docker
+  module Rake
+    extend self
+
+    def load
+      file = File.expand_path(__FILE__, '../../helpers.rake')
+      Kernel.load(file) 
+    end
+  end
+end

data/lib/docker/repository.rb

@@ -0,0 +1,22 @@
+module Docker
+  class Repository < Image
+
+    attr_reader :id, :image_id
+    def initialize(id, name)
+      @id       = name 
+      @image_id = id 
+    end
+
+    def remove!
+      `docker rmi #{id}`
+    end
+
+    def remove_image!
+      `docker rmi -f #{image_id}`
+    end
+
+    def to_s
+      id 
+    end
+  end
+end

data/lib/docker/ruby.rb

@@ -0,0 +1,27 @@
+module Docker
+  module Ruby
+
+    extend Helpers
+    extend Docker
+    extend self
+    
+    def build(app_path)
+      path = Docker::PATH(app_path)
+      Docker.build(path, "ruby-#{path.name}")
+    end
+
+    def run_irb(app_path, flags = '', command = '')
+      path    = Docker::PATH(app_path)
+      name    = path.name
+
+      image   = "jphager2/ruby-#{path.name}"
+      flags = "-it --name ruby-irb-#{name} -v #{path}:/usr/src/app #{flags}" 
+
+      docker_cmd = "docker run #{flags} #{image} #{command}" 
+
+      Docker::Interactive.warn(docker_cmd)
+      docker_cmd
+    end
+  end
+end
+

data/lib/docker/tag.rb

@@ -0,0 +1,11 @@
+module Docker
+  class Tag < Repository 
+
+    attr_reader :repo_name
+    def initialize(id, repo_name, name)
+      @id         = "#{repo_name}:#{name}"
+      @repo_name  = repo_name
+      @image_id   = id
+    end
+  end
+end

data/lib/docker-dev.rb

@@ -0,0 +1 @@
+require_relative 'docker'