sfn 0.0.1 → 0.3.0

data/bin/sfn

@@ -0,0 +1,43 @@
+#!/usr/bin/env ruby
+
+require 'bogo-cli'
+require 'sfn'
+
+Bogo::Cli::Setup.define do
+
+  on :v, :version, 'Print version ' do
+    puts "sfn - SparkleFormation CLI - [Version: #{Sfn::VERSION}]"
+    exit
+  end
+
+  Sfn::Config.constants.map do |konst|
+    const = Sfn::Config.const_get(konst)
+    if(const.is_a?(Class) && const.ancestors.include?(Bogo::Config))
+      const
+    end
+  end.compact.sort_by(&:to_s).each do |klass|
+
+    klass_name = klass.name.split('::').last.downcase
+
+    command klass_name do
+      if(klass.const_defined?(:DESCRIPTION))
+        description klass.const_get(:DESCRIPTION)
+      end
+
+      Sfn::Config.options_for(klass).each do |name, info|
+        on_name = info[:boolean] ? info[:long] : "#{info[:long]}="
+        opts = Smash.new.tap do |o|
+          o[:default] = info[:default] if info[:default]
+          o[:as] = Array if info[:multiple]
+        end
+        on info[:short], on_name, info[:description], :default => info[:default]
+      end
+
+      run do |opts, args|
+        Bogo::Utility.constantize(klass.to_s.sub('Config', 'Command')).new(opts, args).execute!
+      end
+    end
+
+  end
+
+end

data/lib/chef/knife/knife_plugin_seed.rb

@@ -0,0 +1,117 @@
+begin
+  kcfn = Gem::Specification.find_by_name('knife-cloudformation')
+  $stderr.puts "[WARN]: Deprecated gem detected: #{kcfn.name} [V: #{kcfn.version}]"
+  $stderr.puts '[WARN]: Uninstall gem to prevent any conflicts (`gem uninstall knife-cloudformation -a`)'
+rescue Gem::LoadError => e
+  # ignore
+end
+
+unless(defined?(Chef::Knife::CloudformationCreate))
+
+  require 'sfn'
+  require 'bogo'
+
+  Chef::Config[:knife][:cloudformation] = {
+    :options => {},
+    :create => {},
+    :update => {}
+  }
+  Chef::Config[:knife][:sparkleformation] = Chef::Config[:knife][:cloudformation]
+
+  VALID_PREFIX = ['cloudformation', 'sparkleformation']
+
+
+  Sfn::Config.constants.map do |konst|
+    const = Sfn::Config.const_get(konst)
+    if(const.is_a?(Class) && const.ancestors.include?(Bogo::Config))
+      const
+    end
+  end.compact.sort_by(&:to_s).each do |klass|
+
+    VALID_PREFIX.each do |prefix|
+
+      klass_name = klass.name.split('::').last
+      command_class = "#{prefix.capitalize}#{klass_name}"
+
+      knife_klass = Class.new(Chef::Knife)
+      knife_klass.class_eval do
+
+        include Bogo::AnimalStrings
+
+        # Stub in names so knife will detect
+        def self.name
+          @name
+        end
+
+        def self.sfn_class
+          @sfn_class
+        end
+
+        def name
+          self.class.name
+        end
+
+        # Properly load in configurations and execute command
+        def run
+          knife = Chef::Config[:knife]
+          if(knife.respond_to?(:hash_dup))
+            knife = knife.hash_dup
+          end
+          base = knife.to_smash
+          keys = VALID_PREFIX.dup
+          cmd_config = keys.unshift(keys.delete(snake(self.class.name.split('::').last).to_s.split('_').first)).map do |k|
+            base[k]
+          end.compact.first || {}
+          cmd_config = cmd_config.to_smash
+          reconfig = config.find_all do |k,v|
+            !v.nil?
+          end
+          # Split up options provided multiple arguments
+          reconfig.map! do |k,v|
+            if(v.is_a?(String) && v.include?(','))
+              v = v.split(',').map(&:strip)
+            end
+            [k,v]
+          end
+          config = Smash[reconfig]
+          cmd_config = cmd_config.deep_merge(config)
+          self.class.sfn_class.new(cmd_config, name_args).execute!
+        end
+
+      end
+      knife_klass.instance_variable_set(:@name, "Chef::Knife::#{command_class}")
+      knife_klass.instance_variable_set(
+        :@sfn_class,
+        Bogo::Utility.constantize(klass.name.sub('Config', 'Command'))
+      )
+      knife_klass.banner "knife #{prefix} #{Bogo::Utility.snake(klass_name)}"
+
+      Sfn::Config.options_for(klass).each do |name, info|
+        if(info[:boolean])
+          short = "-#{info[:short]}"
+          long = "--[no-]#{info[:long]}"
+        else
+          val = 'VALUE'
+          if(info[:multiple])
+            val << '[,VALUE]'
+          end
+          short = "-#{info[:short]} #{val}"
+          long = "--#{info[:long]} #{val}"
+        end
+        knife_klass.option(
+          name.to_sym, {
+            :short => short,
+            :long => long,
+            :boolean => info[:boolean],
+            :default => info[:default],
+            :description => info[:description]
+          }
+        )
+      end
+      # Set the class as a proper constant
+      Chef::Knife.const_set(command_class, knife_klass)
+      # Force knife to pick up as a subcommand
+      Chef::Knife.inherited(knife_klass)
+    end
+  end
+end

