dream-ops 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 8b8aa9f131724802c240a24e1d23dbf37eb8c70e
+  data.tar.gz: 513e26443ce943be5ec10c4251a90794364ce536
+SHA512:
+  metadata.gz: d95f1f526da0bcc544dfcb06af87576571b46cf4ad75e14d1b68b36085084121ec5f14a1c561a9da5197fad733a9c2ad934d0ea5a6e3f2d73e4ad98c928f0341
+  data.tar.gz: 42e9083c9b3d6038548bd5b4897a91c861eb673a84bb2e46d0f675eef5166e74802bc17d7a0fe674082b5e067a7fc08509beed271cb178e59ad70b9644a5465d

data/.gitignore

@@ -0,0 +1,10 @@
+.DS_Store
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 chris-allen
+
+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,39 @@
+# DreamOps
+
+Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/dream-ops`. To experiment with that code, run `bin/console` for an interactive prompt.
+
+TODO: Delete this and the text above, and describe your gem
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'dream-ops'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install dream-ops
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/dream-ops.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "dream-ops"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/dream-ops.gemspec

@@ -0,0 +1,35 @@
+# coding: utf-8
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "dream-ops/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "dream-ops"
+  spec.version       = DreamOps::VERSION
+  spec.authors       = ["Chris Allen"]
+  spec.email         = ["chris@apaxsoftware.com"]
+  spec.required_ruby_version     = ">= 2.3.1"
+  spec.required_rubygems_version = ">= 2.0.0"
+
+  spec.summary       = "This is the summary"
+  spec.description   = "This is the description"
+  spec.homepage      = "https://github.com/chris-allen/dream-ops"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.15"
+  spec.add_development_dependency "rake", "~> 10.0"
+
+  spec.add_dependency "rubyzip",   "~> 1.2"
+  spec.add_dependency "aws-sdk",   "~> 2"
+  spec.add_dependency "berkshelf", "~> 6.2"
+  spec.add_dependency "ridley",    "~> 5.0"
+  spec.add_dependency "thor",      "~> 0.19", "< 0.19.2"
+  spec.add_dependency "chef",      "~> 12.7"
+end

data/exe/dream

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+$:.push File.expand_path("../../lib", __FILE__)
+require "dream-ops/cli"
+
+DreamOps::Cli::Runner.new(ARGV.dup).execute!

data/lib/dream-ops.rb

@@ -0,0 +1,60 @@
+# XXX: work around logger spam from hashie
+# https://github.com/intridea/hashie/issues/394
+begin
+  require "hashie"
+  require "hashie/logger"
+  Hashie.logger = Logger.new(nil)
+rescue LoadError
+  # intentionally left blank
+end
+
+require "berkshelf"
+require "thor"
+
+Berkshelf.ui.mute!
+
+module DreamOps
+
+  require_relative "dream-ops/version"
+  require_relative "dream-ops/errors"
+
+  autoload :Shell,      "dream-ops/shell"
+
+  autoload :BaseFormatter,  "dream-ops/formatters/base"
+  autoload :HumanFormatter, "dream-ops/formatters/human"
+  # autoload :JsonFormatter,  "dream-ops/formatters/json"
+  # autoload :NullFormatter,  "dream-ops/formatters/null"
+
+  autoload :BaseDeployer,  "dream-ops/deployment/base"
+  autoload :OpsWorksDeployer, "dream-ops/deployment/opsworks"
+
+  class << self
+    # @return [DreamOps::Shell]
+    def ui
+      @ui ||= DreamOps::Shell.new
+    end
+
+    # Get the appropriate Formatter object based on the formatter
+    # classes that have been registered.
+    #
+    # @return [~Formatter]
+    def formatter
+      @formatter ||= HumanFormatter.new
+    end
+
+    # Specify the format for output
+    #
+    # @param [#to_sym] format_id
+    #   the ID of the registered formatter to use
+    #
+    # @example DreamOps.set_format :json
+    #
+    # @return [~Formatter]
+    def set_format(name)
+      id = name.to_s.capitalize
+      @formatter = DreamOps.const_get("#{id}Formatter").new
+    end
+  end
+end
+
+require_relative "dream-ops/cli"

data/lib/dream-ops/cli.rb

@@ -0,0 +1,150 @@
+require "dream-ops"
+
+# require_relative "init_generator"
+# require_relative "cookbook_generator"
+# require_relative "commands/shelf"
+
+
+module DreamOps
+  class Cli < Thor
+    # This is the main entry point for the CLI. It exposes the method {#execute!} to
+    # start the CLI.
+    #
+    # @note the arity of {#initialize} and {#execute!} are extremely important for testing purposes. It
+    #   is a requirement to perform in-process testing with Aruba. In process testing is much faster
+    #   than spawning a new Ruby process for each test.
+    class Runner
+      def initialize(argv, stdin = STDIN, stdout = STDOUT, stderr = STDERR, kernel = Kernel)
+        @argv, @stdin, @stdout, @stderr, @kernel = argv, stdin, stdout, stderr, kernel
+      end
+
+      def execute!
+        $stdin  = @stdin
+        $stdout = @stdout
+        $stderr = @stderr
+
+        DreamOps::Cli.start(@argv)
+        @kernel.exit(0)
+      rescue DreamOps::DreamOpsError => e
+        DreamOps.ui.error e
+        DreamOps.ui.error "\t" + e.backtrace.join("\n\t") if ENV["BERKSHELF_DEBUG"]
+        @kernel.exit(e.status_code)
+      # rescue Ridley::Errors::RidleyError => e
+      #   DreamOps.ui.error "#{e.class} #{e}"
+      #   DreamOps.ui.error "\t" + e.backtrace.join("\n\t") if ENV["BERKSHELF_DEBUG"]
+      #   @kernel.exit(47)
+      end
+    end
+
+    class << self
+      def dispatch(meth, given_args, given_opts, config)
+        if given_args.length > 1 && !(given_args & Thor::HELP_MAPPINGS).empty?
+          command = given_args.first
+
+          if subcommands.include?(command)
+            super(meth, [command, "help"].compact, nil, config)
+          else
+            super(meth, ["help", command].compact, nil, config)
+          end
+        else
+          super
+          DreamOps.formatter.cleanup_hook unless config[:current_command].name == "help"
+        end
+      end
+    end
+
+    def initialize(*args)
+      super(*args)
+
+      # if @options[:config]
+      #   unless File.exist?(@options[:config])
+      #     raise ConfigNotFound.new(:berkshelf, @options[:config])
+      #   end
+
+      #   DreamOps.config = DreamOps::Config.from_file(@options[:config])
+      # end
+
+      if @options[:debug]
+        ENV["BERKSHELF_DEBUG"] = "true"
+        DreamOps.logger.level = ::Logger::DEBUG
+      end
+
+      if @options[:quiet]
+        DreamOps.ui.mute!
+      end
+
+      DreamOps.set_format @options[:format]
+      @options = options.dup # unfreeze frozen options Hash from Thor
+    end
+
+    namespace "berkshelf"
+
+    map "ls"   => :list
+    map "book" => :cookbook
+    map ["ver", "-v", "--version"] => :version
+
+    default_task :install
+
+    class_option :config,
+      type: :string,
+      desc: "Path to DreamOps configuration to use.",
+      aliases: "-c",
+      banner: "PATH"
+    class_option :format,
+      type: :string,
+      default: "human",
+      desc: "Output format to use.",
+      aliases: "-F",
+      banner: "FORMAT"
+    class_option :quiet,
+      type: :boolean,
+      desc: "Silence all informational output.",
+      aliases: "-q",
+      default: false
+    class_option :debug,
+      type: :boolean,
+      desc: "Output debug information",
+      aliases: "-d",
+      default: false
+
+    desc "version", "Display version"
+    def version
+      DreamOps.formatter.version
+    end
+
+    method_option :stacks,
+      type: :array,
+      desc: "Only these stack IDs.",
+      aliases: "-s"
+    desc "deploy", "Creates deploy"
+    def deploy(type)
+      deployer = nil
+
+      args = []
+      if type == 'opsworks'
+        deployer = OpsWorksDeployer.new
+        stack_ids = options[:stacks]
+        args = [*stack_ids]
+      end
+
+      if !deployer.nil?
+        deployer.deploy(*args)
+      end
+    end
+
+    # tasks["cookbook"].options = DreamOps::CookbookGenerator.class_options
+
+    private
+
+      # Print a list of the given cookbooks. This is used by various
+      # methods like {list} and {contingent}.
+      #
+      # @param [Array<CachedCookbook>] cookbooks
+      #
+    def print_list(cookbooks)
+      Array(cookbooks).sort.each do |cookbook|
+        DreamOps.formatter.msg "  * #{cookbook.cookbook_name} (#{cookbook.version})"
+      end
+    end
+  end
+end

data/lib/dream-ops/deployment/base.rb

@@ -0,0 +1,80 @@
+require "berkshelf"
+require "dream-ops/utils/zip"
+require 'fileutils'
+
+module DreamOps
+  class BaseDeployer
+    class << self
+      #
+      # @macro deployer_method
+      #   @method $1(*args)
+      #     Create a deployer method for the declaration
+      #
+      def deployer_method(name)
+        class_eval <<-EOH, __FILE__, __LINE__ + 1
+          def #{name}(*args)
+            raise AbstractFunction,
+              "##{name} must be implemented on \#{self.class.name}!"
+          end
+        EOH
+      end
+    end
+
+    # These MUST be implemented by subclasses
+    deployer_method :analyze
+    deployer_method :deploy_cookbook
+    deployer_method :deploy_target
+
+    # It may turn out that cookbook building will be different for different
+    # deployments, but for now all deployments build them the same way.
+    def build_cookbook(cookbook)
+      berksfile = Berkshelf::Berksfile.from_file(File.join(cookbook[:path], "Berksfile"))
+      berksfile.vendor("berks-cookbooks")
+
+      File.open("berks-cookbooks/Berksfile", 'w') { |file|
+        file.write("source \"https://supermarket.chef.io\"\n\n")
+        file.write("cookbook \"#{cookbook[:name]}\", path: \"./#{cookbook[:name]}\"")
+      }
+      zf = ZipFileGenerator.new("berks-cookbooks", cookbook[:cookbook_key])
+      zf.write
+    end
+
+    def cleanup_cookbooks(cookbooks)
+      cookbooks.each do |cookbook|
+        File.delete(cookbook[:cookbook_key])
+        FileUtils.remove_dir("berks-cookbooks")
+      end
+    end
+
+    def deploy(*args)
+      # Find unique cookbooks and deploy targets
+      result = analyze(args)
+
+      # Build each unique cookbook once in case it's used by more than one app
+      result[:cookbooks].each do |cookbook|
+        DreamOps.ui.info "...Building cookbook [#{cookbook[:name]}]"
+        build_cookbook(cookbook)
+
+        DreamOps.ui.info "...Deploying cookbook [#{cookbook[:name]}]"
+        deploy_cookbook(cookbook)
+      end
+      cleanup_cookbooks(result[:cookbooks])
+
+      # Update cookbooks if needed and deploy to all targets
+      deploy_success = true
+      deploy_threads = []
+      result[:deploy_targets].each do |target|
+        deploy_threads << Thread.new { deploy_target(target, result[:cookbooks]) }
+      end
+      deploy_threads.each do |t|
+        begin
+          t.join
+        rescue DreamOps::FatalDeployError
+          deploy_success = deploy_success && false
+        end
+      end
+
+      exit(1) if !deploy_success
+    end
+  end
+end

data/lib/dream-ops/deployment/opsworks.rb

@@ -0,0 +1,202 @@
+require "aws-sdk"
+require "ridley"
+
+Aws.use_bundled_cert!
+
+module DreamOps
+  class OpsWorksDeployer < BaseDeployer
+
+    # Output the version of DreamOps
+    def analyze(stack_ids)
+      begin
+        @opsworks = Aws::OpsWorks::Client.new
+        stacks = @opsworks.describe_stacks({ stack_ids: stack_ids, }).stacks
+      rescue => e
+        DreamOps.ui.error "Failed to fetch OpsWorks stacks\n"
+        DreamOps.ui.error "#{$!}"
+        exit(1)
+      end
+
+      # Collect and print stack info
+      result = { cookbooks: [], deploy_targets: [] }
+      stacks.each do |stack|
+        stack_result = analyze_stack(stack)
+        # Add the stack to the deploy targets
+        result[:deploy_targets] << {
+          stack: stack,
+          apps: stack_result[:apps],
+          cookbook: stack_result[:cookbook]
+        }
+        # Determine whether the cookbook needs to be built
+        cbook = stack_result[:cookbook]
+        if !cbook.nil? && !cbook[:local_sha].nil?
+          # We only build the cookbook if we don't have this version on S3
+          if cbook[:remote_sha] != cbook[:local_sha]
+            # Don't build the same destination cookbook more than once
+            if !__cookbook_in_array(cbook, result[:cookbooks])
+              result[:cookbooks] << cbook
+            end
+          end
+        end
+      end
+      return result
+    end
+
+    ################## OpsWorks specific methods ##################
+
+    # Retrieves stack apps and gets all information about remote/local cookbook
+    def analyze_stack(stack)
+      cookbook = nil
+      cookbookName = nil
+
+      DreamOps.ui.info "Stack: #{stack.name}"
+      if !stack.custom_cookbooks_source.nil?
+        source = stack.custom_cookbooks_source
+
+        # Skip this step if the stack doesn't use S3
+        if source.type == 's3'
+          cookbookPath = source.url[25..-1]
+          firstSlash = cookbookPath.index('/')
+          cookbook = {
+              bucket: cookbookPath[0..(firstSlash-1)],
+              cookbook_key: cookbookPath[(firstSlash+1)..-1],
+              sha_key: cookbookPath[firstSlash+1..-1].sub('.zip', '_SHA.txt')
+          }
+
+          # Treat any directory with a Berksfile as a cookbook
+          cookbooks = Dir.glob('./**/Berksfile')
+
+          # For now we only handle if we find one cookbook
+          if cookbooks.length == 1
+            metadata = Ridley::Chef::Cookbook::Metadata.from_file(cookbooks[0].sub("Berksfile", "metadata.rb"))
+            cookbook[:name] = metadata.name
+            cookbook[:path] = cookbooks[0].sub('/Berksfile', '')
+            if cookbook[:cookbook_key].include? cookbook[:name]
+              cookbook[:local_sha] = `git log --pretty=%H -1 #{cookbook[:path]}`.chomp
+
+              begin
+                obj = Aws::S3::Object.new(cookbook[:bucket], cookbook[:sha_key])
+                cookbook[:remote_sha] = obj.get.body.string
+              rescue Aws::S3::Errors::NoSuchKey
+                cookbook[:remote_sha] = ''
+              end
+            else
+              DreamOps.ui.info "Stack cookbook source is '#{cookbook[:cookbook_key]}' but found '#{cookbook[:name]}' locally"
+            end
+          end
+          DreamOps.ui.info "--- Cookbook: #{cookbook[:name]}"
+        end
+      end
+
+      apps = @opsworks.describe_apps({ stack_id: stack.stack_id }).apps
+      if apps.length == 0
+        DreamOps.ui.info "--- Apps: No apps"
+      else
+        DreamOps.ui.info "--- Apps: #{apps.map{|app| app.name}}"
+      end
+
+      return { apps: apps, cookbook: cookbook }
+    end
+
+    # Deploys cookbook to S3
+    def deploy_cookbook(cookbook)
+      begin
+        archiveFile = File.open(cookbook[:cookbook_key])
+        remoteCookbook = Aws::S3::Object.new(cookbook[:bucket], cookbook[:cookbook_key])
+        response = remoteCookbook.put({ acl: "private", body: archiveFile })
+        archiveFile.close
+
+        remoteSha = Aws::S3::Object.new(cookbook[:bucket], cookbook[:sha_key])
+        response = remoteSha.put({ acl: "private", body: cookbook[:local_sha] })
+      rescue => e
+        DreamOps.ui.error "#{$!}"
+      end
+    end
+
+    # 
+    def deploy_target(target, cookbooks)
+      # If this stack has a new cookbook
+      if !target[:cookbook].nil?
+        if __cookbook_in_array(target[:cookbook], cookbooks)
+          begin
+            # Grab a fresh copy of the cookbook on all instances in the stack
+            update_custom_cookbooks(target[:stack])
+          rescue Aws::OpsWorks::Errors::ValidationException
+            DreamOps.ui.error "Stack \"#{target[:stack].name}\" has no running instances."
+            __bail_with_fatal_error
+          end
+
+          # Re-run the setup step for all layers
+          setup(target[:stack])
+        end
+      end
+
+      # Deploy all apps for stack
+      target[:apps].each do |app|
+        begin
+          deploy_app(app, target[:stack])
+        rescue Aws::OpsWorks::Errors::ValidationException
+          DreamOps.ui.error "Stack \"#{target[:stack].name}\" has no running instances."
+          __bail_with_fatal_error
+        end
+      end
+    end
+
+    def update_custom_cookbooks(stack)
+      DreamOps.ui.info "...Updating custom cookbooks [stack=\"#{stack.name}\"]"
+      response = @opsworks.create_deployment({
+        stack_id: stack.stack_id,
+        command: { name: "update_custom_cookbooks" }
+      })
+      return wait_for_deployment(response.deployment_id)
+    end
+
+    def setup(stack)
+      DreamOps.ui.info "...Running setup command [stack=\"#{stack.name}\"]"
+      response = @opsworks.create_deployment({
+        stack_id: stack.stack_id,
+        command: { name: "setup" }
+      })
+      return wait_for_deployment(response.deployment_id)
+    end
+
+    def deploy_app(app, stack)
+      DreamOps.ui.info "...Deploying [stack=\"#{stack.name}\"] [app=\"#{app.name}\"]"
+      response = @opsworks.create_deployment({
+        stack_id: stack.stack_id,
+        app_id: app.app_id,
+        command: { name: "deploy" }
+      })
+      return wait_for_deployment(response.deployment_id)
+    end
+
+    def get_deployment_status(deployment_id)
+      response = @opsworks.describe_deployments({ deployment_ids: [deployment_id] })
+      if response[:deployments].length == 1
+        return response[:deployments][0].status
+      end
+      return "failed"
+    end
+
+    def wait_for_deployment(deployment_id)
+      status = "failed"
+      while true
+        status = get_deployment_status(deployment_id)
+        break if ["successful", "failed"].include? status
+        sleep(2)
+      end
+      return status
+    end
+
+    def __bail_with_fatal_error
+      raise FatalDeployError
+      Thread.exit
+    end
+
+    def __cookbook_in_array(cb, cookbooks)
+      return cookbooks.any? {|c|
+        c[:cookbook_key] == cb[:cookbook_key] and c[:bucket] == cb[:bucket]
+      }
+    end
+  end
+end

