puppet_generator 0.5.4

data/lib/puppet_generator/middleware/execute_actions.rb

@@ -0,0 +1,34 @@
+module PuppetGenerator
+  module Middleware
+    class ExecuteActions
+
+      def initialize(app)
+        @app = app
+      end
+
+      def call(task)
+        PuppetGenerator.logger.debug(self.class.name){ "Execute action \"#{task.meta[:requested_actions].join(", ")}\" on output." }
+
+        task.body = execute_actions( task.meta[:requested_actions] , task )
+
+        @app.call(task)
+      end
+
+      private
+
+      def execute_actions(actions, task)
+
+        module_name = task.meta[:module]
+        data = task.body
+
+        actions.inject(data) do |data,action|
+          active_action = Models::Action.find action
+          raise Exceptions::UnknownAction unless active_action
+
+          data = active_action.run( task , data )
+        end
+      end
+
+    end
+  end
+end

data/lib/puppet_generator/middleware/filter_imported_data.rb

@@ -0,0 +1,22 @@
+module PuppetGenerator
+  module Middleware
+    class FilterImportedData
+
+      def initialize(app)
+        @app = app
+      end
+
+      def call(task)
+        PuppetGenerator.logger.debug(self.class.name){ "Filter the input with filter \"#{task.meta[:requested_import_filter]}\"" }
+
+        active_filter = Models::ImportFilter.find task.meta[:requested_import_filter]
+        raise Exceptions::UnknownImportFilter unless active_filter
+
+        task.body = active_filter.convert(task.body)
+
+        @app.call(task)
+      end
+
+    end
+  end
+end

data/lib/puppet_generator/middleware/handle_errors.rb

@@ -0,0 +1,62 @@
+module PuppetGenerator
+  module Middleware
+    class HandleErrors
+      def initialize(app)
+        @app = app
+      end
+
+      def call(t)
+        @task = t
+
+        PuppetGenerator.logger.debug(self.class.name){ "Waiting for errors to occure. ;-)" }
+
+        begin
+          @app.call(task)
+        rescue PuppetGenerator::Exceptions::InvalidSource
+          exit_with_error :invalid_source, source: task.meta[:source], command: task.meta[:command] 
+        rescue PuppetGenerator::Exceptions::InvalidOutputChannel
+          exit_with_error :invalid_output_channel
+        rescue PuppetGenerator::Exceptions::EmptySource
+          exit_with_error :empty_source, source: task.meta[:source]
+        rescue PuppetGenerator::Exceptions::UnknownImportFilter
+          exit_with_error :unknown_import_filter, requested_import_filter: task.meta[:requested_import_filter], 
+                                                  available_import_filter: Models::ImportFilter.all_names_as_string
+        rescue PuppetGenerator::Exceptions::InvalidYamlInput
+          exit_with_error :invalid_yaml_input
+        rescue PuppetGenerator::Exceptions::InvalidPasswdInput
+          exit_with_error :invalid_passwd_input
+        rescue PuppetGenerator::Exceptions::UnknownAction
+          exit_with_error :unknown_action, requested_actions: task.meta[:requested_actions], 
+                                           available_actions: Models::Action.all_names_as_string
+        rescue PuppetGenerator::Exceptions::FilesystemError
+          exit_with_error :filesystem_error, fs_object: task.meta[:source]
+        rescue PuppetGenerator::Exceptions::WrongTemplateChosen
+          exit_with_error :wrong_template_chosen, command: task.meta[:command], tags: task.meta[:template_tagged_with].to_a.join(", "), destination: task.meta[:destination] 
+        rescue PuppetGenerator::Exceptions::InternalError => e
+          exit_with_error :internal_error, exception_message: e.message
+        rescue Interrupt
+          exit_with_error :interrupt
+        end
+      end
+
+      private 
+
+      attr_reader :task
+
+      def exit_with_error(name, parameter={})
+        msg = Models::ErrorMessage.find(name)
+        raise Exceptions::UnknownErrorMessage unless msg
+
+        PuppetGenerator.logger.fatal msg.text(parameter)
+        exit msg.code
+      end
+
+      def postscript
+      end
+
+      def option_to_output(option)
+        option.keys.join(", ")
+      end
+    end
+  end
+end

