config_kit 0.0.11

data/lib/config_kit/cli/commands/get.rb

@@ -0,0 +1,37 @@
+module ConfigKit::Cli
+  class Get < Command
+    def self.command; "get"; end
+
+    def initialize(args)
+      @app = 'all'
+      @output = nil
+      super(args)
+    end
+
+    def run
+      begin
+        @output = ConfigKit::Manager.get(@app)
+        pp @output
+      rescue ConfigKit::Cli::Command::CommandFailure
+        raise
+      rescue => e
+        ConfigKit.logger.error "Unexpected error attempting to get config data #{@uri} in env #{@env} for #{@app.nil? ? 'all' : @app}"
+        ConfigKit.logger.debug "#{e}: #{e.backtrace.join("\n   ")}"
+        raise ConfigKit::Cli::Command::CommandFailure.new(e.to_s)
+      end
+    end
+
+    private
+    def options
+      OptionParser.new %Q{Usage: #{$0} #{self.class.command} [OPTIONS] ["description"] }, 40 do |opts|
+        opts.separator ''
+        opts.separator 'Specific options:'
+
+        opts.on('-a APP', '--app', 'Specify an app of config to create(default: all to deploy all apps)') do |app|
+          @app = app
+        end
+      end
+    end
+  end
+
+end

data/lib/config_kit/cli/commands/init.rb

@@ -0,0 +1,42 @@
+module ConfigKit::Cli
+  class Init < Command
+    def self.command; "init"; end
+
+    def initialize(args)
+      @output
+      super(args)
+    end
+
+    def run
+      begin
+        raise ConfigKit::Cli::Command::CommandFailure.new 'Missing name options' if @name.nil?
+        raise ConfigKit::Cli::Command::CommandFailure.new 'Missing environment options' if @env.nil?
+        @output = ConfigKit::Manager.init(@name, @env)
+        pp @output.to_h.to_json
+      rescue ConfigKit::Cli::Command::CommandFailure
+        raise
+      rescue => e
+        ConfigKit.logger.error "Unexpected error attempting to get config data #{@uri} in env #{@env} for #{@app.nil? ? 'all' : @app}"
+        ConfigKit.logger.debug "#{e}: #{e.backtrace.join("\n   ")}"
+        raise ConfigKit::Cli::Command::CommandFailure.new(e.to_s)
+      end
+    end
+
+    private
+    def options
+      OptionParser.new %Q{Usage: #{$0} #{self.class.command} [OPTIONS] ["description"] }, 40 do |opts|
+        opts.separator ''
+        opts.separator 'Specific options:'
+
+        opts.on('-n NAME', '--name', 'Specify a name of IDC to config') do |name|
+          @name = name
+        end
+
+        opts.on('-e ENV', '--env', 'Specify a environment of IDC to config') do |env|
+          @env = env
+        end
+      end
+    end
+  end
+
+end

data/lib/config_kit/cli/commands/rollback.rb

@@ -0,0 +1,40 @@
+module ConfigKit::Cli
+  class Rollback < Command
+    def self.command; "rollback"; end
+
+    def initialize(args)
+      @app = nil
+      super(args)
+    end
+
+    def run
+      begin
+        @output = ConfigKit::Manager.rollback(@app, @version)
+        pp @output.to_h.to_json
+      rescue ConfigKit::Cli::Command::CommandFailure
+        raise
+      rescue => e
+        ConfigKit.logger.error "Unexpected error attempting to get config data #{@uri} in env #{@env} for #{@app.nil? ? 'all' : @app}"
+        ConfigKit.logger.debug "#{e}: #{e.backtrace.join("\n   ")}"
+        raise ConfigKit::Cli::Command::CommandFailure.new(e.to_s)
+      end
+    end
+
+    private
+    def options
+      OptionParser.new %Q{Usage: #{$0} #{self.class.command} [OPTIONS] ["description"] }, 40 do |opts|
+        opts.separator ''
+        opts.separator 'Specific options:'
+
+        opts.on('-v VERSION', '--version', 'Specify a existing version to rollout') do |version|
+          @version = version[0] == 'v' ? version : "v#{version}"
+        end
+
+        opts.on('-a APP', '--app', 'Specify an app of config to create(default: all to deploy all apps)') do |app|
+          @app = app
+        end
+      end
+    end
+  end
+
+end

data/lib/config_kit/client.rb

@@ -0,0 +1,203 @@
+require 'diplomat'
+require 'config_kit/error'
+module ConfigKit
+  class Client
+    class ConfigKitCreateError < ConfigKit::Error; end
+    class ConfigKitUpdateError < ConfigKit::Error; end
+    class ConfigKitTxnError < ConfigKit::Error; end
+    class ConfigKitReadError < ConfigKit::Error; end
+    attr_reader :url, :acl_token, :opts
+
+    class ConsulConnection
+      attr_reader :config, :connection
+
+      extend Forwardable
+      def_delegators :@connection, :put, :get, :delete, :txn
+      def initialize(url, acl_token)
+        setup_consul(url, acl_token)
+      end
+
+      def setup_consul(url, acl_token)
+        @config = Diplomat.configure do |config|
+          config.url = url
+          config.acl_token = acl_token unless acl_token.nil?
+        end
+        @connection = Diplomat
+      end
+
+      def put!(key, value, options = nil)
+        response = put(key, value, options = nil)
+        raise ConfigKitUpdateError, "Config Kit Update key:#{key} error" unless response
+        response
+      end
+
+      def create_txn(data)
+        prepare_txn_data(data,type='create')
+        self
+      end
+
+      def read_txn(data,recurse=false)
+        prepare_txn_data(data,type='read',recurse)
+        self
+      end
+
+      def update_txn(data)
+        prepare_txn_data(data,type='read')
+        self
+      end
+
+      def delete_txn(data,recurse=false)
+        prepare_txn_data(data,type='delete',recurse)
+        self
+      end
+
+      def init_txn
+        reset_txn_data
+      end
+
+      def perform_txn
+        begin
+          txn(@txn_data)
+        rescue => e
+          raise ConfigKitTxnError.new "perform txn error:#{e.message}"
+        ensure
+          reset_txn_data
+        end
+      end
+
+      def reset_txn_data
+        @txn_data = []
+      end
+
+      def prepare_txn_data(data, type='read', recurse=false)
+        init_txn if @txn_data.nil?
+        verb = determine_verb(type, recurse)
+        data.each_pair do |k,v|
+          kv = {
+             "Verb" => verb,
+              "Key" => k.to_s,
+            "Value" => v.to_s
+          }
+
+          @txn_data << {"KV" => kv}
+        end
+        @txn_data
+      end
+      
+      def determine_verb(_type, recurse)
+        verb = nil
+        type = _type.to_s
+        case type
+        when 'read'
+          if recurse
+            verb = 'get-tree'
+          else
+            verb = 'get'
+          end
+        when 'update'
+          verb = 'set'
+        when 'create'
+          verb = 'set'
+        when 'delete'
+          if recurse
+            verb = 'delete-tree'
+          else
+           verb = 'delete'
+          end
+        else
+          verb = nil
+        end
+        verb
+      end
+    end
+
+    def initialize(url, acl_token)
+      @url = url
+      @acl_token = acl_token
+      @connection = ConsulConnection.new(@url, @acl_token)
+    end
+
+    def create(key,value)
+      response = @connection.put(key, value, cas: 0)
+      raise ConfigKitCreateError, "Config Kit create #{key} error" unless response
+      response
+    end
+
+    def update(key, value)
+      response = @connection.put(key, value)
+      raise ConfigKitUpdateError, "Config Kit update #{key} error" unless response
+    end
+
+    def atom_update(key,value)
+      begin
+        retries ||= 0
+        modify_idx = @connection.get(key, modify_index: true)
+        response = @connection.put!(key, value, cas: modify_idx)
+      rescue ConfigKitUpdateError => e
+        if (retries += 1) < 3
+          #
+          # TODO: 
+          # 1. Need to log
+          # 2. Need to delay and retry refactor
+          #
+          sleep(0.5)
+          retry
+        end
+      end
+    end
+
+    #
+    # TODO: enhancement
+    #
+    def read(key, convert_to_hash=true, recurse=true)
+      begin
+        ConfigKit.logger.debug "getting key: #{key}"
+        response = @connection.get(key, convert_to_hash: convert_to_hash, recurse: recurse)
+        response
+      rescue Diplomat::KeyNotFound => e
+        return nil
+      rescue Faraday::ConnectionFailed => e
+        raise ConfigKitReadError, "config server #{@url} is not avaliable. #{e.message}"
+      rescue Diplomat::UnknownStatus => e
+        raise ConfigKitReadError, "Unknown error #{e.message}."
+      rescue Exception => e
+        ConfigKit.logger.debug e.backtrace.join("\n ")
+        return nil
+      end
+
+    end
+
+    #
+    # TODO: enhancement
+    #
+
+    def delete(key)
+      response = @connection.delete(url, recurse: true)
+      response
+    end
+
+    def create_txn(data)
+      @connection.create_txn(data)
+    end
+
+    def read_txn(data)
+      @connection.read_txn(data)
+    end
+
+    def update_txn(data)
+      @connection.update_txn(data)
+    end
+
+    def delete_txn(data)
+      @connection.delete_txn(data)
+    end
+
+    def init_txn
+      @connection.init_txn
+    end
+
+    def perform_txn
+      @connection.perform_txn
+    end
+  end
+end

data/lib/config_kit/config_data.rb

@@ -0,0 +1,92 @@
+require 'config_kit/ext/slashed_hash'
+
+module ConfigKit
+  class ConfigData < SlashedHash
+    class MetadataError < ConfigKit::Error; end
+    class MetadataMissingRequireFieldError < ConfigKit::Error; end
+
+    class DataError < ConfigKit::Error; end
+    class DataMissingRequireFieldError < ConfigKit::Error; end
+
+    def initialize(config_data, name, api_version='v1.0', kind='config_kit')
+      
+      @defined_api_version=api_version
+      @defined_kind = kind
+
+      @metadata_required_fields = ['api_version', 'kind']
+      @data_required_fields = ['version', 'namespace']
+      @config_data = config_data
+      @name = name
+      check_metadata
+      check_data
+      @binded_data = binding_data
+      super(@binded_data)
+    end
+
+    def check_data
+      raise DataError, 'Config Kit Support Hash Data Formate ONLY.' unless data.is_a?(Hash)
+      @data_required_fields.each do |f|
+        raise DataMissingRequireFieldError,"Config Kit Raw data missing require field #{f} " unless data.has_key?(f)
+      end
+    end
+
+    def check_metadata
+      raise MetadataError, 'Config Kit Support Hash Data Formate ONLY.' unless @config_data.is_a?(Hash)
+      @metadata_required_fields.each do |f|
+        raise MetadataMissingRequireFieldError,"Config Kit Meta data missing require field #{f} " unless @config_data.has_key?(f)
+      end
+      raise MetadataError, "Config Kit API Version metadata mis-match #{@config_data['api_version']}." unless support_api?
+      raise MetadataError, "Config Kit Kind metadate mis-match #{@config_data['kind']}." unless same_kind?
+    end
+
+    def binding_version
+      { data_version => data }
+    end
+
+    def binding_name
+      { @name => binding_version }
+    end
+
+    def binding_kind
+      { kind => binding_name }
+    end
+
+    #
+    # /v1/config_kit/axle/v1.0/database => mysql
+    #
+
+    def binding_data
+      binding_kind
+    end
+
+    def same_kind?
+      @defined_kind == kind  
+    end
+
+    def support_api?
+      @defined_api_version == api_version
+    end
+
+    def data_version
+      _version = @config_data && @config_data[@name] && @config_data[@name]['version']
+      version = _version[0] == 'v' ? _version : "v#{_version}"
+      version
+    end
+
+    def data_cs
+      nil
+    end
+
+    def data
+      @config_data && @config_data[@name]
+    end
+
+    def api_version
+      @config_data['api_version']
+    end
+
+    def kind
+      @config_data['kind']
+    end
+  end
+end

data/lib/config_kit/configuration.rb

@@ -0,0 +1,16 @@
+require 'logger'
+module ConfigKit
+  class Configuration
+    attr_accessor :url, :acl_token, :options, :api_version, :kind, :debug, :logger
+    def initialize(url, opts={})
+      @url = url
+      @opts = opts
+      @acl_token = opts[:acl_token]
+      @api_version = 'v1.0'
+      @kind = 'config_kit'
+      @logger = @opts.fetch(:logger, ::Logger.new(STDOUT))
+      @debug = @opts[:debug] || false
+      @logger.level = ::Logger::DEBUG if @debug 
+    end
+  end
+end

data/lib/config_kit/data/loader.rb

@@ -0,0 +1,91 @@
+require 'uri'
+module ConfigKit
+  module Data
+    class Loader
+
+      class LoaderFailure < StandardError
+        attr_reader :options
+        def initialize message, opts=nil
+          super message
+          @options = opts
+        end
+      end
+
+      def self.info(message)
+        STDOUT.puts message
+      end
+
+      def self.err(message)
+        STDERR.puts message
+      end
+
+
+      @loaders = []
+
+      def self.inherited(subclass)
+        @loaders << subclass
+      end
+
+      ldrs = ldrs = File.expand_path(File.join(File.dirname(__FILE__), 'loaders', '*.rb'))
+      Dir[ldrs].each {|loader| require loader}
+
+      def self.load(app, from, uri_kls, env, version, &block)
+        @loader_names = @loaders.map{ |l| l.loader}
+
+        @uri_kls, @env, @app, @version = uri_kls, env, app, version
+
+        loader = from
+
+
+        if loader.nil?
+          ConfigKit.logger.error "from empty source with #{@uri_kls.to_s}"
+        elsif !@loader_names.include?(loader)
+          ConfigKit.logger.error "Unrecognize loader: #{loader} for #{@uri}"
+        else
+          loader_class = @loaders.find{ |c| c.loader == loader}
+          ConfigKit.logger.debug "#{loader_class.loader} is loading env(#{@env}) app(#{app}) data(#{@version}) from #{uri_kls.to_s}"
+          loader_class.new(@uri_kls, @env, @app, @version).run(&block)
+          ConfigKit.logger.debug "#{loader_class.loader} is loaded env(#{@env}) app(#{app}) data(#{@version}) from #{uri_kls.to_s}"
+        end
+      rescue => e
+        raise ConfigKit::Data::Loader::LoaderFailure.new e.message
+      end
+      
+      attr_reader :cursor,:batch_size, :files
+      def initialize(batch_size=10)
+        @files = []
+        @batch_size = batch_size
+        @current_files = []
+        @cursor = 0
+        @files = retrieve_files
+      end
+
+      def file_count
+        @files.count
+      end
+
+      def next_batch
+        if finish?
+          @current_files = []
+          @cursor = file_count
+          return @cursor
+        end
+        _next_cursor = next_cursor
+        @current_files = @files[@cursor.._next_cursor - 1]
+        @cursor = _next_cursor
+      end
+
+      def next_cursor
+        @cursor + @batch_size > file_count ? file_count : (@cursor + @batch_size)
+      end
+
+      def finish?
+        @cursor >= file_count
+      end
+
+      def retrieve_files
+        raise NotImplementedError
+      end
+    end
+  end
+end