mccloud 0.0.13 → 0.0.14

data/lib/mccloud/provisioner/chef_solo.rb

@@ -1,13 +1,30 @@
-require 'mccloud/util/rsync'
-require 'mccloud/util/ssh'
+require 'erb'
+require 'ostruct'
+require 'tempfile'
+
+
 module Mccloud
   module Provisioner
+    class ErbBinding < OpenStruct
+      def get_binding
+        return binding()
+      end
+    end
+
     class ChefSolo
-      attr_accessor :cookbooks_path 
-      attr_accessor :role_path 
+
+      attr_reader   :name
+      attr_reader   :env
+
+      attr_accessor :cookbooks_path
+      attr_accessor :roles_path
       attr_accessor :provisioning_path
+      attr_accessor :data_bags_path
       attr_accessor :json
+      attr_accessor :json_erb
+      attr_accessor :clean_after_run
       attr_reader   :roles
+
       attr_accessor :node_name
       attr_accessor :log_level
       attr_accessor :http_proxy
@@ -18,37 +35,133 @@ module Mccloud
       attr_accessor :https_proxy_pass
       attr_accessor :no_proxy
 
-      def initialize
+      def initialize(env)
+        @env=env
         @provisioning_path="/tmp/mccloud-chef"
         @json={ :instance_role => "mccloud"}
+        @json_erb=true
+        @name ="chef_solo"
+        @log_level="info"
+        @cookbooks_path =  []
+        @clean_after_run = true
       end
-      
-      def run(vm)
-        puts "we ran mylord"
-        json=@json.to_json
-        puts json
+
+      def mccloudconfig_to_json
+      end
+
+      def run(server)
+        if @json_erb
+          # http://stackoverflow.com/questions/1338960/ruby-templates-how-to-pass-variables-into-inlined-erb
+
+          public_ips=Hash.new
+          private_ips=Hash.new
+          server.provider.vms.each do |name,vm|
+            public_ips[name]=vm.public_ip_address
+            private_ips[name]=vm.private_ip_address
+          end
+
+          # http://www.techques.com/question/1-3242470/Problem-using-OpenStruct-with-ERB
+          # We only want specific variables for ERB
+          data = { :public_ips => public_ips, :private_ips => private_ips}
+
+          vars = ErbBinding.new(data)
+
+          # Added vmname in mccloud
+          @json.merge!({ :mccloud => {:name => server.name }})
+
+          template = @json.to_json.to_s
+          erb = ERB.new(template)
+
+          vars_binding = vars.send(:get_binding)
+          result=erb.result(vars_binding)
+
+          #Result = String
+          #JSON.parse result = Hash
+          #.to_json = String containing JSON formatting of Hash
+
+          json=JSON.parse(result).to_json
+
+        else
+          json=@json.to_json
+        end
+
         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")
+
+        # Prepare solo.rb
+        configfile=['file_cache_path "/var/chef-solo"']
+        configfile << "cookbook_path [\""+cooks.join("\",\"")+"\"]"
+        configfile << "log_level #{log_level}"
+        configfile << "role_path \"/tmp/#{File.basename(roles_path)}\"" unless roles_path.nil?
+        configfile << "data_bag_path \"/tmp/#{File.basename(data_bags_path)}\"" unless data_bags_path.nil?
+
+        #convert string to Tempfile (instead of StringIO), as server.transfer expects a file with a filename
+        temp_file_json = Tempfile.new("dna_json")
+        temp_file_json.write(json)
+        temp_file_json.close
+
+        temp_file_solo = Tempfile.new("solo_rb")
+        temp_file_solo.write(configfile.join("\n"))
+        temp_file_solo.close
+
+        server.transfer(temp_file_json.path,"/tmp/dna.json")
+        server.transfer(temp_file_solo.path,"/tmp/solo.rb")
 
         # Share the cookbooks
+        i=0
         cookbooks_path.each do |path|
-          Mccloud::Util.rsync(path,vm,vm.instance)
+          server.share_folder("cookbook_path-#{i}","/tmp/" + File.basename(path),path,{:mute => true})
+          i=i+1
         end
