fog 1.29.0 → 1.30.0

data/lib/fog/google/core.rb

@@ -1,210 +0,0 @@
-require 'fog/core'
-require 'fog/xml'
-
-module Fog
-  module Google
-    extend Fog::Provider
-
-    service(:compute,    'Compute')
-    service(:dns,        'DNS')
-    service(:monitoring, 'Monitoring')
-    service(:storage,    'Storage')
-    service(:sql,        'SQL')
-
-    class Mock
-      def self.etag
-        hex(32)
-      end
-
-      def self.hex(length)
-        max = ('f' * length).to_i(16)
-        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_json_key_location The location of a JSON key file
-      # @option options [String] :google_json_key_string The content of the JSON 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?
-
-        # Create a signing key
-        signing_key = create_signing_key(options)
-
-        # Validate required arguments
-        unless options[:google_client_email]
-          raise ArgumentError.new('Missing required arguments: google_client_email')
-        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],
-          signing_key,
-          options[:google_api_scope_url],
-          options[:app_name],
-          options[:app_version]
-        )
-      end
-
-      ##
-      # Creates a Google signing key
-      #
-      def create_signing_key(options)
-        if options[:google_json_key_location] || options[:google_json_key_string]
-          if options[:google_json_key_location]
-            json_key_location = File.expand_path(options[:google_json_key_location])
-            json_key = File.open(json_key_location, 'r') { |file| file.read }
-          else
-            json_key = options[:google_json_key_string]
-          end
-
-          json_key_hash = Fog::JSON.decode(json_key)
-          unless json_key_hash.has_key?('client_email') || json_key_hash.has_key?('private_key')
-            raise ArgumentError.new('Invalid Google JSON key')
-          end
-
-          options[:google_client_email] = json_key_hash['client_email']
-          ::Google::APIClient::KeyUtils.load_from_pem(json_key_hash['private_key'], 'notasecret')
-        elsif options[:google_key_location] || options[:google_key_string]
-          if options[:google_key_location]
-            google_key = File.expand_path(options[:google_key_location])
-          else
-            google_key = options[:google_key_string]
-          end
-
-          ::Google::APIClient::KeyUtils.load_from_pkcs12(google_key, 'notasecret')
-        else
-          raise ArgumentError.new('Missing required arguments: google_key_location, google_key_string, ' \
-                                  'google_json_key_location or google_json_key_string')
-        end
-      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 [OpenSSL::PKey] signing_key The private key for signing
-      # @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, signing_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 => signing_key,
-            :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

@@ -1,98 +0,0 @@
-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_json_key_location, :google_json_key_string
-
-      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)
-
-      ##
-      # MODELS
-      model_path 'fog/google/models/dns'
-
-      # Zone
-      model :zone
-      collection :zones
-
-      # Record
-      model :record
-      collection :records
-
-      # Change
-      model :change
-      collection :changes
-
-      # Project
-      model :project
-      collection :projects
-
-      ##
-      # REQUESTS
-      request_path 'fog/google/requests/dns'
-
-      # Zone
-      request :create_managed_zone
-      request :delete_managed_zone
-      request :get_managed_zone
-      request :list_managed_zones
-
-      # Record
-      request :list_resource_record_sets
-
-      # Change
-      request :create_change
-      request :get_change
-      request :list_changes
-
-      # Project
-      request :get_project
-
-      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 => {},
-            :resource_record_sets => {},
-            :changes => {},
-          }
-        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

@@ -1,22 +0,0 @@
-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/bootstrap.rb

@@ -1,9 +0,0 @@
-def test
-  connection = Fog::Compute.new({ :provider => "Google" })
-
-  server = connection.servers.bootstrap
-  server.wait_for { sshable? }
-
-  raise "Could not bootstrap sshable server." unless server.ssh("whoami")
-  raise "Could not delete server." unless server.destroy
-end

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

