puppet_generator 0.5.4

data/lib/puppet_generator/exceptions.rb

@@ -0,0 +1,104 @@
+module PuppetGenerator
+  module Exceptions
+    # exceptions raise because of a wrong usage by the user
+    class UserError < Exception; end
+    
+    #raise if a file does not exist in filesystem
+    class WrongTemplateChosen < UserError; end
+
+    #raised if source is not a directory, file etc.
+    class InvalidSource < UserError; end
+
+    #raised if output channel is not directory, file etc.
+    class InvalidOutputChannel < UserError; end
+
+    #raised if template can not be found
+    class TemplateNotFound < UserError; end
+    
+    #raised if something goes wrong internally
+    #should never happend
+    class InternalError < Exception; end
+    
+    #raised if source is empty
+    class EmptySource < UserError; end
+    
+    #raised if an unknown input filter was
+    #requested by the user
+    class UnknownImportFilter < UserError; end
+   
+    #raised if an unknown export filter was
+    #requested by the user
+    class UnknownExportFilter < UserError; end
+    
+    #raised if an unknown action was
+    #requested by the user
+    class UnknownAction < UserError; end
+    
+    #raised if an error happened during decoding of yaml
+    class InvalidYamlInput < UserError; end
+    
+    #raised if an error happened during decoding of passwd
+    class InvalidPasswdInput < UserError; end
+    
+    #raised if an error happened during copying files
+    class ErrorDuringCopyFiles < UserError; end
+    
+    #raised if one tries to delete an instance which
+    #does not exist
+    class InstanceNotFound < InternalError; end
+    
+    #raised if one tries to use an unknown error
+    #message
+    class UnknownErrorMessage < InternalError; end
+
+    #raised if one tries to use a keyword whose use
+    #is restricted
+    class UnauthorizedUseOfKeyword < InternalError; end
+
+    #raised if one uses invalid search criteria
+    class InvalidSearchCriteria < InternalError; end
+    
+    #raised if one uses an invalid template
+    class InvalidTemplate < InternalError; end
+    
+    #raised if one uses an invalid action
+    class InvalidAction < InternalError; end
+    
+    #raised if the code which defines an import filter
+    #which is malformed
+    class InvalidImportFilter < InternalError; end
+    
+    #raised if the code which defines an import filter
+    #which is malformed
+    class InvalidExportFilter < InternalError; end
+    
+    #raised if the code which defines an importer
+    #which is malformed
+    class InvalidImporter < InternalError; end
+    
+    #raised if the code which defines an exporter
+    #which is malformed
+    class InvalidExporter < InternalError; end
+    
+    #raised if the code which defines an entry converter
+    #which is malformed
+    class InvalidEntryConverter < InternalError; end
+    
+    #raised if the code which defines an import filter
+    #is malformed
+    class MethodNeedsToBeImplemented < InternalError; end
+    
+    #raised if one tries to use an unimplemented exception
+    class ExceptionNeedsToBeImplemented < InternalError; end
+
+    #raised if an file system error occured
+    class FilesystemError < Exception ; end
+
+    #raise if a directory does not exist in filesystem
+    class DirectoryDoesNotExist < FilesystemError; end
+    
+    #raise if a file does not exist in filesystem
+    class FileDoesNotExist < FilesystemError; end
+
+  end
+end

data/lib/puppet_generator/export_filters/build_role_includes_for_directory.rb

@@ -0,0 +1,35 @@
+module PuppetGenerator
+  module ExportFilters
+    class BuildRoleIncludesForDirectory
+
+      include PuppetHelper
+
+      def convert(objects)
+
+        objects.collect do |o|
+          path = o[:name]
+
+          next unless directory? path
+
+          result = {
+            name: path,
+            includes: includes(path),
+          }
+        end.compact
+
+      end
+
+      private
+
+      def includes(path)
+        Dir.glob( File.join( path, '*.pp' ) ).collect { |f| File.basename( f, '.pp') }.sort
+      rescue
+        PuppetGenerator.logger.warn(self.class.name) { "Directory \"#{o[:name]}\" does not exist. There's no chance to get subentries for it. Therefor I use the name only and do not generate \"include\"-instructions." }
+      end
+
+      def directory?(path)
+        FileTest.directory? path
+      end
+    end
+  end
+end

