mccloud 0.0.13 → 0.0.14

data/lib/mccloud/command/named_base.rb

@@ -0,0 +1,14 @@
+module Mccloud
+  module Command
+    # Same as {Base} except adds the `name` argument for you. This superclass
+    # is useful if you're creating a command which should be able to target
+    # a specific VM in a multi-VM environment. For example, in a multi-VM
+    # environment, `vagrant up` "ups" all defined VMs, but you can specify a
+    # name such as `vagrant up web` to target only a specific VM. That name
+    # argument is from {NamedBase}. Of course, you can always add it manually
+    # yourself, as well.
+    class NamedBase < Base
+      argument :name, :type => :string, :optional => true
+    end
+  end
+end

data/lib/mccloud/command/package.rb

@@ -0,0 +1,17 @@
+module Mccloud
+  module Command
+    class PackageCommand < Base
+
+      argument :box_name, :type => :string, :optional => false, :default => nil
+
+      register "package [NAME]", "Packages the machine"
+
+      def execute
+        env.config.providers.each do |name,provider|
+          env.logger.debug("Asking provider #{name} to package box #{box_name}")
+          provider.package(box_name,options)
+        end
+      end
+    end
+  end
+end

data/lib/mccloud/command/provider.rb

@@ -0,0 +1,30 @@
+module Mccloud
+  module EnvironmentCommand
+
+     def boot(selection=nil,options=nil)
+       @config.providers.each do |name,provider|
+         provider.boot(selection,command,options)
+       end
+     end
+
+     def bootstrap(selection=nil,options=nil)
+       @config.providers.each do |name,provider|
+         provider.bootstrap(selection,options)
+       end
+     end
+
+     def halt(selection,options)
+       @config.providers.each do |name,provider|
+         provider.halt(selection,options)
+       end
+     end
+
+     def rsync(selection,path,options)
+       @config.providers.each do |name,provider|
+         provider.rsync(selection,path,options)
+       end
+     end
+
+
+  end
+end

data/lib/mccloud/command/provision.rb

@@ -1,31 +1,17 @@
-require 'net/scp'
-
 module Mccloud
   module Command
+    class ProvisionCommand < Base
+
+      argument :box_name, :type => :string, :optional => false, :default => nil
+
+      register "provision [NAME]", "Provisions the machine"
 
-    def provision(selection=nil,options=nil)
-      on_selected_machines(selection) do |id,vm|
-        
-        instance=vm.instance
-        instance.private_key_path=vm.private_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]
-        else
-          puts "Starting provisioning on #{vm.name} with #{vm.provisioner} as provisioner"
-          provisioner.run(vm)
+      def execute
+        env.config.providers.each do |name,provider|
+          env.logger.debug("Asking provider #{name} to provision box #{box_name}")
+          provider.provision(box_name,options)
         end
       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
+end

data/lib/mccloud/command/reload.rb

@@ -1,11 +1,17 @@
 module Mccloud
   module Command
-  def reload(selection=nil?)
-    load_config
-    on_selected_machines(selection) do |id,vm|
-      puts "rebooting #{id}"
-      vm.instance.reboot
+    class ReloadCommand < Base
+
+      argument :box_name, :type => :string, :optional => true, :default => nil
+
+      register "reload [NAME]", "Reboots the machine"
+
+      def execute
+        env.config.providers.each do |name,provider|
+          env.logger.debug("Asking provider #{name} to reload box #{box_name}")
+          provider.reload(box_name,options)
+        end
+      end
     end
   end
 end
-end

data/lib/mccloud/command/sorry.rb

@@ -0,0 +1,20 @@
+module Mccloud
+  module Command
+    class SorryCommand < Base
+
+      register "sorry [LB-NAME]", "Puts loadbalancers in a sorry state"
+      argument :selection, :type => :string, :optional => true, :default => nil
+
+      def execute
+        env.config.providers.each do |name,provider|
+          env.logger.debug("Asking provider #{name} to sorry #{selection}")
+          provider.on_selected_components("lb",selection) do |id,lb|
+            lb.sorry(options)
+          end
+        end
+      end
+
+    end
+
+  end
+end

data/lib/mccloud/command/ssh.rb

@@ -1,52 +1,18 @@
-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.nil?
-      puts "#{name} is not available anymore"
-      return
-    end
-    if vm.instance.state != "running"
-      puts "#{name} is not running, move along"
-      return
-    end
+    class SshCommand < Base
 
