mccloud 0.0.13 → 0.0.14

data/lib/mccloud/config/mccloud.rb

@@ -0,0 +1,39 @@
+module Mccloud
+  class Config
+    class Mccloud
+
+      attr_reader :env
+
+      attr_accessor :prefix
+      attr_accessor :environment
+      attr_accessor :identity
+
+      attr_accessor :delimiter
+      attr_accessor :loglevel
+
+      attr_accessor :template_path
+      attr_accessor :definition_path
+      attr_accessor :vm_path
+
+      def initialize(config)
+        @env=config.env
+
+        @prefix="mccloud"
+        @environment=""
+        @identity=""
+
+        @delimiter="-"
+        @loglevel=:info
+
+        @template_path=File.expand_path(File.join(File.dirname(__FILE__),'..','..','..','templates'))
+        @definition_path=File.join(@env.root_path,"definitions")
+        @vm_path=File.join(@env.root_path,"vms")
+
+        env.logger.debug("done loading the mccloud setting")
+
+      end
+
+
+    end #Class
+  end #Module
+end #Module

data/lib/mccloud/config/provider.rb

@@ -0,0 +1,55 @@
+require 'mccloud/config/component'
+require 'ostruct'
+
+module Mccloud
+  class Config
+    class Provider
+
+      attr_accessor :components
+      attr_reader :env
+
+      def initialize(config)
+        @env=config.env
+        @components=Hash.new
+      end
+
+      def define(name)
+        # We do this for vagrant syntax
+        # Depending on type, we create a variable of that type
+        # f.i. component_stub.vm or component_stub.lb
+        provider_stub=OpenStruct.new
+        provider_stub.provider=OpenStruct.new
+
+        env.logger.debug("config provider"){ "Start stubbing provider"}
+
+        # Now we can 'execute' the config file using our stub component
+        # For guessing the provider type
+        yield provider_stub
+
+        env.logger.debug("config provider"){ "End stubbing provider"}
+
+        # After processing we extract the provider type and options again
+        provider_type=provider_stub.provider.flavor
+        env.logger.debug("config provider"){ "Found provider of type #{provider_type}"}
+        provider_options=provider_stub.provider.options
+
+        begin
+          # Now that we know the actual provider, we can check if the provider has this type of component
+          require_path='mccloud/provider/'+provider_type.to_s.downcase+"/provider"
+            require require_path
+
+          # Now we can create the real provider
+          real_provider=Object.const_get("Mccloud").const_get("Provider").const_get(provider_type.to_s.capitalize).const_get("Provider").new(name,provider_options,env)
+          provider_stub.provider=real_provider
+          yield provider_stub
+
+          env.logger.debug("config provider"){ "Instantiating provider #{name.to_s}"}
+          components[name.to_s]=provider_stub.provider
+        rescue ::Mccloud::Error => ex
+          raise ::Mccloud::Error, "Error loading provider with #{name}\n#{ex}"
+        end
+      end
+
+    end
+  end
+end #Module Mccloud

data/lib/mccloud/config/template.rb

@@ -0,0 +1,35 @@
+require 'mccloud/config/component'
+require 'mccloud/template'
+require 'ostruct'
+
+module Mccloud
+  class Config
+    class Template
+
+      attr_accessor :components
+      attr_reader :env
+
+      def initialize(config)
+        @env=config.env
+        @components=Hash.new
+      end
+
+      def define(name)
+        # We do this for vagrant syntax
+        # Depending on type, we create a variable of that type
+        # f.i. component_stub.vm or component_stub.lb
+        template_stub=OpenStruct.new
+        template_stub.template=::Mccloud::Template.new(name,env)
+
+        env.logger.debug("config template"){ "Start reading template"}
+
+        yield template_stub
+
+        env.logger.debug("config template"){ "End reading template #{template_stub.template.name}"}
+
+        components[name.to_s]=template_stub.template
+      end
+
+    end
+  end
+end #Module Mccloud

data/lib/mccloud/config.rb

@@ -1,47 +1,134 @@
-require 'mccloud/configurator/mccloud'
-require 'mccloud/configurator/vm'
-require 'mccloud/configurator/lb'
-require 'mccloud/provisioner/chef_solo'
+require 'mccloud/template'
+require 'mccloud/templates'
+require 'mccloud/vms'
+require 'mccloud/definition'
+require 'mccloud/definitions'
+require 'mccloud/keypair'
+require 'mccloud/config/mccloud'
+require 'mccloud/config/provider'
+require 'mccloud/config/template'
+require 'mccloud/config/keypair'
+require 'mccloud/config/definition'
+require 'mccloud/config/collection'
+
 
 module Mccloud
-  
-  class Configuration
-    attr_accessor :vms
-    attr_accessor :lbs
-    attr_accessor :providers
-    attr_accessor :provisioners
-    
+  class Config
+
+    #    include ::Mccloud::Logger
+
     attr_accessor :mccloud
