In Files

Parent

Class/Module Index [+]

Quicksearch

Fog::Compute::Joyent::Real

Public Class Methods

new(options = {}) click to toggle source
# File lib/fog/joyent/compute.rb, line 98
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] && options[:joyent_keyfile]
    if File.exists?(options[:joyent_keyfile])
      @joyent_keyname = options[:joyent_keyname]
      @joyent_key = File.read(options[:joyent_keyfile])

      if @joyent_key.lines.first.include?('-----BEGIN DSA PRIVATE KEY-----')
        @key = OpenSSL::PKey::DSA.new(@joyent_key)
      elsif @joyent_key.lines.first.include?('-----BEGIN RSA PRIVATE KEY-----')
        @key = OpenSSL::PKey::RSA.new(@joyent_key)
      else
        raise ArgumentError, "options[joyent_keyfile] provided must be an RSA or DSA private key"
      end


      @header_method = method(:header_for_signature_auth)
    else
      raise ArgumentError, "options[:joyent_keyfile] provided does not exist."
    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::Connection.new(
    @joyent_url,
    @persistent,
    @connection_options
  )
end

Public Instance Methods

add_machine_tags(machine_id, tags={}) click to toggle source

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

# File lib/fog/joyent/requests/compute/add_machine_tags.rb, line 7
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={}) click to toggle source

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

# File lib/fog/joyent/requests/compute/create_key.rb, line 41
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 = {}) click to toggle source
# 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) click to toggle source
# File lib/fog/joyent/requests/compute/create_machine_snapshot.rb, line 6
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) click to toggle source

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

# 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) click to toggle source
# 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) click to toggle source
# File lib/fog/joyent/requests/compute/delete_key.rb, line 18
def delete_key(name)
  request(
    :method => "DELETE",
    :path => "/my/keys/#{name}",
    :expects => 204
  )
end
delete_machine(machine_id) click to toggle source
# 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]
  )
end
delete_machine_metadata(machine_id, key) click to toggle source

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

# File lib/fog/joyent/requests/compute/delete_machine_metadata.rb, line 8
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) click to toggle source
# File lib/fog/joyent/requests/compute/delete_machine_snapshot.rb, line 6
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) click to toggle source
# 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() click to toggle source
# File lib/fog/joyent/requests/compute/get_dataset.rb, line 18
def get_dataset
  request(
    :method => "GET",
    :path => "/my/datasets"
  )
end
get_key(keyid) click to toggle source
# File lib/fog/joyent/requests/compute/get_key.rb, line 19
def get_key(keyid)
  request(
    :method => "GET",
    :path => "/my/keys/#{keyid}",
    :expects => 200
  )
end
get_machine(uuid) click to toggle source
# File lib/fog/joyent/requests/compute/get_machine.rb, line 19
def get_machine(uuid)
  request(
    :method => "GET",
    :path => "/my/machines/#{uuid}",
    :expects => 200
  )
end
get_machine_metadata(machine_id, options = {}) click to toggle source
# File lib/fog/joyent/requests/compute/get_machine_metadata.rb, line 6
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
  )
end
get_machine_snapshot(machine_id, snapshot_name) click to toggle source
# 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"
  )
end
get_machine_tag(machine_id, tagname) click to toggle source

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

# File lib/fog/joyent/requests/compute/get_machine_tag.rb, line 7
def get_machine_tag(machine_id, tagname)
  request(
    :path => "/my/machines/#{machine_id}/tags/#{tagname}",
    :method => "GET",
    :headers => {"Accept" => "text/plain"},
    :expects => 200
  )
end
get_package(name) click to toggle source
# File lib/fog/joyent/requests/compute/get_package.rb, line 21
def get_package(name)
  name = URI.escape(name)
  request(
    :method => "GET",
    :path => "/my/packages/#{name}",
    :expects => 200
  )
end
list_datacenters() click to toggle source
# File lib/fog/joyent/requests/compute/list_datacenters.rb, line 6
def list_datacenters
  request(
    :expects => 200,
    :method => :'GET',
    :path => '/my/datacenters'
  )
end
list_datasets() click to toggle source
# File lib/fog/joyent/requests/compute/list_datasets.rb, line 15
def list_datasets
  request(
    :method => "GET",
    :path => "/my/datasets"
  )
end
list_keys() click to toggle source
# File lib/fog/joyent/requests/compute/list_keys.rb, line 14
def list_keys
  request(
    :expects => 200,
    :method => :'GET',
    :path => '/my/keys'
  )
end
list_machine_snapshots(machine_id) click to toggle source
# 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"
  )
end
list_machine_tags(machine_id) click to toggle source

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

# 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
  )
end
list_machines(options={}) click to toggle source
# File lib/fog/joyent/requests/compute/list_machines.rb, line 15
def list_machines(options={})
  request(
    :path => "/my/machines",
    :method => "GET",
    :query => options
  )
end
list_packages() click to toggle source

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"

# File lib/fog/joyent/requests/compute/list_packages.rb, line 24
def list_packages
  request(
    :path => "/my/packages",
    :method => "GET",
    :expects => 200
  )
end
reboot_machine(id) click to toggle source
# 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(request = {}) click to toggle source
# File lib/fog/joyent/compute.rb, line 145
def request(request = {})
  request[:headers] = {
    "X-Api-Version" => @joyent_version,
    "Content-Type" => "application/json",
    "Accept" => "application/json"
  }.merge(request[:headers] || {}).merge(@header_method.call) 

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

  response = @connection.request(request)

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

  raise_if_error!(request, response)

  response
end
resize_machine(id, package) click to toggle source
# 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}
  )
end
start_machine(id) click to toggle source
# 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) click to toggle source
# 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) click to toggle source
# 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) click to toggle source
# 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

[Validate]

Generated with the Darkfish Rdoc Generator 2.