miasma-google 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e2d2cab6950ca96ad4fb8c6a3d190bbb3a43dab3
+  data.tar.gz: 25e2c4132fc3a15959b1ea3fc154c0bbe84f8dc2
+SHA512:
+  metadata.gz: 80b7edcbb1da6434ed0fc57b35c16d9b6b5b75066255c4142a2f2582939bfc4522bbc218a7a0595e842b07f296c5fb2529372cd49da76c744d84b43758ff37dd
+  data.tar.gz: e87bde17346316b5e81f2dcf2b952f899a58eb31f21746dd71918971d3a151b74f51937ee46f28494c12472d9d600d46535bf60dee33bc26a7b7eb33005ff48d

data/CHANGELOG.md

@@ -0,0 +1,2 @@
+# v0.1.0
+* Initial release with Orchestration support

data/README.md

@@ -0,0 +1,46 @@
+# Miasma Google
+
+Google API plugin for the miasma cloud library
+
+## Supported credential attributes:
+
+Supported attributes used in the credentials section of API
+configurations:
+
+```ruby
+Miasma.api(
+  :type => :orchestration,
+  :provider => :google,
+  :credentials => {
+    ...
+  }
+)
+```
+
+### Credential attributes
+
+` `google_project` - ID of the google project to use
+* `google_service_account_email` - Email address for service account
+* `google_service_account_private_key` - Path to private key for service account
+* `google_auth_scope` - Scope requested for user (default: `'cloud-platform'`)
+* `google_auth_base` - URL endpoint for authorization (default: `'https://www.googleapis.com/auth'`)
+* `google_assertion_target` - URL for permission assertion (default: `'https://www.googleapis.com/oauth2/v4/token'`)
+* `google_assertion_expiry` - Number of seconds token is valid (default: `120`)
+* `google_api_base_endpoint` - URL for requests (default: `'https://www.googleapis.com'`)
+
+## Current support matrix
+
+|Model         |Create|Read|Update|Delete|
+|--------------|------|----|------|------|
+|AutoScale     |      |    |      |      |
+|BlockStorage  |      |    |      |      |
+|Compute       |      |    |      |      |
+|DNS           |      |    |      |      |
+|LoadBalancer  |      |    |      |      |
+|Network       |      |    |      |      |
+|Orchestration |  X   | X  |  X   |  X   |
+|Queues        |      |    |      |      |
+|Storage       |      |    |      |      |
+
+## Info
+* Repository: https://github.com/miasma-rb/miasma-google

data/lib/miasma-google/version.rb

@@ -0,0 +1,3 @@
+module MiasmaGoogle
+  VERSION = Gem::Version.new('0.1.0')
+end

data/lib/miasma/contrib/google.rb

@@ -0,0 +1,261 @@
+require 'miasma'
+require 'base64'
+require 'digest/sha2'
+require 'openssl'
+
+module Miasma
+
+  module Contrib
+
+    module Google
+
+      # Base signature class
+      class Signature
+
+        # @return [String] algorithm of signature
+        attr_reader :algorithm
+        # @return [String] format of signature
+        attr_reader :format
+        # @return [Smash] signature claims
+        attr_reader :claims
+
+        # Create a new signature
+        #
+        # @param [String, Symbol] algorithm used for signature
+        # @param [String, Symbol] format of signature
+        # @param claims [Hash] request claims
+        # @return [self]
+        def initialize(algo, fmt, clms)
+          @algorithm = algo
+          @format = fmt
+          @claims = clms.to_smash
+        end
+
+        # Generate signature
+        #
+        # @return [String]
+        def generate
+          raise NotImplementedError
+        end
+
+        # JSON Web Token signature
+        class Jwt < Signature
+
+          # Required items within claims
+          REQUIRED_CLAIMS = [
+            :iss, # email address of service account
+            :scope, # space-delimited list of permissions requested
+            :aud, # intended target of assertion
+            :exp, # expiration time of assertion
+            :iat # time assertion was issued
+          ]
+
+          # Create a new JWT signature instance
+          #
+          # @param private_key_path [String] private signing key path
+          # @param claims [Hash] request claims
+          # @return [self]
+          def initialize(private_key_path, i_claims)
+            super('RS256', 'JWT', i_claims)
+            claims[:iat] ||= Time.now.to_i
+            claims[:exp] ||= Time.now.to_i + 120
+            @private_key = private_key_path
+            validate_claims!
+            validate_key!
+          end
+
+          # Generate signature
+          #
+          # @return [String]
+          def generate
+            "#{encoded_header}.#{encoded_claims}.#{encoded_signature}"
+          end
+
+          # @return [String] encoded header
+          def encoded_header
+            Base64.urlsafe_encode64(header.to_json)
+          end
+
+          # @return [String] header
+          def header
+            Smash.new(
+              :alg => algorithm,
+              :typ => format
+            )
+          end
+
+          # @return [String] encoded claims set
+          def encoded_claims
+            t_claims = claims.to_smash
+            if(t_claims.key?(:scope))
+              t_claims[:scope] = [t_claims[:scope]].flatten.compact.join(' ')
+            end
+            Base64.urlsafe_encode64(t_claims.to_json)
+          end
+
+          # @return [String] encoded signature
+          def encoded_signature
+            Base64.urlsafe_encode64(signature)
+          end
+
+          # @return [String] JWT signature
+          def signature
+            token = "#{encoded_header}.#{encoded_claims}"
+            hasher = OpenSSL::Digest::SHA256.new
+            author = OpenSSL::PKey::RSA.new(File.read(@private_key))
+            author.sign(hasher, token)
+          end
+
+          # Check for required claims and raise error if unset
+          #
+          # @return [TrueClass]
+          # @raises [KeyError]
+          def validate_claims!
+            REQUIRED_CLAIMS.each do |claim|
+              unless(claims.key?(claim))
+                raise KeyError.new "Missing required claim key `#{claim}`"
+              end
+            end
+            true
+          end
+
+          # Check that the private key exists, is readable, and is
+          def validate_key!
+          end
+
+        end
+
+      end
+
+      module ApiCommon
+
+        def self.included(klass)
+          klass.class_eval do
+            attribute :google_service_account_email, String, :required => true
+            attribute :google_service_account_private_key, String, :required => true
+            attribute :google_auth_scope, String, :required => true, :multiple => true, :default => 'cloud-platform'
+            attribute :google_auth_base, String, :default => 'https://www.googleapis.com/auth'
+            attribute :google_assertion_target, String, :required => true, :default => 'https://www.googleapis.com/oauth2/v4/token'
+            attribute :google_assertion_expiry, Integer, :required => true, :default => 120
+            attribute :google_project, String, :required => true
+            attribute :google_api_base_endpoint, String, :required => true, :default => 'https://www.googleapis.com'
+          end
+
+          klass.const_set(:TOKEN_GRANT_TYPE, 'urn:ietf:params:oauth:grant-type:jwt-bearer')
+        end
+
+        # @return [String]
+        def endpoint
+          point = google_api_base_endpoint.dup
+          if(self.class.const_defined?(:GOOGLE_SERVICE_PATH))
+            point << "/#{self.class.const_get(:GOOGLE_SERVICE_PATH)}"
+          end
+          if(self.class.const_defined?(:GOOGLE_SERVICE_PROJECT) && self.class.const_get(:GOOGLE_SERVICE_PROJECT))
+            point << "/projects/#{google_project}"
+          end
+          point
+        end
+
+        # Setup for API connections
+        def connect
+          @oauth_token_information = Smash.new
+        end
+
+        def oauth_token_information
+          @oauth_token_information
+        end
+
+        # @return [HTTP] connection for requests (forces headers)
+        def connection
+          super.headers(
+            'Authorization' => "Bearer #{client_access_token}"
+          )
+        end
+
+        # @return [Contrib::Google::Signature::Jwt]
+        def signer
+          Contrib::Google::Signature::Jwt.new(
+            google_service_account_private_key,
+            :iss => google_service_account_email,
+            :scope => [google_auth_scope].flatten.compact.map{|scope|
+              "#{google_auth_base}/#{scope}"
+            },
+            :aud => google_assertion_target,
+            :exp => Time.now.to_i + google_assertion_expiry
+          )
+        end
+
+        # Request a new authentication token from the remote API
+        #
+        # @return [Smash] token information - :access_token, :token_type, :expires_in, :expires_on
+        def request_client_token
+          token_signer = signer
+          result = HTTP.post(
+            google_assertion_target,
+            :form => {
+              :grant_type => self.class.const_get(:TOKEN_GRANT_TYPE),
+              :assertion => token_signer.generate
+            }
+          )
+          unless(result.code == 200)
+            raise Miasma::Error::ApiError.new(
+              'Request for client authentication token failed',
+              :response => result
+            )
+          end
+          @oauth_token_information = MultiJson.load(result.body.to_s).to_smash
+          @oauth_token_information[:expires_on] = Time.at(
+            @oauth_token_information[:expires_in] + token_signer.claims[:iat].to_i
+          )
+          @oauth_token_information
+        end
+
+        # @return [String] auth token
+        def client_access_token
+          request_client_token if access_token_expired?
+          oauth_token_information[:access_token]
+        end
+
+        # @return [TrueClass, FalseClass]
+        def access_token_expired?
+          if(oauth_token_information[:expires_on])
+            oauth_token_information[:expires_on] < Time.now
+          else
+            true
+          end
+        end
+
+        # When in debug mode, do not retry requests
+        #
+        # @return [TrueClass, FalseClass]
+        def retryable_allowed?(*_)
+          if(ENV['DEBUG'])
+            false
+          else
+            super
+          end
+        end
+
+        # Define when request should be retried
+        #
+        # @param exception [Exception]
+        # @return [TrueClass, FalseClass]
+        def perform_request_retry(exception)
+          if(exception.is_a?(Error::ApiError::RequestError))
+            exception.response.code >= 500
+          else
+            false
+          end
+        end
+
+      end
+    end
+  end
+
+  Models::Storage.autoload :Google, 'miasma/contrib/google/storage'
+  Models::Orchestration.autoload :Google, 'miasma/contrib/google/orchestration'
+
+  # Models::Compute.autoload :Google, 'misama/contrib/google/compute'
+  # Models::LoadBalancer.autoload :Google, 'misama/contrib/google/load_balancer'
+  # Models::AutoScale.autoload :Google, 'misama/contrib/google/auto_scale'
+end

