mccloud 0.0.13 → 0.0.14

data/lib/mccloud/environment.rb

@@ -0,0 +1,222 @@
+require 'mccloud/config'
+require 'mccloud/generator'
+
+require 'mccloud/command/init'
+require 'mccloud/command/provider'
+require 'logger'
+
+module Mccloud
+
+  # Represents a single Mccloud environment. A "Mccloud environment" is
+  # defined as basically a folder with a "Mccloudfile". This class allows
+  # access to the VMs, CLI, etc. all in the scope of this environment
+  class Environment
+
+    include Mccloud::EnvironmentCommand
+
+    # The `cwd` that this environment represents
+    attr_reader :cwd
+
+    # The valid name for a Mccloudfile for this environment
+    attr_reader :mccloud_file
+
+    # The {UI} Object to communicate with the outside world
+    attr_writer :ui
+
+    # The configuration as loaded by the Mccloudfile
+    attr_accessor :config
+
+    # A generator helper to create a Mccloud project
+    attr_accessor :generator
+
+    # Default ssh keypath
+    attr_accessor :ssh_key_path
+
+    attr_accessor :autoload
+    #    attr_accessor :providers
+
+
+    def initialize(newoptions=nil)
+      options = {
+        :cwd => nil,
+        :mccloud_file => "Mccloudfile",
+        :autoload => true}.merge(newoptions || {})
+
+        # We need to set this variable before the first call to the logger object
+        if options.has_key?("debug")
+          ENV['MCCLOUD_LOG']="STDOUT"
+          ui.info "Debugging enabled"
+        end
+
+        options.each do |key, value|
+          logger.info("environment") { "Setting @#{key} to #{options[key]}" }
+          self.instance_variable_set("@#{key}".to_sym, options[key])
+        end
+
+        if options[:cwd].nil?
+          @cwd=computed_rootpath(".")
+        else
+          @cwd=computed_rootpath(options[:cwd])
+        end
+
+        logger.info("environment") { "Autoload activated? #{options[:autoload]}"}
+        @autoload=options[:autoload]
+
+        # Set the default working directory to look for the Mccloudfile
+        logger.info("environment") { "Environment initialized (#{self})" }
+        logger.info("environment") { " - cwd : #{cwd}" }
+
+        @config=Config.new({:env => self})
+        @generator=Generator.new(self)
+
+        # Setting the default to path of the sshkey
+        @ssh_key_path=File.join(ENV['HOME'],".ssh")
+
+        return self
+    end
+
+    def root_path
+      return File.expand_path(@cwd)
+    end
+
+    def computed_rootpath(start)
+      # Let's start at the start path provided
+      logger.info("Calculating computed rootpath")
+      logger.info("Start provided: #{start}")
+      startdir=start
+      prevdir="/someunknownpath"
+
+      until File.exists?(File.join(startdir,@mccloud_file))
+        prevdir=startdir
+        startdir=File.expand_path(File.join(startdir,".."))
+        logger.info("No #{@mccloud_file} found, going up one directory #{startdir}")
+
+        # Check if aren't at the root dir
+        if File.expand_path(prevdir)==File.expand_path(startdir)
+          return start
+        end
+      end
+
+      return startdir
+    end
+
+    #---------------------------------------------------------------
+    # Config Methods
+    #---------------------------------------------------------------
+
+    # The configuration object represented by this environment. This
+    # will trigger the environment to load if it hasn't loaded yet (see
+    # {#load!}).
+    #
+    # @return [Config::Top]
+    def config
+      if  @autoload
+        load! if !loaded?
+      end
+      @config
+    end
+
+    # Returns the {UI} for the environment, which is responsible
+    # for talking with the outside world.
+    #
+    # @return [UI]
+    def ui
+      @ui ||=  UI.new(self)
+    end
+
+    #---------------------------------------------------------------
+    # Load Methods
+    #---------------------------------------------------------------
+
+    # Returns a boolean representing if the environment has been
+    # loaded or not.
+    #
+    # @return [Bool]
+    def loaded?
+      !!@loaded
+    end
+
+    # Loads this entire environment, setting up the instance variables
+    # such as `vm`, `config`, etc. on this environment. The order this
+    # method calls its other methods is very particular.
+    def load!
+      if !loaded?
+        @loaded = true
+
+        logger.info("environment") { "Loading configuration..." }
+        load_config!
+
+        self
+      end
+    end
+
+    ## Does the actual read of the configuration file
+    ## @return [self]
+    def load_config!
+
+      # Read the config
+      @config.load_mccloud_config()
+
+      # Read the templates in the template sub-dir
+      @config.templates.load!
+      @config.definitions.load!
+
+      # Read the vms specified inthe vm sub-dir
+      @config.vms.load!
+
+      ui.info "Loaded providers[#{@config.providers.length}]"+" vms[#{@config.vms.length}]"+" ips[#{@config.ips.length}]"+" lbs[#{@config.lbs.length}]"+" stacks[#{@config.stacks.length}]"+" templates[#{@config.templates.length}] keypairs[#{@config.keypairs.length}] keystores[#{@config.keystores.length}]"
+
+      return self
+    end
+
+    # Reloads the configuration of this environment.
+    def reload_config!
+      @config = nil
+      load_config!
+      self
+    end
+
+    # Makes a call to the CLI with the given arguments as if they
+    # came from the real command line (sometimes they do!). An example:
+    #
+    #     env.cli("package", "--mccloudfile", "Mccloudfile")
+    #
+    def cli(*args)
+      CLI.start(args.flatten, :env => self)
+    end
+
+    def resource
+      "mccloud"
+    end
+
+    # Accesses the logger for Mccloud. This logger is a _detailed_
+    # logger which should be used to log internals only. For outward
+    # facing information, use {#ui}.
+    #
+    # @return [Logger]
+    def logger
+      return @logger if @logger
+
+      # Figure out where the output should go to.
+      output = nil
+      if ENV["MCCLOUD_LOG"] == "STDOUT"
+        output = STDOUT
+      elsif ENV["MCCLOUD_LOG"] == "NULL"
+        output = nil
+      elsif ENV["MCCLOUD_LOG"]
+        output = ENV["MCCLOUD_LOG"]
+      else
+        output = nil #log_path.join("#{Time.now.to_i}.log")
+      end
+
+      # Create the logger and custom formatter
+      @logger = ::Logger.new(output)
+      @logger.formatter = Proc.new do |severity, datetime, progname, msg|
+        "#{datetime} - #{progname} - [#{resource}] #{msg}\n"
+      end
+
+      @logger
+    end
+
+  end #Class
+end #Module

