mccloud 0.0.1

data/lib/mccloud/provisioner/chef_solo.rb

@@ -0,0 +1,149 @@
+require 'mccloud/util/rsync'
+require 'mccloud/util/ssh'
+module Mccloud
+  module Provisioner
+    class ChefSolo
+      attr_accessor :cookbooks_path 
+      attr_accessor :role_path 
+      attr_accessor :provisioning_path
+      attr_accessor :json
+      attr_reader   :roles
+      attr_accessor :node_name
+      attr_accessor :log_level
+      attr_accessor :http_proxy
+      attr_accessor :http_proxy_user
+      attr_accessor :http_proxy_pass
+      attr_accessor :https_proxy
+      attr_accessor :https_proxy_user
+      attr_accessor :https_proxy_pass
+      attr_accessor :no_proxy
+
+      def initialize
+        @provisioning_path="/tmp/mccloud-chef"
+        @json={ :instance_role => "mccloud"}
+      end
+      
+      def run(vm)
+        puts "we ran mylord"
+        json=@json.to_json
+        puts json
+        cooks=Array.new
+        @cookbooks_path.each do |cook|
+          cooks << File.join("/tmp/"+File.basename(cook))
+        end
+        cookpath="cookbook_path [\""+cooks.join("\",\"")+"\"]"
+        loglevel="loglevel :debug"
+        configfile=['file_cache_path "/var/chef-solo"',cookpath,loglevel]
+        vm.instance.scp(StringIO.new(json),"/tmp/dna.json")
+        vm.instance.scp(StringIO.new(configfile.join("\n")),"/tmp/solo.rb")
+
+        # Share the cookbooks
+        cookbooks_path.each do |path|
+          Mccloud::Util.rsync(path,vm,vm.instance)
+        end
+        
+        puts "Running chef-solo"
+        options={ :port => 22, :keys => [ vm.key ], :paranoid => false, :keys_only => true}
+        Mccloud::Util.ssh(vm.instance.public_ip_address,vm.user,options,"sudo chef-solo -c /tmp/solo.rb -j /tmp/dna.json -l debug")
+        
+      end
+      # Returns the run list for the provisioning
+      def run_list
+        json[:run_list] ||= []
+      end
+      # Sets the run list to the specified value
+      def run_list=(value)
+        json[:run_list] = value
+      end
+      def add_role(name)
+        name = "role[#{name}]" unless name =~ /^role\[(.+?)\]$/
+        run_list << name
+      end
+      def add_recipe(name)
+        name = "recipe[#{name}]" unless name =~ /^recipe\[(.+?)\]$/
+        run_list << name
+      end
+
+      def setup_config(template, filename, template_vars)
+        config_file = TemplateRenderer.render(template, {
+          :log_level => config.log_level.to_sym,
+          :http_proxy => config.http_proxy,
+          :http_proxy_user => config.http_proxy_user,
+          :http_proxy_pass => config.http_proxy_pass,
+          :https_proxy => config.https_proxy,
+          :https_proxy_user => config.https_proxy_user,
+          :https_proxy_pass => config.https_proxy_pass,
+          :no_proxy => config.no_proxy
+          }.merge(template_vars))
+
+          # file_cache_path "/var/chef-solo"
+          # cookbook_path "/var/chef-solo/cookbooks"
+
+          #vm.ssh.upload!(StringIO.new(config_file), File.join(config.provisioning_path, filename))
+        end
+
+        def setup_json
+
+          json = Mccloud::Config.config.chef.json.to_json
+          #vm.ssh.upload!(StringIO.new(json), File.join(config.provisioning_path, "dna.json"))
+	  return json
+        end
+
+        def prepare
+          share_cookbook_folders
+          share_role_folders
+        end
+
+        def provision!
+          verify_binary("chef-solo")
+          chown_provisioning_folder
+          setup_json
+          setup_solo_config
+          run_chef_solo
+        end
+
+        def share_cookbook_folders
+          host_cookbook_paths.each_with_index do |cookbook, i|
+            env.config.vm.share_folder("v-csc-#{i}", cookbook_path(i), cookbook)
+          end
+        end
+
+        def share_role_folders
+          host_role_paths.each_with_index do |role, i|
+            env.config.vm.share_folder("v-csr-#{i}", role_path(i), role)
+          end
+        end
+
+        def setup_solo_config
+          setup_config("chef_solo_solo", "solo.rb", {
+            :node_name => config.node_name,
+            :provisioning_path => config.provisioning_path,
+            :cookbooks_path => cookbooks_path,
+      		:log_level        => :debug,
+            :recipe_url => config.recipe_url,
+            :roles_path => roles_path,
+            })
+          end
+          def run_chef_solo
+            commands = ["cd #{config.provisioning_path}", "chef-solo -c solo.rb -j dna.json"]
+
+            env.ui.info I18n.t("vagrant.provisioners.chef.running_solo")
+            vm.ssh.execute do |ssh|
+              ssh.sudo!(commands) do |channel, type, data|
+                if type == :exit_status
+                  ssh.check_exit_status(data, commands)
+                else
+                  env.ui.info("#{data}: #{type}")
+                end
+              end
+            end
+          end
+        end
+      end #Module Provisioners
+    end #Module Mccloud
+
+
+#cookbook_path     "/etc/chef/recipes/cookbooks" 
+#log_level         :info
+#file_store_path  "/etc/chef/recipes/" 
+#file_cache_path  "/etc/chef/recipes/" 

