Class: Fog::Compute::Joyent::Real

Inherits:
Object
  • Object
show all
Defined in:
lib/fog/joyent/compute.rb,
lib/fog/joyent/requests/compute/get_key.rb,
lib/fog/joyent/requests/compute/get_image.rb,
lib/fog/joyent/requests/compute/list_keys.rb,
lib/fog/joyent/requests/compute/create_key.rb,
lib/fog/joyent/requests/compute/delete_key.rb,
lib/fog/joyent/requests/compute/get_dataset.rb,
lib/fog/joyent/requests/compute/get_machine.rb,
lib/fog/joyent/requests/compute/get_package.rb,
lib/fog/joyent/requests/compute/list_images.rb,
lib/fog/joyent/requests/compute/stop_machine.rb,
lib/fog/joyent/requests/compute/list_datasets.rb,
lib/fog/joyent/requests/compute/list_machines.rb,
lib/fog/joyent/requests/compute/list_networks.rb,
lib/fog/joyent/requests/compute/list_packages.rb,
lib/fog/joyent/requests/compute/start_machine.rb,
lib/fog/joyent/requests/compute/create_machine.rb,
lib/fog/joyent/requests/compute/delete_machine.rb,
lib/fog/joyent/requests/compute/reboot_machine.rb,
lib/fog/joyent/requests/compute/resize_machine.rb,
lib/fog/joyent/requests/compute/get_machine_tag.rb,
lib/fog/joyent/requests/compute/add_machine_tags.rb,
lib/fog/joyent/requests/compute/list_datacenters.rb,
lib/fog/joyent/requests/compute/list_machine_tags.rb,
lib/fog/joyent/requests/compute/delete_machine_tag.rb,
lib/fog/joyent/requests/compute/get_machine_metadata.rb,
lib/fog/joyent/requests/compute/get_machine_snapshot.rb,
lib/fog/joyent/requests/compute/list_machine_snapshots.rb,
lib/fog/joyent/requests/compute/create_machine_snapshot.rb,
lib/fog/joyent/requests/compute/delete_all_machine_tags.rb,
lib/fog/joyent/requests/compute/delete_machine_metadata.rb,
lib/fog/joyent/requests/compute/delete_machine_snapshot.rb,
lib/fog/joyent/requests/compute/update_machine_metadata.rb,
lib/fog/joyent/requests/compute/delete_all_machine_metadata.rb,
lib/fog/joyent/requests/compute/start_machine_from_snapshot.rb

Overview

Mock

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(options = {}) ⇒ Real

Returns a new instance of Real.



116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
 
# File 'lib/fog/joyent/compute.rb', line 116

def initialize(options = {})
  @connection_options = options[:connection_options] || {}
  @persistent = options[:persistent] || false

  @joyent_url = options[:joyent_url] || 'https://us-sw-1.api.joyentcloud.com'
  @joyent_version = options[:joyent_version] || '~6.5'
  @joyent_username = options[:joyent_username]

  unless @joyent_username
    raise ArgumentError, "options[:joyent_username] required"
  end

  if options[:joyent_keyname]
    @joyent_keyname = options[:joyent_keyname]
    @joyent_keyphrase = options[:joyent_keyphrase]
    @key_manager = Net::SSH::Authentication::KeyManager.new(nil, {
        :keys_only => true,
        :passphrase => @joyent_keyphrase
    })
    @header_method = method(:header_for_signature_auth)

    if options[:joyent_keyfile]
      if File.exist?(options[:joyent_keyfile])
        @joyent_keyfile = options[:joyent_keyfile]
        @key_manager.add(@joyent_keyfile)
      else
        raise ArgumentError, "options[:joyent_keyfile] provided does not exist."
      end
    elsif options[:joyent_keydata]
      if options[:joyent_keydata].to_s.empty?
        raise ArgumentError, 'options[:joyent_keydata] must not be blank'
      else
        @joyent_keydata = options[:joyent_keydata]
        @key_manager.add_key_data(@joyent_keydata)
      end
    end
  elsif options[:joyent_password]
    @joyent_password = options[:joyent_password]
    @header_method = method(:header_for_basic_auth)
  else
    raise ArgumentError, "Must provide either a joyent_password or joyent_keyname and joyent_keyfile pair"
  end

  @connection = Fog::XML::Connection.new(
    @joyent_url,
    @persistent,
    @connection_options
  )