data/lib/puppet_generator/export_filters/filesystem_attributes.rb

@@ -0,0 +1,57 @@
+module PuppetGenerator
+  module ExportFilters
+    class FilesystemAttributes
+      def convert(objects)
+
+        objects.collect do |o|
+          path = o[:name]
+
+          if File.exists? path
+            fs_object_info = stats(path)
+
+            o.merge!( { 
+              type: type(path),
+              owner: owner(fs_object_info),
+              mode: mode(fs_object_info),
+            } )
+          end
+
+          o
+        end
+
+      end
+
+      private
+
+      def stats(path)
+        File::Stat.new(path) 
+      end
+
+      def mode(fs_object_info)
+        "%o" % fs_object_info.mode
+      end
+
+      def owner(fs_object_info)
+        Etc.getpwuid(fs_object_info.uid).name
+      end
+
+      def type(path)
+        if file?(path)
+          return 'file'
+        elsif directory?(path)
+          return 'directory'
+        else
+          return 'file'
+        end
+      end
+
+      def file?(path)
+        FileTest.file? path
+      end
+
+      def directory?(path)
+        FileTest.directory? path
+      end
+    end
+  end
+end

data/lib/puppet_generator/export_filters/null.rb

@@ -0,0 +1,9 @@
+module PuppetGenerator
+  module ExportFilters
+    class Null
+      def convert(objects)
+        objects
+      end
+    end
+  end
+end

data/lib/puppet_generator/exporters/directory.rb

@@ -0,0 +1,23 @@
+module PuppetGenerator
+  module Exporters
+    class Directory
+
+      def write(directory, definitions=[])
+        ::Dir.mkdir directory unless ::Dir.exists? directory
+
+        definitions.each do |d| 
+          filename = ::File.join( directory, "#{d.file_name}" )
+
+          ::File.open(filename, "w") do |f|
+            f.puts d.text
+          end
+        end
+      end
+
+      def writes_to?(destination)
+        /^(?:dir|directory):/ === destination
+      end
+
+    end
+  end
+end

data/lib/puppet_generator/exporters/file.rb

@@ -0,0 +1,17 @@
+module PuppetGenerator
+  module Exporters
+    class File
+
+      def write(filename, definitions)
+        ::File.open(filename, "w") do |f|
+          definitions.each { |d| f.puts d.text }
+        end
+      end
+
+      def writes_to?(destination)
+        /^file:/ === destination
+      end
+
+    end
+  end
+end

data/lib/puppet_generator/exporters/stdout.rb

@@ -0,0 +1,16 @@
+module PuppetGenerator
+  module Exporters
+    class Stdout
+
+      def write( output=$stdout , definitions=[] )
+        output = definitions.inject( [] ) { |strings, definition| strings << definition.text }
+        printf "%s", output.join("\n")
+      end
+
+      def writes_to?(destination)
+        /^stdout/ === destination
+      end
+
+    end
+  end
+end

data/lib/puppet_generator/import_filters/null.rb

@@ -0,0 +1,9 @@
+module PuppetGenerator
+  module ImportFilters
+    class Null
+      def convert(lines)
+        lines.collect { |line| { name: line.strip } }
+      end
+    end
+  end
+end

data/lib/puppet_generator/import_filters/passwd.rb

@@ -0,0 +1,22 @@
+module PuppetGenerator
+  module ImportFilters
+    class Passwd
+      def convert(lines)
+        lines.collect do |line|
+          passwd = line.split(/:/)
+          raise Exceptions::InvalidPasswdInput if passwd.size < 7
+
+          (username,_,uid,gid,_,homedir,shell) = passwd
+
+          { 
+            name: username,
+            userid: uid,
+            groupid: gid,
+            homedir: homedir,
+            shell: shell,
+          }
+        end
+      end
+    end
+  end
+end

