dockerize 0.1.0

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    Njg4NjU1MjBhNDkyMmFlMzMwYjhiODIzNDM3MzEwY2RiMzM2NDg2Mg==
+  data.tar.gz: !binary |-
+    Nzg0ZjUwNmE4YWUwZWY0MmFjYjczZDlkZmI2NTQwYzZkNGUwOTczMQ==
+SHA512:
+  metadata.gz: !binary |-
+    ZTg2OTdjMGJiZDJmYWRlYWJmNTMyYTgzNjczNjU0YjcyMzJmZTNlNzY0YmY2
+    MTVkMjVlZDRjMGQwN2EzNGU4YTNhMDIxZWNiZmVhZDdmMjY0YWY2ZTJiZTZl
+    YmVlMTViOWU0NThlNmMxOTkxMjczYjYyZjFhZGEzYTE0YzYyZDE=
+  data.tar.gz: !binary |-
+    ZTVmMTQ3ZmFhNGM5YWFjZjE2MzNmMGNkZWJmM2IyNjlkNzJkMGUzOTJhYjg1
+    OTE2YTdkYjY4MTU5YjExYzhiMGNiYzc1YzdlNjA0ZGNhODcwYWVmMzU3N2I5
+    MmFmNjRkZWU0Y2M2ODgxYTQxYTU1NDIxNWIyNjc2YTVhN2I5Mjc=

data/.gitignore

@@ -0,0 +1,20 @@
+*.gem
+*.rbc
+.bundle
+.config
+coverage
+InstalledFiles
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+Gemfile.lock
+
+# YARD artifacts
+.yardoc
+_yardoc
+doc/
+.ruby-version

data/.jrubyrc

@@ -0,0 +1,5 @@
+compat.version=1.9
+ctext.enabled=false
+errno.backtrace=true
+
+# vim:filetype=jproperties

data/.rspec

@@ -0,0 +1,3 @@
+--color
+--require spec_helper
+--require English

data/.rubocop.yml

