mantra 0.1.0 → 0.2.0

data/lib/mantra/manifest/scope.rb

@@ -0,0 +1,94 @@
+module Mantra
+  class Manifest
+    class Scope
+
+      class ScopeParseError < Exception; end
+      
+      include Helpers::ObjectWithType
+      include Helpers::RegexpHelper
+
+      def self.parse(scope_or_string)
+        return scope_or_string if scope_or_string.is_a?(Scope)
+        parse_selector(scope_or_string)
+      end
+
+      HASH_SELECTOR_REGEXP  = /^([a-zA-Z0-9\_\-\=\*]+)\.?(.*)$/
+      ARRAY_SELECTOR_REGEXP = /^\[([a-zA-Z0-9\:\_\-\=\*]*)\]\.?(.*)$/
+
+      def self.parse_selector(selector)
+        case selector
+        when HASH_SELECTOR_REGEXP
+          head_selector, tail_selector = split_selector(selector, HASH_SELECTOR_REGEXP)
+          HashScope.new(scope: head_selector, next: parse_selector(tail_selector))
+        when ARRAY_SELECTOR_REGEXP
+          head_selector, tail_selector = split_selector(selector, ARRAY_SELECTOR_REGEXP)
+          ArrayScope.new(scope: head_selector, next: parse_selector(tail_selector))
+        when ""
+          EmptyScope.new()
+        else
+          raise_parse_error(selector)
+        end
+      end
+
+      def self.split_selector(selector, matcher_regex)
+        matcher = selector.match(matcher_regex)
+        raise_parse_error(selector) if matcher.nil?
+        head_selector = matcher[1]
+        tail_selector = matcher[2]
+        return head_selector, tail_selector
+      end
+
+      def self.raise_parse_error(selector)
+        raise ScopeParseError.new("Can't parse selector: #{selector}")
+      end
+
+      attr_accessor :scope, :next
+
+      def initialize(options={})
+        self.scope, self.next = options[:scope], options[:next]
+      end
+
+      def last?
+        self.is_a?(EmptyScope)
+      end
+
+      alias_method :tail, :next
+
+      def match?(manifest_element)
+        raise "not implemented"
+      end
+
+      def filter(element, &block)
+        return [] if !has_same_type?(element)
+        matched_elements = _filter(element)
+        if self.last?
+          block.call(matched_elements) if block_given?
+          matched_elements
+        else
+          matched_elements.map do |e|
+            self.next.filter(e)
+          end.compact.flatten
+        end
+      end
+
+      def has_same_type?(element)
+        raise element.inspect if element.is_a?(Array)
+        self.type == element.type
+      end
+
+      def _filter(element)
+        raise "not implemented"
+      end
+
+      def to_a
+        [self, self.tail.to_a].flatten
+      end
+
+    end
+  end
+end
+
+require "mantra/manifest/scope/array_scope"
+require "mantra/manifest/scope/empty_scope"
+# require "mantra/manifest/scope/leaf_scope"
+require "mantra/manifest/scope/hash_scope"

data/lib/mantra/manifest.rb

@@ -0,0 +1,47 @@
+require "forwardable"
+require "mantra/manifest/scope"
+require "mantra/manifest/element"
+require "mantra/manifest/ext"
+require "mantra/manifest/root_element"
+require "mantra/manifest/array_element"
+require "mantra/manifest/hash_element"
+require "mantra/manifest/leaf_element"
+
+module Mantra
+  class Manifest
+
+    extend Forwardable
+    include Mantra::Manifest::Ext
+
+    class UnknownScopeError < Exception; end
+    class FileNotFoundError < Exception; end
+
+    attr_accessor :root, :file
+
+    def_delegators :@root, :merge, :to_ruby_object, :traverse,
+      :select, :find, :add_node, :fetch, :get
+
+    def initialize(manifest_object_or_path)
+      if manifest_object_or_path.is_a?(String) && File.exist?(manifest_object_or_path)
+        manifest_object = YAML.load_file(manifest_object_or_path)
+        self.file = manifest_object_or_path
+        self.root = Element.create(manifest_object)
+      elsif manifest_object_or_path.is_a?(Hash) || manifest_object_or_path.is_a?(Array)
+        self.root = Element.create(manifest_object_or_path)
+      else
+        raise "Don't know how initialize manifest. Expected existing file path or hash, " +
+          "got #{manifest_object_or_path.class.inspect}: #{manifest_object_or_path.inspect}"
+          end
+    end
+
+    def write(manifest_path)
+      File.open(manifest_path, 'w') { |f| f.write(self.to_ruby_object.to_yaml) }
+    end
+
+    def save
+      raise FileNotFoundError.new("File is not specified") if self.file.nil?
+      self.write(self.file)
+    end
+
+  end
+end

