mccloud 0.0.1

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

@@ -0,0 +1,142 @@
+module Vagrant
+  module Provisioners
+    # This class implements provisioning via chef-solo.
+    class ChefSolo < Chef
+      register :chef_solo
+
+      class Config < Chef::Config
+        attr_accessor :cookbooks_path
+        attr_accessor :roles_path
+        attr_accessor :recipe_url
+
+        def initialize
+          super
+
+          @cookbooks_path = ["cookbooks", [:vm, "cookbooks"]]
+          @roles_path = []
+        end
+
+        def validate(errors)
+          super
+
+          errors.add(I18n.t("vagrant.config.chef.cookbooks_path_empty")) if !cookbooks_path || [cookbooks_path].flatten.empty?
+          errors.add(I18n.t("vagrant.config.chef.run_list_empty")) if !json[:run_list] || run_list.empty?
+        end
+      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,
+          :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
+
+      def host_folder_paths(paths)
+        # Convert single cookbook paths such as "cookbooks" or [:vm, "cookbooks"]
+        # into a proper array representation.
+        paths = [paths] if paths.is_a?(String) || paths.first.is_a?(Symbol)
+
+        paths.inject([]) do |acc, path|
+          path = [:host, path] if !path.is_a?(Array)
+          type, path = path
+
+          acc << File.expand_path(path, env.root_path) if type == :host
+          acc
+        end
+      end
+
+      def folder_path(*args)
+        File.join(config.provisioning_path, args.join("-"))
+      end
+
+      def folders_path(folders, folder)
+        # Convert single cookbook paths such as "cookbooks" or [:vm, "cookbooks"]
+        # into a proper array representation.
+        folders = [folders] if folders.is_a?(String) || folders.first.is_a?(Symbol)
+
+        # Convert each path to the proper absolute path depending on if the path
+        # is a host path or a VM path
+        result = []
+        folders.each_with_index do |path, i|
+          path = [:host, path] if !path.is_a?(Array)
+          type, path = path
+
+          result << folder_path(folder, i) if type == :host
+          result << folder_path(path) if type == :vm
+        end
+
+        # We're lucky that ruby's string and array syntax for strings is the
+        # same as JSON, so we can just convert to JSON here and use that
+        result = result[0].to_s if result.length == 1
+        result
+      end
+
+      def host_cookbook_paths
+        host_folder_paths(config.cookbooks_path)
+      end
+
+      def host_role_paths
+        host_folder_paths(config.roles_path)
+      end
+
+      def cookbook_path(i)
+        folder_path("cookbooks", i)
+      end
+
+      def role_path(i)
+        folder_path("roles", i)
+      end
+
+      def cookbooks_path
+        folders_path(config.cookbooks_path, "cookbooks").to_json
+      end
+
+      def roles_path
+        folders_path(config.roles_path, "roles").to_json
+      end
+    end
+  end
+end

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

@@ -0,0 +1,137 @@
+module Vagrant
+  module Provisioners
+    class PuppetError < Vagrant::Errors::VagrantError
+      error_namespace("vagrant.provisioners.puppet")
+    end
+
+    class Puppet < Base
+      register :puppet
+
+      class Config < Vagrant::Config::Base
+        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
+
+        # 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 manifest file if set otherwise returns the box name pp file
+        # which may or may not exist.
+        def computed_manifest_file
+          manifest_file || "#{top.vm.box}.pp"
+        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
+
+        def validate(errors)
+          super
+
+          # Manifests path/file validation
+          if !expanded_manifests_path.directory?
+            errors.add(I18n.t("vagrant.provisioners.puppet.manifests_path_missing", :path => expanded_manifests_path))
+          else
+            if !expanded_manifests_path.join(computed_manifest_file).file?
+              errors.add(I18n.t("vagrant.provisioners.puppet.manifest_missing", :manifest => computed_manifest_file))
+            end
+          end
+
+          # Module paths validation
+          expanded_module_paths.each do |path|
+            if !path.directory?
+              errors.add(I18n.t("vagrant.provisioners.puppet.module_path_missing", :path => path))
+            end
+          end
+        end
+      end
+
+      def prepare
+        set_module_paths
+        share_manifests
+        share_module_paths
+      end
+
+      def provision!
+        verify_binary("puppet")
+        run_puppet_client
+      end
+
+      def share_manifests
+        env.config.vm.share_folder("manifests", manifests_guest_path, config.expanded_manifests_path)
+      end
+
+      def share_module_paths
+        count = 0
+        @module_paths.each do |from, to|
+          # Sorry for the cryptic key here, but VirtualBox has a strange limit on
+          # maximum size for it and its something small (around 10)
+          env.config.vm.share_folder("v-pp-m#{count}", to, from)
+          count += 1
+        end
+      end
+
+      def set_module_paths
+        @module_paths = {}
+        config.expanded_module_paths.each_with_index do |path, i|
+          @module_paths[path] = File.join(config.pp_path, "modules-#{i}")
+        end
+      end
+
+      def manifests_guest_path
+        File.join(config.pp_path, "manifests")
+      end
+
+      def verify_binary(binary)
+        vm.ssh.execute do |ssh|
+          ssh.sudo!("which #{binary}", :error_class => PuppetError, :_key => :puppet_not_detected, :binary => binary)
+        end
+      end
+
+      def run_puppet_client
+        options = [config.options].flatten
+        options << "--modulepath '#{@module_paths.values.join(':')}'" if !@module_paths.empty?
+        options << config.computed_manifest_file
+        options = options.join(" ")
+
+        commands = ["cd #{manifests_guest_path}",
+                    "puppet #{options}"]
+
+        env.ui.info I18n.t("vagrant.provisioners.puppet.running_puppet", :manifest => config.computed_manifest_file)
+
+        vm.ssh.execute do |ssh|
+          ssh.sudo! commands do |ch, type, data|
+            if type == :exit_status
+              ssh.check_exit_status(data, commands)
+            else
+              env.ui.info(data)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+module Vagrant
+  module Provisioners
+    class PuppetServerError < Vagrant::Errors::VagrantError
+      error_namespace("vagrant.provisioners.puppet_server")
+    end
+
+    class PuppetServer < Base
+      register :puppet_server
+
+      class Config < Vagrant::Config::Base
+        attr_accessor :puppet_server
+        attr_accessor :puppet_node
+        attr_accessor :options
+
+        def initialize
+          @puppet_server = "puppet"
+          @puppet_node = "puppet_node"
+          @options = []
+        end
+      end
+
+      def provision!
+        verify_binary("puppetd")
+        run_puppetd_client
+      end
+
+      def verify_binary(binary)
+        vm.ssh.execute do |ssh|
+          ssh.sudo!("which #{binary}", :error_class => PuppetServerError, :_key => :puppetd_not_detected, :binary => binary)
+        end
+      end
+
+      def run_puppetd_client
+        options = config.options
+        options = options.join(" ") if options.is_a?(Array)
+        if config.puppet_node
+          cn = config.puppet_node
+        else
+          cn = env.config.vm.box
+        end
+
+        commands = "puppetd #{options} --server #{config.puppet_server} --certname #{cn}"
+
+        env.ui.info I18n.t("vagrant.provisioners.puppet_server.running_puppetd")
+
+        vm.ssh.execute do |ssh|
+          ssh.sudo!(commands) do |channel, type, data|
+            ssh.check_exit_status(data, commands) if type == :exit_status
+            env.ui.info(data) if type != :exit_status
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+module Vagrant
+  module Provisioners
+    class Shell < Base
+      register :shell
+
+      class Config < Vagrant::Config::Base
+        attr_accessor :path
+        attr_accessor :upload_path
+
+        def initialize
+          @upload_path = "/tmp/vagrant-shell"
+        end
+
+        def expanded_path
+          Pathname.new(path).expand_path(env.root_path) if path
+        end
+
+        def validate(errors)
+          super
+
+          if !path
+            errors.add(I18n.t("vagrant.provisioners.shell.path_not_set"))
+          elsif !expanded_path.file?
+            errors.add(I18n.t("vagrant.provisioners.shell.path_invalid", :path => expanded_path))
+          end
+
+          if !upload_path
+            errors.add(I18n.t("vagrant.provisioners.shell.upload_path_not_set"))
+          end
+        end
+      end
+
+      def provision!
+        commands = ["chmod +x #{config.upload_path}", config.upload_path]
+
+        # Upload the script to the VM
+        vm.ssh.upload!(config.expanded_path.to_s, config.upload_path)
+
+        # Execute it with sudo
+        vm.ssh.execute do |ssh|
+          ssh.sudo!(commands) do |ch, type, data|
+            if type == :exit_status
+              ssh.check_exit_status(data, commands)
+            else
+              env.ui.info(data)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mccloud/session.rb

