vagrant-opsworks 0.0.5

data/lib/vagrant-opsworks/client/layer.rb

@@ -0,0 +1,39 @@
+module VagrantPlugins::OpsWorks
+  class Client
+    class Layer < VagrantPlugins::OpsWorks::Util::DummyConfiguration
+
+      def layer_id(value=nil)
+        set_or_return(:layer_id, value)
+      end
+
+      def type(value=nil)
+        set_or_return(:type, value)
+      end
+
+      def name(value=nil)
+        set_or_return(:description, value)
+      end
+
+      def shortname(value=nil)
+        set_or_return(:name, value)
+      end
+
+      def attributes(value=nil)
+        set_or_return(:attributes, value)
+      end
+
+      def packages(value=nil)
+        set_or_return(:packages, value)
+      end
+
+      def default_recipes(value=nil)
+        set_or_return(:default_recipes, value)
+      end
+
+      def custom_recipes(value=nil)
+        set_or_return(:custom_recipes, value)
+      end
+
+    end
+  end
+end

data/lib/vagrant-opsworks/client/stack.rb

@@ -0,0 +1,47 @@
+module VagrantPlugins::OpsWorks
+  class Client
+    class Stack < VagrantPlugins::OpsWorks::Util::DummyConfiguration
+
+      def name(value=nil)
+        set_or_return(:name, value)
+      end
+
+      def default_os(value=nil)
+        set_or_return(:default_os, value)
+      end
+
+      def configuration_manager(value=nil)
+        set_or_return(:configuration_manager, value)
+      end
+
+      def chef_configuration(value=nil)
+        set_or_return(:chef_configuration, value)
+      end
+
+      def berks_enabled?
+        return self['chef_configuration'][:manage_berkshelf]
+      end
+
+      def use_custom_cookbooks?
+        self['use_custom_cookbooks']
+      end
+
+      def use_custom_cookbooks(value=nil)
+        set_or_return(:use_custom_cookbooks, value)
+      end
+
+      def custom_cookbooks_source(value=nil)
+        set_or_return(:custom_cookbooks_source, value)
+      end
+
+      def custom_json(value=nil)
+        require_relative '../custom_json'
+        unless value.nil?
+          value = CustomJson.new(JSON.parse(value)) if value.is_a?(String)
+        end
+        set_or_return(:custom_json, value)
+      end
+
+    end
+  end
+end

data/lib/vagrant-opsworks/client.rb

@@ -0,0 +1,46 @@
+module VagrantPlugins::OpsWorks
+  class Client
+    require_relative 'util/dummy_configuration'
+    require_relative 'client/app'
+    require_relative 'client/instance'
+    require_relative 'client/layer'
+    require_relative 'client/stack'
+
+    # @return [String]
+    attr_reader :stack_id
+
+    # @paran [String] stack_id the stack id to retrieve metadata about
+    def initialize(stack_id)
+      @stack_id = stack_id
+    end
+
+    # @return [Array<App>]
+    def apps
+      @apps ||= aws_client.describe_apps(stack_id: @stack_id)[:apps].map{|a| App.new(a)}
+    end
+
+    # @return [Array<Instance>]
+    def instances
+      @instances ||= aws_client.describe_instances(stack_id: @stack_id)[:instances].map{|i| Instance.new(i)}
+    end
+
+    # @return [Array<Layer>]
+    def layers
+      @layers ||= aws_client.describe_layers(stack_id: @stack_id)[:layers].map{|l| Layer.new(l)}
+    end
+
+    # @return [Stack]
+    def stack
+      @stack ||= Stack.new(aws_client.describe_stacks(stack_ids: [@stack_id])[:stacks].first)
+    end
+
+    protected
+
+    # @return [AWS::OpsWorks::Client]
+    def aws_client
+      require 'aws-sdk'
+      @client ||= AWS::OpsWorks::Client.new
+    end
+
+  end
+end

data/lib/vagrant-opsworks/client_old.rb