data/lib/mccloud/error.rb

@@ -0,0 +1,20 @@
+module Mccloud
+    class Error < StandardError
+      attr_reader :orginal
+      def initialize(msg, original=$!)
+        super(msg)
+        @original = original; end
+    end
+end
+
+#Usage (from the exceptional ruby book)
+#begin
+#   begin
+#     raise "Error A"
+#   rescue => error
+#     raise MyError, "Error B"
+#   end
+#rescue => error.
+#   puts "Current failure: #{error.inspect}"
+#   puts "Original failure: #{error.original.inspect}"
+#end

data/lib/mccloud/generator.rb

@@ -0,0 +1,49 @@
+require 'mccloud/mccloudfile'
+require 'mccloud/keypair'
+
+module Mccloud
+
+  # This takes care of initializing a new Mccloud project
+  class Generator
+
+    attr_accessor :env
+
+    def initialize(env)
+      @env=env
+      @generators=[:aws,:kvm,:host]
+    end
+
+    def generate(options={})
+      defaults={ :provider => :aws, :force => false}
+      options=defaults.merge(options)
+      provider=options[:provider].to_sym
+      raise ::Mccloud::Error, "Unsupported provider #{provider}" unless @generators.include?(provider)
+      generate_mccloudfile(options)
+      generate_mccloud_sshkey(options)
+    end
+
+    def generate_mccloudfile(options)
+      begin
+        f=Mccloud::Mccloudfile.new(File.join(env.root_path,"Mccloudfile"))
+        if f.exists?
+          env.ui.error "Mccloudfile already exists"
+        else
+          env.ui.info "Creating a new Mccloudfile"
+          f.generate(options)
+        end
+      rescue Error => ex
+        raise ::Mccloud::Error, "Error creating Mccloudfile.\n#{ex}"
+      end
+    end
+
+    def generate_mccloud_sshkey(options)
+      k=Mccloud::Keypair.new("mccloud",env)
+      if k.exists?
+          env.ui.info "Re-using existing mccloud RSA key in #{k.public_key_path}"
+      else
+        k.generate(options)
+      end
+    end
+
+  end
+end