data/lib/mantra/merge_tool/spiff.rb

@@ -0,0 +1,23 @@
+module Mantra
+  class MergeTool
+    class Spiff < MergeTool
+      type :spiff
+
+      def templatize(string, scope, start, finish)
+        first_part = string[0..start-1]
+        value      = string[start..finish]
+        last_part  = string[finish..-1]
+        first_part = first_part[3..-1] if first_part.end_with?("(( ")
+        last_part  = last_part[0..-4]  if last_part.end_with?(" ))")
+        ["((", "\"#{first_part}\"", scope, "\"#{last_part}\"", "))"].select do |s|
+          s != "\"\""
+        end.join(" ")
+      end
+
+      def is_template?(string)
+        !!string.match(/^\(\(.*\)\)$/)
+      end
+
+    end
+  end
+end

data/lib/mantra/merge_tool.rb

@@ -0,0 +1,13 @@
+module Mantra
+  class MergeTool
+    include Helpers::ObjectWithType
+
+    def templatize(string, scope, start, finish)
+      raise "not implemented"
+    end
+
+  end
+end
+
+require "mantra/merge_tool/spiff"
+

data/lib/mantra/transform/extract.rb

@@ -0,0 +1,10 @@
+module Mantra
+  class Transform
+    class Extract < Transform
+      type :extract
+
+
+
+    end
+  end
+end

data/lib/mantra/transform/extract_certificates.rb

@@ -0,0 +1,18 @@
+module Mantra
+  class Transform
+    class ExtractCertificates < Transform
+      type :"extract-certificates"
+
+      description "Extracts certificates from source manifest, " +
+                  "templatize source manifest and places certificates to target manifest."
+      input "source", type: :file,
+                      validate: :file_exists,
+                      description: "Source manifest with ceritificates, that will become a template"
+      input "target", type: :file,
+                      description: "Target manifest with extracted ceritificates"
+
+
+
+    end
+  end
+end

data/lib/mantra/transform/extract_certificates_to_files.rb

@@ -0,0 +1,12 @@
+module Mantra
+  class Transform
+    class ExtractCertificatesToFiles < Transform
+      type :"extract-certificates-to-files"
+
+      def perform
+        
+      end
+
+    end
+  end
+end

data/lib/mantra/transform/extract_section.rb

@@ -0,0 +1,10 @@
+module Mantra
+  class Transform
+    class ExtractSection < Transform
+      type :"extract-section"
+
+
+
+    end
+  end
+end

data/lib/mantra/transform/inputs/any.rb

@@ -0,0 +1,10 @@
+module Mantra
+  class Transform
+    class Input
+      class AnyInput < Input
+        type :any
+
+      end
+    end
+  end
+end

data/lib/mantra/transform/inputs/array.rb

@@ -0,0 +1,16 @@
+module Mantra
+  class Transform
+    class Input
+      class ArrayInput < Input
+        type :array
+
+        def validate_file_exists(value, name)
+          unless File.exist?(value)
+            raise ValidationError.new("File does not exist: #{value}")
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/mantra/transform/inputs/file.rb

@@ -0,0 +1,16 @@
+module Mantra
+  class Transform
+    class Input
+      class FileInput < Input
+        type :file
+
+        def validate_file_exists(value, name)
+          unless File.exist?(value)
+            raise ValidationError.new("File does not exist: #{value}")
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/mantra/transform/inputs/folder.rb

@@ -0,0 +1,9 @@
+module Mantra
+  class Transform
+    class Input
+      class FolderInput < Input
+        type :folder
+      end
+    end
+  end
+end

data/lib/mantra/transform/inputs/hash.rb

@@ -0,0 +1,16 @@
+module Mantra
+  class Transform
+    class Input
+      class HashInput < Input
+        type :hash
+
+        # def validate_file_exists(value, name)
+        #   unless ::File.exist?(value)
+        #     raise ValidationError.new("File does not exist: #{value}")
+        #   end
+        # end
+
+      end      
+    end
+  end
+end

