corl 0.4.0

data/lib/corl/command/shell.rb

@@ -0,0 +1,164 @@
+
+module CORL
+module Command
+class Shell < Plugin::Command
+
+  #-----------------------------------------------------------------------------
+  # Command plugin interface
+  
+  def normalize
+    super
+    command = executable(self)
+    
+    logger.info("Setting command executable to #{command}")
+    set(:command, command)
+  end
+   
+  #-----------------------------------------------------------------------------
+  # Command operations
+  
+  def build(components = {}, overrides = nil, override_key = false)
+    command            = string(components[:command])
+    flags              = array( components.has_key?(:flags) ? components[:flags] : [] )
+    data               = string_map(hash( components.has_key?(:data) ? components[:data] : {} ))
+    args               = array( components.has_key?(:args) ? components[:args] : [] )
+    subcommand         = hash( components.has_key?(:subcommand) ? components[:subcommand] : {} )
+    
+    override_key       = command unless override_key
+    override_key       = override_key.to_sym
+    
+    command_string     = command.dup
+    subcommand_string  = ''
+    
+    escape_characters  = /[\'\"]+/
+    escape_replacement = '\"'
+    
+    dash_pattern       = /^([\-]+)/
+    assignment_pattern = /\=$/
+    
+    logger.info("Building command #{command}")
+    logger.debug("Command flags: #{flags.inspect}")
+    logger.debug("Command options: #{data.inspect}")
+    logger.debug("Command arguments: #{args.inspect}")
+    logger.debug("Command has sub command") unless subcommand.empty?
+    
+    logger.debug("Overrides: #{overrides.inspect}")
+    logger.debug("Override key: #{override_key}")
+    
+    # Flags
+    if overrides && overrides.has_key?(:flags)
+      if overrides[:flags].is_a?(Hash)
+        if overrides[:flags].has_key?(override_key)
+          flags = array(overrides[:flags][override_key])
+        end
+      else
+        flags = array(overrides[:flags])
+      end
+    end
+    flags.each do |flag|
+      flag = string(flag)
+      if ! flag.empty?        
+        if flag.match(dash_pattern)
+          dashes = $1
+        else
+          dashes = ( flag.size == 1 ? '-' : '--' )  
+        end
+        command_string << " #{dashes}#{flag}"
+      end
+    end
+    
+    # Data
+    if overrides && overrides.has_key?(:data)
+      if overrides[:data].has_key?(override_key)
+        data = hash(overrides[:data][override_key])
+      else
+        override = true
+        overrides[:data].each do |key, value|
+          if ! value.is_a?(String)
+            override = false
+          end
+        end
+        data = hash(overrides[:data]) if override
+      end
+    end
+    data.each do |key, value|
+      key   = string(key)
+      value = string(value).strip.sub(escape_characters, escape_replacement)
+      
+      if key.match(dash_pattern)
+        dashes = $1
+      else
+        dashes = ( key.size == 1 ? '-' : '--' )  
+      end      
+      space = ( key.match(assignment_pattern) ? '' : ' ' )  
+      
+      command_string << " #{dashes}#{key}#{space}\"#{value}\""
+    end
+    
+    # Arguments
+    if overrides && overrides.has_key?(:args)
+      unless overrides[:args].empty?
+        if overrides[:args].is_a?(Hash)
+          if overrides[:args].has_key?(override_key)
+            args = array(overrides[:args][override_key])
+          end
+        else
+          args = array(overrides[:args])
+        end
+      end
+    end
+    args.each do |arg|
+      arg = string(arg).sub(escape_characters, escape_replacement)
+      
+      unless arg.empty?
+        command_string << " \"#{arg}\""
+      end
+    end
+    
+    # Subcommand
+    subcommand_overrides = ( overrides ? overrides[:subcommand] : nil )
+    if subcommand && subcommand.is_a?(Hash) && ! subcommand.empty?
+      subcommand_string = build(subcommand, subcommand_overrides)
+    end
+    
+    command_string = (command_string + ' ' + subcommand_string).strip
+    
+    logger.debug("Rendered command: #{command_string}")
+    return command_string
+  end
+  
+  #---
+    
+  def exec(options = {}, overrides = nil)
+    config = Config.ensure(options)
+    
+    logger.info("Executing command #{command}")
+    
+    config[:ui] = @ui
+    result = Util::Shell.connection.exec(build(export, overrides), config) do |op, command, data|
+      block_given? ? yield(op, command, data) : true
+    end
+    
+    logger.warn("Command #{command} failed to execute") unless result.status == CORL.code.success    
+    return result
+  end
+  
+  #-----------------------------------------------------------------------------
+  # Utilities
+  
+  def executable(options)
+    config = Config.ensure(options)
+    
+    if config.get(:corl, false)
+      return 'corl ' + config[:corl]
+        
+    elsif config.get(:vagrant, false)
+      return 'vagrant ' + config[:vagrant]
+        
+    elsif config.get(:command, false)
+      return config[:command]
+    end
+  end  
+end
+end
+end

data/lib/corl/configuration/file.rb

@@ -0,0 +1,386 @@
+
+module CORL
+module Configuration
+class File < Plugin::Configuration
+
+  #-----------------------------------------------------------------------------
+  # Configuration plugin interface
+  
+  def normalize
+    super
+    
+    logger.info("Setting source configuration project")
+    @project = CORL.project(extended_config(:project, {
+      :directory => _delete(:directory, Dir.pwd),
+      :url       => _delete(:url),
+      :revision  => _delete(:revision)
+    }), _delete(:project_provider))
+        
+    _set(:search, Config.new)
+    _set(:router, Config.new)
+    
+    set_location(@project)
+  end
+  
+  #--- 
+  
+  def self.finalize(file_name)
+    proc do
+      logger.debug("Finalizing file: #{file_name}")
+      Util::Disk.close(file_name)
+    end
+  end
+     
+  #-----------------------------------------------------------------------------
+  # Checks
+  
+  def can_persist?
+    project.can_persist?
+  end
+      
+  #-----------------------------------------------------------------------------
+  # Property accessors / modifiers
+
+  def project
+    @project
+  end
+  
+  #---
+  
+  def search
+    _get(:search)
+  end
+  
+  #---
+  
+  def router
+    _get(:router)
+  end
+
+  #-----------------------------------------------------------------------------
+  
+  def set_location(directory)
+    if directory && directory.is_a?(CORL::Plugin::Project)
+      logger.debug("Setting source project directory from other project at #{directory.directory}")
+      project.set_location(directory.directory)
+      
+    elsif directory && directory.is_a?(String) || directory.is_a?(Symbol)
+      logger.debug("Setting source project directory to #{directory}")
+      project.set_location(directory.to_s)
+    end
+    search_files if directory
+  end
+  
+  #---
+  
+  def remote(name)
+    project.remote(name)
+  end
+  
+  #---
+  
+  def set_remote(name, location)
+    project.set_remote(name, location)
+  end
+  
+  #-----------------------------------------------------------------------------
+  # Configuration loading / saving
+    
+  def load(options = {})
+    super do |method_config, properties|
+      
+      generate_routes = lambda do |config_name, file_properties, parents = []|
+        file_properties.each do |name, value|
+          keys = [ parents, name ].flatten
+          
+          if value.is_a?(Hash) && ! value.empty?
+            generate_routes.call(config_name, value, keys)
+          else
+            router.set(keys, config_name)  
+          end
+        end
+      end
+      
+      if fetch_project(method_config)
+        search.export.each do |config_name, info|
+          provider = info[:provider]
+          file     = info[:file]
+        
+          logger.info("Loading #{provider} translated source configuration from #{file}")
+          
+          parser = CORL.translator(method_config, provider)
+          raw    = Util::Disk.read(file)    
+        
+          if parser && raw && ! raw.empty?
+            logger.debug("Source configuration file contents: #{raw}")            
+            file_properties = parser.parse(raw)
+            
+            generate_routes.call(config_name, file_properties)
+            properties.import(file_properties)
+          end         
+        end
+      end
+    end
+  end
+   
+  #---
+  
+  # properties[key...] = values
+  #
+  # to
+  # 
+  # file_data[config_name][key...] = config
+  
+  def separate    
+    file_data = Config.new
+    
+    split_config = lambda do |properties, local_router, parents = []|
+      properties.each do |name, value|
+        keys = [ parents, name ].flatten
+        
+        if value.is_a?(Hash) && ! value.empty?
+          # Nested configurations
+          if local_router.is_a?(Hash) && local_router.has_key?(name)
+            # Router and configuration values are nested
+            split_config.call(value, local_router[name], keys)
+          else
+            # Just configuration values are nested
+            if local_router.is_a?(String)
+              # We are down to a config_name router.  Inherit on down the line
+              split_config.call(value, local_router, keys)
+            else
+              # Never encountered before
+              config_name = nil
+              config_name = select_largest(router.get(parents)) unless parents.empty?
+              split_config.call(value, config_name, keys)  
+            end  
+          end
+        else
+          if local_router.is_a?(String)
+            # Router is a config_name string
+            file_data.set([ local_router, keys ].flatten, value)          
+          elsif router.is_a?(Hash)
+            # Router is a hash with sub options we have to pick from
+            config_name = select_largest(local_router)
+            file_data.set([ config_name, keys ].flatten, value)  
+          else
+            # Router is non existent
+            if config_name = select_largest(router)
+              # Pick largest router from top level
+              file_data.set([ config_name, keys ].flatten, value)
+            else
+              # Resort to sane defaults
+              default_provider = Manager.connection.type_default(:translator)
+              config_name      = "corl.#{default_provider}"
+              file_data.set([ config_name, keys ].flatten, value)
+            end      
+          end
+        end        
+      end
+    end
+    
+    # Whew!  Glad that's over...
+    
+    split_config.call(config.export, router.export)
+    file_data     
+  end
+  protected :separate
+  
+  #---
+    
+  def save(options = {})
+    super do |method_config|
+      config_files = []
+      success      = true
+      
+      separate.export.each do |config_name, router_data|
+        info     = search[config_name]
+        provider = info[:provider]
+        file     = info[:file]
+        
+        if renderer = CORL.translator(method_config, provider)
+          rendering = renderer.generate(router_data)
+          
+          if Util::Disk.write(file, rendering)
+            config_files << config_name
+          else
+            success = false
+          end
+        else
+          success = false
+        end
+        break unless success        
+      end
+      if success && ! config_files.empty?
+        commit_files = [ config_files, method_config.get_array(:files) ].flatten
+          
+        logger.debug("Source configuration rendering: #{rendering}")        
+        success = update_project(commit_files, method_config)
+      end
+      success
+    end
+  end
+  
+  #---
+  
+  def remove(options = {})
+    super do |method_config|
+      success      = true
+      config_files = [] 
+      search.each do |config_name, info|
+        config_files << info[:file]
+        success = false unless Util::Disk.delete(info[:file])
+      end
+      success = update_project(config_files, method_config) if success
+      success
+    end
+  end
+  
+  #---
+  
+  def attach(type, name, data, options = {})
+    super do |method_config|
+      attach_path = Util::Disk.filename([ project.directory, type.to_s ])
+      success     = true
+      
+      begin
+        FileUtils.mkdir_p(attach_path) unless Dir.exists?(attach_path)
+      
+      rescue Exception => error
+        alert(error.message)
+        success = false
+      end
+      
+      if success
+        case method_config.get(:type, :source)
+        when :source
+          new_file = project.local_path(Util::Disk.filename([ attach_path, name ])) 
+        
+          logger.debug("Attaching source data (length: #{data.length}) to configuration at #{attach_path}")        
+          success = Util::Disk.write(new_file, data)
+          
+        when :file  
+          file       = ::File.expand_path(data)
+          attach_ext = ::File.basename(file)
+          new_file   = project.local_path(Util::Disk.filename([ attach_path, "#{name}-#{attach_ext}" ])) 
+              
+          logger.debug("Attaching file #{file} to configuration at #{attach_path}")       
+      
+          begin
+            FileUtils.mkdir_p(attach_path) unless Dir.exists?(attach_path)
+            FileUtils.cp(file, new_file)
+          
+          rescue Exception => error
+            alert(error.message)
+            success = false
+          end  
+        end
+      end
+      if success
+        logger.debug("Attaching data to project as #{new_file}")
+        success = update_project(new_file, method_config)
+      end
+      success ? new_file : nil
+    end
+  end
+  
+  #-----------------------------------------------------------------------------
+  # Utilities
+   
+  def search_files
+    if Util::Data.empty?(project.directory)
+      logger.debug("Clearing configuration file information")      
+      search.clear
+    else
+      file_bases = [ "corl", extension_collect(:base) ].flatten
+      
+      Manager.connection.loaded_plugins(:translator).each do |provider, info|
+        file_bases.each do |file_base|
+          config_name = "#{file_base}.#{provider}"
+          file        = Util::Disk.filename([ project.directory, config_name ])
+          
+          if Util::Disk.exists?(file)            
+            search[config_name] = {
+              :provider => provider,
+              :info     => info,
+              :file     => file
+            }
+            ObjectSpace.define_finalizer(myself, myself.class.finalize(file))
+          else
+            logger.info("Configuration file #{file} does not exist")   
+          end
+        end
+      end     
+      logger.debug("Setting configuration file information to #{search.inspect}")
+    end
+    load(_export) if autoload
+  end
+  protected :search_files
+  
+  #---
+  
+  def fetch_project(options = {})
+    config  = Config.ensure(options)
+    success = true
+    if remote = config.get(:remote, nil)
+      logger.info("Pulling configuration updates from remote #{remote}")
+      success = project.pull(remote, config) if config.get(:pull, true)   
+    end
+    success
+  end
+  protected :fetch_project
+  
+  #---
+  
+  def update_project(files = [], options = {})
+    config  = Config.ensure(options)
+    success = true
+    
+    commit_files = '.'
+    commit_files = array(files).flatten unless files.empty?
+          
+    logger.info("Committing changes to configuration files")        
+    success = project.commit(commit_files, config)
+          
+    if success && remote = config.get(:remote, nil)
+      logger.info("Pushing configuration updates to remote #{remote}")
+      success = project.pull(remote, config) if config.get(:pull, true)
+      success = project.push(remote, config) if success && config.get(:push, true)      
+    end
+    success
+  end
+  protected :update_project
+  
+  #---
+  
+  def select_largest(router)
+    config_map = {}
+    
+    count_config_names = lambda do |data|
+      data = data.export if data.is_a?(CORL::Config)
+      data.each do |name, value|
+        if value.is_a?(Hash)
+          count_config_names.call(value)
+        else
+          config_map[value] = 0 unless config_map.has_key?(value)
+          config_map[value] = config_map[value] + 1
+        end
+      end
+    end
+    
+    config_name   = nil
+    config_weight = nil
+    
+    count_config_names.call(router)
+    config_map.each do |name, weight|
+      if config_name.nil? || weight > config_weight
+        config_name   = name
+        config_weight = weight
+      end  
+    end
+    config_name
+  end
+  protected :select_largest
+end
+end
+end

data/lib/corl/event/puppet.rb

@@ -0,0 +1,90 @@
+
+module CORL
+module Event
+class Puppet < Plugin::Event
+  
+  #-----------------------------------------------------------------------------
+  # Puppet event interface
+  
+  def normalize
+    super
+    
+    if get(:string)
+      items          = string(delete(:string)).split(':')
+      myself.element   = items[0]
+      myself.operation = items[1]
+      myself.message   = items[2]
+    end
+  end
+    
+  #-----------------------------------------------------------------------------
+  # Property accessors / modifiers
+  
+  def element(default = '')
+    return get(:element, default, :string)
+  end
+  
+  #---
+ 
+  def element=element
+    set(:element, string(element))
+  end
+  
+  #---
+  
+  def operation(default = '')
+    return get(:operation, default, :string)
+  end
+  
+  #---
+   
+  def operation=operation
+    set(:operation, string(operation))
+  end
+  
+  #--
+  
+  def message(default = '')
+    return get(:message, default, :string)
+  end
+  
+  #---
+   
+  def message=message
+    set(:message, string(message))
+  end
+  
+  #-----------------------------------------------------------------------------
+  # Operations
+  
+  def render
+    return "#{name}:#{element}:#{operation}:#{message}"
+  end
+  
+  #---
+  
+  def check(source)
+    if source.match(/notice:\s+(.+?):\s+(.+)\s*/i)
+      source_element   = $1
+      source_operation = ''
+      source_message   = $2
+                    
+      source_elements  = source_element.split('/')
+      source_operation = source_elements.pop.strip unless source_elements.last.match(/[\[\]]/)
+                    
+      if source_operation
+        source_element = source_elements.join('/').strip
+        success        = ( source_element.include?(element) && source_operation == operation && source_message.include?(message) )
+        
+        logger.debug("Checking puppet event with source #{source_element} #{source_operation} #{source_message}: #{success.inspect}")
+        
+        return success
+      else
+        logger.warn("Can not check puppet event because it is missing an operation")
+      end
+    end
+    return false
+  end
+end
+end
+end

data/lib/corl/event/regex.rb

@@ -0,0 +1,52 @@
+
+module CORL
+module Event
+class Regex < Plugin::Event
+ 
+  #-----------------------------------------------------------------------------
+  # Regular expression event interface
+  
+  def normalize
+    super
+    
+    if get(:string)
+      myself.pattern = delete(:string)
+    end
+  end
+      
+  #-----------------------------------------------------------------------------
+  # Property accessors / modifiers
+  
+  def pattern(default = '')
+    return get(:pattern, default)
+  end
+  
+  #---
+   
+  def pattern=pattern
+    set(:pattern, string(pattern))  
+  end
+  
+  #-----------------------------------------------------------------------------
+  # Operations
+  
+  def render
+    return "#{name}:#{pattern}"
+  end
+  
+  #---
+   
+  def check(source)
+    if pattern.empty?
+      logger.warn("Can not check regex pattern because it is empty")
+    else
+      success = source.match(/#{pattern}/)
+      
+      logger.debug("Checking regex event with pattern #{pattern}: #{success.inspect}")
+      return success
+    end
+    return true
+  end
+end
+end
+end

data/lib/corl/extension/puppetloader.rb

@@ -0,0 +1,24 @@
+
+module CORL
+module Extension
+class Puppetloader < Plugin::Extension
+
+  def register_plugins(config)
+    connection  = Manager.connection
+    provisioners = connection.plugins(:provisioner, :puppetnode)
+    provisioner  = provisioners.empty? ? nil : provisioners[provisioners.keys.first]
+  
+    if provisioner
+      # Register Puppet CORL extensions
+      provisioner.env.modules.each do |mod|
+        lib_dir = File.join(mod.path, 'lib', 'corl')
+        if File.directory?(lib_dir)
+          logger.debug("Registering Puppet module at #{lib_dir}")
+          connection.register(lib_dir)
+        end
+      end
+    end
+  end      
+end
+end
+end