data/lib/mccloud/keypair.rb

@@ -0,0 +1,48 @@
+require 'mccloud/util/sshkey'
+
+module Mccloud
+  class Keypair
+    attr_accessor :public_key_path
+    attr_accessor :private_key_path
+    attr_accessor :name
+    attr_accessor :env
+
+    def initialize(name,env)
+      @name=name
+      @env=env
+      @private_key_path=File.join(env.ssh_key_path,"#{name}_rsa")
+      @public_key_path=File.join(env.ssh_key_path,"#{name}_rsa.pub")
+      return self
+    end
+
+    def exists?
+      return false unless File.exists?(@public_key_path)
+      return false unless File.exists?(@private_key_path)
+      return true
+    end
+
+    def generate(options={:force => false})
+      force=options[:force]
+      if exists? && force==false
+        env.ui.error "Keypair: #{@name} already exists"
+        env.ui.error "- #{@public_key_path}"
+        env.ui.error "- #{@private_key_path}"
+        raise ::Mccloud::Error, "Keypair #{@name} already exists"
+      else
+        env.ui.info "Generating Keypair: #{@name}"
+        env.ui.info "- #{@public_key_path}"
+        env.ui.info "- #{@private_key_path}"
+        env.ui.info ""
+        env.ui.warn "Make sure you make a backup!!"
+        rsa_key=::Mccloud::Util::SSHKey.generate({ :comment => "Key generated by mccloud #{@name}"})
+        begin
+          File.open(@public_key_path,'w'){|f| f.write(rsa_key.ssh_public_key)}
+          File.open(@private_key_path,'w'){|f| f.write(rsa_key.rsa_private_key)}
+        rescue Exception => ex
+          env.ui.error "Error generating keypair : #{ex}"
+        end
+      end
+    end
+
+  end
+end

data/lib/mccloud/mccloudfile.rb

@@ -0,0 +1,78 @@
+require 'erb'
+module Mccloud
+  class Mccloudfile
+
+    attr_accessor :path
+    attr_accessor :sections
+
+    def initialize(path)
+      # Path to the file
+      @path=path
+
+    end
+
+    def exists?
+      return File.exists?(@path)
+    end
+
+    # Bindings in ERB http://www.stuartellis.eu/articles/erb/
+    # Links:
+    # * Trimming whitespace in ERB
+    # http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-talk/242656
+    # * Appending to ERB output
+    # http://blog.jayfields.com/2007/01/appending-to-erb-output-from-block.html
+    def uncomment(selection)
+
+      cur_pos=@output.length
+      yield
+      new_pos=@output.length
+
+      if exclude_section?(selection)
+        # Extract the block
+        block_text=@output[cur_pos..new_pos]
+
+        # Remove the block
+        @output[cur_pos..new_pos]=''
+
+        # Comment the block, with leading spaces into account
+        block_text.gsub!(/^(\s)*/,'\1# ')
+
+        # Re-insert the block
+        @output=@output.insert cur_pos, block_text
+      end
+    end
+
+    def exclude_section?(section)
+      section.each do |s|
+        return false if @sections.include?(s)
+      end
+      return true
+    end
+
+    def generate(options={:force => false})
+      force=options[:force]
+      provider=options[:provider]
+      raise Mccloud::Error, "You need to specify a provider to generate a Mccloudfile" if provider.nil?
+
+      @sections=[provider.to_sym]
+      # We need at least one provider
+
+      if exists? && force==false
+          raise Mccloud::Error, "Error Mccloudfile already exists."
+      else
+       begin
+        File.open(@path,'w'){ |f| f.write(self.to_s)}
+       rescue Exception => ex
+          raise Mccloud::Error, "Error saving Mccloudfile: #{ex}"
+       end
+      end
+    end
+
+    def to_s
+      template=File.new(File.join(File.dirname(__FILE__),"templates","Mccloudfile.erb")).read
+      result=::ERB.new(template,nil,"-","@output").result(binding)
+      return result
+    end
+
+  end
+end