-    #https://github.com/mitchellh/vagrant/blob/master/lib/vagrant/ssh.rb
-    options={ :port => 22, :private_key_path => vm.private_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?
+      argument :box_name, :type => :string, :optional => false, :default => nil
+      argument :command, :type => :string, :optional => true, :default => nil
 
-      command_exec="ssh #{command_options.join(" ")} #{options[:username]}@#{options[:host]} #{extra_command}".strip
-      
-      puts "Executing - #{command_exec}"
-      puts
-      Kernel.exec command_exec if pid.nil?
-      Process.wait(pid) if pid
-    end
+      register "ssh [NAME] [COMMAND]", "Ssh-shes into the box"
 
- 
+      def execute
+        env.config.providers.each do |name,provider|
+          env.logger.debug("Asking provider #{name} to ssh into box #{box_name}")
+          provider.ssh(box_name,command,options)
+        end
+      end
+    end
   end
 end

data/lib/mccloud/command/status.rb

@@ -1,40 +1,19 @@
 module Mccloud
   module Command
-    def status(selection=nil,options=nil)
+    class StatusCommand < Base
 
-      unless options.verbose?
+      class_option :force, :type => :boolean, :default => false, :aliases => "-f"
+      class_option :debug,:type => :boolean , :default => false, :aliases => "-d", :desc => "enable debugging"
+      class_option :provider, :type => :string, :optional => true, :default => nil
+      argument :name, :type => :string, :optional => true, :default => nil
+      register "status [name]", "Shows the status of the current Mccloud environment"
 
-        filter=@session.config.mccloud.filter
-        puts "Using Filter: #{filter}"
-
-        printf "%-10s %-12s %-20s %-15s %-8s\n", "Name", "Instance Id", "IP", "Type","Status"
-        80.times { |i| printf "=" } ; puts
-      else
-        filter=""
+      def execute
+        env.load!
+        env.config.providers.each do |provider_name,provider_instance|
+          provider_instance.status(name,options)
+        end
       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+" - "]=""
-                printf "%-10s %-12s %-20s %-15s %-8s\n",name,vm.id, vm.public_ip_address, vm.flavor.name,vm.state
-              else
-                puts "Name: #{name}"
-                puts "Instance Id: #{vm.id}"
-                puts "Public Ip: #{vm.public_ip_address}"
-                puts "Flavor: #{vm.flavor.name}"
-                puts "State: #{vm.state}"
-                80.times { |i| printf "=" } ; puts
-              end
-            end
-          end #End 1 provider
-        end #providers
-    end #def
-  end #module
-end
+    end
+  end
+end

data/lib/mccloud/command/template.rb

@@ -0,0 +1,16 @@
+module Mccloud
+  module Command
+    class TemplateCommand < Mccloud::Command::GroupBase
+      register "template", "Subcommand to manage templates"
+
+      desc "list [TEMPLATE-NAME]", "List templates"
+      def list(selection=nil)
+          env.config.templates.each do |name,template|
+            env.ui.info template.to_s
+          end
+      end
+
+    end
+
+  end
+end

data/lib/mccloud/command/undefine.rb

@@ -0,0 +1,23 @@
+require 'fileutils'
+module Mccloud
+  module Command
+    class UnDefineCommand < Base
+
+      register "undefine NAME", "Undefines a machine"
+      argument :name, :type => :string, :optional => false, :default => nil
+
+      def execute
+        env.ui.info "Undefine machine #{name}"
+        filename=File.join("vms","#{name}.rb")
+        if File.exists?(filename)
+          env.ui.info "Removing #{filename}"
+          FileUtils.rm(filename)
+        else
+          env.ui.info "Machine #{name} has not yet defined"
+        end
+      end
+
+    end
+
+  end
+end

data/lib/mccloud/command/up.rb

