mccloud 0.0.13 → 0.0.14

data/bin/mccloud

@@ -1,128 +1,29 @@
 #!/usr/bin/env ruby
-
-require 'rubygems'
-require 'thor'
 require 'mccloud'
 
-require 'mccloud/version'
-require 'mccloud/session'
-
-class MccloudCLI < Thor 
-
-  attr_accessor :all_servers
-  no_tasks do
-    def create_session
-      @session=Mccloud::Session.new
-      @session.load_config
-    end
-
-  end
-
-  desc "init", "Creates a Mccloud Config File" 
-  method_options :force => :boolean
-  def init(amiId=nil)
-    Mccloud::Command.init(amiId,options)
-  end
-
-  desc "up [NAME]", "Fires up a machine, bootstrap and provision"
-  method_options :force => :boolean
-  def up(selection=nil)
-    create_session
-    @session.up(selection,options)
-  end
-  
-  desc "status", "Show a status of all machines that are configured"
-  method_options :verbose => false
-  def status(selection=nil)
-    create_session
-    @session.status(selection,options)
-  end
-
-  desc "halt [NAME]", "Shutdown the machine"
-  method_options :force => :boolean  
-  def halt(selection=nil)
-    create_session
-     @session.halt(selection,options)
-  end
-  
-  desc "ssh [NAME]", "Spawns an ssh client to the machine"
-   method_options :screen => :boolean  
-   def ssh(selection=nil,command=nil)
-    create_session
-    @session.ssh(selection,command,options)
-   end
-   
-  desc "suspend [NAME]", "Shutdown of the machine"
-  method_options :force => :boolean
-  def suspend(selection=nil)
-    create_session
-    @session.suspend(selection,options)
-  end
-
-#  desc "boot", "same a"
-#  method_options :force => :boolean
-#  def boot(selection=nil)
-#    create_session
-#    @session.boot(selection,options)
-#  end
 
-  desc "destroy [NAME]", "Destroys the machine"
-  method_options :force => :boolean  
-  def destroy(selection=nil)
-    create_session
-    @session.destroy(selection,options)
-  end
+begin
 
-  desc "reload [NAME]", "Reboots the machine"
-  method_options :force => :boolean  
-  def reload(selection=nil?)
-    create_session
-    @session.reload(selection,options)
-  end
+  # Disable color if the proper argument was passed
+  shell = ARGV.include?("--no-color") ? Thor::Shell::Basic.new : Thor::Base.shell.new
 
-#  desc "command [NAME] [COMMAND]", "exec a command on a box"
-#  method_options :parallel => :boolean
-#  def command(selection=nil,command="who am i")
-#    create_session
-#    @session.command(selection,command,options)
-#  end
 
-  desc "bootstrap [NAME]", "Executes the bootstrap sequence"
-  method_options :sudo => :boolean      
-  def bootstrap(selection=nil,script="who am i")
-    create_session
-    @session.bootstrap(selection,script,options)
-  end
+  # Start the CLI
+  begin
+    env = Mccloud::Environment.new(:cwd => ".")
 
-#  desc "multi","multi"
-#  method_options :verbose => :boolean  
-#  def multi(selection=nil,command="who am i")
-#    create_session
-#    @session.multi(selection,command,options)
-#  end  
+    # # Attach the UI
+    env.ui = ::Mccloud::UI::Shell.new(env, shell)
 
-  desc "provision [NAME]", "Runs the provisioner the machine"
-  def provision(selection=nil)
-    create_session
-    @session.provision(selection,options)
+    ::Mccloud::CLI.start(ARGV,:env => env)
+  rescue Mccloud::Error => ex
+    env.ui.error "#{ex}"
+  rescue Exception => ex
+    puts "Something blew up Mccloud. Time for McGuyver:"
+    puts ""
+    puts "#{ex}"
+    puts ex.backtrace
+    exit 1
   end
 
-  desc "server", "Runs a server+ forwards network ports"
-  def server(selection=nil)
-    create_session
-    @session.server(selection,options)
-  end
 end
-
-puts 
-80.times { |i| printf "*" } ; puts
-myversion="* Mccloud v#{Mccloud::VERSION} - alpha - use at your own risk"
-puts "#{myversion}"
-puts "- github : https://github.com/jedi4ever/mccloud"
-
-80.times { |i| printf "*" } ; puts
-puts
-
-
-MccloudCLI.start
-puts

