persistence-providers 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a953df0805cd56776854b2ecc2536bd65168a09134cac2a9e19370800e2d08bf
+  data.tar.gz: cd8693b064bcc866ebdbbe870b258da63c4cf26ead0a844d7c6481b63f64dd37
+SHA512:
+  metadata.gz: 6a13cae6f9c26a52e2408e5c7f630ea85a2aab48da505b8ff35a89966a3004103ecf815bd37e618f61532e758f5576359e1a8074fe29be0010ed7e0c0a1a307b
+  data.tar.gz: 9059eeec1a431c6460e820afa1be83ee5a365b8df82980c528dd0397ca716d96571b4d92d0d0dd486ba4a39d3d12eda5763546929cd7341e73c5fa10ca0aee9f

data/Gemfile

@@ -0,0 +1,2 @@
+source 'https://rubygems.org'
+gemspec

data/lib/crd_client.rb

@@ -0,0 +1,49 @@
+require 'kubeclient'
+require 'celluloid/io'
+require 'singleton'
+
+module DTK
+  class CrdClient
+    include Singleton
+
+    attr_accessor :kubeclient
+
+    def self.get_kubeclient(opts)
+      if @kubeclient = opts[:kubeclient]
+        @kubeclient
+      else
+        ::DTK::CrdClient.instance.kubeclient
+      end
+    end
+
+    # opts can have keys
+    #   kubernetes_client - already instantiated kubernetes client
+    def initialize(opts = {})
+      if @kubeclient = opts[:kubernetes_client]
+        return @kubeclient
+      end
+
+      ssl_options  = {}
+      auth_options = { bearer_token_file: '/var/run/secrets/kubernetes.io/serviceaccount/token' }
+      
+      if File.exist?("/var/run/secrets/kubernetes.io/serviceaccount/ca.crt")
+        ssl_options[:ca_file] = "/var/run/secrets/kubernetes.io/serviceaccount/ca.crt"
+      end
+
+      socket_options = {
+        socket_class: Celluloid::IO::TCPSocket,
+        ssl_socket_class: Celluloid::IO::SSLSocket
+      }
+
+      @kubeclient = Kubeclient::Client.new(
+        'https://kubernetes.default.svc/apis/',
+        'dtk.io/v1alpha1',
+        auth_options: auth_options,
+        ssl_options:  ssl_options,
+        socket_options: socket_options 
+      )
+      @kubeclient.discover unless @kubeclient.discovered
+      @kubeclient
+    end
+  end
+end

data/lib/persistence_providers.rb

@@ -0,0 +1,9 @@
+module DTK
+  module State
+    require_relative 'crd_client'
+    require_relative 'state/crd_component'
+    require_relative 'state/component'
+    require_relative 'state/component_def'
+    require_relative 'state/executable_action'
+  end
+end

data/lib/state/component.rb

@@ -0,0 +1,73 @@
+module DTK::State
+  class Component
+    require_relative 'component/attribute'
+
+    attr_reader :name, :parent, :module_refs, :component_def
+
+    def initialize(name, component_content, parent, opts = {})
+      @name           = name
+      # @parent     = parent
+      @module_refs    = parent.module_refs
+      @component_def  = get_component_def(opts)
+
+      @attribute_objs = Attribute.create_from_kube_hash(component_content[:attributes])# convert_to_attribute_objects(component_content[:attributes])
+    end
+
+    # opts can have keys
+    #   task_id
+    def self.get(namespace, crd_component_name, component_name, opts = {})
+      crd_component = CrdComponent.get(namespace, crd_component_name, opts)
+      if matching_component = crd_component.components.find{ |cmp| cmp.to_hash.keys.first.to_s == component_name }
+        Component.new(component_name, matching_component[component_name], crd_component, opts)
+      end
+    end
+
+    # opts can have keys
+    # task_id
+    # format:
+    #   hash
+    #   kubernetes - return attributes in raw format from kubeclient
+    def self.get_attributes(namespace, crd_component_name, component_name, opts = {})
+      component = get(namespace, crd_component_name, component_name, opts)
+      component.attributes(opts)
+    end
+
+    def attributes(opts = {})
+      format = opts[:format]
+
+      return @attribute_objs unless format
+
+      if format.to_s == 'hash'
+        @attribute_objs.map{ |attr| attr.to_hash }
+      else
+        fail Error.new "Unsupported format '#{format}'"
+      end
+    end
+
+    def attribute_values
+      attribute_with_values = []
+      @content[:attributes].each do |name, content|
+        attribute_with_values << { name => content[:value] }
+      end
+      attribute_with_values
+    end
+
+    private
+
+    def get_component_def(opts = {})
+      destructured_component = destructure_component_full_name
+      module_ref             = @module_refs.find { |module_ref| module_ref[:name] == destructured_component[:module_name] }
+      ComponentDef.get(module_ref[:namespace], destructured_component[:component_def_name], opts)
+    end
+
+    def destructure_component_full_name
+      regex = /(.*)::(.*)\[(.*)\]/
+      module_name, component_def_name, component_name = @name.match(regex).captures
+      {
+        module_name: module_name,
+        component_def_name: "#{module_name}-#{component_def_name}",
+        component_name: component_name
+      }
+    end
+  end
+end

