persistence-providers 0.0.4.1 → 0.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9bc555b9367087540ccddc49bc1ce3fa937b0a36be7b3d6ff832373a9beeadd0
-  data.tar.gz: 5ae84500a46b183544d53b1d7d2f90cf6b49bcf52d34d2b95eba8474f7653c93
+  metadata.gz: c0df9c5f3778b1aba3a4b2474b9e47dad64d60566697c3ee15708e26a1a8bfe6
+  data.tar.gz: a7d39896b337a3579c491b4f13553b28556324b6ecbfdaf7439eafe1f2f6d6b7
 SHA512:
-  metadata.gz: 52cc878735fdf04cb19b7a202ff2622872b4514f40c1b849a0ff73a821f4e8e333c1aa9a3ac6ba6b31de29b199f4c49fb5fbd3df2c2bdf64fd4d421f6ff67e7d
-  data.tar.gz: a9b7fbf25e02a5b1dc15220760e91ca1bc703e7f1c2f388f6f2b083c48170c1162ffc483464cbde99f31e2465dd687c78bc47006a5ad9ee6157c5c40538083e9
+  metadata.gz: 55e280a54d5a75f1bc6ae12b5fcf31659bae2efcf7c83897c0a6fed78d576464173fecec7bc2807945caf56cc3c930248947fd3d747c934ba75e06d73762715a
+  data.tar.gz: 3e8f981dd1ca1cbb000f1e926bebee66bb73eeaf710c4f0824154dae1526dd74d7dc2c1a87f40e9a58a94ba48fa9ca39ad054f5c9cbc4d3338c0340ba7283931

data/lib/persistence_providers.rb

@@ -7,5 +7,6 @@ module DTK
     require_relative 'state/component_def'
     require_relative 'state/executable_action'
     require_relative 'state/workflow_instance'
+    require_relative 'state/workflow'
   end
 end

data/lib/state/component.rb

@@ -3,12 +3,14 @@ module DTK::State
     require_relative 'component/attribute'
 
     attr_reader :name, :parent, :component_def
+    attr_accessor :raw_attributes
 
     def initialize(name, component_content, parent, opts = {})
       @name           = name
       # @parent     = parent
       @component_defs = parent.references.component_def
       @component_def  = get_component_def(opts)
+      @raw_attributes = component_content[:attributes] || {}
 
       @attribute_objs = Attribute.create_from_kube_hash(component_content[:attributes] || {})# convert_to_attribute_objects(component_content[:attributes])
     end
@@ -22,6 +24,45 @@ module DTK::State
       end
     end
 
+    def self.get_with_influx_data(namespace, assembly_name, component_name, opts = {})
+      component = get(namespace, assembly_name, component_name, opts)
+      return unless component
+      attributes = component.raw_attributes.to_hash
+
+      attr_type_info = component.component_def.attribute_type_info
+      attr_type_info.each do |attr_info|
+        if attr_info.temporal
+          attribute_name = attr_info.name.to_sym
+          influxdb = ::DTK::State::Component::Attribute::Influxdb.new(:attributes)
+          influxdb_attribute = influxdb.get(namespace, component_name, assembly_name, attribute_name, opts)
+          if valid_attribute = influxdb_attribute.first
+            value = valid_attribute['_value']
+            if attributes[attribute_name]
+              if attributes[attribute_name].is_a?(String)
+                attributes[attribute_name] = value
+              else
+                attributes[attribute_name][:value] = value
+              end
+            end
+          end
+        end
+      end
+
+      component.raw_attributes = attributes
+      component
+    end
+
+    def to_hash
+      {
+        name: @name,
+        component_def: {
+          name: @component_def.name,
+          namespace: @component_def.namespace
+        },
+        attributes: @raw_attributes.to_hash
+      }
+    end
+
     # opts can have keys
     # task_id
     # format:
@@ -44,14 +85,48 @@ module DTK::State
       end
     end
 
+    def attribute_metadata
+      attributes         = @raw_attributes.to_hash
+      attr_type_info     = @component_def.attribute_type_info
+      attribute_metadata = {}
+
+      attr_type_info.each do |attr_info|
+        attr_info_hash = attr_info.to_hash
+        attribute_name = attr_info_hash[:name].to_sym
+
+        if attribute = attributes[attribute_name]
+          if attribute.is_a?(String)
+            attribute = { value: attribute }
+          end
+
+          attribute_metadata[attribute_name] = attr_info_hash.merge(attribute)
+        end
+      end
+
+      attribute_metadata
+    end
+
     def attribute_values
