fog 1.23.0 → 1.42.1

data/lib/fog/rackspace/requests/monitoring/list_notifications.rb

@@ -1,63 +0,0 @@
-module Fog
-  module Rackspace
-    class Monitoring
-      class Real
-        def list_notifications(options={})
-          request(
-            :expects  => [200],
-            :method   => 'GET',
-            :path     => "notifications",
-            :query    => options
-          )
-        end
-      end
-
-      class Mock
-        def list_notifications(options={})
-          account_id = Fog::Mock.random_numbers(6).to_s
-          server_id = Fog::Rackspace::MockData.uuid
-          entity_id = Fog::Mock.random_letters(10)
-          entity_label = Fog::Mock.random_letters(10)
-
-          response = Excon::Response.new
-          response.status = 200
-          response.body = {
-            "values"=> [
-              {
-                  "created_at"=>1378783452067,
-                  "details"=>{
-                      "address"=>"test@test.com"
-                  },
-                  "id"=>"ntnJN3MQrA",
-                  "label"=>"my email update test",
-                  "type"=>"email",
-                  "updated_at"=>1378784136307
-              }
-          ],
-            "metadata" => {
-               "count"       => 1,
-               "limit"       => 100,
-               "marker"      => nil,
-               "next_marker" => nil,
-               "next_href"   => nil
-            }
-          }
-          response.headers = {
-            "Date"                  => Time.now.utc.to_s,
-            "Content-Type"          => "application/json; charset=UTF-8",
-            "X-RateLimit-Limit"     => "50000",
-            "X-RateLimit-Remaining" => "49627",
-            "X-RateLimit-Window"    => "24 hours",
-            "X-RateLimit-Type"      => "global",
-            "X-Response-Id"         => "j23jlk234jl2j34j",
-            "X-LB"                  => "dfw1-maas-prod-api0",
-            "Vary"                  => "Accept-Encoding",
-            "Transfer-Encoding"     => "chunked"
-          }
-          response.remote_ip = Fog::Rackspace::MockData.ipv4_address
-          response
-        end
-      end
-    end
-  end
-end

data/lib/fog/rackspace/requests/monitoring/list_overview.rb

@@ -1,111 +0,0 @@
-module Fog
-  module Rackspace
-    class Monitoring
-      class Real
-        def list_overview(options={})
-          request(
-            :expects  => [200, 203],
-            :method   => 'GET',
-            :path     => "views/overview",
-            :query    => options
-          )
-        end
-      end
-
-      class Mock
-        def list_overview(options={})
-          alarm_id   = Fog::Mock.random_letters(10)
-          check_id   = Fog::Mock.random_letters(10)
-          entity_id  = Fog::Mock.random_letters(10)
-          account_id = Fog::Mock.random_numbers(6).to_s
-          server_id  = Fog::Rackspace::MockData.uuid
-
-          response = Excon::Response.new
-          response.status = 200
-          response.body = {
-            "values" => [
-              {
-                "entity" => {
-                  "id"           => entity_id,
-                  "label"        => "mock_entity",
-                  "ip_addresses" => {
-                    "access_ip0_v6" => Fog::Rackspace::MockData.ipv6_address,
-                    "public0_v4"    => Fog::Rackspace::MockData.ipv4_address,
-                    "public1_v6"    => Fog::Rackspace::MockData.ipv6_address,
-                    "access_ip1_v4" => Fog::Rackspace::MockData.ipv4_address,
-                    "private0_v4"   => Fog::Rackspace::MockData.ipv4_address
-                  },
-                  "metadata" => {
-                    "testing" => "Bar"
-                  },
-                  "managed"    => false,
-                  "uri"        => "https://ord.servers.api.rackspacecloud.com/" + account_id + "/servers/" + server_id,
-                  "agent_id"   => nil,
-                  "created_at" => Time.now.to_i - 1,
-                  "updated_at" => Time.now.to_i
-                },
-                "checks"              => [
-                  {
-                    "id"              => check_id,
-                    "label"           => "mock",
-                    "type"            => "remote.mock",
-                    "details"         => {},
-                    "monitoring_zones_poll" => nil,
-                    "timeout"         => 10,
-                    "period"          => 30,
-                    "target_alias"    => nil,
-                    "target_hostname" => nil,
-                    "target_resolver" => nil,
-                    "disabled       " => false,
-                    "metadata"        => nil,
-                    "created_at"      => Time.now.to_i - 1,
-                    "updated_at"      => Time.now.to_i
-                  }
-                ],
-                "alarms" => [
-                  {
-                    "id"         => alarm_id,
-                    "label"      => nil,
-                    "check_id"   => check_id,
-                    "criteria"   => nil,
-                    "disabled"   => false,
-                    "notification_plan_id" => "npTechnicalContactsEmail",
-                    "metadata"   => nil,
-                    "created_at" => Time.now.to_i - 1,
-                    "updated_at" => Time.now.to_i
-                  }
-                ],
-                "latest_alarm_states" => []
-              }
-            ],
-
-            "metadata" => {
-              "count"       => 1,
-              "limit"       => 100,
-              "marker"      => nil,
-              "next_marker" => nil,
-              "next_href"   => nil
-            }
-
-          }
-
-          response.headers = {
-            "Date"                  => Time.now.utc.to_s,
-            "Content-Type"          => "application/json; charset=UTF-8",
-            "X-RateLimit-Limit"     => "50000",
-            "X-RateLimit-Remaining" => "49627",
-            "X-RateLimit-Window"    => "24 hours",
-            "X-RateLimit-Type"      => "global",
-            "X-Response-Id"         =>" zsdvasdtrq345",
-            "X-LB"                  => "dfw1-maas-prod-api0",
-            "Vary"                  => "Accept-Encoding",
-            "Transfer-Encoding"     => "chunked"
-          }
-
-          response.remote_ip = Fog::Rackspace::MockData.ipv4_address
-          response
-        end
-      end
-    end
-  end
-end

