oci 2.9.0 → 2.10.0

data/lib/oci/log_analytics/models/recall_archived_data_details.rb

@@ -0,0 +1,210 @@
+# Copyright (c) 2016, 2020, Oracle and/or its affiliates.  All rights reserved.
+# This software is dual-licensed to you under the Universal Permissive License (UPL) 1.0 as shown at https://oss.oracle.com/licenses/upl or Apache License 2.0 as shown at http://www.apache.org/licenses/LICENSE-2.0. You may choose either license.
+
+require 'date'
+
+# rubocop:disable Lint/UnneededCopDisableDirective, Metrics/LineLength
+module OCI
+  # Work request details to recall archived data
+  #
+  class LogAnalytics::Models::RecallArchivedDataDetails
+    DATA_TYPE_ENUM = [
+      DATA_TYPE_LOG = 'LOG'.freeze,
+      DATA_TYPE_LOOKUP = 'LOOKUP'.freeze
+    ].freeze
+
+    # **[Required]** the compartment OCID for permission checking
+    # @return [String]
+    attr_accessor :compartment_id
+
+    # **[Required]** the end of the time interval
+    # @return [DateTime]
+    attr_accessor :time_data_ended
+
+    # **[Required]** the start of the time interval
+    # @return [DateTime]
+    attr_accessor :time_data_started
+
+    # the type of the log data to be purged
+    # @return [String]
+    attr_reader :data_type
+
+    # Attribute mapping from ruby-style variable name to JSON key.
+    def self.attribute_map
+      {
+        # rubocop:disable Style/SymbolLiteral
+        'compartment_id': :'compartmentId',
+        'time_data_ended': :'timeDataEnded',
+        'time_data_started': :'timeDataStarted',
+        'data_type': :'dataType'
+        # rubocop:enable Style/SymbolLiteral
+      }
+    end
+
+    # Attribute type mapping.
+    def self.swagger_types
+      {
+        # rubocop:disable Style/SymbolLiteral
+        'compartment_id': :'String',
+        'time_data_ended': :'DateTime',
+        'time_data_started': :'DateTime',
+        'data_type': :'String'
+        # rubocop:enable Style/SymbolLiteral
+      }
+    end
+
+    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/PerceivedComplexity
+    # rubocop:disable Metrics/MethodLength, Layout/EmptyLines, Style/SymbolLiteral
+
+
+    # Initializes the object
+    # @param [Hash] attributes Model attributes in the form of hash
+    # @option attributes [String] :compartment_id The value to assign to the {#compartment_id} property
+    # @option attributes [DateTime] :time_data_ended The value to assign to the {#time_data_ended} property
+    # @option attributes [DateTime] :time_data_started The value to assign to the {#time_data_started} property
+    # @option attributes [String] :data_type The value to assign to the {#data_type} property
+    def initialize(attributes = {})
+      return unless attributes.is_a?(Hash)
+
+      # convert string to symbol for hash key
+      attributes = attributes.each_with_object({}) { |(k, v), h| h[k.to_sym] = v }
+
+      self.compartment_id = attributes[:'compartmentId'] if attributes[:'compartmentId']
+
+      raise 'You cannot provide both :compartmentId and :compartment_id' if attributes.key?(:'compartmentId') && attributes.key?(:'compartment_id')
+
+      self.compartment_id = attributes[:'compartment_id'] if attributes[:'compartment_id']
+
+      self.time_data_ended = attributes[:'timeDataEnded'] if attributes[:'timeDataEnded']
+
+      raise 'You cannot provide both :timeDataEnded and :time_data_ended' if attributes.key?(:'timeDataEnded') && attributes.key?(:'time_data_ended')
+
+      self.time_data_ended = attributes[:'time_data_ended'] if attributes[:'time_data_ended']
+
+      self.time_data_started = attributes[:'timeDataStarted'] if attributes[:'timeDataStarted']
+
+      raise 'You cannot provide both :timeDataStarted and :time_data_started' if attributes.key?(:'timeDataStarted') && attributes.key?(:'time_data_started')
+
+      self.time_data_started = attributes[:'time_data_started'] if attributes[:'time_data_started']
+
+      self.data_type = attributes[:'dataType'] if attributes[:'dataType']
+
+      raise 'You cannot provide both :dataType and :data_type' if attributes.key?(:'dataType') && attributes.key?(:'data_type')
+
+      self.data_type = attributes[:'data_type'] if attributes[:'data_type']
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/PerceivedComplexity
+    # rubocop:enable Metrics/MethodLength, Layout/EmptyLines, Style/SymbolLiteral
+
+    # Custom attribute writer method checking allowed values (enum).
+    # @param [Object] data_type Object to be assigned
+    def data_type=(data_type)
+      raise "Invalid value for 'data_type': this must be one of the values in DATA_TYPE_ENUM." if data_type && !DATA_TYPE_ENUM.include?(data_type)
+
+      @data_type = data_type
+    end
+
+    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/PerceivedComplexity, Layout/EmptyLines
+
+
+    # Checks equality by comparing each attribute.
+    # @param [Object] other the other object to be compared
+    def ==(other)
+      return true if equal?(other)
+
+      self.class == other.class &&
+        compartment_id == other.compartment_id &&
+        time_data_ended == other.time_data_ended &&
+        time_data_started == other.time_data_started &&
+        data_type == other.data_type
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/PerceivedComplexity, Layout/EmptyLines
+
+    # @see the `==` method
+    # @param [Object] other the other object to be compared
+    def eql?(other)
+      self == other
+    end
+
+    # rubocop:disable Metrics/AbcSize, Layout/EmptyLines
+
+
+    # Calculates hash code according to all attributes.
+    # @return [Fixnum] Hash code
+    def hash
+      [compartment_id, time_data_ended, time_data_started, data_type].hash
+    end
+    # rubocop:enable Metrics/AbcSize, Layout/EmptyLines
+
+    # rubocop:disable Metrics/AbcSize, Layout/EmptyLines
+
+
+    # Builds the object from hash
+    # @param [Hash] attributes Model attributes in the form of hash
+    # @return [Object] Returns the model itself
+    def build_from_hash(attributes)
+      return nil unless attributes.is_a?(Hash)
+
+      self.class.swagger_types.each_pair do |key, type|
+        if type =~ /^Array<(.*)>/i
+          # check to ensure the input is an array given that the the attribute
+          # is documented as an array but the input is not
+          if attributes[self.class.attribute_map[key]].is_a?(Array)
+            public_method("#{key}=").call(
+              attributes[self.class.attribute_map[key]]
+                .map { |v| OCI::Internal::Util.convert_to_type(Regexp.last_match(1), v) }
+            )
+          end
+        elsif !attributes[self.class.attribute_map[key]].nil?
+          public_method("#{key}=").call(
+            OCI::Internal::Util.convert_to_type(type, attributes[self.class.attribute_map[key]])
+          )
+        end
+        # or else data not found in attributes(hash), not an issue as the data can be optional
+      end
+
+      self
+    end
+    # rubocop:enable Metrics/AbcSize, Layout/EmptyLines
+
+    # Returns the string representation of the object
+    # @return [String] String presentation of the object
+    def to_s
+      to_hash.to_s
+    end
+
+    # Returns the object in the form of hash
+    # @return [Hash] Returns the object in the form of hash
+    def to_hash
+      hash = {}
+      self.class.attribute_map.each_pair do |attr, param|
+        value = public_method(attr).call
+        next if value.nil? && !instance_variable_defined?("@#{attr}")
+
+        hash[param] = _to_hash(value)
+      end
+      hash
+    end
+
+    private
+
+    # Outputs non-array value in the form of hash
+    # For object, use to_hash. Otherwise, just return the value
+    # @param [Object] value Any valid value
+    # @return [Hash] Returns the value in the form of hash
+    def _to_hash(value)
+      if value.is_a?(Array)
+        value.compact.map { |v| _to_hash(v) }
+      elsif value.is_a?(Hash)
+        {}.tap do |hash|
+          value.each { |k, v| hash[k] = _to_hash(v) }
+        end
+      elsif value.respond_to? :to_hash
+        value.to_hash
+      else
+        value
+      end
+    end
+  end
+end
+# rubocop:enable Lint/UnneededCopDisableDirective, Metrics/LineLength