data/lib/puppet_generator/middleware/output_debug_information_for_models.rb

@@ -0,0 +1,21 @@
+module PuppetGenerator
+  module Middleware
+    class OutputDebugInformationForModels
+      def initialize(app)
+        @app = app
+      end
+
+      def call(task)
+
+        PuppetGenerator.logger.debug(self.class.name){ "Available importer: " +  Models::Importer.all_names_as_string }
+        PuppetGenerator.logger.debug(self.class.name){ "Available templates: " +  Models::Template.all_names_as_string }
+        PuppetGenerator.logger.debug(self.class.name){ "Available import filter: " +  Models::ImportFilter.all_names_as_string }
+        PuppetGenerator.logger.debug(self.class.name){ "Available export filter: " +  Models::ExportFilter.all_names_as_string }
+        PuppetGenerator.logger.debug(self.class.name){ "Available actions: " +  Models::Action.all_names_as_string }
+
+        @app.call(task)
+      end
+
+    end
+  end
+end

data/lib/puppet_generator/middleware/read_input.rb

@@ -0,0 +1,27 @@
+module PuppetGenerator
+  module Middleware
+    class ReadInput
+
+      def initialize(app)
+        @app = app
+      end
+
+      def call(task)
+        PuppetGenerator.logger.debug(self.class.name){ "Read data from input \"#{task.meta[:source]}\"." }
+
+        raise Exceptions::FilesystemError unless PuppetGenerator::Models::Importer.existing_source?(task.meta[:source].to_s)
+        raise Exceptions::InvalidSource   unless PuppetGenerator::Models::Importer.valid_source?(task.meta[:source].to_s)
+
+        importer = PuppetGenerator::Models::Importer.find( reads_from: task.meta[:source].to_s, enabled: true )
+        raise PuppetGenerator::Exceptions::InvalidSource unless importer 
+        PuppetGenerator.logger.debug(self.class.name){ "Using importer \"#{importer.name}\" to read data." }
+
+        task.body = importer.read( task.meta[:source] )
+        PuppetGenerator.logger.debug(self.class.name) { "Count input lines: #{task.body.size}" }
+
+        @app.call(task)
+      end
+
+    end
+  end
+end

data/lib/puppet_generator/models/action.rb

@@ -0,0 +1,36 @@
+module PuppetGenerator
+  module Models
+    # model for import action
+    class Action < FeduxOrg::Stdlib::Models::BaseModel
+
+      include FeduxOrg::Stdlib::Models::FilesystemBasedModel
+      include FeduxOrg::Stdlib::Models::ClassBasedModel
+
+      extend Forwardable
+
+      #@!method convert
+      #   converts an object using the convert method of 
+      #   the stored action
+      def_delegator :@action, :run, :run
+
+      #create new instance of action model
+      def initialize( name , action )
+        super(name)
+
+        @action = action
+      end
+
+      class << self
+        private
+
+        def check_method
+          :run
+        end
+
+        def path
+          __FILE__
+        end
+      end
+    end
+  end
+end

data/lib/puppet_generator/models/base.rb

