fog-google 0.6.0 → 1.0.0

data/lib/fog/google/requests/monitoring/delete_metric_descriptor.rb

@@ -0,0 +1,17 @@
+module Fog
+  module Google
+    class Monitoring
+      class Real
+        def delete_metric_descriptor(metric_type)
+          @monitoring.delete_project_metric_descriptor("projects/#{@project}/metricDescriptors/#{metric_type}")
+        end
+      end
+
+      class Mock
+        def delete_metric_descriptor(_metric_type)
+          Fog::Mock.not_implemented
+        end
+      end
+    end
+  end
+end

data/lib/fog/google/requests/monitoring/get_metric_descriptor.rb

@@ -0,0 +1,17 @@
+module Fog
+  module Google
+    class Monitoring
+      class Real
+        def get_metric_descriptor(metric_type)
+          @monitoring.get_project_metric_descriptor("projects/#{@project}/metricDescriptors/#{metric_type}")
+        end
+      end
+
+      class Mock
+        def get_metric_descriptor(_metric_type)
+          Fog::Mock.not_implemented
+        end
+      end
+    end
+  end
+end

data/lib/fog/google/requests/monitoring/get_monitored_resource_descriptor.rb

@@ -0,0 +1,19 @@
+module Fog
+  module Google
+    class Monitoring
+      class Real
+        def get_monitored_resource_descriptor(resource_type)
+          @monitoring.get_project_monitored_resource_descriptor(
+            "projects/#{@project}/monitoredResourceDescriptors/#{resource_type}"
+          )
+        end
+      end
+
+      class Mock
+        def get_monitored_resource_descriptor(_resource_type)
+          raise Fog::Errors::MockNotImplemented
+        end
+      end
+    end
+  end
+end

data/lib/fog/google/requests/monitoring/list_metric_descriptors.rb

@@ -6,241 +6,19 @@ module Fog
       #
       # @see https://cloud.google.com/monitoring/api/ref_v3/rest/v3/projects.metricDescriptors/list
       class Real
-        def list_metric_descriptors(options = {})
-          api_method = @monitoring.projects.metric_descriptors.list
-          parameters = {
-            "name" => "projects/#{@project}"
-          }
-          parameters["filter"] = options[:filter] if options.key?(:filter)
-          parameters["pageSize"] = options[:page_size] if options.key?(:page_size)
-          parameters["pageToken"] = options[:page_token] if options.key?(:page_token)
-
-          puts parameters
-          request(api_method, parameters)
+        def list_metric_descriptors(filter: nil, page_size: nil, page_token: nil)
+          @monitoring.list_project_metric_descriptors(
+            "projects/#{@project}",
+            :filter => filter,
+            :page_size => page_size,
+            :page_token => page_token
+          )
         end
       end
 
       class Mock
         def list_metric_descriptors(_options = {})
