simp-metadata 0.4.3

data/lib/simp/metadata/release.rb

@@ -0,0 +1,119 @@
+require 'simp/metadata/components'
+module Simp
+  module Metadata
+    class Release
+      attr_accessor :engine
+      attr_accessor :version
+
+      def initialize(engine, version)
+        @engine = engine
+        @version = version
+      end
+
+      def components(type = nil)
+        Simp::Metadata::Components.new(engine, version, type)
+      end
+
+      def puppetfile_component(component, options)
+        contents = []
+        contents << "mod '#{component.name("puppetfile")}',"
+        contents << "  :git => '#{component.primary.url}',"
+        if (component.ref == nil)
+          contents << "  :tag => '#{component.tag}'"
+        else
+          contents << "  :ref => '#{component.ref}'"
+        end
+        contents << ""
+        contents
+      end
+
+      def puppetfile(options = {})
+        contents = []
+        if (options["type"] == "simp-core")
+          contents << "moduledir 'src'"
+          contents << ""
+          contents << puppetfile_component(components['simp-doc'], options)
+          contents << puppetfile_component(components['simp-rsync'], options)
+          contents << "moduledir 'src/assets'"
+          contents << ""
+          components.each do |component|
+            if (component.component_type == "rpm")
+              contents << puppetfile_component(component, options)
+            end
+          end
+          contents << "moduledir 'src/rubygems'"
+          contents << ""
+          components.each do |component|
+            if (component.component_type == "rubygem")
+              contents << puppetfile_component(component, options)
+            end
+          end
+          contents << "moduledir 'src/puppet/modules'"
+          contents << ""
+        end
+        components.each do |component|
+          if (component.component_type == "puppet-module")
+            contents << puppetfile_component(component, options)
+          end
+        end
+        contents.join("\n")
+      end
+
+      def to_s()
+        self.components.to_s
+      end
+
+      def diff(compare_release, attribute)
+        diff = {}
+
+        current_hash = {}
+        compare_hash = {}
+        self.components.each do |comp|
+          self_component_hash = {}
+          comp.each do |key, value|
+            if (attribute != nil)
+              if (key.to_s == attribute)
+                self_component_hash[key] = value.to_s
+              end
+            else
+              self_component_hash[key] = value.to_s
+            end
+            current_hash[comp.name] = self_component_hash
+          end
+        end
+
+        compare_release.components.each do |comp|
+          self_component_hash = {}
+          comp.each do |key, value|
+            if (attribute != nil)
+              if (key.to_s == attribute)
+                self_component_hash[key] = value.to_s
+              end
+            else
+              self_component_hash[key] = value.to_s
+            end
+            compare_hash[comp.name] = self_component_hash
+          end
+        end
+        current_hash.each do |comp, hash|
+
+          diff_hash = {}
+          hash.each do |key, value|
+            if (compare_hash.key?(comp))
+              if (compare_hash[comp][key] != value)
+                diff_hash[key] = {
+                    "original" => "#{value}",
+                    "changed" => "#{compare_hash[comp][key]}"
+                }
+              end
+            end
+          end
+          unless diff_hash.empty?
+            diff[comp] = diff_hash
+          end
+        end
+        return diff
+      end
+    end
+  end
+end

data/lib/simp/metadata/releases.rb

@@ -0,0 +1,57 @@
+require 'simp/metadata/release'
+
+module Simp
+  module Metadata
+    class Releases
+      include Enumerable
+      attr_accessor :engine
+
+      def initialize(engine)
+        @engine = engine
+      end
+
+      def each(&block)
+        self.keys.each do |version|
+          yield self[version]
+        end
+      end
+
+      def [](index)
+        Simp::Metadata::Release.new(engine, index)
+      end
+
+      def keys()
+        result = {}
+        engine.sources.each do |name, source|
+          source.releases.keys.each do |name|
+            result[name] = true
+          end
+        end
+        result.keys
+      end
+
+      def size()
+        self.keys.size
+      end
+
+      def to_s()
+        self.keys.to_s
+      end
+      def delete(version)
+        engine.sources.each do |name, metadata_source|
+          if (metadata_source.writable?)
+            metadata_source.delete_release(version)
+          end
+        end
+      end
+      def create(destination, source = 'master')
+        engine.sources.each do |name, metadata_source|
+          if (metadata_source.writable?)
+            metadata_source.create_release(destination, source)
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/simp/metadata/source.rb