data/lib/puppet_generator/import_filters/yaml.rb

@@ -0,0 +1,20 @@
+module PuppetGenerator
+  module ImportFilters
+    class Yaml
+      def convert(lines)
+        hash_keys_from_str_to_sym(Psych.load(lines.join("\n")))
+      end
+
+      private
+
+      def hash_keys_from_str_to_sym(hash)
+        hash.inject([]) do |result,(name,attributes)|
+          result << attributes.inject( { name: name} ) { |result, (k,v)| result[k.to_sym] = v; result }
+        end
+      rescue Exception => e
+        raise Exceptions::InvalidYamlInput, e.message
+      end
+
+    end
+  end
+end

data/lib/puppet_generator/importers/directory.rb

@@ -0,0 +1,21 @@
+module PuppetGenerator
+  module Importers
+    class Directory
+      attr_reader :lines
+
+      def read( directory )
+        lines = []
+        ::Find.find( directory ) { |path| lines << path }
+
+        lines
+      rescue Exception => e
+        raise Exceptions::DirectoryDoesNotExist, e.message
+      end
+
+      def reads_from?(source)
+        FileTest.directory? source
+      end
+
+    end
+  end
+end

data/lib/puppet_generator/importers/file.rb

@@ -0,0 +1,17 @@
+module PuppetGenerator
+  module Importers
+    class File
+
+      def read(filename)
+        ::File.open(filename).readlines.collect { |l| l.chomp }
+      rescue Exception => e
+        raise Exceptions::FileDoesNotExist, e.message
+      end
+
+      def reads_from?(source)
+        FileTest.file? source
+      end
+
+    end
+  end
+end

data/lib/puppet_generator/importers/stdin.rb

@@ -0,0 +1,16 @@
+module PuppetGenerator
+  module Importers
+    class Stdin
+      attr_reader :lines
+
+      def read( input )
+        $stdin.readlines.collect { |l| l.strip.chomp }
+      end
+
+      def reads_from?(source)
+        source == 'stdin'
+      end
+
+    end
+  end
+end

data/lib/puppet_generator/logger.rb

@@ -0,0 +1,62 @@
+class ::Logger
+  SILENT = 9999 unless defined? SILENT
+end
+
+module PuppetGenerator
+  class Logger
+
+    extend ::Forwardable
+    def_delegators :@logger, :fatal, :warn, :debug, :info, :error, :unknown
+
+    attr_reader :mode
+
+    def initialize
+      @logger = ::Logger.new($stderr)
+      self.mode = :info
+    end
+
+    def mode=(m)
+      @mode = m
+
+      case m
+      when :debug
+        @logger.level = ::Logger::DEBUG
+        format_debug
+      when :silent
+        @logger.level = ::Logger::SILENT
+      when :info
+        @logger.level = ::Logger::INFO
+        format_standard
+      else
+        @logger.level = ::Logger::INFO
+        format_standard
+      end
+    end
+
+    private
+
+    def format_debug
+      @logger.formatter = proc { |severity, datetime, progname , msg|
+                                 debug_msg("%s %s %s: %s\n" % [ datetime, severity, progname, msg ])
+      }
+    end
+
+    def format_standard
+      @logger.formatter = proc { |severity, datetime, _, msg|
+        info_msg( "%s %s: %s\n" % [ datetime, severity, msg ] )
+      }
+    end
+
+    def error_msg(msg)
+      ANSI.red(msg)
+    end
+
+    def info_msg(msg)
+      msg
+    end
+
+    def debug_msg(msg)
+      msg
+    end
+  end
+end

data/lib/puppet_generator/main.rb