-          body = {
-            "metricDescriptors" => [
-              {
-                "type" => "compute.googleapis.com/instance/cpu/reserved_cores",
-                "name" => "projects/#{@project}/metricDescriptors/compute.googleapis.com/instance/cpu/reserved_cores",
-                "labels" => [
-                  {
-                    "key" => "instance_name",
-                    "description" => "The name of the VM instance."
-                  }
-                ],
-                "metricKind" => "GAUGE",
-                "valueType" => "DOUBLE",
-                "unit" => "1",
-                "description" => "Number of cores reserved on the host of the instance.",
-                "displayName" => "Reserved cores"
-              },
-              {
-                "type" => "compute.googleapis.com/instance/cpu/usage_time",
-                "name" => "projects/#{@project}/metricDescriptors/compute.googleapis.com/instance/cpu/usage_time",
-                "labels" => [
-                  {
-                    "key" => "instance_name",
-                    "description" => "The name of the VM instance."
-                  }
-                ],
-                "metricKind" => "DELTA",
-                "valueType" => "DOUBLE",
-                "unit" => "s",
-                "description" => "Delta CPU usage for all cores, in seconds. To compute the per-core CPU utilization fraction, divide this value by (end-start)*N, where end and start define this value's time interval and N is `compute.googleapis.com/instance/cpu/reserved_cores` at the end of the interval.",
-                "displayName" => "CPU usage"
-              },
-              {
-                "type" => "compute.googleapis.com/instance/disk/read_bytes_count",
-                "name" => "projects/#{@project}/metricDescriptors/compute.googleapis.com/instance/disk/read_bytes_count",
-                "labels" => [
-                  {
-                    "key" => "instance_name",
-                    "description" => "The name of the VM instance."
-                  },
-                  {
-                    "key" => "device_name",
-                    "description" => "The name of the disk device."
-                  },
-                  {
-                    "key" => "storage_type",
-                    "description" => "The storage type => `pd-standard` or `pd-ssd`."
-                  },
-                  {
-                    "key" => "device_type",
-                    "description" => "The disk type => `ephemeral` or `permanent`."
-                  }
-                ],
-                "metricKind" => "DELTA",
-                "valueType" => "INT64",
-                "unit" => "By",
-                "description" => "Delta count of bytes read from disk.",
-                "displayName" => "Disk read bytes"
-              },
-              {
-                "name" => "projects/#{@project}/metricDescriptors/compute.googleapis.com/instance/disk/read_ops_count",
-                "labels" => [
-                  {
-                    "key" => "instance_name",
-                    "description" => "The name of the VM instance."
-                  },
-                  {
-                    "key" => "device_name",
-                    "description" => "The name of the disk device."
-                  },
-                  {
-                    "key" => "storage_type",
-                    "description" => "The storage type => `pd-standard` or `pd-ssd`."
-                  },
-                  {
-                    "key" => "device_type",
-                    "description" => "The disk type => `ephemeral` or `permanent`."
-                  }
-                ],
-                "metricKind" => "DELTA",
-                "valueType" => "INT64",
-                "unit" => "1",
-                "description" => "Delta count of disk read IO operations.",
-                "displayName" => "Disk read operations",
-                "type" => "compute.googleapis.com/instance/disk/read_ops_count"
-              },
-              {
-                "type" => "compute.googleapis.com/instance/disk/write_bytes_count",
-                "name" => "projects/#{@project}/metricDescriptors/compute.googleapis.com/instance/disk/write_bytes_count",
-                "labels" => [
-                  {
-                    "key" => "instance_name",
-                    "description" => "The name of the VM instance."
-                  },
-                  {
-                    "key" => "device_name",
-                    "description" => "The name of the disk device."
-                  },
-                  {
-                    "key" => "storage_type",
-                    "description" => "The storage type => `pd-standard` or `pd-ssd`."
-                  },
-                  {
-                    "key" => "device_type",
-                    "description" => "The disk type => `ephemeral` or `permanent`."
-                  }
-                ],
-                "metricKind" => "DELTA",
-                "valueType" => "INT64",
-                "unit" => "By",
-                "description" => "Delta count of bytes written to disk.",
-                "displayName" => "Disk write bytes"
-              },
-              {
-                "type" => "compute.googleapis.com/instance/disk/write_ops_count",
-                "name" => "projects/#{@project}/metricDescriptors/compute.googleapis.com/instance/disk/write_ops_count",
-                "labels" => [
-                  {
-                    "key" => "instance_name",
-                    "description" => "The name of the VM instance."
-                  },
-                  {
-                    "key" => "device_name",
-                    "description" => "The name of the disk device."
-                  },
-                  {
-                    "key" => "storage_type",
-                    "description" => "The storage type => `pd-standard` or `pd-ssd`."
-                  },
-                  {
-                    "key" => "device_type",
-                    "description" => "The disk type => `ephemeral` or `permanent`."
-                  }
-                ],
-                "metricKind" => "DELTA",
-                "valueType" => "INT64",
-                "unit" => "1",
-                "description" => "Delta count of disk write IO operations.",
-                "displayName" => "Disk write operations"
-              },
-              {
-                "type" => "compute.googleapis.com/instance/network/received_packets_count",
-                "name" => "projects/#{@project}/metricDescriptors/compute.googleapis.com/instance/network/received_packets_count",
-                "labels" => [
-                  {
-                    "key" => "instance_name",
-                    "description" => "The name of the VM instance."
-                  },
-                  {
-                    "key" => "loadbalanced",
-                    "valueType" => "BOOL",
-                    "description" => "Whether traffic was received by an L3 loadbalanced IP address assigned to the VM. Traffic that is externally routed to the VM's standard internal or external IP address, such as L7 loadbalanced traffic, is not considered to be loadbalanced in this metric."
-                  }
-                ],
-                "metricKind" => "DELTA",
-                "valueType" => "INT64",
-                "unit" => "1",
-                "description" => "Delta count of packets received from the network.",
-                "displayName" => "Received packets"
-              },
-              {
-                "type" => "compute.googleapis.com/instance/network/sent_bytes_count",
-                "name" => "projects/#{@project}/metricDescriptors/compute.googleapis.com/instance/network/sent_bytes_count",
-                "labels" => [
-                  {
-                    "key" => "instance_name",
-                    "description" => "The name of the VM instance."
-                  },
-                  {
-                    "key" => "loadbalanced",
-                    "valueType" => "BOOL",
-                    "description" => "Whether traffic was sent from an L3 loadbalanced IP address assigned to the VM. Traffic that is externally routed from the VM's standard internal or external IP address, such as L7 loadbalanced traffic, is not considered to be loadbalanced in this metric."
-                  }
-                ],
-                "metricKind" => "DELTA",
-                "valueType" => "INT64",
-                "unit" => "By",
-                "description" => "Delta count of bytes sent over the network.",
-                "displayName" => "Sent bytes"
-              },
-              {
-                "type" => "compute.googleapis.com/instance/network/sent_packets_count",
-                "name" => "projects/#{@project}/metricDescriptors/compute.googleapis.com/instance/network/sent_packets_count",
-                "labels" => [
-                  {
-                    "key" => "instance_name",
-                    "description" => "The name of the VM instance."
-                  },
-                  {
-                    "key" => "loadbalanced",
-                    "valueType" => "BOOL",
-                    "description" => "Whether traffic was sent from an L3 loadbalanced IP address assigned to the VM. Traffic that is externally routed from the VM's standard internal or external IP address, such as L7 loadbalanced traffic, is not considered to be loadbalanced in this metric."
-                  }
-                ],
-                "metricKind" => "DELTA",
-                "valueType" => "INT64",
-                "unit" => "1",
-                "description" => "Delta count of packets sent over the network.",
-                "displayName" => "Sent packets"
-              },
-              {
-                "type" => "compute.googleapis.com/instance/uptime",
-                "name" => "projects/#{@project}/metricDescriptors/compute.googleapis.com/instance/uptime",
-                "labels" => [
-                  {
-                    "key" => "instance_name",
-                    "description" => "The name of the VM instance."
-                  }
-                ],
-                "metricKind" => "DELTA",
-                "valueType" => "DOUBLE",
-                "unit" => "s",
-                "description" => "How long the VM has been running, in seconds.",
-                "displayName" => "Uptime"
-              }
-            ]
-          }
-
-          build_excon_response(body)
+          raise Fog::Errors::MockNotImplemented
         end
       end
     end

