persistence-providers 0.0.2.4 → 0.0.2.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 660dab58980e91237fcf7f0d6ce5bb54a7ce6dd7e9fa3cebc7863a7313007bba
-  data.tar.gz: 2c88433473a7bcf024a18819d8027f2ff21dfabb3ccb98db5093ed42f7e6747d
+  metadata.gz: 9b6d9600d71e5dbb6af778bdb092ded254b6870f7eed368c1e98a0841f0524b4
+  data.tar.gz: 65b02da0199b1aa48306ac1b5e319365e0948564a000ebfb10f476bbe2e74853
 SHA512:
-  metadata.gz: '0081a8eb82ab1c9aa999c8dbf34ac4b54835e712f51a9bcc8ba7d2b17579f6334b9bb25f0faf1d9831c7bc551367f6dfd9f87c4cdfe8eec6f5af137204ec95d0'
-  data.tar.gz: 772e78be6305a28ff88719dbd9bc8d4d40c5f7a20687cfe87c2a983e01399760715e805532487c84a76099d64b633d5626fe8fd67845db0bfba7f2f0297052da
+  metadata.gz: 7382b3e4b134717176e85030b125b34bcf4b7cc1c04366288f363d5e710de989fd22fe26a50d79adb8e7e4d88bb7975dcc6c84a0eeeecc92a42ef7927c8adcda
+  data.tar.gz: cb984101e69c340129b7fefc7fc033306608121b106c973968d61363be0eaab840e587095a5affd1260d5880990456a68a75a09e4042ea21f43b13152db9bbf2

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

@@ -7,13 +7,20 @@ module DTK::State
       attr_reader :client, :measurement
 
       def initialize(measurement_name)
-        @client = Influxdb::Client.new('dtk')
+        @client = Influxdb::Client.new
         @measurement = @client.measurement_helper(measurement_name)
       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)
+        if opts[:provider] == "correlation"
+          errors = client.measurement_helper(:errors)
+          required_tags.merge!({ correlator_type: opts[:entrypoint].split("/").last.split(".")[0] })
+          errors.get_last_point(required_tags)
+        elsif
+          last_value = measurement.get_last_point(required_tags)
+          last_value
+        end
       end
 
       def write(namespace, crd_component_name, component_instance_name, attribute_name, value, opts = {}, timestamp = nil)

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

@@ -1,22 +1,34 @@
-require 'influxdb'
 require 'resolv-replace'
+require 'influxdb2/client'
 module DTK::State
   class Component::Attribute::Influxdb
     class Client
       INFLUXDB_SECRET_DIR = '/app/influxdb/'
-      def initialize(database)
-        @database = database
+      def initialize
         @connection_parameters   = return_connection_parameters
-        @connection    = return_connection(@database, @connection_parameters)
-        create_database?
+        @connection    = return_connection(@connection_parameters)
       end
 
       def query(query_expression)
-        self.connection.query(query_expression)
+        query_api = self.connection.create_query_api
+        query_api.query(query_expression)
       end
 
-      def write_point(name, data)
-        self.connection.write_point(name.to_s, data)
+      def return_line_protocol_data(data)
+        protocol_string = ''
+        protocol_string += data[:name].to_s + ','
+        data[:tags].each_pair { |key,value| protocol_string+="#{key}=#{value},"}
+        protocol_string.delete_suffix!(',')
+        protocol_string += ' '
+        data[:fields].each_pair { |key,value| protocol_string+="#{key}=\"#{value.gsub!(/"/, '\"')},\"" }
+        protocol_string.delete_suffix!(',')
+        protocol_string += " #{data[:time].to_s}"
+      end
+
+      def write_point(data)
+        data = return_line_protocol_data(data)
+        write_api = self.connection.create_write_api
+        write_api.write(data: data)
       end
 
       def measurement_helper(measurement_name)
@@ -28,36 +40,36 @@ module DTK::State
         end
       end
 
-      attr_reader :database, :connection_parameters, :connection
+      attr_reader :connection_parameters, :connection
       
       private
 
       def return_connection_parameters
         params = {}
         Dir.children(INFLUXDB_SECRET_DIR).each do |file| 
-          if (file == 'username' || file == 'password' || file == 'url')
+          if (file == 'url' || file == 'token' || file == 'org' || file == 'bucket')
             params[file.to_sym] = File.read("#{INFLUXDB_SECRET_DIR}#{file}")
           end
         end
         {
-          url: params[:url] + "?retry=3",
-          username: params[:username],
-          password: params[:password],
-          time_precision: 'ms'
+          url: params[:url],
+          token: params[:token],
+          org: params[:org],
+          bucket: params[:bucket]
         }
       end
 