end

Instance Attribute Details

#joyent_url ⇒ Object

Returns the value of attribute joyent_url.



114
115
116
 
# File 'lib/fog/joyent/compute.rb', line 114

def joyent_url
  @joyent_url
end

#joyent_version ⇒ Object

Returns the value of attribute joyent_version.



113
114
115
 
# File 'lib/fog/joyent/compute.rb', line 113

def joyent_version
  @joyent_version
end

Instance Method Details

#add_machine_tags(machine_id, tags = {}) ⇒ Object

us-west-1.api.joyentcloud.com/docs#AddMachineTags

Raises:

  • (ArgumentError) 


6
7
8
9
10
11
12
13
14
15
 
# File 'lib/fog/joyent/requests/compute/add_machine_tags.rb', line 6

def add_machine_tags(machine_id, tags={})
  raise ArgumentError, "tags must be a Hash of tags" unless tags.is_a?(Hash)

  request(
    :path => "/my/machines/#{machine_id}/tags",
    :method => "POST",
    :body => tags,
    :expects => 200
  )
end

#create_key(params = {}) ⇒ Object

Creates a new SSH Key

Parameters

  • name<~String> - Name to assign to this key

  • key<~String> - OpenSSH formatted public key

Returns

  • response<~Excon::Response>:

    • body<~Hash>:

      • ‘name’<~String> - Name for this key

      • ‘key’<~String> - OpenSSH formatted public key

Raises:

  • (ArgumentError) 


40
41
42
43
44
45
46
47
48
49
50
 
# File 'lib/fog/joyent/requests/compute/create_key.rb', line 40

def create_key(params={})
  raise ArgumentError, "error creating key: [name] is required" unless params[:name]
  raise ArgumentError, "error creating key: [key] is required" unless params[:key]

  request(
    :method => "POST",
    :path => "/my/keys",
    :body => { "name" => params[:name], "key" => params[:key] },
    :expects => 201
  )
end

#create_machine(params = {}) ⇒ Object 



5
6
7
8
9
10
11
12
 
# File 'lib/fog/joyent/requests/compute/create_machine.rb', line 5

def create_machine(params = {})
  request(
    :method => "POST",
    :path => "/my/machines",
    :body => params,
    :expects => [200, 201, 202]
  )
end

#create_machine_snapshot(machine_id, snapshot_name) ⇒ Object 



5
6
7
8
9
10
11
12
 
# File 'lib/fog/joyent/requests/compute/create_machine_snapshot.rb', line 5

def create_machine_snapshot(machine_id, snapshot_name)
  request(
    :method => "POST",
    :path => "/my/machines/#{machine_id}/snapshots",
    :body => {"name" => snapshot_name },
    :expects => [201]
  )
end

#delete_all_machine_metadata(machine_id) ⇒ Object

us-west-1.api.joyentcloud.com/docs#DeleteMachineMetadata



6
7
8
9
10
11
12
 
# File 'lib/fog/joyent/requests/compute/delete_all_machine_metadata.rb', line 6

def delete_all_machine_metadata(machine_id)
  request(
    :method => "DELETE",
    :path => "/my/machines/#{machine_id}/metadata",
    :expects => 204
  )
end

#delete_all_machine_tags(machine_id) ⇒ Object 



5
6
7
8
9
10
11
 
# File 'lib/fog/joyent/requests/compute/delete_all_machine_tags.rb', line 5