data/lib/dream-ops/errors.rb

@@ -0,0 +1,15 @@
+module DreamOps
+  class DreamOpsError < StandardError
+    class << self
+      # @param [Integer] code
+      def set_status_code(code)
+        define_method(:status_code) { code }
+        define_singleton_method(:status_code) { code }
+      end
+    end
+
+    alias_method :message, :to_s
+  end
+
+  class FatalDeployError < DreamOpsError; set_status_code(10); end
+end

data/lib/dream-ops/formatters/base.rb

@@ -0,0 +1,43 @@
+module DreamOps
+  class BaseFormatter
+    class << self
+      #
+      # @macro formatter_method
+      #   @method $1(*args)
+      #     Create a formatter method for the declaration
+      #
+      def formatter_method(name)
+        class_eval <<-EOH, __FILE__, __LINE__ + 1
+          def #{name}(*args)
+            raise AbstractFunction,
+              "##{name} must be implemented on \#{self.class.name}!"
+          end
+        EOH
+      end
+    end
+
+    # UI methods
+    formatter_method :deprecation
+    formatter_method :error
+    formatter_method :msg
+    formatter_method :warn
+
+    # Object methods
+    formatter_method :fetch
+    formatter_method :info
+    formatter_method :install
+    formatter_method :list
+    formatter_method :outdated
+    formatter_method :package
+    formatter_method :search
+    formatter_method :show
+    formatter_method :skipping
+    formatter_method :uploaded
+    formatter_method :use
+    formatter_method :vendor
+    formatter_method :version
+
+    # The cleanup hook is defined by subclasses and is called by the CLI.
+    def cleanup_hook; end
+  end
+end

data/lib/dream-ops/formatters/human.rb

@@ -0,0 +1,163 @@
+module DreamOps
+  class HumanFormatter < BaseFormatter
+    # Output the version of DreamOps
+    def version
+      DreamOps.ui.info DreamOps::VERSION
+    end
+
+    # @param [DreamOps::Dependency] dependency
+    def fetch(dependency)
+      DreamOps.ui.info "Fetching '#{dependency.name}' from #{dependency.location}"
+    end
+
+    # Output a Cookbook installation message using {DreamOps.ui}
+    #
+    # @param [Source] source
+    #   the source the dependency is being downloaded from
+    # @param [RemoteCookbook] cookbook
+    #   the cookbook to be downloaded
+    def install(source, cookbook)
+      message = "Installing #{cookbook.name} (#{cookbook.version})"
+
+      if source.type == :chef_repo
+        message << " from #{cookbook.location_path}"
+      elsif !source.default?
+        message << " from #{source}"
+        message << " ([#{cookbook.location_type}] #{cookbook.location_path})"
+      end
+
+      DreamOps.ui.info(message)
+    end
+
+    # Output a Cookbook use message using {DreamOps.ui}
+    #
+    # @param [Dependency] dependency
+    def use(dependency)
+      message =  "Using #{dependency.name} (#{dependency.locked_version})"
+      message << " from #{dependency.location}" if dependency.location
+      DreamOps.ui.info(message)
+    end
+
+    # Output a Cookbook upload message using {DreamOps.ui}
+    #
+    # @param [DreamOps::CachedCookbook] cookbook
+    # @param [Ridley::Connection] conn
+    def uploaded(cookbook, conn)
+      DreamOps.ui.info "Uploaded #{cookbook.cookbook_name} (#{cookbook.version}) to: '#{conn.server_url}'"
+    end
+
+    # Output a Cookbook skip message using {DreamOps.ui}
+    #
+    # @param [DreamOps::CachedCookbook] cookbook
+    # @param [Ridley::Connection] conn
+    def skipping(cookbook, conn)
+      DreamOps.ui.info "Skipping #{cookbook.cookbook_name} (#{cookbook.version}) (frozen)"
+    end
+
+    # Output a list of outdated cookbooks and the most recent version
+    # using {DreamOps.ui}
+    #
+    # @param [Hash] hash
+    #   the list of outdated cookbooks in the format
+    #   { 'cookbook' => { 'supermarket.chef.io' => #<Cookbook> } }
+    def outdated(hash)
+      if hash.empty?
+        DreamOps.ui.info("All cookbooks up to date!")
+      else
+        DreamOps.ui.info("The following cookbooks have newer versions:")
+
+        hash.each do |name, info|
+          info["remote"].each do |remote_source, remote_version|
+            out = "  * #{name} (#{info['local']} => #{remote_version})"
+
+            unless remote_source.default?
+              out << " [#{remote_source.uri}]"
+            end
+
+            DreamOps.ui.info(out)
+          end
+        end
+      end
+    end
+
+    # Output a Cookbook package message using {DreamOps.ui}
+    #
+    # @param [String] destination
+    def package(destination)
+      DreamOps.ui.info "Cookbook(s) packaged to #{destination}"
+    end
+
+    # Output the important information about a cookbook using {DreamOps.ui}.
+    #
+    # @param [CachedCookbook] cookbook
+    def info(cookbook)
+      DreamOps.ui.info(cookbook.pretty_print)
+    end
+
+    # Output a list of cookbooks using {DreamOps.ui}
+    #
+    # @param [Array<Dependency>] list
+    def list(dependencies)
+      DreamOps.ui.info "Cookbooks installed by your Berksfile:"
+      dependencies.each do |dependency|
+        out =  "  * #{dependency}"
+        out << " from #{dependency.location}" if dependency.location
+        DreamOps.ui.info(out)
+      end
+    end
+
+    # Ouput Cookbook search results using {DreamOps.ui}
+    #
+    # @param [Array<APIClient::RemoteCookbook>] results
+    def search(results)
+      results.sort_by(&:name).each do |remote_cookbook|
+        DreamOps.ui.info "#{remote_cookbook.name} (#{remote_cookbook.version})"
+      end
+    end
+
+    # Output Cookbook path using {DreamOps.ui}
+    #
+    # @param [CachedCookbook] cookbook
+    def show(cookbook)
+      path = File.expand_path(cookbook.path)
+      DreamOps.ui.info(path)
+    end
+
+    # Output Cookbook vendor info message using {DreamOps.ui}
+    #
+    # @param [CachedCookbook] cookbook
+    # @param [String] destination
+    def vendor(cookbook, destination)
+      cookbook_destination = File.join(destination, cookbook.cookbook_name)
+      DreamOps.ui.info "Vendoring #{cookbook.cookbook_name} (#{cookbook.version}) to #{cookbook_destination}"
+    end
+
+    # Output a generic message using {DreamOps.ui}
+    #
+    # @param [String] message
+    def msg(message)
+      DreamOps.ui.info message
+    end
+
+    # Output an error message using {DreamOps.ui}
+    #
+    # @param [String] message
+    def error(message)
+      DreamOps.ui.error message
+    end
+
+    # Output a warning message using {DreamOps.ui}
+    #
+    # @param [String] message
+    def warn(message)
+      DreamOps.ui.warn message
+    end
+
+    # Output a deprecation warning
+    #
+    # @param [String] message
+    def deprecation(message)
+      DreamOps.ui.info "DEPRECATED: #{message}"
+    end
+  end
+end

