corl 0.5.2 → 0.5.3

data/lib/core/plugin/agent.rb

@@ -0,0 +1,141 @@
+
+nucleon_require(File.dirname(__FILE__), :cloud_action)
+
+#---
+
+module Nucleon
+module Plugin
+class Agent < Nucleon.plugin_class(:nucleon, :cloud_action)
+
+  #-----------------------------------------------------------------------------
+  # Property accessor / modifiers
+
+  def configure
+    super do
+      yield if block_given?
+      agent_config
+    end
+  end
+
+  #---
+
+  def help
+    # TODO:  Localization
+    'AGENT ' + super
+  end
+
+  #-----------------------------------------------------------------------------
+  # Settings
+
+  def pid
+    settings[:pid]
+  end
+
+  #---
+
+  def agent_config
+  end
+
+  #-----------------------------------------------------------------------------
+  # Operations
+
+  def execute(use_network = true, &code)
+    super do |node|
+      ensure_network do
+        daemonize(node)
+        yield node
+      end
+    end
+  end
+
+  #---
+
+  def daemonize(node)
+    # Mostly derived from rack gem implementation
+    #
+    # https://github.com/rack/rack/blob/master/lib/rack/server.rb
+    # http://www.jstorimer.com/blogs/workingwithcode/7766093-daemon-processes-in-ruby
+    #
+    if RUBY_VERSION < "1.9"
+      exit if fork
+      Process.setsid
+      safe_exit if fork
+
+      Dir.chdir network.directory
+
+      STDIN.reopen "/dev/null"
+      STDOUT.reopen "/dev/null", "a"
+      STDERR.reopen "/dev/null", "a"
+    else
+      Process.daemon
+    end
+
+    #---
+
+    save_process(node)
+
+    at_exit do
+      shutdown_process(node)
+    end
+
+    trap(:INT) do
+      safe_exit
+    end
+  end
+  protected :daemonize
+
+  #-----------------------------------------------------------------------------
+  # Utilities
+
+  def process_status(node)
+    agent_settings = node.agent(plugin_provider)
+
+    return :not_running unless agent_settings && agent_settings.has_key?(:pid)
+    return :dead if agent_settings[:pid] == 0
+
+    Process.kill(0, agent_settings[:pid])
+    :running
+
+    rescue Errno::ESRCH
+      :dead
+    rescue Errno::EPERM
+      :not_owned
+  end
+  protected :process_status
+
+  #---
+
+  def save_process(node)
+    settings[:pid] = Process.pid
+
+    node.add_agent(plugin_provider, settings)
+    node.save({
+      :message => "Agent #{plugin_provider} starting up on #{node.plugin_name}",
+      :remote => extension_set(:write_process_remote, :edit),
+      :push => true
+    })
+  end
+  protected :save_process
+
+  #---
+
+  def shutdown_process(node)
+    node.remove_agent(plugin_provider)
+    node.save({
+      :message => "Agent #{plugin_provider} shutting down on #{node.plugin_name}",
+      :remote => extension_set(:shutdown_handler_remote, :edit),
+      :push => true
+    })
+  end
+  protected :shutdown_process
+
+  #---
+
+  def safe_exit
+    finalize_execution
+    exit status
+  end
+  protected :safe_exit
+end
+end
+end

data/lib/core/plugin/cloud_action.rb

@@ -1,27 +1,27 @@
 
 module CORL
 module Vagrant
-  
+
   #
   # Since we can execute CORL actions from within Vagrant on a combination of
-  # Vagrant VMs and remote server instances we need a way to tap into the 
+  # Vagrant VMs and remote server instances we need a way to tap into the
   # Vagrant environment and operate on CORL configured Vagrant machines.
-  # 
-  # This command is set in the CORL launcher Vagrant command plugin execute 
+  #
+  # This command is set in the CORL launcher Vagrant command plugin execute
   # method.  It is then accessible anywhere within CORL if we have used that
   # Vagrant command as an execution gateway.  If not it will be nil, giving us
   # a convienient method for checking whether we are executing through Vagrant
   # which is used in the CORL Vagrant {Node} and {Machine} plugins.
-  #  
+  #
   @@command = nil
-  
+
   def self.command=command
     @@command = command
   end
-  
+
   def self.command
     @@command
-  end  
+  end
 end
 end
 
@@ -30,75 +30,76 @@ end
 module Nucleon
 module Plugin
 class CloudAction < Nucleon.plugin_class(:nucleon, :action)
-  
+
   #-----------------------------------------------------------------------------
   # Constuctor / Destructor
-  
+
   def normalize(reload)
-    super
-    init_network unless reload 
+    super do
+      init_network
+    end
   end
-  
+
   #-----------------------------------------------------------------------------
   # Property accessor / modifiers
-  
+
   def self.namespace
     :corl
   end
-  
+
   #---
-  
+
   def network=network
     @network = network
   end
-  
+
   def network
     @network
   end