@@ -0,0 +1,10 @@
+---
+AllCops:
+  Excludes:
+    - vendor/**
+
+Documentation:
+  Enabled: false
+
+GlobalVars:
+  Enabled: false

data/.simplecov

@@ -0,0 +1,6 @@
+# vim:fileencoding=utf-8
+if ENV['COVERAGE']
+  SimpleCov.start do
+    add_filter '/spec/'
+  end
+end

data/.travis.yml

@@ -0,0 +1,13 @@
+---
+language: ruby
+matrix:
+  allow_failures:
+  - rvm: jruby-19mode
+rvm:
+- 1.9.3
+- 2.0.0
+- jruby-19mode
+notifications:
+  email:
+    recipients:
+      - r.colton@modcloth.com

data/Gemfile

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

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Rafe Colton
+
+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,94 @@
+# Dockerize
+
+[![Build Status](https://travis-ci.org/modcloth-labs/dockerize.png?branch=master)](https://travis-ci.org/modcloth-labs/dockerize)
+
+Dockerizes your project.
+
+## About
+
+Dockerize helps 'dockerize' your application by providing you an easy
+way to add Docker integration to your project.  Once a project has been
+'dockerized,' you will have some useful files in place that will guide
+you through the process of deploying your application with Docker.
+
+In particular, `dockerize` creates the `.run` directory in your project.
+Use this directory to configure important files that need to be placed
+on the host machine *outside* your container at deploy time.  These
+files might include an [Upstart](http://upstart.ubuntu.com/cookbook/)
+config file, for example.  Follow the comments in the files for more
+details
+
+## Installation
+
+Install with:
+
+```bash
+> gem install dockerize
+```
+
+## Usage
+
+The simplest use case is dockerizing the current project.  Example
+
+```bash
+> dockerize .
+```
+
+Dockerize is also very configurable, and allows many options to be set
+through the command line.
+
+To see what options are available, run `dockerize` with the help flag:
+
+```bash
+> dockerize --help
+
+# Usage: dockerize <project directory> [options]
+# Options:
+#                 --quiet, -q:   Silence output
+#               --dry-run, -d:   Dry run, do not write any files
+#                 --force, -f:   Force existing files to be overwritten
+#   --backup, --no-backup, -b:   Creates .bak version of files before overwriting them
+#          --registry, -r <s>:   The Docker registry to use when writing files
+#      --template-dir, -t <s>:   The directory containing the templates to be written
+#        --maintainer, -m <s>:   The default MAINTAINER to use for any Dockerfiles written 
+#              --from, -F <s>:   The default base image to use for any Dockerfiles written
+#               --version, -v:   Print version and exit
+#                  --help, -h:   Show this message
+```
+
+If you want to use `dockerize` to dockerize multiple projects, it may be
+useful to set some defaults in the environment.  Options currently
+configurable in the environment include:
+
+* default registry - `DOCKERIZE_REGISTRY`
+* template dir - `DOCKERIZE_TEMPLATE_DIR`
+* default maintainer - `DOCKERIZE_MAINTAINER`
+* default base image - `DOCKERIZE_FROM`
+
+## Deploying
+
+This gem also provides a handy script for unpacking the `.run` directory
+at deploy time.  To run this script, use the following command:
+
+```bash
+# retrieve the script
+> curl -s -O https://raw.github.com/modcloth-labs/dockerize/master/bin/dockerize-unpack
+
+# make it executable
+> chmod +x dockerize-unpack
+
+# run the script
+> dockerize-unpack quay.io/yourorg/example-image:tag
+
+# or, run with the help flag for more info
+> dockerize-unpack --help
+```
+
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,16 @@
+#!/usr/bin/env rake
+# vim:fileencoding=utf-8
+
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+desc 'Run rubocop'
+task :rubocop do
+  sh('rubocop --format simple'){ |ok, _| ok || abort }
+end
+
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.rspec_opts = '--format documentation'
+end
+
+task default: [:spec, :rubocop]

data/bin/dockerize

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# coding: utf-8
+
+lib = File.expand_path('../../lib', __FILE__)
+vendor = File.expand_path('../../vendor', __FILE__)
+
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+$LOAD_PATH.unshift(vendor) unless $LOAD_PATH.include?(vendor)
+
+require 'dockerize'
+require 'dockerize/cli'
+require 'colored'
+
+Dockerize::Cli.run(ARGV)
+exit 0

data/bin/dockerize-unpack

@@ -0,0 +1,53 @@
+#!/usr/bin/env bash
+
+set -x
+set -e
+
+function usage() {
+  cat <<EOB
+
+  Usage: dockerize-unpack <image> [docker args]
+
+  Options:
+  -h/--help    Display this message
+
+  Unpacks the files shipped with a docker container (via the \`dockerize\` gem)
+  and puts them in place by calling the \`deploy\` target in the
+  \`Makefile.run\`
+EOB
+}
+
+function main() {
+  case "$1" in
+    -h|--help)
+      usage
+      exit 0
+      ;;
+  esac
+
+  export DOCKER="${DOCKER:-sudo docker}"
+  export IMAGE="$1"
+  if [[ -z "$IMAGE" ]] ; then
+    usage
+    exit 1
+  fi
+  export ARGS="$2"
+
+  mkdir -p /tmp/docker-bridge
+  pushd /tmp/docker-bridge
+  fetch
+  unpack
+  popd
+}
+
+function fetch() {
+  $DOCKER run -v /tmp/docker-bridge:/bridge "$ARGS" "$IMAGE" /docker/run/bridge
+  tar -xzf /tmp/docker-bridge/run.tar.gz
+}
+
+function unpack() {
+  cd ./docker/run
+  make -f Makefile.run deploy
+}
+
+main "$@"

data/dockerize.gemspec

@@ -0,0 +1,36 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+vendor = File.expand_path('../vendor', __FILE__)
+
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+$LOAD_PATH.unshift(vendor) unless $LOAD_PATH.include?(vendor)
+
+require 'dockerize/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = 'dockerize'
+  gem.version       = Dockerize::VERSION
+  gem.authors       = ['Rafe Colton']
+  gem.email         = ['r.colton@modcloth.com']
+  gem.description   = 'Dockerizes your application'
+  gem.summary       = 'Creates a templated Dockerfile and corresponding ' <<
+                       'support files for easy deployment with docker.'
+  gem.homepage      = 'https://github.com/modcloth-labs/dockerize'
+  gem.license       = 'MIT'
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  gem.bindir        = 'bin'
+  gem.test_files    = gem.files.grep(%r{^spec/})
+  gem.require_paths = %w(lib vendor)
+  gem.required_ruby_version = '>= 1.9.3'
+
+  gem.add_development_dependency 'rake'
+  gem.add_development_dependency 'rspec'
+  gem.add_development_dependency 'rubocop'
+
+  gem.add_development_dependency 'pry' unless RUBY_PLATFORM == 'java'
+  gem.add_development_dependency 'simplecov' unless RUBY_PLATFORM == 'java'
+
+  gem.add_runtime_dependency 'syck' if RUBY_VERSION.split('.').first.to_i >= 2
+end

data/lib/dockerize/cli.rb

@@ -0,0 +1,52 @@
+# coding: utf-8
+
+require 'dockerize/template_parser'
+require 'dockerize/document_writer'
+
+module Dockerize
+  class Cli
+    class << self
+      attr_reader :args
+
+      def run(argv = [])
+        @args = argv
+        ensure_project_dir
+        parse_args
+        set_out_stream
+        handle_templates
+      end
+
+      private
+
+      attr_writer :args
+
+      def handle_templates
+        all_templates.map do |template|
+          Dockerize::TemplateParser.new(File.read(template))
+            .write_with Dockerize::DocumentWriter.new
+        end
+      end
+
+      def all_templates
+        Dir["#{Dockerize::Config.template_dir}/**/*.erb"] |
+          Dir["#{Dockerize::Config.template_dir}/**/*.erb"]
+      end
+
+      def set_out_stream
+        $out = $stdout
+        $out = File.open('/dev/null', 'w') if Dockerize::Config.quiet?
+      end
+
+      def parse_args
+        Dockerize::Config.parse(args)
+      end
+
+      def ensure_project_dir
+        if args.count < 1 && !%w(-h --help).include?(args[0])
+          fail Dockerize::Error::MissingRequiredArgument,
+               'You must specify a project directory to dockerize'
+        end
+      end
+    end
+  end
+end