data/lib/dream-ops/shell.rb

@@ -0,0 +1,31 @@
+require "thor"
+
+module DreamOps
+  # Subclass the current shell (which is different based on the OS)
+  Shell = Class.new(Thor::Base.shell) do
+    # Mute the output of this instance of UI until {#unmute!} is called
+    def mute!
+      @mute = true
+    end
+
+    # Unmute the output of this instance of UI until {#mute!} is called
+    def unmute!
+      @mute = false
+    end
+
+    def say(*args)
+      return if quiet?
+      super(*args)
+    end
+    alias_method :info, :say
+
+    def warn(message, color = :yellow)
+      say(message, color)
+    end
+
+    def error(message, color = :red)
+      message = set_color(message, *color) if color
+      super(message)
+    end
+  end
+end

data/lib/dream-ops/utils/zip.rb

@@ -0,0 +1,47 @@
+require 'zip'
+
+# This is a simple example which uses rubyzip to
+# recursively generate a zip file from the contents of
+# a specified directory. The directory itself is not
+# included in the archive, rather just its contents.
+#
+# Usage:
+#   directoryToZip = "/tmp/input"
+#   outputFile = "/tmp/out.zip"
+#   zf = ZipFileGenerator.new(directoryToZip, outputFile)
+#   zf.write()
+class ZipFileGenerator
+
+  # Initialize with the directory to zip and the location of the output archive.
+  def initialize(inputDir, outputFile)
+    @inputDir = inputDir
+    @outputFile = outputFile
+  end
+
+  # Zip the input directory.
+  def write()
+    entries = Dir.entries(@inputDir); entries.delete("."); entries.delete("..")
+    io = Zip::File.open(@outputFile, Zip::File::CREATE);
+
+    writeEntries(entries, "", io)
+    io.close();
+  end
+
+  # A helper method to make the recursion work.
+  private
+  def writeEntries(entries, path, io)
+
+    entries.each { |e|
+      zipFilePath = path == "" ? e : File.join(path, e)
+      diskFilePath = File.join(@inputDir, zipFilePath)
+      if  File.directory?(diskFilePath)
+        io.mkdir(zipFilePath)
+        subdir =Dir.entries(diskFilePath); subdir.delete("."); subdir.delete("..")
+        writeEntries(subdir, zipFilePath, io)
+      else
+        io.get_output_stream(zipFilePath) { |f| f.puts(File.open(diskFilePath, "rb").read())}
+      end
+    }
+  end
+
+end