@@ -0,0 +1,94 @@
+module VagrantPlugins
+  module OpsWorks
+    class Client
+
+      attr_reader :stack_id
+
+      def initialize(stack_id, cache=nil)
+        @stack_id = stack_id
+        @registry = Vagrant::Registry.new
+        @cache = cache
+
+        %w(apps instances layers).each{ |m| @registry.register(m) { build_metadata_proc(m).call } }
+        @registry.register('stacks') {
+          api_proc = Proc.new {
+            unless opsworks_reachable?
+              raise VagrantPlugins::OpsWorks::Errors::ConnectError
+            end
+
+            aws_client.describe_stacks(stack_ids: [@stack_id])[:stacks]
+          }
+          build_api_proc('stacks', api_proc).call
+        }
+      end
+
+      def apps
+        @registry['apps']
+      end
+
+      def instances
+        @registry['instances']
+      end
+
+      def layers
+        @registry['layers']
+      end
+
+      def stack
+        @registry['stacks'].first
+      end
+
+      protected
+
+      def aws_client
+        require 'aws-sdk'
+        @client ||= AWS::OpsWorks::Client.new
+      end
+
+      def build_metadata_proc(type)
+        method = "describe_#{type}"
+        api_proc = Proc.new {
+          unless opsworks_reachable?
+            raise VagrantPlugins::OpsWorks::Errors::ConnectError
+          end
+
+          aws_client.send(method, stack_id: @stack_id)[type.to_sym]
+        }
+        build_api_proc(type, api_proc)
+      end
+
+      def build_api_proc(type, metadata_proc)
+        if @cache.is_a?(Pathname)
+          unless File.directory?(@cache)
+            FileUtils.mkdir_p(@cache)
+          end
+
+          api_proc = metadata_proc
+
+          metadata_proc = Proc.new {
+            cache_file = @cache.join(type)
+
+            if cache_file.file?
+              Marshal.load(File.read(cache_file))
+            else
+              data = api_proc.call
+              File.open(cache_file, 'w') {|f| f.puts Marshal.dump(data)}
+              data
+            end
+          }
+        end
+
+        metadata_proc
+      end
+
+      def opsworks_reachable?
+        require 'open-uri'
+        begin
+          true if open('https://opsworks.us-east-1.amazonaws.com', { read_timeout: 2 })
+        rescue
+          false
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-opsworks/config.rb

