coral_vagrant 0.1.1

data/README.rdoc

@@ -0,0 +1,31 @@
+= coral_vagrant
+
+This library contains various commands and exposes a data model to Vagrant
+that allows for tightly integrated management of Virtual machines that are
+linked to remote servers.  
+
+This also allows for custom execution plans.
+
+Note:  This library is still very early in development!
+
+== Contributing to coral_vagrant
+ 
+* Check out the latest master to make sure the feature hasn't been implemented 
+  or the bug hasn't been fixed yet.
+* Check out the issue tracker to make sure someone already hasn't requested 
+  it and/or contributed it.
+* Fork the project.
+* Start a feature/bugfix branch.
+* Commit and push until you are happy with your contribution.
+* Make sure to add tests for it. This is important so I don't break it in a 
+  future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want 
+  to have your own version, or is otherwise necessary, that is fine, but 
+  please isolate to its own commit so I can cherry-pick around it.
+
+== Copyright
+
+Licensed under GPLv3.  See LICENSE.txt for further details.
+
+Copyright (c) 2013  Adrian Webb <adrian.webb@coraltech.net>
+Coral Technology Group LLC

data/Rakefile

@@ -0,0 +1,68 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+require 'rake'
+require 'rake/testtask'
+require 'rdoc/task'
+require 'jeweler'
+
+require './lib/coral_vagrant.rb'
+
+#-------------------------------------------------------------------------------
+# Dependencies
+
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+
+#-------------------------------------------------------------------------------
+# Gem specification
+
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name                  = "coral_vagrant"
+  gem.homepage              = "http://github.com/coraltech/ruby-coral_vagrant"
+  gem.rubyforge_project     = 'coral_vagrant'
+  gem.license               = "GPLv3"
+  gem.email                 = "adrian.webb@coraltech.net"
+  gem.authors               = ["Adrian Webb"]
+  gem.summary               = %Q{Provides a data model and various Coral commands for Vagrant}
+  gem.description           = File.read('README.rdoc')
+  gem.required_ruby_version = '>= 1.8.1'
+  gem.has_rdoc              = true
+  gem.rdoc_options << '--title' << 'Coral Vagrant library' <<
+                      '--main' << 'README.rdoc' <<
+                      '--line-numbers' 
+  
+  # Dependencies defined in Gemfile
+end
+
+Jeweler::RubygemsDotOrgTasks.new
+
+#-------------------------------------------------------------------------------
+# Testing
+
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+task :default => :test
+
+#-------------------------------------------------------------------------------
+# Documentation
+
+Rake::RDocTask.new do |rdoc|
+  version = Coral::Vagrant::VERSION
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = "coral_vagrant #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.1

data/Vagrantfile

