mccloud 0.0.13 → 0.0.14

data/lib/mccloud/provider/core/vm/ssh.rb

@@ -0,0 +1,137 @@
+require 'mccloud/util/platform'
+
+module Mccloud
+  module Provider
+    module Core
+      module VmCommand
+
+        def ssh_commandline_options(options)
+
+          command_options = [
+            "-q", #Suppress warning messages
+             #           "-T", #Pseudo-terminal will not be allocated because stdin is not a terminal.
+            "-t",
+            "-p #{@port}",
+            "-o UserKnownHostsFile=/dev/null",
+            "-o StrictHostKeyChecking=no",
+            #"-o IdentitiesOnly=yes",
+            "-o VerifyHostKeyDNS=no",
+            "-o ControlMaster=auto",
+            "-o \"ControlPath=~/.ssh/master-%r@%h:%p\""
+          ]
+          unless @private_key_path.nil?
+            command_options << "-i #{@private_key_path}"
+
+          end
+          if @agent_forwarding
+            command_options << "-A"
+          end
+          commandline_options="#{command_options.join(" ")} ".strip
+
+          unless options[:user]
+            user_option=@user.nil? ? "" : "-l #{@user}"
+          else
+            user_option=@user.nil? ? "" : "-l #{options[:user]}"
+          end
+
+          return "#{commandline_options} #{user_option}"
+        end
+
+        def sudo(command=nil,options={})
+
+          self.execute("#{sudo_string(command,options)}",options)
+        end
+
+        def sudo_string(command=nil,options={})
+          prefix="sudo -E "
+
+          # Check if we override the user in the options
+          unless options[:user]
+            prefix="" if self.user == "root"
+          else
+            prefix="" if options[:user] == "root"
+          end
+          return "#{prefix}#{command}"
+        end
+
+        def execute(command=nil,options={})
+          ssh(command,options)
+        end
+
+        def fg_exec(ssh_command,options)
+          # Some hackery going on here. On Mac OS X Leopard (10.5), exec fails
+          # (GH-51). As a workaround, we fork and wait. On all other platforms,
+          # we simply exec.
+          pid = nil
+          pid = fork if Mccloud::Util::Platform.leopard? || Mccloud::Util::Platform.tiger?
+
+          env.logger.info "Executing internal ssh command"
+          # Add terminal
+          env.logger.info ssh_command+" -t"
+          Kernel.exec ssh_command if pid.nil?
+          Process.wait(pid) if pid
+        end
+
+        def bg_exec(ssh_command,options)
+          result=ShellResult.new("","",-1)
+
+          IO.popen("#{ssh_command}") { |p|
+            p.each_line{ |l|
+              result.stdout+=l
+              print l unless options[:mute]
+            }
+            result.status=Process.waitpid2(p.pid)[1].exitstatus
+            if result.status!=0
+              env.ui.error "Exit status was not 0 but #{result.status}" unless options[:mute]
+            end
+          }
+          return result
+        end
+
+        def ssh(command=nil,options={})
+
+          # Command line options
+          extended_command="#{command}"
+
+          unless options.nil?
+            extended_command="screen -R \\\"#{command}\\\"" unless options[:screen].nil?
+          end
+
+          host_ip=self.ip_address
+
+          unless host_ip.nil? || host_ip==""
+            ssh_command="ssh #{ssh_commandline_options(options)} #{host_ip} \"#{extended_command}\""
+
+            unless options.nil? || options[:mute]
+              env.ui.info "[#{@name}] - ssh -p #{@port} #{@user}@#{host_ip} \"#{command}\""
+            end
+
+            if command.nil? || command==""
+              fg_exec(ssh_command,options)
+            else
+              unless options[:password]
+                bg_exec(ssh_command,options)
+              else
+                env.ui.info "[#{@name}] - attempting password login"
+                real_user = @user
+                real_user = options[:user] if options[:user]
+
+                if options[:user]
+                    Net::SSH.start(host_ip, real_user, :password => options[:password] ) do |ssh2|
+                        result = ssh2.exec!(command)
+                        puts result
+                    end
+                else
+                end
+              end
+            end
+
+          else
+            env.ui.error "Can't ssh into '#{@name} as we couldn't figure out it's ip-address"
+          end
+        end
+
+      end #Module
+    end #module
+  end #Module
+end #module