-  
+
   #---
-    
+
   def configure
     super do
       yield if block_given?
       node_config
     end
   end
-          
+
   #-----------------------------------------------------------------------------
   # Settings
-  
+
   def node_config
     register_str :net_remote, :edit, 'corl.core.action.options.net_remote'
     register_network_provider :net_provider, :corl, [ 'corl.core.action.options.net_provider', 'corl.core.action.errors.network_provider' ]
-    
-    register_node_provider :node_provider, :local, [ 'corl.core.action.options.node_provider', 'corl.core.action.errors.node_provider' ]    
+
+    register_node_provider :node_provider, :local, [ 'corl.core.action.options.node_provider', 'corl.core.action.errors.node_provider' ]
     register_nodes :nodes, [], [ 'corl.core.action.options.nodes', 'corl.core.action.errors.nodes' ]
-    
+
     register_bool :parallel, true, 'corl.core.action.options.parallel'
   end
-  
+
   #---
-         
+
   def node_ignore
     [ :parallel, :node_provider, :nodes ]
   end
-  
+
   #-----------------------------------------------------------------------------
   # Operations
-  
+
   def validate(node = nil, network = nil)
     super(node, network)
   end
-  
+
   #---
-   
+
   def execute(use_network = true, &code)
     if use_network
       super(true, true) do
         node_exec do |node|
           hook_config = { :node => node, :network => network }
-        
+
           code.call(node) if code && extension_check(:exec_init, hook_config)
           myself.status = extension_set(:exec_exit, status, hook_config)
         end
@@ -107,48 +108,48 @@ class CloudAction < Nucleon.plugin_class(:nucleon, :action)
       super(false, false, &code)
     end
   end
-  
+
   #---
-        
+
   def node_exec
-    init_network(settings[:net_provider]) unless settings[:net_provider].to_sym == network.plugin_provider
-    
+    init_network(settings[:net_provider]) unless network && settings[:net_provider].to_sym == network.plugin_provider
+
     #
     # A fork in the road...
     #
     if network && network.has_nodes? && ! settings[:nodes].empty?
-      # Execute action on remote nodes 
+      # Execute action on remote nodes
       success = network.batch(settings[:nodes], settings[:node_provider], settings[:parallel]) do |node|
         exec_config = Config.new(settings)
         exec_config.delete(:nodes)
-              
+
         result = node.action(plugin_provider, exec_config) do |op, data|
           execute_remote(node, op, data)
         end
-        result.status == code.success 
+        result.status == code.success
       end
       myself.status = code.batch_error unless success
     else
       # Execute statement locally
       node = nil
       node = network.local_node if network
-      
+
       settings[:net_remote] = sanitize_remote(settings[:net_remote]) if settings.has_key?(:net_remote)
-      
+
       if validate(node, network)
         yield(node) if block_given?
       else
         puts "\n" + I18n.t('nucleon.core.exec.help.usage') + ': ' + help + "\n" unless quiet?
-        myself.status = code.validation_failed 
+        myself.status = code.validation_failed
       end
     end
   end
-  
+
   #---
-  
+
   def init_network(provider = nil, path = nil)
     provider = extension_set(:network_provider, :corl) unless provider
-    
+
     # Get network configuration path
     if CORL.admin?
       network_path = lookup(:corl_network)
@@ -156,59 +157,63 @@ class CloudAction < Nucleon.plugin_class(:nucleon, :action)
     else
       network_path = ( path.nil? ? Dir.pwd : File.expand_path(path) )
     end
-    
-    # Load network if it exists
-    network_config = extended_config(:network, { :directory => network_path })
-    @network       = CORL.network(network_path, network_config, provider)
+
+    if File.exists?(File.join(network_path, '.corl'))
+      # Load network if it exists
+      network_config = extended_config(:network, { :directory => network_path, :new => true })
+      @network       = CORL.network(network_path, network_config, provider)
+    else
+      @network = nil
+    end
   end
-  
+
   #---
-  
+
   def execute_remote(node, op, data)
     # Implement in sub classes if needed
-    data 
+    data
   end
-  
+
   #---
-  
+
   def ensure_network(&block)
     codes :network_failure
-    
+
     if network
       block.call
     else
       myself.status = code.network_failure
     end
   end
-  
+
   def ensure_node(node, &block)
     codes :node_failure
-    
+
     if node
       block.call
     else
       myself.status = code.node_failure
     end
   end
-    
+
   #-----------------------------------------------------------------------------
   # Utilities
-  
+
   def sanitize_remote(remote)
     remote && ( ! network || network.remote(remote) ) ? remote : nil
   end
-  
+
   #---
-  
+
   def remote_message(remote)
     remote ? "#{remote}" : "LOCAL ONLY"
   end
-  
+
   #---
 
   def parse_property_name(property)
     property = property.clone
-    
+
     if property.size > 1
       property.shift.to_s + '[' + property.join('][') + ']'
     else