mamiya 0.0.1.alpha2

data/lib/mamiya/steps/build.rb

@@ -0,0 +1,72 @@
+require 'mamiya/steps/abstract'
+require 'mamiya/package'
+
+module Mamiya
+  module Steps
+    class Build < Abstract
+      def run!
+        @exception = nil
+
+        logger.info "Initiating package build"
+
+        logger.info "Running script.before_build"
+        script.before_build[]
+
+        unless script.skip_prepare_build
+          logger.info "Running script.prepare_build"
+          script.prepare_build[File.exists?(script.build_from)]
+        else
+          logger.debug "prepare_build skipped due to script.skip_prepare_build"
+        end
+
+        old_pwd = Dir.pwd
+        begin
+          # Using without block because chdir in block shows warning
+          Dir.chdir(script.build_from)
+          logger.info "Running script.build ..."
+          logger.debug "pwd=#{Dir.pwd}"
+          script.build[]
+        ensure
+          Dir.chdir old_pwd
+        end
+
+
+        logger.debug "Determining package name..."
+        package_name = Dir.chdir(script.build_from) {
+          script.package_name[
+            [Time.now.strftime("%Y-%m-%d_%H.%M.%S"), script.application]
+          ].join('-')
+        }
+        logger.info "Package name determined: #{package_name}"
+
+        package_path = File.join(script.build_to, package_name)
+        package = Mamiya::Package.new(package_path)
+        package.meta[:application] = script.application
+
+        Dir.chdir(script.build_from) do
+          package.meta.replace script.package_meta[package.meta]
+        end
+
+        logger.info "Packaging to: #{package.path}"
+        logger.debug "meta=#{package.meta.inspect}"
+        package.build!(script.build_from,
+           exclude_from_package: script.exclude_from_package || [],
+           dereference_symlinks: script.dereference_symlinks || false,
+           package_under: script.package_under || nil,
+           logger: logger)
+        logger.info "Packed."
+
+      rescue Exception => e
+        @exception = e
+        raise
+      ensure
+        logger.warn "Exception occured, cleaning up..." if @exception
+
+        logger.info "Running script.after_build"
+        script.after_build[@exception]
+
+        logger.info "DONE!" unless @exception
+      end
+    end
+  end
+end

data/lib/mamiya/steps/extract.rb

@@ -0,0 +1,26 @@
+require 'mamiya/steps/abstract'
+
+
+module Mamiya
+  module Steps
+    class Extract < Abstract
+      def run!
+        package = case options[:package]
+                  when Mamiya::Package
+                    options[:package]
+                  else
+                    Mamiya::Package.new(options[:package])
+                  end
+
+        if File.exists?(options[:destination])
+          destination = File.join(options[:destination], package.name)
+        else
+          destination = options[:destination]
+        end
+
+        logger.info "Extracting #{package.path} onto #{destination}"
+        package.extract_onto!(destination)
+      end
+    end
+  end
+end

data/lib/mamiya/steps/fetch.rb

@@ -0,0 +1,24 @@
+require 'mamiya/steps/abstract'
+require 'mamiya/package'
+
+module Mamiya
+  module Steps
+    class Fetch < Abstract
+      def run!
+        application = options[:application] || (script && script.application)
+
+        raise 'no application name given' unless application
+
+        storage = config.storage_class.new(
+          config[:storage].merge(
+            application: application
+          )
+        )
+
+        logger.info("Fetching package #{options[:package]} from storage(app=#{storage.application}) to #{options[:destination]}...")
+        storage.fetch(options[:package], options[:destination])
+      end
+    end
+  end
+end
+

data/lib/mamiya/steps/push.rb

@@ -0,0 +1,34 @@
+require 'mamiya/steps/abstract'
+require 'mamiya/package'
+
+module Mamiya
+  module Steps
+    class Push < Abstract
+      def run!
+        package = case options[:package]
+                  when Mamiya::Package
+                    options[:package]
+                  else
+                    Mamiya::Package.new(options[:package])
+                  end
+
+        application = options[:application] || package.application
+
+        raise 'no application name given' unless application
+
+        storage = config.storage_class.new(
+          config[:storage].merge(
+            application: application
+          )
+        )
+
+        logger.info "Pushing #{package.path} to storage(app=#{storage.application})..."
+
+        storage.push(package)
+
+        logger.info "DONE!"
+      end
+    end
+  end
+end
+