data/lib/mccloud/provider/core/vm/ssh_bootstrap.rb

@@ -0,0 +1,62 @@
+require 'mccloud/util/platform'
+require 'net/ssh'
+
+module Mccloud
+  module Provider
+    module Core
+      module VmCommand
+
+        def ssh_bootstrap(command,bootstrap_options=nil)
+          begin
+            options = bootstrap_options.dup
+
+            options[:port] = @port
+
+            unless @bootstrap_user.nil?
+              options[:user] = @bootstrap_user
+            end
+
+            unless @bootstrap_password.nil?
+              options[:password] = @bootstrap_password
+            end
+
+            if self.running?
+              scriptname=command.nil? ? @bootstrap : command
+              unless scriptname.nil?
+                env.logger.info "[#{@name}] - Using #{scriptname} as bootstrap script"
+                full_scriptname=Pathname.new(scriptname).expand_path(env.root_path).to_s
+                env.logger.info "[#{@name}] - Full #{full_scriptname} "
+                env.ui.info "[#{@name}] - Uploading bootstrap code to machine #{@name}"
+
+                unless !File.exists?(full_scriptname)
+                  begin
+                    self.transfer(full_scriptname,"/tmp/bootstrap.sh",options)
+                  rescue Net::SSH::AuthenticationFailed
+                    raise ::Mccloud::Error, "[#{@name}] - Authentication problem \n"
+                  rescue Exception => ex
+                    raise ::Mccloud::Error, "[#{@name}] - Error uploading file #{full_scriptname} #{ex.to_s}\n"
+                  end
+                  env.ui.info "[#{@name}] - Enabling the bootstrap code to run"
+                  result=self.execute("chmod +x /tmp/bootstrap.sh && #{self.sudo_string("/tmp/bootstrap.sh",options)}",options)
+
+
+                else
+                  raise ::Mccloud::Error, "[#{@name}] - Error: bootstrap file #{scriptname} does not exist"
+                end
+
+              else
+                env.ui.warn "[#{@name}] - You didn't specify a bootstrap, hope you know what you're doing."
+              end
+            else
+              env.ui.warn "[#{@name}] - Server is not running, so bootstrapping will do no good"
+            end
+          rescue ::Net::SSH::AuthenticationFailed => ex
+            raise ::Mccloud::Error, "[#{@name}] - Authentication failure #{ex.to_s}"
+          end
+        end
+
+      end #Module
+    end #module
+  end #Module
+end #module
+

data/lib/mccloud/provider/core/vm/ssh_forward.rb

@@ -0,0 +1,47 @@
+module Mccloud
+  module Provider
+    module Core
+      module VmCommand
+
+
+        def ssh_forward(options=nil)
+          return ssh_tunnel_start(@forwardings)
+        end
+
+        def ssh_tunnel_start(forwardings)
+          unless forwardings.empty?
+            @forward_threads<< Thread.new(self) { |vm|
+              env=vm.env
+              begin
+                ssh_options={ :paranoid => false, :keys_only => true}
+                ssh_options[:keys]= [ vm.private_key_path ] unless vm.private_key_path.nil?
+                Net::SSH.start(vm.ip_address, vm.user, ssh_options) do |ssh_session|
+                  vm.forwardings.each do |f|
+                    begin
+                      env.ui.info "Forwarding remote port #{f.remote} on #{vm.ip_address} from #{@name} to localhost port #{f.local}"
+                      ssh_session.forward.local(f.local.to_i, "127.0.0.1",f.remote.to_i)
+                      #ssh_session.forward.local(f.local.to_i, vm.ip_address,f.remote.to_i)
+                    rescue Errno::EACCES
+                      env.ui.error "Error - Access denied to forward remote port #{f.remote} from #{@name} to localhost port #{f.local}"
+                    end
+                  end
+                  ssh_session.loop {true}
+                end
+              rescue IOError
+                env.ui.error "IOError - maybe there is no listener on the port (yet?)"
+              end
+            }
+          end
+            return @forward_threads
+          end
+
+          def ssh_tunnel_stop
+            @forward_threads.each do |thread|
+              Thread.kill(thread)
+            end
+          end
+
+        end #Module
+      end #module
+    end #Module
+  end #module

