corl 0.4.15 → 0.4.16

data/lib/CORL/machine/vagrant.rb

@@ -0,0 +1,358 @@
+
+module CORL
+module Machine
+class Vagrant < CORL.plugin_class(:machine)
+  
+  @@lock = Mutex.new
+    
+  #-----------------------------------------------------------------------------
+  # Checks
+  
+  def created?
+    server && state != :not_created
+  end
+  
+  #---
+  
+  def running?
+    server && state == :running
+  end
+   
+  #-----------------------------------------------------------------------------
+  # Property accessors / modifiers
+  
+  def set_command
+    @command = nil
+    
+    begin
+      # Ensure we are running within Vagrant from the corl base command
+      require 'vagrant'
+      
+      logger.info("Setting up Vagrant for machine")
+      @command = CORL::Vagrant.command 
+      
+    rescue LoadError
+    end
+  end
+  protected :set_command
+  
+  #---
+  
+  def command
+    set_command unless @command
+    @command
+  end
+  
+  #---
+  
+  def env
+    return command.env if command
+    nil
+  end
+  
+  #---
+  
+  def server=id
+    @server = nil
+    
+    if id.is_a?(String)
+      @server = new_machine(id)
+    elsif ! id.nil?
+      @server = id
+    end
+  end
+  
+  def server
+    command
+    load unless @server
+    @server
+  end
+  
+  #---
+  
+  def state
+    return server.state.id if server
+    :not_loaded
+  end
+  
+  #---
+    
+  def machine_types
+    [ :virtualbox, :vmware_fusion, :hyperv ]
+  end
+        
+  #-----------------------------------------------------------------------------
+  # Management
+
+  def load
+    super do
+      myself.server = plugin_name if command && plugin_name
+      ! plugin_name && @server.nil? ? false : true
+    end    
+  end
+  
+  #---
+  
+  def create(options = {})
+    super do |config|
+      start_machine(config)
+    end
+  end
+  
+  #---
+  
+  def download(remote_path, local_path, options = {})
+    super do |config, success|
+      begin
+        server.communicate.tap do |comm|
+          comm.download(remote_path, local_path)  
+        end
+        success = true
+          
+      rescue Exception => error
+        ui.error(error.message)
+        success = false
+      end
+      success
+    end  
+  end
+  
+  #---
+  
+  def upload(local_path, remote_path, options = {})
+    super do |config, success|
+      begin
+        server.communicate.tap do |comm|
+          comm.upload(local_path, remote_path)  
+        end
+        success = true
+          
+      rescue Exception => error
+        ui.error(error.message)
+        success = false
+      end
+      success
+    end  
+  end
+  
+  #---
+  
+  def exec(commands, options = {})
+    super do |config, results|
+      codes :vagrant_exec_failed
+        
+      begin
+        server.communicate.tap do |comm|            
+          commands.each do |command|
+            as_admin = command.match(/^sudo\s+/) ? true : false
+            result   = Util::Shell::Result.new(command.gsub(/^sudo\s+/, '').strip)
+            
+            result.status = comm.execute(result.command, { :sudo => as_admin }) do |type, data|
+              case type
+              when :stdout
+                result.append_output(data)
+                yield(:output, result.command, data) if block_given?      
+              when :stderr
+                result.append_errors(data)
+                yield(:error, result.command, data) if block_given?  
+              end  
+            end
+            results << result
+          end
+        end
+          
+      rescue Exception => error
+        ui.error(error.message)
+        results << Util::Shell::Result.new(command, code.vagrant_exec_failed)
+      end      
+      results
+    end    
+  end
+  
+  #---
+  
+  def terminal(user, options = {})
+    super do |config|
+      run(:ssh, { :ssh_opts => config.export }) 
+    end
+  end
+  
+  #---
+  
+  def reload(options = {})
+    super do |config|
+      run(:reload, config)
+    end
+  end
+
+  #---
+ 
+  def create_image(options = {})
+    super do |config|
+      stop = config.delete(:stop, false)
+      
+      # TODO: Decide how to handle versions??  
+      # Timestamps stink since these things are huge (>600MB)
+      box_name = sprintf("%s", node.id).gsub(/\s+/, '-')
+      box_path = File.join(node.network.directory, 'boxes', "#{box_name}.box")
+      box_url  = "file://#{box_path}"
+      FileUtils.mkdir_p(File.dirname(box_path))
+      FileUtils.rm_f(box_path)
+      
+      begin
+        success = run(:package, config.defaults({ 'package.output' => box_path }), false)
+      
+        node.set_cache_setting(:box, box_name)
+        node.set_cache_setting(:box_url, box_url)
+        
+        if success    
+          env.action_runner.run(::Vagrant::Action.action_box_add, {
+            :box_name  => box_name,
+            :box_url   => box_url,          
+            :box_clean => false,
+            :box_force => true,
+            :ui        => ::Vagrant::UI::Prefixed.new(env.ui, "box")
+          })
+          load
+        end
+        
+      rescue Exception => error
+        ui.error(error.message)
+        success = false
+      end
+      
+      success = run(:up, config) if success && ! stop
+      success
+    end
+  end
+  
+  #---
+  
+  def stop(options = {})
+    super do |config|
+      create_image(config.import({ :stop => true }))
+    end
+  end
+  
+  #---
+  
+  def start(options = {})
+    super do |config|
+      start_machine(config)  
+    end
+  end
+ 
+  #---
+
+  def destroy(options = {})
+    super do |config|
+      # We should handle prompting internally to keep it consistent
+      success = run(:destroy, config.defaults({ :force_confirm_destroy => true }))
+      
+      if success
+        box_name = sprintf("%s", node.id).gsub(/\s+/, '-')
+        found    = false
+        
+        # TODO: Figure out box versions.
+        
+        env.boxes.all.each do |info|
+          registered_box_name     = info[0]
+          registered_box_version  = info[1]
+          registered_box_provider = info[2]
+          
+          if box_name == registered_box_name
+            found = true
+            break
+          end
+        end        
+        
+        if found
+          env.action_runner.run(::Vagrant::Action.action_box_remove, {
+            :box_name     => box_name,
+            :box_provider => node.machine_type
+          })
+          
+          box_name = sprintf("%s", node.id).gsub(/\s+/, '-')
+          box_path = File.join(node.network.directory, 'boxes', "#{box_name}.box")
+          Util::Disk.delete(box_path)
+        end
+      end
+      success
+    end
+  end
+  
+  #-----------------------------------------------------------------------------
+  # Utilities
+  
+  def refresh_config
+    if env
+      @@lock.synchronize do
+        begin
+          CORL::Vagrant::Config.network = node.network
+          env.vagrantfile.reload
+        ensure
+          CORL::Vagrant::Config.network = nil
+        end
+      end
+    end
+  end
+  protected :refresh_config
+  
+  #---
+  
+  def new_machine(id)
+    server = nil
+    if command && ! id.empty?
+      refresh_config
+      if env.vagrantfile.machine_names.include?(id.to_sym)        
+        server = command.vm_machine(id.to_sym, node.machine_type, true)
+      end
+    end
+    server
+  end
+  protected :new_machine
+  
+  #---
+  
+  def start_machine(options)
+    success = false
+    
+    if server
+      load
+      success = run(:up, options)
+        
+      # Make sure provisioner changes (key changes) are accounted for
+      # TODO: Is there a better way?
+      load if success
+    end
+    success  
+  end
+  protected :start_machine
+  
+  #---
+  
+  def run(action, options = {}, symbolize_keys = true)
+    config = Config.ensure(options)
+    
+    if server
+      logger.debug("Running Vagrant action #{action} on machine #{node.id}")
+    
+      success = true
+      begin
+        params = config.export
+        params = string_map(params) unless symbolize_keys
+        
+        server.send(:action, action.to_sym, params)
+        
+      rescue Exception => error
+        ui.error(error)
+        ui.error(Util::Data.to_yaml(error.backtrace))
+        success = false
+      end      
+    end
+    success
+  end
+  protected :run
+end
+end
+end