data/lib/dockerize/config.rb

@@ -0,0 +1,141 @@
+# coding: utf-8
+# rubocop:disable MethodLength, ClassLength, CyclomaticComplexity
+
+require 'trollop'
+
+module Dockerize
+  class Config
+    class << self
+      attr_reader :project_dir
+      attr_accessor :opts
+
+      def parse(args)
+        config = self
+
+        Trollop.options(args) do
+          text "Usage: dockerize <project directory> [options]\nOptions:\n"
+
+          # -q/--quiet
+          opt :quiet, 'Silence output', type: :flag, short: 'q', default: false
+
+          # -d/--dry-run
+          opt :dry_run, 'Dry run, do not write any files',
+              type: :flag,
+              short: 'd',
+              default: false
+
+          # -f/--force
+          opt :force, 'Force existing files to be overwritten',
+              type: :flag,
+              short: 'f',
+              default: false
+
+          # -b/--backup
+          opt :backup, 'Creates .bak version of files before overwriting them',
+              type: :flag,
+              short: 'b',
+              default: true
+
+          # -r/--registry
+          opt :registry, 'The Docker registry to use when writing files',
+              type: :string,
+              short: 'r',
+              default: ENV['DOCKERIZE_REGISTRY'] || 'quay.io/modcloth'
+
+          # -t/--template-dir
+          opt :template_dir,
+              'The directory containing the templates to be written',
+              type: :string,
+              short: 't',
+              default: ENV['DOCKERIZE_TEMPLATE_DIR'] ||
+                "#{config.top}/templates"
+
+          # -m/--maintainer
+          opt :maintainer,
+              'The default MAINTAINER to use for any Dockerfiles written',
+              type: :string,
+              short: 'm',
+              default: ENV['DOCKERIZE_MAINTAINER'] ||
+                "#{ENV['USER']} <#{ENV['USER']}@example.com>"
+
+          # -F/--from
+          opt :from,
+              'The default base image to use for any Dockerfiles written',
+              type: :string,
+              short: 'F',
+              default: ENV['DOCKERIZE_FROM'] || 'ubuntu:12.04'
+
+          version "dockerize #{Dockerize::VERSION}"
+
+          begin
+            config.send(:opts=, parse(args))
+          rescue Trollop::CommandlineError => e
+            $stderr.puts "Error: #{e.message}."
+            $stderr.puts 'Try --help for help.'
+            exit 1
+          rescue Trollop::HelpNeeded
+            educate
+            exit
+          rescue Trollop::VersionNeeded
+            $stderr.puts version
+            exit
+          end
+
+          config.send(:opts)[:top] = config.top
+          config.send(:generate_accessor_methods, self)
+        end
+
+        self.project_dir = args[0]
+        set_project_name unless opts[:project_name]
+      end
+
+      def project_dir=(dir)
+        unless dir
+          fail Dockerize::Error::UnspecifiedProjectDirectory,
+               'You must specify a project directory'
+        end
+
+        expanded_dir = File.expand_path(dir)
+
+        if !File.exists?(expanded_dir)
+          fail Dockerize::Error::NonexistentProjectDirectory,
+               "Project directory '#{expanded_dir}' does not exist"
+        elsif !File.directory?(expanded_dir)
+          fail Dockerize::Error::InvalidProjectDirectory,
+               "Project directory '#{expanded_dir}' is not a directory"
+        else
+          @project_dir = expanded_dir
+        end
+      end
+
+      def set_project_name
+        opts[:project_name] ||= File.basename(project_dir)
+      end
+
+      def top
+        @top ||= Gem::Specification.find_by_name('dockerize').gem_dir
+      end
+
+      private
+
+      def klass
+        @klass ||= class << self ; self ; end
+      end
+
+      def add_method(name, &block)
+        klass.send(:define_method, name.to_sym, &block)
+      end
+
+      def generate_accessor_methods(parser)
+        parser.specs.map do |k, v|
+          case v[:type]
+          when *Trollop::Parser::FLAG_TYPES
+            add_method("#{k}?") { @opts[k] }
+          when :string
+            add_method("#{k}") { @opts[k] }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dockerize/document_writer.rb