@@ -0,0 +1,204 @@
+require 'yaml'
+require 'uri'
+
+module Simp
+  module Metadata
+    class Source
+
+      attr_accessor :url
+      attr_accessor :cachepath
+      attr_accessor :components
+      attr_accessor :releases
+      attr_accessor :basename
+      attr_accessor :data
+      attr_accessor :releases
+      attr_accessor :components
+      attr_accessor :name
+      attr_accessor :edition
+      attr_accessor :engine
+
+      def initialize(args)
+        unless (args.key?(:engine))
+          raise ":engine must be specified when initializing a metadata source"
+        end
+        unless (args.key?(:name))
+          raise ":name must be specified when initializing a metadata source"
+        end
+        unless (args.key?(:component))
+          raise ":component must be specified when initializing a metadata source"
+        end
+        unless (args.key?(:edition))
+          raise ":edition must be specified when initializing a metadata source"
+        end
+
+        @engine = args[:engine]
+        @name = args[:name]
+        @component = args[:component]
+        @edition = args[:edition]
+
+        if (args[:url])
+          @url = args[:url]
+        else
+          @url = @component.primary.url
+        end
+        @write_url = @url
+        cachepath = args[:cachepath]
+        @components = {}
+        @releases = {}
+        @data = {}
+        @cleanup = []
+
+        if (cachepath == nil)
+          @cachepath = Dir.mktmpdir("cachedir")
+          @cleanup << @cachepath
+        else
+          @cachepath = File.absolute_path(cachepath);
+        end
+        retval = Simp::Metadata.download_component(@component, {"target" => @cachepath})
+        load_from_dir(retval["path"])
+
+        @dirty = false
+      end
+
+      def to_s()
+        self.name
+      end
+
+      def writable?()
+        true
+      end
+      def write_url
+        @write_url
+      end
+      def write_url=(value)
+        if (value != @url)
+          @write_url = value
+          FileUtils.rm_r("#{@cachepath}/#{@component.name}")
+          retval = Simp::Metadata.download_component(@component, {"target" => @cachepath, "url" => value})
+          load_from_dir(retval["path"])
+        end
+      end
+      def release(version)
+        if (self.releases.key?(version))
+          self.releases[version]
+        else
+          {}
+        end
+      end
+
+      def delete_release(version)
+        if (@releases.key?(version))
+          self.dirty = true
+          @releases.delete(version)
+        end
+      end
+
+      def create_release(destination, source = 'master')
+        if (@releases.key?(destination))
+          raise "destination version #{destination} already exists"
+        end
+        unless (@releases.key?(source))
+          raise "source version #{source} doesn't exist"
+        end
+        self.dirty = true
+        @releases[destination] = Marshal.load(Marshal.dump(@releases[source]))
+      end
+
+      def dirty?()
+        @dirty
+      end
+
+      def dirty=(value)
+        @dirty = value
+      end
+
+      def save(message = "Auto-saving using simp-metadata")
+        if (self.dirty? == true)
+          puts @load_path
+          # XXX ToDo: Write files to yaml, commit and push (where appropriate)
+
+
+
+          Simp::Metadata.run("cd #{@load_path} && rm -rf v1")
+          FileUtils.mkdir_p("#{@load_path}/v1")
+          File.open("#{@load_path}/v1/components.yaml", 'w') {|file| file.write({"components" => @components}.to_yaml)}
+          @releases.each do |releasename, data|
+            directory = "releases"
+            case releasename
+              when /.*-[Aa][Ll][Pp][Hh][Aa].*/
+                directory = "prereleases"
+              when /.*-[Bb][Ee][Tt][Aa].*/
+                directory = "prereleases"
+              when /.*-[Rr][Cc].*/
+                directory = "prereleases"
+              when /^nightly\-/
+                directory = "nightlies"
+              when /develop/
+                directory = "channels"
+              when /development/
+                directory = "channels"
+              when /master/
+                directory = "channels"
+              when /^test\-/
+                directory = "tests"
+              else
+                directory = "releases"
+            end
+            FileUtils.mkdir_p("#{@load_path}/v1/#{directory}")
+            File.open("#{@load_path}/v1/#{directory}/#{releasename}.yaml", 'w') {|file| file.write({"releases" => {"#{releasename}" => data}}.to_yaml)}
+          end
+          Simp::Metadata.run("cd #{@load_path} && git remote add upstream #{write_url}")
+          Simp::Metadata.run("cd #{@load_path} && git remote set-url upstream #{write_url}")
+          exitcode = Simp::Metadata.run("cd #{@load_path} && git add -A && git commit -m '#{message}'; git push upstream master")
+          if (exitcode != 0)
+            Simp::Metadata.critical("error committing changes")
+            raise "#{exitcode}"
+          else
+            puts "Successfully updated #{name}"
+          end
+          self.dirty = false
+        end
+      end
+
+      def load_from_dir(path)
+        @load_path = path
+        Dir.chdir(path) do
+          Dir.glob("**/*.yaml") do |filename|
+            begin
+              hash = YAML.load_file(filename)
+              @data = deep_merge(@data, hash)
+            end
+          end
+        end
+        unless @data['releases'] == nil
+          @releases = @data['releases']
+        end
+        unless @data['components'] == nil
+          @components = @data['components']
+        end
+      end
+
+      def deep_merge(target_hash, source_hash)
+        source_hash.each do |key, value|
+          if (target_hash.key?(key))
+            if (value.class == Hash)
+              self.deep_merge(target_hash[key], value)
+            else
+              target_hash[key] = value
+            end
+          else
+            target_hash[key] = value
+          end
+        end
+        target_hash
+      end
+
+      def cleanup()
+        @cleanup.each do |path|
+          FileUtils.rmtree(path)
+        end
+      end
+    end
+  end
+end
+

