dockit 1.0.0

data/lib/dockit/config.rb

@@ -0,0 +1,63 @@
+# Parse a dockit config file.
+# The dockit configuration file should contain the necessary options for
+# passing to the appropriate Docker api methods for image creation (build) or
+# container creation (running.)
+# The file is passed through ERB before YAML loading.
+require 'erb'
+require 'dotenv'
+
+module Dockit
+  class Config
+    ENVFILE='.env'
+    ##
+    # Instantiate and parse the file.
+    #
+    # file [String] :: dockit yaml file
+    # locals [Hash] :: local variables to bind in the ERB context
+    def initialize(file, locals={})
+      root = Dockit::Env.new.root
+      Dotenv.load(File.join(root, ENVFILE))
+      locals['root'] ||= root
+
+      begin
+        @config = YAML::load(ERB.new(File.read(file)).result(bindings(locals)))
+      rescue NameError => e
+        error(e)
+      rescue ArgumentError => e
+        error(e)
+      end
+    end
+
+    # The +Dockit.yaml+ file should have top-level entries for (at least)
+    # +build+ and/or +create+
+    # name :: Top-level key
+    # key :: key in +name+ hash
+    # ==== Returns
+    # - Hash for +name+ if +key+ is nil.
+    # - Value of +key+ in +name+ hash.
+    def get(name, key=nil)
+      phase = @config[name.to_s]
+      return phase unless key && phase
+
+      phase[key.to_s]
+    end
+
+    private
+    # Generate bindings object for locals to pass to erb
+    # locals :: hash converted to local variables
+    # Returns :: binding object
+    def bindings(locals)
+      b  = binding
+      locals.each do |k,v|
+        b.local_variable_set(k, v)
+      end
+
+      return b
+    end
+
+    def error(e)
+      abort [e.message.capitalize,
+             "Did you forget '--locals key:value'?"].join("\n")
+    end
+  end
+end

data/lib/dockit/container.rb

@@ -0,0 +1,81 @@
+module Dockit
+  class Container
+    attr_reader :container
+
+    class << self
+      def list(all: false, filters: nil)
+        Docker::Container.all(all: all, filters: JSON.dump(filters))
+      end
+
+      def clean(force: false)
+        list(
+          all: force,
+          filters: force ? nil : {status: [:exited]}
+        ).each do |container|
+          puts "  #{container.id}"
+          container.delete(force: true, v: force)
+        end
+      end
+
+      def find(name: nil, id: nil)
+        unless name || id
+          STDERR.puts "Must specify name or id"
+          exit 1
+        end
+        list().find do |container|
+          name && container.info['Names'].include?(name) ||
+            id && container.id == id
+        end
+
+      end
+    end
+
+    def initialize(options)
+      @tty = options['Tty']
+      @container = Docker::Container.create(options)
+    end
+
+    def start(options={}, verbose: true, transient: false)
+      container.start!(options)
+      if transient
+        if @tty
+          trap("INT") {}
+          STDIN.raw!
+        end
+        container.attach(tty: @tty, stdin: @tty ? STDIN : nil) do |*args|
+          if @tty then
+            print args[0]
+          else
+            msg(*args)
+          end
+        end
+        STDIN.cooked!
+        destroy
+      end
+    end
+
+    def destroy
+      puts "Deleting container #{container.id}"
+      container.delete(force: true, v: true)
+    end
+
+    private
+    def msg(stream, chunk)
+      pfx = stream.to_s == 'stdout' ? 'INFO: ' : 'ERROR: '
+      puts pfx +
+           [chunk.sub(/^\n/,'').split("\n")]
+             .flatten
+             .collect(&:rstrip)
+             .reject(&:empty?)
+             .join("\n#{pfx}")
+    end
+
+    def binds(options)
+      return unless options['Volumes']
+
+      options['Volumes'].collect do |k, v|
+        "#{Dir.pwd}/#{v}:#{k}"
+      end
+    end
+  end
+end

data/lib/dockit/digitalocean.rb