data/lib/mccloud/provider/core/vm.rb

@@ -0,0 +1,121 @@
+require 'mccloud/provisioner/chef_solo'
+require 'mccloud/provisioner/puppet'
+require 'mccloud/provisioner/shell'
+
+require 'mccloud/provider/core/forwarding'
+
+require 'mccloud/provider/core/vm/ssh.rb'
+require 'mccloud/provider/core/vm/ssh_bootstrap.rb'
+require 'mccloud/provider/core/vm/ssh_forward.rb'
+require 'mccloud/provider/core/vm/rsync.rb'
+
+module Mccloud
+  module Provider
+    module Core
+
+      class ShellResult
+        attr_accessor :stdout
+        attr_accessor :stderr
+        attr_accessor :status
+
+        def initialize(stdout,stderr,status)
+          @stdout=stdout
+          @stderr=stderr
+          @status=status
+        end
+      end
+
+    class Vm
+
+      include Mccloud::Provider::Core::VmCommand
+
+      attr_reader   :env
+
+      attr_accessor :provider
+      attr_accessor :definition
+
+      attr_accessor :create_options
+      attr_accessor :name
+      attr_accessor :user
+      attr_accessor :port
+      attr_accessor :private_key_path
+      attr_accessor :public_key_path
+      attr_accessor :agent_forwarding
+
+      attr_accessor :auto_selection
+
+      attr_accessor :bootstrap
+      attr_accessor :bootstrap_user
+      attr_accessor :bootstrap_password
+      attr_accessor :provisioners
+
+      attr_accessor :forwardings
+      attr_accessor :shared_folders
+      attr_accessor :stacked
+      attr_accessor :declared
+
+      def initialize(env)
+        @env=env
+        @forwardings=Array.new
+        @shared_folders = Array.new
+        @stacked=false
+        @auto_selection=true
+        @declared=true
+        @provisioners=Array.new
+        @port=22
+        @agent_forwarding=false
+        @create_options={}
+        @definition=nil
+      end
+
+      def declared?
+        return declared
+      end
+
+      def stacked?
+        return stacked
+      end
+
+      def auto_selected?
+        return auto_selection
+      end
+
+      def provisioner
+        if provisioners.nil?
+          return nil
+        else
+          provisioners.first
+        end
+      end
+
+      # This function is swapped with the component provision function
+      # while reading the configuration
+      def provision(type)
+        if block_given?
+          case type
+          when :chef_solo
+            @provisioners<< Mccloud::Provisioner::ChefSolo.new(env)
+          when :puppet
+            @provisioners<<Mccloud::Provisioner::Puppet.new(env)
+          when :shell
+            @provisioners<<Mccloud::Provisioner::Shell.new(env)
+
+          else
+          end
+          yield @provisioners.last
+        end
+      end
+
+      def forward_port(name,remote,local)
+        forwarding=Forwarding.new(name,remote,local)
+        forwardings << forwarding
+      end
+
+      def method_missing(m, *args, &block)
+          env.logger.info "There's no keyword #{m} defined for vm #{@name}-- ignoring it"
+      end
+
+    end #Class
+  end #Module
+  end #Module
+end #Module Provider

data/lib/mccloud/provider/fog/fogconfig.rb