data/lib/oci/log_analytics/models/regex_command_descriptor.rb

@@ -0,0 +1,166 @@
+# Copyright (c) 2016, 2020, Oracle and/or its affiliates.  All rights reserved.
+# This software is dual-licensed to you under the Universal Permissive License (UPL) 1.0 as shown at https://oss.oracle.com/licenses/upl or Apache License 2.0 as shown at http://www.apache.org/licenses/LICENSE-2.0. You may choose either license.
+
+require 'date'
+require_relative 'abstract_command_descriptor'
+
+# rubocop:disable Lint/UnneededCopDisableDirective, Metrics/LineLength
+module OCI
+  # Command descriptor for querylanguage REGEX command.
+  #
+  class LogAnalytics::Models::RegexCommandDescriptor < LogAnalytics::Models::AbstractCommandDescriptor
+    # Attribute mapping from ruby-style variable name to JSON key.
+    def self.attribute_map
+      {
+        # rubocop:disable Style/SymbolLiteral
+        'name': :'name',
+        'display_query_string': :'displayQueryString',
+        'internal_query_string': :'internalQueryString',
+        'category': :'category',
+        'referenced_fields': :'referencedFields',
+        'declared_fields': :'declaredFields'
+        # rubocop:enable Style/SymbolLiteral
+      }
+    end
+
+    # Attribute type mapping.
+    def self.swagger_types
+      {
+        # rubocop:disable Style/SymbolLiteral
+        'name': :'String',
+        'display_query_string': :'String',
+        'internal_query_string': :'String',
+        'category': :'String',
+        'referenced_fields': :'Array<OCI::LogAnalytics::Models::AbstractField>',
+        'declared_fields': :'Array<OCI::LogAnalytics::Models::AbstractField>'
+        # rubocop:enable Style/SymbolLiteral
+      }
+    end
+
+    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/PerceivedComplexity
+    # rubocop:disable Metrics/MethodLength, Layout/EmptyLines, Style/SymbolLiteral
+
+
+    # Initializes the object
+    # @param [Hash] attributes Model attributes in the form of hash
+    # @option attributes [String] :display_query_string The value to assign to the {OCI::LogAnalytics::Models::AbstractCommandDescriptor#display_query_string #display_query_string} proprety
+    # @option attributes [String] :internal_query_string The value to assign to the {OCI::LogAnalytics::Models::AbstractCommandDescriptor#internal_query_string #internal_query_string} proprety
+    # @option attributes [String] :category The value to assign to the {OCI::LogAnalytics::Models::AbstractCommandDescriptor#category #category} proprety
+    # @option attributes [Array<OCI::LogAnalytics::Models::AbstractField>] :referenced_fields The value to assign to the {OCI::LogAnalytics::Models::AbstractCommandDescriptor#referenced_fields #referenced_fields} proprety
+    # @option attributes [Array<OCI::LogAnalytics::Models::AbstractField>] :declared_fields The value to assign to the {OCI::LogAnalytics::Models::AbstractCommandDescriptor#declared_fields #declared_fields} proprety
+    def initialize(attributes = {})
+      return unless attributes.is_a?(Hash)
+
+      attributes['name'] = 'REGEX'
+
+      super(attributes)
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/PerceivedComplexity
+    # rubocop:enable Metrics/MethodLength, Layout/EmptyLines, Style/SymbolLiteral
+
+    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/PerceivedComplexity, Layout/EmptyLines
+
+
+    # Checks equality by comparing each attribute.
+    # @param [Object] other the other object to be compared
+    def ==(other)
+      return true if equal?(other)
+
+      self.class == other.class &&
+        name == other.name &&
+        display_query_string == other.display_query_string &&
+        internal_query_string == other.internal_query_string &&
+        category == other.category &&
+        referenced_fields == other.referenced_fields &&
+        declared_fields == other.declared_fields
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/PerceivedComplexity, Layout/EmptyLines
+
+    # @see the `==` method
+    # @param [Object] other the other object to be compared
+    def eql?(other)
+      self == other
+    end
+
+    # rubocop:disable Metrics/AbcSize, Layout/EmptyLines
+
+
+    # Calculates hash code according to all attributes.
+    # @return [Fixnum] Hash code
+    def hash
+      [name, display_query_string, internal_query_string, category, referenced_fields, declared_fields].hash
+    end
+    # rubocop:enable Metrics/AbcSize, Layout/EmptyLines
+
+    # rubocop:disable Metrics/AbcSize, Layout/EmptyLines
+
+
+    # Builds the object from hash
+    # @param [Hash] attributes Model attributes in the form of hash
+    # @return [Object] Returns the model itself
+    def build_from_hash(attributes)
+      return nil unless attributes.is_a?(Hash)
+
+      self.class.swagger_types.each_pair do |key, type|
+        if type =~ /^Array<(.*)>/i
+          # check to ensure the input is an array given that the the attribute
+          # is documented as an array but the input is not
+          if attributes[self.class.attribute_map[key]].is_a?(Array)
+            public_method("#{key}=").call(
+              attributes[self.class.attribute_map[key]]
+                .map { |v| OCI::Internal::Util.convert_to_type(Regexp.last_match(1), v) }
+            )
+          end
+        elsif !attributes[self.class.attribute_map[key]].nil?
+          public_method("#{key}=").call(
+            OCI::Internal::Util.convert_to_type(type, attributes[self.class.attribute_map[key]])
+          )
+        end
+        # or else data not found in attributes(hash), not an issue as the data can be optional
+      end
+
+      self
+    end
+    # rubocop:enable Metrics/AbcSize, Layout/EmptyLines
+
+    # Returns the string representation of the object
+    # @return [String] String presentation of the object
+    def to_s
+      to_hash.to_s
+    end
+
+    # Returns the object in the form of hash
+    # @return [Hash] Returns the object in the form of hash
+    def to_hash
+      hash = {}
+      self.class.attribute_map.each_pair do |attr, param|
+        value = public_method(attr).call
+        next if value.nil? && !instance_variable_defined?("@#{attr}")
+
+        hash[param] = _to_hash(value)
+      end
+      hash
+    end
+
+    private
+
+    # Outputs non-array value in the form of hash
+    # For object, use to_hash. Otherwise, just return the value
+    # @param [Object] value Any valid value
+    # @return [Hash] Returns the value in the form of hash
+    def _to_hash(value)
+      if value.is_a?(Array)
+        value.compact.map { |v| _to_hash(v) }
+      elsif value.is_a?(Hash)
+        {}.tap do |hash|
+          value.each { |k, v| hash[k] = _to_hash(v) }
+        end
+      elsif value.respond_to? :to_hash
+        value.to_hash
+      else
+        value
+      end
+    end
+  end
+end
+# rubocop:enable Lint/UnneededCopDisableDirective, Metrics/LineLength