-      attribute_with_values = []
-      @content[:attributes].each do |name, content|
-        attribute_with_values << { name => content[:value] }
+      attribute_with_values = {}
+      @raw_attributes.each do |name, content|
+        attribute_with_values.merge!(name => content[:value])
       end
       attribute_with_values
     end
 
+    def self.create_from_kube_array(kube_components, crd_assembly)
+      kube_components.map do |component_hash|
+        if component_hash.is_a?(String)
+          component_name    = component_hash
+          component_content = {}
+        else
+          component_name = component_hash.to_hash.keys.first
+          component_content = component_hash[component_name]
+        end
+        Component.new(component_name, component_content, crd_assembly)
+      end
+    end
+
     private
 
     def self.get_component_content(matching_component, component_name)

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

@@ -4,6 +4,7 @@ module DTK::State
       require_relative('influxdb/client')
       require_relative('influxdb/measurement')
       require_relative('influxdb/semantictype')
+      require_relative('../../../utils/log')
 
       attr_reader :client, :measurement
 

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

@@ -2,7 +2,6 @@ module DTK::State
   class Component::Attribute::Influxdb
     class 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)
@@ -11,10 +10,9 @@ module DTK::State
         protected
 
         def required_params
-          [:namespace, :component_name, :assembly_name, :attribute_name, :task_id]
+          %i[namespace component_name assembly_name attribute_name task_id]
         end
-
-      end                       
+      end
     end
   end
 end

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

@@ -9,18 +9,17 @@ module DTK::State
         end
 
         def get_correlator_type(entrypoint)