data/lib/dream-ops/version.rb

@@ -0,0 +1,3 @@
+module DreamOps
+  VERSION = "0.1.0"
+end

metadata

@@ -0,0 +1,182 @@
+--- !ruby/object:Gem::Specification
+name: dream-ops
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Chris Allen
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2017-07-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rubyzip
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+- !ruby/object:Gem::Dependency
+  name: aws-sdk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2'
+- !ruby/object:Gem::Dependency
+  name: berkshelf
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.2'
+- !ruby/object:Gem::Dependency
+  name: ridley
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.19'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 0.19.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.19'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 0.19.2
+- !ruby/object:Gem::Dependency
+  name: chef
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.7'
+description: This is the description
+email:
+- chris@apaxsoftware.com
+executables:
+- dream
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- dream-ops.gemspec
+- exe/dream
+- lib/dream-ops.rb
+- lib/dream-ops/cli.rb
+- lib/dream-ops/deployment/base.rb
+- lib/dream-ops/deployment/opsworks.rb
+- lib/dream-ops/errors.rb
+- lib/dream-ops/formatters/base.rb
+- lib/dream-ops/formatters/human.rb
+- lib/dream-ops/shell.rb
+- lib/dream-ops/utils/zip.rb
+- lib/dream-ops/version.rb
+homepage: https://github.com/chris-allen/dream-ops
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.3.1
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.0.0
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.8
+signing_key: 
+specification_version: 4
+summary: This is the summary
+test_files: []