coral_vagrant 0.2.1 → 0.2.2

data/lib/coral_vagrant/commands/coral/init.rb

@@ -0,0 +1,77 @@
+module Coral
+  module Vagrant
+    module SubCommand
+      class CoralInit < ::Vagrant.plugin('2', :command)
+
+        #-----------------------------------------------------------------------
+        # Execution
+        
+        def execute
+          options = {}
+          success = true
+
+          opts = OptionParser.new do |opts|
+            opts.banner = 'Usage: coral init -hdf [ {server_name} ... ]'
+            opts.separator ''
+
+            opts.on('-d', '--destroy', 'Remove existing servers and start from scratch') do |d|
+              options[:destroy] = d
+            end
+
+            opts.on('-f', '--force', 'Destroy without confirmation') do |f|
+              options[:force] = f
+            end
+
+            #---
+
+            options[:min] = 1
+            opts.on('-m', '--min TRIES', 'Minimum number of provision runs (1)') do |m|
+              options[:min] = m
+            end
+
+            options[:tries] = 1
+            opts.on('-t', '--tries TRIES', 'Number of provision attempts before stopping with an error (1)') do |t|
+              options[:tries] = t
+            end
+
+            options[:exit] = ''
+            opts.on('-e', '--exit CONDITIONS', 'Conditions on which to exit in the format separated by a comma: "User[git]:ensure:created"') do |e|
+              options[:exit] = e
+            end
+
+            options[:repos] = ''
+            opts.on('-r', '--repos REPO_DIR,...', 'Local directories of repositories to syncronize remotes relative to the Vagrantfile root') do |r|
+              options[:repos] = r
+            end
+          end
+
+          options[:min]  = 1
+          options[:auth] = true
+
+          #---
+
+          servers = parse_options(opts)
+          return unless servers
+
+          with_target_vms(servers) do |vm|
+            @env.ui.info("Starting initialization run for: #{vm.name}")
+
+            server = Cloud::Server.new({
+              :cloud   => Coral.vagrant,
+              :machine => vm,
+              :logger  => @logger,
+              :ui      => @env.ui,
+            })
+
+            if options[:destroy]
+            success = server.destroy(options) if success
+            end
+            success = server.start(options) if success
+            success = server.update(options) if success
+          end
+          exit success ? 0 : 1
+        end
+      end
+    end
+  end
+end

data/lib/coral_vagrant/commands/coral/push.rb

@@ -0,0 +1,83 @@
+module Coral
+  module Vagrant
+    module SubCommand
+      class CoralPush < ::Vagrant.plugin('2', :command)
+
+        #-----------------------------------------------------------------------
+        # Execution
+        
+        def execute
+          options = {}
+          success = true
+
+          opts = OptionParser.new do |opts|
+            opts.banner = 'Usage: coral push -hcet --repos={repository_name},... [ {server_name} ... ]'
+            opts.separator ''
+
+            opts.on('-c', '--commit', 'Commit any uncommitted changes before pushing to remotes') do |c|
+              options[:commit] = c
+            end
+
+            opts.on('-e', '--empty', 'Allow commits with no changes') do |e|
+              options[:allow_empty] = e
+            end
+
+            opts.on('-t', '--tags', 'Push all local tags with selected branch') do |t|
+              options[:tags] = t
+            end
+
+            #---
+
+            options[:message] = ''
+            opts.on('-m', '--message MESSAGE', 'Commit message') do |m|
+              options[:message] = m
+            end
+
+            options[:author] = ''
+            opts.on('-a', '--author AUTHOR', 'Author of the changes being committed if different from the committer') do |a|
+              options[:author] = a
+            end
+
+            options[:branch] = ''
+            opts.on('-b', '--branch BRANCH', 'Local branch of the remotes to push') do |b|
+              options[:branch] = b
+            end
+
+            options[:repos] = ''
+            opts.on('-r', '--repos REPO_DIR,...', 'Local directories of repositories to push relative to the Vagrantfile root') do |r|
+              options[:repos] = r
+            end
+          end
+
+          options[:auth] = true
+
+          #---
+
+          remotes = parse_options(opts)
+          return unless remotes
+
+          if remotes.empty?
+            remotes = [ 'all' ]
+          end
+
+          remotes.each do |remote_name|
+            @env.ui.info("Starting push for: #{remote_name}")
+
+            server = Cloud::Server.new({
+              :cloud   => Coral.vagrant,
+              :machine => remote_name,
+              :logger  => @logger,
+              :ui      => @env.ui,
+            })
+
+            if options[:commit]
+            success = server.commit(options) if success
+            end
+            success = server.push(options) if success
+          end
+          exit success ? 0 : 1
+        end
+      end
+    end
+  end
+end

