fog 1.23.0 → 1.24.0

data/lib/fog/google/core.rb

@@ -5,8 +5,11 @@ module Fog
   module Google
     extend Fog::Provider
 
-    service(:compute, 'Compute')
-    service(:storage, 'Storage')
+    service(:compute,    'Compute')
+    service(:dns,        'DNS')
+    service(:monitoring, 'Monitoring')
+    service(:storage,    'Storage')
+    service(:sql,        'SQL')
 
     class Mock
       def self.etag
@@ -18,5 +21,160 @@ module Fog
         rand(max).to_s(16)
       end
     end
+
+    module Shared
+      attr_reader :project, :api_version, :api_url
+
+      ##
+      # Initializes shared attributes
+      #
+      # @param [String] project Google Cloud Project
+      # @param [String] api_version Google API version
+      # @param [String] base_url Google API base url
+      # @return [void]
+      def shared_initialize(project, api_version, base_url)
+        @project = project
+        @api_version = api_version
+        @api_url = base_url + api_version + '/projects/'
+      end
+
+      ##
+      # Initializes the Google API Client
+      #
+      # @param [Hash] options Google API options
+      # @option options [String] :google_client_email A @developer.gserviceaccount.com email address to use
+      # @option options [String] :google_key_location The location of a pkcs12 key file
+      # @option options [String] :google_key_string The content of the pkcs12 key file
+      # @option options [String] :google_api_scope_url The access scope URLs
+      # @option options [String] :app_name The app name to set in the user agent
+      # @option options [String] :app_version The app version to set in the user agent
+      # @option options [Google::APIClient] :google_client Existing Google API Client
+      # @return [Google::APIClient] Google API Client
+      # @raises [ArgumentError] If there is any missing argument
+      def initialize_google_client(options)
+        # NOTE: loaded here to avoid requiring this as a core Fog dependency
+        begin
+          require 'google/api_client'
+        rescue LoadError => error
+          Fog::Logger.warning('Please install the google-api-client gem before using this provider')
+          raise error
+        end
+
+        # User can provide an existing Google API Client
+        client = options[:google_client]
+        return client unless client.nil?
+
+        # Validate required arguments
+        unless options[:google_client_email]
+          raise ArgumentError.new('Missing required arguments: google_client_email')
+        end
+
+        if options[:google_key_location]
+          google_key = File.expand_path(options[:google_key_location])
+        elsif options[:google_key_string]
+          google_key = options[:google_key_string]
+        else
+          raise ArgumentError.new('Missing required arguments: google_key_location or google_key_string')
+        end
+
+        unless options[:google_api_scope_url]
+          raise ArgumentError.new('Missing required arguments: google_api_scope_url')
+        end
+
+        # Create a new Google API Client
+        self.new_pk12_google_client(
+          options[:google_client_email],
+          google_key,
+          options[:google_api_scope_url],
+          options[:app_name],
+          options[:app_version]
+        )
+      end
+
+      ##
+      # Create a Google API Client with a user email and a pkcs12 key
+      #
+      # @param [String] google_client_email A @developer.gserviceaccount.com email address to use
+      # @param [String] google_key An absolute location to a pkcs12 key file or the content of the file itself
+      # @param [String] google_api_scope_url Access scope URLs
+      # @param [String] app_name The app name to set in the user agent
+      # @param [String] app_version The app version to set in the user agent
+      # @return [Google::APIClient] Google API Client
+      def new_pk12_google_client(google_client_email, google_key, google_api_scope_url, app_name = nil, app_version = nil)
+        application_name = app_name.nil? ? 'fog' : "#{app_name}/#{app_version || '0.0.0'} fog"
+        api_client_options = {
+          :application_name => application_name,
+          :application_version => Fog::VERSION,
+        }
+        client = ::Google::APIClient.new(api_client_options)
+
+        client.authorization = Signet::OAuth2::Client.new(
+          {
+            :audience => 'https://accounts.google.com/o/oauth2/token',
+            :auth_provider_x509_cert_url => 'https://www.googleapis.com/oauth2/v1/certs',
+            :client_x509_cert_url => "https://www.googleapis.com/robot/v1/metadata/x509/#{google_client_email}",
+            :issuer => google_client_email,
+            :scope => google_api_scope_url,
+            :signing_key => ::Google::APIClient::KeyUtils.load_from_pkcs12(google_key, 'notasecret'),
+            :token_credential_uri => 'https://accounts.google.com/o/oauth2/token',
+          }
+        )
+        client.authorization.fetch_access_token!
+
+        client
+      end
+
+      ##
+      # Executes a request and wraps it in a result object
+      #
+      # @param [Google::APIClient::Method] api_method The method object or the RPC name of the method being executed
+      # @param [Hash] parameters The parameters to send to the method
+      # @param [Hash] body_object The body object of the request
+      # @return [Excon::Response] The result from the API
+      def request(api_method, parameters, body_object = nil)
+        client_parms = {
+          :api_method => api_method,
+          :parameters => parameters,
+        }
+        client_parms[:body_object] = body_object if body_object
+
+        result = @client.execute(client_parms)
+
+        build_excon_response(result.body.nil? || result.body.empty? ? nil : Fog::JSON.decode(result.body), result.status)
+      end
+
+      ##
+      # Builds an Excon response
+      #
+      # @param [Hash] Response body
+      # @param [Integer] Response status
+      # @return [Excon::Response] Excon response
+      def build_excon_response(body, status = 200)
+        response = Excon::Response.new(:body => body, :status => status)
+        if body && body.has_key?('error')
+          msg = 'Google Cloud did not return an error message'
+
+          if body['error'].kind_of?(Hash)
+            response.status = body['error']['code']
+            if body['error'].has_key?('errors')
+              msg = body['error']['errors'].map{ |error| error['message'] }.join(', ')
+            elsif body['error'].has_key?('message')
+              msg = body['error']['message']
+            end
+          elsif body['error'].kind_of?(Array)
+            msg = body['error'].map{ |error| error['code'] }.join(', ')
+          end
+
+          case response.status
+            when 404
+              raise Fog::Errors::NotFound.new(msg)
+            else
+              raise Fog::Errors::Error.new(msg)
+          end
+        end
+
+        response
+      end
+    end
   end
 end