-      def return_connection(database, connection_parameters)
+      def return_connection(connection_parameters)
         begin
-          ::InfluxDB::Client.new(database, connection_parameters)
+          InfluxDB2::Client.new(connection_parameters[:url], connection_parameters[:token],
+                                bucket: connection_parameters[:bucket],
+                                org: connection_parameters[:org],
+                                precision: InfluxDB2::WritePrecision::MILLISECOND,
+                                use_ssl: false)
         rescue => error
           fail "Error: #{error}"
         end
       end
-
-      def create_database?
-        self.connection.query("CREATE DATABASE #{database}")
-      end
     end
   end
 end

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

@@ -11,16 +11,22 @@ module DTK::State
         @client = client
       end
 
-      def get_last_point(params_hash = {})
+      def flux_filter(params_hash)
+        filter = ''
+        params_hash.each_pair do |key,value|
+          filter += "|> filter(fn: (r) => r.#{key} == \"#{value}\")"
+        end
+        filter
+      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]
+          flux_query = 'from(bucket:"' + client.connection_parameters[:bucket] + '") |> range(start:-5) |> filter(fn: (r) => r._measurement == "' + name.to_s + '")' + flux_filter(params_hash) + ' |> last()'  +   '|> drop(columns: ["_start", "_stop", "_field", "_measurement", "attribute_name", "component_instance_name", "task_id", "crd_component_name", "namespace"])'
+          result  = self.client.query(flux_query)
+          result.values.map(&:records).flatten.map(&:values)
         rescue => error
-          puts error
+          fail error
         end
       end
       
@@ -35,15 +41,19 @@ module DTK::State
       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)
+        begin
+          influxdb_encoding = influxdb_encoding(params_hash, timestamp)
+          timestamp = timestamp.nil? ? Time.now : timestamp
+          data = {
+            name: name,
+            tags:   influxdb_encoding.tags,
+            fields: { value: value },
+            time: (timestamp.to_f * 1000).to_i
+          }
+          self.client.write_point(data)
+        rescue => error
+          fail "write_point error: #{error}"
+        end
       end
       
       def check_params_hash(params_hash = {})
@@ -65,25 +75,6 @@ module DTK::State
         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)

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

@@ -4,8 +4,8 @@ module DTK::State
       class Errors < self
 
         def write(value, params_hash = {}, timestamp)
-            checked_params_hash = check_params_hash(params_hash)
-            write_point(value, checked_params_hash, timestamp)
+          checked_params_hash = check_params_hash(params_hash)
+          write_point(value, checked_params_hash, timestamp)
         end
 
         protected

data/persistence-providers.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |spec|
   spec.name        = 'persistence-providers'
-  spec.version     = '0.0.2.4'
+  spec.version     = '0.0.2.5'
   spec.author      = 'Reactor8'
   spec.email       = 'support@reactor8.com'
   spec.description = %q{Persistence providers plugin}
@@ -15,5 +15,5 @@ Gem::Specification.new do |spec|
 
   spec.add_dependency 'kubeclient'
   spec.add_dependency 'celluloid-io'
-  spec.add_dependency 'influxdb', '0.8.0'
+  spec.add_dependency 'influxdb-client', '1.2.0'
 end

data/test-influxdb.rb

@@ -1,8 +1,8 @@
 require_relative 'lib/persistence_providers'
 
-influxdb = DTK::State::Component::Attribute::Influxdb.new
+influxdb = DTK::State::Component::Attribute::Influxdb.new(:attributes)
 
-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')
+influxdb.write('namespace', 'comp_full_name', 'assembly_name', 'attribute_name', 'something', { }, Time.new)
+
+something = influxdb.get('namespace', 'comp_full_name', 'assembly_name', 'attribute_name', { })
 puts something

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: persistence-providers
 version: !ruby/object:Gem::Version
-  version: 0.0.2.4
+  version: 0.0.2.5
 platform: ruby
 authors:
 - Reactor8
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-04-08 00:00:00.000000000 Z
+date: 2020-04-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: kubeclient
@@ -39,19 +39,19 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: influxdb
+  name: influxdb-client
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.8.0
+        version: 1.2.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.8.0
+        version: 1.2.0
 description: Persistence providers plugin
 email: support@reactor8.com
 executables: []