-        
-        puts "Running chef-solo"
-        options={ :port => 22, :keys => [ vm.private_key ], :paranoid => false, :keys_only => true}
-        if vm.user=="root"
-          Mccloud::Util.ssh(vm.instance.public_ip_address,vm.user,options,"sudo chef-solo -c /tmp/solo.rb -j /tmp/dna.json -l debug")
-        else
-          Mccloud::Util.ssh(vm.instance.public_ip_address,vm.user,options,"chef-solo -c /tmp/solo.rb -j /tmp/dna.json -l debug")
+
+        unless roles_path.nil?
+          server.share_folder("roles_path","/tmp/" + File.basename(roles_path),roles_path,{:mute => true})
+        end
+
+        unless data_bags_path.nil?
+          server.share_folder("databags_path","/tmp/" + File.basename(data_bags_path),data_bags_path,{:mute => true})
         end
+
+        server.share
+
+        env.ui.info "[#{server.name}] - [#{@name}] - running chef-solo"
+        env.ui.info "[#{server.name}] - [#{@name}] - login as #{server.user}"
+        begin
+          if server.user=="root"
+            server.execute("chef-solo -c /tmp/solo.rb -j /tmp/dna.json -l #{@log_level}")
+          else
+            server.execute("sudo -i chef-solo -c /tmp/solo.rb -j /tmp/dna.json -l #{@log_level}")
+
+            #server.execute("sudo chef-solo -c /tmp/solo.rb -j /tmp/dna.json -l #{@log_level}")
+          end
+        rescue Exception
+        ensure
+          if @clean_after_run == true
+            env.ui.info "[#{server.name}] - [#{@name}] - Cleaning up dna.json"
+            server.execute("rm /tmp/dna.json",{:mute => true})
+            env.ui.info "[#{server.name}] - [#{@name}] - Cleaning up solo.json"
+            server.execute("rm /tmp/solo.rb", {:mute => true})
+            cookbooks_path.each do |path|
+              env.ui.info "[#{server.name}] - [#{@name}] - Cleaning cookbook_path #{path}"
+              server.execute("rm -rf /tmp/#{File.basename(path)}",{:mute => true})
+            end
+
+            unless roles_path.nil?
+                env.ui.info "[#{server.name}] - [#{@name}] - Cleaning roles_path #{roles_path}"
+                server.execute("rm -rf /tmp/#{File.basename(roles_path)}",{:mute => true})
+            end
+
+            unless data_bags_path.nil?
+                env.ui.info "[#{server.name}] - [#{@name}] - Cleaning data_bags_path #{data_bags_path}"
+                server.execute("rm -rf /tmp/#{File.basename(data_bags_path)}",{:mute => true})
+            end
+          end
+        end
+
+        #Cleaning up
+
       end
       # Returns the run list for the provisioning
       def run_list
@@ -76,77 +189,78 @@ module Mccloud
           :https_proxy => config.https_proxy,
           :https_proxy_user => config.https_proxy_user,
           :https_proxy_pass => config.https_proxy_pass,
+          :data_bag_path => config.data_bag_path,
+          :roles_path => config.roles_path,
           :no_proxy => config.no_proxy
-          }.merge(template_vars))
+        }.merge(template_vars))
 
-          # file_cache_path "/var/chef-solo"
-          # cookbook_path "/var/chef-solo/cookbooks"
+        # file_cache_path "/var/chef-solo"
 
-          #vm.ssh.upload!(StringIO.new(config_file), File.join(config.provisioning_path, filename))
-        end
+        #server.execute.upload!(StringIO.new(config_file), File.join(config.provisioning_path, filename))
+      end
 
-        def setup_json
+      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
+        json = Mccloud::Config.config.chef.json.to_json
+        #server.execute.upload!(StringIO.new(json), File.join(config.provisioning_path, "dna.json"))
+        return json
+      end
 
-        def prepare
-          share_cookbook_folders
-          share_role_folders
-        end
+      def prepare
+        share_cookbook_folders
+        share_role_folder
+      end
 
-        def provision!
-          verify_binary("chef-solo")
-          chown_provisioning_folder
-          setup_json
-          setup_solo_config
-          run_chef_solo
-        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
+      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
+      def share_role_folder
+        host_roles_path.each_with_index do |role, i|
+          env.config.vm.share_folder("v-csr-#{i}", roles_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
+      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,
+          :data_bags_path => data_bags_path,
+        })
+      end
+      def run_chef_solo
+        commands = ["cd #{config.provisioning_path}", "chef-solo -c solo.rb -j dna.json"]
+
+        server.execute.execute do |execute|
+          execute.sudo!(commands) do |channel, type, data|
+            if type == :exit_status
+              execute.check_exit_status(data, commands)
+            else
+              env.ui.info("#{data}: #{type}")
             end
           end
         end