data/lib/fog/google/dns.rb

@@ -0,0 +1,63 @@
+require 'fog/google/core'
+
+module Fog
+  module DNS
+    class Google < Fog::Service
+      requires :google_project
+      recognizes :app_name, :app_version, :google_client_email, :google_key_location, :google_key_string, :google_client
+
+      GOOGLE_DNS_API_VERSION     = 'v1beta1'
+      GOOGLE_DNS_BASE_URL        = 'https://www.googleapis.com/dns/'
+      GOOGLE_DNS_API_SCOPE_URLS  = %w(https://www.googleapis.com/auth/ndev.clouddns.readwrite)
+
+      request_path 'fog/google/requests/dns'
+      request :create_managed_zone
+      request :delete_managed_zone
+      request :get_managed_zone
+      request :list_managed_zones
+
+      class Mock
+	include Fog::Google::Shared
+
+        def initialize(options)
+          shared_initialize(options[:google_project], GOOGLE_DNS_API_VERSION, GOOGLE_DNS_BASE_URL)
+        end
+
+	def self.data(api_version)
+	  @data ||= {}
+	end
+
+	def self.reset
+	  @data = nil
+	end
+
+        def data(project=@project)
+          self.class.data(api_version)[project] ||= {
+              :managed_zones => {
+                  :by_id => {},
+                  :by_name => {},
+              },
+	  }
+        end
+
+        def reset_data
+          self.class.data(api_version).delete(@project)
+        end
+      end
+
+      class Real
+        include Fog::Google::Shared
+
+        attr_accessor :client
+        attr_reader :dns
+
+        def initialize(options)
+          shared_initialize(options[:google_project], GOOGLE_DNS_API_VERSION, GOOGLE_DNS_BASE_URL)
+          options.merge!(:google_api_scope_url => GOOGLE_DNS_API_SCOPE_URLS.join(' '))
+          @client = initialize_google_client(options)
+          @dns = @client.discovered_api('dns', api_version)
+        end
+      end
+    end
+  end
+end

data/lib/fog/google/examples/backend_services.rb

@@ -0,0 +1,22 @@
+require 'rubygems'
+require 'fog'
+
+def test
+  connection = Fog::Compute.new({:provider => "google"})
+  health = connection.http_health_checks.create({
+    :name => 'test-checks'
+  })
+  health.wait_for { health.ready? }
+  backend= connection.backend_services.create({
+    :name => 'backend-test',
+    :health_checks => [health.self_link],
+    :port => 8080,
+    :timeout_sec => 40,
+    :backends => [{'group' => 'resource_view self_link'}]
+  })
+  puts connection.backend_services.all
+  backend= connection.backend_services.get('backend-test')
+  backend.get_health
+end
+
+test

data/lib/fog/google/examples/create.rb

@@ -16,9 +16,9 @@ def test
     :name => "fog-smoke-test-#{Time.now.to_i}",
     :disks => [disk],
     :machine_type => "n1-standard-1",
-    :zone_name => "us-central1-a",
     :private_key_path => File.expand_path("~/.ssh/id_rsa"),
     :public_key_path => File.expand_path("~/.ssh/id_rsa.pub"),
+    :zone_name => "us-central1-a",
     :user => ENV['USER'],
     :tags => ["fog"]
   })