data/bin/mccloud_old

@@ -0,0 +1,159 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'thor'
+require 'mccloud'
+
+
+class MccloudCLI < Thor
+
+  no_tasks do
+    #    def create_environment
+    #      @environment=Mccloud::Environment.new.
+    #      @environment.load_config
+    #    end
+  end
+
+  desc "init", "Creates a Mccloud Config File"
+  method_options :force => :boolean
+  def init(name=nil)
+    Mccloud::Environment.new().load!().init(name,options)
+  end
+
+  desc "up [NAME]", "Fires up a machine, bootstrap and provision"
+  method_options :force => :boolean
+  method_options :noprovision => :boolean
+  def up(selection=nil)
+    Mccloud::Environment.new().load!().up(selection,options)
+  end
+
+  desc "status", "Show a status of all machines and images that are configured"
+  method_options :verbose => false
+  def status(selection=nil)
+    Mccloud::Environment.new().load!().status(selection,options)
+  end
+
+  desc "halt [NAME]", "Shutdown the machine"
+  method_options :force => :boolean
+  def halt(selection=nil)
+    Mccloud::Environment.new().load!().halt(selection,options)
+  end
+
+  desc "ssh [NAME]", "Spawns an ssh client to the machine"
+  method_options :screen => :boolean
+  def ssh(selection=nil,command=nil)
+    Mccloud::Environment.new().load!().ssh(selection,command,options)
+  end
+
+  desc "rsync [PATH]", "Syncs the directory to the remote machine"
+  method_options :screen => :boolean
+  def rsync(selection=nil,path=nil)
+    Mccloud::Environment.new().load!().rsync(selection,path,options)
+  end
+
+  desc "suspend [NAME]", "Shutdown of the machine"
+  method_options :force => :boolean
+  def suspend(selection=nil)
+    Mccloud::Environment.new().load!().suspend(selection,options)
+  end
+
+  desc "flavors", "Lists all available flavors"
+  method_options :force => :boolean
+  def flavors()
+    Mccloud::Environment.new().load!().flavors()
+  end
+
+  #  desc "boot", "same a"
+  #  method_options :force => :boolean
+  #  def boot(selection=nil)
+  #    create_environment
+  #    @environment.boot(selection,options)
+  #  end
+
+  desc "loadbalance [NAME]", "Updates the server instances of the loadbalancer"
+  method_options :force => :boolean
+  def loadbalance(selection=nil)
+    Mccloud::Environment.new().load!().loadbalance(selection,options)
+  end
+
+  desc "sorry [NAME]", "Activates the sorry server instances of the loadbalancer"
+  method_options :force => :boolean
+  def sorry(selection=nil)
+    Mccloud::Environment.new().load!().sorry(selection,options)
+  end
+
+  desc "ips [NAME]", "Associates instances with Ips"
+  method_options :force => :boolean
+  def ips(selection=nil)
+    Mccloud::Environment.new().load!().ips(selection,options)
+  end
+
+  desc "destroy [NAME]", "Destroys the machine"
+  method_options :force => :boolean
+  def destroy(selection=nil)
+    Mccloud::Environment.new().load!().destroy(selection,options)
+  end
+
+  desc "reload [NAME]", "Reboots the machine"
+  method_options :force => :boolean
+  def reload(selection=nil?)
+    Mccloud::Environment.new().load!().reload(selection,options)
+  end
+
+  #  desc "command [NAME] [COMMAND]", "exec a command on a box"
+  #  method_options :parallel => :boolean
+  #  def command(selection=nil,command="who am i")
+  #    create_environment
+  #    @environment.command(selection,command,options)
+  #  end
+
+  desc "bootstrap [NAME]", "Executes the bootstrap sequence"
+  method_options :sudo => :boolean
+  def bootstrap(selection=nil)
+    Mccloud::Environment.new().load!().bootstrap(selection,options)
+  end
+
+  desc "package [NAME]", "Packages the current state of a machine into an image"
+  method_options :name => :string
+  method_options :description => :string
+  method_options :dontwait => :boolean
+  def package(selection=nil)
+    Mccloud::Environment.new().load!().package(selection,options)
+  end
+
+  desc "deregister [IMAGE-ID]", "Deregisters an image"
+  def deregister(imageId=nil)
+    Mccloud::Environment.new().load!().deregister(imageId,options)
+  end
+
+
+  #  desc "multi","multi"
+  #  method_options :verbose => :boolean
+  #  def multi(selection=nil,command="who am i")
+  #    create_environment
+  #    @environment.multi(selection,command,options)
+  #  end
+
+  desc "provision [NAME]", "Runs the provisioner the machine"
+  def provision(selection=nil)
+    Mccloud::Environment.new().load!().provision(selection,options)
+  end
+
+  desc "server", "Runs a server+ forwards network ports"
+  def server(selection=nil)
+    Mccloud::Environment.new().load!().server(selection,options)
+  end
+end
+
+puts
+80.times { |i| printf "*" } ; puts
+myversion="* Mccloud v#{Mccloud::VERSION} - alpha - use at your own risk"
+puts "#{myversion}"
+puts "- github : https://github.com/jedi4ever/mccloud"
+
+80.times { |i| printf "*" } ; puts
+puts
+
+
+MccloudCLI.start
+puts