data/lib/mccloud/provisioner/puppet.rb

@@ -0,0 +1,39 @@
+require 'mccloud/util/rsync'
+require 'mccloud/util/ssh'
+module Mccloud
+  module Provisioner
+    class Puppet
+      
+            attr_accessor :manifest_file
+            attr_accessor :manifests_path
+            attr_accessor :module_path
+            attr_accessor :pp_path
+            attr_accessor :options
+
+            def initialize
+              @manifest_file = nil
+              @manifests_path = "manifests"
+              @module_path = nil
+              @pp_path = "/tmp/vagrant-puppet"
+              @options = []
+            end
+      
+      def run(vm)
+#        @module_paths.each do |from, to|
+#            Mccloud::Util.rsync(path,vm,vm.instance)
+#        end
+
+#        @manifests_paths.each do |from, to|
+#            Mccloud::Util.rsync(path,vm,vm.instance)
+#        end
+        vm.instance.ssh("mkdir -p #{@pp_path}")
+        vm.instance.scp(@manifest_file,"#{@pp_path}/manifest.pp")      
+        
+        puts "Running puppet"
+        options={ :port => 22, :keys => [ vm.key ], :paranoid => false, :keys_only => true}
+        Mccloud::Util.ssh(vm.instance.public_ip_address,vm.user,options,"sudo puppet #{@pp_path}/manifest.pp")
+        
+      end
+    end #Class
+  end #Module Provisioners
+end #Module Mccloud

data/lib/mccloud/provisioner/vagrant/base.rb

@@ -0,0 +1,63 @@
+module Vagrant
+  module Provisioners
+    # The base class for a "provisioner." A provisioner is responsible for
+    # provisioning a Vagrant system. This has been abstracted out to provide
+    # support for multiple solutions such as Chef Solo, Chef Client, and
+    # Puppet.
+    class Base
+      include Vagrant::Util
+
+      # The environment which provisioner is running in. This is a
+      # {Vagrant::Action::Environment}
+      attr_reader :action_env
+
+      # The configuration for this provisioner. This will be an instance of
+      # the `Config` class which is part of the provisioner.
+      attr_reader :config
+
+      # Registers a provisioner with a given shortcut. This allows that provisioner
+      # to be referenced with the shortcut.
+      #
+      # @param [Symbol] shortcut
+      def self.register(shortcut)
+        registered[shortcut] = self
+      end
+
+      # Returns the provisioner associated with the given shortcut.
+      def self.registered
+        @@registered ||= {}
+      end
+
+      def initialize(env, config)
+        @action_env = env
+        @config = config
+      end
+
+      # Returns the actual {Vagrant::Environment} which this provisioner
+      # represents.
+      #
+      # @return [Vagrant::Environment]
+      def env
+        action_env.env
+      end
+
+      # Returns the VM which this provisioner is working on.
+      #
+      # @return [Vagrant::VM]
+      def vm
+        env.vm
+      end
+
+      # This is the method called to "prepare" the provisioner. This is called
+      # before any actions are run by the action runner (see {Vagrant::Actions::Runner}).
+      # This can be used to setup shared folders, forward ports, etc. Whatever is
+      # necessary on a "meta" level.
+      def prepare; end
+
+      # This is the method called to provision the system. This method
+      # is expected to do whatever necessary to provision the system (create files,
+      # SSH, etc.)
+      def provision!; end
+    end
+  end
+end