-          { 
-            correlator_type: entrypoint.split("/").last.split(".")[0] 
+          {
+            correlator_type: entrypoint.split('/').last.split('.')[0]
           }
         end
 
         protected
 
         def required_params
-          [:namespace, :component_name, :assembly_name, :task_id, :attribute_name, :task_id, :correlator_type]
+          %i[namespace component_name assembly_name task_id attribute_name correlator_type]
         end
-
-      end                       
+      end
     end
   end
-end
+end

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

@@ -22,10 +22,9 @@ module DTK::State
         protected
 
         def required_params
-          [:event_id, :pod_name, :pod_namespace, :component_name, :attribute_name, :task_id]
+          %i[event_id pod_name pod_namespace component_name attribute_name task_id]
         end
-        
-      end                       
+      end
     end
   end
-end
+end

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

@@ -23,10 +23,9 @@ module DTK::State
         protected
 
         def required_params
-          [:type, :name, :namespace, :object_state, :component_name, :attribute_name, :task_id]
+          %i[type name namespace object_state component_name attribute_name task_id]
         end
-        
-      end                       
+      end
     end
   end
-end
+end

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

@@ -2,7 +2,8 @@ module DTK::State
   class Component::Attribute::Influxdb
     class SemanticType
       require_relative './client'
-      attr_reader :name, :crd_content, :namespace, :client
+      require_relative('../../../../utils/log')
+      attr_reader :name, :crd_content, :namespace, :client, :expanded_semantictype_spec
       attr_accessor :content_to_write
 
       def initialize(name, namespace)
@@ -11,75 +12,103 @@ module DTK::State
         @client = Client.new
         @crd_content = get(name, namespace)
         @content_to_write = []
-      end
-
-      # no namespace because semantictype instances are going to be unique in cluster
-      def get(name, namespace, opts = {})
-        begin
-          semantictype = ::DTK::CrdClient.get_kubeclient(opts).get_semantictype(name, namespace)
-          semantictype.spec[:openAPIV3Schema]
-        rescue => error
-          fail "SemanticType attribute with name '#{name}' not found on the cluster!. Error: #{error}"
-        end
+        @expanded_spec = ::DTK::CrdClient.get_kubeclient({}).get_semantictype(name, namespace).expandedSpec
+        @expanded_semantictype_spec = expand(crd_content.to_h[:properties], @expanded_spec)
       end
 
       def write_semantictype_inventory(inventory, component_id)
-        begin
-          get_influxdb_properties(inventory)
-          content_to_write.each do |point|
-            point[:tags].merge!({ component_id: component_id, attribute_name: @name })
-            @client.write_point({
-              name: point[:name],
-              tags: point[:tags],
-              fields: point[:fields],
-              time: (Time.new.to_f * 1000).to_i
-            })
-          end
-          "Inventory for attribute #{name} written to InfluxDB"
-        rescue => error
-          fail "#{name} inventory write failed. Error: #{error}"
+        get_influxdb_properties(inventory)
+        content_to_write.each do |point|
+          point[:tags].merge!({ component_id: component_id, attribute_name: @name })
+          @client.write_point({
+                                name: point[:name],
+                                tags: point[:tags],
+                                fields: point[:fields],
+                                time: (Time.new.to_f * 1000).to_i
+                              })
         end
+      rescue => e
+        raise "#{name} inventory write failed. Error: #{e}"
       end
 
       def partial_write_update(component_and_attribute, path, field_name, field_value)
         parent, child = validate_parameter(path)
         component_id, attribute_name = component_and_attribute.split('/')
         # getting previous value for given parameters
-        previous_value = { }
+        previous_value = {}
         begin
           flux_query = 'from(bucket:"' + @client.connection_parameters[:bucket] + '") |> range(start:-5) |> filter(fn:(r) => r._measurement == "' + attribute_name + "_" + child[:type] + '") |> filter(fn: (r) => r.parent == "' + parent[:name] + '") |> filter(fn: (r) => r.name == "' + child[:name] + '")|> last()'
           result = @client.query(query: flux_query)
           previous_value = result.values.map(&:records).flatten.map(&:values)
-        rescue => error
-          fail "Partial write could not be completed. Previous point for given parameters not found!"
+        rescue => e
+          raise "Partial write could not be completed. Previous point for given parameters not found!. Error: #{e}"
         end
         update_current(previous_value[0], get_path_to_object(path), field_name, field_value)
       end
 
       private
 
+      def expand(crd_content, expanded_spec)
+        if expanded_spec.nil?
+          expanded_spec = {}
+          populate_semantictypes(crd_content, expanded_spec)
+          ::DTK::CrdClient.get_kubeclient({}).merge_patch_semantictype(name, { expandedSpec: expanded_spec }, namespace)
+        end
+        expanded_spec
+      end
+
+      def get(name, namespace, opts = {})
+        semantictype = ::DTK::CrdClient.get_kubeclient(opts).get_semantictype(name, namespace)
+        semantictype.spec[:openAPIV3Schema]
+      rescue => e
+        raise "SemanticType attribute with name '#{name}' not found  on the cluster!. Error: #{e.inspect}"
+      end
+
+      def populate_semantictypes(crd, expanded_spec, parent = nil)
+        crd.each_pair do |key, value|
+          basic, semantictype = value[:type].split(':')
+          if semantictype
+            expanded_spec[key] = get(basic.to_s, namespace).to_h[:properties]
+            crd[key] = get(basic.to_s, namespace).to_h[:properties]
+            temporary_expanded_spec = populate_semantictypes(crd[key], expanded_spec[key], basic)
+          end
+          if basic == 'array'
+            basic, semantictype = value[:items][:type].split(':')
+            if semantictype
+              expanded_spec[key] = get(basic.to_s, namespace).to_h[:properties]
+              crd[key] = get(basic.to_s, namespace).to_h[:properties]
+              temporary_expanded_spec = populate_semantictypes(crd[key], expanded_spec[key], basic)
+            end
+          end
+          temporary_expanded_spec ||= {}
+          unless temporary_expanded_spec.empty? || parent.nil?
+            ::DTK::CrdClient.get_kubeclient({}).merge_patch_semantictype(parent, { expandedSpec: { key => temporary_expanded_spec } }, namespace)
+          end
+        end
+        expanded_spec
+      end
+
       def update_current(previous_value, path, field_name, field_value)
-        tags = { }
+        tags = {}
         previous_value.each_pair do |key, value|
-            tags[key] = value if key[0..0] != "_" && key != "result" && key != "table"
+          tags[key] = value if key[0..0] != '_' && key != 'result' && key != 'table'
         end
         fields = Hash.new
         fields[field_name.to_sym] = field_value
         validate_fields(get_partial_definition(path), fields)
         @client.write_point({
-          name: previous_value["_measurement"],
-          tags: tags,
-          fields: fields,
-          time: (Time.new.to_f * 1000).to_i
-        })
-        "Partial write update successful"
+                              name: previous_value['_measurement'],
+                              tags: tags,
+                              fields: fields,
+                              time: (Time.new.to_f * 1000).to_i
+                            })
       end
 
       def get_influxdb_properties(inventory, parent_type = [:top], parent_name = nil)
         content_to_write = []
         properties = { }
         inventory.each_pair do |key, value|