data/lib/fog/rackspace/requests/monitoring/update_alarm.rb

@@ -1,45 +0,0 @@
-module Fog
-  module Rackspace
-    class Monitoring
-      class Real
-        def update_alarm(entity_id, alarm_id, options)
-          request(
-            :body     => JSON.encode(options),
-            :expects  => [204],
-            :method   => 'PUT',
-            :path     => "entities/#{entity_id}/alarms/#{alarm_id}"
-          )
-        end
-      end
-
-      class Mock
-        def update_alarm(entity_id, alarm_id, options)
-          account_id = Fog::Mock.random_numbers(6).to_s
-
-          if entity_id == -1 || alarm_id == -1 || options[:testing]
-            raise Fog::Rackspace::Monitoring::NotFound
-          end
-
-          response = Excon::Response.new
-          response.status = 204
-          response.body = ""
-          response.headers = {
-            "Date"                  => Time.now.utc.to_s,
-            "Location"              => "https://monitoring.api.rackspacecloud.com/v1.0/" + account_id + "/entities/" + entity_id.to_s + "/alarms/" + alarm_id,
-            "X-Object-ID"           => alarm_id,
-            "X-RateLimit-Limit"     => "50000",
-            "X-RateLimit-Remaining" => "47877",
-            "X-RateLimit-Window"    => "24 hours",
-            "X-RateLimit-Type"      => "global",
-            "X-Response-Id"         => "laolsgggopsnfksdovnsv",
-            "X-LB"                  => "dfw1-maas-prod-api1",
-            "Content-Length"        => "0",
-            "Content-Type"          => "text/plain"
-          }
-          response.remote_ip = Fog::Rackspace::MockData.ipv4_address
-          response
-        end
-      end
-    end
-  end
-end

data/lib/fog/rackspace/requests/monitoring/update_check.rb

