gitlab-fog-google 1.13.0

data/lib/fog/google/models/monitoring/monitored_resource_descriptor.rb

@@ -0,0 +1,20 @@
+require "fog/core/model"
+
+module Fog
+  module Google
+    class Monitoring
+      ##
+      # A monitoredResourceDescriptor defines a metric type and its schema.
+      #
+      # @see https://cloud.google.com/monitoring/api/ref_v3/rest/v3/projects.monitoredResourceDescriptors#MonitoredResourceDescriptor
+      class MonitoredResourceDescriptor < Fog::Model
+        identity :name
+
+        attribute :description
+        attribute :display_name, :aliases => "displayName"
+        attribute :type
+        attribute :labels
+      end
+    end
+  end
+end

data/lib/fog/google/models/monitoring/monitored_resource_descriptors.rb

@@ -0,0 +1,37 @@
+require "fog/core/collection"
+require "fog/google/models/monitoring/monitored_resource_descriptor"
+
+module Fog
+  module Google
+    class Monitoring
+      class MonitoredResourceDescriptors < Fog::Collection
+        model Fog::Google::Monitoring::MonitoredResourceDescriptor
+
+        ##
+        # Lists all Monitored Resource Descriptors.
+        #
+        # @param filter [String] The monitoring filter used to search against existing descriptors.
+        #   @see https://cloud.google.com/monitoring/api/v3/filters filter documentation
+        # @param page_size [String]  Maximum number of metric descriptors per page. Used for pagination.
+        # @param page_token [String]  The pagination token, which is used to page through large result sets.
+        # @return [Array<Fog::Google::Monitoring::MetricDescriptor>] List of Monitored Resource Descriptors.
+        def all(filter: nil, page_size: nil, page_token: nil)
+          data = service.list_monitored_resource_descriptors(
+            :filter => filter,
+            :page_size => page_size,
+            :page_token => page_token
+          ).to_h[:resource_descriptors] || []
+          load(data)
+        end
+
+        def get(resource_type)
+          data = service.get_monitored_resource_descriptor(resource_type).to_h
+          new(data)
+        rescue ::Google::Apis::ClientError => e
+          raise e unless e.status_code == 404
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/fog/google/models/monitoring/timeseries.rb

@@ -0,0 +1,19 @@
+require "fog/core/model"
+
+module Fog
+  module Google
+    class Monitoring
+      ##
+      # A time series is a collection of data points that represents the value of a metric of a project over time.
+      #
+      # https://cloud.google.com/monitoring/api/ref_v3/rest/v3/projects.timeSeries/list
+      class Timeseries < Fog::Model
+        attribute :metric
+        attribute :resource
+        attribute :metric_kind, :aliases => "metricKind"
+        attribute :value_type, :aliases => "valueType"
+        attribute :points
+      end
+    end
+  end
+end

data/lib/fog/google/models/monitoring/timeseries_collection.rb

@@ -0,0 +1,48 @@
+require "fog/core/collection"
+require "fog/google/models/monitoring/timeseries"
+
+module Fog
+  module Google
+    class Monitoring
+      class TimeseriesCollection < Fog::Collection
+        model Fog::Google::Monitoring::Timeseries
+
+        ##
+        # Lists all Timeseries.
+        #
+        # @param filter [String] A monitoring filter that specifies which time series should be returned.
+        #   The filter must specify a single metric type, and can additionally specify metric labels and other
+        #   information.
+        # @param interval [Hash] Required. The time interval for which results should be returned.
+        # @option interval [String] end_time Required RFC3339 timestamp marking the end of interval
+        # @option interval [String] start_time Required RFC3339 timestamp marking start of interval.
+        # @param aggregation [Hash] Optional object describing how to combine multiple time series to provide
+        #   different views of the data. By default, the raw time series data is returned.
+        # @option aggregation [String] alignment_period The alignment period for per-time series alignment.
+        # @option aggregation [String] cross_series_reducer The approach to be used to align individual time series.
+        # @option aggregation [String] group_by_fields The set of fields to preserve when crossSeriesReducer is specified.
+        # @option aggregation [String] per_series_aligner The approach to be used to combine time series.
+        # @param order_by [String] Specifies the order in which the points of the time series should be returned.
+        #   By default, results are not ordered. Currently, this field must be left blank.
+        # @param page_size [String]
+        # @param page_token [String]
+        # @param view [String] Specifies which information is returned about the time series.
+        #
+        # @return [Array<Fog::Google::Monitoring::Timeseries>] List of Timeseries.
+        def all(filter: nil, interval: nil, aggregation: nil, order_by: nil, page_size: nil, page_token: nil, view: nil)
+          data = service.list_timeseries(
+            :filter => filter,
+            :interval => interval,
+            :aggregation => aggregation,
+            :order_by => order_by,
+            :page_size => page_size,
+            :page_token => page_token,
+            :view => view
+          ).to_h[:time_series] || []
+
+          load(data)
+        end
+      end
+    end
+  end
+end