data/lib/state/component/attribute.rb

@@ -0,0 +1,88 @@
+module DTK::State
+  class Component
+    class Attribute
+      require_relative 'providers/influxdb'
+      require_relative 'providers/kube_crd'
+
+      attr_reader :name, :parent, :type, :function, :value, :required, :dynamic, :encrypted
+
+      def initialize(name, attribute_content, parent)
+        @name              = name
+        # @attribute_content = attribute_content
+        # @parent            = parent
+
+        # TODO for backward compatibility with remote executors all attribute content is considered as value
+        # we should change this to use proper parts of attribute as specified below
+        @value = attribute_content
+
+        # workaround for cases where we have attribute set as attribut_name: value
+        # if attribute_content.is_a?(String)
+        #   attribute_content = {
+        #     value: attribute_content
+        #   }
+        # end
+
+        # @type     = attribute_content[:type]
+        # @function = attribute_content[:function]
+        # @value    = attribute_content[:value]
+        # @temporal = attribute_content[:temporal]
+        # @required  = attribute_content[:required]  || false
+        # @dynamic   = attribute_content[:dynamic]   || false
+        # @encrypted = attribute_content[:encrypted] || false
+      end
+
+      def self.get(namespace, crd_component_name, component_instance_name, attribute_name, opts = {})
+        # getting attribute here because we can reuse it if it's stored in crd
+        # when we decide to not store attribute value as part of component_instance crd we can overwrite this
+        component_instance = Component.get(namespace, crd_component_name, component_instance_name, opts)
+        attribute_content  = component_instance.attributes.find{ |attribute| attribute.name == attribute_name }
+        
+        fail Error.new("Unable to find attribute '#{attribute_name}' in provided component instance") if attribute_content.nil? || attribute_content.empty?
+
+        attribute      = self.new(attribute_name, attribute_content, component_instance)
+        provider_class = provider_class_name(attribute, opts)
+        # return already fetched attribute value if provider is KubeCrd
+        return attribute if provider_class == 'KubeCrd'
+
+        # for KubeCrd this will do the same work we did in provider_class_name method to find temporal param
+        self.class.const_get(provider_class).get(component_instance_name, attribute_name, opts)
+      end
+
+      def to_hash
+        {
+          @name => {
+            # type: @type,
+            # function: @function,
+            value: @value,
+            # temporal: @temporal,
+            # required: @required,
+            # dynamic: @dynamic,
+            # encrypted: @encrypted
+          }
+        }
+      end
+
+      def self.create_from_kube_hash(kube_attributes)
+        kube_attributes.to_hash.map do |attribute_name, attribute_content|
+          Attribute.new(attribute_name, attribute_content, nil)
+        end
+      end
+
+      def self.create_from_kube_array(kube_attributes)
+        kube_attributes.map do |attribute_content|
+          Attribute.new(attribute_content[:name], attribute_content, nil)
+        end
+      end
+
+      private
+
+      def provider_class_name(attribute, opts = {})
+        if attribute.temporal
+          'Influxdb'
+        else
+          'KubeCrd'
+        end
+      end
+    end
+  end
+end