@@ -1,45 +0,0 @@
-module Fog
-  module Rackspace
-    class Monitoring
-      class Real
-        def update_check(entity_id, check_id, options)
-          request(
-            :body     => JSON.encode(options),
-            :expects  => [204],
-            :method   => 'PUT',
-            :path     => "entities/#{entity_id}/checks/#{check_id}"
-          )
-        end
-      end
-
-      class Mock
-        def update_check(entity_id, check_id, options)
-           account_id = Fog::Mock.random_numbers(6).to_s
-
-          if entity_id == -1 || check_id == -1 || options[:testing]
-            raise Fog::Rackspace::Monitoring::NotFound
-          end
-
-          response = Excon::Response.new
-          response.status = 204
-          response.body = ""
-          response.headers = {
-            "Date"                  => Time.now.utc.to_s,
-            "Location"              => "https://monitoring.api.rackspacecloud.com/v1.0/" + account_id + "/entities/" + entity_id + "/checks/" + check_id,
-            "X-Object-ID"           => check_id,
-            "X-RateLimit-Limit"     => "50000",
-            "X-RateLimit-Remaining" => "49627",
-            "X-RateLimit-Window"    => "24 hours",
-            "X-RateLimit-Type"      => "global",
-            "X-Response-Id"         => "owbgowb989wno73ubgvw89",
-            "X-LB"                  => "ord1-maas-prod-api1",
-            "Content-Length"        => "0",
-            "Content-Type"          => "text/plain",
-          }
-          response.remote_ip = Fog::Rackspace::MockData.ipv4_address
-          response
-        end
-      end
-    end
-  end
-end

data/lib/fog/rackspace/requests/monitoring/update_entity.rb

@@ -1,45 +0,0 @@
-module Fog
-  module Rackspace
-    class Monitoring
-      class Real
-        def update_entity(entity_id, options)
-          request(
-            :body     => JSON.encode(options),
-            :expects  => [204],
-            :method   => 'PUT',
-            :path     => "entities/#{entity_id}"
-          )
-        end
-      end
-
-      class Mock
-        def update_entity(entity_id, options)
-          account_id = Fog::Mock.random_numbers(6).to_s
-
-          if entity_id == -1
-           raise Fog::Rackspace::Monitoring::NotFound
-          end
-
-          response = Excon::Response.new
-          response.status = 204
-          response.body = ""
-          response.headers = {
-            "Date"                  => Time.now.utc.to_s,
-            "Location"              => "https://monitoring.api.rackspacecloud.com/v1.0/" + account_id + "/entities/" + entity_id.to_s,
-            "X-Object-ID"           => entity_id.to_s,
-            "X-RateLimit-Limit"     => "50000",
-            "X-RateLimit-Remaining" => "47877",
-            "X-RateLimit-Window"    => "24 hours",
-            "X-RateLimit-Type"      => "global",
-            "X-Response-Id"         => "lakbngf9bsgkn69gb39sobnsv",
-            "X-LB"                  => "dfw1-maas-prod-api1",
-            "Content-Length"        => "0",
-            "Content-Type"          => "text/plain"
-          }
-          response.remote_ip = Fog::Rackspace::MockData.ipv4_address
-          response
-        end
-      end
-    end
-  end
-end

data/lib/fog/rackspace/requests/monitoring/update_notification.rb

@@ -1,16 +0,0 @@
-module Fog
-  module Rackspace
-    class Monitoring
-      class Real
-        def update_notification(id, options)
-          request(
-            :body     => JSON.encode(options),
-            :expects  => [204],
-            :method   => 'PUT',
-            :path     => "notifications/#{id}"
-          )
-        end
-      end
-    end
-  end
-end

data/lib/fog/rackspace/requests/queues/create_claim.rb