data/lib/mantra/transform/inputs/string.rb

@@ -0,0 +1,9 @@
+module Mantra
+  class Transform
+    class Input
+      class StringInput < Input
+        type :string
+      end
+    end
+  end
+end

data/lib/mantra/transform/merge.rb

@@ -0,0 +1,26 @@
+module Mantra
+  class Transform
+    class Merge < Mantra::Transform
+      type :"merge"
+      attr_accessor :manifest
+
+      description "Merge"
+
+      input "value", description: "value that should be merged in", type: :any
+
+      input "scope",  description: "scope (or path) in stub file that will have current value (for instance meta.networks)",
+                      type:        :string
+
+      def perform
+        @manifest = previous_transform.manifest
+        value_manifest_element = Mantra::Manifest::Element.create(self.value).content
+
+        scope = @manifest.fetch(self.scope)
+        scope.each do |s|
+          s.merge(value_manifest_element)
+        end
+      end
+
+    end
+  end
+end

data/lib/mantra/transform/replace.rb

@@ -0,0 +1,34 @@
+module Mantra
+  class Transform
+    class Replace < Mantra::Transform
+      type :"replace"
+      attr_accessor :manifest
+
+      description "Merge"
+
+      input "value", description: "value that should be merged in", type: :any
+
+      input "scope",  description: "scope (or path) in stub file that will have current value (for instance meta.networks)",
+                      type:        :string
+
+      def perform
+        @manifest = previous_transform.manifest
+        # value_manifest_element = Mantra::Manifest::Element.create(self.value).content
+
+        scope = @manifest.fetch(self.scope)
+        scope.each do |s|
+          puts "psssss!!"
+          puts s.class
+          s.content = self.value
+        end
+      end
+
+      def raise_if_no_source_manifest
+        if self.source.nil? || !File.exist?(self.source)
+          raise Manifest::FileNotFoundError.new("Source manifest does not exist: #{self.source.inspect}")
+        end
+      end
+
+    end
+  end
+end

data/lib/mantra/transform/templatize_ip_address.rb