data/doc/old-README.md

@@ -0,0 +1,81 @@
+# This needs to be completely rewritten for the new version!!!
+
+
+## Note:
+- This is a quick copy and paste job(weekend hacking), you should not consider it anything but experimental right now
+- But I wanted to share the idea already with others
+
+## DISCLAIMER:
+this is alpha sofware . Don't trust it:) And don't complain if it removes all your EC instances at once....
+
+## Kudos to great stuff
+- [Vagrant](http://www.vagrantup.com) is great for testing machines on your local machines
+- [Fog](https://github.com/geemus/fog) is a great fog library for managing cloud systems
+
+Without those two, this project would not be possible. Kudos to the authors!
+
+This project tries to combine both:
+- Because your local machine might outgrow your complexity your local machine can handle
+- use the same vagrantfile for local dev, and cloud devel
+
+## Some notes before you dive in
+
+- I could probably have integrated with vagrant code but this would have taken me longer to understand vagrant code
+- I didn't want the dependency on virtualbox
+- The machines it creates will have the prefix as defined in the Mccloudfile, so this should not pollute your stuff
+
+## Todo:
+
+- provision to other providers than ec2
+- try to stay fully compatible with Vagrantfile
+
+## How it will work/works
+
+### Create a config file for fog. Note that these are spaces in front and no tabs
+$ cat $HOME/.fog
+<pre>
+:default:
+  :aws_access_key_id: <your id here>
+  :aws_secret_access_key: <your acess key here>
+</pre>
+
+### Create a Mccloud project
+$ mccloud init
+
+This will create a Mccloudfile
+
+### Edit your Mccloud appropriate
+
+<pre>
+</pre>
+
+### Start your machines
+# If the machine does not yet exist, it will also run bootstrap
+$ mccloud up web
+
+### Check the status
+$ mccloud status
+
+### Bootstrap the machine
+$ mccloud bootstrap web
+
+### (interactive) Login into the machine
+$ mccloud ssh web
+
+### run a command on a machine
+$ mccloud command web "who am i"
+
+### Halt the machine
+$ mccloud halt web
+
+### Start the machine again
+$ mccloud up web
+
+### Provision the machine
+$ mccloud provision web
+
+### Port forwarding server
+$ mccloud server
+
+### Destroy the machine again
+$ mccloud destroy web

data/lib/mccloud/cli.rb

@@ -0,0 +1,55 @@
+require 'thor'
+
+module Mccloud
+  # Entrypoint for the Mccloud CLI. This class should never be
+  # initialized directly (like a typical Thor class). Instead,
+  # use {Environment#cli} to invoke the CLI.
+  #
+  # # Defining Custom CLI Commands
+  #
+  # If you're looking to define custom CLI commands, then look at
+  # one of the two following classes:
+  #
+  # * {Command::Base} - Implementing a single command such as `mccloud up`, e.g.
+  #   one without subcommands. Also take a look at {Command::NamedBase}.
+  # * {Command::GroupBase} - Implementing a command with subcommands, such as
+  #   `mccloud box`, which has the `list`, `add`, etc. subcommands.
+  #
+  # The above linked classes contain the main documentation for each
+  # type of command.
+  class CLI < Thor
+    # Registers the given class with the CLI so it can be accessed.
+    # The class must be a subclass of either {Command::Base} or {Command::GroupBase}.
+    # Don't call this method directly, instead call the {Command::Base.register}
+    # or {Command::GroupBase.register} methods.
+    #
+    # @param [Class] klass Command class
+    # @param [String] name Command name, accessed at `mccloud NAME`
+    # @param [String] usage Command usage, such as "mccloud NAME [--option]"
+    # @param [String] description Description of the command shown during the
+    #   command listing.
+    # @param [Hash] opts Other options (not gone into detail here, look at
+    #   the source instead).
+    def self.register(klass, name, usage, description, opts=nil)
+      opts ||= {}
+
+      if klass <= Command::GroupBase
+        # A subclass of GroupBase is a subcommand, since it contains
+        # many smaller commands within it.
+        desc usage, description, opts
+        subcommand name, klass
+      elsif klass <= Command::Base
+        # A subclass of Base is a single command, since it
+        # is invoked as a whole (as Thor::Group)
+        desc usage, description, opts
+        define_method(name) { |*args| invoke klass, args }
+      end
+
+      if opts[:alias]
+        # Alises are defined for this command, so properly alias the
+        # newly defined method/subcommand:
+        map opts[:alias] => name
+      end
+    end
+  end
+end #Mccloud

data/lib/mccloud/command/balance.rb

@@ -0,0 +1,21 @@
+module Mccloud
+  module Command
+    class BalanceCommand < Base
+
+      register "balance [LB-NAME]", "Balances loadbalancers"
+      argument :selection, :type => :string, :optional => true, :default => nil
+
+      def execute
+        env.load!
+        env.config.providers.each do |name,provider|
+          env.logger.debug("Asking provider #{name} to associate to #{selection}")
+          provider.on_selected_components("lb",selection) do |id,lb|
+            lb.associate(options)
+          end
+        end
+      end
+
+    end
+
+  end
+end

data/lib/mccloud/command/base.rb

@@ -0,0 +1,106 @@
+require 'thor/group'
+require 'thor/actions'
+
+module Mccloud
+  module Command
+    # A {Base} is the superclass for all commands which are single
+    # commands, e.g. `mccloud init`, `mccloud up`. Not commands like
+    # `mccloud box add`. For commands which have more subcommands, use
+    # a {GroupBase}.
+    #
+    # A {Base} is a subclass of `Thor::Group`, so view the documentation
+    # there on how to add arguments, descriptions etc. The important note
+    # about this is that when invoked, _all public methods_ will be called
+    # in the order they are defined. If you don't want a method called when
+    # the command is invoked, it must be made `protected` or `private`.
+    #
+    # The best way to get examples of how to create your own command is to
+    # view the various Mccloud commands, which are relatively simple, and
+    # can be found in the Mccloud source tree at `lib/mccloud/command/`.
+    #
+    # # Defining a New Command
+    #
+    # To define a new single command, create a new class which inherits
+    # from this class, then call {register} to register the command. That's
+    # it! When the command is invoked, _all public methods_ will be called.
+    # Below is an example `SayHello` class:
+    #
+    #     class SayHello < Mccloud::Command::Base
+    #       register "hello", "Says hello"
+    #
+    #       def hello
+    #         env.ui.info "Hello"
+    #       end
+    #     end
+    #
+    # In this case, the above class is invokable via `mccloud hello`. To give
+    # this a try, just copy and paste the above into a Mccloudfile somewhere.
+    # The command will be available for that project!
+    #
+    # Also note that the above example uses `env.ui` to output. It is recommended
+    # you use this instead of raw "puts" since it is configurable and provides
+    # additional functionality, such as colors and asking for user input. See
+    # the {UI} class for more information.
+    #
+    # ## Defining Command-line Options
+    #
+    # Most command line actions won't be as simple as `mccloud hello`, and will
+    # probably require parameters or switches. Luckily, Thor makes adding these
+    # easy:
+    #
+    #     class SayHello < Mccloud::Command::Base
+    #       register "hello", "Says hello"
+    #       argument :name, :type => :string
+    #
+    #       def hello
+    #         env.ui.info "Hello, #{name}"
+    #       end
+    #     end
+    #
+    # Then, the above can be invoked with `mccloud hello Mitchell` which would
+    # output "Hello, Mitchell." If instead you're looking for switches, such as
+    # "--name Mitchell", then take a look at `class_option`, an example of which
+    # can be found in the {PackageCommand}.
+    class Base < Thor::Group
+      include Thor::Actions
+      include Helpers
+
+      attr_reader :env
+
+      # Register the command with the main Mccloud CLI under the
+      # given name. The name will be used for accessing it from the CLI,
+      # so if you name it "lamp", then the command to invoke this
+      # will be `mccloud lamp`.
+      #
+      # The description is used when the help is listed, and is meant to be
+      # a brief (one sentence) description of what the command does.
+      #
+      # Some additional options may be passed in as the last parameter:
+      #
+      # * `:alias` - If given as an array or string, these will be aliases
+      #  for the same command. For example, `mccloud version` is also
+      #  `mccloud --version` and `mccloud -v`
+      #
+      # @param [String] usage
+      # @param [String] description
+      # @param [Hash] opts
+      def self.register(usage, description, opts=nil)
+        desc description
+        ::Mccloud::CLI.register(self, extract_name_from_usage(usage), usage, desc, opts)
+      end
+
+      def initialize(*args)
+        super
+        initialize_environment(*args)
+      end
+
+      protected
+
+      # Extracts the name of the command from a usage string. Example:
+      # `init [box_name] [box_url]` becomes just `init`.
+      def self.extract_name_from_usage(usage)
+        /^([-_a-zA-Z0-9]+)(\s+(.+?))?$/.match(usage).to_a[1]
+      end
+    end
+  end
+end

data/lib/mccloud/command/bootstrap.rb

@@ -1,31 +1,19 @@
-require 'pp'
 module Mccloud
   module Command
-    def bootstrap(selection=nil,command="who am i",options=nil)
-      
-      on_selected_machines(selection) do |id,vm|
-        puts "bootstrap #{selection} "
-        server=vm.instance
-        server.private_key_path=vm.private_key
-        server.username = vm.user
-        if server.state == "running"
-          puts "Uploading bootstrap code to machine #{vm.name}"
-          unless !File.exists?(vm.bootstrap)
-            server.scp(vm.bootstrap,"/tmp/bootstrap.sh")
-            puts "Enabling the bootstrap code to run"
-            result=server.ssh("chmod +x /tmp/bootstrap.sh")
-          else
-            puts "Error: bootstrap file #{vm.bootstrap} does not exist"
-            exit -1
-          end
-        else
-          puts "server is not running, so bootstrapping will do no good"
+    class BootstrapCommand < Base
+
+      argument :box_name, :type => :string, :optional => true, :default => nil
+      argument :command, :type => :string, :optional => true, :default => nil
+
+      register "bootstrap [NAME] [FILENAME]", "Executes the bootstrap sequence"
+
+      def execute
+        env.load!
+        env.config.providers.each do |name,provider|
+          env.logger.debug("Asking provider #{name} to reload box #{box_name}")
+          provider.bootstrap(box_name,command,options)
         end
-        #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,"sudo /tmp/bootstrap.sh")
       end
-      multi(selection,"/tmp/bootstrap.sh",options.merge({ "sudo" => true}))
     end
   end
 end

data/lib/mccloud/command/define.rb

@@ -0,0 +1,18 @@
+require 'fileutils'
+module Mccloud
+  module Command
+    class DefineCommand < Base
+
+      register "define NAME TEMPLATE-NAME", "Creates a new definition based on a tempate"
+      argument :name, :type => :string, :optional => false, :default => nil
+      argument :template, :type => :string, :optional => false, :default => nil
+
+      def execute
+        env.ui.info "Define #{name} with template #{template}"
+        env.config.definitions.define(name,template)
+      end
+
+    end
+
+  end
+end

data/lib/mccloud/command/destroy.rb

@@ -1,19 +1,18 @@
-require 'mccloud/util/iterator'
-
 module Mccloud
   module Command
-    def destroy(selection=nil,options=nil)
-      on_selected_machines(selection) do |id,vm|
-        unless vm.instance.nil? || vm.instance.state == "shutting-down" || vm.instance.state =="terminated"
-          puts "Destroying machine #{vm.name} (#{id})"
-          vm.instance.destroy
-          
-          vm.instance.wait_for {  print "."; STDOUT.flush; state=="terminated"}
-          puts
-        else
-          puts "Machine #{vm.name} is already terminated"        
+    class DestroyCommand < Base
+
+      argument :box_name, :type => :string, :optional => false, :default => nil
+
+      register "destroy [NAME]", "Destroys the machine"
+
+      def execute
+        env.load!
+        env.config.providers.each do |name,provider|
+          env.logger.debug("Asking provider #{name} to destroy box #{box_name}")
+          provider.destroy(box_name,options)
         end
       end
     end
   end
-end
+end