@@ -0,0 +1,199 @@
+require 'json'
+require 'logger'
+
+
+require 'fog'
+require 'highline'
+require 'highline/import'
+
+require 'mccloud/config'
+
+require 'mccloud/command/status'
+require 'mccloud/command/up'
+require 'mccloud/command/halt'
+require 'mccloud/command/ssh'
+require 'mccloud/command/boot'
+require 'mccloud/command/bootstrap'
+require 'mccloud/command/reload'
+require 'mccloud/command/multi'
+require 'mccloud/command/init'
+require 'mccloud/command/suspend'
+require 'mccloud/command/destroy'
+require 'mccloud/command/provision'
+require 'mccloud/command/server'
+
+module Mccloud
+
+  # We need some global thing for the config file to find our session
+  def self.session=(value)
+    @session=value
+  end
+  def self.session
+    return @session
+  end
+
+  class Session
+    attr_accessor :config
+    attr_accessor :logger
+    attr_accessor :all_servers
+
+    include Mccloud::Command
+
+    def initialize(options=nil)
+      @logger = Logger.new(STDOUT)
+      @logger.level = Logger::DEBUG
+
+      #http://www.ruby-doc.org/stdlib/libdoc/logger/rdoc/classes/Logger.html
+      @logger.datetime_format = "%Y-%m-%d %H:%M:%S"
+
+      #logger.formatter = proc { |severity, datetime, progname, msg|
+      #   "#{datetime} - #{severity}: #{msg}\n"
+      # }
+      @session=self
+      Mccloud.session=self
+    end
+
+    def load_config(options=nil)
+      @logger.debug "Loading mccloud config"
+      #if File.exist?(path)
+      begin
+        Kernel.load File.join(Dir.pwd,"Mccloudfile")
+      rescue LoadError => e
+        @logger.error "Error loading configfile - Sorry"
+        @logger.error e.message  
+        @logger.error e.backtrace.inspect  
+        exit -1
+      end
+
+      @all_servers=Hash.new
+      if File.exists?(".mccloud")
+
+        @logger.debug ".mccloud exists"
+        dotmccloud=File.new(".mccloud")
+
+        @logger.debug "reading .mccloud json file"
+        json=dotmccloud.readlines.to_s
+
+        begin
+          @logger.debug "parsing .mccloud json file"
+          @all_servers=JSON.parse(json)
+        rescue Error => e
+          @logger.error "Error parsing json file - Sorry"
+          @logger.error e.message  
+          @logger.error e.backtrace.inspect  
+          exit -1
+        end
+
+      end
+
+      #Loading providers
+      Mccloud.session.config.vms.each do |name,vm|
+        if @session.config.providers[vm.provider].nil?
+        
+        @logger.debug "adding provider #{vm.provider}"
+        begin
+          @session.config.providers[vm.provider]=Fog::Compute.new(:provider => vm.provider)
+        rescue ArgumentError => e
+          #  Missing required arguments: 
+          required_string=e.message
+          required_string["Missing required arguments: "]=""
+          required_options=required_string.split(", ")
+          puts "Please provide credentials for provider [#{vm.provider}]:"
+          answer=Hash.new
+          for fog_option in required_options do 
+            answer["#{fog_option}".to_sym]=ask("- #{fog_option}: ") 
+            #{ |q| q.validate = /\A\d{5}(?:-?\d{4})?\Z/ }
+          end
+          puts "\nThe following snippet will be written to #{File.join(ENV['HOME'],".fog")}"
+
+          snippet=":default:\n"
+          for fog_option in required_options do
+            snippet=snippet+"  :#{fog_option}: #{answer[fog_option.to_sym]}\n"
+          end
+
+          puts "======== snippit start ====="
+          puts "#{snippet}"
+          puts "======== snippit end ======="
+          confirmed=agree("Do you wan to save this?: ")
+
+          if (confirmed)
+            fogfile=File.new("#{File.join(ENV['HOME'],".fog")}","w")
+            fogfile.puts "#{snippet}"
+            fogfile.close
+          else
+            puts "Ok, we won't write it, but we continue with your credentials in memory"
+            exit -1
+          end
+          begin
+            answer[:provider]= vm.provider
+            @session.config.providers[vm.provider]=Fog::Compute.new(answer)
+          rescue
+              puts "We tried to create the provider but failed again, sorry we give up"
+              exit -1
+          end
+        end
+      end
+      end
+
+      invalid_cache=false
+      @session.config.vms.each do |name,vm|
+        prefix=@session.config.mccloud.prefix
+        id=@all_servers["#{name.to_s}"]
+
+        #Check if not destroyed or something else
+        instance=vm.instance
+        if instance.nil?
+          @logger.error "Cache is invalid"
+          invalid_cache=true
+        else  
+          if instance.state == "shutting-down" || instance.state == "terminated"
+            @logger.info "parsing .mccloud json" 
+            @logger.info "rebuilding cache"
+            invalid_cache=true
+          end
+        end
+      end
+
+      #
+      if (invalid_cache)
+        #Resetting the list
+        @all_servers=Hash.new
+
+        servers_by_provider=Hash.new
+
+        # Find all providers
+        @session.config.providers.each do |name,provider|
+          server_list=Hash.new
+          provider.servers.each do |server|
+
+            if !(server.state == "terminated")
+              server_list[server.tags["Name"]]=server.id	
+            end
+          end
+          servers_by_provider[name]=server_list
+        end
+        prefix=@session.config.mccloud.prefix
+
+        @session.config.vms.each do |name,vm|
+          id=servers_by_provider[vm.provider]["#{prefix} - #{name.to_s}"]
+
+
+          if !id.nil?
+            @all_servers[name]=id
+            #@session.config.vms[name].instance=@session.config.providers[vm.provider].servers.get(id)
+          end
+        end
+
+        dotmccloud=File.new(".mccloud","w")
+        dotmccloud.puts(@all_servers.to_json)
+        dotmccloud.close
+
+
+      end
+    end
+
+
+
+
+  end
+end