@@ -0,0 +1,129 @@
+module Mantra
+  class Transform
+    class TemplatizeIpAddress < Transform
+      type :"templatize-ip-address"
+      include Mantra::Helpers::RegexpHelper
+      include Mantra::Helpers::TemplateHelper
+
+      description "Templatize ip addresses"
+
+      input "source", description: "Source manifest with ceritificates, that will become a template",
+        type:        :file,
+        validate:    :file_exists
+
+      input "target", description: "Target manifest with extracted ceritificates",
+        type:        :file
+
+      input "quads",   description: "quad that is going to be extracted",
+        type:        :array
+
+      def perform
+        raise_error_if_no_source_manifest
+        ensure_yml_file_exist(self.target)
+
+        source_manifest.traverse do |node|
+          template, values = if is_ip_address?(node.content)
+            splitter = QuadSplitter.new(node.content, quads)
+            ["(( #{splitter.parts(templatize: true).join(" ")} ))", splitter.values]
+          elsif is_network_range?(node.content)
+            ip_address, network_prefix_size = *node.content.split("/")
+            puts "NETWORK RANGE! #{[ip_address, network_prefix_size].inspect}"
+            splitter = QuadSplitter.new(ip_address, quads)
+            network_range_parts = splitter.parts + ["/#{network_prefix_size}"]
+            # puts "PARTS! #{network_range_parts.inspect}"
+            resulting_template = "(( #{templatize(network_range_parts).join(" ")} ))"
+            [resulting_template, splitter.values]
+          elsif is_ip_range?(node.content)
+            ip_address1, ip_address2 = *node.content.split("-").map { |ip| ip.strip }
+            splitter1 = QuadSplitter.new(ip_address1, quads)
+            splitter2 = QuadSplitter.new(ip_address2, quads)
+            result = templatize(splitter1.parts + ["-"] + splitter2.parts)
+            ["(( #{result.join(" ")} ))", splitter1.values]
+          end
+          unless template.nil?
+            puts template.inspect if node.content == "192.168.3.0/24"
+            raise UnknownScopeError.new("Can't templatize non leaf ip address") unless node.leaf?
+            node.content = template
+            values.each_pair do |scope, value|
+              scope_element = Manifest::Element.element_with_selector(scope, value)
+              target_manifest.merge(scope_element)
+            end
+          end
+        end
+
+        source_manifest.save
+        target_manifest.save
+      end
+
+      def ip_address_matcher
+        "(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})"
+      end
+
+      def is_network_range?(value)
+        !!value.to_s.match(/^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})\/\d{1,2}$/)
+      end
+
+      def is_ip_range?(value)
+        !!value.to_s.match(/^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})\s*-\s*(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/)
+      end
+
+      def is_ip_address?(value)
+        !!value.to_s.match(/^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/)
+      end
+
+      # def templatize(parts)
+      #   raise "wrong!!!"
+      #   merged_parts = [parts.shift]
+      #   parts.each do |p|
+      #     if !p.is_a?(Scope) && !merged_parts.last.is_a?(Scope)
+      #       merged_parts.last.concat(p)
+      #     else
+      #       merged_parts << p
+      #     end
+      #   end
+      #   merged_parts.select { |p| !p.empty? }.map do |p|
+      #     p.is_a?(Scope) ? p : "\"#{p}\""
+      #   end
+      # end
+
+      class QuadSplitter
+        include Mantra::Helpers::TemplateHelper
+        attr_accessor :values, :parts
+        def initialize(ip_address, template_quads)
+          @values = {}
+          extract_options = template_quads.map do |quad|
+            quad["range_object"] = if quad["number"]
+              index = quad["number"].to_i - 1
+              (index..index)
+            elsif quad["range"]
+              index1, index2 = *quad["range"].split("-").map { |v| v.strip.to_i - 1 }
+              (index1..index2)
+            end
+            quad
+          end
+
+          template = IpAddressTemplate.new(ip_address)
+
+          extract_options.each do |option|
+            range = option["range_object"]
+            value_to_extract = template.quads[range].join(".")
+            if option["with_value"].nil? || value_to_extract == option["with_value"]
+              template.replace_with_scope(range, option["scope"])
+              @values[option["scope"]] = value_to_extract
+            end
+          end
+          @parts = template.parts
+        end
+
+        def parts(options={templatize: false})
+          if options[:templatize]
+            templatize(@parts)
+          else
+            @parts
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/mantra/transform/templatize_value.rb

@@ -0,0 +1,63 @@
+module Mantra
+  class Transform
+    class TemplatizeValue < Transform
+      type :"templatize-value"
+
+      include Mantra::Helpers::RegexpHelper
+
+      description "Extracts specified value to stub file"
+
+      input "source", description: "Source manifest with ceritificates, that will become a template",
+                      type:        :file,
+                      validate:    :file_exists
+                      
+      input "target", description: "Target manifest with extracted ceritificates",
+                      type:        :file
+
+      input "value",  description: "value you want to templatize (for instance 'domain.com')",
+                      type:        :string
+
+      input "scope",  description: "scope (or path) in stub file that will have current value (for instance meta.networks)",
+                      type:        :string
+
+      input "in",     description: "wildcard matcher (for instance 'https://*.domain.com')",
+                      type:        :string,
+                      optional:    true
+
+      input "regexp", description: "string with ruby regexp to match values",
+                      type:        :string,
+                      optional:    true
+
+      def perform
+        raise_error_if_no_source_manifest
+        ensure_yml_file_exist(self.target)
+        # value_matcher = to_regexp(value)
+
+        raise "scope must not match value wildcard" if scope.match(value)
+
+        source_manifest.traverse do |node|
+          if node.content.to_s.match(value)
+            # match = node.content.to_s.match(value_matcher)[0]
+            match = node.content.to_s.match(value)[0]
+            begin_index = node.content.to_s.index(match)
+            end_index   = begin_index + match.size
+            final_value = merge_tool.templatize(node.content.to_s, scope, begin_index, end_index)
+            node.content = final_value
+            scope_element = Manifest::Element.element_with_selector(scope, value)
+            target_manifest.merge(scope_element)
+          end
+        end
+
+        source_manifest.save
+        target_manifest.save
+      end
+
+      def raise_if_no_source_manifest
+        if self.source.nil? || !File.exist?(self.source)
+          raise Manifest::FileNotFoundError.new("Source manifest does not exist: #{self.source.inspect}")
+        end
+      end
+
+    end
+  end
+end