corl 0.5.0 → 0.5.1

data/lib/nucleon/action/node/fact.rb

@@ -0,0 +1,119 @@
+
+module Nucleon
+module Action
+module Node
+class Fact < CORL.plugin_class(:nucleon, :cloud_action)
+  
+  include Mixin::Action::Registration
+  
+  #-----------------------------------------------------------------------------
+  # Info
+  
+  def self.describe(action = :fact, weight = 570)
+    super(:node, action, weight)
+  end
+  
+  #-----------------------------------------------------------------------------
+  # Settings
+
+  def configure(aggregate = false)
+    super() do
+      codes :fact_save_failed
+      
+      unless aggregate
+        register_str :name, nil
+        register_str :value
+      
+        register_bool :delete      
+      
+        register_translator :input_format
+      end
+      
+      register_translator :format, :json
+    end
+  end
+  
+  #---
+  
+  def arguments
+    [ :name, :value ]
+  end
+
+  #-----------------------------------------------------------------------------
+  # Operations
+   
+  def execute
+    super do |node, network|
+      ensure_node(node) do
+        if ! settings[:name] || settings[:name].empty?
+          render_node_facts(node)
+        else
+          if settings.delete(:delete, false)
+            delete_node_fact(node, settings[:name], sanitize_remote(network, settings[:net_remote]))                
+          elsif settings[:value] && ! settings[:value].empty?
+            set_node_fact(node, settings[:name], settings[:value], sanitize_remote(network, settings[:net_remote]))
+          else
+            render_node_fact(node, settings[:name])
+          end
+        end
+      end
+    end
+  end
+  
+  #-----------------------------------------------------------------------------
+  # Sub operations
+  
+  def render_node_facts(node)
+    format        = settings[:format]
+    myself.result = node.facts        
+    render result, :format => format  
+  end
+  
+  #---
+  
+  def render_node_fact(node, name)
+    format        = settings[:format]
+    myself.result = node.fact(name)    
+    render result, :format => format 
+  end
+  
+  #---
+  
+  def delete_node_fact(node, name, remote = nil)
+    remote_text = remote ? "#{remote}" : "LOCAL ONLY"
+    
+    node.delete_facts(name)
+            
+    if node.save({ :remote => remote, :message => "Deleting fact #{name} from #{node.plugin_provider} #{node.plugin_name}" })
+      success("Fact #{name} deleted (#{remote_text})", { :i18n => false })
+    else
+      error("Fact #{name} deletion could not be saved", { :i18n => false })
+      myself.status = code.fact_save_failed  
+    end  
+  end
+  
+  #---
+  
+  def set_node_fact(node, name, value, remote = nil)
+    remote_text  = remote ? "#{remote}" : "LOCAL ONLY"
+    input_format = settings[:input_format]
+    
+    value        = Util::Data.value(render(value, { 
+      :format => input_format, 
+      :silent => true 
+    })) if input_format
+            
+    myself.result = value           
+    node.create_facts({ name => value })    
+            
+    if node.save({ :remote => remote, :message => "Saving fact #{name} to #{node.plugin_provider} #{node.plugin_name}" })
+      success("Fact #{name} saved (#{remote_text})", { :i18n => false })
+    else
+      error("New fact #{name} could not be saved", { :i18n => false })
+      myself.status = code.fact_save_failed  
+    end  
+  end
+end
+end
+end
+end

data/lib/nucleon/action/node/facts.rb

@@ -1,31 +1,31 @@
 
+nucleon_require(File.dirname(__FILE__), :fact)
+
+#---
+
 module Nucleon
 module Action
 module Node
-class Facts < CORL.plugin_class(:nucleon, :cloud_action)
-  
+class Facts < Fact
+ 
   #-----------------------------------------------------------------------------
   # Info
   
   def self.describe
-    super(:node, :facts, 570)
+    super(:facts, 571)
   end
- 
+  
   #-----------------------------------------------------------------------------
   # Settings
 