data/lib/mccloud/provider/aws/image.rb

@@ -0,0 +1,107 @@
+module Mccloud::Provider
+  module Aws
+
+    class Image
+      attr_accessor :provider
+      attr_accessor :name
+
+      def raw
+      end
+
+      def package(selection=nil,options=nil)
+
+        if selection.nil?
+          env.ui.info "[Error] We need at least a name of a machine."
+          exit
+        end
+
+
+        #f=Fog::Compute.new({ :region => "eu-west-1", :provider => "AWS"})
+        # i=f.create_image("i-c1ac2bb7","name","description")
+        # f.images.all({ "Owner" => "self"})
+        # f.deregister_image("ami-796d5b0d")
+
+        on_selected_machines(selection) do |id,vm|
+
+          time=Time.new
+          strtime=time.strftime("%Y-%m-%d-%H-%M-%S")
+          name=""
+
+          if options["name"].nil?
+            name="#{vm.name}-#{strtime}"
+          else
+            name=options["name"]
+          end
+
+          description=""
+          if options["description"].nil?
+            description="Autogenerated snapshot from machine #{vm.name}"
+          else
+            description=options["description"]
+          end
+
+          filter=@environment.config.mccloud.filter
+          fullname="#{@environment.config.mccloud.filter}#{name}"
+
+          provider= @environment.config.providers[vm.provider]
+          begin
+            result=provider.create_image(id,name,description)
+            imageId=result.body["imageId"]
+            env.ui.info "[#{vm.name}] image #{imageId} with #{description} being created"
+
+            unless options["dontwait"]
+              sleep 3
+              counter=0
+              max_tries=5
+              #Pending
+              state="pending"
+              until state!="pending" do
+                print "."
+                sleep 2
+                image=provider.images.get(imageId)
+
+                if image.nil?
+                  sleep 3
+                  print "."
+                else
+                  state=image.state
+                end
+              end
+              env.ui.info ""
+              env.ui.info "[#{vm.name}] creation done!"
+            end
+          rescue Fog::Service::Error => fogerror
+            env.ui.info "[Error] #{fogerror}"
+
+          end
+          #      vm.instance.start
+        end
+      end
+
+      def register
+        #f=Fog::Compute.new({ :region => "eu-west-1", :provider => "AWS"})
+        # i=f.create_image("i-c1ac2bb7","name","description")
+        # f.images.all({ "Owner" => "self"})
+        # f.deregister_image("ami-796d5b0d")
+
+        env.ui.info "Looking for imageId: #{imageId}"
+        @environment.config.providers.each do |name,provider|
+          begin
+            image=provider.images.get(imageId)
+            if image.nil?
+              env.ui.info "[#{name}] - ImageId #{imageId} not found"
+            else
+              env.ui.info "[#{name}] - ImageId #{imageId} found"
+              env.ui.info "[#{name}] - Deregistering #{imageId} now"
+              begin
+                provider.deregister_image(imageId)
+              rescue Fog::Service::Error => fogerror
+                env.ui.info "[Error] #{fogerror}"
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mccloud/provider/aws/ip/associate.rb

@@ -0,0 +1,33 @@
+module Mccloud::Provider
+  module Aws
+    module IpCommand
+
+      def associate(options)
+        unless raw.nil?
+          env.ui.info "[#{@name}] Attempting to associate ip #{@name} with vm name #{@vmname}"
+          vm=env.config.vms[@vmname]
+          if vm.nil?
+            env.ui.error "[#{@name}] vm #{@vmname} is not defined"
+            return
+          else
+            if vm.id.nil?
+              env.ui.error "[#{@name}] vm #{@vmname} is not yet instantiated"
+              return
+            else
+              env.ui.info "[#{@name}] The ipaddress currently has server_id #{raw.server_id} associated" unless raw.server_id.nil?
+              if raw.server_id==vm.id
+                env.ui.info "[#{@name}] #{@address} is already associated with #{@vmname} #{vm.id}"
+              else
+                env.ui.info "[#{@name}] Associating #{@address} with #{@vmname} #{vm.id}"
+                raw.server=vm.raw
+              end
+            end
+          end
+        else
+          env.ui.error "[#{ip.name}] Ipaddress does not (yet) exist"
+        end
+      end
+
+    end
+  end
+end