data/lib/fog/google/requests/monitoring/list_monitored_resource_descriptors.rb

@@ -7,55 +7,19 @@ module Fog
       #
       # @see https://cloud.google.com/monitoring/api/ref_v3/rest/v3/projects.monitoredResourceDescriptors/list
       class Real
-        def list_monitored_resource_descriptors(options = {})
-          api_method = @monitoring.projects.monitored_resource_descriptors.list
-          parameters = {
-            "name" => "projects/#{@project}"
-          }
-
-          parameters["filter"] = options[:filter] if options.key?(:filter)
-          parameters["pageSize"] = options[:page_size] if options.key?(:page_size)
-          parameters["pageToken"] = options[:page_token] if options.key?(:page_token)
-
-          request(api_method, parameters)
+        def list_monitored_resource_descriptors(filter: nil, page_size: nil, page_token: nil)
+          @monitoring.list_project_monitored_resource_descriptors(
+            "projects/#{@project}",
+            :filter => filter,
+            :page_size => page_size,
+            :page_token => page_token
+          )
         end
       end
 
       class Mock
-        def list_monitored_resource_descriptors(_options = {})
-          body = {
-            "resourceDescriptors" => [
-              {
-                "type" => "api",
-                "displayName" => "Produced API",
-                "description" => "An API provided by the producer.",
-                "labels" => [
-                  {
-                    "key" => "project_id",
-                    "description" => "The identifier of the GCP project associated with this resource (e.g., my-project)."
-                  },
-                  {
-                    "key" => "service",
-                    "description" => "API service name e.g. \"cloudsql.googleapis.com\"."
-                  },
-                  {
-                    "key" => "method",
-                    "description" => "API method e.g. \"disks.list\"."
-                  },
-                  {
-                    "key" => "version",
-                    "description" => "API version e.g. \"v1\"."
-                  },
-                  {
-                    "key" => "location",
-                    "description" => "The service specific notion of location. This can be a name of a zone, region, or \"global."
-                  }
-                ],
-                "name" => "projects/#{@project}/monitoredResourceDescriptors/api"
-              }
-            ]
-          }
-          build_excon_response(body)
+        def list_monitored_resource_descriptors(_filter, _page_size, _page_token)
+          Fog::Mock.not_implemented
         end
       end
     end