data/lib/oci/log_analytics/models/regex_match_result.rb

@@ -0,0 +1,210 @@
+# Copyright (c) 2016, 2020, Oracle and/or its affiliates.  All rights reserved.
+# This software is dual-licensed to you under the Universal Permissive License (UPL) 1.0 as shown at https://oss.oracle.com/licenses/upl or Apache License 2.0 as shown at http://www.apache.org/licenses/LICENSE-2.0. You may choose either license.
+
+require 'date'
+
+# rubocop:disable Lint/UnneededCopDisableDirective, Metrics/LineLength
+module OCI
+  # RegexMatchResult
+  class LogAnalytics::Models::RegexMatchResult
+    # matchedLogEntryEndIndex
+    # @return [Integer]
+    attr_accessor :matched_log_entry_end_index
+
+    # regexScore
+    # @return [Integer]
+    attr_accessor :regex_score
+
+    # regexStepsInfo
+    # @return [Array<OCI::LogAnalytics::Models::StepInfo>]
+    attr_accessor :regex_steps_info
+
+    # stepCount
+    # @return [Integer]
+    attr_accessor :step_count
+
+    # subRegexesMatchInfo
+    # @return [Hash<String, OCI::LogAnalytics::Models::MatchInfo>]
+    attr_accessor :sub_regexes_match_info
+
+    # Attribute mapping from ruby-style variable name to JSON key.
+    def self.attribute_map
+      {
+        # rubocop:disable Style/SymbolLiteral
+        'matched_log_entry_end_index': :'matchedLogEntryEndIndex',
+        'regex_score': :'regexScore',
+        'regex_steps_info': :'regexStepsInfo',
+        'step_count': :'stepCount',
+        'sub_regexes_match_info': :'subRegexesMatchInfo'
+        # rubocop:enable Style/SymbolLiteral
+      }
+    end
+
+    # Attribute type mapping.
+    def self.swagger_types
+      {
+        # rubocop:disable Style/SymbolLiteral
+        'matched_log_entry_end_index': :'Integer',
+        'regex_score': :'Integer',
+        'regex_steps_info': :'Array<OCI::LogAnalytics::Models::StepInfo>',
+        'step_count': :'Integer',
+        'sub_regexes_match_info': :'Hash<String, OCI::LogAnalytics::Models::MatchInfo>'
+        # rubocop:enable Style/SymbolLiteral
+      }
+    end
+
+    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/PerceivedComplexity
+    # rubocop:disable Metrics/MethodLength, Layout/EmptyLines, Style/SymbolLiteral
+
+
+    # Initializes the object
+    # @param [Hash] attributes Model attributes in the form of hash
+    # @option attributes [Integer] :matched_log_entry_end_index The value to assign to the {#matched_log_entry_end_index} property
+    # @option attributes [Integer] :regex_score The value to assign to the {#regex_score} property
+    # @option attributes [Array<OCI::LogAnalytics::Models::StepInfo>] :regex_steps_info The value to assign to the {#regex_steps_info} property
+    # @option attributes [Integer] :step_count The value to assign to the {#step_count} property
+    # @option attributes [Hash<String, OCI::LogAnalytics::Models::MatchInfo>] :sub_regexes_match_info The value to assign to the {#sub_regexes_match_info} property
+    def initialize(attributes = {})
+      return unless attributes.is_a?(Hash)
+
+      # convert string to symbol for hash key
+      attributes = attributes.each_with_object({}) { |(k, v), h| h[k.to_sym] = v }
+
+      self.matched_log_entry_end_index = attributes[:'matchedLogEntryEndIndex'] if attributes[:'matchedLogEntryEndIndex']
+
+      raise 'You cannot provide both :matchedLogEntryEndIndex and :matched_log_entry_end_index' if attributes.key?(:'matchedLogEntryEndIndex') && attributes.key?(:'matched_log_entry_end_index')
+
+      self.matched_log_entry_end_index = attributes[:'matched_log_entry_end_index'] if attributes[:'matched_log_entry_end_index']
+
+      self.regex_score = attributes[:'regexScore'] if attributes[:'regexScore']
+
+      raise 'You cannot provide both :regexScore and :regex_score' if attributes.key?(:'regexScore') && attributes.key?(:'regex_score')
+
+      self.regex_score = attributes[:'regex_score'] if attributes[:'regex_score']
+
+      self.regex_steps_info = attributes[:'regexStepsInfo'] if attributes[:'regexStepsInfo']
+
+      raise 'You cannot provide both :regexStepsInfo and :regex_steps_info' if attributes.key?(:'regexStepsInfo') && attributes.key?(:'regex_steps_info')
+
+      self.regex_steps_info = attributes[:'regex_steps_info'] if attributes[:'regex_steps_info']
+
+      self.step_count = attributes[:'stepCount'] if attributes[:'stepCount']
+
+      raise 'You cannot provide both :stepCount and :step_count' if attributes.key?(:'stepCount') && attributes.key?(:'step_count')
+
+      self.step_count = attributes[:'step_count'] if attributes[:'step_count']
+
+      self.sub_regexes_match_info = attributes[:'subRegexesMatchInfo'] if attributes[:'subRegexesMatchInfo']
+
+      raise 'You cannot provide both :subRegexesMatchInfo and :sub_regexes_match_info' if attributes.key?(:'subRegexesMatchInfo') && attributes.key?(:'sub_regexes_match_info')
+
+      self.sub_regexes_match_info = attributes[:'sub_regexes_match_info'] if attributes[:'sub_regexes_match_info']
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/PerceivedComplexity
+    # rubocop:enable Metrics/MethodLength, Layout/EmptyLines, Style/SymbolLiteral
+
+    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/PerceivedComplexity, Layout/EmptyLines
+
+
+    # Checks equality by comparing each attribute.
+    # @param [Object] other the other object to be compared
+    def ==(other)
+      return true if equal?(other)
+
+      self.class == other.class &&
+        matched_log_entry_end_index == other.matched_log_entry_end_index &&
+        regex_score == other.regex_score &&
+        regex_steps_info == other.regex_steps_info &&
+        step_count == other.step_count &&
+        sub_regexes_match_info == other.sub_regexes_match_info
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/PerceivedComplexity, Layout/EmptyLines
+
+    # @see the `==` method
+    # @param [Object] other the other object to be compared
+    def eql?(other)
+      self == other
+    end
+
+    # rubocop:disable Metrics/AbcSize, Layout/EmptyLines
+
+
+    # Calculates hash code according to all attributes.
+    # @return [Fixnum] Hash code
+    def hash
+      [matched_log_entry_end_index, regex_score, regex_steps_info, step_count, sub_regexes_match_info].hash
+    end
+    # rubocop:enable Metrics/AbcSize, Layout/EmptyLines
+
+    # rubocop:disable Metrics/AbcSize, Layout/EmptyLines
+
+
+    # Builds the object from hash
+    # @param [Hash] attributes Model attributes in the form of hash
+    # @return [Object] Returns the model itself
+    def build_from_hash(attributes)
+      return nil unless attributes.is_a?(Hash)
+
+      self.class.swagger_types.each_pair do |key, type|
+        if type =~ /^Array<(.*)>/i
+          # check to ensure the input is an array given that the the attribute
+          # is documented as an array but the input is not
+          if attributes[self.class.attribute_map[key]].is_a?(Array)
+            public_method("#{key}=").call(
+              attributes[self.class.attribute_map[key]]
+                .map { |v| OCI::Internal::Util.convert_to_type(Regexp.last_match(1), v) }
+            )
+          end
+        elsif !attributes[self.class.attribute_map[key]].nil?
+          public_method("#{key}=").call(
+            OCI::Internal::Util.convert_to_type(type, attributes[self.class.attribute_map[key]])
+          )
+        end
+        # or else data not found in attributes(hash), not an issue as the data can be optional
+      end
+
+      self
+    end
+    # rubocop:enable Metrics/AbcSize, Layout/EmptyLines
+
+    # Returns the string representation of the object
+    # @return [String] String presentation of the object
+    def to_s
+      to_hash.to_s
+    end
+
+    # Returns the object in the form of hash
+    # @return [Hash] Returns the object in the form of hash
+    def to_hash
+      hash = {}
+      self.class.attribute_map.each_pair do |attr, param|
+        value = public_method(attr).call
+        next if value.nil? && !instance_variable_defined?("@#{attr}")
+
+        hash[param] = _to_hash(value)
+      end
+      hash
+    end
+
+    private
+
+    # Outputs non-array value in the form of hash
+    # For object, use to_hash. Otherwise, just return the value
+    # @param [Object] value Any valid value
+    # @return [Hash] Returns the value in the form of hash
+    def _to_hash(value)
+      if value.is_a?(Array)
+        value.compact.map { |v| _to_hash(v) }
+      elsif value.is_a?(Hash)
+        {}.tap do |hash|
+          value.each { |k, v| hash[k] = _to_hash(v) }
+        end
+      elsif value.respond_to? :to_hash
+        value.to_hash
+      else
+        value
+      end
+    end
+  end
+end
+# rubocop:enable Lint/UnneededCopDisableDirective, Metrics/LineLength