data/lib/mccloud/provider/aws/ip.rb

@@ -0,0 +1,31 @@
+require 'mccloud/provider/core/ip'
+require 'mccloud/provider/aws/ip/associate'
+
+module Mccloud::Provider
+  module Aws
+
+    class Ip < ::Mccloud::Provider::Core::Ip
+
+      #Inherits     :name
+      #             :provider
+      attr_accessor :vmname
+      attr_accessor :address
+
+      include Mccloud::Provider::Aws::IpCommand
+
+      def initialize(env)
+        super(env)
+      end
+
+      def raw
+        if @raw.nil?
+          rawname="#{@provider.filter}#{@name}"
+          @raw=@provider.raw.addresses.all('public-ip' => self.address).first
+          env.logger.info("IP found #{@raw.server_id} #{@raw.public_ip}")
+        end
+        return @raw
+      end
+
+    end #Class
+  end #module Type
+end #Module Mccloud

data/lib/mccloud/provider/aws/keystore.rb

@@ -0,0 +1,21 @@
+require 'mccloud/provider/core/keystore'
+
+module Mccloud::Provider
+  module Aws
+
+    class Keystore < ::Mccloud::Provider::Core::Keystore
+
+      #Inherits
+      #attr_accesor  :name,:provider
+      attr_accessor :keypairs
+
+     # include Mccloud::Provider::Aws::KeystoreCommand
+
+      def initialize(env)
+        super(env)
+        @keypairs=Array.new
+      end
+
+    end #Class
+  end #module Type
+end #Module Mccloud

data/lib/mccloud/provider/aws/lb/associate.rb

@@ -0,0 +1,53 @@
+module Mccloud::Provider
+  module Aws
+    module LbCommand
+
+      def associate(options)
+        balance(@members,options)
+      end
+
+      def balance(members,options)
+        unless raw.nil?
+          current_members=raw.instances
+          cleanup_members=current_members
+          members.each do |member_id|
+            env.logger.info "Attempting to associate  #{@name} with vm name #{member_id}"
+            vm=env.config.vms[member_id]
+            if vm.nil?
+              env.ui.error "vm #{member_id} is not defined"
+            else
+              if vm.id.nil?
+                env.ui.error "vm #{member_id} is not yet instantiated"
+              else
+                env.logger.info "The loadbalancer currently has members #{current_members.join(",")} associated" unless raw.instances.nil?
+
+                # First add new members
+                if current_members.include?(vm.id)
+                  cleanup_members=cleanup_members - [ vm.id ]
+                  env.ui.info "[#{@name}] Skipping associate #{vm.name} - #{vm.id} as it already is a member"
+                else
+                  env.ui.info "[#{@name}] Associating #{vm.name} - #{vm.id}"
+                  raw.register_instances(vm.id)
+                end
+
+              end
+            end
+          end
+
+          # And now remove old members
+          #unless member_ids.include?(instance_id)
+          #lb_instance=lb.instance
+          require 'pp'
+          cleanup_members.each do |member_id|
+            env.ui.info "Cleanup of old member #{member_id}"
+            raw.deregister_instances(member_id)
+          end
+
+        else
+          env.ui.error "[#{@name}] Loadbalancer does not (yet) exist"
+        end
+      end
+
+    end
+  end
+end

data/lib/mccloud/provider/aws/lb/sorry.rb

@@ -0,0 +1,14 @@
+require 'mccloud/provider/aws/lb/associate'
+
+module Mccloud::Provider
+  module Aws
+    module LbCommand
+
+      def sorry(options)
+        balance(@sorry_members,options)
+      end
+
+    end
+  end
+end
+