data/lib/mamiya/storages.rb

@@ -0,0 +1,17 @@
+module Mamiya
+  module Storages
+    def self.find(name)
+      name = name.to_s
+      classish_name = name.capitalize.gsub(/_./) { |s| s[1].upcase }
+
+      begin
+        return const_get(classish_name)
+      rescue NameError; end
+
+      require "mamiya/storages/#{File.basename(name)}"
+      const_get(classish_name)
+    rescue NameError, LoadError
+      return nil
+    end
+  end
+end

data/lib/mamiya/storages/abstract.rb

@@ -0,0 +1,48 @@
+module Mamiya
+  module Storages
+    class Abstract
+      class NotBuilt < Exception; end
+      class NotFound < Exception; end
+      class AlreadyExists < Exception; end
+      class AlreadyFetched < Exception; end
+
+      def initialize(config = {})
+        @config = config.dup
+        @application = config.delete(:application)
+      end
+
+      attr_reader :config, :application
+
+      def self.find(config={})
+        {}
+      end
+
+      def packages
+        []
+      end
+
+      def push(package)
+        raise NotImplementedError
+      end
+
+      def fetch(package_name, dir)
+        raise NotImplementedError
+      end
+
+      def meta(package_name)
+        raise NotImplementedError
+      end
+
+      def remove(package)
+        raise NotImplementedError
+      end
+
+      def prune(nums_to_keep)
+        packages = self.packages()
+        (packages - packages.last(nums_to_keep)).each do |package|
+          self.remove(package)
+        end
+      end
+    end
+  end
+end

data/lib/mamiya/storages/mock.rb

@@ -0,0 +1,61 @@
+require 'mamiya/package'
+require 'mamiya/storages/abstract'
+require 'fileutils'
+
+module Mamiya
+  module Storages
+    class Mock < Mamiya::Storages::Abstract
+      def self.storage
+        @storage ||= {}
+      end
+
+      def self.clear
+        @storage = {}
+      end
+
+      def self.find(config={})
+        storage.keys
+      end
+
+      def initialize(*)
+        super
+        self.class.storage[application] ||= {}
+      end
+
+      def packages
+        self.class.storage[application].keys
+      end
+
+      def push(package)
+        raise TypeError, "package should be a kind of Mamiya::Package" unless package.kind_of?(Mamiya::Package)
+        raise NotBuilt, "package not built" unless package.exists?
+        self.class.storage[application] ||= {}
+        raise AlreadyExists if self.class.storage[application][package.name]
+        self.class.storage[application][package.name] = {package: package, config: config}
+      end
+
+      def fetch(package_name, destination)
+        self.class.storage[application] ||= {}
+        raise NotFound unless self.class.storage[application][package_name]
+        package_path = File.join(destination, "#{package_name}.tar.gz")
+        meta_path = File.join(destination, "#{package_name}.json")
+
+        if File.exists?(package_path) || File.exists?(meta_path)
+          raise AlreadyFetched
+        end
+
+        package = self.class.storage[application][package_name][:package]
+        FileUtils.cp package.path, package_path
+        FileUtils.cp package.meta_path, meta_path
+        return package
+      end
+
+      def meta(package_name)
+        package = self.class.storage[application][package_name]
+        return unless package
+
+        package[:package].meta
+      end
+    end
+  end
+end

data/lib/mamiya/storages/s3.rb