-          if value.class.to_s == "Array"
+          if value.class.to_s == 'Array'
             inventory[key].each do |element|
               get_influxdb_properties(element, parent_type.push(key), inventory[:name])
             end
@@ -102,12 +131,10 @@ module DTK::State
       end
 
       def validate_request(partial_definition, request)
-        begin
-          validate_tags(partial_definition, request[:tags])
-          validate_fields(partial_definition, request[:fields])
-        rescue => error
-          fail error  
-        end
+        validate_tags(partial_definition, request[:tags])
+        validate_fields(partial_definition, request[:fields])
+      rescue => e
+        raise e
       end
 
       def get_tags_and_fields(partial_definition, properties)
@@ -115,7 +142,7 @@ module DTK::State
         fields = { }
         properties.each_pair do |key, value|
           if partial_definition[key].nil?
-            fail "Property '#{key}' not found in the definition of attribute"
+            raise "Property '#{key}' not found in the definition of attribute"
           else
             if partial_definition[key][:metric].nil? || partial_definition[key][:metric] == false
               tags[key] = value
@@ -131,14 +158,12 @@ module DTK::State
       end
 
       def validate_fields(partial_definition, fields)
-
         partial_definition.each_pair do |key, value|
           next if key == :required || value[:metric] == (false || nil)
-      
           if fields[key].nil?
-            fail "Field #{key} is missing. Validation of request failed!"
+            raise "Field #{key} is missing. Validation of request failed!"
           elsif value[:type].capitalize != fields[key].class.to_s
-            fail "Defined type for SemanticType attribute property '#{key}' is #{value[:type].capitalize}, #{fields[key].class} provided"
+            raise "Defined type for SemanticType attribute property '#{key}' is #{value[:type].capitalize}, #{fields[key].class} provided"
           end
         end
       end
@@ -146,20 +171,19 @@ module DTK::State
       def validate_tags(partial_definition, tags)
         partial_definition.each_pair do |key, value|
           next if key == :required || value[:metric] == true
-          
           if tags[key].nil?
             if value[:default].nil?
-              fail "Property #{key} is missing. Validation of request failed!"
-            else 
+              raise "Property #{key} is missing. Validation of request failed!"
+            else
               tags[key] = value[:default]
             end
-          else 
+          else
             type = tags[key].class
-            type = "Boolean" if type == TrueClass || type == FalseClass
+            type = 'Boolean' if type == TrueClass || type == FalseClass
             if value[:type].capitalize == type.to_s
               next
             else
-              fail "Defined type for SemanticType attribute property '#{key}' is #{value[:type].capitalize}, #{type} provided"
+              raise "Defined type for SemanticType attribute property '#{key}' is #{value[:type].capitalize}, #{type} provided"
             end
           end
         end
@@ -167,24 +191,25 @@ module DTK::State
 
       def get_partial_definition(path)
         i = 0
-        definition = { }
-        semantictype_crd = crd_content[:properties]
+        definition = {}
+        semantictype_crd = crd_content.to_h[:properties]
+        expanded_spec = expanded_semantictype_spec.to_h
         while i < path.length
           if path[i].to_sym == :top
             semantictype_crd.each_pair do |key, value|
               if key == :required
                 definition[key] = value
               else
-                definition[key] = value if value[:type] != "array"
+                basic, semantictype = value[:type].split(':')
+                semantictype.nil? ? definition[key] = value : definition[key] = semantictype_crd[key] if basic != 'array'
               end
             end
           else
             definition = {}