data/lib/miasma/contrib/google/orchestration.rb

@@ -0,0 +1,338 @@
+require 'securerandom'
+require 'miasma'
+
+module Miasma
+  module Models
+    class Orchestration
+      class Google < Orchestration
+
+        include Contrib::Google::ApiCommon
+
+        GOOGLE_SERVICE_PATH = '/deploymentmanager/v2'
+        GOOGLE_SERVICE_PROJECT = true
+
+        # Determine stack state based on last operation information
+        #
+        # @param operation [Hash]
+        # @option operation [String] :operationType
+        # @option operation [String] :status
+        # @return [Symbol]
+        def determine_state(operation)
+          prefix = case operation[:operationType]
+                   when 'insert'
+                     'create'
+                   when 'update'
+                     'update'
+                   when 'delete'
+                     'delete'
+                   end
+          suffix = case operation[:status]
+                   when 'RUNNING', 'PENDING'
+                     'in_progress'
+                   when 'DONE'
+                     'complete'
+                   end
+          if(operation[:error])
+            suffix = 'failed'
+          end
+          if(prefix.nil? || suffix.nil?)
+            :unknown
+          else
+            "#{prefix}_#{suffix}".to_sym
+          end
+        end
+
+        # Create stack data hash from information
+        #
+        # @param info [Hash]
+        # @option info [String] :insertTime
+        # @option info [String] :description
+        # @option info [String] :name
+        # @option info [Hash] :operation
+        # @return [Hash]
+        def basic_stack_data_format(info)
+          info = info.to_smash
+          Smash.new(
+            :id => info[:id],
+            :created => Time.parse(info[:insertTime]),
+            :updated => Time.parse(info.fetch(:operation, :endTime, info.fetch(:operation, :startTime, info[:insertTime]))),
+            :description => info[:description],
+            :name => info[:name],
+            :state => determine_state(info.fetch(:operation, {})),
+            :status => determine_state(info.fetch(:operation, {})).to_s.split('_').map(&:capitalize).join(' '),
+            :custom => info
+          )
+        end
+
+        # @return [Array<Stack>]
+        def stack_all
+          result = request(
+            :path => 'global/deployments'
+          )
+          result.fetch(:body, :deployments, []).map do |item|
+            new_stack = Stack.new(self)
+            new_stack.load_data(basic_stack_data_format(item)).valid_state
+          end
+        end
+
+        # Save stack state
+        #
+        # @param stack [Stack]
+        # @return [Stack]
+        def stack_save(stack)
+          unless(stack.persisted?)
+            result = request(
+              :path => 'global/deployments',
+              :method => :post,
+              :json => {
+                :name => stack.name,
+                :target => template_data_unformat(stack.template)
+              }
+            )
+          else
+            result = request(
+              :path => "global/deployments/#{stack.name}",
+              :method => :put,
+              :json => {
+                :name => stack.name,
+                :target => template_data_unformat(stack.template),
+                :fingerprint => stack.custom[:fingerprint]
+              }
+            )
+          end
+          stack.id = result.get(:body, :id)
+          stack.valid_state
+          stack.reload
+        end
+
+        # Fetch the stack template
+        #
+        # @param stack [Stack]
+        # @return [Hash]
+        def stack_template_load(stack)
+          if(stack.persisted?)
+            result = request(
+              :endpoint => stack.custom.fetch(:manifest, stack.custom.get(:update, :manifest))
+            )
+            cache_template = stack.template = template_data_format(result[:body])
+            stack.custom = stack.custom.merge(result[:body])
+            if(stack.custom['expandedConfig'])
+              stack.custom['expandedConfig'] = YAML.load(stack.custom['expandedConfig']).to_smash
+            end
+            if(stack.custom['layout'])
+              stack.custom['layout'] = YAML.load(stack.custom['layout']).to_smash
+            end
+            stack.valid_state
+            cache_template
+          else
+            Smash.new
+          end
+        end
+
+        # Pack template data for shipping to API
+        #
+        # @param data [Hash]
+        # @option data [Hash] :config
+        # @option data [Array<Hash>] :imports
+        # @return [Hash]
+        def template_data_unformat(data)
+          Hash.new.tap do |result|
+            if(v = data.to_smash.get(:config, :content))
+              result[:config] = {
+                :content => yamlize(v)
+              }
+            end
+            if(data[:imports])
+              result[:imports] = data[:imports].map do |item|
+                Smash.new(
+                  :name => item['name'],
+                  :content => yamlize(item['content'])
+                )
+              end
+            end
+          end
+        end
+
+        # Convert value to YAML if not string
+        #
+        # @param value [Object]
+        # @return [String, Object]
+        def yamlize(value)
+          unless(value.is_a?(String))
+            if(value.is_a?(Hash) && value.respond_to?(:to_hash))
+              value = value.to_hash
+            end
+            value.to_yaml(:header => true)
+          else
+            value
+          end
+        end
+
+        # Unpack received template data for local model instance
+        #
+        # @param data [Hash]
+        # @option data [Hash] :config
+        # @option data [Array<Hash>] :imports
+        # @return [Hash]
+        def template_data_format(data)
+          data = data.to_smash
+          Smash.new.tap do |result|
+            result[:config] = data.fetch(:config, Smash.new)
+            result[:imports] = data.fetch(:imports, []).map do |item|
+              begin
+                Smash.new(
+                  :name => item[:name],
+                  :content => YAML.load(item[:content])
+                )
+              rescue
+                item
+              end
+            end
+            if(result.get(:config, :content))
+              result[:config][:content] = YAML.load(result[:config][:content]) || Smash.new
+            else
+              result[:config][:content] = Smash.new
+            end
+          end
+        end
+
+        # Reload the stack data
+        #
+        # @param stack [Stack]
+        # @return [Stack]
+        def stack_reload(stack)
+          if(stack.persisted?)
+            result = request(
+              :path => "global/deployments/#{stack.name}"
+            )
+            deploy = result[:body]
+            stack.load_data(basic_stack_data_format(deploy)).valid_state
+            stack_template_load(stack)
+            set_outputs_if_available(stack)
+          end
+          stack
+        end
+
+        # Set outputs into stack instance
+        #
+        # @param stack [Stack]
+        # @return [TrueClass, FalseClass]
+        def set_outputs_if_available(stack)
+          outputs = extract_outputs(stack.custom.fetch(:layout, {}))
+          unless(outputs.empty?)
+            stack.outputs = outputs
+            stack.valid_state
+            true
+          else
+            false
+          end
+        end
+
+        # Extract outputs from stack hash
+        #
+        # @param stack_hash [Hash]
+        # @return [Array<Hash>]
+        def extract_outputs(stack_hash)
+          outputs = []
+          if(stack_hash[:outputs])
+            outputs += stack_hash[:outputs].map do |output|
+              Smash.new(:key => output[:name], :value => output[:finalValue])
+            end
+          end
+          stack_hash.fetch(:resources, []).each do |resource|
+            outputs += extract_outputs(resource)
+          end
+          outputs
+        end
+
+        # Delete stack
+        #
+        # @param stack [Stack]
+        # @return [TrueClass, FalseClass]
+        def stack_destroy(stack)
+          if(stack.persisted?)
+            request(
+              :path => "global/deployments/#{stack.name}",
+              :method => :delete
+            )
+            true
+          else
+            false
+          end
+        end
+
+        # Fetch all events
+        #
+        # @param stack [Stack]
+        # @return [Array<Stack::Event>]
+        def event_all(stack, evt_id=nil)
+          result = request(
+            :path => 'global/operations',
+            :params => {
+              :filter => "targetId eq #{stack.id}"
+            }
+          )
+          result.fetch(:body, :operations, []).map do |event|
+            status_msg = [
+              event[:statusMessage],
+              *event.fetch(:error, :errors, []).map{|e| e[:message]}
+            ].compact.join(' -- ')
+            Stack::Event.new(
+              stack,
+              :id => event[:id],
+              :resource_id => event[:targetId],
+              :resource_name => stack.name,
+              :resource_logical_id => stack.name,
+              :resource_state => determine_state(event),
+              :resource_status => determine_state(event).to_s.split('_').map(&:capitalize).join(' '),
+              :resource_status_reason => "#{event[:status]} - #{event[:progress]}% complete #{status_msg}",
+              :time => Time.parse(event.fetch(:startTime, event[:insertTime]))
+            ).valid_state
+          end
+        end
+
+        # Fetch all stack resources
+        #
+        # @param stack [Stack]
+        # @return [Array<Stack::Resource>]
+        # @todo Add status reason extraction
+        def resource_all(stack)
+          request(
+            :path => "global/deployments/#{stack.name}/resources"
+          ).fetch('body', 'resources', []).map do |resource|
+            Stack::Resource.new(stack,
+              :id => resource[:id],
+              :type => resource[:type],
+              :name => resource[:name],
+              :logical_id => resource[:name],
+              :created => Time.parse(resource[:insertTime]),
+              :updated => resource[:updateTime] ? Time.parse(resource[:updateTime]) : nil,
+              :state => :create_complete,
+              :status => 'OK',
+              :status_reason => resource.fetch(:warnings, []).map{|w| w[:message]}.join(' ')
+            ).valid_state
+          end
+        end
+
+        # Reload resource data
+        #
+        # @param resource [Stack::Resource]
+        # @return [Stack::Resource]
+        def resource_reload(resource)
+          resource.stack.resources.reload
+          resource.stack.resources.get(resource.id)
+        end
+
+        # Reload event data
+        #
+        # @param event [Stack::Event]
+        # @return event [Stack::Event]
+        def event_reload(event)
+          event.stack.events.reload
+          event.stack.events.get(event.id)
+        end
+
+      end
+    end
+  end
+end