data/lib/mccloud/provisioner/vagrant/chef.rb

@@ -0,0 +1,130 @@
+module Vagrant
+  module Provisioners
+    # This class is a base class where the common functionality shared between
+    # chef-solo and chef-client provisioning are stored. This is **not an actual
+    # provisioner**. Instead, {ChefSolo} or {ChefServer} should be used.
+    class Chef < Base
+      def prepare
+        raise ChefError, :invalid_provisioner
+      end
+
+      def verify_binary(binary)
+        vm.ssh.execute do |ssh|
+          # Checks for the existence of chef binary and error if it
+          # doesn't exist.
+          ssh.sudo!("which #{binary}", :error_class => ChefError, :_key => :chef_not_detected, :binary => binary)
+        end
+      end
+
+      def chown_provisioning_folder
+        vm.ssh.execute do |ssh|
+          ssh.sudo!("mkdir -p #{config.provisioning_path}")
+          ssh.sudo!("chown #{env.config.ssh.username} #{config.provisioning_path}")
+        end
+      end
+
+      def setup_config(template, filename, template_vars)
+        config_file = TemplateRenderer.render(template, {
+          :log_level => config.log_level.to_sym,
+          :http_proxy => config.http_proxy,
+          :http_proxy_user => config.http_proxy_user,
+          :http_proxy_pass => config.http_proxy_pass,
+          :https_proxy => config.https_proxy,
+          :https_proxy_user => config.https_proxy_user,
+          :https_proxy_pass => config.https_proxy_pass,
+          :no_proxy => config.no_proxy
+        }.merge(template_vars))
+
+        vm.ssh.upload!(StringIO.new(config_file), File.join(config.provisioning_path, filename))
+      end
+
+      def setup_json
+        env.ui.info I18n.t("vagrant.provisioners.chef.json")
+
+        # Set up initial configuration
+        data = {
+          :config => env.config.to_hash,
+          :directory => env.config.vm.shared_folders["v-root"][:guestpath],
+        }
+
+        # And wrap it under the "vagrant" namespace
+        data = { :vagrant => data }
+
+        # Merge with the "extra data" which isn't put under the
+        # vagrant namespace by default
+        data.merge!(config.json)
+
+        json = data.to_json
+
+        vm.ssh.upload!(StringIO.new(json), File.join(config.provisioning_path, "dna.json"))
+      end
+    end
+
+    class Chef < Base
+      class ChefError < Errors::VagrantError
+        error_namespace("vagrant.provisioners.chef")
+      end
+    end
+
+    class Chef < Base
+      # This is the configuration which is available through `config.chef`
+      class Config < Vagrant::Config::Base
+        # Shared config
+        attr_accessor :node_name
+        attr_accessor :provisioning_path
+        attr_accessor :log_level
+        attr_accessor :json
+        attr_accessor :http_proxy
+        attr_accessor :http_proxy_user
+        attr_accessor :http_proxy_pass
+        attr_accessor :https_proxy
+        attr_accessor :https_proxy_user
+        attr_accessor :https_proxy_pass
+        attr_accessor :no_proxy
+
+        def initialize
+          @provisioning_path = "/tmp/vagrant-chef"
+          @log_level = :info
+          @json = { :instance_role => "vagrant" }
+          @http_proxy = nil
+          @http_proxy_user = nil
+          @http_proxy_pass = nil
+          @https_proxy = nil
+          @https_proxy_user = nil
+          @https_proxy_pass = nil
+          @no_proxy = nil
+        end
+
+        # Returns the run list for the provisioning
+        def run_list
+          json[:run_list] ||= []
+        end
+
+        # Sets the run list to the specified value
+        def run_list=(value)
+          json[:run_list] = value
+        end
+
+        # Adds a recipe to the run list
+        def add_recipe(name)
+          name = "recipe[#{name}]" unless name =~ /^recipe\[(.+?)\]$/
+          run_list << name
+        end
+
+        # Adds a role to the run list
+        def add_role(name)
+          name = "role[#{name}]" unless name =~ /^role\[(.+?)\]$/
+          run_list << name
+        end
+
+        def instance_variables_hash
+          # Overridden so that the 'json' key could be removed, since its just
+          # merged into the config anyways
+          result = super
+          result.delete("json")
+          result
+        end
+      end
+    end
+  end
+end