-            definition[:required] = semantictype_crd[path[i].to_sym][:items][:required]
-            semantictype_crd[path[i].to_sym][:items][:properties].each_pair do |key, value|
-                definition[key] = value if value[:type] != "array"
+            expanded_spec[path[i].to_sym].each_pair do |key, value|
+              definition[key] = value unless value[:type].nil?
             end
-            semantictype_crd = semantictype_crd[path[i].to_sym][:items][:properties]
+            expanded_spec = expanded_spec[path[i].to_sym]
           end
           i+=1
         end
@@ -192,7 +217,7 @@ module DTK::State
       end
 
       def get_path_to_object(parameter)
-        path = ["top"]
+        path = ['top']
         array = parameter.split('/')
         array.each do |element|
           path.push(element.split(':')[1])
@@ -202,19 +227,18 @@ module DTK::State
 
       def validate_parameter(parameter)
         array_of_parameters = []
-        begin
-          parameter.split('/').each_with_index do |param, index|
-            name, type = param.split(':')
-            fail unless name && type
-            array_of_parameters.push({
-              name: name,
-              type: type
-            })
-          end
-          array_of_parameters
-        rescue => error
-          fail "Could not resolve parameter '#{parameter}'. It should be in format: 'parent:type/child:type'"
+        parameter.split('/').each_with_index do |param, index|
+          name, type = param.split(':')
+          raise unless name && type
+
+          array_of_parameters.push({
+                                      name: name,
+                                      type: type
+                                   })
         end
+        array_of_parameters
+      rescue => e
+        raise "Could not resolve parameter '#{parameter}'. It should be in format: 'parent:type/child:type'"
       end
     end
   end

data/lib/state/component_def.rb

@@ -9,7 +9,7 @@ module DTK::State
     def initialize(namespace, name, content)
       @name                = name
       @namespace           = namespace
-      @executable_actions  = content[:spec][:actions]
+      @executable_actions  = content[:spec][:actions] || {}
       @attribute_type_info  = AttributeTypeInfo.create_from_kube_hash(content[:spec][:attributes] || {})
     end
 

data/lib/state/component_def/attribute_type_info.rb

@@ -19,6 +19,19 @@ module DTK::State
         end
       end
 
+      def to_hash
+        type_info = {}
+
+        type_info.merge!(name: @name) if @name
+        type_info.merge!(type: @type) if @type
+        type_info.merge!(required: @required) if @required
+        type_info.merge!(dynamic: @dynamic) if @dynamic
+        type_info.merge!(temporal: @temporal) if @temporal
+        type_info.merge!(encrypted: @encrypted) if @encrypted
+
+        type_info
+      end
+
     end
   end
 end

data/lib/state/crd_assembly.rb

@@ -2,14 +2,19 @@ module DTK::State
   class CrdAssembly
     ASSEMBLY_CRD_VERSION = ENV["ASSEMBLY_CRD_VERSION"]
 
-    attr_reader :name, :namespace, :crd_content, :components, :references
+    attr_reader :name, :namespace, :crd_content, :references, :component_objs
+    attr_accessor :components
 
     def initialize(namespace, name, crd_content)
-      @name        = name
-      @namespace   = namespace
-      @crd_content = crd_content
-      @references  = crd_content.references
-      @components  = crd_content[:spec][:components]
+      @name           = name
+      @namespace      = namespace
+      @api_version    = crd_content.apiVersion
+      @kind           = crd_content.kind
+      @metadata       = crd_content.metadata
+      # @crd_content    = crd_content
+      @references     = crd_content.references
+      @components     = crd_content[:spec][:components] || []
+      # @component_objs = Component.create_from_kube_array(@components, self)
     end
 
     def self.get(namespace, name, opts = {})
@@ -52,6 +57,51 @@ module DTK::State
       output
     end
 