data/miasma-google.gemspec

@@ -0,0 +1,21 @@
+$LOAD_PATH.unshift File.expand_path(File.dirname(__FILE__)) + '/lib/'
+require 'miasma-google/version'
+Gem::Specification.new do |s|
+  s.name = 'miasma-google'
+  s.version = MiasmaGoogle::VERSION.version
+  s.summary = 'Smoggy Google API'
+  s.author = 'Chris Roberts'
+  s.email = 'code@chrisroberts.org'
+  s.homepage = 'https://github.com/miasma-rb/miasma-google'
+  s.description = 'Smoggy Google API'
+  s.license = 'Apache 2.0'
+  s.require_path = 'lib'
+  s.add_runtime_dependency 'miasma', '>= 0.2.12'
+  s.add_development_dependency 'pry'
+  s.add_development_dependency 'minitest'
+  s.add_development_dependency 'vcr'
+  s.add_development_dependency 'webmock'
+  s.add_development_dependency 'psych', '>= 2.0.8'
+  s.add_runtime_dependency 'mime-types'
+  s.files = Dir['lib/**/*'] + %w(miasma-google.gemspec README.md CHANGELOG.md LICENSE)
+end

metadata

@@ -0,0 +1,149 @@
+--- !ruby/object:Gem::Specification
+name: miasma-google
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Chris Roberts
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-04-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: miasma
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.2.12
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.2.12
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: vcr
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: psych
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.0.8
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.0.8
+- !ruby/object:Gem::Dependency
+  name: mime-types
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Smoggy Google API
+email: code@chrisroberts.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- README.md
+- lib/miasma-google/version.rb
+- lib/miasma/contrib/google.rb
+- lib/miasma/contrib/google/orchestration.rb
+- miasma-google.gemspec
+homepage: https://github.com/miasma-rb/miasma-google
+licenses:
+- Apache 2.0
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.8
+signing_key: 
+specification_version: 4
+summary: Smoggy Google API
+test_files: []
+has_rdoc: