mccloud 0.0.1

data/lib/mccloud/command/init.rb

@@ -0,0 +1,7 @@
+module Mccloud
+  module Command
+  def init(amiId=nil)
+    Mccloud::Generators.run_cli Dir.pwd, File.basename(__FILE__), Mccloud::VERSION, ARGV
+  end
+end
+end

data/lib/mccloud/command/multi.rb

@@ -0,0 +1,53 @@
+require 'net/ssh/multi'
+
+module Mccloud
+  module Command
+    #http://stackoverflow.com/questions/1383282/netsshmulti-using-the-session-exec-how-do-you-get-the-output-straight-away
+    #https://gist.github.com/700730
+    def multi(selection=nil,command="who am i",options=nil)
+      trap("INT") { puts "we hit CTRL_C"; exit }
+      
+      Net::SSH::Multi.start do |session|
+         # Connect to remote machines
+         ip2name=Hash.new
+         on_selected_machines(selection) do |id,vm|
+           instance=vm.instance
+           if instance.state == "running"
+             ip2name[instance.public_ip_address]=vm.name
+             session.use "#{instance.public_ip_address}", { :user => vm.user , :keys => [ vm.key ], :paranoid => false, :keys_only => true}
+           end
+         end
+
+        puts "Executing #{command}"
+        begin
+         session.exec("#{command}") do |ch, stream, data|
+         #exit code
+         #http://groups.google.com/group/comp.lang.ruby/browse_thread/thread/a806b0f5dae4e1e2
+         
+         ch.on_request("exit-status") do |ch, data|
+           exit_code = data.read_long
+           @status=exit_code
+           if exit_code > 0
+             puts "ERROR: exit code #{exit_code}"
+           else
+             puts "Successfully executed"
+           end
+         end
+            if (ip2name.count > 1) || options.verbose?
+              puts "[#{ip2name[ch[:host]]}] #{data}"
+            else
+              print "#{data}"              
+            end
+           # puts "[#{ch[:host]} : #{stream}] #{data}"
+
+         end
+       rescue Errno::ECONNREFUSED
+         puts "oops - no connection"
+       end
+         # Tell Net::SSH to wait for output from the SSH server
+         session.loop  
+      end
+      
+    end
+  end
+end

data/lib/mccloud/command/provision.rb

@@ -0,0 +1,28 @@
+require 'net/scp'
+
+module Mccloud
+  module Command
+
+    def provision(selection=nil,options=nil)
+      on_selected_machines(selection) do |id,vm|
+        instance=vm.instance
+        instance.private_key_path=vm.key
+        instance.username = vm.user
+  
+        #p vm.provisioner
+        provisioner=@session.config.provisioners[vm.provisioner.to_s]
+        if provisioner.nil?
+          # We take the first provisioner defined
+          provisioner=@session.config.provisioners.first[1]
+        end
+        provisioner.run(vm)
+      end
+      ##on_selected_machines(selection) do |id,vm|
+      #instance=PROVIDER.servers.get(id)
+      #options={ :port => 22, :keys => [ vm.key ], :paranoid => false, :keys_only => true}
+      #Mccloud::Ssh.execute(instance.public_ip_address,vm.user,options,"who am i")
+      #end
+    end
+    
+  end
+end

data/lib/mccloud/command/reload.rb

@@ -0,0 +1,11 @@
+module Mccloud
+  module Command
+  def reload(selection=nil?)
+    load_config
+    on_selected_machines(selection) do |id,vm|
+      puts "rebooting #{id}"
+      vm.instance.reboot
+    end
+  end
+end
+end

data/lib/mccloud/command/server.rb