data/lib/coral_vagrant/commands/coral/rm.rb

@@ -0,0 +1,37 @@
+module Coral
+  module Vagrant
+    module SubCommand
+      class CoralRemove < ::Vagrant.plugin('2', :command)
+
+        #-----------------------------------------------------------------------
+        # Execution
+        
+        def execute
+          options = {}
+          success = true
+
+          opts = OptionParser.new do |opts|
+            opts.banner = 'Usage: coral rm -h {name} [ {type} ]'
+            opts.separator ''
+
+          end
+
+          #---
+
+          args = parse_options(opts)
+          return unless args
+
+          raise ::Vagrant::Errors::CLIInvalidUsage, :help => opts.help.chomp if args.length < 1
+
+          project_name = args[0]
+          project_type = ( args.size < 2 ? 'module' : args[1] )
+
+          #---------
+          # Start
+
+          exit success ? 0 : 1
+        end
+      end
+    end
+  end
+end

data/lib/coral_vagrant/commands/coral/run.rb

@@ -0,0 +1,52 @@
+module Coral
+  module Vagrant
+    module SubCommand
+      class CoralRun < ::Vagrant.plugin('2', :command)
+
+        #-----------------------------------------------------------------------
+        # Execution
+        
+        def execute
+          options = {}
+          success = true
+
+          opts = OptionParser.new do |opts|
+            opts.banner = 'Usage: coral run --dir={plan_dir} {plan_name} ...'
+            opts.separator ''
+
+            options[:repo] = '.'
+            opts.on('-r', '--repo REPO_DIR', 'Local directory of repository relative to the Vagrantfile root (.)') do |r|
+              options[:repo] = r
+            end
+
+            options[:directory] = 'plans'
+            opts.on('-d', '--dir DIRECTORY', 'Local directory that contains the plan(s) being executed (plans)') do |d|
+              options[:directory] = d
+            end
+          end
+
+          #---
+
+          plans = parse_options(opts)
+          return unless plans
+
+          plans.each do |plan_name|
+            @logger.debug("Running plan: #{plan_name}")
+
+            success = Coral.create_plan(plan_name, {
+              :home        => Coral.vagrant,
+              :submodule   => options[:repo],
+              :config_file => File.join([ options[:directory].to_s, "#{plan_name}.json" ]),
+              :logger      => @logger,
+              :ui          => @env.ui,
+            }).run(options)
+
+            break unless success
+          end
+
+          exit success ? 0 : 1
+        end
+      end
+    end
+  end
+end

data/lib/coral_vagrant/commands/coral/send.rb

@@ -0,0 +1,42 @@
+module Coral
+  module Vagrant
+    module SubCommand
+      class CoralSend < ::Vagrant.plugin('2', :command)
+      
+        #-----------------------------------------------------------------------
+        # Execution
+  
+        def execute
+          options = {}
+          success = true
+        
+          opts = OptionParser.new do |opts|
+            opts.banner = 'Usage: coral send {provider} ...'
+            opts.separator ''
+          
+            options[:tries] = 1       
+            opts.on('-t', '--tries TRIES', 'Number of times to try sending to provider before stopping with an error (1)') do |t|
+              options[:tries] = t
+            end
+          end
+        
+          options[:auth] = true
+
+          #---
+        
+          providers = parse_options(opts)
+          return unless providers
+          
+          raise ::Vagrant::Errors::CLIInvalidUsage, :help => opts.help.chomp if providers.length < 1      
+
+          #---------
+          # Start
+        
+          
+          
+          exit success ? 0 : 1
+        end
+      end
+    end
+  end
+end

data/lib/coral_vagrant/commands/coral/update.rb