@@ -0,0 +1,36 @@
+module PuppetGenerator
+  class << self
+    def logger
+      @logger ||= Logger.new
+    end
+
+    def library_name
+      self.to_s
+    end
+
+    def gem_load_path
+      library_name.underscore
+    end
+
+    def root_directory
+      File.expand_path('../../../', __FILE__)
+    end
+
+    def enable_coverage_report
+      require 'simplecov' 
+
+      SimpleCov.start
+      SimpleCov.command_name 'cucumber'
+      SimpleCov.root PuppetGenerator.root_directory
+    rescue
+      self.logger.warn(self) { "Please note, this code is just for coverage testing. You need to install the \"simplecov\"-gem to make it work" }
+    end
+
+    def enable_debugging_libraries
+      require 'pry' 
+      require 'debugger'
+    rescue
+      self.logger.warn(self) { "Please note, this code is just for debugging the library. You need to install the \"ruby-debug19\"- and \"pry\"-gem to make it work" }
+    end
+  end
+end

data/lib/puppet_generator/middleware/apply_export_filters.rb

@@ -0,0 +1,33 @@
+module PuppetGenerator
+  module Middleware
+    class ApplyExportFilters
+
+      def initialize(app)
+        @app = app
+      end
+
+      def call(task)
+        PuppetGenerator.logger.debug(self.class.name){ "Filter the output with filter \"#{task.meta[:requested_export_filter].join(", ")}\"" }
+
+        task.body = apply_filters(task.meta[:requested_export_filter], task.body)
+
+        PuppetGenerator.logger.debug(self.class.name) { "Count output lines: #{task.body.size}" }
+
+        @app.call(task)
+      end
+
+      private
+
+      def apply_filters(filters, data, &block)
+
+        filters.inject(data) do |data,filter|
+          active_filter = Models::ExportFilter.find filter
+          raise Exceptions::UnknownExportFilter unless active_filter
+
+          data = active_filter.convert(data)
+        end
+      end
+
+    end
+  end
+end

data/lib/puppet_generator/middleware/check_for_empty_source.rb

@@ -0,0 +1,16 @@
+module PuppetGenerator
+  module Middleware
+    class CheckForEmptySource
+      def initialize(app)
+        @app = app
+      end
+
+      def call(task)
+        PuppetGenerator.logger.debug(self.class.name){ "Checking if given source \"#{task.meta[:source]}\" is empty." }
+        raise PuppetGenerator::Exceptions::EmptySource if task.body.empty?
+
+        @app.call(task)
+      end
+    end
+  end
+end

data/lib/puppet_generator/middleware/configure_logging.rb

@@ -0,0 +1,30 @@
+module PuppetGenerator
+  module Middleware
+    class ConfigureLogging
+      def initialize(app)
+        @app = app
+      end
+
+      def call(task)
+        case task.meta[:logging_mode]
+        when :debug
+          PuppetGenerator.logger.mode = :debug
+        when :silent
+          PuppetGenerator.logger.mode = :silent
+        else
+          PuppetGenerator.logger.mode = :info
+        end
+
+        PuppetGenerator.logger.debug(self.class.name){ "Logging is configured with mode \"#{PuppetGenerator.logger.mode}\"." }
+
+        @app.call(task)
+      end
+
+      private
+
+      def bold_red(msg)
+        ANSI.bold(ANSI.red(msg))
+      end
+    end
+  end
+end

data/lib/puppet_generator/middleware/create_module_directories.rb