@@ -0,0 +1,44 @@
+module Mccloud
+  module Provider
+    module Fog
+      class FogConfig
+
+        attr_reader :credential
+        def initialize(credential)
+          @credential=credential
+        end
+
+        def exists?
+          return File.exists?(::Fog.credentials_path)
+        end
+
+        def missing_credentials(keynames)
+          missing_credentials=Array.new
+          ::Fog.credential=@credential
+
+          keynames.each do |key|
+            unless ::Fog.credentials.has_key?(key)
+               missing_credentials << key
+            end
+          end
+          return missing_credentials
+        end
+
+        def missing_snippet(keynames)
+          # Reading the existing file if needed
+          path=::Fog.credentials_path
+          keys={}
+          if File.exists?(path)
+            keys=YAML.load(File.read(path))
+          end
+          missing_credentials(keynames).each do |key|
+            keys[@credential]=Hash.new if keys[@credential].nil?
+            keys[@credential][key]="<your #{key}>"
+          end
+          return keys.to_yaml
+        end
+      end
+    end
+  end
+end
+

data/lib/mccloud/provider/fog/provider.rb

@@ -0,0 +1,46 @@
+require 'mccloud/provider/core/provider'
+require 'mccloud/provider/fog/fogconfig'
+
+module Mccloud
+  module Provider
+    module Fog
+      class Provider  < ::Mccloud::Provider::Core::Provider
+
+        attr_accessor :credentials_path
+
+        def initialize(name,options,env)
+          super(name,options,env)
+          required_gems=%w{fog}
+          check_gem_availability(required_gems)
+          require 'fog'
+          @credentials_path=::Fog.credentials_path
+        end
+
+        def check_fog_credentials(keynames)
+          ::Fog.credentials_path=@credentials_path
+
+          errormsgs=["Missing Credentials"]
+          fogconfig=::Mccloud::Provider::Fog::FogConfig.new(@credential)
+
+          missing_credentials=fogconfig.missing_credentials(keynames)
+          unless missing_credentials.empty?
+
+            unless fogconfig.exists?
+              errormsgs<<"Create the file #{::Fog.credentials_path} with the following content:"
+            else
+              errormsgs<<"Add the following snippet to #{::Fog.credentials_path}:"
+            end
+
+            errormsgs<< "=====================  snippet begin ====================="
+            errormsgs<< fogconfig.missing_snippet(keynames)
+            errormsgs<< "=====================  snippet end   ====================="
+            errormsg=errormsgs.join("\n")
+
+            raise Mccloud::Error, "#{errormsg}"
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/mccloud/provider/host/provider/status.rb

@@ -0,0 +1,12 @@
+module Mccloud::Provider
+  module Host
+    module ProviderCommand
+  
+    def status(selection=nil,options=nil)
+      
+    end
+    
+    end #module  
+  end #module
+end #module
+

data/lib/mccloud/provider/host/provider.rb

@@ -0,0 +1,85 @@
+require 'mccloud/provider/host/provider/status'
+require 'mccloud/provider/host/vm'
+require 'mccloud/provider/core/provider'
+
+module Mccloud
+  module Provider
+    module Host
+      class Provider  < ::Mccloud::Provider::Core::Provider
+
+        attr_accessor :name
+        attr_accessor :flavor
+
+        attr_accessor :options
+
+        attr_accessor :vms
+
+        include Mccloud::Provider::Host::ProviderCommand
+
+
+        def initialize(name,options,env)
+
+          super(name,options,env)
+
+          @vms=Hash.new
+
+          @options=options
+          @flavor=self.class.to_s.split("::")[-2]
+          @name=name
+        end
+
+        def raw
+          # We don't use this
+          @raw=nil
+        end
+        def up(selection,options)
+          on_selected_components("vm",selection) do |id,vm|
+            vm.up(options)
+          end
+        end
+
+        def bootstrap(selection,script,options)
+          on_selected_components("vm",selection) do |id,vm|
+            vm._bootstrap(script,options)
+          end
+
+        end
+
+        def destroy(selection,options)
+
+          on_selected_components("vm",selection) do |id,vm|
+            vm.destroy(options)
+          end
+
+        end
+
+        def ssh(selection,command,options)
+
+          on_selected_components("vm",selection) do |id,vm|
+            vm.ssh(command,options)
+          end
+
+        end
+
+
+
+        def provision(selection,options)
+
+          on_selected_components("vm",selection) do |id,vm|
+            vm._provision(options)
+          end
+
+        end
+
+        def halt(selection,options)
+          on_selected_components("vm",selection) do |id,vm|
+            env.ui.info "Matched #{vm.name}"
+            vm.halt(options)
+          end
+
+        end
+
+      end
+    end
+  end
+end

data/lib/mccloud/provider/host/vm/bootstrap.rb

@@ -0,0 +1,11 @@
+module Mccloud::Provider
+  module Host
+    module VmCommand
+
+      def _bootstrap(command,options=nil)
+        ssh_bootstrap(command,options)
+      end
+
+    end #module
+  end #module
+end #module

data/lib/mccloud/provider/host/vm/forward.rb

@@ -0,0 +1,12 @@
+module Mccloud::Provider
+  module Host
+    module VmCommand
+
+        def forward(command,options={})
+          @forward_threads=Array.new
+          return self.ssh_forward(options)
+        end
+
+    end #module
+  end #module
+end #module

data/lib/mccloud/provider/host/vm/provision.rb

@@ -0,0 +1,19 @@
+module Mccloud::Provider
+  module Host
+    module VmCommand
+
+      def _provision(options)
+
+        self.share
+
+        unless @provisioners.nil?
+          @provisioners.each do |provisioner|
+            env.ui.info "[#{@name}] - starting provisioning with #{provisioner.name} as provisioner"
+            provisioner.run(self)
+          end
+        end
+      end
+
+    end #module
+  end #module
+end #module

data/lib/mccloud/provider/host/vm/scp.rb

@@ -0,0 +1,35 @@
+require 'net/scp'
+module Mccloud::Provider
+  module Host
+    module VmCommand
+
+      def transfer(src,dest,options = {})
+        scp(src,dest,options)
+      end
+
+       def scp(src,dest,options = {})
+
+         if options[:user]
+
+           if options[:password]
+             Net::SCP.start(ip_address,options[:user],:password => options[:password], :port => options[:port]) do |auth_scp|
+               auth_scp.upload!(src,dest)
+             end
+           else
+             Net::SCP.start(ip_address,options[:user],:port => options[:port]) do |auth_scp|
+               auth_scp.upload!(src,dest)
+             end
+           end
+
+         else
+           Net::SCP.start(ip_address,@user, :port => options[:port]) do |auth_scp|
+               auth_scp.upload!(src,dest)
+             end
+           # This does not allow to specify a non standard port
+           #Net::SCP.upload!(ip_address,@user,src,dest,options)
+         end
+      end
+
+       end #module
+      end #module
+    end #module

data/lib/mccloud/provider/host/vm/ssh.rb

@@ -0,0 +1,11 @@
+module Mccloud::Provider
+  module Host
+    module VmCommand
+
+        def ssh(command,options={})
+          super(command,options)
+        end
+ 
+    end #module
+  end #module
+end #module

data/lib/mccloud/provider/host/vm.rb

@@ -0,0 +1,28 @@
+require 'mccloud/provider/core/vm'
+
+#require 'mccloud/provider/host/vm/up'
+require 'mccloud/provider/host/vm/bootstrap'
+require 'mccloud/provider/host/vm/ssh'
+require 'mccloud/provider/host/vm/scp'
+require 'mccloud/provider/host/vm/forward'
+#require 'mccloud/provider/host/vm/rsync'
+#require 'mccloud/provider/host/vm/halt'
+require 'mccloud/provider/host/vm/provision'
+#require 'mccloud/provider/host/vm/destroy'
+
+module Mccloud::Provider
+  module Host
+
+    class Vm < ::Mccloud::Provider::Core::Vm
+
+      include Mccloud::Provider::Host::VmCommand
+
+      attr_accessor :ip_address
+
+      def runnning?
+          true
+      end
+
+    end
+  end
+end