@@ -0,0 +1,60 @@
+module Coral
+  module Vagrant
+    module SubCommand
+      class CoralUpdate < ::Vagrant.plugin('2', :command)
+      
+        #-----------------------------------------------------------------------
+        # Execution
+  
+        def execute
+          options = {}
+          success = true
+        
+          opts = OptionParser.new do |opts|
+            opts.banner = 'Usage: coral init -h [ {server_name} ... ]'
+            opts.separator ''
+          
+            options[:min] = 1
+            opts.on('-m', '--min TRIES', 'Minimum number of provision runs (1)') do |m|
+              options[:min] = m
+            end
+          
+            options[:tries] = 1       
+            opts.on('-t', '--tries TRIES', 'Number of provision attempts before stopping with an error (1)') do |t|
+              options[:tries] = t
+            end
+          
+            options[:exit] = ''
+            opts.on('-e', '--exit CONDITIONS', 'Conditions on which to exit in the format separated by comma: "User[git]:ensure:created"') do |e|
+              options[:exit] = e
+            end
+        
+            options[:repos] = ''        
+            opts.on('-r', '--repos REPO_DIR,...', 'Local directories of repositories to push relative to the Vagrantfile root') do |r|
+              options[:repos] = r
+            end
+          end
+        
+          options[:auth] = true
+
+          #---
+        
+          servers = parse_options(opts)
+          return unless servers       
+        
+          with_target_vms(servers) do |vm|
+            @env.ui.info("Starting update run for: #{vm.name}")
+          
+            success = Cloud::Server.new({
+              :cloud   => Coral.vagrant,
+              :machine => vm,
+              :logger  => @logger,
+              :ui      => @env.ui,
+            }).update(options) if success
+          end        
+          exit success ? 0 : 1
+        end
+      end
+    end
+  end
+end

data/lib/coral_vagrant/commands/coral_base.rb

@@ -1,79 +1,166 @@
-
-module Vagrant
-module Command
 module Coral
-class Base < Base
-    
-  #-----------------------------------------------------------------------------
-  # Constructor / Destructor
+  module Vagrant
+    module Command
+      class CoralBase < ::Vagrant.plugin("2", :command)
 
-  def initialize(argv, env)
-    super
+        #-----------------------------------------------------------------------------
+        # Constructor / Destructor
+        
+        def initialize(argv, env)
+          super
 
-    @main_args, @sub_command, @sub_args = split_main_and_subcommand(argv)
+          @main_args, @sub_command, @sub_args = split_main_and_subcommand(argv)
 
-    @subcommands = Registry.new
-    @subcommands.register(:init) { Vagrant::Command::Coral::Init }
-    @subcommands.register(:update) { Vagrant::Command::Coral::Update }
-    @subcommands.register(:push) { Vagrant::Command::Coral::Push }
-    @subcommands.register(:run) { Vagrant::Command::Coral::Run }
-  end
-    
-  #-----------------------------------------------------------------------------
-  # Help
-
-  def help
-    opts = OptionParser.new do |opts|
-      opts.banner = "Usage: vagrant coral <command> [<args>]"
-      opts.separator ""
-      opts.separator "Available subcommands:"
-
-      # Add the available subcommands as separators in order to print them
-      # out as well.
-      keys = []
-      @subcommands.each { |key, value| keys << key.to_s }
-
-      keys.sort.each do |key|
-        opts.separator "     #{key}"
-      end
+          @subcommands = ::Vagrant::Registry.new
 
-      opts.separator ""
-      opts.separator "For help on any individual command run `vagrant coral COMMAND -h`"
-    end
+          #------------
+          # Builders
 
-    @env.ui.info(opts.help, :prefix => false)
-  end
-      
-  #-----------------------------------------------------------------------------
-  # Execution
-
-  def execute
-    if @main_args.include?("-h") || @main_args.include?("--help")
-      # Print the help for all the cluster commands.
-      return help
-    end
+          #
+          # coral create --repo={cluster_repository} [ {project_path} ]
+          #
+          # {cluster_repository} -> Defaults to the coral cluster core
+          # {project_path}       -> Defaults to the current directory (must be empty)
+          #
+          # * calls: coral init
+          #
+          @subcommands.register(:create) { Coral::Vagrant::SubCommand::CoralCreate }
 
-    # If we reached this far then we must have a subcommand. If not,
-    # then we also just print the help and exit.
-    command_class = @subcommands.get(@sub_command.to_sym) if @sub_command
-        
-    if ! command_class && @sub_command
-      command_class = @subcommands.get(:run)
-      @sub_args.unshift(@sub_command) 
-    end
-        
-    return help if !command_class || !@sub_command
-    @logger.debug("Invoking command class: #{command_class} #{@sub_args.inspect}")
+          #
+          # coral add --repo={repository} {name} [ {type} ]
+          #
+          # {name}       -> Name of the project (required)
+          # {type}       -> Defaults to module (can be: cluster, profile, module)
+          # {repository} -> Defaults to a new template repository of {type}
+          #
+          @subcommands.register(:add) { Coral::Vagrant::SubCommand::CoralAdd }
 