@@ -0,0 +1,30 @@
+require 'net/ssh/multi'
+require 'pp'
+module Mccloud
+  module Command
+    def server(selection=nil,options=nil)
+      
+      trap("INT") { puts "You've hit CTRL-C . Stopping server now"; exit }
+      threads = []
+      on_selected_machines(selection) do |id,vm|
+        threads << Thread.new(id,vm) do |id,vm|
+          public_ip_address=vm.instance.public_ip_address
+          private_ip_address=vm.instance.private_ip_address
+          unless public_ip_address.nil? || private_ip_address.nil?
+            ssh_options={ :keys => [ vm.key ], :paranoid => false, :keys_only => true}
+            Net::SSH.start(public_ip_address, vm.user, ssh_options) do |ssh|
+              vm.forwardings.each do |forwarding|
+                puts "forwarding port #{forwarding.remote} from #{vm.name} to local port #{forwarding.local}"
+                ssh.forward.local(forwarding.local, private_ip_address,forwarding.remote)
+              end
+              ssh.loop { true }
+            end
+          end
+        end
+      end
+#      threads.each {|thr| thr.join}
+      puts "and we continue here"
+      sleep 30
+    end
+  end
+end

data/lib/mccloud/command/ssh.rb

@@ -0,0 +1,46 @@
+require 'mccloud/util/platform'
+require 'pp'
+
+module Mccloud
+  module Command
+  def ssh(selection=nil,command=nil,options=nil)
+    if options.screen?
+      extra_command="\"screen -R \\\"#{command}\\\"\""
+    else
+      extra_command="\"#{command}\""
+    end
+    
+    if selection.nil?
+      @session.config.vms
+      selection=@session.config.vms.first[0]
+    end
+    
+    name=selection
+    vm=@session.config.vms[name]
+    if vm.instance.state != "running"
+      puts "#{name} is not running, move along"
+      return
+    end
+
+    #https://github.com/mitchellh/vagrant/blob/master/lib/vagrant/ssh.rb
+    options={ :port => 22, :private_key_path => vm.key, 
+      :username => vm.user , :host => vm.instance.public_ip_address }
+      # Command line options
+      command_options = ["-p #{options[:port]}", "-o UserKnownHostsFile=/dev/null",
+      "-t -o StrictHostKeyChecking=no", "-o IdentitiesOnly=yes","-o VerifyHostKeyDNS=no",
+      "-i #{options[:private_key_path]}"]
+      # 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?
+
+      command_exec="ssh #{command_options.join(" ")} #{options[:username]}@#{options[:host]} #{extra_command}".strip
+      puts "#{command_exec}"
+      Kernel.exec command_exec if pid.nil?
+      Process.wait(pid) if pid
+    end
+
+ 
+  end
+end

data/lib/mccloud/command/status.rb

@@ -0,0 +1,31 @@
+module Mccloud
+  module Command
+    def status(selection=nil,options=nil)
+
+      printf "%-10s %-12s %-20s %-15s %-8s\n", "Name", "Instance Id", "IP", "Type","Status"
+      80.times { |i| printf "=" } ; puts
+
+      unless options.verbose?
+        filter=@session.config.mccloud.prefix
+      else
+        filter=""
+      end
+
+      @session.config.providers.each  do |name,provider|
+          provider.servers.each do |vm|
+            name="<no name set>"
+            if !vm.tags["Name"].nil?
+              name=vm.tags["Name"].strip
+            end #end if
+
+            if name.start_with?(filter)
+              unless filter==""
+                name[filter+" - "]=""
+              end
+              printf "%-10s %-12s %-20s %-15s %-8s\n",name,vm.id, vm.public_ip_address, vm.flavor.name,vm.state
+            end
+          end #End 1 provider
+        end #providers
+    end #def
+  end #module
+end

data/lib/mccloud/command/suspend.rb

@@ -0,0 +1,15 @@
+module Mccloud
+  module Command
+    def suspend
+      load_config
+      on_selected_machines(selection) do |id,vm|
+        puts "Halting machine #{vm.name} with Id: #{id}"
+        PROVIDER.servers.get(id).stop
+
+        vm.instance.wait_for { printf ".";STDOUT.flush;  state=="stopped"}          
+        puts
+        
+      end
+    end
+  end
+end

data/lib/mccloud/command/up.rb