@@ -0,0 +1,148 @@
+# This class allows for basic deployment to a digitalocean docker droplet
+# via ssh (without exposing tcp access to the docker service.)
+require 'droplet_kit'
+
+class DO < Thor
+  USERNAME = 'root'.freeze
+  REMOTE_CMDS = %w[start push create].freeze
+
+  def self.remote_required?(extra_cmds=[])
+    ARGV[0] == 'do' && (
+      REMOTE_CMDS.include?(ARGV[1]) || extra_cmds.include?(ARGV[1]))
+  end
+
+  class_option :remote, type: :string, desc: 'remote droplet address',
+               required: remote_required?, aliases: ['r']
+  class_option :user  , type: :string, desc: 'remote user',
+               default: USERNAME, aliases: ['u']
+  class_option :token , type: :string,
+               desc: 'token filename relative to "~/.digitalocean"',
+               default: 'token'
+
+  desc 'create', 'create droplet REMOTE'
+  option :size,   type: :string, desc: 'size for droplet',   default: '512mb'
+  option :region, type: :string, desc: 'region for droplet', default: 'nyc3'
+  def create
+    if find(options.remote)
+      say  "Droplet #{options.remote} exists. Please destroy it first.", :red
+      exit 1
+    end
+    say "creating droplet: #{options.remote}"
+    d = client.droplets.create(DropletKit::Droplet.new(
+                            name: options.remote,
+                            region: options.region,
+                            size: options[:size],
+                            image: 'docker',
+                            ssh_keys: client.ssh_keys.all.collect(&:id)))
+    say  [d.id, d.status, d.name].join(' ')
+  end
+
+  desc 'list', 'list droplets'
+  def list
+    l = client.droplets.all.collect do |d|
+      [d.id, d.name, d.status, d.networks[:v4].first.ip_address]
+    end
+    l.unshift %w[id name status ip]
+    print_table l
+  end
+
+  desc 'destroy', 'destroy REMOTE droplet'
+  option :force, type: :boolean, desc: "don't prompt"
+  def destroy
+    force = options[:force]
+    say "Destroying droplet: #{options.remote}", force ? :red : nil
+    if force || yes?("Are you sure?", :red)
+      client.droplets.delete(id: find(options.remote).id)
+    else
+      say "#{options.remote} not destroyed", :red
+    end
+  end
+
+  desc 'push [SERVICES]', 'push service(s) to digitalocean (default all)'
+  option :backup, type: :boolean, desc: "Backup (tag) current version before push",
+         aliases: ['b']
+  option :tag, type: :string, desc: "tag name for backup", default: 'last'
+  def push(*args)
+    args = dockit.services.keys if args.empty?
+    say "Processing images for #{args}"
+    args.each do |k|
+      s = service(k)
+      unless s.image
+        say ". No image for #{k}!", :red
+        next
+      end
+      name    = s.config.get(:build, :t)
+      id      = s.image.id
+      msg     =  "#{k}: #{id[0..11]}(#{name})"
+      if ssh(options.remote, options.user,
+             "docker images --no-trunc | grep #{id} > /dev/null")
+        say ". Exists #{msg}"
+      else
+        if options.backup
+          tag = "#{k}:#{options.tag}"
+          say "Tagging #{name} as #{tag}"
+          ssh(options.remote, options.user, "docker tag #{name} #{tag}")
+        end
+        say ". Pushing #{msg}"
+        ssh(options.remote, options.user, 'docker load', "docker save #{name}")
+      end
+    end
+  end
+
+  desc 'start [SERVICE]', 'start a container for SERVICE on remote server'
+  option :vars, type: :hash,
+         desc: 'extra environment variables not defined in Dockit.yaml'
+  def start(name)
+    s     = service(name)
+    name  = s.config.get(:create, :name) || s.config.get(:build, :t)
+    links = config(s, :run,    :Links, 'l')
+    binds = config(s, :run,    :Binds, 'v')
+
+    env   = config(s, :create, :Env,   'e')
+    env   << (options[:vars]||{}).collect { |k,v| ['-e', "#{k}='#{v}'"]}
+    env   << ['-e', "ENV='#{options.env}'"]
+
+    cmd = ['docker', 'run', env, links, binds].join(' ')
+    ssh(options.remote, options.user, cmd)
+  end
+
+  private
+  def ssh(host, user, cmd, src=nil)
+    src << '|' if src
+    system("#{src}ssh #{user}@#{host} #{cmd}")
+  end
+
+  def client
+    @client ||= DropletKit::Client.new(
+      access_token: File.read(File.join(Dir.home, '.digitalocean', options.token)))
+  end
+
+  def find(hostname)
+    client.droplets.all.find do |d|
+      d.name == hostname
+    end
+  end
+
+  def dockit
+    @dockit ||= Dockit::Env.new
+  end
+
+  def service(name)
+    Dockit::Service.new(
+      service_file(name),
+      locals: {env: options.env ? "-#{options.env}" : ''}.merge(options[:locals]||{}))
+  end
+
+  def service_file(name)
+    file = dockit.services[name]
+    unless file
+      say "Service '#{name}' does not exist!", :red
+      exit 1
+    end
+    file
+  end
+
+  def config(service, phase, key, flag)
+    (service.config.get(phase, key)||[]).collect { |v| ["-#{flag}", "'#{v}'"] }
+  end
+end