-      end #Module Provisioners
-    end #Module Mccloud
+      end
+    end
+  end #Module Provisioners
+end #Module Mccloud
 
 
-#cookbook_path     "/etc/chef/recipes/cookbooks" 
+#cookbook_path     "/etc/chef/recipes/cookbooks"
 #log_level         :info
-#file_store_path  "/etc/chef/recipes/" 
-#file_cache_path  "/etc/chef/recipes/" 
+#file_store_path  "/etc/chef/recipes/"
+#file_cache_path  "/etc/chef/recipes/"

data/lib/mccloud/provisioner/puppet.rb

@@ -1,42 +1,215 @@
 require 'mccloud/util/rsync'
 require 'mccloud/util/ssh'
+require 'erb'
+require 'tempfile'
+
 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}")
-        puts "Synching manifest #{@manifest_file}"
-        vm.instance.scp(@manifest_file,"#{@pp_path}/manifest.pp")      
-        
-        puts "Running puppet"
-        options={ :port => 22, :keys => [ vm.private_key ], :paranoid => false, :keys_only => true}
-        if vm.user=="root"
-          Mccloud::Util.ssh(vm.instance.public_ip_address,vm.user,options,"puppet #{@pp_path}/manifest.pp")
+
+      attr_accessor :name
+      attr_accessor :env
+
+      attr_accessor :manifest_file
+      attr_accessor :manifests_path
+      attr_accessor :module_path
+      attr_accessor :pp_path
+      attr_accessor :options
+      attr_accessor :remote_environment
+
+      attr_reader   :server
+
+      def initialize(env)
+        @env=env
+        @manifest_file = nil
+        @manifests_path = "manifests"
+        @module_paths = []
+        @pp_path = "/tmp/mccloud-puppet"
+        @name="puppet"
+        @options = []
+        @remote_environment={}
+      end
+
+      # Returns the manifests path expanded relative to the root path of the
+      # environment.
+      def expanded_manifests_path
+        Pathname.new(manifests_path).expand_path(env.root_path)
+      end
+
+
+      # Returns the module paths as an array of paths expanded relative to the
+      # root path.
+      def expanded_module_paths
+        return [] if !module_path
+
+        # Get all the paths and expand them relative to the root path, returning
+        # the array of expanded paths
+        paths = module_path
+        paths = [paths] if !paths.is_a?(Array)
+        paths.map do |path|
+          Pathname.new(path).expand_path(env.root_path)
+        end
+      end
+
+      # Returns the manifests paths as an array of paths expanded relative to the
+      # root path.
+      def expanded_manifests_paths
+        return [] if !manifests_path
+
+        # Get all the paths and expand them relative to the root path, returning
+        # the array of expanded paths
+        paths = manifests_path
+        paths = [paths] if !paths.is_a?(Array)
+        paths.map do |path|
+          Pathname.new(path).expand_path(env.root_path)
+        end
+      end
+
+      def share_modules
+        i=0
+        expanded_module_paths.each do |path|
+          remote_path=File.join(pp_path,"modules-#{i}")
+          env.ui.info "Sharing module dir #{path}"
+          server.share_sync(path,remote_path,{:mute => false})
+          server.execute("chmod 700 '#{remote_path}'")
+          i=i+1
+        end
+      end
+
+      def share_manifests
+        i=0
+        expanded_manifests_paths.each do |path|
+          remote_path=File.join(pp_path,"manifests-#{i}")
+          env.ui.info "Sharing manifest dir #{path}"
+          server.execute("test -d '#{remote_path}' || mkdir -p '#{remote_path}'")
+          server.share_sync(path,remote_path,{:mute => false})
+          server.execute("chmod 700 '#{remote_path}'")
+          i=i+1
+        end
+      end
+
+      def set_module_paths
+        @module_paths = {}
+        expanded_module_paths.each_with_index do |path, i|
+          @module_paths[path] = File.join(@pp_path, "modules-#{i}")
+        end
+      end
+
+      def share_manifest
+        if @manifest_file.nil?
+          # Nothing to do here
+          return
+        end
+
+        full_path=Pathname.new(File.join(manifests_path,@manifest_file)).expand_path(env.root_path).to_s
+
+        # These are the default
+        dest=File.join(@pp_path,File.basename(@manifest_file))
+        src=full_path
+
+        # ERB file
+        if is_erb?(full_path)
+          env.ui.info "Interpreting ERB puppet manifest"
+
+          # Correct the src path
+          temp_file = Tempfile.new("puppet_erb")
+          src=temp_file.path
+          result=erbify(full_path)
+          File.open(temp_file,'w') { |f| f.write(result)}
+
+          # Correct the dest path
+          dest=File.join(@pp_path,File.basename(@manifest_file,".erb"))
+
+          # Immediately unlink it
+          #temp_file.close(true)
+        end
+
+        env.ui.info "Synching manifest #{src} -> #{dest}"
+        server.transfer(src,dest)
+      end
+
+      def is_erb?(filename)
+        result=File.extname(filename) == ".erb"
+        puts result
+        return result
+      end
+
+      def erbify(filename)
+
+        # Fill the array to pass to the ERB
+        public_ips=Hash.new
+        private_ips=Hash.new
+        server.provider.vms.each do |name,vm|
+          public_ips[name] = vm.public_ip_address
+          private_ips[name] = vm.private_ip_address
+        end
+
+        data = { :public_ips => public_ips, :private_ips => private_ips}
+        vars = ErbBinding.new(data)
+
+        template = File.read(filename)
+        erb = ERB.new(template)
+
+        vars_binding = vars.send(:get_binding)
+        result=erb.result(vars_binding)
+        return result
+
+      end
+
+      def prepare
+        share_manifests
+        share_modules
+        share_manifest
+        set_module_paths
+      end
+
+      def cleanup
+      end
+
+      def run(server)
+        @server=server
+        if @manifest_file.nil?
+          env.ui.info "No specific manifestfile specified defaulting to site.pp in the manifest dir"
+        end
+
+        env.logger.info "Starting puppet run"
+        server.execute("mkdir -p '#{@pp_path}'")
+        server.execute("chmod 700 '#{@pp_path}'")
+        prepare
+
+        env.ui.info "Running puppet"
+
+        pre_options=[]
+        unless @remote_environment.empty?
+          @remote_environment.each do |key,value|
+            pre_options << "#{key.to_s}=\"#{value}\""
+          end
+        end
+
+        puppet_options=[ "apply"]
+        @options.each do |o|
+          puppet_options << o
+        end
+
+
+        unless @module_paths.empty?
+          puppet_options << "--modulepath=#{@module_paths.values.join(':')}"
+        end
+
+        manifestdir="#{File.join(@pp_path,'manifests-0')}"
+        puppet_options << "--manifestdir=#{manifestdir}"
+
+        if @manifest_file.nil?
+          puppet_options << File.join(manifestdir,"site.pp")
         else