data/lib/state/component/providers/influxdb.rb

@@ -0,0 +1,42 @@
+module DTK::State
+  class Component::Attribute
+    class Influxdb < self
+      require_relative('influxdb/client')
+      require_relative('influxdb/measurement')
+
+      attr_reader :client, :measurement
+
+      def initialize
+        @client = Influxdb::Client.new('dtk')
+        @measurement = @client.measurement_helper(:attributes)
+      end
+
+      def get(namespace, crd_component_name, component_instance_name, attribute_name, opts = {})
+        required_tags = get_required_tags(namespace, crd_component_name, component_instance_name, attribute_name)
+        last_point = measurement.get_last_point(required_tags)
+      end
+
+      def write(namespace, crd_component_name, component_instance_name, attribute_name, value, opts = {}, timestamp = nil)
+        begin
+          fail "Bad timestamp input, write operation wont be completed" if timestamp > Time.new
+          required_tags = get_required_tags(namespace, crd_component_name, component_instance_name, attribute_name)
+          measurement.write(value, required_tags, timestamp)
+        rescue => error
+          puts error
+        end
+      end
+      
+      private 
+
+      def get_required_tags(namespace, crd_component_name, component_instance_name, attribute_name)
+        required_tags = {
+          namespace: namespace,
+          crd_component_name: crd_component_name,
+          component_instance_name: component_instance_name,
+          attribute_name: attribute_name,
+          task_id: 1
+        }
+      end
+    end
+  end
+end

data/lib/state/component/providers/influxdb/client.rb

@@ -0,0 +1,59 @@
+require 'influxdb'
+require 'resolv-replace'
+module DTK::State
+  class Component::Attribute::Influxdb
+    class Client
+      INFLUXDB_SECRET_DIR = '/app/influxdb/'
+      def initialize(database)
+        @database = database
+        @connection_parameters   = return_connection_parameters
+        @connection    = return_connection(@database, @connection_parameters)
+        create_database?
+      end
+
+      def query(query_expression)
+        self.connection.query(query_expression)
+      end
+
+      def write_point(name, data)
+        self.connection.write_point(name.to_s, data)
+      end
+
+      def measurement_helper(measurement_name)
+        begin
+          klass = Measurement.const_get(measurement_name.to_sym.capitalize)
+          klass.new(measurement_name, self)
+        rescue => error
+          puts error
+        end
+      end
+
+      attr_reader :database, :connection_parameters, :connection
+      
+      private
+
+      def return_connection_parameters
+        params = {}
+        Dir.children(INFLUXDB_SECRET_DIR).each do |file| 
+          if (file == 'username' || file == 'password' || file == 'url')
+            params[file.to_sym] = File.read("#{INFLUXDB_SECRET_DIR}#{file}")
+          end
+        end
+        {
+          url: params[:url],
+          username: params[:username],
+          password: params[:password],
+          time_precision: 'ms'
+        }
+      end
+
+      def return_connection(database, connection_parameters)
+        ::InfluxDB::Client.new(database, connection_parameters)
+      end
+
+      def create_database?
+        self.connection.query("CREATE DATABASE #{database}")
+      end
+    end
+  end
+end

data/lib/state/component/providers/influxdb/measurement.rb