@@ -0,0 +1,91 @@
+# coding: utf-8
+
+require 'fileutils'
+require 'colored'
+
+module Dockerize
+  class DocumentWriter
+    CREATE_WORD = 'created '.green
+    REPLACE_WORD = 'replaced '.red
+    IGNORE_WORD = 'ignored '.yellow
+
+    attr_writer :document_name
+
+    def initialize(document_name = nil, stream = $out)
+      @stream = stream
+      @document_name = document_name
+    end
+
+    def write(contents = nil, executable = false)
+      @invalid_content = true unless contents
+      ensure_containing_dir
+      do_backup! if should_backup?
+      inform_of_write(status_word)
+      do_write!(contents, executable) if should_write?
+    end
+
+    def output_target
+      "#{Dockerize::Config.project_dir}/#{document_name}"
+    end
+
+    def inform_of_write(type)
+      $out.puts '     ' << type <<  document_name
+    end
+
+    protected
+
+    def invalid_content?
+      @invalid_content.nil? ? false : @invalid_content
+    end
+
+    def invalid_word
+      'The template provided contains invalid content: '.blue
+    end
+
+    def status_word
+      if invalid_content?
+        invalid_word
+      elsif !should_write?
+        IGNORE_WORD
+      elsif preexisting_file?
+        REPLACE_WORD
+      else
+        CREATE_WORD
+      end
+    end
+
+    def should_backup?
+      Dockerize::Config.backup? && preexisting_file?
+    end
+
+    def should_write?
+      (Dockerize::Config.force? || !preexisting_file?) && !invalid_content?
+    end
+
+    def preexisting_file?
+      File.exists?(output_target)
+    end
+
+    def ensure_containing_dir(target = output_target)
+      FileUtils.mkdir_p(File.dirname(target))
+    end
+
+    def do_write!(contents, executable)
+      @stream = File.open(output_target, 'w') unless Dockerize::Config.dry_run?
+      @stream.print contents
+      FileUtils.chmod('+x', output_target) if executable && @stream != $out
+    ensure
+      @stream.close unless @stream == $out
+    end
+
+    def do_backup!
+      FileUtils.cp(output_target, "#{output_target}.bak")
+    end
+
+    def document_name
+      return @document_name if @document_name
+      fail Dockerize::Error::DocumentNameNotSpecified,
+           "Document name not specified for class #{self.class.name}"
+    end
+  end
+end

data/lib/dockerize/error.rb

@@ -0,0 +1,15 @@
+# coding: utf-8
+
+module Dockerize
+  module Error
+    # Invalid Config Errors
+    InvalidConfig = Class.new(StandardError)
+    NonexistentProjectDirectory = Class.new(InvalidConfig)
+    InvalidProjectDirectory = Class.new(InvalidConfig)
+    UnspecifiedProjectDirectory = Class.new(InvalidConfig)
+
+    # General Errors
+    MissingRequiredArgument = Class.new(ArgumentError)
+    DocumentNameNotSpecified = Class.new(NoMethodError)
+  end
+end

data/lib/dockerize/template_parser.rb

@@ -0,0 +1,63 @@
+# coding: utf-8
+
+require 'ostruct'
+require 'erb'
+
+module Dockerize
+  class TemplateParser
+    attr_reader :raw_text
+    attr_reader :metadata
+
+    def initialize(contents)
+      @raw_text = contents
+      @metadata = []
+    end
+
+    def document_name
+      metadata[:filename]
+    end
+
+    def executable?
+      metadata[:executable] == true ? true : false
+    end
+
+    def write_with(writer)
+      text = parsed_erb
+      writer.document_name = document_name
+      writer.write(text, executable?)
+    end
+
+    def parsed_erb
+      return @parsed_erb if @parsed_erb
+      begin
+        @parsed_erb = parse_erb(raw_text, config_vars)
+      rescue SyntaxError
+        @parsed_erb = nil
+      end
+    end
+
+    private
+
+    def config_vars
+      Dockerize::Config.opts
+    end
+
+    def parse_erb(raw, hash)
+      os = OpenStruct.new(hash)
+      os_before = os.clone
+      result = ERB.new(raw, nil, '%<>>-').result(
+        os.instance_eval { binding }
+      )
+      @metadata = hash_diff(os, os_before)
+      result
+    end
+
+    def hash_diff(os1, os2)
+      h1 = os1.marshal_dump
+      h2 = os2.marshal_dump
+      h1.dup.delete_if { |k, v| h2[k] == v }.merge!(
+        h2.dup.delete_if { |k, v| h1.key?(k) }
+      )
+    end
+  end
+end