-  #-----------------------------------------------------------------------------
-  # Operations
-   
-  def execute
-    super do |node, network|
-      ensure_node(node) do
-        facter_facts = node.facts
-      
-        ui.info(Util::Data.to_json(facter_facts, true), { :prefix => false })
-        myself.result = facter_facts
-      end
-    end
+  def configure
+    super(true)
+  end
+  
+  #---
+  
+  def arguments
+    []
   end
 end
 end

data/lib/nucleon/action/node/group.rb

@@ -0,0 +1,115 @@
+
+module Nucleon
+module Action
+module Node
+class Group < CORL.plugin_class(:nucleon, :cloud_action)
+  
+  include Mixin::Action::Registration
+  
+  #-----------------------------------------------------------------------------
+  # Info
+  
+  def self.describe(action = :group, weight = 670)
+    super(:node, action, weight)
+  end
+  
+  #-----------------------------------------------------------------------------
+  # Settings
+
+  def configure(aggregate = false)
+    super() do
+      codes :group_save_failed
+      
+      unless aggregate
+        register_str :name, nil
+        
+        register_bool :add      
+        register_bool :delete
+      end
+      
+      register_translator :format, :json
+    end
+  end
+  
+  #---
+  
+  def arguments
+    [ :name ]
+  end
+
+  #-----------------------------------------------------------------------------
+  # Operations
+   
+  def execute
+    super do |node, network|
+      ensure_node(node) do
+        if ! settings[:name] || settings[:name].empty?
+          render_node_groups(node)
+        else
+          if settings.delete(:delete, false)
+            delete_node_group(node, settings[:name], sanitize_remote(network, settings[:net_remote]))                
+          elsif settings.delete(:add, false)
+            set_node_group(node, settings[:name], sanitize_remote(network, settings[:net_remote]))
+          else
+            render_node_group(node, settings[:name])
+          end
+        end
+      end
+    end
+  end
+  
+  #-----------------------------------------------------------------------------
+  # Sub operations
+  
+  def render_node_groups(node)
+    format        = settings[:format]
+    myself.result = node.groups        
+    render result, :format => format  
+  end
+  
+  #---
+  
+  def render_node_group(node, name)
+    if node.groups.include?(name.to_s)
+      myself.result = true
+      success("Group #{name} found", { :i18n => false })
+    else
+      myself.result = false
+      warn("Group #{name} not found", { :i18n => false })
+    end
+  end
+  
+  #---
+  
+  def delete_node_group(node, name, remote = nil)
+    remote_text = remote ? "#{remote}" : "LOCAL ONLY"
+    
+    node.remove_groups(name)
+            
+    if node.save({ :remote => remote, :message => "Deleting group #{name} from #{node.plugin_provider} #{node.plugin_name}" })
+      success("Group #{name} deleted (#{remote_text})", { :i18n => false })
+    else
+      error("Group #{name} deletion could not be saved", { :i18n => false })
+      myself.status = code.group_save_failed  
+    end  
+  end
+  
+  #---
+  
+  def set_node_group(node, name, remote = nil)
+    remote_text  = remote ? "#{remote}" : "LOCAL ONLY"
+            
+    myself.result = name           
+    node.add_groups(name)    
+            
+    if node.save({ :remote => remote, :message => "Saving group #{name} to #{node.plugin_provider} #{node.plugin_name}" })
+      success("Group #{name} saved (#{remote_text})", { :i18n => false })
+    else
+      error("New group #{name} could not be saved", { :i18n => false })
+      myself.status = code.group_save_failed  
+    end  
+  end
+end
+end
+end
+end

data/lib/nucleon/action/node/groups.rb

@@ -0,0 +1,33 @@
+
+nucleon_require(File.dirname(__FILE__), :group)
+
+#---
+
+module Nucleon
+module Action
+module Node
+class Groups < Group
+ 
+  #-----------------------------------------------------------------------------
+  # Info
+  
+  def self.describe
+    super(:groups, 671)
+  end
+  
+  #-----------------------------------------------------------------------------
+  # Settings
+
+  def configure
+    super(true)
+  end
+  
+  #---
+  
+  def arguments
+    []
+  end
+end
+end
+end
+end