@@ -0,0 +1,156 @@
+module VagrantPlugins
+  module OpsWorks
+    class Config < ::Vagrant.plugin('2', :config)
+      # @return [Boolean]
+      #   disable use of OpsWorks in Vagrant
+      attr_accessor :enabled
+
+      # @return [Boolean]
+      #   disable use of OpsWorks Cache
+      attr_accessor :cache
+
+      # @return [String]
+      #   OpsWorks agent version
+      attr_accessor :agent_version
+
+      # @return [String]
+      #   OpsWorks agent bucket
+      attr_accessor :agent_bucket
+
+      # @return [String]
+      #   OpsWorks asset bucket
+      attr_accessor :asset_bucket
+
+      # @return [String]
+      #   OpsWorks stack id
+      attr_accessor :stack_id
+
+      # @return [String]
+      #   OpsWorks hostname suffix
+      attr_accessor :hostname_suffix
+
+      # @return [Array]
+      #   Applications to ignore in OpsWorks stack
+      attr_accessor :ignore_apps
+
+      # @return [Array]
+      #   Instances to ignore in OpsWorks stack
+      attr_accessor :ignore_instances
+
+      # @return [Array]
+      #   Layers to ignore in OpsWorks stack
+      attr_accessor :ignore_layers
+
+      # @return [Array]
+      #   Recipes to ignore in OpsWorks stack
+      attr_accessor :ignore_recipes
+
+      # @return [Hash]
+      attr_accessor :supplimental_json
+
+      def initialize
+        super
+
+        @agent_version     = UNSET_VALUE
+        @agent_bucket      = UNSET_VALUE
+        @asset_bucket      = UNSET_VALUE
+        @cache             = UNSET_VALUE
+        @enabled           = UNSET_VALUE
+        @stack_id          = UNSET_VALUE
+        @hostname_suffix   = UNSET_VALUE
+        @ignore_apps       = UNSET_VALUE
+        @ignore_instances  = UNSET_VALUE
+        @ignore_layers     = UNSET_VALUE
+        @ignore_recipes    = UNSET_VALUE
+        @supplimental_json = UNSET_VALUE
+      end
+
+      def finalize!
+        @agent_version     = "327"                                       if @agent_version     == UNSET_VALUE
+        @agent_bucket      = "opsworks-instance-agent.s3.amazonaws.com"  if @agent_bucket      == UNSET_VALUE
+        @asset_bucket      = "opsworks-instance-assets.s3.amazonaws.com" if @asset_bucket      == UNSET_VALUE
+        @cache             = true                                        if @cache             == UNSET_VALUE
+        @enabled           = @stack_id == UNSET_VALUE ? false : true     if @enabled           == UNSET_VALUE
+        @hostname_suffix   = '.vm'                                       if @hostname_suffix   == UNSET_VALUE
+        @ignore_apps       = Array.new                                   if @ignore_apps       == UNSET_VALUE
+        @ignore_instances  = Array.new                                   if @ignore_instances  == UNSET_VALUE
+        @ignore_layers     = Array.new                                   if @ignore_layers     == UNSET_VALUE
+        @ignore_recipes    = Array.new                                   if @ignore_recipes    == UNSET_VALUE
+        @supplimental_json = Hash.new                                    if @supplimental_json == UNSET_VALUE
+        @supplimental_json = merge_hash({
+                                          :opsworks => {
+                                            :agent_version => @agent_version,
+                                            :ruby_version => '2.0.0',
+                                            :ruby_stack => 'ruby',
+                                            :stack => {
+                                              :rds_instances => [{:engine => 'mysql'}]
+                                            }
+                                          },
+                                          :ssh_users => {
+                                            Process.uid => {
+                                              :name => Etc.getlogin,
+                                              :public_key => File.exists?(File.expand_path('~/.ssh/id_rsa.pub')) ? File.read(File.expand_path('~/.ssh/id_rsa.pub')) : nil,
+                                              :sudoer => true
+                                            },
+                                          },
+                                          :sudoers => [{:name => 'vagrant'}]
+                                        }, @supplimental_json)
+      end
+
+      # TODO: refactor hash merging logic to mixin
+      # def merge(other)
+      #   super.tap do |result|
+      #     result.ignore_apps       = Array.new if other.ignore_apps.nil?
+      #     result.ignore_instances  = Array.new if other.ignore_instances.nil?
+      #     result.ignore_layers     = Array.new if other.ignore_layers.nil?
+      #     result.ignore_recipes    = Array.new if other.ignore_recipes.nil?
+      #     result.stack_id          = @stack_id                                               unless other.stack_id == UNSET_VALUE
+      #     result.ignore_instances  = @ignore_instances.concat(other.ignore_instances)        if other.ignore_instances.is_a?(Array) && @ignore_instances  != UNSET_VALUE
+      #     result.ignore_layers     = @ignore_layers.concat(other.ignore_layers)              if other.ignore_layers.is_a?(Array)    && @ignore_layers     != UNSET_VALUE
+      #     result.ignore_recipes    = @ignore_recipes.concat(other.ignore_recipes)            if other.ignore_recipes.is_a?(Array)   && @ignore_recipes    != UNSET_VALUE
+      #     result.supplimental_json = merge_hash(@supplimental_json, other.supplimental_json) if other.supplimental_json.is_a?(Hash) && @supplimental_json != UNSET_VALUE
+      #   end
+      # end
+
+      def validate(machine)
+        errors = Array.new
+        unless [TrueClass, FalseClass].include?(enabled.class)
+          errors << I18n.t('vagrant_opsworks.config.not_a_bool', {
+            :config_key => 'opsworks.enabled'
+          })
+        end
+
+        unless [TrueClass, FalseClass].include?(cache.class)
+          errors << I18n.t('vagrant_opsworks.config.not_a_bool', {
+            :config_key => 'opsworks.cache'
+          })
+        end
+
+        {'opsworks configuration' => errors}
+      end
+
+      protected
+
+      def merge_hash(old, new)
+        old = unsymbolize_keys(old)
+        new = unsymbolize_keys(new)
+
+        new.each_pair{|current_key,new_value|
+          old_value = old[current_key]
+
+          old[current_key] = if old_value.is_a?(Hash) && new_value.is_a?(Hash)
+                               merge_hash(old_value, new_value)
+                             else
+                               new_value
+                             end
+        }
+        old
+      end
+
+      def unsymbolize_keys(h)
+        return Hash[h.map{ |k,v| [k.to_s, v] }]
+      end
+
+    end
+  end
+end

data/lib/vagrant-opsworks/custom_json.rb

@@ -0,0 +1,22 @@
+module VagrantPlugins::OpsWorks
+  require 'vagrant/util/hash_with_indifferent_access'
+  class CustomJson < ::Vagrant::Util::HashWithIndifferentAccess
+
+    def deep_merge(other_json, &block)
+      dup.deep_merge!(other_json, &block)
+    end
+
+    def deep_merge!(other_json, &block)
+      other_json.each_pair do |k,theirs|
+        ours = self[k]
+        if ours.is_a?(CustomJson) && theirs.is_a?(Hash)
+          self[k] = ours.deep_merge!(theirs, &block)
+        else
+          self[k] = block && ours ? block.call(k, ours, theirs) : theirs
+        end
+      end
+      self
+    end
+
+  end
+end