+    # TODO: this is a temporal solution to avoid breaking backward compatibility; will change this soon
+    def self.get_with_influx_data(namespace, assembly_name, opts = {})
+      assembly = get(namespace, assembly_name, opts)
+
+      components_hash = {}
+      assembly.components.each do |assembly_component|
+        cmp_name = assembly_component.to_hash.keys.first
+        components_hash[cmp_name] = assembly_component[cmp_name].to_hash
+      end
+
+      component_objs = Component.create_from_kube_array(assembly.components, assembly)
+
+      component_objs.each do |component_obj|
+        component_name = component_obj.name
+        attr_type_info = component_obj.component_def.attribute_type_info
+        attr_type_info.each do |attr_info|
+          if attr_info.temporal
+            attribute_name = attr_info.name
+            influxdb = ::DTK::State::Component::Attribute::Influxdb.new(:attributes)
+            influxdb_attribute = influxdb.get(namespace, component_name, assembly_name, attribute_name, opts)
+            if valid_attribute = influxdb_attribute.first
+              value = valid_attribute['_value']
+              if components_hash[component_name][:attributes][attribute_name].is_a?(String)
+                components_hash[component_name][:attributes][attribute_name] = value
+              else
+                components_hash[component_name][:attributes][attribute_name][:value] = value
+              end
+            end
+          end
+        end
+      end
+      assembly.components = components_hash
+      assembly
+    end
+
+    def to_hash
+      {
+        apiVersion: @api_version,
+        kind: @kind,
+        metadata: @metadata.to_hash,
+        references: @references.to_hash,
+        spec: { components: @components.to_hash }
+      }
+    end
+
     private
 
     def self.check_for_missing_components(crd_components, requested_components)

data/lib/state/workflow.rb

@@ -0,0 +1,26 @@
+module DTK::State
+  class Workflow
+    require_relative 'workflow_instance/attribute_type_info'
+
+    WORKFLOW_CRD_VERSION = ENV["WORKFLOW_CRD_VERSION"]
+
+    attr_reader :name, :namespace, :references, :assembly, :workflow, :attribute_type_info
+
+    def initialize(namespace, name, crd_content)
+      @name      = name
+      @namespace = namespace
+
+      @references = crd_content.references
+      @assembly   = @references.assembly
+      @workflow   = crd_content.spec.workflow || {}
+
+      @attribute_type_info = ::DTK::State::WorkflowInstance::AttributeTypeInfo.create_from_kube_hash(crd_content.spec.attributes.to_h || {})
+    end
+
+    def self.get(namespace, name, opts = {})
+      opts[:apiVersion] = WORKFLOW_CRD_VERSION
+      workflow = ::DTK::CrdClient.get_kubeclient(opts).get_workflow(name, namespace)
+      Workflow.new(namespace, name, workflow)
+    end
+  end
+end

data/lib/state/workflow_instance.rb

@@ -4,16 +4,24 @@ module DTK::State
 
     WORKFLOW_INSTANCE_CRD_VERSION = ENV["WORKFLOW_INSTANCE_CRD_VERSION"]
 
-    attr_reader :name, :namespace, :assembly, :workflow_template, :attributes, :workflow,  :attribute_type_info
+    attr_reader :name, :namespace, :assembly, :workflow_template, :attributes, :attribute_type_info, :status, :workflow
+    attr_accessor :workflow
 
     def initialize(namespace, name, crd_content)
       @name        = name
       @namespace   = namespace
-      @assembly          = crd_content.references.assembly
-      @workflow_template = crd_content.references.workflow
-      @attributes        = crd_content.spec.attributes
-      @workflow          = crd_content.spec.workflow
-      @attribute_type_info = AttributeTypeInfo.create_from_kube_hash(@attributes.to_h || {})
+
+      @api_version    = crd_content.apiVersion
+      @kind           = crd_content.kind
+      @metadata       = crd_content.metadata
+
+      @references        = crd_content.references
+      @assembly          = @references.assembly
+      @workflow_template = @references.workflow
+
+      @attributes        = crd_content.spec.attributes || {}
+      @status            = crd_content.spec.status || {}
+      @workflow          = crd_content.spec.workflow || {}
     end
 
     def self.get(namespace, name, opts = {})
@@ -22,6 +30,47 @@ module DTK::State
       WorkflowInstance.new(namespace, name, workflow_instance)
     end
 
