mccloud 0.0.13 → 0.0.14

data/lib/mccloud/configurator/mccloud.rb

@@ -1,33 +0,0 @@
-module Mccloud
-  module Configurator
-    class MccloudConfigurator
-      attr_accessor :prefix
-      attr_accessor :environment
-
-      attr_accessor :identity
-      attr_accessor :loglevel
-      
-      def initialize()
-          @prefix="mccloud"
-          @environment=""
-          @identity=""
-          @loglevel=:info
-      end   
-      
-      def filter()
-        mcfilter=Array.new
-        if !@prefix.nil? 
-           mcfilter << @prefix 
-        end
-        if @environment!="" 
-           mcfilter << @environment
-        end
-        if @identity!=""
-           mcfilter << @identity 
-        end
-        return mcfilter.join(" - ")
-      end  
-       
-    end
-  end
-end

data/lib/mccloud/configurator/vm.rb

@@ -1,37 +0,0 @@
-require 'mccloud/provisioner/chef_solo'
-require 'mccloud/provisioner/puppet'
-
-require 'mccloud/type/vm'
-
-module Mccloud
-  module Configurator
-    
-  class VmConfigurator
-
-    attr_accessor :vm
-    
-    def initialize()
-     end
-    
-    def define(name)
-      @vm=Mccloud::Type::Vm.new	
-      vmconfig=self
-      yield vmconfig
-      @vm.name=name
-      Mccloud.session.config.vms[name.to_s]=@vm
-    end
-    def provision(type)
-      case type
-      when :chef_solo
-        @provisioner=Mccloud::Provisioner::ChefSolo.new
-      when :puppet
-        @provisioner=Mccloud::Provisioner::Puppet.new        
-      else
-      end
-      yield @provisioner
-      Mccloud.session.config.provisioners[type.to_s]=@provisioner
-    end
-  end
-  
-end
-end #Module Mccloud

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

@@ -1,63 +0,0 @@
-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

@@ -1,130 +0,0 @@
-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

@@ -1,103 +0,0 @@
-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

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

@@ -1,142 +0,0 @@
-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

@@ -1,137 +0,0 @@
-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

@@ -1,55 +0,0 @@
-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