data/lib/vagrant-opsworks/env.rb

@@ -0,0 +1,19 @@
+module VagrantPlugins
+  module OpsWorks
+    require_relative 'stack'
+    class Env
+      # @return [Vagrant::UI::Colored]
+      attr_accessor :ui
+      # @return [Pathname]
+      attr_accessor :data_directory
+
+      attr_accessor :client
+
+      def initialize
+        @ui               = ::Vagrant::UI::Colored.new
+        @ui.opts[:target] = 'OpsWorks'
+      end
+
+    end
+  end
+end

data/lib/vagrant-opsworks/env_old.rb

@@ -0,0 +1,162 @@
+module VagrantPlugins
+  module OpsWorks
+    require_relative 'stack'
+    class Env
+      # @return [Vagrant::UI::Colored]
+      attr_accessor :ui
+      # @return [VagrantPlugins::OpsWorks::Config]
+      attr_accessor :config
+      # @return [Pathname]
+      attr_accessor :data_directory
+
+      def initialize
+        @ui               = ::Vagrant::UI::Colored.new
+        @ui.opts[:target] = 'OpsWorks'
+        @logger = Log4r::Logger.new("vagrantplugins::opsworks::env")
+      end
+
+      # @return [Boolean]
+      def enabled?
+        begin
+          config.enabled
+        rescue
+          false
+        end
+      end
+
+      # @return [Boolean]
+      def cache_enabled?
+        begin
+          config.cache
+        rescue
+          false
+        end
+      end
+
+      # @return [Pathname]
+      def cache_directory
+        @data_directory.join('cache') if cache_enabled?
+      end
+
+      # @return [String]
+      def agent_version
+        config.agent_version unless config.nil?
+      end
+
+      # @return [String]
+      def agent_bucket
+        config.agent_bucket unless config.nil?
+      end
+
+      # @return [String]
+      def asset_bucket
+        config.asset_bucket unless config.nil?
+      end
+
+      # @return [String]
+      def stack_id
+        config.stack_id unless config.nil?
+      end
+
+      # @return [String]
+      def hostname_suffix
+        config.hostname_suffix unless config.nil?
+      end
+
+      # @return [Array]
+      def ignore_apps
+        config.ignore_apps unless config.nil?
+      end
+
+      # @return [Array]
+      def ignore_instances
+        config.ignore_instances unless config.nil?
+      end
+
+      # @return [Array]
+      def ignore_layers
+        config.ignore_layers unless config.nil?
+      end
+
+      # @return [Array]
+      def ignore_recipes
+        config.ignore_recipes unless config.nil?
+      end
+
+      # @return [Array]
+      def supplimental_json
+        config.supplimental_json unless config.nil?
+      end
+
+      # @return [VagrantPlugins::OpsWorks::Stack::Stack]
+      def stack
+        if stack_id
+          VagrantPlugins::OpsWorks::Stack::Stack.new(self, client.stack)
+        end
+      end
+
+      # @return [Hash]
+      def apps
+        if stack_id
+          apps = {}
+          client.apps.each do |a|
+            unless ignore_apps.include?(a[:shortname])
+              app = {
+                :application => a[:shortname],
+                :application_type => a[:type],
+                :environment => a[:environment].nil? ? {} : Hash[a[:environment].select{|e| !e[:secure] }.map{|e| [e[:key], e[:value]]}],
+                :auto_bundle_on_deploy => a[:attributes]['AutoBundleOnDeploy'],
+                :deploying_user => Etc.getlogin,
+                :document_roos => a[:attributes]['DocumentRoot'],
+                :domains => a[:domains],
+                :database => {},
+                :memcached => { :host => nil, :port => 11211 },
+                :scm => {}
+              }
+              if a[:app_source][:type] == 'git'
+                app[:scm] = {
+                  :scm_type => 'git',
+                  :repository => a[:app_source][:url],
+                  :revision => a[:app_source][:revision],
+                  :ssh_key => nil,
+                  :user => nil,
+                  :password => nil
+                }
+              end
+              apps[a[:shortname]] = app
+            end
+          end
+          apps
+        end
+      end
+
+      # @return [Vagrant::Registry]
+      def instances
+        if stack_id
+          instances = Vagrant::Registry.new
+          client.instances.sort_by{|i| i[:hostname]}.each do |i|
+            unless ignore_instances.include?(i[:hostname])
+              instances.register(i[:hostname]) {
+                VagrantPlugins::OpsWorks::Stack::Instance.new(self, i)
+              }
+            end
+          end
+          instances
+        end
+      end
+
+      # @return [Vagrant::Registry]
+      def layers
+        client.layers
+      end
+
+      protected
+
+      # @return [VagrantPlugins::OpsWorks::Client]
+      def client
+        require_relative 'client'
+        @client ||= Client.new(stack_id, cache_directory)
+      end
+    end
+  end
+end

