simp-metadata 0.4.3

data/lib/simp/metadata/commands/delete.rb

@@ -0,0 +1,26 @@
+require_relative '../commands'
+module Simp
+  module Metadata
+    module Commands
+      class Delete < Simp::Metadata::Commands::Base
+        def run(argv, engine = nil)
+
+          options = defaults(argv) do | opts|
+            opts.banner = "Usage: simp-metadata delete <component_name>"
+          end
+
+          engine, root = get_engine(engine, options)
+          begin
+            engine.releases.delete(argv[0])
+            if (root == true)
+              engine.save((["simp-metadata", "delete"] + argv).join(" "))
+            end
+          rescue RuntimeError => e
+            Simp::Metadata.critical(e.message)
+            exit 5
+          end
+        end
+      end
+    end
+  end
+end

data/lib/simp/metadata/commands/pry.rb

@@ -0,0 +1,19 @@
+require_relative '../commands'
+module Simp
+  module Metadata
+    module Commands
+      class Pry < Simp::Metadata::Commands::Base
+        def run(argv, engine = nil)
+
+          options = defaults(argv) do |opts|
+            opts.banner = "Usage: simp-metadata pry"
+          end
+
+          engine, root = get_engine(engine, options)
+          require 'pry'
+          binding.pry
+        end
+      end
+    end
+  end
+end

data/lib/simp/metadata/commands/release.rb

@@ -0,0 +1,47 @@
+require_relative '../commands'
+module Simp
+  module Metadata
+    module Commands
+      class Release < Simp::Metadata::Commands::Base
+        def run(argv, engine = nil)
+
+          options = defaults(argv) do |opts|
+            opts.banner = "Usage: simp-metadata release <release_name> [components]"
+            opts.banner = "       simp-metadata release diff <release1> <release2>"
+          end
+
+
+          engine, root = get_engine(engine, options)
+          begin
+            section = argv[0]
+            case section
+              when "components"
+                puts engine.releases[options["release"]].components.keys.join("\n")
+
+              when "puppetfile"
+                type = argv[1]
+                puts engine.releases[options["release"]].puppetfile({ "type" => type})
+
+              when "diff"
+                release1 = argv[1]
+                release2 = argv[2]
+                attribute = argv[3]
+                release1 = engine.releases[release1]
+                release2 = engine.releases[release2]
+                diff = release1.diff(release2, attribute)
+                puts diff.to_yaml
+              else
+                puts "components:"
+                engine.releases[options["release"]].components.keys.each do |line|
+                  puts "    #{line}"
+                end
+            end
+          rescue RuntimeError => e
+            Simp::Metadata.critical(e.message)
+            exit 5
+          end
+        end
+      end
+    end
+  end
+end

data/lib/simp/metadata/commands/releases.rb

@@ -0,0 +1,24 @@
+require_relative '../commands'
+module Simp
+  module Metadata
+    module Commands
+      class Releases < Simp::Metadata::Commands::Base
+        def run(argv, engine = nil)
+
+          options = defaults(argv) do |opts|
+            opts.banner = "Usage: simp-metadata releases"
+          end
+
+
+          engine, root = get_engine(engine, options)
+          begin
+            puts engine.releases.keys
+          rescue RuntimeError => e
+            Simp::Metadata.critical(e.message)
+            exit 5
+          end
+        end
+      end
+    end
+  end
+end

data/lib/simp/metadata/commands/save.rb

@@ -0,0 +1,33 @@
+require_relative '../commands'
+module Simp
+  module Metadata
+    module Commands
+      class Save < Simp::Metadata::Commands::Base
+        def run(argv, engine = nil)
+
+          options = defaults(argv) do |opts|
+            opts.banner = "Usage: simp-metadata save [options] [message]"
+          end
+
+
+          engine, root = get_engine(engine, options)
+          if (argv.size == 0)
+            short = "Auto-saving using simp-metadata"
+          else
+            short = argv.join(" ")
+          end
+          if ($commandqueue != nil)
+            message = []
+            while $commandqueue.empty?() == false
+              message << $commandqueue.pop
+            end
+            puts message
+            engine.save("#{short}\n\nsimp-metadata log:\n    #{message.join("\n    ")}")
+          else
+            engine.save(short)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/simp/metadata/commands/script.rb