@@ -0,0 +1,127 @@
+require 'mamiya/package'
+require 'mamiya/storages/abstract'
+require 'aws-sdk-core'
+require 'json'
+
+module Mamiya
+  module Storages
+    class S3 < Mamiya::Storages::Abstract
+      def self.find(config={})
+        s3 = initiate_s3_with_config(config)
+        Hash[s3.list_objects(bucket: config[:bucket], delimiter: '/').common_prefixes.map { |prefix|
+          app = prefix.prefix.gsub(%r{/$},'')
+          [app, self.new(config.merge(application: app))]
+        }]
+      end
+
+      def packages
+        s3.list_objects(bucket: @config[:bucket], delimiter: '/', prefix: "#{self.application}/").contents.map { |content|
+          content.key.sub(/\A#{Regexp.escape(self.application)}\//, '')
+        }.group_by { |key|
+          key.sub(Package::PATH_SUFFIXES,'')
+        }.select { |key, files|
+          files.find { |file| file.end_with?('.tar.gz') } && files.find { |file| file.end_with?('.json') }
+        }.keys
+      end
+
+      def push(package)
+        raise TypeError, "package should be a kind of Mamiya::Package" unless package.kind_of?(Mamiya::Package)
+        raise NotBuilt, "package not built" unless package.exists?
+
+        package_key, meta_key = package_and_meta_key_for(package.name)
+
+        [package_key, meta_key].each do |key|
+          raise AlreadyExists if key_exists_in_s3?(key)
+        end
+
+        open(package.path, 'rb') do |io|
+          s3.put_object(bucket: @config[:bucket], key: package_key, body: io)
+        end
+        open(package.meta_path, 'rb') do |io|
+          s3.put_object(bucket: @config[:bucket], key: meta_key, body: io)
+        end
+      end
+
+      def fetch(package_name, dir)
+        package_key, meta_key = package_and_meta_key_for(package_name)
+
+        package_path = File.join(dir, File.basename(package_key))
+        meta_path = File.join(dir, File.basename(meta_key))
+
+        if File.exists?(package_path) || File.exists?(meta_path)
+          raise AlreadyFetched
+        end
+
+        open(package_path, 'wb+') do |io|
+          s3.get_object({bucket: @config[:bucket], key: package_key}, target: io)
+        end
+        open(meta_path, 'wb+') do |io|
+          s3.get_object({bucket: @config[:bucket], key: meta_key}, target: io)
+        end
+
+        return Mamiya::Package.new(package_path)
+      rescue Aws::S3::Errors::NoSuchKey
+        File.unlink package_path if package_path && File.exists?(package_path)
+        File.unlink meta_path if meta_path && File.exists?(meta_path)
+
+        raise NotFound
+      rescue Exception => e
+        File.unlink package_path if package_path && File.exists?(package_path)
+        File.unlink meta_path if meta_path && File.exists?(meta_path)
+
+        raise e
+      end
+
+      def meta(package_name)
+        _, meta_key = package_and_meta_key_for(package_name)
+        JSON.parse(s3.get_object(bucket: @config[:bucket], key: meta_key).body.string)
+      rescue Aws::S3::Errors::NoSuchKey
+        return nil
+      end
+
+      def remove(package_name)
+        package_key, meta_key = package_and_meta_key_for(package_name)
+
+        objs_to_delete = [package_key, meta_key].map { |key|
+          if key_exists_in_s3?(key)
+            {key: key}
+          else
+            nil
+          end
+        }.compact
+        raise NotFound if objs_to_delete.empty?
+
+        s3.delete_objects(bucket: @config[:bucket], objects: objs_to_delete)
+      end
+
+      def self.initiate_s3_with_config(config) # :nodoc:
+        s3_config = config.dup
+        s3_config.delete(:bucket)
+        s3_config.delete(:application)
+        s3_config.delete(:type)
+        Aws::S3.new(s3_config)
+      end
+
+      private
+
+      def s3
+        @s3 ||= self.class.initiate_s3_with_config(@config)
+      end
+
+      def package_and_meta_key_for(package_name)
+        package_name = package_name.sub(/\.(?:tar\.gz|json)\z/, '')
+        ["#{self.application}/#{package_name}.tar.gz", "#{self.application}/#{package_name}.json"]
+      end
+
+      def key_exists_in_s3?(key)
+        begin
+          if s3.head_object(bucket: @config[:bucket], key: key)
+            true
+          end
+        rescue Aws::S3::Errors::NotFound
+          false
+        end
+      end
+    end
+  end
+end

data/lib/mamiya/util/label_matcher.rb

@@ -0,0 +1,38 @@
+module Mamiya
+  module Util
+    module LabelMatcher
+      def match?(*expressions)
+        labels = self.labels()
+
+        if expressions.all? { |_| _.kind_of?(Symbol) || _.kind_of?(String) }
+          return self.match?(expressions)
+        end
+
+        expressions.any? do |expression|
+          case expression
+          when Symbol, String
+            labels.include?(expression)
+          when Array
+            if expression.any? { |_| _.kind_of?(Array) }
+              self.match?(*expression)
+            else
+              expression.all? { |_| labels.include?(_) }
+            end
+          end
+        end
+      end
+
+      alias matches? match?
+
+      class Simple
+        def initialize(*labels)
+          @labels = labels.flatten
+        end
+
+        attr_reader :labels
+
+        include LabelMatcher
+      end
+    end
+  end
+end