data/lib/CORL/node/local.rb

@@ -7,9 +7,8 @@ class Local < CORL.plugin_class(:node)
   # Node plugin interface
    
   def normalize(reload)
-    super do
-      myself.machine = create_machine(:machine, :physical, machine_config)
-    end
+    super
+    myself.machine = create_machine(:machine, :physical, machine_config)
   end
        
   #-----------------------------------------------------------------------------

data/lib/CORL/node/vagrant.rb

@@ -0,0 +1,238 @@
+
+module CORL
+module Node
+class Vagrant < CORL.plugin_class(:node)
+ 
+  #-----------------------------------------------------------------------------
+  # Node plugin interface
+   
+  def normalize(reload)
+    super
+    
+    unless reload
+      machine_provider = :vagrant
+      machine_provider = yield if block_given?
+                        
+      myself.machine = create_machine(:machine, machine_provider, machine_config)
+    end
+    
+    network.ignore([ '.vagrant', 'boxes' ])
+    init_shares
+  end
+       
+  #-----------------------------------------------------------------------------
+  # Checks
+     
+  #-----------------------------------------------------------------------------
+  # Property accessors / modifiers
+  
+  def state(reset = false)
+    machine.state
+  end
+  
+  #---
+  
+  def vm=vm
+    myself[:vm] = vm
+  end
+  
+  def vm
+    hash(myself[:vm])
+  end
+  
+  #---
+  
+  def ssh=ssh
+    myself[:ssh] = ssh
+  end
+  
+  def ssh
+    hash(myself[:ssh])
+  end
+  
+  #---
+    
+  def shares=shares
+    myself[:shares] = shares
+    init_shares
+  end
+  
+  def shares
+    hash(myself[:shares])
+  end
+  
+  #-----------------------------------------------------------------------------
+  # Settings groups
+    
+  def machine_config
+    super do |config|        
+      config[:vm]     = vm
+      config[:shares] = shares
+      
+      yield(config) if block_given?
+    end
+  end
+  
+  #---
+  
+  def exec_options(name, options = {})
+    extended_config(name, options).export
+  end
+  
+  #-----------------------------------------------------------------------------
+  # Node operations
+  
+  def create(options = {})
+    super do |op, config|
+      if op == :config
+        config.import(exec_options(:create))
+      end     
+    end
+  end
+  
+  #---
+  
+  def download(remote_path, local_path, options = {})
+    super do |op, config|
+      if op == :config
+        config.import(exec_options(:download))
+      end
+    end
+  end
+  
+  #---
+  
+  def upload(local_path, remote_path, options = {})
+    super do |op, config|
+      if op == :config
+        config.import(exec_options(:upload))
+      end
+    end
+  end
+  
+  #---
+  
+  def exec(options = {})
+    super do |op, config|
+      if op == :config
+        config.import(exec_options(:exec))
+      end
+    end
+  end
+  
+  #---
+  
+  def save(options = {})
+    super do
+      id(true)
+      delete_setting(:machine_type)  
+    end  
+  end
+  
+  #---
+    
+  def start(options = {})
+    super do |op, config|
+      if op == :config
+        config.import(exec_options(:start))
+      end
+    end
+  end
+  
+  #---
+    
+  def reload(options = {})
+    super do |op, config|
+      if op == :config
+        config.import(exec_options(:reload))
+      end
+    end
+  end
+  
+  #---
+  
+  def create_image(options = {})
+    super do |op, config|
+      if op == :config
+        config.import(exec_options(:image))
+      end
+    end
+  end
+  
+  #---
+  
+  def stop(options = {})
+    super do |op, config|
+      if op == :config
+        config.import(exec_options(:stop))
+      elsif op == :finalize
+        true
+      end
+    end
+  end
+  
+  #---
+
+  def destroy(options = {})    
+    super do |op, config|
+      if op == :config
+        config.import(exec_options(:destroy))
+      end
+    end
+  end
+  
+  #-----------------------------------------------------------------------------
+  # Utilities
+  
+  def init_shares
+    shares.each do |name, info|
+      local_dir = info[:local]
+      network.ignore(local_dir)      
+    end
+  end
+  
+  #---
+  
+  def filter_output(type, data)
+    if type == :error
+      if data.include?('stdin: is not a tty') || data.include?('unable to re-open stdin')
+        data = ''  
+      end
+    end
+    data  
+  end
+   
+  #-----------------------------------------------------------------------------
+  # Machine type utilities
+  
+  def machine_type_id(machine_type)
+    machine_type
+  end
+  
+  #---
+  
+  def render_machine_type(machine_type)
+    machine_type.to_s
+  end
+  
+  #-----------------------------------------------------------------------------
+  # Image utilities
+  
+  def image_id(image)
+    image.id
+  end
+  
+  #---
+  
+  def render_image(image)
+    ''  
+  end
+  
+  #---
+  
+  def image_search_text(image)
+    image.to_s
+  end    
+end
+end
+end