+    def self.get_with_influx_data(namespace, workflow_instance_name, opts = {})
+      workflow_instance = get(namespace, workflow_instance_name, opts)
+      return unless workflow_instance
+
+      workflow_instance.workflow[:subtasks].each do |subtask|
+        component_name, action_name = subtask[:component].split('.')
+        assembly_name = workflow_instance.assembly[:name]
+
+        executable_action = ::DTK::State::ExecutableAction.get(namespace, assembly_name, component_name, action_name, opts)
+        attr_type_info = executable_action.attribute_type_info
+
+        attr_type_info.each do |attr_info|
+          if attr_info.temporal
+            attribute_name = attr_info.name
+            influxdb = ::DTK::State::Component::Attribute::Influxdb.new(:attributes)
+            influxdb_attribute = influxdb.get(namespace, component_name, assembly_name, attribute_name, opts)
+            if valid_attribute = influxdb_attribute.first
+              value = valid_attribute['_value']
+              subtask[:attributes][attribute_name] = value
+            end
+          end
+        end
+      end
+
+      workflow_instance
+    end
+
+    def to_hash
+      {
+        apiVersion: @api_version,
+        kind: @kind,
+        metadata: @metadata.to_hash,
+        references: @references.to_hash,
+        spec: {
+          attributes: @attributes.to_hash,
+          status: @status.to_hash,
+          workflow: @workflow.to_hash
+        }
+      }
+    end
+
     def self.get_attributes(namespace, name, opts = {})
       workflow_instance = get(namespace, name, opts)
       workflow_instance.attributes.to_h
@@ -95,5 +144,38 @@ module DTK::State
       action
     end
 
+    def get_workflow_template(opts = {})
+      Workflow.get(@workflow_template.namespace, @workflow_template.name, opts)
+    end
+
+    def attribute_metadata
+      attributes         = @attributes.to_hash
+      attr_type_info     = get_workflow_template.attribute_type_info
+      attribute_metadata = {}
+
+      attr_type_info.each do |attr_info|
+        attr_info_hash = attr_info.to_hash
+        attribute_name = attr_info_hash[:name].to_sym
+
+        if attribute = attributes[attribute_name]
+          if attribute.is_a?(String)
+            attribute = { value: attribute }
+          end
+
+          attribute_metadata[attribute_name] = attr_info_hash.merge(attribute)
+        end
+      end
+
+      attribute_metadata
+    end
+
+    def attribute_values
+      attribute_with_values = {}
+      @attributes.each_pair do |name, content|
+        attribute_with_values.merge!(name => content[:value])
+      end
+      attribute_with_values
+    end
+
   end
 end

data/lib/state/workflow_instance/attribute_type_info.rb

@@ -21,6 +21,19 @@ module DTK::State
         end
       end
 
+      def to_hash
+        type_info = {}
+
+        type_info.merge!(name: @name) if @name
+        type_info.merge!(type: @type) if @type
+        type_info.merge!(required: @required) if @required
+        type_info.merge!(dynamic: @dynamic) if @dynamic
+        type_info.merge!(temporal: @temporal) if @temporal
+        type_info.merge!(encrypted: @encrypted) if @encrypted
+
+        type_info
+      end
+
     end
   end
 end

data/lib/utils.rb

@@ -1,3 +1,5 @@
-module Utils
-  require_relative 'utils/log'
+module DTK
+  module Utils
+    require_relative 'utils/log'
+  end
 end

data/lib/utils/log.rb

@@ -1,4 +1,4 @@
-module Utils
+module DTK::Utils
   module Log
     require 'logger'
 

data/persistence-providers.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |spec|
   spec.name        = 'persistence-providers'
-  spec.version     = '0.0.4.1'
+  spec.version     = '0.0.5'
   spec.author      = 'Reactor8'
   spec.email       = 'support@reactor8.com'
   spec.description = %q{Persistence providers plugin}

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: persistence-providers
 version: !ruby/object:Gem::Version
-  version: 0.0.4.1
+  version: 0.0.5
 platform: ruby
 authors:
 - Reactor8
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-05-27 00:00:00.000000000 Z
+date: 2020-06-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: kubeclient
@@ -77,6 +77,7 @@ files:
 - lib/state/crd_assembly.rb
 - lib/state/executable_action.rb
 - lib/state/executable_action/attribute_type_info.rb
+- lib/state/workflow.rb
 - lib/state/workflow_instance.rb
 - lib/state/workflow_instance/attribute_type_info.rb
 - lib/utils.rb