-          Mccloud::Util.ssh(vm.instance.public_ip_address,vm.user,options,"sudo puppet #{@pp_path}/manifest.pp")
+          if is_erb?(@manifest_file)
+            puppet_options << File.join(@pp_path,File.basename(@manifest_file,".erb"))
+          else
+            puppet_options << File.join(@pp_path,File.basename(@manifest_file))
+          end
         end
+
+        server.sudo("#{pre_options.join(" ")} puppet #{puppet_options.join(' ')}")
       end
     end #Class
   end #Module Provisioners

data/lib/mccloud/provisioner/shell.rb

@@ -0,0 +1,48 @@
+require 'erb'
+require 'ostruct'
+
+module Mccloud
+  module Provisioner
+
+    class Shell
+
+      attr_reader   :name
+      attr_reader   :env
+
+      attr_accessor :path
+      attr_accessor :inline
+      attr_accessor :sudo
+
+      def initialize(env)
+        @env=env
+        @sudo=false
+        @name ="shell"
+        @inline="who am i"
+        @log_level="info"
+      end
+
+      def run(server)
+        server.transfer(StringIO.new(@inline),"/tmp/shell-provisioner.sh") unless @inline.nil?
+        server.transfer(path,"/tmp/shell-provisioner.sh") unless @path.nil?
+
+        server.execute("chmod +x /tmp/shell-provisioner.sh",{:mute => true})
+
+                env.ui.info "[#{server.name}] - [#{@name}] - running shell"
+                env.ui.info "[#{server.name}] - [#{@name}] - login as #{server.user}"
+
+                begin
+                  if !@sudo || server.user=="root"
+                    server.execute("/tmp/shell-provisioner.sh")
+                  else
+                    server.execute("sudo /tmp/shell-provisioner.sh")
+                  end
+                rescue Exception
+                ensure
+                  env.ui.info "[#{server.name}] - [#{@name}] - Cleaning up script"
+                  server.execute("rm /tmp/shell-provisioner.sh",{:mute => true})
+                end
+      end
+
+    end
+  end #Module Provisioners
+end #Module Mccloud