def delete_all_machine_tags(machine_id)
  request(
    :path => "/my/machines/#{machine_id}/tags",
    :method => "DELETE",
    :expects => 204
  )
end

#delete_key(name) ⇒ Object 



17
18
19
20
21
22
23
 
# File 'lib/fog/joyent/requests/compute/delete_key.rb', line 17

def delete_key(name)
  request(
    :method => "DELETE",
    :path => "/my/keys/#{name}",
    :expects => 204
  )
end

#delete_machine(machine_id) ⇒ Object 



5
6
7
8
9
10
11
 
# File 'lib/fog/joyent/requests/compute/delete_machine.rb', line 5

def delete_machine(machine_id)
  request(
    :path => "/my/machines/#{machine_id}",
    :method => "DELETE",
    :expects => [200, 204, 410]
  )
end

#delete_machine_metadata(machine_id, key) ⇒ Object

us-west-1.api.joyentcloud.com/docs#DeleteAllMachineMetadata



6
7
8
9
10
11
12
 
# File 'lib/fog/joyent/requests/compute/delete_machine_metadata.rb', line 6

def delete_machine_metadata(machine_id, key)
  request(
    :method => "DELETE",
    :path => "/my/machines/#{machine_id}/metadata/#{key}",
    :expects => [200, 204]
  )
end

#delete_machine_snapshot(machine_id, snapshot) ⇒ Object 



5
6
7
8
9
10
11
 
# File 'lib/fog/joyent/requests/compute/delete_machine_snapshot.rb', line 5

def delete_machine_snapshot(machine_id, snapshot)
  request(
    :method => "DELETE",
    :path => "/my/machines/#{machine_id}/snapshots/#{snapshot}",
    :expects => [200, 204]
  )
end

#delete_machine_tag(machine_id, tagname) ⇒ Object 



5
6
7
8
9
10
11
 
# File 'lib/fog/joyent/requests/compute/delete_machine_tag.rb', line 5

def delete_machine_tag(machine_id, tagname)
  request(
    :path => "/my/machines/#{machine_id}/tags/#{tagname}",
    :method => "DELETE",
    :expects => 204
  )
end

#get_dataset ⇒ Object 



17
18
19
20
21
22
23
 
# File 'lib/fog/joyent/requests/compute/get_dataset.rb', line 17

def get_dataset
  request(
    :method => "GET",
    :path => "/my/datasets",
    :idempotent => true
  )
end

#get_image(id) ⇒ Object 



17
18
19
20
21
22
23
24
 
# File 'lib/fog/joyent/requests/compute/get_image.rb', line 17

def get_image(id)
  request(
      :method => "GET",
      :path => "/#{@joyent_username}/images/#{id}",
      :expects => 200,
      :idempotent => true
  )
end

#get_key(keyid) ⇒ Object 



18
19
20
21
22
23
24
25
 
# File 'lib/fog/joyent/requests/compute/get_key.rb', line 18

def get_key(keyid)
  request(
    :method => "GET",
    :path => "/my/keys/#{keyid}",
    :expects => 200,
    :idempotent => true
  )
end

#get_machine(uuid) ⇒ Object 



18
19
20
21
22
23
24
25
 
# File 'lib/fog/joyent/requests/compute/get_machine.rb', line 18

def get_machine(uuid)
  request(
    :method => "GET",
    :path => "/my/machines/#{uuid}",
    :expects => [200, 410],
    :idempotent => true
  )
end

#get_machine_metadata(machine_id, options = {}) ⇒ Object 



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

def get_machine_metadata(machine_id, options = {})
  query = {}
  if options[:credentials]
    if options[:credentials].is_a?(Boolean)
      query[:credentials] = options[:credentials]
    else
      raise ArgumentError, "options[:credentials] must be a Boolean or nil"
    end
  end

  request(
    :path => "/my/machines/#{machine_id}/metadata",
    :query => query,
    :idempotent => true
  )