data/lib/sfn.rb

@@ -0,0 +1,17 @@
+require 'sfn/version'
+require 'miasma'
+require 'bogo'
+
+module Sfn
+
+  autoload :Provider, 'sfn/provider'
+  autoload :Cache, 'sfn/cache'
+  autoload :Config, 'sfn/config'
+  autoload :Export, 'sfn/export'
+  autoload :Utils, 'sfn/utils'
+  autoload :MonkeyPatch, 'sfn/monkey_patch'
+  autoload :Knife, 'sfn/knife'
+  autoload :Command, 'sfn/command'
+  autoload :CommandModule, 'sfn/command_module'
+
+end

data/lib/sfn/cache.rb

@@ -0,0 +1,385 @@
+require 'digest/sha2'
+require 'thread'
+require 'sfn'
+
+module Sfn
+  # Data caching helper
+  class Cache
+
+    class << self
+
+      # Configure the caching approach to use
+      #
+      # @param type [Symbol] :redis or :local
+      # @param args [Hash] redis connection arguments if used
+      def configure(type, args={})
+        type = type.to_sym
+        case type
+        when :redis
+          begin
+            require 'redis-objects'
+          rescue LoadError
+            $stderr.puts 'The `redis-objects` gem is required for Cache support!'
+            raise
+          end
+          @_pid = Process.pid
+          Redis::Objects.redis = Redis.new(args)
+        when :local
+        else
+          raise TypeError.new("Unsupported caching type: #{type}")
+        end
+        enable(type)
+      end
+
+      # Set enabled caching type
+      #
+      # @param type [Symbol]
+      # @return [Symbol]
+      def enable(type)
+        @type = type.to_sym
+      end
+
+      # @return [Symbol] type of caching enabled
+      def type
+        @type || :local
+      end
+
+      # Set/get time limit on data type
+      #
+      # @param kind [String, Symbol] data type
+      # @param seconds [Integer]
+      # return [Integer] seconds
+      def apply_limit(kind, seconds=nil)
+        @apply_limit ||= {}
+        if(seconds)
+          @apply_limit[kind.to_sym] = seconds.to_i
+        end
+        @apply_limit[kind.to_sym].to_i
+      end
+
+      # @return [Hash] default limits
+      def default_limits
+        (@apply_limit || {}).dup
+      end
+
+      # Ping the redis connection and reconnect if dead
+      def redis_ping!
+        if((@_pid && @_pid != Process.pid) || !Redis::Objects.redis.connected?)
+          Redis::Objects.redis.client.reconnect
+          @_pid = Process.pid
+        end
+      end
+
+    end
+
+    # @return [String] custom key for this cache
+    attr_reader :key
+
+    # Create new instance
+    #
+    # @param key [String, Array]
+    def initialize(key)
+      if(key.respond_to?(:sort))
+        key = key.flatten if key.respond_to?(:flatten)
+        key = key.map(&:to_s).sort
+      end
+      @key = Digest::SHA256.hexdigest(key.to_s)
+      @apply_limit = self.class.default_limits
+    end
+
+    # Initialize a new data type
+    #
+    # @param name [Symbol] name of data
+    # @param kind [Symbol] data type
+    # @param args [Hash] options for data type
+    def init(name, kind, args={})
+      get_storage(self.class.type, kind, name, args)
+      true
+    end
+
+    # @return [Hash] data registry
+    def registry
+      get_storage(self.class.type, :hash, "registry_#{key}")
+    end
+
+    # Clear data
+    #
+    # @param args [Symbol] list of names to delete
+    # @return [TrueClass]
+    # @note clears all data if no names provided
+    def clear!(*args)
+      internal_lock do
+        args = registry.keys if args.empty?
+        args.each do |key|
+          value = self[key]
+          if(value.respond_to?(:clear))
+            value.clear
+          elsif(value.respond_to?(:value))
+            value.value = nil
+          end
+          registry.delete(key)
+        end
+        yield if block_given?
+      end
+      true
+    end
+
+    # Fetch item from storage
+    #
+    # @param store_type [Symbol]
+    # @param data_type [Symbol]
+    # @param name [Symbol] name of data
+    # @param args [Hash] options for underlying storage
+    # @return [Object]
+    def get_storage(store_type, data_type, name, args={})
+      full_name = "#{key}_#{name}"
+      result = nil
+      case store_type.to_sym
+      when :redis
+        result = get_redis_storage(data_type, full_name.to_s, args)
+      when :local
+        @_local_cache ||= {}
+        unless(@_local_cache[full_name.to_s])
+          @_local_cache[full_name.to_s] = get_local_storage(data_type, full_name.to_s, args)
+        end
+        result = @_local_cache[full_name.to_s]
+      else
+        raise TypeError.new("Unsupported caching storage type encountered: #{store_type}")
+      end
+      unless(full_name == "#{key}_registry_#{key}")
+        registry[name.to_s] = data_type
+      end
+      result
+    end
+
+    # Fetch item from redis storage
+    #
+    # @param data_type [Symbol]
+    # @param full_name [Symbol]
+    # @param args [Hash]
+    # @return [Object]
+    def get_redis_storage(data_type, full_name, args={})
+      self.class.redis_ping!
+      case data_type.to_sym
+      when :array
+        Redis::List.new(full_name, {:marshal => true}.merge(args))
+      when :hash
+        Redis::HashKey.new(full_name)
+      when :value
+        Redis::Value.new(full_name, {:marshal => true}.merge(args))
+      when :lock
+        Redis::Lock.new(full_name, {:expiration => 60, :timeout => 0.1}.merge(args))
+      when :stamped
+        Stamped.new(full_name.sub("#{key}_", '').to_sym, get_redis_storage(:value, full_name), self)
+      else
+        raise TypeError.new("Unsupported caching data type encountered: #{data_type}")
+      end
+    end
+
+    # Fetch item from local storage
+    #
+    # @param data_type [Symbol]
+    # @param full_name [Symbol]
+    # @param args [Hash]
+    # @return [Object]
+    # @todo make proper singleton for local storage
+    def get_local_storage(data_type, full_name, args={})
+      @storage ||= {}
+      @storage[full_name] ||= case data_type.to_sym
+        when :array
+          []
+        when :hash
+          {}
+        when :value
+          LocalValue.new
+        when :lock
+          LocalLock.new(full_name, {:expiration => 60, :timeout => 0.1}.merge(args))
+        when :stamped
+          Stamped.new(full_name.sub("#{key}_", '').to_sym, get_local_storage(:value, full_name), self)
+        else
+          raise TypeError.new("Unsupported caching data type encountered: #{data_type}")
+        end
+    end
+
+    # Execute block within internal lock
+    #
+    # @return [Object] result of yield
+    # @note for internal use
+    def internal_lock
+      get_storage(self.class.type, :lock, :internal_access, :timeout => 20, :expiration => 120).lock do
+        yield
+      end
+    end
+
+    # Fetch data
+    #
+    # @param name [String, Symbol]
+    # @return [Object, NilClass]
+    def [](name)
+      if(kind = registry[name.to_s])
+        get_storage(self.class.type, kind, name)
+      else
+        nil
+      end
+    end
+
+    # Set data
+    #
+    # @param key [Object]
+    # @param val [Object]
+    # @note this will never work, thus you should never use it
+    def []=(key, val)
+      raise 'Setting backend data is not allowed'
+    end
+
+    # Check if cache time has expired
+    #
+    # @param key [String, Symbol] value key
+    # @param stamp [Time, Integer]
+    # @return [TrueClass, FalseClass]
+    def time_check_allow?(key, stamp)
+      Time.now.to_i - stamp.to_i > apply_limit(key)
+    end
+
+    # Apply time limit for data type
+    #
+    # @param kind [String, Symbol] data type
+    # @param seconds [Integer]
+    # return [Integer]
+    def apply_limit(kind, seconds=nil)
+      @apply_limit ||= {}
+      if(seconds)
+        @apply_limit[kind.to_sym] = seconds.to_i
+      end
+      @apply_limit[kind.to_sym].to_i
+    end
+
+    # Perform action within lock
+    #
+    # @param lock_name [String, Symbol] name of lock
+    # @param raise_on_locked [TrueClass, FalseClass] raise execption if lock wait times out
+    # @return [Object] result of yield
+    def locked_action(lock_name, raise_on_locked=false)
+      begin
+        self[lock_name].lock do
+          yield
+        end
+      rescue => e
+        if(e.class.to_s == 'Redis::Lock::LockTimeout')
+          raise if raise_on_locked
+        else
+          raise
+        end
+      end
+    end
+
+    # Simple value for memory cache
+    class LocalValue
+      # @return [Object] value
+      attr_accessor :value
+      def initialize(*args)
+        @value = nil
+      end
+    end
+
+    # Simple lock for memory cache
+    class LocalLock
+
+      # @return [Symbol] key name
+      attr_reader :_key
+      # @return [Numeric] timeout
+      attr_reader :_timeout
+      # @return [Mutex] underlying lock
+      attr_reader :_lock
+
+      # Create new instance
+      #
+      # @param name [Symbol] name of lock
+      # @param args [Hash]
+      # @option args [Numeric] :timeout
+      def initialize(name, args={})
+        @_key = name
+        @_timeout = args.fetch(:timeout, -1).to_f
+        @_lock = Mutex.new
+      end
+
+      # Aquire lock and yield
+      #
+      # @yield block to execute within lock
+      # @return [Object] result of yield
+      def lock
+        locked = false
+        attempt_start = Time.now.to_f
+        while(!locked && (_timeout < 0 || Time.now.to_f - attempt_start < _timeout))
+          locked = _lock.try_lock
+        end
+        if(locked)
+          begin
+            yield
+          ensure
+            _lock.unlock if _lock.locked?
+          end
+        else
+          raise Redis::Lock::LockTimeout.new "Timeout on lock #{_key} exceeded #{_timeout} sec"
+        end
+      end
+
+      # Clear the lock
+      #
+      # @note this is a noop
+      def clear
+        # noop
+      end
+    end
+
+    # Wrapper to auto stamp values
+    class Stamped
+
+      # Create new instance
+      #
+      # @param name [String, Symbol]
+      # @param base [Redis::Value, LocalValue]
+      # @param cache [Cache]
+      def initialize(name, base, cache)
+        @name = name.to_sym
+        @base = base
+        @cache = cache
+      end
+
+      # @return [Object] value stored
+      def value
+        @base.value[:value] if set?
+      end
+
+      # Store value and update timestamp
+      #
+      # @param v [Object] value
+      # @return [Object]
+      def value=(v)
+        @base.value = {:stamp => Time.now.to_f, :value => v}
+        v
+      end
+
+      # @return [TrueClass, FalseClass] is value set
+      def set?
+        @base.value.is_a?(Hash)
+      end
+
+      # @return [Float] timestamp of last set (or 0.0 if unset)
+      def stamp
+        set? ? @base.value[:stamp] : 0.0
+      end
+
+      # Force a timestamp update
+      def restamp!
+        self.value = value
+      end
+
+      # @return [TrueClass, FalseClass] update is allowed based on stamp and limits
+      def update_allowed?
+        !set? || @cache.time_check_allow?(@name, @base.value[:stamp])
+      end
+    end
+
+  end
+end