corl 0.5.0 → 0.5.1

data/lib/nucleon/action/cloud/config.rb

@@ -0,0 +1,259 @@
+
+module Nucleon
+module Action
+module Cloud
+class Config < CORL.plugin_class(:nucleon, :cloud_action)
+  
+  include Mixin::Action::Registration
+  
+  #-----------------------------------------------------------------------------
+  # Info
+  
+  def self.describe
+    super(:cloud, :config, 949)
+  end
+ 
+  #-----------------------------------------------------------------------------
+  # Settings
+ 
+  def configure
+    super do
+      codes :configuration_parse_failed,
+            :configuration_save_failed,
+            :configuration_delete_failed
+      
+      register_str :name, nil
+      register_array :value
+      
+      register_bool :delete
+      register_bool :append
+      
+      register_translator :input_format
+      register_translator :load_format, :json 
+      register_translator :format, :json
+    end
+  end
+  
+  #---
+  
+  def ignore
+    [ :nodes ]
+  end
+  
+  def arguments
+    [ :name, :value ]
+  end
+  
+  #-----------------------------------------------------------------------------
+  # Operations
+   
+  def execute
+    super do |node, network|
+      ensure_network(network) do
+        config_info = parse_config_reference(network, settings[:name])
+        
+        unless config_info
+          myself.status = code.configuration_parse_failed
+        end
+        
+        if config_info[:property].nil?
+          render_config_properties(network, config_info)
+           
+        elsif settings.delete(:delete, false)
+          delete_config_property(network, config_info, sanitize_remote(network, settings[:net_remote]))
+                          
+        elsif ! settings[:value].empty?
+          set_config_property(network, config_info, settings[:value], sanitize_remote(network, settings[:net_remote]))
+        else
+          render_config_property(network, config_info)
+        end
+      end
+    end
+  end
+  
+  #-----------------------------------------------------------------------------
+  # Sub operations
+  
+  def render_config_properties(network, config_info)
+    if file_labels = config_info[:files]
+      info("Sub configurations available:", { :i18n => false })
+      file_labels.each do |label|
+        info("-> #{yellow(label)}", { :i18n => false })
+      end  
+    else
+      format        = settings[:format]
+      myself.result = config_info[:config].export
+      render result, :format => format
+    end  
+  end
+  
+  #---
+  
+  def render_config_property(network, config_info)
+    format        = settings[:format]
+    myself.result = config_info[:value]
+    render result, :format => format 
+  end
+  
+  #---
+  
+  def delete_config_property(network, config_info, remote = nil)
+    name        = parse_property_name(config_info[:property])    
+    remote_text = remote_message(remote)
+    config_file = config_info[:file].sub(network.directory + File::SEPARATOR, '')
+    
+    config_info[:config].delete(config_info[:property])
+    
+    if File.exists?(config_info[:file])    
+      if Util::Disk.write(config_info[:file], config_info[:translator].generate(config_info[:config].export))
+        if network.save({ :files => config_file, :remote => remote, :message => "Deleting configuration #{name} from #{config_file}", :allow_empty => true })
+          success("Configuration `#{blue(name)}` deleted (#{yellow(remote_text)})", { :i18n => false })
+        else
+          error("Configuration `#{blue(name)}` deletion could not be saved", { :i18n => false })
+          myself.status = code.configuration_save_failed    
+        end
+      else
+        error("Configuration file `#{blue(config_file)}` could not be saved", { :i18n => false })
+        myself.status = code.configuration_save_failed  
+      end
+    else
+      info("Configuration file `#{blue(config_file)} does not exist so configuration can not be deleted", { :i18n => false })    
+    end
+  end
+  
+  #---
+  
+  def set_config_property(network, config_info, values, remote = nil)
+    name         = parse_property_name(config_info[:property])    
+    remote_text  = remote_message(remote)
+    
+    config_file  = config_info[:file].sub(network.directory + File::SEPARATOR, '')
+    input_format = settings[:input_format]
+    
+    values.each_with_index do |value, index|    
+      values[index] = render(value, { 
+        :format => input_format, 
+        :silent => true 
+      }) if input_format
+      values[index] = Util::Data.value(values[index])
+    end
+    
+    if settings[:append]
+      if prev_value = config_info[:value]
+        prev_value = array(prev_value)
+        
+        values.each do |value|
+          prev_value.push(value)
+        end        
+        values = prev_value
+      end
+    else
+      if values.size == 1
+        values = values[0]
+      end    
+    end
+            
+    myself.result = values    
+    config_info[:config].set(config_info[:property], result)
+    
+    FileUtils.mkdir_p(File.dirname(config_info[:file]))
+    
+    if Util::Disk.write(config_info[:file], config_info[:translator].generate(config_info[:config].export))
+      if network.save({ :files => config_file, :remote => remote, :message => "Updating configuration #{name} in #{config_file}", :allow_empty => true })
+        success("Configuration `#{blue(name)}` update (#{yellow(remote_text)})", { :i18n => false })
+      else
+        error("Configuration `#{blue(name)}` update could not be saved", { :i18n => false })
+        myself.status = code.configuration_save_failed    
+      end
+    else
+      error("Configuration file `#{blue(config_file)}` could not be saved", { :i18n => false })
+      myself.status = code.configuration_save_failed  
+    end
+  end
+  
+  #-----------------------------------------------------------------------------
+  # Utilities
+  
+  def parse_config_reference(network, name)
+    info = {}
+    data = {}
+    
+    translators = CORL.loaded_plugins(:nucleon, :translator).keys
+    
+    # common@php::apache::memory_limit
+    # identity/test@users::user[admin][shell]
+    # servers/development/dev.loc@facts[server_environment]
+    
+    config_elements  = name.split('@')
+    
+    property         = config_elements.size > 1 ? config_elements.pop : nil
+    config_elements  = config_elements[0].split('/')    
+    config_file_name = config_elements.pop    
+    config_path      = File.join(network.config_directory, *config_elements)
+        
+    if config_file_name
+      config_dir   = File.join(config_path, config_file_name)
+      config_file  = File.join(config_path, "#{config_file_name}." + settings[:load_format].to_s)
+      config_files = nil
+      property     = property.gsub(/\]$/, '').split(/\]?\[/) if property
+      
+      unless translator = CORL.translator({}, settings[:load_format])
+        error("Translator for #{settings[:format]} could not be loaded", { :i18n => false })
+        return nil
+      end
+      
+      if File.exists?(config_file)
+        unless data = Util::Disk.read(config_file)
+          error("Failed to read file: #{config_file}", { :i18n => false })
+          return nil
+        end
+        config = CORL::Config.new(translator.parse(data))
+      elsif File.directory?(config_dir)
+        config_files = Dir.glob("#{config_dir}/**/*").select do |file|
+          is_config = false
+          
+          translators.each do |translator_name|
+            is_config = true if file.match(/\.#{translator_name}/)
+          end
+          is_config
+        end
+        config_files.each_with_index do |file, index|
+          config_files[index] = file.sub(/#{network.config_directory + File::SEPARATOR}/, '')
+          config_files[index] = config_files[index].sub(/\.([a-z0-9]+)$/, ' [ ' + blue('\1') + ' ]') 
+        end
+      end
+      
+      config = CORL::Config.new unless config            
+      info   = {
+        :translator => translator,
+        :file       => config_file,
+        :files      => config_files,
+        :property   => property,
+        :config     => config,
+        :value      => property ? Util::Data.value(config.get(property)) : nil
+      }
+    end
+    info
+  end
+  
+  #---
+
+  def parse_property_name(property)
+    property = property.clone
+    
+    if property.size > 1
+      property.shift.to_s + '[' + property.join('][') + ']'
+    else
+      property.shift.to_s
+    end
+  end
+  
+  #---
+  
+  def remote_message(remote)
+    remote ? "#{remote}" : "LOCAL ONLY"
+  end
+end
+end
+end
+end

data/lib/nucleon/action/cloud/images.rb

@@ -47,7 +47,7 @@ class Images < CORL.plugin_class(:nucleon, :cloud_action)
         if node = network.test_node(settings[:node_provider], { :region => settings[:region] })
           if images = node.images(settings[:search], settings)
             images.each do |image|
-              render(node.render_image(image), { :prefix => false })
+              info(node.render_image(image), { :prefix => false, :i18n => false })
             end
           
             myself.result = images

data/lib/nucleon/action/cloud/inspect.rb

@@ -4,6 +4,8 @@ module Action
 module Cloud
 class Inspect < CORL.plugin_class(:nucleon, :cloud_action)
   
+  include Mixin::Action::Registration
+  
   #-----------------------------------------------------------------------------
   # Info
   
@@ -16,7 +18,10 @@ class Inspect < CORL.plugin_class(:nucleon, :cloud_action)
  
   def configure
     super do
-      register :elements, :array, []
+      codes :configuration_parse_failed
+      
+      register_array :elements
+      register_translator :format, :json
     end
   end
   
@@ -37,7 +42,11 @@ class Inspect < CORL.plugin_class(:nucleon, :cloud_action)
         else
           data = network.config.get(settings[:elements])
         end
-        ui.info("\n\n" + CORL.render_object(data) + "\n\n")
+        if network.config.status == code.success
+          render data, :format => settings[:format]
+        else
+          myself.status = code.configuration_parse_failed
+        end
       end
     end
   end

data/lib/nucleon/action/cloud/machines.rb

@@ -42,7 +42,7 @@ class Machines < CORL.plugin_class(:nucleon, :cloud_action)
         if node = network.test_node(settings[:node_provider])
           if machine_types = node.machine_types
             machine_types.each do |machine_type|
-              render(node.render_machine_type(machine_type), { :prefix => false })
+              info(node.render_machine_type(machine_type), { :prefix => false, :i18n => false })
             end
           
             myself.result = machine_types

data/lib/nucleon/action/cloud/regions.rb

@@ -42,7 +42,7 @@ class Regions < CORL.plugin_class(:nucleon, :cloud_action)
         if node = network.test_node(settings[:node_provider])
           if regions = node.regions
             regions.each do |region|
-              render(sprintf("> %s", region), { :prefix => false })
+              info(sprintf("> %s", region), { :prefix => false, :i18n => false })
             end
           
             myself.result = regions

data/lib/nucleon/action/cloud/settings.rb

@@ -0,0 +1,185 @@
+
+module Nucleon
+module Action
+module Cloud
+class Settings < CORL.plugin_class(:nucleon, :cloud_action)
+  
+  include Mixin::Action::Registration
+  
+  #-----------------------------------------------------------------------------
+  # Info
+  
+  def self.describe
+    super(:cloud, :settings, 951)
+  end
+ 
+  #-----------------------------------------------------------------------------
+  # Settings
+ 
+  def configure
+    super do
+      codes :settings_save_failed,
+            :settings_delete_failed
+      
+      register_str :group
+      register_str :name
+      register_array :value
+      
+      register_bool :delete
+      register_bool :append
+      register_bool :groups
+      
+      register_translator :input_format
+      register_translator :format, :json
+    end
+  end
+  
+  #---
+  
+  def ignore
+    [ :nodes ]
+  end
+   
+  def arguments
+    [ :group, :name, :value ]
+  end
+  
+  #-----------------------------------------------------------------------------
+  # Operations
+   
+  def execute
+    super do |node, network|
+      ensure_network(network) do
+        if settings[:groups]
+          render_groups(network)
+          
+        elsif settings[:group].empty?
+          render_settings(network)
+          
+        elsif settings[:name].empty?
+          render_settings(network, settings[:group])
+          
+        else
+          name = settings[:name].gsub(/\]$/, '').split(/\]?\[/)
+          
+          if settings.get(:delete, false)
+            delete_settings(network, name, sanitize_remote(network, settings[:net_remote]))
+                 
+          elsif ! settings[:value].empty?
+            set_settings(network, name, settings[:value], sanitize_remote(network, settings[:net_remote]))
+                
+          else
+            render_settings(network, [ settings[:group], name ])  
+          end          
+        end
+      end
+    end
+  end
+  
+  #-----------------------------------------------------------------------------
+  # Sub operations
+  
+  def render_groups(network)
+    groups = network.config.get(:settings).keys
+    
+    info("Currently defined groups:", { :i18n => false })
+    groups.each do |group|
+      info("-> #{green(group)}", { :i18n => false })
+    end
+  end
+  
+  #---
+  
+  def render_settings(network, elements = [])
+    format = settings[:format]
+    
+    if elements.size > 0
+      myself.result = network.config.get([ :settings, elements ])
+    else
+      myself.result = network.config.get(:settings)
+    end
+    render result, :format => format  
+  end
+   
+  #---
+  
+  def delete_settings(network, property, remote = nil)
+    group       = settings[:group]
+    name        = parse_property_name(property)    
+    remote_text = remote_message(remote)
+    
+    network.config.delete([ :settings, group, property ])
+    
+    if network.save({ :remote => remote, :message => "Deleting #{group} setting #{name}", :allow_empty => true })
+      success("Group #{blue(group)} setting `#{blue(name)}` deleted (#{yellow(remote_text)})", { :i18n => false })
+    else
+      error("Group #{blue(group)} setting `#{blue(name)}` deletion could not be saved", { :i18n => false })
+      myself.status = code.settings_delete_failed    
+    end
+  end
+  
+  #---
+  
+  def set_settings(network, property, values, remote = nil)
+    group        = settings[:group]
+    name         = parse_property_name(property)    
+    remote_text  = remote_message(remote)
+    
+    input_format = settings[:input_format]
+    
+    values.each_with_index do |value, index|    
+      values[index] = render(value, { 
+        :format => input_format, 
+        :silent => true 
+      }) if input_format
+      values[index] = Util::Data.value(values[index])
+    end
+    
+    if settings[:append]
+      if prev_value = network.config.get([ :settings, group, property ])
+        prev_value = array(prev_value)
+        
+        values.each do |value|
+          prev_value.push(value)
+        end        
+        values = prev_value
+      end
+    else
+      if values.size == 1
+        values = values[0]
+      end    
+    end
+            
+    myself.result = values    
+    network.config.set([ :settings, group, property ], result)
+    
+    if network.save({ :remote => remote, :message => "Updating #{group} setting #{name}", :allow_empty => true })
+      success("Group #{blue(group)} setting `#{blue(name)}` updated (#{yellow(remote_text)})", { :i18n => false })
+    else
+      error("Group #{blue(group)} setting `#{blue(name)}` update could not be saved", { :i18n => false })
+      myself.status = code.settings_save_failed    
+    end
+  end
+  
+  #-----------------------------------------------------------------------------
+  # Utilities
+
+  def parse_property_name(property)
+    property = property.clone
+    
+    if property.size > 1
+      property.shift.to_s + '[' + property.join('][') + ']'
+    else
+      property.shift.to_s
+    end
+  end
+  
+  #---
+  
+  def remote_message(remote)
+    remote ? "#{remote}" : "LOCAL ONLY"
+  end
+end
+end
+end
+end

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

@@ -20,7 +20,7 @@ class IP < CORL.plugin_class(:nucleon, :cloud_action)
   def execute
     super do |node, network|
       ensure_node(node) do
-        ui.info(CORL.public_ip)
+        render(CORL.public_ip)
       end
     end
   end

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

@@ -80,7 +80,7 @@ class Bootstrap < CORL.plugin_class(:nucleon, :cloud_action)
           render_options = { :id => node.id, :hostname => node.hostname }
           
           info('corl.actions.bootstrap.start', render_options)
-          success = node.bootstrap(network.home, extended_config(:bootstrap, settings))
+          success = node.bootstrap(network.home, extended_config(:bootstrap, settings.clone))
           if success
             info('corl.actions.bootstrap.success', render_options)
           else

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

@@ -0,0 +1,133 @@
+
+module Nucleon
+module Action
+module Node
+class Cache < CORL.plugin_class(:nucleon, :cloud_action)
+  
+  include Mixin::Action::Registration
+  
+  #-----------------------------------------------------------------------------
+  # Info
+  
+  def self.describe
+    super(:node, :cache, 600)
+  end
+  
+  #-----------------------------------------------------------------------------
+  # Settings
+
+  def configure
+    super do
+      codes :cache_save_failed
+      
+      register_str :name
+      register_str :value
+      
+      register_bool :delete
+      register_bool :clear     
+      
+      register_translator :input_format            
+      register_translator :format, :json
+    end
+  end
+  
+  #---
+  
+  def arguments
+    [ :name, :value ]
+  end
+
+  #-----------------------------------------------------------------------------
+  # Operations
+   
+  def execute
+    super do |node, network|
+      ensure_node(node) do
+        if settings.delete(:clear, false)
+          clear_node_cache(node)
+        elsif ! settings[:name] || settings[:name].empty?
+          render_node_cache(node)
+        else
+          settings[:name]  = settings[:name].split('.')
+          settings[:value] = nil if settings[:value].is_a?(String) && settings[:value].empty? 
+          
+          if settings.delete(:delete, false)
+            delete_node_cache(node, settings[:name])                
+          elsif ! settings[:value].nil?
+            set_node_cache(node, settings[:name], settings[:value])
+          else
+            render_node_cache_property(node, settings[:name])
+          end
+        end
+      end
+    end
+  end
+  
+  #-----------------------------------------------------------------------------
+  # Sub operations
+  
+  def render_node_cache(node)
+    format        = settings[:format]
+    myself.result = node.cache_setting([], {}, :hash)
+    render result, :format => format  
+  end
+  
+  #---
+  
+  def render_node_cache_property(node, name)
+    format        = settings[:format]
+    myself.result = node.cache_setting(name)
+    render result, :format => format 
+  end
+  
+  #---
+  
+  def delete_node_cache(node, name)
+    node.delete_cache_setting(name)
+    
+    if node.cache.status == code.success
+      success("Cached property #{name.join('.')} deleted", { :i18n => false })
+    else
+      error("Cached property #{name.join('.')} deletion could not be saved", { :i18n => false })
+      myself.status = code.cache_save_failed  
+    end  
+  end
+  
+  #---
+  
+  def set_node_cache(node, name, value)
+    input_format = settings[:input_format]
+    
+    value        = Util::Data.value(render(value, { 
+      :format => input_format, 
+      :silent => true 
+    })) if input_format
+            
+    myself.result = value
+        
+    node.set_cache_setting(name, value)
+    
+    if node.cache.status == code.success  
+      success("Cached property #{name.join('.')} saved", { :i18n => false })
+    else
+      error("Cached property #{name.join('.')} could not be saved", { :i18n => false })
+      myself.status = code.cache_save_failed  
+    end  
+  end
+  
+  #---
+  
+  def clear_node_cache(node)
+    node.clear_cache
+    
+    if node.cache.status == code.success
+      success("Cached properties cleared", { :i18n => false })
+    else
+      error("Cached properties could not be cleared", { :i18n => false })
+      myself.status = code.cache_save_failed  
+    end  
+  end
+end
+end
+end
+end