data/spec/simp/media/command_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+require 'simp/media'
+require 'simp/media/command'
+
+describe Simp::Media::Command do
+  xit "Should display help when no options are passed" do
+    # Create an output capture system.
+    command = Simp::Media::Command.new()
+    command.run([])
+  end
+
+end

data/spec/simp/media/engine_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+require 'simp/media'
+
+describe Simp::Media::Engine do
+  it "should throw an error if input_type is nil" do
+    expect { engine = Simp::Media::Engine.new({"version" => "test-stub", "input_type" => nil}) }.to raise_error(RuntimeError, "input_type must be specified")
+  end
+  it "should throw an error if output_type is nil" do
+    expect { engine = Simp::Media::Engine.new({"version" => "test-stub", "output_type" => nil}) }.to raise_error(RuntimeError, "output_type must be specified")
+  end
+  it "should instantiate without errors" do
+    tempdir = Dir.mktmpdir("simp-media-rspec")
+    engine = Simp::Media::Engine.new({"version" => "test-stub", "edition" => "community", "output_type" => "tar", "output" => "#{tempdir}/test.tgz"})
+    expect(engine.loaded?).to match(true)
+    engine.cleanup()
+    engine = nil
+    FileUtils.rmtree(tempdir)
+  end
+  it "should run without errors" do
+    tempdir = Dir.mktmpdir("simp-media-rspec")
+    engine = Simp::Media::Engine.new({"version" => "test-stub", "edition" => "community", "output_type" => "tar", "output" => "#{tempdir}/test.tgz"})
+    expect(engine.loaded?).to match(true)
+    engine.run
+    engine.cleanup()
+    engine = nil
+    FileUtils.rmtree(tempdir)
+  end
+end

data/spec/simp/media/type/control_repo_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+require 'simp/media'
+
+describe Simp::Media::Type::Control_repo do
+
+  it "should throw an error if output is nil" do
+    expect { engine = Simp::Media::Engine.new({"version" => "test-stub", "output" => nil}) }.to raise_error(RuntimeError, "output must be specified for control-repo output")
+  end
+  it "should throw an error if output is not a git repo and it's not a local directory" do
+    expect { engine = Simp::Media::Engine.new({"version" => "test-stub", "output" => "https://localhost:6666/repo.git"}) }.to raise_error(RuntimeError, "output is not a valid control-repo")
+  end
+
+  it "should create a bare repo when .git is part of the path" do
+    tempdir = Dir.mktmpdir("simp-media-rspec")
+    engine = Simp::Media::Engine.new({"version" => "test-stub", "output" => "file://#{tempdir}/control-repo.git"})
+    expect(engine.loaded?).to match(true)
+    engine.run()
+    engine.cleanup()
+    engine = nil
+    FileUtils.rmtree(tempdir)
+  end
+
+end