-    # Initialize and execute the command class
-    command_class.new(@sub_args, @env).execute
-  end
-end
-end
-end
-end
+          #
+          # coral rm {name} [ {type} ]
+          #
+          # {name}       -> Name of the project (required)
+          # {type}       -> Defaults to module (can be: cluster, profile, module)
+          #
+          @subcommands.register(:rm) { Coral::Vagrant::SubCommand::CoralRemove }
+
+          #------------------------------
+          # Configuration / Deployment
+
+          #
+          # coral config --dir={config_dir} {config_name} [ {value} ]
+          #
+          # {config_name} -> Dot separated configuration name (dot = directory entry)
+          # {value}       -> Configuration value (if we are setting the configuration)
+          # {config_dir}  -> Root directory of configuration files (default: config)
+          #
+          @subcommands.register(:config) { Coral::Vagrant::SubCommand::CoralConfig }
+
+          #
+          # coral push --repos={repository_name},... [ {server_name} ... ]
+          #
+          # {server_name}     -> Server name of a local or remote server to push attached repositories to
+          # {repository_name} -> Local repository name for a local/remote repository relationship
+          #
+          @subcommands.register(:push) { Coral::Vagrant::SubCommand::CoralPush }
+
+          #
+          # coral send {provider} ...
+          #
+          # {provider} -> Remote cloud provider on which to send and initialize the coral cluster
+          #
+          # * calls: coral init
+          #          coral image
+          #
+          @subcommands.register(:send) { Coral::Vagrant::SubCommand::CoralSend }
 
-#-------------------------------------------------------------------------------
+          #
+          # coral image --servers={server_name},... {provider} ...
+          #
+          # {provider}    -> Remote cloud provider on which to create the image
+          # {server_name} -> Server name of a cluster server to create an image of
+          #
+          @subcommands.register(:image) { Coral::Vagrant::SubCommand::CoralImage }
 
-Vagrant.commands.register(:coral) { Vagrant::Command::Coral::Base }
+          #--------------
+          # Management
 
+          #
+          # coral init [ {server_name} ... ]
+          #
+          # {server_name} -> Server name of a cluster server to initialize
+          #
+          @subcommands.register(:init) { Coral::Vagrant::SubCommand::CoralInit }
+
+          #
+          # coral update [ {server_name} ... ]
+          #
+          # {server_name} -> Server name of a cluster server to update
+          #
+          @subcommands.register(:update) { Coral::Vagrant::SubCommand::CoralUpdate }
+
+          #
+          # coral run --dir={plan_dir} {plan_name} ...
+          #
+          # {plan_name} -> Name of JSON based execution plan to run
+          # {plan_dir}  -> Root directory of exexution plan files (default: config/plans)
+          #
+          # * could call anything
+          #
+          @subcommands.register(:run) { Coral::Vagrant::SubCommand::CoralRun }
+        end
+
+        #-----------------------------------------------------------------------------
+        # Help
+
+        def help
+          opts = OptionParser.new do |opts|
+            opts.banner = 'Usage: vagrant coral <command> [<args>]'
+            opts.separator ''
+            opts.separator 'Available subcommands:'
+
+            # Add the available subcommands as separators in order to print them
+            # out as well.
+            keys = []
+            @subcommands.each { |key, value| keys << key.to_s }
+
+            keys.sort.each do |key|
+              opts.separator "     #{key}"
+            end
+
+            opts.separator ''
+            opts.separator 'For help on any individual command run `vagrant coral COMMAND -h`'
+          end
+
+          @env.ui.info(opts.help, :prefix => false)
+        end
+
+        #-----------------------------------------------------------------------------
+        # Execution
+
+        def execute
+          if @main_args.include?('-h') || @main_args.include?('--help')
+            # Print the help for all the cluster commands.
+            return help
+          end
+
+          # Fetch our command class if we have a subcommand.
+          command_class = @subcommands.get(@sub_command.to_sym) if @sub_command
+
+          # If there is no class mapping, we try running the subcommand as an
+          # execution plan.
+          if !command_class && @sub_command
+            command_class = @subcommands.get(:run)
+            @sub_args.unshift(@sub_command)
+          end
+          # If all else fails print the help and exit.
+          return help if !command_class || !@sub_command
+
+          @logger.debug("Invoking command class: #{command_class} #{@sub_args.inspect}")
+
+          # Initialize and execute the command class
+          command_class.new(@sub_args, @env).execute
+        end
+      end
+    end
+  end
+end