@@ -0,0 +1,38 @@
+require 'optparse'
+require_relative '../commands'
+
+module Simp
+  module Metadata
+    module Commands
+      class Script < Simp::Metadata::Commands::Base
+        def run(argv, engine = nil)
+
+          options = defaults(argv) do |opts|
+            opts.banner = "Usage: simp-metadata script [options] <filename>"
+          end
+
+          $commandqueue = Queue.new();
+
+          engine, root = get_engine(engine, options)
+          unless (argv[0] != nil)
+            Simp::Metadata.critical("filename must be specified")
+            exit 3
+          end
+          data = File.read(argv[0])
+          lines = data.split("\n")
+          lines.each do |line|
+            temp_argv = line.split(" ")
+            unless (temp_argv.size == 0)
+              unless (temp_argv[0] =~ /^#/)
+                $commandqueue.push(line);
+                command = Module.const_get("Simp::Metadata::Commands::#{temp_argv[0].gsub("-","_").capitalize}").new()
+                temp_argv.shift
+                command.run(temp_argv, engine)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/simp/metadata/commands/search.rb

@@ -0,0 +1,65 @@
+require 'cgi'
+require_relative '../commands'
+
+module Simp
+  module Metadata
+    module Commands
+      class Search < Simp::Metadata::Commands::Base
+
+        def run(argv, engine = nil)
+
+          options = defaults(argv) do |opts|
+            opts.banner = "Usage: simp-metadata search <attribute>=<value>\n(supports multiple attributes as well as encoded URLs)"
+          end
+
+          engine, root = get_engine(engine, options)
+          begin
+            data = {}
+            argv.each do |argument|
+              splitted = argument.split("=")
+              name = splitted[0]
+              value = splitted[1]
+              case name
+                when name
+                  data[name] = value
+              end
+            end
+            unless (data == {}) or data.nil?
+              data.each do |key, value|
+                if value == "" or value.nil?
+                  puts "No value specified for #{key}"
+                  exit
+                end
+              end
+              engine.components.each do |component|
+
+                result = data.all? do |key, value|
+                  if key == "url"
+                    component.locations.any? do |location|
+                      location.url == value or location.url == CGI.unescape(value)
+                    end
+                  else
+                    component[key] == value or component[key] == CGI.unescape(value)
+                  end
+                end
+
+                if result
+                  puts component.name
+                end
+              end
+            else
+              puts "No search parameters specified"
+            end
+            if (root == true)
+              engine.save
+            end
+          rescue RuntimeError => e
+            Simp::Metadata.critical(e.message)
+            exit 5
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/simp/metadata/commands/set-write-url.rb

@@ -0,0 +1,19 @@
+require_relative '../commands'
+module Simp
+  module Metadata
+    module Commands
+      class Set_write_url < Simp::Metadata::Commands::Base
+        def run(argv, engine = nil)
+
+          options = defaults(argv) do |opts|
+            opts.banner = "Usage: simp-metadata set-write-url <repo_name> <url>"
+          end
+
+
+          engine, root = get_engine(engine, options)
+          engine.writable_url(argv[0], argv[1])
+        end
+      end
+    end
+  end
+end

data/lib/simp/metadata/commands/set-write.rb

@@ -0,0 +1,19 @@
+require_relative '../commands'
+module Simp
+  module Metadata
+    module Commands
+      class Set_write < Simp::Metadata::Commands::Base
+        def run(argv, engine = nil)
+
+          options = defaults(argv) do |opts|
+            opts.banner = "Usage: simp-metadata set-write [options]"
+          end
+
+
+          engine, root = get_engine(engine, options)
+          engine.writable_source_name = argv[0]
+        end
+      end
+    end
+  end
+end

data/lib/simp/metadata/commands/update.rb

@@ -0,0 +1,46 @@
+require_relative '../commands'
+module Simp
+  module Metadata
+    module Commands
+      class Update < Simp::Metadata::Commands::Base
+
+        def run(argv, engine = nil)
+
+          options = defaults(argv) do |opts|
+            opts.banner = "Usage: simp-metadata update <component> <setting> <value>"
+          end
+
+
+          engine, root = get_engine(engine, options)
+          begin
+            component = argv[0]
+            setting = argv[1]
+            value = argv[2]
+            if (options["release"] == nil)
+              object = engine.components[component]
+            else
+              object = engine.releases[options["release"]].components[component]
+            end
+            unless (object.methods.include?(setting.to_sym))
+              Simp::Metadata.critical("#{setting} is not a valid setting")
+              exit 7
+            end
+            begin
+              object.send("#{setting}=".to_sym, value)
+            rescue NoMethodError => ex
+              Simp::Metadata.critical("#{setting} is a read-only setting")
+              exit 6
+            end
+
+            if (root == true)
+              engine.save((["simp-metadata", "update"] + argv).join(" "))
+            end
+          rescue RuntimeError => e
+            Simp::Metadata.critical(e.message)
+            exit 5
+          end
+        end
+      end
+    end
+  end
+end

data/lib/simp/metadata/component.rb

@@ -0,0 +1,388 @@
+module Simp
+  module Metadata
+    class Component
+      include Enumerable
+      attr_accessor :engine
+      attr_accessor :release_version
+
+      def initialize(engine, name, version)
+        @engine = engine
+        @name = name
+        @release_version = version
+      end
+
+      def to_s
+        self.name
+      end
+
+      def name(type = "component")
+        case type
+          when "component"
+            @name
+          when "puppetfile"
+            if (component_type == "rubygem")
+              "rubygem-#{@name.gsub(/\-/, '_')}"
+            elsif (component_type == "puppet-module")
+              @name.gsub(/pupmod\-/, '')
+            else
+              @name
+            end
+        end
+      end
+
+      def component_source()
+        retval = engine.sources["bootstrap_metadata"]
+        engine.sources.each do |name, source|
+          if (source.components != nil)
+            if (source.components.key?(self.name))
+              retval = source
+              break
+            end
+          end
+        end
+        return retval
+      end
+
+      def release_source()
+        retval = engine.sources["bootstrap_metadata"]
+        engine.sources.each do |name, source|
+          if (source.releases.key?(release_version))
+            if (source.releases[release_version].key?(self.name))
+              retval = source
+              break
+            end
+          else
+            if (source.release(release_version).key?(self.name))
+              retval = source
+              break
+            end
+          end
+        end
+        return retval
+      end
+
+      #
+      # Will be used to grab method based data in the future, rather
+      # then calling get_from_release or get_from_component directly,
+      #
+      # For now, just use it in Simp::Metadata::Buildinfo
+      def fetch_data(item)
+         component = get_from_component
+         release = get_from_release
+         if (release.key?(item))
+           release[item]
+         else
+           component[item]
+         end
+      end
+
+      def get_from_component()
+        return self.component_source.components[self.name]
+      end
+
+      def get_from_release()
+        retval = {}
+        if (self.release_source.releases.key?(release_version))
+          if (self.release_source.releases[release_version].key?(self.name))
+            retval = self.release_source.releases[release_version][self.name]
+          end
+        else
+          if (self.release_source.release(release_version).key?(self.name))
+            retval = self.release_source.release(release_version)[self.name]
+          end
+        end
+        return retval
+      end
+
+      def type
+        get_from_component["type"]
+      end
+
+      def extension
+        if (self.real_extension == nil)
+          case (self.component_type)
+            when "simp-metadata"
+              "tgz"
+            when "logstash-filter"
+              "gem"
+            when "rubygem"
+              "gem"
+            when "grafana-plugin"
+              "zip"
+            when "puppet-module"
+              "tgz"
+            else
+              ""
+          end
+        else
+          self.real_extension
+        end
+      end
+
+      def keys()
+        ["component_type", "authoritative", "asset_name", "extension", "format", "module_name", "type", "url", "method", "extract", "branch", "tag", "ref", "version", "release_source", "component_source"]
+      end
+
+      def [] (index)
+        self.send index.to_sym
+      end
+
+      def each(&block)
+        self.keys.each do |key|
+          yield key, self[key]
+        end
+      end
+
+      def real_extension
+        get_from_component["extension"]
+      end
+
+      def real_asset_name
+        case self.component_type
+          when "puppet-module"
+            get_from_component["module_name"]
+          when "rubygem"
+            get_from_component["gem_name"]
+          else
+            get_from_component["asset_name"]
+        end
+      end
+
+      def module_name
+        asset_name
+      end
+
+      def asset_name
+        if (self.real_asset_name == nil)
+          case self.component_type
+            when "puppet-module"
+              splitted = self.name.split("-")
+              splitted[splitted.size - 1]
+            else
+              self.name
+          end
+        else
+          self.real_asset_name
+        end
+      end
+
+
+      def output_type
+        if (self.compiled?)
+          return :file
+        else
+          return :directory
+        end
+      end
+
+      def output_filename
+        if (self.compiled?)
+          return "#{self.name}-#{self.version}.#{self.extension}"
+        else
+          return self.name
+        end
+      end
+
+      def primary
+        self.locations.primary
+      end
+
+      def url
+        self.locations.primary.url
+      end
+
+      def method
+        self.locations.primary.method
+      end
+
+      def extract
+        self.locations.primary.extract
+      end
+
+      def locations
+        # XXX: ToDo Allow manifest.yaml to override locations
+        # XXX: ToDo Use primary_source and mirrors here if locations is empty
+        Simp::Metadata::Locations.new({"locations" => get_from_component["locations"], "primary_source" => get_from_component["primary_source"], "mirrors" => get_from_component["mirrors"]}, self)
+      end
+
+      # XXX: ToDo Generate a filename, and output file type; ie, directory or file
+
+
+      def format
+        get_from_component["format"]
+      end
+
+      def component_type
+        get_from_component["component-type"]
+      end
+
+      def authoritative?
+        get_from_component["authoritative"]
+      end
+
+      def authoritative
+        get_from_component["authoritative"]
+      end
+
+      def ref
+        get_from_release["ref"]
+      end
+
+      def ref=(value)
+        release = self.release_source.releases[release_version]
+        if (release != nil)
+          if (release.key?(name))
+            release[name]["ref"] = value
+          else
+            release[name] = {"ref" => value}
+          end
+        end
+        self.release_source.dirty = true
+      end
+
+      def branch
+        get_from_release["branch"]
+      end
+
+      def branch=(value)
+        release = self.release_source.releases[release_version]
+        if (release != nil)
+          if (release.key?(name))
+            release[name]["branch"] = value
+          else
+            release[name] = {"branch" => value}
+          end
+        end
+        self.release_source.dirty = true
+      end
+
+      def tag
+        get_from_release["tag"]
+      end
+
+      def tag=(value)
+        release = self.release_source.releases[release_version]
+        if (release != nil)
+          if (release.key?(name))
+            release[name]["tag"] = value
+          else
+            release[name] = {"tag" => value}
+          end
+        end
+        self.release_source.dirty = true
+      end
+
+      def version
+        ver = ""
+        ["version", "tag", "ref", "branch"].each do |item|
+          if (get_from_release[item] != nil)
+            ver = get_from_release[item]
+            break
+          end
+        end
+        return ver
+      end
+
+      def rpm_basename
+        if component_type == 'puppet-module'
+          if name.match(/pupmod-*/)
+            "#{name}"
+          else
+            "pupmod-#{name}"
+          end
+        else
+          "#{name}"
+        end
+      end
+
+      def rpm_version
+        if version.match(/[v][0-9]+.[0-9]+.[0-9]+/)
+          version.split('v')[1]
+        else
+          version
+        end
+      end
+
+      def rpm_name
+        "#{rpm_basename}-#{rpm_version}.rpm"
+      end
+
+      def compiled?
+        if get_from_release.key?("compiled")
+          get_from_release["compiled"]
+        else
+          false
+        end
+      end
+
+      def binaryname
+        "#{asset_name}-#{version}.#{extension}"
+      end
+
+      def view(attribute)
+        comp = self
+        view_hash = {}
+        if attribute.nil?
+          comp.each do |key, value|
+            unless value.nil? or value == ""
+              view_hash[key] = value.to_s
+            end
+          end
+          location_hash = {}
+          comp.locations.each do |location|
+            location.each do |key, value|
+              unless value.nil?
+                location_hash.merge!(key => value.to_s)
+              end
+            end
+          end
+          buildinfo_hash = {}
+          comp.buildinfo.each do |buildinfo|
+            buildinfo.each do |key, value|
+            end
+          end
+          view_hash['location'] = location_hash
+        else
+          view_hash[attribute] = comp[attribute].to_s
+        end
+        return view_hash
+      end
+
+      def diff(component, attribute)
+        diff = {}
+
+        if attribute.nil?
+          current_hash = {}
+          comp_hash = {}
+          self.each do |attribute, value|
+            current_hash.merge!(attribute => value)
+          end
+          component.each do |attribute, value|
+            comp_hash.merge!(attribute => value)
+          end
+          unless current_hash == comp_hash
+            current_hash.each do |attribute, value|
+              diff[attribute] = {"original" => "#{current_hash[attribute]}",
+                                 "changed" => "#{comp_hash[attribute]}"} if comp_hash[attribute] != value
+            end
+          end
+          return diff
+        else
+          v1 = self["#{attribute}"]
+          v2 = component["#{attribute}"]
+          unless (v1 == v2)
+            diff[attribute] = {"original" => "#{v1}", "changed" => "#{v2}"}
+            return diff
+          end
+        end
+      end
+      def buildinfo(type = nil)
+        if (type == nil)
+          {}
+        else
+          Simp::Metadata::Buildinfo.new(self, type)
+        end
+      end
+    end
+  end
+end