@@ -0,0 +1,65 @@
+require 'pp'
+require 'mccloud/util/iterator'
+
+module Mccloud
+  module Command
+    include Mccloud::Util
+    def up(selection,options)
+
+      on_selected_machines(selection) do |id,vm|
+
+        provider=@session.config.providers[vm.provider]
+        if (id.nil?)
+          puts "Machine #{vm.name} doesn't yet exist"
+          provider_options=vm.provider_options
+          boxname=vm.name
+          puts "Spinning up a new machine called #{boxname}"
+          instance=provider.servers.create(provider_options)
+          puts "Waiting for it the machine to become accessible"
+          instance.wait_for { printf "."; STDOUT.flush;  ready?}
+          puts
+          prefix=@session.config.mccloud.prefix
+
+
+          provider.create_tags(instance.id, { "Name" => "#{prefix} - #{boxname}"})
+
+          # Resetting the in memory model of the new machine
+          @all_servers[boxname.to_s]=instance.id
+          unless @session.config.vms[boxname.to_s].nil?
+            @session.config.vms[boxname.to_s].reload
+          end
+
+          # Wait for ssh to become available ...
+          puts "Waiting for ssh to be come available"
+          Mccloud::Util.execute_when_tcp_available(instance.public_ip_address, { :port => 22, :timeout => 60 }) do
+            puts "Ok, ssh is available , proceeding with bootstrap"
+          end
+
+          @session.bootstrap(boxname.to_s,nil,options)       
+
+        else 
+          state=vm.instance.state
+          if state =="stopped"
+            puts "Machine #{vm.name} was stopped -> starting it again"
+            vm.instance.start
+            vm.instance.wait_for { printf ".";STDOUT.flush;  ready?}  
+            puts        
+          else
+            puts "Machine #{selection} already exists but is currently in state #{state} "
+          end
+        end
+
+
+      end
+
+      @session.provision(selection,options)       
+
+      #server.boostrap(:image_id => 'ami', :private_key_path => '', :public_key_path => '')
+    end
+ 
+ 
+ 
+ 
+ 
+  end
+end

data/lib/mccloud/config.rb

@@ -0,0 +1,47 @@
+require 'mccloud/configurator/mccloud'
+require 'mccloud/configurator/vm'
+require 'mccloud/configurator/lb'
+require 'mccloud/provisioner/chef_solo'
+
+module Mccloud
+  
+  class Configuration
+    attr_accessor :vms
+    attr_accessor :lbs
+    attr_accessor :providers
+    attr_accessor :provisioners
+    
+    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
+    end
+  end
+  
+  module Config
+    class << self; 
+      attr_accessor :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
+    end
+  end
+end

data/lib/mccloud/configurator/lb.rb

@@ -0,0 +1,26 @@
+require 'mccloud/provisioner/chef_solo'
+require 'mccloud/provisioner/puppet'
+
+require 'mccloud/type/lb'
+
+module Mccloud
+  module Configurator
+    
+  class LbConfigurator
+
+    attr_accessor :lb
+    
+    def initialize()
+     end
+    
+    def define(name)
+      @lb=Mccloud::Type::Lb.new	
+      lbconfig=self
+      yield lbconfig
+      @lb.name=name
+      Mccloud.session.config.lbs[name.to_s]=@lb
+    end
+  end
+  
+end
+end #Module Mccloud

data/lib/mccloud/configurator/mccloud.rb

@@ -0,0 +1,13 @@
+module Mccloud
+  module Configurator
+    class MccloudConfigurator
+      attr_accessor :prefix
+      attr_accessor :loglevel
+      
+      def initialize()
+          @prefix="mccloud"
+          @loglevel=:info
+      end      
+    end
+  end
+end

data/lib/mccloud/configurator/vm.rb

@@ -0,0 +1,37 @@
+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/generators.rb

@@ -0,0 +1,28 @@
+require 'templater'
+
+module Mccloud
+  module Generators
+    extend Templater::Manifold
+
+    class InitGenerator < Templater::Generator
+      def self.source_root
+        File.join(File.dirname(__FILE__), 'templates')
+      end
+
+      desc <<-DESC
+      Initialize a mccloud environment 
+      mccloud init [AMI-ID]
+      DESC
+
+      first_argument :ami_id, :required => true, :desc => 'AMI ID'
+ 
+      template :mccloudfile, 'Mccloudfile'
+                
+    end
+    
+    desc "Generators to simplify the creation of a Mccloud Project"
+    add :init, InitGenerator
+    
+  end
+end
+