@@ -1,71 +1,17 @@
-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?)
-          provider_options=vm.provider_options
-          boxname=vm.name
-          puts "Spinning up a new machine called #{boxname}"
-          
-          provider_options=provider_options.merge({ :private_key_path => vm.private_key , :public_key_path => vm.public_key, :username => vm.user})
-          
-          #instance=provider.servers.bootstrap(provider_options)
-
-          instance=provider.servers.create(provider_options)
-          #instance=provider.servers.create(provider_options)
-          
-          puts "Waiting for the machine to become accessible"
-          instance.wait_for { printf "."; STDOUT.flush;  ready?}
-          puts
-          filter=@session.config.mccloud.filter
-    
-          provider.create_tags(instance.id, { "Name" => "#{filter} - #{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
+    class UpCommand < Base
 
-          # Wait for ssh to become available ...
-          puts "Waiting for ssh to be come available"
-          #puts instance.console_output.body["output"]
+      argument :box_name, :type => :string, :optional => true, :default => nil
 
-          Mccloud::Util.execute_when_tcp_available(instance.public_ip_address, { :port => 22, :timeout => 60 }) do
-            puts "Ok, ssh is available , proceeding with bootstrap"
-          end
+      register "up [NAME]", "Starts the machine and provisions it"
 
-          @session.bootstrap(boxname.to_s,nil,options)       
-
-        else 
-          state=vm.instance.state
-          if state =="stopped"
-            puts "Booting up machine #{vm.name}"
-            vm.instance.start
-            vm.instance.wait_for { printf ".";STDOUT.flush;  ready?}  
-            puts        
-          else
-            puts "Machine #{selection} is already running."
-          end
+      def execute
+        env.config.providers.each do |name,provider|
+          env.logger.debug("Asking provider #{name} to up box #{box_name}")
+          provider.up(box_name,options)
         end
-
-
       end
-
-      @session.provision(selection,options)       
-
     end
- 
- 
- 
- 
- 
   end
-end
+end

data/lib/mccloud/command/version.rb

@@ -0,0 +1,14 @@
+module Mccloud
+  module Command
+    class VersionCommand < Base
+
+      register "version", "Prints the Mccloud version information"
+
+      def execute
+        env.ui.info "Version : #{Mccloud::VERSION} - use at your own risk"
+      end
+
+    end
+
+  end
+end

data/lib/mccloud/command/vm.rb

@@ -0,0 +1,27 @@
+module Mccloud
+  module Command
+    class VmCommand < Mccloud::Command::GroupBase
+      register "vm", "Subcommand to manage vms"
+
+      desc "define [VM-NAME] [DEFINITION-NAME]", "define a new vm based on a definition"
+      def define(vm_name,definition_name)
+        env.config.vms.define(vm_name,definition_name)
+      end
+
+      desc "list", "list all known vms"
+      def list
+        vms = env.config.vms.sort
+        printf("%-30s|%-20s|%-15s|%-15s\n","alias","provider","ip-address","private-address")
+        80.times do 
+          print '-'
+        end
+        puts
+        vms.each do |name,vm|
+          printf("%-30s|%-20s|%-15s|%-15s\n",name,vm.provider.name,vm.ip_address,vm.private_ip_address)
+        end
+      end
+
+    end #Class
+
+  end #Module
+end # Module

data/lib/mccloud/command.rb

@@ -0,0 +1,36 @@
+module Mccloud
+  module Command
+    autoload :Base,      'mccloud/command/base'
+    autoload :GroupBase, 'mccloud/command/group_base'
+    autoload :Helpers,   'mccloud/command/helpers'
+    autoload :NamedBase, 'mccloud/command/named_base'
+  end
+end
+
+# The built-in commands must always be loaded
+require 'mccloud/command/status'
+#require 'mccloud/command/init'
+require 'mccloud/command/keypair'
+require 'mccloud/command/up'
+require 'mccloud/command/bootstrap'
+require 'mccloud/command/ssh'
+require 'mccloud/command/provision'
+require 'mccloud/command/destroy'
+require 'mccloud/command/halt'
+require 'mccloud/command/ip'
+require 'mccloud/command/ips'
+require 'mccloud/command/sorry'
+require 'mccloud/command/lb'
+require 'mccloud/command/vm'
+require 'mccloud/command/image'
+require 'mccloud/command/balance'
+require 'mccloud/command/reload'
+require 'mccloud/command/keystore'
+#require 'mccloud/command/suspend'
+require 'mccloud/command/package'
+#require 'mccloud/command/resume'
+require 'mccloud/command/forward'
+require 'mccloud/command/version'
+require 'mccloud/command/template'
+require 'mccloud/command/define'
+#require 'mccloud/command/undefine'

data/lib/mccloud/config/collection.rb

@@ -0,0 +1,107 @@
+require 'mccloud/config/component'
+require 'ostruct'
+
+module Mccloud
+  class Config
+    class Collection
+
+      attr_accessor :components
+      attr_accessor :type
+      attr_accessor :config
+
+      attr_reader   :env
+
+      def initialize(type,config)
+        @type=type
+        @components=Hash.new
+        @providers=config.providers
+        @config=config
+        @env=config.env
+      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
+        component_stub=OpenStruct.new
+        component_stub.send("#{@type}=",::Mccloud::Config::Component.new(config))
+
+        env.logger.info("config collection"){ "First pass of reading the config"}
+        # Now we can 'execute' the config file using our stub component
+        # For guessing the provider type
+        yield component_stub
+
+        env.logger.debug("config collection"){ "Stubs collection type #{@type} is loaded"}
+
+        # After processing we extract the component again
+        component=component_stub.send("#{@type}")
+
+
+        # Checking if this component has a base definition
+        provider_name=nil
+        if component.provider.nil?
+          env.logger.debug("config collection"){ "We got an empty provider here"}
+          env.logger.debug("config collection"){ "Trying if there is a definition provider"}
+          unless component.definition.nil?
+            provider_name=env.config.definitions[component.definition].provider
+          end
+        else
+          provider_name=component.provider.to_s
+        end
+
+        provider=@providers[provider_name]
+
+        env.logger.debug("config collection"){ "We get here"}
+
+        if provider.nil?
+          env.ui.warn "Provider #{component.provider.to_s} does not (yet) exist"
+          env.ui.warn "Skipping definition of #{name}"
+          return
+        end
+
+        unless component.definition.nil?
+          real_component=env.config.definitions[component.definition].to_vm("blub")
+        else
+          real_component=provider.get_component(@type.capitalize,env)
+        end
+
+        begin
+
+          # And repeat the same process with a real component
+          env.logger.debug("config collection"){ "Component of #{@type}"}
+
+          component_stub.send("#{@type}=",real_component)
+
+          yield component_stub
+          # After processing we extract the component again
+          component=component_stub.send("#{@type}")
+          # And we set the name
+          component.name=name
+
+          # We set the provider for this component
+          component.provider=provider
+
+          # And register this component with the provider
+          # if it is a vm, we add to the hash vms
+          # if it is an ip, we add it to the hash ips
+          provider_collection=provider.instance_variable_get("@#{@type}s")
+          env.logger.debug("registering #{name} with provider #{provider.name}")
+          provider_collection[name]=component
+
+          # And we also add it to the global config element
+          # So we can have all components of a similar type in one place
+          config_collection=@config.instance_variable_get("@#{@type}s")
+          config_collection[name]=component
+
+          # Now we can ask the component to validate itself
+          #component_stub.validate
+          components[name.to_s]=component
+
+        rescue Error => e
+          env.ui.error "Error loading component with #{name} of type #{@type} for provider #{component.provider.type}"
+        end
+      end
+
+    end
+  end
+end #Module Mccloud

data/lib/mccloud/config/component.rb

@@ -0,0 +1,20 @@
+module Mccloud
+  class Config
+    class Component
+
+      attr_accessor :provider
+      attr_accessor :definition
+
+      attr_reader   :env
+
+      def initialize(config)
+        @env=config.env
+      end
+
+      def method_missing(m, *args, &block)
+#         env.ui.info "There's no method called #{m} here -- please try again."
+       end
+
+    end
+  end
+end #Module Mccloud

data/lib/mccloud/config/definition.rb

@@ -0,0 +1,35 @@
+require 'mccloud/config/component'
+require 'mccloud/definition'
+require 'ostruct'
+
+module Mccloud
+  class Config
+    class Definition
+
+      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
+        definition_stub=OpenStruct.new
+        definition_stub.definition=::Mccloud::Definition.new(name,env)
+
+        env.logger.debug("config definitions"){ "Start reading definitions"}
+
+        yield definition_stub
+
+        env.logger.debug("config definitions"){ "End reading definition #{definition_stub.definition.name}"}
+
+        components[name.to_s]=definition_stub.definition
+      end
+
+    end
+  end
+end #Module Mccloud

data/lib/mccloud/config/keypair.rb

@@ -0,0 +1,36 @@
+require 'mccloud/config/component'
+require 'mccloud/keypair'
+require 'ostruct'
+
+module Mccloud
+  class Config
+    class Keypair
+
+      attr_accessor :components
+      attr_reader :env
+
+      def initialize(config)
+        @env=config.env
+        @components=Hash.new
+        env.logger.debug("initalizing keypair")
+      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
+        keypair_stub=OpenStruct.new
+        keypair_stub.keypair=::Mccloud::Keypair.new(name,env)
+
+        env.logger.debug("config keypair"){ "Start reading keypair"}
+
+        yield keypair_stub
+
+        env.logger.debug("config keypair"){ "End reading keypair #{keypair_stub.keypair.name}"}
+
+        components[name.to_s]=keypair_stub.keypair
+      end
+
+    end
+  end
+end #Module Mccloud