@@ -0,0 +1,69 @@
+#
+# Configurable Vagrant server environment (development platform)
+#-------------------------------------------------------------------------------
+#
+# This Vagrantfile is designed to test server components
+#
+# => "puppet" directory should be a submodule with a bootstrap capable Puppet library.
+# => "config" directory should be a submodule with a JSON configuration repository.
+#
+
+require 'coral_vagrant'
+
+Vagrant::Config.run do |config|
+
+  #-----------------------------------------------------------------------------
+  # Server definitions (managed by ./config/cloud.json)
+
+  cloud = Coral.init_vagrant(File.dirname(__FILE__))
+  
+  cloud.servers.each do |server_name, server|  
+    config.vm.define server_name do |machine|    
+      # Basic server settings      
+      machine.vm.host_name = server.hostname
+            
+      machine.vm.box       = cloud.get('vm_box')
+      machine.vm.box_url   = cloud.get('vm_box_url')
+      
+      # Network interfaces      
+      if cloud.get('vm_network_bridged', false, :test)
+        machine.vm.network :bridged
+      else
+        machine.vm.network :hostonly, server.public_ip
+        
+        unless server.virtual_ip.empty?
+          machine.vm.network :hostonly, server.virtual_ip
+        end
+      end
+     
+      # Server NFS shares      
+      cloud.servers[server_name].shares.each do |name, share|
+        unless share.directory.empty? || share.remote_dir.empty?
+          machine.vm.share_folder name, share.remote_dir, share.directory, :nfs => true
+        end
+      end
+            
+      # Server settings      
+      vm_cpus   = cloud.search(server_name, 'vm_cpus', '1')
+      vm_memory = cloud.search(server_name, 'vm_memory', '512')
+      
+      machine.vm.customize [ "modifyvm", :id, "--cpus", vm_cpus, "--memory", vm_memory ]
+            
+      # Puppet configuration
+      puppet_manifest_path = cloud.get('puppet_manifest_path')
+      puppet_module_path   = [] 
+      cloud.get('puppet_module_path', [], :array).each do |module_path|
+        puppet_module_path << File.join(puppet_manifest_path, module_path)
+      end
+      
+      # Puppet provisioning      
+      machine.vm.provision :puppet do |puppet|
+        puppet.module_path    = puppet_module_path
+        puppet.manifests_path = puppet_manifest_path
+        puppet.manifest_file  = cloud.get('puppet_manifest_file')
+        puppet.options        = cloud.search(server_name, 'puppet_options')
+        puppet.facter         = cloud.search(server_name, 'facts')
+      end
+    end
+  end
+end

data/coral_vagrant.gemspec

@@ -0,0 +1,78 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = "coral_vagrant"
+  s.version = "0.1.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Adrian Webb"]
+  s.date = "2013-02-07"
+  s.description = "= coral_vagrant\n\nThis library contains various commands and exposes a data model to Vagrant\nthat allows for tightly integrated management of Virtual machines that are\nlinked to remote servers.  \n\nThis also allows for custom execution plans.\n\nNote:  This library is still very early in development!\n\n== Contributing to coral_vagrant\n \n* Check out the latest master to make sure the feature hasn't been implemented \n  or the bug hasn't been fixed yet.\n* Check out the issue tracker to make sure someone already hasn't requested \n  it and/or contributed it.\n* Fork the project.\n* Start a feature/bugfix branch.\n* Commit and push until you are happy with your contribution.\n* Make sure to add tests for it. This is important so I don't break it in a \n  future version unintentionally.\n* Please try not to mess with the Rakefile, version, or history. If you want \n  to have your own version, or is otherwise necessary, that is fine, but \n  please isolate to its own commit so I can cherry-pick around it.\n\n== Copyright\n\nLicensed under GPLv3.  See LICENSE.txt for further details.\n\nCopyright (c) 2013  Adrian Webb <adrian.webb@coraltech.net>\nCoral Technology Group LLC"
+  s.email = "adrian.webb@coraltech.net"
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+    "Gemfile",
+    "Gemfile.lock",
+    "LICENSE.txt",
+    "README.rdoc",
+    "Rakefile",
+    "VERSION",
+    "Vagrantfile",
+    "coral_vagrant.gemspec",
+    "lib/coral_vagrant.rb",
+    "lib/coral_vagrant/commands/coral_base.rb",
+    "lib/coral_vagrant/commands/coral_init.rb",
+    "lib/coral_vagrant/commands/coral_push.rb",
+    "lib/coral_vagrant/commands/coral_run.rb",
+    "lib/coral_vagrant/commands/coral_update.rb"
+  ]
+  s.homepage = "http://github.com/coraltech/ruby-coral_vagrant"
+  s.licenses = ["GPLv3"]
+  s.rdoc_options = ["--title", "Coral Vagrant library", "--main", "README.rdoc", "--line-numbers"]
+  s.require_paths = ["lib"]
+  s.required_ruby_version = Gem::Requirement.new(">= 1.8.1")
+  s.rubyforge_project = "coral_vagrant"
+  s.rubygems_version = "1.8.15"
+  s.summary = "Provides a data model and various Coral commands for Vagrant"
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<vagrant>, ["~> 1.0"])
+      s.add_runtime_dependency(%q<coral_plan>, ["~> 0.1"])
+      s.add_runtime_dependency(%q<coral_cloud>, ["~> 0.1"])
+      s.add_development_dependency(%q<bundler>, ["~> 1.2"])
+      s.add_development_dependency(%q<jeweler>, ["~> 1.8"])
+      s.add_development_dependency(%q<rspec>, ["~> 2.10"])
+      s.add_development_dependency(%q<rdoc>, ["~> 3.12"])
+      s.add_development_dependency(%q<yard>, ["~> 0.8"])
+    else
+      s.add_dependency(%q<vagrant>, ["~> 1.0"])
+      s.add_dependency(%q<coral_plan>, ["~> 0.1"])
+      s.add_dependency(%q<coral_cloud>, ["~> 0.1"])
+      s.add_dependency(%q<bundler>, ["~> 1.2"])
+      s.add_dependency(%q<jeweler>, ["~> 1.8"])
+      s.add_dependency(%q<rspec>, ["~> 2.10"])
+      s.add_dependency(%q<rdoc>, ["~> 3.12"])
+      s.add_dependency(%q<yard>, ["~> 0.8"])
+    end
+  else
+    s.add_dependency(%q<vagrant>, ["~> 1.0"])
+    s.add_dependency(%q<coral_plan>, ["~> 0.1"])
+    s.add_dependency(%q<coral_cloud>, ["~> 0.1"])
+    s.add_dependency(%q<bundler>, ["~> 1.2"])
+    s.add_dependency(%q<jeweler>, ["~> 1.8"])
+    s.add_dependency(%q<rspec>, ["~> 2.10"])
+    s.add_dependency(%q<rdoc>, ["~> 3.12"])
+    s.add_dependency(%q<yard>, ["~> 0.8"])
+  end
+end
+