data/lib/vagrant-opsworks/errors.rb

@@ -0,0 +1,13 @@
+module VagrantPlugins
+  module OpsWorks
+    module Errors
+      class OpsWorksError < ::Vagrant::Errors::VagrantError
+        error_namespace('vagrant_opsworks.errors')
+      end
+
+      class ConnectError < OpsWorksError
+        error_key(:connect)
+      end
+    end
+  end
+end

data/lib/vagrant-opsworks/loader/client.rb

@@ -0,0 +1,19 @@
+module VagrantPlugins::OpsWorks::Loader
+  class Client
+
+    def initialize(app, opsworks)
+      @app      = app
+      @opsworks = opsworks
+    end
+
+    def call(env)
+      return @app.pass(env) unless @opsworks.enabled
+
+      require_relative '../client'
+      env[:client] = VagrantPlugins::OpsWorks::Client.new(@opsworks.stack_id)
+
+      @app.pass(env)
+    end
+
+  end
+end

data/lib/vagrant-opsworks/loader/instances.rb

@@ -0,0 +1,78 @@
+module VagrantPlugins::OpsWorks::Loader
+  class Instances
+
+    def initialize(app, opsworks)
+      @app      = app
+      @opsworks = opsworks
+    end
+
+    def call(env)
+      return @app.pass(env) unless @opsworks.enabled
+
+      instances = env[:client].instances.sort_by{|i| i['hostname']}
+
+      apps = {}
+      env[:client].apps.each do |a|
+        next if @opsworks.ignore_apps.include?(a['name'])
+        app = {
+          'application'           => a['name'],
+          'application_type'      => a['type'],
+          'environment'           => a['environment'].nil? ? {} : Hash[a['environment'].select{|e| !e[:secure] }.map{|e| [e[:key], e[:value]]}],
+          'auto_bundle_on_deploy' => a['attributes']['AutoBundleOnDeploy'],
+          'deploying_user'        => Etc.getlogin,
+          'document_root'         => a['attributes']['DocumentRoot'],
+          'domains'               => a['domains'],
+          'database'              => {},
+          'memcached'             => { 'host' => nil, 'port' => 11211 },
+          'scm'                   => {}
+        }
+        if a['app_source'][:type] == 'git'
+          app['scm'] = {
+            'scm_type'   => 'git',
+            'repository' => a[:app_source][:url],
+            'ssh_key'    => nil,
+            'user'       => nil,
+            'password'   => nil
+          }
+        end
+        apps[a['name']] = app
+      end
+
+      instances.each do |i|
+        next if @opsworks.ignore_instances.include?(i['hostname'])
+        env[:config].vm.define i['hostname'] do |node|
+          VagrantPlugins::OpsWorks::Loader.select_vmbox(env[:config], i['os'])
+
+          node.vm.provision :chef_solo do |chef|
+            pkgs = []
+            i['layer_ids'].each do |l|
+              next if @opsworks.ignore_layers.include?(l['name'])
+              layer = env[:client].layers.select{|x| x['layer_id'] == l}.first
+              chef.add_role layer['name']
+              pkgs << layer['packages']
+            end
+
+            custom_json = env[:client].stack.custom_json.dup
+            custom_json.merge!({
+              'opsworks' => {
+                'activity'      => 'setup',
+                'agent_version' => @opsworks.agent_version,
+                'sent_at'       => Time.new.to_i,
+                'deployment'    => SecureRandom.uuid
+              },
+              'dependencies' => {
+                'debs' => Hash[pkgs.flatten.map{|x| [x, nil]}]
+              },
+              'deploy' => apps
+            })
+
+            chef.json = custom_json
+          end
+        end
+      end
+
+      @app.pass(env)
+    end
+
+  end
+end