data/lib/fog/google/models/pubsub/received_message.rb

@@ -0,0 +1,40 @@
+require "fog/core/model"
+
+module Fog
+  module Google
+    class Pubsub
+      # Represents a ReceivedMessage retrieved from a Google Pubsub
+      # subscription. Note that ReceivedMessages are immutable.
+      #
+      # @see https://cloud.google.com/pubsub/reference/rest/v1/projects.subscriptions/pull#ReceivedMessage
+      class ReceivedMessage < Fog::Model
+        identity :ack_id, :aliases => "ackId"
+
+        attribute :message
+
+        def initialize(new_attributes = {})
+          # Here we secretly store the subscription name we were received on
+          # in order to support #acknowledge
+          attributes = new_attributes.clone
+          @subscription_name = attributes.delete(:subscription_name)
+          super(attributes)
+        end
+
+        # Acknowledges a message.
+        #
+        # @see https://cloud.google.com/pubsub/reference/rest/v1/projects.subscriptions/acknowledge
+        def acknowledge
+          requires :ack_id
+
+          service.acknowledge_subscription(@subscription_name, [ack_id])
+          nil
+        end
+
+        def reload
+          # Message is immutable - do nothing
+          Fog::Logger.warning("#reload called on immutable ReceivedMessage")
+        end
+      end
+    end
+  end
+end

data/lib/fog/google/models/pubsub/subscription.rb

@@ -0,0 +1,86 @@
+module Fog
+  module Google
+    class Pubsub
+      # Represents a Pubsub subscription resource
+      #
+      # @see https://cloud.google.com/pubsub/reference/rest/v1/projects.subscriptions
+      class Subscription < Fog::Model
+        identity :name
+        attribute :topic
+        attribute :push_config, :aliases => "pushConfig"
+        attribute :ack_deadline_seconds, :aliases => "ackDeadlineSeconds"
+
+        # Pulls from this subscription, returning any available messages. By
+        # default, this method returns immediately with up to 10 messages. The
+        # option 'return_immediately' allows the method to block until a
+        # message is received, or the remote service closes the connection.
+        #
+        # Note that this method automatically performs a base64 decode on the
+        # 'data' field.
+        #
+        # @param options [Hash] options to modify the pull request
+        # @option options [Boolean] :return_immediately If true, method returns
+        #   after checking for messages. Otherwise the method blocks until one
+        #   or more messages are available, or the connection is closed.
+        # @option options [Number] :max_messages maximum number of messages to
+        #   receive
+        # @return [Array<Fog::Google::Pubsub::ReceivedMessage>] list of
+        #   received messages, or an empty list if no messages are available.
+        # @see https://cloud.google.com/pubsub/reference/rest/v1/projects.subscriptions/pull
+        def pull(options = { :return_immediately => true, :max_messages => 10 })
+          requires :name
+
+          data = service.pull_subscription(name, options).to_h
+
+          return [] unless data.key?(:received_messages)
+          # Turn into a list of ReceivedMessage, but ensure we perform a base64 decode first
+          data[:received_messages].map do |recv_message|
+            attrs = {
+              :service => service,
+              :subscription_name => name
+            }.merge(recv_message)
+
+            attrs[:message][:data] = Base64.decode64(recv_message[:message][:data]) if recv_message[:message].key?(:data)
+            ReceivedMessage.new(attrs)
+          end
+        end
+
+        # Acknowledges a list of received messages for this subscription.
+        #
+        # @param messages [Array<Fog::Google::Pubsub::ReceivedMessage, #to_s>]
+        #   A list containing either ReceivedMessage instances to acknowledge,
+        #   or a list of ackIds (@see
+        #   https://cloud.google.com/pubsub/reference/rest/v1/projects.subscriptions/pull#ReceivedMessage).
+        # @see https://cloud.google.com/pubsub/reference/rest/v1/projects.subscriptions/acknowledge
+        def acknowledge(messages)
+          return if messages.empty?
+
+          ack_ids = messages.map { |m| m.is_a?(ReceivedMessage) ? m.ack_id : m.to_s }
+
+          service.acknowledge_subscription(name, ack_ids)
+          nil
+        end
+
+        # Save this instance on the remove service.
+        #
+        # @return [Fog::Google::Pubsub::Subscription] this instance
+        # @see https://cloud.google.com/pubsub/reference/rest/v1/projects.subscriptions/create
+        def save
+          requires :name, :topic
+
+          data = service.create_subscription(name, topic, push_config, ack_deadline_seconds).to_h
+          merge_attributes(data)
+        end
+
+        # Deletes this subscription on the remote service.
+        #
+        # @see https://cloud.google.com/pubsub/reference/rest/v1/projects.subscriptions/delete
+        def destroy
+          requires :name
+
+          service.delete_subscription(name)
+        end
+      end
+    end
+  end
+end

data/lib/fog/google/models/pubsub/subscriptions.rb

@@ -0,0 +1,33 @@
+require "fog/core/collection"
+require "fog/google/models/pubsub/subscription"
+
+module Fog
+  module Google
+    class Pubsub
+      class Subscriptions < Fog::Collection
+        model Fog::Google::Pubsub::Subscription
+
+        # Lists all subscriptions that exist on the project.
+        #
+        # @return [Array<Fog::Google::Pubsub::Subscription>] list of
+        #   subscriptions
+        def all
+          data = service.list_subscriptions.to_h[:subscriptions] || []
+          load(data)
+        end
+
+        # Retrieves a subscription by name
+        #
+        # @param subscription_name [String] name of subscription to retrieve
+        # @return [Fog::Google::Pubsub::Topic] topic found, or nil if not found
+        def get(subscription_name)
+          subscription = service.get_subscription(subscription_name).to_h
+          new(subscription)
+        rescue ::Google::Apis::ClientError => e
+          raise e unless e.status_code == 404
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/fog/google/models/pubsub/topic.rb

@@ -0,0 +1,71 @@
+require "fog/core/model"
+
+module Fog
+  module Google
+    class Pubsub
+      # Represents a Pubsub topic resource
+      #
+      # @see https://cloud.google.com/pubsub/reference/rest/v1/projects.topics#Topic
+      class Topic < Fog::Model
+        identity :name
+
+        # Creates this topic resource on the service.
+        #
+        # @return [Fog::Google::Pubsub::Topic] this instance
+        def create
+          requires :name
+
+          service.create_topic(name)
+          self
+        end
+
+        # Deletes this topic resource on the service.
+        #
+        # @return [Fog::Google::Pubsub::Topic] this instance
+        def destroy
+          requires :name
+
+          service.delete_topic(name)
+          self
+        end
+
+        # Publish a message to this topic. This method will automatically
+        # encode the message via base64 encoding.
+        #
+        # @param messages [Array<Hash{String => String}, #to_s>] list of messages
+        #   to send; if it's a hash, then the value of key "data" will be sent
+        #   as the message. Additionally, if the hash contains a value for key
+        #   "attributes", then they will be sent as well as attributes on the
+        #   message.
+        # @return [Array<String>] list of message ids
+        def publish(messages)
+          requires :name
+
+          # Ensure our messages are base64 encoded
+          encoded_messages = []
+
+          messages.each do |message|
+            encoded_message = {}
+            if message.is_a?(Hash)
+              if message.key?("data")
+                encoded_message[:data] = Base64.strict_encode64(message["data"])
+              end
+            else
+              encoded_message[:data] = Base64.strict_encode64(message.to_s)
+            end
+
+            encoded_messages << encoded_message
+          end
+
+          service.publish_topic(name, encoded_messages).to_h[:message_ids]
+        end
+
+        # Save the instance (does the same thing as #create)
+        # @return [Fog::Google::Pubsub::Topic] this instance
+        def save
+          create
+        end
+      end
+    end
+  end
+end