data/lib/coral_vagrant/commands/coral_base.rb

@@ -0,0 +1,79 @@
+
+module Vagrant
+module Command
+module Coral
+class Base < Base
+    
+  #-----------------------------------------------------------------------------
+  # Constructor / Destructor
+
+  def initialize(argv, env)
+    super
+
+    @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
+
+      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
+
+    # 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}")
+
+    # Initialize and execute the command class
+    command_class.new(@sub_args, @env).execute
+  end
+end
+end
+end
+end
+
+#-------------------------------------------------------------------------------
+
+Vagrant.commands.register(:coral) { Vagrant::Command::Coral::Base }
+

data/lib/coral_vagrant/commands/coral_init.rb

@@ -0,0 +1,78 @@
+
+module Vagrant
+module Command
+module Coral
+class Init < Base
+      
+  #-----------------------------------------------------------------------------
+  # Execution
+  
+  def execute
+    options = {}
+    success = true
+        
+    opts = OptionParser.new do |opts|
+      opts.banner = "Usage: vagrant coral init [server-name]... [-h] ..."
+      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") do |m|
+        options[:min] = m
+      end     
+          
+      options[:tries] = 5
+      opts.on("-t", "--tries TRIES", "Number of provision attempts before stopping with an error") 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_DIRS,...'", "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 if ! servers
+        
+    with_target_vms(servers) do |vm|
+      @env.ui.info("Starting initialization run for: #{vm.name}")
+          
+      server = Coral::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,84 @@
+
+module Vagrant
+module Command
+module Coral
+class Push < Base
+      
+  #-----------------------------------------------------------------------------
+  # Execution
+
+  def execute
+    options = {}
+    success = true
+        
+    opts = OptionParser.new do |opts|
+      opts.banner = "Usage: vagrant coral push [server-name]... [-h] ..."
+      opts.separator ""
+       
+      opts.on("-c", "--commit", "Commit any uncommitted changes before pushing to remotes") do |c|
+        options[:commit] = c
+      end
+        
+      opts.on("-e", "--allow_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_DIRS,...", "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 if ! remotes
+        
+    if remotes.empty?
+      remotes = [ 'all' ]
+    end
+                
+    remotes.each do |remote_name|
+      @env.ui.info("Starting push for: #{remote_name}")
+          
+      server = Coral::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_run.rb

@@ -0,0 +1,53 @@
+
+module Vagrant
+module Command
+module Coral
+class Run < Base
+      
+  #-----------------------------------------------------------------------------
+  # Execution
+  
+  def execute
+    options = {}
+    success = true
+        
+    opts = OptionParser.new do |opts|
+      opts.banner = "Usage: vagrant cloud run [plan-name]... [-h] ..."
+      opts.separator ""          
+          
+      options[:repo] = 'config'        
+      opts.on("-r", "--repo REPO_DIR", "Local directories of repositories (relative to the Vagrantfile root)") do |r|
+        options[:repo] = r
+      end     
+          
+      options[:directory] = 'plans'
+      opts.on("-d", "--directory DIR", "Local directory that contains the plan(s) being executed") do |d|
+        options[:directory] = d
+      end         
+    end
+        
+    #---
+        
+    plans = parse_options(opts)
+    return if ! 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 => "#{options[:directory]}/#{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_update.rb

@@ -0,0 +1,61 @@
+
+module Vagrant
+module Command
+module Coral
+class Update < Base
+      
+  #-----------------------------------------------------------------------------
+  # Execution
+  
+  def execute
+    options = {}
+    success = true
+        
+    opts = OptionParser.new do |opts|
+      opts.banner = "Usage: vagrant coral update [server-name]... [-h] ..."
+      opts.separator ""
+          
+      options[:min] = 1
+      opts.on("-m", "--min TRIES", "Minimum number of provision runs") do |m|
+        options[:min] = m
+      end
+          
+      options[:tries] = 5        
+      opts.on("-t", "--tries TRIES", "Number of provision attempts before stopping with an error.") 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_DIRS,...'", "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 if ! servers       
+        
+    with_target_vms(servers) do |vm|
+      @env.ui.info("Starting update run for: #{vm.name}")
+          
+      success = Coral::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.rb

@@ -0,0 +1,74 @@
+
+home = File.dirname(__FILE__)
+
+$:.unshift(home) unless
+  $:.include?(home) || $:.include?(File.expand_path(home))
+  
+#-------------------------------------------------------------------------------
+  
+require 'rubygems'
+require 'optparse'
+require 'vagrant'
+require 'coral_cloud'
+require 'coral_plan'
+
+#---
+
+# Include Vagrant commands
+[ :coral_base, 
+  :coral_init, 
+  :coral_update, 
+  :coral_push, 
+  :coral_run, 
+].each do |name| 
+  require File.join('coral_vagrant', 'commands', name.to_s + '.rb') 
+end
+
+#*******************************************************************************
+# Coral Vagrant Library
+#
+# This provides a data model and commands that interface with Vagrant.
+#
+# Author::    Adrian Webb (mailto:adrian.webb@coraltech.net)
+# License::   GPLv3
+module Coral
+    
+  #-----------------------------------------------------------------------------
+  # Constructor / Destructor
+  
+  def self.init_vagrant(directory, submodule = 'config', config_file = 'cloud.json')
+    return Coral::Vagrant.init(directory, submodule, config_file)
+  end
+      
+  #-----------------------------------------------------------------------------
+  # Accessors / Modifiers
+  
+  def self.vagrant
+    return Coral::Vagrant.get
+  end 
+
+#*******************************************************************************
+
+module Vagrant
+  
+  VERSION = File.read(File.join(File.dirname(__FILE__), '..', 'VERSION'))
+  
+  #-----------------------------------------------------------------------------
+  # Constructor / Destructor
+
+  def init(directory, submodule = 'config', config_file = 'cloud.json')
+    return Coral.create_cloud(:vagrant, {
+      :directory   => directory, 
+      :submodule   => submodule,
+      :config_file => config_file,
+    })
+  end
+  
+  #-----------------------------------------------------------------------------
+  # Accessors / Modifiers
+  
+  def self.get
+    return Coral.cloud(:vagrant)  
+  end 
+end
+end