@@ -0,0 +1,94 @@
+module DTK::State
+  class Component::Attribute::Influxdb
+    class Measurement
+      require_relative('measurement/attribute_measurement')
+      
+      def initialize(name, client)
+        @name   = name
+        @client = client
+      end
+
+      def get_last_point(params_hash = {})
+
+        begin
+          check_params_hash(params_hash)
+          influxdb_encoding = influxdb_encoding(params_hash, Time.new)
+          last_point  = self.client.query("select last(*) from #{influxdb_encoding.measurement_name} WHERE #{where_clause(influxdb_encoding)}")
+          fail "No data points in measurement #{name} for parameters:\n#{JSON.pretty_generate(params_hash)}" if last_point.empty?
+          last_point[0]["values"][0]
+        rescue => error
+          puts error
+        end
+      end
+      
+      protected
+      
+      attr_reader :name, :client
+      
+      private
+      
+      InfluxdbEncoding = ::Struct.new(:measurement_name, :tags, :timestamp)
+      
+      def write_point(value, params_hash = {}, timestamp)
+        # The encode function we allow us to use different mappings of name, params_hash
+        # to the influxdb actual measurement name and tags.
+        influxdb_encoding = influxdb_encoding(params_hash, timestamp)
+        timestamp = timestamp.nil? ? Time.now : timestamp
+
+        data = {
+          values: { value: value },
+          tags:   influxdb_encoding.tags,
+          timestamp: (timestamp.to_f * 1000).to_i
+        }
+        self.client.write_point(influxdb_encoding.measurement_name, data)
+      end
+      
+      def check_params_hash(params_hash = {})
+        checked_params_hash = {}
+        self.required_params.each do |name|
+          unless value = params_hash[name]
+            fail "Missing parameter '#{name}'"
+          end
+          fail_if_illegal_tag_value(name, value)
+          checked_params_hash[name] = value 
+        end
+        checked_params_hash
+      end
+      
+      # This default encoding can be overwritten by its children, for example
+      # attribute might make teh emasurement name be "#{self.name}_#{params[:component_name]" if that turns
+      # to be more efficient indexing
+      def influxdb_encoding(params_hash, timestamp)
+        InfluxdbEncoding.new(self.name, params_hash, timestamp)
+      end
+      
+      def where_clause(influxdb_encoding)
+        ret = ''
+        influxdb_encoding.tags.each_pair do |name, value|
+          unless value.nil?
+            if ret.empty?
+              ret += where_clause_term(name, value)
+            else
+              ret += " AND #{where_clause_term(name, value)}"
+            end
+          end   
+        end
+        ret
+      end
+      
+      def where_clause_term(name, value)
+        fail_if_illegal_tag_value(name, value)
+        "#{name} ='#{value}'" 
+      end
+      
+      LEGAL_TAG_CLASSES = [::String, ::Symbol, ::Integer]
+      
+      def fail_if_illegal_tag_value(name, value)
+        unless LEGAL_TAG_CLASSES.include?(value.class)
+          fail "Parameter '#{name}' has an illegal type, legal types are #{LEGAL_TAG_CLASSES.join(', ')}"
+        end
+      end
+      
+    end
+  end
+end

data/lib/state/component/providers/influxdb/measurement/attribute_measurement.rb

@@ -0,0 +1,21 @@
+module DTK::State
+  class Component::Attribute::Influxdb
+    class Measurement
+      # DTK Attributes measurement
+      class Attributes < self
+
+        def write(value, params_hash = {}, timestamp)
+          checked_params_hash = check_params_hash(params_hash)
+          write_point(value, checked_params_hash, timestamp)
+        end
+
+        protected
+
+        def required_params
+          [:namespace, :crd_component_name, :component_instance_name, :attribute_name, :task_id]
+        end
+
+      end                       
+    end
+  end
+end

data/lib/state/component/providers/kube_crd.rb

@@ -0,0 +1,11 @@
+module DTK::State
+  class Component::Attribute
+    class KubeCrd < self
+      def get(namespace, crd_component_name, component_instance_name, attribute_name, opts = {})
+        component_instance = Component.get(namespace, crd_component_name, component_instance_name, opts)
+        attribute = component_instance.attributes.find{ |attribute| attribute.name == attribute_name }
+        Attribute.new(attribute_name, attribute, component_instance)
+      end
+    end
+  end
+end

data/lib/state/component_def.rb