@@ -1,72 +0,0 @@
-module Fog
-  module Rackspace
-    class Queues
-      class Real
-        # This operation claims a set of messages (up to the value of the limit parameter) from oldest to newest and skips any messages that are already claimed.
-        # If no unclaimed messages are available, the API returns a 204 No Content message.
-        #
-        # @param [String] queue_name Specifies the name of the queue.
-        # @param [Integer] ttl The ttl attribute specifies how long the server waits before releasing the claim. The ttl value must be between 60 and 43200 seconds (12 hours).
-        # @param [Integer] grace The grace attribute specifies the message grace period in seconds. The value of grace value must be between 60 and 43200 seconds (12 hours).
-        # @param [Hash] options
-        # @option options [Integer] :limit - Specifies the number of messages to return, up to 20 messages. If limit is not specified, limit defaults to 10.
-        # @return [Excon::Response] response
-        # @raise [Fog::Rackspace::Queues::NotFound] - HTTP 404
-        # @raise [Fog::Rackspace::Queues::BadRequest] - HTTP 400
-        # @raise [Fog::Rackspace::Queues::InternalServerError] - HTTP 500
-        # @raise [Fog::Rackspace::Queues::ServiceError]
-        # @see http://docs.rackspace.com/queues/api/v1.0/cq-devguide/content/POST_claimMessages__version__queues__queue_name__claims_claims-operations-dle001.html
-        def create_claim(queue_name, ttl, grace, options = {})
-          body = {
-            :ttl => ttl,
-            :grace => grace
-          }
-
-          query = {}
-          query[:limit] = options[:limit] if options.key? :limit
-          request(
-            :body => Fog::JSON.encode(body),
-            :expects => [200, 201, 204],
-            :method => 'POST',
-            :path => "queues/#{queue_name}/claims",
-            :query => query
-          )
-        end
-      end
-
-      class Mock
-        def create_claim(queue_name, ttl, grace, options = {})
-          queue = mock_queue!(queue_name)
-
-          limit = options[:limit] || 10
-
-          claim = queue.add_claim(ttl, grace)
-
-          claimed = queue.messages.select do |message|
-            ! message.claimed?
-          end.first(limit)
-
-          if claimed.empty?
-            response = Excon::Response.new
-            response.status = 204
-            return response
-          end
-
-          claimed.each do |message|
-            message.claim = claim
-
-            # Extend the message's lifetime to include the lifetime of the claim, plus the claim's
-            # grace period.
-            message.extend_life
-          end
-
-          response = Excon::Response.new
-          response.status = 201
-          response.body = claimed.map { |msg| msg.to_h }
-          response.headers['Location'] = "#{PATH_BASE}/#{queue_name}/claims/#{claim.id}"
-          response
-        end
-      end
-    end
-  end
-end

data/lib/fog/rackspace/requests/queues/create_message.rb

@@ -1,56 +0,0 @@
-module Fog
-  module Rackspace
-    class Queues
-      class Real
-        # This operation posts the specified message or messages.
-        # @note You can submit up to 10 messages in a single request.
-        #
-        # @param [String] client_id UUID for the client instance.
-        # @param [String] queue_name Specifies the name of the queue.
-        # @param [String, Hash, Array] body The body attribute specifies an arbitrary document that constitutes the body of the message being sent.
-        #   The size of this body is limited to 256 KB, excluding whitespace. The document must be valid JSON.
-        # @param [Integer] ttl The ttl attribute specifies how long the server waits before releasing the claim. The ttl value must be between 60 and 43200 seconds (12 hours).
-        # @return [Excon::Response] response
-        # @raise [Fog::Rackspace::Queues::NotFound] - HTTP 404
-        # @raise [Fog::Rackspace::Queues::BadRequest] - HTTP 400
-        # @raise [Fog::Rackspace::Queues::InternalServerError] - HTTP 500
-        # @raise [Fog::Rackspace::Queues::ServiceError]
-        # @see http://docs.rackspace.com/queues/api/v1.0/cq-devguide/content/POST_postMessage__version__queues__queue_name__messages_message-operations-dle001.html
-        def create_message(client_id, queue_name, body, ttl)
-          data = [{
-            :ttl => ttl,
-            :body => body
-          }]
-          request(
-            :body => Fog::JSON.encode(data),
-            :expects => 201,
-            :method => 'POST',
-            :path => "queues/#{queue_name}/messages",
-            :headers => { 'Client-ID' => client_id }
-          )
-        end
-      end
-
-      class Mock
-        def create_message(client_id, queue_name, body, ttl)
-          queue = mock_queue!(queue_name)
-
-          raise BadRequest.new if body.nil? || body.empty?
-
-          # Ensure that any Symbol keys within +body+ are converted to Strings, just as being
-          # round-tripped through the API will.
-          converted = MockData.stringify(body)
-          message = queue.add_message(client_id, converted, ttl)
-
-          response = Excon::Response.new
-          response.status = 201
-          response.body = {
-            "partial" => false,
-            "resources" => ["#{PATH_BASE}/#{queue_name}/messages/#{message.id}"]
-          }
-          response
-        end
-      end
-    end
-  end
-end