@@ -0,0 +1,42 @@
+module PuppetGenerator
+  module Middleware
+    class CreateModuleDirectories
+      def initialize(app)
+        @app = app
+      end
+
+      def call(task)
+        module_name = task.meta[:module]
+        module_dirs = %w[ manifests files ].collect { |d| File.join(module_name, d) }
+        module_file =  File.join(module_name, 'manifests', 'init.pp')
+
+        PuppetGenerator.logger.info(self.class.name) { "Create the module directory for module \"#{module_name}\" at \"#{Dir.pwd}\"." }
+
+        mkdir module_name
+        mkdir module_dirs
+        mkfile module_file, <<-EOF
+class #{module_name} {
+
+}
+        EOF
+
+      end
+
+      private
+
+      def mkdir(*dirs)
+        FileUtils.mkdir_p( dirs.flatten.collect { |d| File.join(root_path, d ) } )
+      end
+
+      def mkfile(file, content)
+        File.open(file, "w") do |f|
+          f.write content
+        end
+      end
+
+      def root_path
+        Dir.pwd
+      end
+    end
+  end
+end

data/lib/puppet_generator/middleware/create_output.rb

@@ -0,0 +1,46 @@
+module PuppetGenerator
+  module Middleware
+    class CreateOutput
+      def initialize(app)
+        @app = app
+      end
+
+      def call(task)
+        destination = task.meta[:destination].split(/:/)
+        channel     = destination[0]
+        sink        = destination[1]
+
+        PuppetGenerator.logger.info(self.class.name){ "Puppet definitions will be output to \"#{task.meta[:destination]}\"."  }
+        PuppetGenerator.logger.debug(self.class.name){ "Render template for channel \"#{channel}\" and sink \"#{sink}\"." }
+
+        unless task.meta[:template_tagged_with]
+          task.meta[:template_tagged_with] = case channel
+                                             when /file/
+                                               [ :many_per_file ]
+                                             when /^(?:dir|directory)/
+                                               [ :one_per_file ]
+                                             when /stdout/
+                                               [ :many_per_file ]
+                                             else
+                                               [ :many_per_file ]
+                                             end
+        end
+
+        template = Models::Template.find(name: task.meta[:command], is_suitable_for: channel.to_sym, is_tagged_with: task.meta[:template_tagged_with] )
+        raise Exceptions::WrongTemplateChosen unless template
+        PuppetGenerator.logger.debug(self.class.name){ "Chosen template: #{template.name} (#{template.path})." }
+
+        definitions = template.render(task.body)
+
+        exporter = Models::Exporter.find(writes_to: task.meta[:destination])
+        raise Exceptions::InvalidExporter unless exporter
+        PuppetGenerator.logger.debug(self.class.name){ "Chosen exporter: #{exporter.name}." }
+
+        exporter.write(sink, definitions)
+
+        @app.call(task)
+      end
+
+    end
+  end
+end

data/lib/puppet_generator/middleware/create_puppet_object_from_entry.rb

@@ -0,0 +1,24 @@
+module PuppetGenerator
+  module Middleware
+    class CreatePuppetObjectFromEntry
+
+      def initialize(app)
+        @app = app
+      end
+
+      def call(task)
+        converter = Models::EntryConverter.find( task.meta[ :command ] )
+
+        raise Exceptions::InvalidEntryConverter, "I was not able to find an entry converter for command \"#{ task.meta[ :command ] }\". Available converters are: #{ Models::EntryConverter.all_names_as_string }" unless converter
+
+        PuppetGenerator.logger.debug(self.class.name){ "Convert entries for command \"#{ task.meta[:command] }\"" }
+        PuppetGenerator.logger.debug(self.class.name){ "Convert entries to puppet objects using converter \"#{ converter.name }.\"" }
+
+
+        task.body = converter.convert( task.body, task.meta[:module] , task.meta[:class] )
+
+        @app.call(task)
+      end
+    end
+  end
+end

data/lib/puppet_generator/middleware/enable_debugging_libraries.rb

@@ -0,0 +1,15 @@
+module PuppetGenerator
+  module Middleware
+    class EnableDebuggingLibraries
+      def initialize(app)
+        @app = app
+      end
+
+      def call(task)
+        PuppetGenerator.enable_debugging_libraries if task.meta[:debug] and not ENV['TRAVIS_CI'] == 'true'
+
+        @app.call(task)
+      end
+    end
+  end
+end