@@ -0,0 +1,21 @@
+module DTK::State
+  class ComponentDef
+    require_relative 'component_def/attribute_type_info'
+
+    attr_reader :name, :namespace, :executable_actions, :attribute_type_info
+
+    def initialize(namespace, name, content)
+      @name                = name
+      @namespace           = namespace
+      @executable_actions  = content[:spec][:actions]
+      # @attributes          = AttributeTypeInfo.create_from_kube_array(content[:spec][:attributes])
+      @attribute_type_info  = AttributeTypeInfo.create_from_kube_array(content[:spec][:attributes])
+    end
+
+    def self.get(namespace, name, opts = {})
+      # crd_component_def = ::DTK::CrdClient.instance(opts).kubeclient.get_componentdef(name, namespace)
+      crd_component_def = ::DTK::CrdClient.get_kubeclient(opts).get_componentdef(name, namespace)
+      ComponentDef.new(namespace, name, crd_component_def)
+    end
+  end
+end

data/lib/state/component_def/attribute_type_info.rb

@@ -0,0 +1,23 @@
+module DTK::State
+  class ComponentDef
+    class AttributeTypeInfo
+
+      attr_reader :name, :type, :required, :dynamic, :encrypted
+
+      def initialize(params)
+        @name      = params[:name]
+        @type      = params[:type]
+        @required  = params[:required]  || false
+        @dynamic   = params[:dynamic]   || false
+        @encrypted = params[:encrypted] || false
+      end
+
+      def self.create_from_kube_array(kube_attributes)
+        kube_attributes.map do |attribute_content|
+          AttributeTypeInfo.new(attribute_content)
+        end
+      end
+
+    end
+  end
+end

data/lib/state/crd_component.rb

@@ -0,0 +1,64 @@
+module DTK::State
+  class CrdComponent
+    attr_reader :name, :namespace, :crd_content, :components, :module_refs
+
+    def initialize(namespace, name, crd_content)
+      @name        = name
+      @namespace   = namespace
+      @crd_content = crd_content
+      @components  = crd_content[:spec][:components]
+      @module_refs  = crd_content[:references][:module_refs]
+    end
+
+    def self.get(namespace, name, opts = {})
+      # crd_component = ::DTK::CrdClient.instance.kubeclient.get_component(name, namespace)
+      crd_component = ::DTK::CrdClient.get_kubeclient(opts).get_component(name, namespace)
+      CrdComponent.new(namespace, name, crd_component)
+    end
+
+    # components can be:
+    #   'all'                 - print attributes for all components
+    #   ['cmp1', 'cmp2', ...] - print attributes for set of components
+    #   '<cmp_name>'          - print attributes for single component
+    # opts can have keys:
+    #   task_id
+    #   format                - format to print in (default is yaml)
+    def self.get_attributes_for(namespace, crd_component_name, components, opts = {})
+      output         = {}
+
+      crd_component = get(namespace, crd_component_name, opts)
+      crd_components = crd_component.components
+
+      if components == 'all'
+        crd_components.each do |kube_component|
+          component_hash = kube_component.to_hash
+          component_name    = component_hash.keys.first
+          component = Component.new(component_name, component_hash[component_name], crd_component, opts)
+          output.merge!(component_name => component.attributes(opts))
+        end
+      else
+        components = [components] unless components.is_a?(Array)
+
+        check_for_missing_components(crd_components, components)
+        components.each do |component_name|
+          matching_component = crd_components.find{ |cmp| cmp.to_hash.keys.first == component_name }
+          component = Component.new(component_name, matching_component[component_name], crd_component, opts)
+          output.merge!(component_name => component.attributes(opts))
+        end
+      end
+
+      output
+    end
+
+    private
+
+    def self.check_for_missing_components(crd_components, requested_components)
+      crd_component_names = crd_components.map{ |cmp| cmp.to_hash.keys.first }
+      missing_components = requested_components - crd_component_names
+
+      return if missing_components.empty?
+
+      fail Error.new("You have requested following component(s) but they do not exist in crd instance: #{missing_components.join(', ')}")
+    end
+  end
+end

data/lib/state/executable_action.rb

