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/delete_key.rb,
lib/fog/joyent/requests/compute/create_key.rb,
lib/fog/joyent/requests/compute/list_images.rb,
lib/fog/joyent/requests/compute/get_machine.rb,
lib/fog/joyent/requests/compute/get_dataset.rb,
lib/fog/joyent/requests/compute/get_package.rb,
lib/fog/joyent/requests/compute/stop_machine.rb,
lib/fog/joyent/requests/compute/list_networks.rb,
lib/fog/joyent/requests/compute/start_machine.rb,
lib/fog/joyent/requests/compute/list_machines.rb,
lib/fog/joyent/requests/compute/list_datasets.rb,
lib/fog/joyent/requests/compute/list_packages.rb,
lib/fog/joyent/requests/compute/delete_machine.rb,
lib/fog/joyent/requests/compute/resize_machine.rb,
lib/fog/joyent/requests/compute/create_machine.rb,
lib/fog/joyent/requests/compute/reboot_machine.rb,
lib/fog/joyent/requests/compute/get_machine_tag.rb,
lib/fog/joyent/requests/compute/list_datacenters.rb,
lib/fog/joyent/requests/compute/add_machine_tags.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_snapshot.rb,
lib/fog/joyent/requests/compute/get_machine_metadata.rb,
lib/fog/joyent/requests/compute/list_machine_snapshots.rb,
lib/fog/joyent/requests/compute/delete_machine_metadata.rb,
lib/fog/joyent/requests/compute/delete_machine_snapshot.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/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_urlObject

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_versionObject

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

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


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

def (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


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

def (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_datasetObject


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 (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


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_datacentersObject


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_datasetsObject


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_imagesObject


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_keysObject


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


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_packagesObject

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 (machine_id, )
  request(
    :method => "POST",
    :path => "/my/machines/#{machine_id}/metadata",
    :body => 
  )
end