data/lib/nucleon/action/node/identity.rb

@@ -0,0 +1,75 @@
+
+module Nucleon
+module Action
+module Node
+class Identity < CORL.plugin_class(:nucleon, :cloud_action)
+  
+  include Mixin::Action::Registration
+  
+  #-----------------------------------------------------------------------------
+  # Info
+  
+  def self.describe
+    super(:node, :identity, 700)
+  end
+ 
+  #-----------------------------------------------------------------------------
+  # Settings
+  
+  def configure
+    super do
+      codes :identity_upload_failure
+      
+      register :name, :str
+      register_project :identity
+      register_nodes :identity_nodes      
+    end
+  end
+  
+  #---
+  
+  def ignore
+    [ :nodes ]
+  end
+  
+  def arguments
+    [ :name, :identity_nodes ]
+  end
+
+  #-----------------------------------------------------------------------------
+  # Operations
+   
+  def execute
+    super do |local_node, network|
+      ensure_network(network) do
+        builder = network.identity_builder({ settings[:name] => settings[:identity] })
+        
+        if builder.build(local_node)
+          identity_directory = File.join(builder.build_directory, settings[:name])
+          
+          success = network.batch(settings[:identity_nodes], settings[:node_provider], settings[:parallel]) do |node|
+            info('corl.actions.identity.start', { :provider => node.plugin_provider, :name => node.plugin_name })
+            
+            remote_network_directory  = node.lookup(:corl_network)
+            
+            remote_config_directory        = File.join(remote_network_directory, network.config_directory.sub(/#{network.directory}#{File::SEPARATOR}/, ''))            
+            remote_identity_base_directory = File.join(remote_network_directory, builder.build_directory.sub(/#{network.directory}#{File::SEPARATOR}/, ''))
+            remote_identity_directory      = File.join(remote_identity_base_directory, settings[:name])
+            
+            node.cli.mkdir('-p', remote_identity_base_directory)
+            node.cli.rm('-Rf', remote_identity_directory)
+            
+            if success = node.send_files(identity_directory, remote_identity_directory, nil, '0700')
+              dbg('we were successful!')   
+            end        
+            success        
+          end
+        end
+        myself.status = code.batch_error unless success
+      end
+    end
+  end
+end
+end
+end
+end

data/lib/nucleon/action/node/lookup.rb

@@ -4,6 +4,8 @@ module Action
 module Node
 class Lookup < CORL.plugin_class(:nucleon, :cloud_action)
   
+  include Mixin::Action::Registration
+  
   #-----------------------------------------------------------------------------
   # Info
   
@@ -16,7 +18,7 @@ class Lookup < CORL.plugin_class(:nucleon, :cloud_action)
   
   def configure
     super do
-      register :property, :str, nil
+      register :properties, :array, []
       register :context, :str, :priority do |value|
         success = true
         options = [ :priority, :array, :hash ]
@@ -26,13 +28,15 @@ class Lookup < CORL.plugin_class(:nucleon, :cloud_action)
         end
         success
       end
+      
+      register_translator :format, :json
     end
   end
   
   #---
   
   def arguments
-    [ :property ]
+    [ :properties ]
   end
 
   #-----------------------------------------------------------------------------
@@ -41,11 +45,20 @@ class Lookup < CORL.plugin_class(:nucleon, :cloud_action)
   def execute
     super do |node, network|
       ensure_node(node) do
-        property = settings.delete(:property)
-        value    = node.lookup(property, nil, settings)
-      
-        ui.info(Util::Data.to_json(value, true), { :prefix => false })
-        myself.result = value
+        translator = CORL.translator({}, settings[:format])
+        
+        if settings[:properties].empty?
+          myself.result = node.hiera_configuration(node.facts)
+          $stderr.puts translator.generate(result)
+        else
+          properties = {}
+          
+          settings.delete(:properties).each do |property|
+            properties[property] = node.lookup(property, nil, settings)
+          end
+          $stderr.puts translator.generate(properties)
+          myself.result = properties 
+        end        
       end
     end
   end

data/lib/nucleon/action/node/seed.rb

@@ -64,7 +64,7 @@ class Seed < CORL.plugin_class(:nucleon, :cloud_action)
           network_path = lookup(:corl_network)
           backup_path  = File.join(Dir.tmpdir(), 'corl')
           
-          render("Generating network SSH deploy keys")
+          info("Generating network SSH deploy keys", { :i18n => false })
           
           if keys = Util::SSH.generate.store
             if @project_info
@@ -73,11 +73,11 @@ class Seed < CORL.plugin_class(:nucleon, :cloud_action)
               project_info = Config.new({ :provider => :git })
             end
             
-            render("Backing up current network configuration")
+            info("Backing up current network configuration", { :i18n => false })
             FileUtils.rm_rf(backup_path)
             FileUtils.mv(network_path, backup_path)
             
-            render("Seeding network configuration from #{settings[:project_reference]}")
+            info("Seeding network configuration from #{settings[:project_reference]}", { :i18n => false })
             project = CORL.project(extended_config(:project, {
               :directory   => network_path,
               :reference   => project_info.get(:reference, nil),
@@ -90,15 +90,15 @@ class Seed < CORL.plugin_class(:nucleon, :cloud_action)
             }), project_info[:provider])
         
             if project
-              render("Finalizing network path and removing temporary backup")
+              info("Finalizing network path and removing temporary backup", { :i18n => false })
               FileUtils.chmod_R(0600, network_path)
               FileUtils.rm_rf(backup_path)
               
-              render("Reinitializing network")
+              info("Reinitializing network", { :i18n => false })
               if network = init_network
                 if network.load
                   if node = network.local_node(true)
-                    render("Updating node network configurations")
+                    info("Updating node network configurations", { :i18n => false })
                     myself.status = code.node_save_failure unless node.save  
                   else
                     myself.status = code.node_load_failure

data/lib/nucleon/action/node/status.rb

@@ -0,0 +1,76 @@
+
+module Nucleon
+module Action
+module Node
+class Status < CORL.plugin_class(:nucleon, :cloud_action)
+  
+  include Mixin::Action::Registration
+  
+  #-----------------------------------------------------------------------------
+  # Info
+  
+  def self.describe
+    super(:node, :status, 800)
+  end
+ 
+  #-----------------------------------------------------------------------------
+  # Settings
+  
+  def configure
+    super do
+      register_nodes :status_nodes, []
+      
+      register_bool :basic
+    end
+  end
+  
+  #---
+  
+  def ignore
+    [ :nodes ]
+  end
+  
+  def arguments
+    [ :status_nodes ]
+  end
+  
+  #-----------------------------------------------------------------------------
+  # Operations
+   
+  def execute
+    super do |local_node, network|
+      ensure_network(network) do
+        settings[:status_nodes] = [ 'all' ] if settings[:status_nodes].empty?
+        
+        batch_success = network.batch(settings[:status_nodes], settings[:node_provider], settings[:parallel]) do |node|
+          state       = node.state(true).to_sym
+          ssh_enabled = ''
+          
+          case state
+          when :running, :active
+            state = green(state.to_s)
+            
+            unless settings[:basic]
+              result = node.cli.test :true
+            
+              if result.status == code.success
+                ssh_enabled = '[ ' + green('connected') + ' ]'
+              else
+                ssh_enabled = '[ ' + red('connection failed') + ' ]'      
+              end
+            end
+            
+          when :stopped, :aborted
+            state = red(state.to_s)
+          end
+          info(state + " #{ssh_enabled}".rstrip, { :i18n => false, :prefix_text => yellow(node.plugin_provider) + ' ' + purple(node.plugin_name) })
+          true
+        end
+        myself.status = code.batch_error unless batch_success
+      end
+    end
+  end
+end
+end
+end
+end