Class: Fog::Rackspace::Queues::Real

Inherits:
Service
  • Object
show all
Defined in:
lib/fog/rackspace/queues.rb,
lib/fog/rackspace/requests/queues/get_claim.rb,
lib/fog/rackspace/requests/queues/get_queue.rb,
lib/fog/rackspace/requests/queues/get_message.rb,
lib/fog/rackspace/requests/queues/list_queues.rb,
lib/fog/rackspace/requests/queues/create_claim.rb,
lib/fog/rackspace/requests/queues/create_queue.rb,
lib/fog/rackspace/requests/queues/delete_claim.rb,
lib/fog/rackspace/requests/queues/delete_queue.rb,
lib/fog/rackspace/requests/queues/update_claim.rb,
lib/fog/rackspace/requests/queues/list_messages.rb,
lib/fog/rackspace/requests/queues/create_message.rb,
lib/fog/rackspace/requests/queues/delete_message.rb,
lib/fog/rackspace/requests/queues/get_queue_stats.rb

Instance Method Summary collapse

Methods inherited from Service

#request_without_retry

Constructor Details

#initialize(options = {}) ⇒ Real

Returns a new instance of Real.



61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
 
# File 'lib/fog/rackspace/queues.rb', line 61

def initialize(options = {})
  @rackspace_api_key = options[:rackspace_api_key]
  @rackspace_username = options[:rackspace_username]
  @rackspace_queues_client_id = options[:rackspace_queues_client_id] || Fog::UUID.uuid
  @rackspace_auth_url = options[:rackspace_auth_url]
  @rackspace_must_reauthenticate = false
  @connection_options = options[:connection_options] || {}
  @rackspace_region = options[:rackspace_region] || :ord

  unless v2_authentication?
    raise Fog::Errors::NotImplemented.new("V2 authentication required for Queues")
  end

  authenticate

  @persistent = options[:persistent] || false
  @connection = Fog::Connection.new(endpoint_uri.to_s, @persistent, @connection_options)
end

Instance Method Details

#authenticate(options = {}) ⇒ Object 



98
99
100
101
102
103
104
105
 
# File 'lib/fog/rackspace/queues.rb', line 98

def authenticate(options={})
  super({
    :rackspace_api_key  => @rackspace_api_key,
    :rackspace_username => @rackspace_username,
    :rackspace_auth_url => @rackspace_auth_url,
    :connection_options => @connection_options
  })
end

#client_id ⇒ Object 



107
108
109
 
# File 'lib/fog/rackspace/queues.rb', line 107

def client_id
  @rackspace_queues_client_id
end

#client_id=(client_id) ⇒ Object 



111
112
113
 
# File 'lib/fog/rackspace/queues.rb', line 111

def client_id=(client_id)
  @rackspace_queues_client_id = client_id
end

#create_claim(queue_name, ttl, grace, options = {}) ⇒ Object 



5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
# File 'lib/fog/rackspace/requests/queues/create_claim.rb', line 5

def create_claim(queue_name, ttl, grace, options = {})
  body = {
    :ttl => ttl,
    :grace => grace
  }

  query = {}
  query[:limit] = options[:limit] if options.has_key? :limit
  request(
    :body => Fog::JSON.encode(body),
    :expects => [200, 201, 204],
    :method => 'POST',
    :path => "queues/#{queue_name}/claims",
    :query => query
  )
end

#create_message(client_id, queue_name, body, ttl) ⇒ Object 



5
6
7
8
9
10
11
12
13
14
15
16
17
 
# File 'lib/fog/rackspace/requests/queues/create_message.rb', line 5

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

#create_queue(queue_name) ⇒ Object 



5
6
7
8
9
10
11
12
 
# File 'lib/fog/rackspace/requests/queues/create_queue.rb', line 5

def create_queue(queue_name)
  request(
    :body => Fog::JSON.encode({}),
    :expects => 201,
    :method => 'PUT',
    :path => "queues/#{queue_name}"
  )
end

#delete_claim(queue_name, claim_id) ⇒ Object 



5
6
7
8
9
10
11
 
# File 'lib/fog/rackspace/requests/queues/delete_claim.rb', line 5

def delete_claim(queue_name, claim_id)
  request(
    :expects => 204,
    :method => 'DELETE',
    :path => "queues/#{queue_name}/claims/#{claim_id}"
  )
end

#delete_message(queue_name, message_id, options = {}) ⇒ Object 



5
6
7
8
9
10
11
12
13
14
 
# File 'lib/fog/rackspace/requests/queues/delete_message.rb', line 5

def delete_message(queue_name, message_id, options = {})
  query = {}
  query[:claim_id] = options[:claim_id] if options.has_key? :claim_id
  request(
    :expects => 204,
    :method => 'DELETE',
    :path => "queues/#{queue_name}/messages/#{message_id}",
    :query => query
  )
end

#delete_queue(queue_name) ⇒ Object 



5
6
7
8
9
10
11
 
# File 'lib/fog/rackspace/requests/queues/delete_queue.rb', line 5

def delete_queue(queue_name)
  request(
    :expects => 204,
    :method => 'DELETE',
    :path => "queues/#{queue_name}"
  )
end

#endpoint_uri(service_endpoint_url = nil) ⇒ Object 



94
95
96
 
# File 'lib/fog/rackspace/queues.rb', line 94

def endpoint_uri(service_endpoint_url=nil)
  @uri = super(@rackspace_endpoint || service_endpoint_url, :rackspace_queues_url)
end

#get_claim(queue_name, claim_id) ⇒ Object 



5
6
7
8
9
10
11
 
# File 'lib/fog/rackspace/requests/queues/get_claim.rb', line 5

def get_claim(queue_name, claim_id)
  request(
    :expects => 200,
    :method => 'GET',
    :path => "queues/#{queue_name}/claims/#{claim_id}"
  )
end

#get_message(client_id, queue_name, message_id) ⇒ Object 



5
6
7
8
9
10
11
12
 
# File 'lib/fog/rackspace/requests/queues/get_message.rb', line 5

def get_message(client_id, queue_name, message_id)
  request(
    :expects => 200,
    :method => 'GET',
    :path => "queues/#{queue_name}/messages/#{message_id}",
    :headers => { 'Client-ID' => client_id }
  )
end

#get_queue(queue_name) ⇒ Object 



5
6
7
8
9
10
11
 
# File 'lib/fog/rackspace/requests/queues/get_queue.rb', line 5

def get_queue(queue_name)
  request(
    :expects => [200, 204],
    :method => 'GET',
    :path => "queues/#{queue_name}"
  )
end

#get_queue_stats(queue_name) ⇒ Object 



5
6
7
8
9
10
11
 
# File 'lib/fog/rackspace/requests/queues/get_queue_stats.rb', line 5

def get_queue_stats(queue_name)
  request(
    :expects => 200,
    :method => 'GET',
    :path => "queues/#{queue_name}/stats"
  )
end

#list_messages(client_id, queue_name, options = {}) ⇒ Object 



5
6
7
8
9
10
11
12
13
 
# File 'lib/fog/rackspace/requests/queues/list_messages.rb', line 5

def list_messages(client_id, queue_name, options = {})
  request(
    :expects => [200, 204],
    :method => 'GET',
    :path => "queues/#{queue_name}/messages",
    :headers => { 'Client-ID' => client_id },
    :query => options
  )
end

#list_queues ⇒ Object 



5
6
7
8
9
10
11
 
# File 'lib/fog/rackspace/requests/queues/list_queues.rb', line 5

def list_queues
  request(
    :expects => [200, 204],
    :method => 'GET',
    :path => 'queues'
  )
end

#region ⇒ Object 



57
58
59
 
# File 'lib/fog/rackspace/queues.rb', line 57

def region
  @rackspace_region
end

#request(params, parse_json = true, &block) ⇒ Object 



80
81
82
83
84
85
86
87
88
89
90
91
92
 
# File 'lib/fog/rackspace/queues.rb', line 80

def request(params, parse_json = true, &block)
  super(params, parse_json, &block)
rescue Excon::Errors::NotFound => error
  raise NotFound.slurp(error, self)
rescue Excon::Errors::BadRequest => error
  raise BadRequest.slurp(error, self)
rescue Excon::Errors::InternalServerError => error
  raise InternalServerError.slurp(error, self)
rescue Excon::Errors::MethodNotAllowed => error
  raise MethodNotAllowed.slurp(error, self)
rescue Excon::Errors::HTTPStatusError => error
  raise ServiceError.slurp(error, self)
end

#service_name ⇒ Object 



53
54
55
 
# File 'lib/fog/rackspace/queues.rb', line 53

def service_name
  :cloudQueues
end

#update_claim(queue_name, claim_id, ttl) ⇒ Object 



5
6
7
8
9
10
11
12
13
14
15
 
# File 'lib/fog/rackspace/requests/queues/update_claim.rb', line 5

def update_claim(queue_name, claim_id, ttl)
  body = {
    :ttl => ttl
  }
  request(
    :body => Fog::JSON.encode(body),
    :expects => 204,
    :method => 'PATCH',
    :path => "queues/#{queue_name}/claims/#{claim_id}"
  )
end