data/lib/fog/google/models/pubsub/topics.rb

@@ -0,0 +1,32 @@
+require "fog/core/collection"
+require "fog/google/models/pubsub/topic"
+
+module Fog
+  module Google
+    class Pubsub
+      class Topics < Fog::Collection
+        model Fog::Google::Pubsub::Topic
+
+        # Lists all topics that exist on the project.
+        #
+        # @return [Array<Fog::Google::Pubsub::Topic>] list of topics
+        def all
+          data = service.list_topics.to_h[:topics] || []
+          load(data)
+        end
+
+        # Retrieves a topic by name
+        #
+        # @param topic_name [String] name of topic to retrieve
+        # @return [Fog::Google::Pubsub::Topic] topic found, or nil if not found
+        def get(topic_name)
+          topic = service.get_topic(topic_name).to_h
+          new(topic)
+        rescue ::Google::Apis::ClientError => e
+          raise e unless e.status_code == 404
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/fog/google/models/sql/backup_run.rb

@@ -0,0 +1,37 @@
+require "fog/core/model"
+
+module Fog
+  module Google
+    class SQL
+      ##
+      # A database instance backup run resource
+      #
+      # @see https://cloud.google.com/sql/docs/mysql/admin-api/v1beta4/backupRuns
+      class BackupRun < Fog::Model
+        identity :id
+
+        attribute :description
+        attribute :end_time, :aliases => "endTime"
+        attribute :enqueued_time, :aliases => "enqueuedTime"
+        attribute :error
+        attribute :instance
+        attribute :kind
+        attribute :self_link, :aliases => "selfLink"
+        attribute :start_time, :aliases => "startTime"
+        attribute :status
+        attribute :type
+        attribute :window_start_time, :aliases => "windowStartTime"
+
+        READY_STATUS = "DONE".freeze
+
+        ##
+        # Checks if the instance backup run is done
+        #
+        # @return [Boolean] True if the backup run is done; False otherwise
+        def ready?
+          status == READY_STATUS
+        end
+      end
+    end
+  end
+end

data/lib/fog/google/models/sql/backup_runs.rb

@@ -0,0 +1,38 @@
+require "fog/core/collection"
+require "fog/google/models/sql/backup_run"
+
+module Fog
+  module Google
+    class SQL
+      class BackupRuns < Fog::Collection
+        model Fog::Google::SQL::BackupRun
+
+        ##
+        # Lists all backup runs associated with a given instance.
+        #
+        # @param [String] instance_id Instance ID
+        # @return [Array<Fog::Google::SQL::BackupRun>] List of Backup run resources
+        def all(instance_id)
+          data = service.list_backup_runs(instance_id).to_h[:items] || []
+          load(data)
+        end
+
+        ##
+        # Retrieves a resource containing information about a backup run
+        #
+        # @param [String] instance_id Instance ID
+        # @param [String] backup_run_id Backup Configuration ID
+        # @return [Fog::Google::SQL::BackupRun] Backup run resource
+        def get(instance_id, backup_run_id)
+          backup_run = service.get_backup_run(instance_id, backup_run_id).to_h
+          if backup_run
+            new(backup_run)
+          end
+        rescue ::Google::Apis::ClientError => e
+          raise e unless e.status_code == 404
+          nil
+        end
+      end
+    end
+  end
+end