data/lib/fog/rackspace/requests/queues/create_queue.rb

@@ -1,39 +0,0 @@
-module Fog
-  module Rackspace
-    class Queues
-      class Real
-        # This operation creates a new queue.
-        # The body of the request is empty.
-        #
-        # @param [String] queue_name Specifies the name of the queue.
-        # @return [Excon::Response] response
-        # @raise [Fog::Rackspace::Queues::NotFound] - HTTP 404
-        # @raise [Fog::Rackspace::Queues::BadRequest] - HTTP 400
-        # @raise [Fog::Rackspace::Queues::InternalServerError] - HTTP 500
-        # @raise [Fog::Rackspace::Queues::ServiceError]
-        # @see http://docs.rackspace.com/queues/api/v1.0/cq-devguide/content/PUT_createQueue__version__queues__queue_name__queue-operations-dle001.html
-        def create_queue(queue_name)
-          request(
-            :body => Fog::JSON.encode({}),
-            :expects => 201,
-            :method => 'PUT',
-            :path => "queues/#{queue_name}"
-          )
-        end
-      end
-
-      class Mock
-        def create_queue(queue_name)
-          raise MethodNotAllowed.new if queue_name.nil? || queue_name.empty?
-
-          existed = ! mock_queue(queue_name).nil?
-          add_queue(queue_name) unless existed
-
-          response = Excon::Response.new
-          response.status = existed ? 201 : 204
-          response
-        end
-      end
-    end
-  end
-end

data/lib/fog/rackspace/requests/queues/delete_claim.rb

@@ -1,42 +0,0 @@
-module Fog
-  module Rackspace
-    class Queues
-      class Real
-        # This operation immediately releases a claim, making any remaining, undeleted) messages that are associated with the claim available to other workers.
-        # Claims with malformed IDs or claims that are not found by ID are ignored.
-        #
-        # @param [String] queue_name Specifies the name of the queue.
-        # @param [String] claim_id Specifies the claim ID.
-        # @return [Excon::Response] response
-        # @raise [Fog::Rackspace::Queues::NotFound] - HTTP 404
-        # @raise [Fog::Rackspace::Queues::BadRequest] - HTTP 400
-        # @raise [Fog::Rackspace::Queues::InternalServerError] - HTTP 500
-        # @raise [Fog::Rackspace::Queues::ServiceError]
-        # @see http://docs.rackspace.com/queues/api/v1.0/cq-devguide/content/DELETE_deleteClaim__version__queues__queue_name__claims__claimId__claims-operations-dle001.html
-        def delete_claim(queue_name, claim_id)
-          request(
-            :expects => 204,
-            :method => 'DELETE',
-            :path => "queues/#{queue_name}/claims/#{claim_id}"
-          )
-        end
-      end
-
-      class Mock
-        def delete_claim(queue_name, claim_id)
-          queue = mock_queue!(queue_name)
-          claim = queue.claim!(claim_id)
-
-          claim.messages.each do |message|
-            message.claim = nil
-          end
-          queue.claims.delete(claim_id)
-
-          response = Excon::Response.new
-          response.status = 204
-          response
-        end
-      end
-    end
-  end
-end

data/lib/fog/rackspace/requests/queues/delete_message.rb

@@ -1,62 +0,0 @@
-module Fog
-  module Rackspace
-    class Queues
-      class Real
-        # This operation immediately deletes the specified message.
-        # @note If you do not specify claim_id, but the message is claimed, the operation fails. You can only delete claimed messages by providing an appropriate claim_id.
-        #
-        # @param [String] queue_name Specifies the name of the queue.
-        # @param [String] message_id Specifies the message ID.
-        # @param [Hash] options
-        # @option options [Integer] :claim_id - Identifies the claim.
-        # @return [Excon::Response] response
-        # @raise [Fog::Rackspace::Queues::NotFound] - HTTP 404
-        # @raise [Fog::Rackspace::Queues::BadRequest] - HTTP 400
-        # @raise [Fog::Rackspace::Queues::InternalServerError] - HTTP 500
-        # @raise [Fog::Rackspace::Queues::ServiceError]
-        # @see http://docs.rackspace.com/queues/api/v1.0/cq-devguide/content/DELETE_deleteMessage__version__queues__queue_name__messages__messageId__message-operations-dle001.html
-        def delete_message(queue_name, message_id, options = {})
-          query = {}
-          query[:claim_id] = options[:claim_id] if options.key? :claim_id
-          request(
-            :expects => 204,
-            :method => 'DELETE',
-            :path => "queues/#{queue_name}/messages/#{message_id}",
-            :query => query
-          )
-        end
-      end
-
-      class Mock
-        def delete_message(queue_name, message_id, options = {})
-          queue = mock_queue!(queue_name)
-
-          claim_id = options[:claim_id]
-
-          message = queue.messages.find { |m| m.id == message_id }
-
-          perform_delete = true
-          if message && message.claimed?
-            unless message.claim.id == claim_id
-              # Currently returns a 204 without deleting!
-              perform_delete = false
-            end
-          else
-            if claim_id
-              # Currently returns a 204 without deleting!
-              perform_delete = false
-            end
-          end
-
-          if perform_delete
-            queue.messages.reject! { |m| m.id == message_id }
-          end
-
-          response = Excon::Response.new
-          response.status = 204
-          response
-        end
-      end
-    end
-  end
-end

data/lib/fog/rackspace/requests/queues/delete_queue.rb

@@ -1,33 +0,0 @@
-module Fog
-  module Rackspace
-    class Queues
-      class Real
-        # This operation immediately deletes a queue and all of its existing messages.
-        #
-        # @param [String] queue_name Specifies the name of the queue.
-        # @return [Excon::Response] response
-        # @raise [Fog::Rackspace::Queues::NotFound] - HTTP 404
-        # @raise [Fog::Rackspace::Queues::BadRequest] - HTTP 400
-        # @raise [Fog::Rackspace::Queues::InternalServerError] - HTTP 500
-        # @raise [Fog::Rackspace::Queues::ServiceError]
-        # @see http://docs.rackspace.com/queues/api/v1.0/cq-devguide/content/DELETE_deleteQueue__version__queues__queue_name__queue-operations-dle001.html
-        def delete_queue(queue_name)
-          request(
-            :expects => 204,
-            :method => 'DELETE',
-            :path => "queues/#{queue_name}"
-          )
-        end
-      end
-
-      class Mock
-        def delete_queue(queue_name)
-          data.delete(queue_name)
-          response = Excon::Response.new
-          response.status = 204
-          response
-        end
-      end
-    end
-  end
-end

data/lib/fog/rackspace/requests/queues/get_claim.rb

@@ -1,37 +0,0 @@
-module Fog
-  module Rackspace
-    class Queues
-      class Real
-        # This operation queries the specified claim for the specified queue. Claims with malformed IDs or claims that are not found by ID are ignored.
-        #
-        # @param [String] queue_name Specifies the name of the queue.
-        # @param [Integer] claim_id Specifies the claim ID.
-        # @return [Excon::Response] response
-        # @raise [Fog::Rackspace::Queues::NotFound] - HTTP 404
-        # @raise [Fog::Rackspace::Queues::BadRequest] - HTTP 400
-        # @raise [Fog::Rackspace::Queues::InternalServerError] - HTTP 500
-        # @raise [Fog::Rackspace::Queues::ServiceError]
-        # @see http://docs.rackspace.com/queues/api/v1.0/cq-devguide/content/GET_queryClaim__version__queues__queue_name__claims__claimId__claims-operations-dle001.html
-        def get_claim(queue_name, claim_id)
-          request(
-            :expects => 200,
-            :method => 'GET',
-            :path => "queues/#{queue_name}/claims/#{claim_id}"
-          )
-        end
-      end
-
-      class Mock
-        def get_claim(queue_name, claim_id)
-          queue = mock_queue!(queue_name)
-          claim = queue.claim!(claim_id)
-
-          response = Excon::Response.new
-          response.status = 200
-          response.body = claim.to_h
-          response
-        end
-      end
-    end
-  end
-end