end

#get_machine_snapshot(machine_id, snapshot_name) ⇒ Object 



5
6
7
8
9
10
11
 
# File 'lib/fog/joyent/requests/compute/get_machine_snapshot.rb', line 5

def get_machine_snapshot(machine_id, snapshot_name)
  request(
    :path => "/my/machines/#{machine_id}/snapshots/#{snapshot_name}",
    :method => "GET",
    :idempotent => true
  )
end

#get_machine_tag(machine_id, tagname) ⇒ Object

us-west-1.api.joyentcloud.com/docs#GetMachineTag



6
7
8
9
10
11
12
13
14
 
# File 'lib/fog/joyent/requests/compute/get_machine_tag.rb', line 6

def get_machine_tag(machine_id, tagname)
  request(
    :path => "/my/machines/#{machine_id}/tags/#{tagname}",
    :method => "GET",
    :headers => {"Accept" => "text/plain"},
    :expects => 200,
    :idempotent => true
  )
end

#get_package(name) ⇒ Object 



20
21
22
23
24
25
26
27
28
 
# File 'lib/fog/joyent/requests/compute/get_package.rb', line 20

def get_package(name)
  name = URI.escape(name)
  request(
    :method => "GET",
    :path => "/my/packages/#{name}",
    :expects => 200,
    :idempotent => true
  )
end

#list_datacenters ⇒ Object 



5
6
7
8
9
10
11
12
 
# File 'lib/fog/joyent/requests/compute/list_datacenters.rb', line 5

def list_datacenters
  request(
    :expects => 200,
    :method => :'GET',
    :path => '/my/datacenters',
    :idempotent => true
  )
end

#list_datasets ⇒ Object 



14
15
16
17
18
19
20
 
# File 'lib/fog/joyent/requests/compute/list_datasets.rb', line 14

def list_datasets
  request(
    :method => "GET",
    :path => "/my/datasets",
    :idempotent => true
  )
end

#list_images ⇒ Object 



14
15
16
17
18
19
20
21
 
# File 'lib/fog/joyent/requests/compute/list_images.rb', line 14

def list_images
  request(
      :method => "GET",
      :path => "/#{@joyent_username}/images",
      :expects => 200,
      :idempotent => true
  )
end

#list_keys ⇒ Object 



14
15
16
17
18
19
20
21
 
# File 'lib/fog/joyent/requests/compute/list_keys.rb', line 14

def list_keys
  request(
    :expects => 200,
    :method => :'GET',
    :path => '/my/keys',
    :idempotent => true
  )
end

#list_machine_snapshots(machine_id) ⇒ Object 



5
6
7
8
9
10
11
 
# File 'lib/fog/joyent/requests/compute/list_machine_snapshots.rb', line 5

def list_machine_snapshots(machine_id)
  request(
    :method => "GET",
    :path => "/my/machines/#{machine_id}/snapshots",
    :idempotent => true
  )
end

#list_machine_tags(machine_id) ⇒ Object

us-west-1.api.joyentcloud.com/docs#ListMachineTags



6
7
8
9
10
11
12
13
 
# File 'lib/fog/joyent/requests/compute/list_machine_tags.rb', line 6

def list_machine_tags(machine_id)
  request(
    :path => "/my/machines/#{machine_id}/tags",
    :method => "GET",
    :expects => 200,
    :idempotent => true
  )
end

#list_machines(options = {}) ⇒ Object 



14
15
16
17
18
19
20
21
22
 
# File 'lib/fog/joyent/requests/compute/list_machines.rb', line 14

def list_machines(options={})
  request(
    :path => "/my/machines",
    :method => "GET",
    :query => options,
    :expects => 200,
    :idempotent => true
  )
end

#list_networks(options = {}) ⇒ Object 



14
15
16
17
18
19
20
21
22
 
# File 'lib/fog/joyent/requests/compute/list_networks.rb', line 14