data/lib/mccloud/provisioner/vagrant/chef_server.rb

@@ -0,0 +1,103 @@
+require 'pathname'
+
+module Vagrant
+  module Provisioners
+    # This class implements provisioning via chef-client, allowing provisioning
+    # with a chef server.
+    class ChefServer < Chef
+      register :chef_server
+
+      class Config < Chef::Config
+        attr_accessor :chef_server_url
+        attr_accessor :validation_key_path
+        attr_accessor :validation_client_name
+        attr_accessor :client_key_path
+        attr_accessor :file_cache_path
+        attr_accessor :file_backup_path
+
+        def initialize
+          super
+
+          @validation_client_name = "chef-validator"
+          @client_key_path = "/etc/chef/client.pem"
+          @file_cache_path = "/srv/chef/file_store"
+          @file_backup_path = "/srv/chef/cache"
+        end
+
+        def validate(errors)
+          super
+
+          errors.add(I18n.t("vagrant.config.chef.server_url_empty")) if !chef_server_url || chef_server_url.strip == ""
+          errors.add(I18n.t("vagrant.config.chef.validation_key_path")) if !validation_key_path
+          errors.add(I18n.t("vagrant.config.chef.run_list_empty")) if json[:run_list] && run_list.empty?
+        end
+      end
+
+      def prepare
+        raise ChefError, :server_validation_key_required if config.validation_key_path.nil?
+        raise ChefError, :server_validation_key_doesnt_exist if !File.file?(validation_key_path)
+        raise ChefError, :server_url_required if config.chef_server_url.nil?
+      end
+
+      def provision!
+        verify_binary("chef-client")
+        chown_provisioning_folder
+        create_client_key_folder
+        upload_validation_key
+        setup_json
+        setup_server_config
+        run_chef_client
+      end
+
+      def create_client_key_folder
+        env.ui.info I18n.t("vagrant.provisioners.chef.client_key_folder")
+        path = Pathname.new(config.client_key_path)
+
+        vm.ssh.execute do |ssh|
+          ssh.sudo!("mkdir -p #{path.dirname}")
+        end
+      end
+
+      def upload_validation_key
+        env.ui.info I18n.t("vagrant.provisioners.chef.upload_validation_key")
+        vm.ssh.upload!(validation_key_path, guest_validation_key_path)
+      end
+
+      def setup_server_config
+        setup_config("chef_server_client", "client.rb", {
+          :node_name => config.node_name,
+          :chef_server_url => config.chef_server_url,
+          :validation_client_name => config.validation_client_name,
+          :validation_key => guest_validation_key_path,
+          :client_key => config.client_key_path,
+          :file_cache_path => config.file_cache_path,
+          :file_backup_path => config.file_backup_path
+        })
+      end
+
+      def run_chef_client
+        commands = ["cd #{config.provisioning_path}",
+                    "chef-client -c client.rb -j dna.json"]
+
+        env.ui.info I18n.t("vagrant.provisioners.chef.running_client")
+        vm.ssh.execute do |ssh|
+          ssh.sudo!(commands) do |channel, type, data|
+            if type == :exit_status
+              ssh.check_exit_status(data, commands)
+            else
+              env.ui.info("#{data}: #{type}")
+            end
+          end
+        end
+      end
+
+      def validation_key_path
+        File.expand_path(config.validation_key_path, env.root_path)
+      end
+
+      def guest_validation_key_path
+        File.join(config.provisioning_path, "validation.pem")
+      end
+    end
+  end
+end