data/lib/fog/google/requests/monitoring/list_timeseries.rb

@@ -7,10 +7,23 @@ module Fog
       #
       # @see https://cloud.google.com/monitoring/api/ref_v3/rest/v3/projects.timeSeries/list
       class Real
-        def list_timeseries(options = {})
-          api_method = @monitoring.projects.time_series.list
-          parameters = {
-            "name" => "projects/#{@project}"
+        def list_timeseries(filter: nil, interval: nil, aggregation: nil, order_by: nil, page_size: nil, page_token: nil, view: nil)
+          if filter.nil?
+            raise ArgumentError.new("filter is required")
+          end
+
+          if interval.nil?
+            raise ArgumentError.new("interval is required")
+          end
+
+          options = {
+            :filter => filter,
+            :interval_end_time => interval[:end_time],
+            :interval_start_time => interval[:start_time],
+            :order_by => order_by,
+            :page_size => page_size,
+            :page_token => page_token,
+            :view => view
           }
           if options.key?(:interval)
             interval = options[:interval]
@@ -18,68 +31,21 @@ module Fog
             parameters["interval.startTime"] = interval[:start_time] if interval.key?(:start_time)
           end
 
-          if options.key?(:aggregation)
-            aggregation = options[:aggregation]
-            parameters["aggregation.alignmentPeriod"] = aggregation[:alignment_period] if aggregation.key?(:alignment_period)
-            parameters["aggregation.crossSeriesReducer"] = aggregation[:cross_series_reducer] if aggregation.key?(:cross_series_reducer)
-            parameters["aggregation.groupByFields"] = aggregation[:group_by_fields] if aggregation.key?(:group_by_fields)
-            parameters["aggregation.perSeriesAligner"] = aggregation[:per_series_aligner] if aggregation.key?(:per_series_aligner)
-          end
-
-          parameters["filter"] = options[:filter] if options.key?(:filter)
-          parameters["orderBy"] = options[:order_by] if options.key?(:order_by)
-          parameters["pageSize"] = options[:page_size] if options.key?(:page_size)
-          parameters["pageToken"] = options[:page_token] if options.key?(:page_token)
-          parameters["view"] = options[:view] if options.key?(:view)
-
-          unless parameters.key?("interval.startTime")
-            raise ArgumentError.new("option :interval must have :start_time value for listing timeseries")
+          unless aggregation.nil?
+            %i(alignment_period cross_series_reducer group_by_fields per_series_aligner).each do |k|
+              if aggregation.key?(k)
+                options["aggregation_#{k}".to_sym] = aggregation[k]
+              end
+            end
           end
 
-          unless parameters.key?("interval.endTime")
-            raise ArgumentError.new("option :interval must have :end_time value for listing timeseries")
-          end
-
-          unless parameters.key?("filter")
-            raise ArgumentError.new("options[:filter] value is required to list timeseries")
-          end
-
-          request(api_method, parameters)
+          @monitoring.list_project_time_series("projects/#{@project}", options)
         end
       end
 
       class Mock
-        def list_timeseries(interval, _options = {})
-          body = {
-            "timeSeries" => [
-              {
-                "metric" => {
-                  "labels" => { "instance_name" => "emilyye-dev" },
-                  "type" => "compute.googleapis.com/instance/cpu/usage_time"
-                },
-                "resource" => {
-                  "type" => "gce_instance",
-                  "labels" => {
-                    "instance_id" => "3959348537894302241",
-                    "zone" => "us-central1-c",
-                    "project_id" => @project
-                  }
-                },
-                "metricKind" => "DELTA",
-                "valueType" => "DOUBLE",
-                "points" => [
-                  {
-                    "interval" => interval,
-                    "value" => {
-                      "doubleValue" => 1.8277230720141233
-                    }
-                  }
-                ]
-              }
-            ]
-          }
-
-          build_excon_response(body)
+        def list_timeseries(_options = {})
+          Fog::Mock.not_implemented
         end
       end
     end