def list_networks(options={})
  request(
    :path => "/my/networks",
    :method => "GET",
    :query => options,
    :expects => 200,
    :idempotent => true
  )
end

#list_packages ⇒ Object

Lists all the packages available to the authenticated user

Returns

Exon::Response<Array>

  • name<~String> The “friendly name for this package

  • memory<~Number> How much memory will by available (in Mb)

  • disk<~Number> How much disk space will be available (in Gb)

  • swap<~Number> How much swap memory will be available (in Mb)

  • default<~Boolean> Whether this is the default package in this datacenter“



23
24
25
26
27
28
29
30
 
# File 'lib/fog/joyent/requests/compute/list_packages.rb', line 23

def list_packages
  request(
    :path => "/my/packages",
    :method => "GET",
    :expects => 200,
    :idempotent => true
  )
end

#reboot_machine(id) ⇒ Object 



5
6
7
8
9
10
11
 
# File 'lib/fog/joyent/requests/compute/reboot_machine.rb', line 5

def reboot_machine(id)
  request(
    :method => "POST",
    :query => {"action" => "reboot"},
    :path => "/my/machines/#{id}"
  )
end

#request(opts = {}) ⇒ Object 



166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
 
# File 'lib/fog/joyent/compute.rb', line 166

def request(opts = {})
  opts[:headers] = {
    "X-Api-Version" => @joyent_version,
    "Content-Type" => "application/json",
    "Accept" => "application/json"
  }.merge(opts[:headers] || {}).merge(@header_method.call)

  if opts[:body]
    opts[:body] = Fog::JSON.encode(opts[:body])
  end

  response = @connection.request(opts)
  if response.headers["Content-Type"] == "application/json"
    response.body = json_decode(response.body)
  end

  response
rescue Excon::Errors::HTTPStatusError => e
  if e.response.headers["Content-Type"] == "application/json"
    e.response.body = json_decode(e.response.body)
  end
  raise_if_error!(e.request, e.response)
end

#resize_machine(id, package) ⇒ Object 



5
6
7
8
9
10
11
12
 
# File 'lib/fog/joyent/requests/compute/resize_machine.rb', line 5

def resize_machine(id, package)
  request(
    :method => "POST",
    :path => "/my/machines/#{id}",
    :query => {"action" => "resize", "package" => package},
    :expects => [202]
  )
end

#start_machine(id) ⇒ Object 



5
6
7
8
9
10
11
12
 
# File 'lib/fog/joyent/requests/compute/start_machine.rb', line 5

def start_machine(id)
  request(
    :method => "POST",
    :path => "/my/machines/#{id}",
    :query => {"action" => "start"},
    :expects => 202
  )
end

#start_machine_from_snapshot(machine_id, snapshot_name) ⇒ Object 



5
6
7
8
9
10
11
 
# File 'lib/fog/joyent/requests/compute/start_machine_from_snapshot.rb', line 5

def start_machine_from_snapshot(machine_id, snapshot_name)
  request(
    :method => "POST",
    :path => "/my/machines/#{machine_id}/snapshots/#{snapshot_name}",
    :expects => 202
  )
end

#stop_machine(uuid) ⇒ Object 



5
6
7
8
9
10
11
12
 
# File 'lib/fog/joyent/requests/compute/stop_machine.rb', line 5

def stop_machine(uuid)
  request(
    :method => "POST",
    :path => "/my/machines/#{uuid}",
    :query => {"action" => "stop"},
    :expects => 202
  )
end

#update_machine_metadata(machine_id, metadata) ⇒ Object 



5
6
7
8
9
10
11
 
# File 'lib/fog/joyent/requests/compute/update_machine_metadata.rb', line 5

def update_machine_metadata(machine_id, metadata)
  request(
    :method => "POST",
    :path => "/my/machines/#{machine_id}/metadata",
    :body => metadata
  )
end