@@ -1,49 +0,0 @@
-def test
-  connection = Fog::Compute.new({ :provider => "Google" })
-
-  name = "fog-smoke-test-#{Time.now.to_i}"
-
-  disk = connection.disks.create({
-    :name => name,
-    :size_gb => 10,
-    :zone_name => 'us-central1-a',
-    :source_image => 'debian-7-wheezy-v20131120',
-  })
-
-  disk.wait_for { disk.ready? }
-
-  server = connection.servers.create(defaults = {
-    :name => "fog-smoke-test-#{Time.now.to_i}",
-    :disks => [disk],
-    :machine_type => "n1-standard-1",
-    :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"]
-  })
-
-  # My own wait_for because it hides errors
-  duration = 0
-  interval = 5
-  timeout = 600
-  start = Time.now
-  until server.sshable? || duration > timeout
-    # puts duration
-    # puts " ----- "
-
-    server.reload
-
-    # p "ready?: #{server.ready?}"
-    # p "public_ip_address: #{server.public_ip_address.inspect}"
-    # p "public_key: #{server.public_key.inspect}"
-    # p "metadata: #{server.metadata.inspect}"
-    # p "sshable?: #{server.sshable?}"
-
-    sleep(interval.to_f)
-    duration = Time.now - start
-  end
-
-  raise "Could not bootstrap sshable server." unless server.ssh("whoami")
-  raise "Could not delete server." unless server.destroy
-end

data/lib/fog/google/examples/dns/project.rb

@@ -1,8 +0,0 @@
-def test
-  connection = Fog::DNS::Google.new
-
-  puts 'Get the Project limits...'
-  puts '-------------------------'
-  connection.projects.get(Fog::DNS[:google].project)
-
-end

data/lib/fog/google/examples/dns/zones.rb

@@ -1,43 +0,0 @@
-def test
-  connection = Fog::DNS::Google.new
-
-  puts 'Create a Zone...'
-  puts '----------------'
-  zone = connection.zones.create(name: 'mytestdomain', domain: 'example.org.', description: 'This is my test domain')
-
-  puts 'List all Zones...'
-  puts '-----------------'
-  connection.zones.all
-
-  puts 'Get the Zone...'
-  puts '---------------'
-  zone = connection.zones.get(zone.id)
-
-  puts 'Create an "A" Record...'
-  puts '-----------------------'
-  record = zone.records.create(name: 'test.example.org.', type: 'A', ttl: 3600, rrdatas: ['192.168.1.1'])
-
-  puts 'Get the Zone Resource Record Sets...'
-  puts '------------------------------------'
-  zone.records
-
-  puts 'Get the Record...'
-  puts '-----------------'
-  record = connection.records(zone: zone).get(name: 'test.example.org.', type: 'A')
-
-  puts 'Modify the "A" Record...'
-  puts '------------------------'
-  record.modify(ttl: 2600)
-
-  puts 'Delete the "A" Record...'
-  puts '------------------------'
-  record.destroy
-
-  puts 'Get the Zone Changes...'
-  puts '-----------------------'
-  zone.changes
-
-  puts 'Delete the Zone...'
-  puts '------------------'
-  zone.destroy
-end

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

@@ -1,36 +0,0 @@
-def test
- connection = Fog::Compute.new({ :provider => "Google" })
-
-  name = "fog-smoke-test-#{Time.now.to_i}"
-  zone = "us-central1-a"
-
-  disk = connection.disks.create({
-    :name => name,
-    :size_gb => 10,
-    :zone_name => zone,
-    :source_image => 'debian-7-wheezy-v20140318',
-  })
-
-  disk.wait_for { disk.ready? }
-
-  scopes = [
-    "https://www.googleapis.com/auth/compute",
-    "devstorage.full_control",
-    "userinfo.email"
-  ]
-
-  server = connection.servers.create({
-    :name => name,
-    :disks => [disk],
-    :machine_type => "n1-standard-1",
-    :zone_name => zone,
-    :metadata => {'foo' => 'bar'},
-    :tags => ["t1", "t2", "t3"],
-    :servce_accounts => scopes
-  })
-  sleep(90)
-
-  raise "Could not reload created server." unless server.reload
-  raise "Could not create sshable server." unless server.ssh("whoami")
-  raise "Could not delete server." unless server.destroy
-end