-    attr_accessor :vm
-    attr_accessor :lb
-    attr_accessor :session
-    
-    def initialize
-      @vms=Hash.new
-      @lbs=Hash.new
-      @providers=Hash.new
-      @vm=Mccloud::Configurator::VmConfigurator.new
-      @lb=Mccloud::Configurator::LbConfigurator.new
-      @mccloud=Mccloud::Configurator::MccloudConfigurator.new	
-      @provisioners=Hash.new
+
+    attr_reader :env
+
+    attr_accessor :vms,:lbs,:stacks,:ips,:keystores,:keypairs
+    attr_accessor :providers
+
+    attr_accessor :templates,:definitions
+
+    def initialize(options)
+      @env=options[:env]
+      env.logger.info("config") { "Initializing empty list of vms,lbs,stacks, ips in config" }
+
+      @lbs=Hash.new;@stacks=Hash.new;@ips=Hash.new; @keystores=Hash.new; @keypairs=Hash.new;
+
+      @providers=Hash.new; 
+      @templates=::Mccloud::Templates.new(env)
+      @definitions=::Mccloud::Definitions.new(env)
+      @vms=::Mccloud::Vms.new(env)
     end
-  end
-  
-  module Config
-    class << self; 
-      attr_accessor :config
+
+    def define()
+      config=OpenStruct.new
+
+      # These don't depend on a provider
+      config.mccloud=::Mccloud::Config::Mccloud.new(self)
+      @mccloud=config.mccloud
+
+      # Assign templates
+      config.template=::Mccloud::Config::Template.new(self)
+      config.template.components=@templates
+
+      # Assign definitions
+      config.definition=::Mccloud::Config::Definition.new(self)
+      config.definition.components=@definitions
+
+      # Assign keypairs
+      config.keypair=::Mccloud::Config::Keypair.new(self)
+      config.keypair.components=@keypairs
+
+      # Assign providers
+      config.provider=::Mccloud::Config::Provider.new(self)
+      config.provider.components=@providers
+
+      # These components depend on a provider, so we try to guess it frst
+      # This will access self's variables like :
+      #         vms,lbs, ips, etc by simply putting an 's' after the type
+      config.vm=::Mccloud::Config::Collection.new("vm",self)
+      config.lb=::Mccloud::Config::Collection.new("lb",self)
+      config.ip=::Mccloud::Config::Collection.new("ip",self)
+      config.stack=::Mccloud::Config::Collection.new("stack",self)
+      config.keystore=::Mccloud::Config::Collection.new("keystore",self)
+
+      # Process config file
+      yield config
+
     end
-    def self.run
-      @config=Configuration.new
-      
-      # Here we access a global thing, TODO to make it session specific
-      
-      Mccloud.session.config=@config
-      yield @config
-      #Resetting any left over
-      
-      @config.vm=nil
-      @config.lb=nil
+
+    # We put a long name to not clash with any function in the Mccloud file itself
+    def load_mccloud_config()
+      mccloud_configurator=self
+      begin
+        mccloud_file=File.read(File.join(env.root_path,env.mccloud_file))
+        env.logger.info("Reading #{mccloud_file}")
+        mccloud_file.gsub!("Mccloud::Config.run","mccloud_configurator.define")
+        #        http://www.dan-manges.com/blog/ruby-dsls-instance-eval-with-delegation
+        instance_eval(mccloud_file)
+      rescue LoadError => e
+        raise ::Mccloud::Error, "Error processing configfile - Sorry"
+        env.ui.error "Error loading configfile - Sorry"
+        env.ui.error e.message
+        exit -1
+      rescue NoMethodError => e
+        raise ::Mccloud::Error, "Some method got an error in the configfile - Sorry\n#{$!}\n#{e.message}"
+      rescue Errno::ENOENT => e
+        raise ::Mccloud::Error, "You need a Mccloudfile to be able to run mccloud, run mccloud init to create one, #{e}"
+      rescue ::Mccloud::Error => e
+        raise ::Mccloud::Error, "#{e}"
+      rescue Error => e
+        raise ::Mccloud::Error, "Error processing configfile - Sorry"
+      end
+      return self
     end
-  end
-end
+
+
+
+    def stackfilter
+      vmfilter=self.filter
+      filter=vmfilter.gsub!(/[^[:alnum:]]/, '')
+      return filter
+    end
+
+    def filter()
+      mcfilter=Array.new
+      if !@prefix.nil?
+        mcfilter << @prefix
+      end
+      if @environment!=""
+        mcfilter << @environment
+      end
+      if @identity!=""
+        mcfilter << @identity
+      end
+      full_filter=mcfilter.join(@delimiter)
+      if full_filter.length>0
+        full_filter=full_filter+@delimiter
+      end
+      return full_filter
+
+    end
+
+
+
+  end #End Class
+end #End Module

data/lib/mccloud/definition.rb