@@ -0,0 +1,30 @@
+module DTK::State
+  class ExecutableAction
+    attr_reader :entrypoint, :bash_script, :name, :type
+
+    def initialize(params)
+      @name = params[:name]
+      @entrypoint = params[:entrypoint]
+      @type = params[:type]
+      @bash_script = params[:bash_script]
+    end
+
+    def self.get(namespace, crd_component_name, component_name, action_name, opts = {})
+      component_obj = Component.get(namespace, crd_component_name, component_name, opts)
+      actions = component_obj.component_def.executable_actions
+      action  = actions[action_name]
+
+      raise Error.new("Unable to find action '#{action_name}'") unless action
+
+      ExecutableAction.new(
+        {
+          name: action_name,
+          entrypoint: action[:entrypoint] || '',
+          type: action[:type] || '',
+          bash_script: action[:bash_script] || ''
+        }
+      )
+    end
+
+  end
+end

data/persistence-providers.gemspec

@@ -0,0 +1,19 @@
+Gem::Specification.new do |spec|
+  spec.name        = 'persistence-providers'
+  spec.version     = '0.0.2'
+  spec.author      = 'Reactor8'
+  spec.email       = 'support@reactor8.com'
+  spec.description = %q{Persistence providers plugin}
+  spec.summary     = %q{Persistence providers plugin}
+  spec.license     = 'Apache-2.0'
+  spec.platform    = Gem::Platform::RUBY
+  spec.required_ruby_version = Gem::Requirement.new('>= 2.4.0')
+
+  spec.require_paths = ['lib']
+  spec.files = Dir.glob("**/*").reject { |el| el =~ /persistence-providers-.*.gem/ }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+
+  spec.add_dependency 'kubeclient'
+  spec.add_dependency 'celluloid-io'
+  spec.add_dependency 'influxdb', '0.8.0'
+end

data/test-destroy-influxdb.rb

@@ -0,0 +1,9 @@
+require_relative 'lib/persistence_providers'
+
+DATABASE = 'dtk'
+client = DTK::State::Component::Attribute::Influxdb::Client.new(DATABASE)
+MEASUREMENT_NAME = :attributes
+measurement = client.measurement_helper(MEASUREMENT_NAME)
+
+# clear the measurement
+puts "Cleared the measurement with name '#{MEASUREMENT_NAME}'" if client.query("DELETE FROM #{MEASUREMENT_NAME}")

data/test-influxdb.rb

@@ -0,0 +1,8 @@
+require_relative 'lib/persistence_providers'
+
+influxdb = DTK::State::Component::Attribute::Influxdb.new
+
+something = influxdb.get('default', 'ccn', 'cin', 'an')
+influxdb.write('default', 'ccn', 'cin', 'an', 'some', {}, Time.new('2045', '12'))
+something = influxdb.get('default', 'ccn', 'cin', 'an')
+puts something

data/test.rb

@@ -0,0 +1,5 @@
+require_relative 'lib/persistence_providers'
+require 'byebug'
+byebug
+DTK::State::CrdComponent.get('aldin', 'aldin', {kubeclient: 'test'})
+DTK::State::CrdComponent.new('aaa', 'bbb', { spec: { components: 'some_components'}}, {kubernetes_client: 'test'})

metadata

@@ -0,0 +1,102 @@
+--- !ruby/object:Gem::Specification
+name: persistence-providers
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- Reactor8
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-02-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: kubeclient
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: celluloid-io
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: influxdb
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.8.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.8.0
+description: Persistence providers plugin
+email: support@reactor8.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- lib/crd_client.rb
+- lib/persistence_providers.rb
+- lib/state/component.rb
+- lib/state/component/attribute.rb
+- lib/state/component/providers/influxdb.rb
+- lib/state/component/providers/influxdb/client.rb
+- lib/state/component/providers/influxdb/measurement.rb
+- lib/state/component/providers/influxdb/measurement/attribute_measurement.rb
+- lib/state/component/providers/kube_crd.rb
+- lib/state/component_def.rb
+- lib/state/component_def/attribute_type_info.rb
+- lib/state/crd_component.rb
+- lib/state/executable_action.rb
+- persistence-providers.gemspec
+- test-destroy-influxdb.rb
+- test-influxdb.rb
+- test.rb
+homepage: 
+licenses:
+- Apache-2.0
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.4.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.8
+signing_key: 
+specification_version: 4
+summary: Persistence providers plugin
+test_files: []