data/lib/dockit/image.rb

@@ -0,0 +1,47 @@
+module Dockit
+  class Image
+    attr_reader :image
+
+    class << self
+      def list(all: false, filters: nil)
+        Docker::Image.all(all: all, filters: JSON.dump(filters))
+      end
+
+      def create(config)
+        unless config
+          STDERR.puts "No build target configured"
+          return
+        end
+        repos = config['t']
+        puts  "Building #{repos}"
+        image = Docker::Image.build_from_dir('.', config) do |chunk|
+          begin
+            chunk = JSON.parse(chunk)
+            progress = chunk['progress']
+            id = progress ? '' : chunk['id']
+            print chunk['stream'] ? chunk['stream'] :
+                    [chunk['status'], id, progress, progress ? "\r" : "\n"].join(' ')
+          rescue
+            puts chunk
+          end
+        end
+
+        image
+      end
+
+      def get(name)
+        Docker::Image.get(name)
+      end
+
+      def clean(force: false)
+        list(
+          all: force,
+          filters: force ? nil : {dangling: ['true']}
+        ).each do |image|
+          puts "  #{image.id}"
+          image.remove(force: true)
+        end
+      end
+    end
+  end
+end

data/lib/dockit/service.rb

@@ -0,0 +1,90 @@
+module Dockit
+  class Service
+    attr_reader :config
+    attr_reader :image
+
+    def initialize(file="./Dockit.yaml", locals: {})
+      @config = Dockit::Config.new(file, locals)
+
+      # get the image if it is specified and already exists
+      if name = config.get(:create, :Image) || config.get(:build, :t)
+        begin
+          @image = Dockit::Image.get(name)
+        rescue Docker::Error::NotFoundError
+        end
+      end
+    end
+
+    def build
+      @image = Dockit::Image.create(config.get(:build))
+    end
+
+    def start(options)
+      opts = merge_config(:create, stringify(options[:create]))
+      unless image || opts['Image']
+        raise "No runnable image found or specified!"
+      end
+
+      opts['Image'] ||= image.id if image
+      opts['name']  ||= config.get(:build, :t)
+
+      run = merge_config(:run, stringify(options[:run]))
+
+      if options[:verbose]
+        cmd = [(opts['Entrypoint']||[]), ((opts['Cmd'] || %w[default]))].flatten
+        puts " * %s (%s)" % [ opts['name'] || 'unnamed', cmd.join(' ') ]
+
+        puts " * #{run}" if run.length > 0
+      end
+
+      Dockit::Container.new(opts).start(
+        run, verbose: options[:verbose], transient: options[:transient])
+    end
+
+    def push(registry, tag=nil, force=false)
+      raise "No image found!" unless image
+
+      image.tag(repo: "#{registry}/#{config.get(:build, 't')}", force: force)
+      STDOUT.sync = true
+      image.push(tag: tag) do |chunk|
+        chunk = JSON.parse(chunk)
+        progress = chunk['progress']
+        id = progress ? '' : "#{chunk['id']} "
+        print chunk['status'], ' ', id, progress, progress ? "\r" : "\n"
+      end
+    end
+
+    def pull(registry, tag=nil, force=false)
+      unless repo = config.get(:build, 't')
+        STDERR.puts "No such locally built image"
+        exit 1
+      end
+
+      name = "#{registry}/#{repo}"
+      image = Docker::Image.create(
+        fromImage: name) do |chunk|
+        chunk = JSON.parse(chunk)
+        progress = chunk['progress']
+        id = progress ? '' : chunk['id']
+        print chunk['stream'] ? chunk['stream'] :
+                [chunk['status'], id, progress, progress ? "\r" : "\n"].join(' ')
+      end
+      puts "Tagging #{name} as #{repo}:#{tag||'latest'}"
+      image.tag(repo: repo, tag: tag, force: force)
+    end
+
+    def id
+      image.id
+    end
+
+    private
+    def merge_config(key, opts)
+      (config.get(key) || {}).merge(opts||{})
+    end
+
+    def stringify(hash)
+      return nil unless hash
+      Hash[hash.map {|k,v| [k.to_s, v]}]
+    end
+  end
+end

data/spec/deploy/Dockit.rb

@@ -0,0 +1,7 @@
+class All < SubCommand
+  desc 'build', 'build modules'
+  def build
+    invoke_service 'mod'
+    invoke_default 'svc'
+  end
+end

data/spec/deploy/mod/Dockit.rb

@@ -0,0 +1,6 @@
+class Mod < SubCommand
+  desc 'build', 'prep and build this service'
+  def build
+    invoke_default
+  end
+end