@@ -0,0 +1,104 @@
+module Mccloud
+
+  class Definition
+
+    attr_accessor :name
+    attr_reader :env
+    attr_reader :provider
+
+    def initialize(name,env)
+      @name=name
+      @env=env
+      @type="vm"
+    end
+
+    def provider=(name)
+      @provider=name
+      @raw=env.config.providers[name].get_component(@type.capitalize,env)
+    end
+
+    def method_missing(m, *args, &block)
+      #puts  "There's no method called #{m} here -- please try again."
+      @raw.send(m,*args)
+    end
+
+    def valid?
+      File.exists?(self.definition_path)
+    end
+
+    def exists?
+      File.directory?(self.path)
+    end
+
+    def path
+      File.join(@env.config.mccloud.definition_path,@name)
+    end
+
+    def definition_path
+      File.join(self.path,"mccloud.rb")
+    end
+
+    def load!
+      self.validate
+
+      content=File.read(self.definition_path)
+      mccloud_configurator=env.config
+      content.gsub!("Mccloud::Config.run","mccloud_configurator.define")
+
+      begin
+        env.config.instance_eval(content)
+      rescue Error => ex
+        raise ::Mccloud::Error, "Error reading definition from file #{definition_file}#{ex}"
+      end
+    end
+
+    def to_vm(name)
+      vm=@raw.dup
+      vm.name=name
+      return vm
+    end
+
+    def validate
+      raise ::Mccloud::Error, "Definition #{@name} does not yet exist" unless self.exists?
+    end
+
+
+    def copy_template(templatename)
+      raise ::Mccloud::Error, "Definition #{@name} already exists" if self.exists?
+      raise ::Mccloud::Error, "Template #{templatename} does not exist" unless @env.config.templates[templatename].exists?
+
+      begin
+        t=@env.config.templates[templatename]
+        @env.logger.info "Copying template #{t.path} to definition #{self.path}"
+        FileUtils.cp_r(t.path,self.path)
+        save_mccloud_rb
+        FileUtils.rm(File.join(self.path,"mccloud.erb"))
+      rescue Exception => ex
+        raise ::Mccloud::Error, "Error copying template #{templatename} to definition #{@name}:\n#{ex}"
+      end
+
+    end
+
+    def save_mccloud_rb
+      begin
+        unless File.exists?(self.definition_path)
+          File.open(self.definition_path,'w'){ |f| f.write(self.to_template(@name))}
+        else
+          raise ::Mccloud::Error, "Definition file #{self.definition_path} already exists"
+        end
+      rescue Error => ex
+        raise ::Mccloud::Error, "Error writing mccloud.rb"
+      end
+    end
+
+    def to_template(templatename)
+      result=""
+      t=@env.config.templates[templatename]
+      filename=File.join(self.path,'mccloud.erb')
+      env.logger.info "Opening vm template file #{@file}"
+      template=File.new(filename).read
+      result=ERB.new(template).result(binding)
+      return result
+    end
+  end
+end

data/lib/mccloud/definitions.rb

@@ -0,0 +1,91 @@
+require 'mccloud/definition.rb'
+
+module Mccloud
+  class Definitions < Hash
+
+    attr_reader :env
+
+    def initialize(env)
+      @env=env
+    end
+
+    def define(name,templatename)
+      # Check if template exists
+      unless env.config.templates.registered?(templatename)
+        raise ::Mccloud::Error, "Template #{templatename} does not exist"
+      end
+      # Create the definitions dir if needed
+      unless self.exists?
+        self.create
+      end
+
+      definition=::Mccloud::Definition.new(name,env)
+      unless definition.exists?
+        definition.copy_template(templatename)
+      end
+    end
+
+    def load!
+      if self.exists?
+        Dir[File.join(self.path,"**")].each do |dir|
+          definition_name=File.basename(dir)
+          d=Definition.new(definition_name,env)
+          if d.valid?
+            d.load!
+          else
+            env.logger.info "Skipping loading of definitions #{dir}"
+          end
+        end
+      else
+        env.logger.info "Skipping loading of definitions as the definition_path does exist"
+      end
+    end
+
+    def path
+      @env.config.mccloud.definition_path
+    end
+
+    def exists?
+      File.directory?(self.path)
+    end
+
+    def registered?(name)
+      return self.has_key?(name)
+    end
+
+    def create
+     begin
+      unless self.exists?
+        env.logger.info "Creating the definitions directory #{self.path} as it doesn't exist yet"
+        FileUtils.mkdir(self.path)
+      end
+      rescue Exception => ex
+         raise ::Mccloud::Error, "Error creating definitions directory #{self.path}: \n#{ex}"
+      end
+    end
+
+  end
+end
+
+## Checking for name already defined
+#          env.ui.warn "#{name} was already defined" unless env.config.vms[name].nil?
+#          t=env.config.templates[template]
+#  
+#          # Template was not found
+#          unless t.nil?
+#            unless File.exists?("vms") && File.directory?("vms")
+#>>            env.logger.info ("Creating the vms directory as it doesn't exist yet")
+#              FileUtils.mkdir("vms")
+#            end 
+#            filename=File.join("vms","#{name}.rb")
+#            unless File.exists?(filename)
+#              File.open(filename,'w'){ |f| f.write(t.to_template(name))}
+#            else
+#              env.ui.error "Definition #{name} already exists. Undefine it first:"
+#              env.ui.error "mccloud undefine '#{name}'"
+#  
+#            end 
+#          else
+#            env.ui.error "Template #{template} does not exist"
+#          end 
+#