@@ -0,0 +1,115 @@
+module PuppetGenerator
+  module Models
+    class Base
+
+      include Comparable
+
+      @instances = ::Set.new
+
+      attr_reader :name
+
+      def self.inherited(base)
+        base.instance_variable_set(:@instances, Set.new)
+      end
+
+      def initialize(name)
+        @name = name.to_sym
+        @enabled = false
+      end
+
+      #enable action
+      def enable
+        @enabled = true
+      end
+
+      #check if action is enabled
+      def enabled?(val=true)
+        @enabled == val
+      end
+
+      def name?(name)
+        @name == name
+      end
+
+      def <=>(other)
+        name <=> other.name
+      end
+
+      def eql?(other)
+        name == other.name
+      end
+
+      class << self
+        #attr_accessor :instances
+
+        def register(element)
+          @instances << element
+
+          element
+        end
+
+        def create( *args, &block )
+          if block_given?
+            register( new( *args, &block ) )
+          else
+            register( new( *args ) )
+          end
+        end
+
+        def find( val )
+          @instances.find { |i| i.name == val.to_s.to_sym }
+        end
+
+        def delete( val )
+          element = find( val.to_s.to_sym )
+          raise Exceptions::InstanceNotFound unless element
+          @instances.delete element
+
+          element
+        end
+
+        def clear
+          @instances = Set.new
+        end
+
+        def all
+          @instances.to_a
+        end
+
+        #return all names as string
+        def all_names_as_string(connector=", ")
+          find_all(enabled: true).map(&:name).sort.join(connector)
+        end
+
+        #enables a specific instance
+        def enable(name)
+          find(name: name).enable
+        end
+
+        #finds a single instance
+        def find( criteria={} )
+          find_all( criteria ).first
+        end
+
+        #finds all instances
+        def find_all( criteria={} )
+          PuppetGenerator::Models.logger.debug(self) { "Criteria for search: #{ criteria }" }
+          criteria = { name: criteria.to_sym } if criteria.kind_of? Symbol or criteria.kind_of? String
+
+          PuppetGenerator::Models.logger.debug(self) { "Instances to be searched for: #{ @instances.map { |i| "#{i.name} (#{i.class})" }.join(", ") }" }
+          @instances.find_all do |i| 
+            criteria.all? do |c,v|
+
+              PuppetGenerator::Models.logger.debug(self) { "Check method for search: #{ c }" }
+              i.send( "#{c}?".to_sym , v )
+            end
+          end
+
+        rescue NameError => e
+          raise Exceptions::InvalidSearchCriteria, e.message
+        end
+      end
+
+    end
+  end
+end

data/lib/puppet_generator/models/class_based_model.rb

@@ -0,0 +1,56 @@
+module PuppetGenerator
+  module Models
+    # model for import action
+    module ClassBasedModel
+
+      def self.included(base)
+        base.extend ClassMethods
+      end
+
+      module ClassMethods
+
+        def require_path(name)
+          File.join( PuppetGenerator.gem_load_path, model_name.pluralize.underscore , name.to_s )
+        end
+
+        def exception_for_model
+          "PuppetGenerator::Exceptions::Invalid#{model_name.singularize}".constantize
+        rescue
+          raise Exceptions::ExceptionNeedsToBeImplemented, "Exception \"Exceptions::Invalid#{model_name}\" does not exist."
+        end
+
+        def check_klass( klass , method)
+          raise exception_for_model, "A valid \"#{model_name}\"-class needs to respond to \"#{ method }\"." unless klass.new.respond_to? method
+        end
+
+        def build_class_constant(name)
+          "PuppetGenerator::#{model_name.pluralize}::#{name.to_s.camelcase}".constantize
+        rescue
+          raise exception_for_model , "The filename needs to be snakecase and needs to be convertible to the action class name: filename in camelcase."
+        end
+
+        def check_method
+          raise Exceptions::MethodNeedsToBeImplemented, "Method \"check_method\" does not exist."
+        end
+
+        def suffix
+          '.rb'
+        end
+
+        def load_from_filesystem
+          files = Dir.glob( path_to_instances )
+
+          files.each do |f| 
+            instance_name = name( f )
+
+            require require_path( instance_name )
+
+            instance_klass = build_class_constant( instance_name )
+            check_klass( instance_klass, check_method )
+            create( instance_name , instance_klass.new )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/puppet_generator/models/entry_converter.rb

@@ -0,0 +1,39 @@
+module PuppetGenerator
+  module Models
+    # model for entry converter filter
+    class EntryConverter < FeduxOrg::Stdlib::Models::BaseModel
+
+      include FeduxOrg::Stdlib::Models::FilesystemBasedModel
+      include FeduxOrg::Stdlib::Models::ClassBasedModel
+
+      extend Forwardable
+
+      #@!method convert
+      #   converts an object using the convert method of 
+      #   the stored filter
+      def_delegator :@converter, :convert, :convert
+
+      #create new instance of filter model
+      def initialize( name , converter )
+        super(name)
+
+        @converter = converter
+      end
+
+      class << self
+
+        private
+
+        def check_method
+          :convert
+        end
+
+        def path
+          __FILE__
+        end
+
+      end
+
+    end
+  end
+end

data/lib/puppet_generator/models/error_message.rb

@@ -0,0 +1,60 @@
+module PuppetGenerator
+  module Models
+    class ErrorMessage < Base
+
+      attr_accessor :preambel, :postscript, :code
+      class << self
+        attr_accessor :preambel, :postscript
+
+        def reset
+          self.clear
+
+          self.preambel = nil
+          self.postscript = nil
+        end
+
+        def init
+          Models::ErrorMessage.preambel = "Sorry, but I can't fullfill your request. "
+          Models::ErrorMessage.postscript = "\n\n=================\nPlease read the manual on \"http://github.com/maxmeyer/puppet_generator\" for more information on how to use the script."
+
+          Models::ErrorMessage.create :invalid_source,         1, "You entered an invalid source \"<%= @source %>\": it's not possible to use this source with \"<%= @command %>."
+          Models::ErrorMessage.create :invalid_output_channel, 2, "You entered an invalid output channel: file or directory can be used."
+          Models::ErrorMessage.create :empty_source,           3, "The source \"<%= @source %>\" you tell me to use does not contain any entries. Giving up."
+          Models::ErrorMessage.create :unknown_import_filter,  4, "There's no import filter \"<%= @requested_import_filter %>\". Available import filters: <%= @available_import_filter %>."
+          Models::ErrorMessage.create :invalid_yaml_input,     5, "The input is no YAML valid for this use case."
+          Models::ErrorMessage.create :invalid_passwd_input,   6, "The input is no passwd file valid for this use case."
+          Models::ErrorMessage.create :unknown_action,         7, "There's no action \"<%= @requested_actions %>\". Available actions: <%= @available_actions %>."
+          Models::ErrorMessage.create :filesystem_error,       8, "The file/directory \"<%= @fs_object %>\" does not exist."
+          Models::ErrorMessage.create :wrong_template_chosen,  9, "I was not able to find a suitable template for the given command \"<%= @command %>\", for the given tags \"<%= @tags %>\" and for the given destination \"<%= @destination %>\"."
+          Models::ErrorMessage.create :interrupt,  98, "You pressed \"CTRL-C\". Exiting."
+
+          m = Models::ErrorMessage.create :internal_error,         99, "Sorry, an internal error occured. This should not happen. Please send a bug report to the author and add the following output to that report:\n\n<%= @exception_message %>"
+          m.postscript = "\n\n=================\nPlease go to \"http://github.com/maxmeyer/puppet_generator\" to open the bug report. Thank you very much."
+
+        end
+      end
+
+      def initialize(name, code, template)
+        super(name)
+
+        @code = code
+        @template = template
+      end
+
+      def text(options={})
+        result = []
+        result << ( preambel ? preambel : self.class.preambel )
+        result << Erubis::Eruby.new(@template).evaluate(options)
+        result << ( postscript ? postscript : self.class.postscript )
+
+        result.join
+      end
+
+      private
+
+      def self.path
+        __FILE__
+      end
+    end
+  end
+end

data/lib/puppet_generator/models/export_filter.rb

@@ -0,0 +1,44 @@
+module PuppetGenerator
+  module Models
+    # model for import filter
+    class ExportFilter < FeduxOrg::Stdlib::Models::BaseModel
+
+      include FeduxOrg::Stdlib::Models::FilesystemBasedModel
+      include FeduxOrg::Stdlib::Models::ClassBasedModel
+
+      extend Forwardable
+
+      #@!method convert
+      #   converts an object using the convert method of 
+      #   the stored filter
+      def_delegator :@filter, :convert, :convert
+
+      public
+
+      #create new instance of filter model
+      def initialize( name , filter )
+        super(name)
+
+        @filter = filter
+      end
+
+      class << self
+        private
+
+        def check_method
+          :convert
+        end
+
+        def forbidden_keywords
+          [ :enabled ]
+        end
+
+        def path
+          __FILE__
+        end
+
+      end
+
+    end
+  end
+end

data/lib/puppet_generator/models/exporter.rb

@@ -0,0 +1,51 @@
+module PuppetGenerator
+  module Models
+    # model for import filter
+    class Exporter < FeduxOrg::Stdlib::Models::BaseModel
+
+      include FeduxOrg::Stdlib::Models::FilesystemBasedModel
+      include FeduxOrg::Stdlib::Models::ClassBasedModel
+
+      extend Forwardable
+
+      #@!method convert
+      #   converts an object using the convert method of 
+      #   the stored filter
+      def_delegator :@exporter, :write, :write
+      def_delegator :@exporter, :writes_to?, :writes_to?
+
+      #create new instance of filter model
+      def initialize( name , exporter )
+        super(name)
+
+        @exporter = exporter
+      end
+
+      class << self
+
+        def existing_destination?(destination)
+          return true if File.exists? destination
+
+          false
+        end
+
+        def valid_destination?(destination)
+          return true if find( writes_to: destination, enabled: true )
+
+          false
+        end
+
+        private
+
+        def check_method
+          :write
+        end
+
+        def path
+          __FILE__
+        end
+      end
+
+    end
+  end
+end

data/lib/puppet_generator/models/filesystem_based_model.rb

@@ -0,0 +1,63 @@
+module PuppetGenerator
+  module Models
+    # model for import action
+    module FilesystemBasedModel
+
+      def self.included(base)
+        base.extend ClassMethods
+      end
+
+      module ClassMethods
+
+        #initialize model
+        def init
+          load_from_filesystem
+        end
+
+        private
+
+        def module_name
+          name = fqcn
+          name.pop
+
+          name.join('::')
+        end
+
+        def fqcn
+          self.to_s.split(/::/)
+        end
+
+        def model_name
+          fqcn.last
+        end
+
+        def suffix
+          raise Exceptions::MethodNeedsToBeImplemented
+        end
+
+        def path_to_instances
+          path = File.expand_path("../../#{model_name.pluralize.underscore}", __FILE__ )
+
+          File.join(path,"*#{suffix}")
+        end
+
+        def name(path)
+          name = File.basename(path, suffix ).to_sym
+          raise Exceptions::UnauthorizedUseOfKeyword if forbidden_keywords.include? name
+
+          name
+        end
+
+        def load_from_filesystem
+          raise Exceptions::MethodNeedsToBeImplemented
+        end
+
+        def forbidden_keywords
+          [ ]
+        end
+
+      end
+
+    end
+  end
+end

data/lib/puppet_generator/models/import_filter.rb

@@ -0,0 +1,44 @@
+module PuppetGenerator
+  module Models
+    # model for import filter
+    class ImportFilter < FeduxOrg::Stdlib::Models::BaseModel
+
+      include FeduxOrg::Stdlib::Models::FilesystemBasedModel
+      include FeduxOrg::Stdlib::Models::ClassBasedModel
+
+      extend Forwardable
+
+      #@!method convert
+      #   converts an object using the convert method of 
+      #   the stored filter
+      def_delegator :@filter, :convert, :convert
+
+      public
+
+      #create new instance of filter model
+      def initialize( name , filter )
+        super(name)
+
+        @filter = filter
+      end
+
+      class << self
+        private
+
+        def check_method
+          :convert
+        end
+
+        def forbidden_keywords
+          [ :enabled ]
+        end
+
+        def path
+          __FILE__
+        end
+
+      end
+
+    end
+  end
+end