data/lib/fog/google/examples/eric-fail.rb

@@ -1,5 +1,5 @@
 def test
-  connection = Fog::Compute.new({ :provider => "Google" })
+ connection = Fog::Compute.new({ :provider => "Google" })
 
   name = "fog-smoke-test-#{Time.now.to_i}"
   zone = "us-central1-a"

data/lib/fog/google/examples/image_create.rb

@@ -9,7 +9,7 @@ def test
   # Can't test this unless the 'source' points to a valid URL
   return if rawdisk[:source].nil?
 
-  img = connection.image.create(:name             => 'test-image',
+  img = connection.images.create(:name             => 'test-image',
                                 :description      => 'Test image (via fog)',
                                 :raw_disk         => rawdisk)
 

data/lib/fog/google/examples/l7_load_balance.rb

@@ -0,0 +1,73 @@
+# This example assumes three instances have been created in the project.
+# They should each have Apache installed and distinct index.html files
+# in order to observe the results of the l7 load balancer. A firewall
+# rule should also have been created with a tag shared by the instances.
+# More info on Google's HTTP load balancing: 
+# https://developers.google.com/compute/docs/load-balancing/http/
+
+def test
+  connection = Fog::Compute.new({:provider => "google"})
+  health = connection.http_health_checks.create({
+    :name => 'test-checks'
+    })
+  instance1 = connection.servers.get('fog-l7-instance-1')
+  instance2 = connection.servers.get('fog-l7-instance-2')
+  instance3  = connection.servers.get('fog-l7-instance-3')
+
+  resource_view1 = connection.resource_views.create({ 
+    :name => 'fog-l7-resource-view-1',
+    :numMembers => 1, 
+    :members => [instance1.self_link], 
+    :zone => 'us-central1-a' 
+    })
+  resource_view1.add_resources(instance1.self_link)
+  resource_view2 = connection.resource_views.create({ 
+    :name => 'fog-l7-resource-view-2', 
+    :numMembers => 1, 
+    :members => [instance2.self_link], 
+    :zone => 'us-central1-a' 
+    })
+  resource_view2.add_resources(instance2.self_link)
+  resource_view3 = connection.resource_views.create({ 
+    :name => 'fog-l7-resource-view-3', 
+    :members => [instance3.self_link], 
+    :zone => 'us-central1-b' })
+  resource_view3.add_resources(instance3.self_link)
+  backend_service1 = connection.backend_services.create({
+    :name => 'fog-l7-backend-service-1',
+    :health_checks => [health.self_link],
+    :backends => [{'balancingMode' => 'RATE', 'maxRate' => 100, 'group' => resource_view1.self_link}]
+  })
+  backend_service2 = connection.backend_services.create({
+    :name => 'fog-l7-backend-service-2',
+    :health_checks => [health.self_link],
+    :backends => [{'balancingMode' => 'RATE', 'maxRate' => 100, 'group' => resource_view2.self_link}]
+  })
+  backend_service3 = connection.backend_services.create({
+    :name => 'fog-l7-backend-service-3',
+    :health_checks => [health.self_link],
+    :backends => [{'balancingMode' => 'RATE', 'maxRate' => 100, 'group' => resource_view3.self_link}]
+  })
+  url_map = connection.url_maps.create({
+    :name => 'fog-l7-url-map',
+    :pathMatchers => [{ 
+      'name' => 'pathmatcher', 
+      'defaultService' => backend_service1.self_link, 
+      'pathRules' => [
+        { 'paths' => ["/one/*"], 
+        "service" => backend_service1.self_link }, 
+        {'paths' => ["/two/*"], 
+        "service" => backend_service2.self_link }, 
+        {'paths' => ["/three/*"], 
+        'service' => backend_service3.self_link } 
+        ]
+      }], 
+    :hostRules => [{ 'hosts' => ['*'], 'pathMatcher' => 'pathmatcher'}],
+    :defaultService => backend_service1.self_link,
+  })
+  proxy = connection.target_http_proxies.create({
+    :name => 'fog-l7-proxy',
+    :urlMap => url_map.self_link
+  }) 
+  fwd_rle = connection.global_forwarding_rules.create({:name => 'fog-l7-fwd-rule', :target => proxy.self_link })
+end

data/lib/fog/google/examples/monitoring/metric_descriptors.rb

@@ -0,0 +1,11 @@
+def test
+  connection = Fog::Google::Monitoring.new
+
+  puts 'Listing all MetricDescriptors...'
+  puts '--------------------------------'
+  connection.metric_descriptors
+
+  puts 'Listing all MetricDescriptors related to Google Compute Engine...'
+  puts '-----------------------------------------------------------------'
+  connection.metric_descriptors.all(:query => 'compute')
+end

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

@@ -0,0 +1,15 @@
+def test
+  connection = Fog::Google::Monitoring.new
+
+  puts 'Listing all Timeseries for the metric compute.googleapis.com/instance/uptime...'
+  puts '-------------------------------------------------------------------------------'
+  connection.timeseries_collection.all('compute.googleapis.com/instance/uptime',
+                                       DateTime.now.rfc3339)
+
+  puts 'Listing all Timeseries for the metric compute.googleapis.com/instance/uptime &'
+  puts 'the region us-central1...'
+  puts '------------------------------------------------------------------------------'
+  connection.timeseries_collection.all('compute.googleapis.com/instance/uptime',
+                                       DateTime.now.rfc3339,
+                                       :labels => 'cloud.googleapis.com/location=~us-central1.*')
+end

data/lib/fog/google/examples/monitoring/timeseries_descriptors.rb

@@ -0,0 +1,15 @@
+def test
+  connection = Fog::Google::Monitoring.new
+
+  puts 'Listing all TimeseriesDescriptors for the metric compute.googleapis.com/instance/uptime...'
+  puts '------------------------------------------------------------------------------------------'
+  connection.timeseries_descriptors.all('compute.googleapis.com/instance/uptime',
+                                        DateTime.now.rfc3339)
+
+  puts 'Listing all TimeseriesDescriptors for the metric compute.googleapis.com/instance/uptime &'
+  puts 'the region us-central1...'
+  puts '-----------------------------------------------------------------------------------------'
+  connection.timeseries_descriptors.all('compute.googleapis.com/instance/uptime',
+                                        DateTime.now.rfc3339,
+                                        :labels => 'cloud.googleapis.com/location=~us-central1.*')
+end

data/lib/fog/google/examples/sql/flags.rb

@@ -0,0 +1,7 @@
+def test
+  connection = Fog::Google::SQL.new
+
+  puts 'Listing all Flags...'
+  puts '--------------------'
+  connection.flags
+end

data/lib/fog/google/examples/sql/instances.rb

@@ -0,0 +1,38 @@
+def test
+  connection = Fog::Google::SQL.new
+
+  puts 'Create a Instance...'
+  puts '--------------------'
+  instance = connection.instances.create(:instance => Fog::Mock.random_letters(16), :tier => 'D1')
+  instance.wait_for { ready? }
+
+  puts 'Get the Instance...'
+  puts '----------------------'
+  connection.instances.get(instance.instance)
+
+  puts 'List all Instances...'
+  puts '---------------------'
+  connection.instances.all
+
+  puts 'Update the Instance...'
+  puts '----------------------'
+  instance.activation_policy = 'ALWAYS'
+  instance.update
+  instance.wait_for { ready? }
+
+  puts 'Reset the Instance SSL configuration...'
+  puts '---------------------------------------'
+  instance.reset_ssl_config
+
+  puts 'Restart the Instance...'
+  puts '-----------------------'
+  instance.restart
+
+  puts 'Set the Instance root password...'
+  puts '---------------------------------'
+  instance.set_root_password(Fog::Mock.random_letters_and_numbers(8))
+
+  puts 'Delete the Instance...'
+  puts '----------------------'
+  instance.destroy
+end