data/lib/core/facade.rb

@@ -1,6 +1,31 @@
 
 module CORL
 module Facade
+  
+  #-----------------------------------------------------------------------------
+  # Local identification
+  
+  def public_ip
+    if Config.fact(:vagrant_exists)
+      Config.fact(:ipaddress_eth1)  
+    else
+      CORL.ip_address  
+    end
+  end
+  
+  #-----------------------------------------------------------------------------
+  # Vagrant related
+  
+  def vagrant?
+    Vagrant.command ? true : false
+  end
+  
+  #---
+  
+  def vagrant_config(directory, config)
+    require File.join(File.dirname(__FILE__), 'vagrant', 'config.rb')
+    Vagrant::Config.register(directory, config)
+  end
     
   #-----------------------------------------------------------------------------
   # Core plugin type facade
@@ -40,8 +65,6 @@ module Facade
     plugin(:provisioner, provider, options)
   end
   
-  #---
-  
   def provisioners(data, build_hash = false, keep_array = false)
     plugins(:provisioner, data, build_hash, keep_array)
   end

data/lib/core/mixin/macro/network_settings.rb

@@ -48,9 +48,43 @@ module NetworkSettings
     
     #---
   
+    define_method :cache do
+      network.cache
+    end
+  
+    define_method :cache_setting do |keys, default = nil, format = false|
+      cache.get([ _type, plugin_provider, plugin_name, keys ].flatten, default, format)
+    end
+
+    define_method :set_cache_setting do |keys, value|
+      cache.set([ _type, plugin_provider, plugin_name, keys ].flatten, value)
+    end
+
+    define_method :delete_cache_setting do |keys|
+      cache.delete([ _type, plugin_provider, plugin_name, keys ].flatten)
+    end
+
+    define_method :clear_cache do
+      cache.delete([ _type, plugin_provider, plugin_name ])
+    end
+
+    #---
+  
     define_method :groups do
       array(myself[:settings])
-    end     
+    end
+    
+    #---
+    
+    define_method :add_groups do |groups|
+      myself[:settings] = array(myself[:settings]) | array(groups)
+    end
+    
+    #---
+    
+    define_method :remove_groups do |groups|
+      myself[:settings] = array(myself[:settings]) - array(groups)
+    end    
   end
 end
 end