class Fog::Compute::Linode::Real

Public Class Methods

new(options={}) click to toggle source
# File lib/fog/linode/compute.rb, line 89
def initialize(options={})
  @linode_api_key = options[:linode_api_key]
  @host   = options[:host]    || "api.linode.com"
  @port   = options[:port]    || 443
  @scheme = options[:scheme]  || 'https'
  @connection = Fog::XML::Connection.new("#{@scheme}://#{@host}:#{@port}", options[:persistent])
end

Public Instance Methods

avail_datacenters() click to toggle source

Get available data centers

Returns

  • response<~Excon::Response>:

    • body<~Array>:

TODO: docs

# File lib/fog/linode/requests/compute/avail_datacenters.rb, line 11
def avail_datacenters
  request(
    :expects  => 200,
    :method   => 'GET',
    :query    => { :api_action => 'avail.datacenters' }
  )
end
avail_distributions(distribution_id=nil) click to toggle source

Get available distributions

Parameters

  • distributionId<~Integer>: id to limit results to

Returns

  • response<~Excon::Response>:

    • body<~Array>:

TODO: docs

# File lib/fog/linode/requests/compute/avail_distributions.rb, line 14
def avail_distributions(distribution_id=nil)
  options = {}
  if distribution_id
    options.merge!(:distributionId => distribution_id)
  end
  request(
    :expects  => 200,
    :method   => 'GET',
    :query    => { :api_action => 'avail.distributions' }.merge!(options)
  )
end
avail_kernels(options={}) click to toggle source

Get available kernels

Parameters

  • options<~Hash>

    • isXen<~Boolean> Show or hide Xen compatible kernels

    • isKVM<~Boolean> Show or hide KVM compatible kernels

Returns

  • response<~Excon::Response>:

    • body<~Array>:

TODO: docs

# File lib/fog/linode/requests/compute/avail_kernels.rb, line 16
def avail_kernels(options={})
  # avail.kernels used to accept a kernelId parameter (now removed)
  raise Fog::Errors::Error.new('avail_kernels no longer accepts a kernelId parameter') unless !options || options.is_a?(Hash)
  request(
    :expects  => 200,
    :method   => 'GET',
    :query    => { :api_action => 'avail.kernels' }.merge!(options || {})
  )
end
avail_linodeplans(linodeplan_id = nil) click to toggle source

Get available plans

Parameters

  • linodeplanId<~Integer>: id to limit results to

Returns

  • response<~Excon::Response>:

    • body<~Array>:

TODO: docs

# File lib/fog/linode/requests/compute/avail_linodeplans.rb, line 14
def avail_linodeplans(linodeplan_id = nil)
  options = {}
  if linodeplan_id
    options.merge!(:planId => linodeplan_id)
  end
  result = request(
    :expects  => 200,
    :method   => 'GET',
    :query    => { :api_action => 'avail.linodeplans' }.merge!(options)
  )

  result
end
avail_nodebalancers() click to toggle source

Get NodeBalancer pricing information.

Parameters

Returns

  • response<~Excon::Response>:

    • body<~Array>:

      * 'MONTHLY'<~Float>        - Monthly price
      * 'HOURLY'<~Float>:        - Hourly price
      * 'CONNECTIONS'<~Integer>: - Maximum concurrent connections
# File lib/fog/linode/requests/compute/avail_nodebalancers.rb, line 15
def avail_nodebalancers
  request(
    :expects  => 200,
    :method   => 'GET',
    :query    => { :api_action => 'avail.nodebalancers' }
  )
end
avail_stackscripts(options={}) click to toggle source
# File lib/fog/linode/requests/compute/avail_stackscripts.rb, line 5
def avail_stackscripts(options={})
  result = request(
    :expects  => 200,
    :method   => 'GET',
    :query    => { :api_action => 'avail.stackscripts' }.merge!(options)
  )
  result.body['DATA'].each { |r| r['DISTRIBUTIONIDLIST'] = r['DISTRIBUTIONIDLIST'].to_s }
  result
end
image_delete(image_id) click to toggle source
# File lib/fog/linode/requests/compute/image_delete.rb, line 5
def image_delete(image_id)
  request(
    :expects  => 200,
    :method   => 'GET',
    :query    => {
      :api_action => 'image.delete',
      :imageId => image_id
    }
  )
end
image_list(pending=nil, image_id=nil) click to toggle source
# File lib/fog/linode/requests/compute/image_list.rb, line 5
def image_list(pending=nil, image_id=nil)
  options = {}
  if pending
    options.merge!(:pending => pending)
  end
  if image_id
    options.merge!(:imageId => image_id)
  end
  request(
    :expects  => 200,
    :method   => 'GET',
    :query    => { :api_action => 'image.list' }.merge!(options)
  )
end
linode_boot(linode_id, config_id) click to toggle source
# File lib/fog/linode/requests/compute/linode_boot.rb, line 5
def linode_boot(linode_id, config_id)
  request(
    :expects => 200,
    :method => 'GET',
    :query => { :api_action => 'linode.boot', :linodeId => linode_id, :configId => config_id }
  )
end
linode_config_create(linode_id, kernel_id, name, disk_list) click to toggle source
# File lib/fog/linode/requests/compute/linode_config_create.rb, line 5
def linode_config_create(linode_id, kernel_id, name, disk_list)
  request(
    :expects  => 200,
    :method   => 'GET',
    :query    => {
      :api_action => 'linode.config.create',
      :linodeId => linode_id,
      :kernelId => kernel_id,
      :label => name,
      :diskList => disk_list
    }
  )
end
linode_config_delete(linode_id, config_id) click to toggle source
# File lib/fog/linode/requests/compute/linode_config_delete.rb, line 5
def linode_config_delete(linode_id, config_id)
  request(
    :expects  => 200,
    :method   => 'GET',
    :query    => {
      :api_action => 'linode.config.delete',
      :linodeId => linode_id,
      :configId => config_id
    }
  )
end
linode_config_list(linode_id, config_id=nil, options={}) click to toggle source
# File lib/fog/linode/requests/compute/linode_config_list.rb, line 5
def linode_config_list(linode_id, config_id=nil, options={})
  if config_id
    options.merge!(:configid => config_id)
  end
  request(
    :expects  => 200,
    :method   => 'GET',
    :query    => { :api_action => 'linode.config.list', :linodeId => linode_id }.merge!(options)
  )
end
linode_config_update(linode_id, config_id, options={}) click to toggle source

api docs say LinodeID is optional, turns out its required

# File lib/fog/linode/requests/compute/linode_config_update.rb, line 6
def linode_config_update(linode_id, config_id, options={})
  request(
    :expects  => 200,
    :method   => 'GET',
    :query    => { 
      :api_action => 'linode.config.update', 
      :configId => config_id,
      :linodeID => linode_id
    }.merge!(options)
  )
end
linode_create(datacenter_id, plan_id, payment_term) click to toggle source

Creates a linode and assigns you full privileges

Parameters

  • datacenter_id<~Integer>: id of datacenter to place new linode in

  • plan_id<~Integer>: id of plan to boot new linode with

  • payment_term<~Integer>: Subscription term in months, in [1, 12, 24]

Returns

  • response<~Excon::Response>:

    • body<~Array>:

TODO: docs

# File lib/fog/linode/requests/compute/linode_create.rb, line 16
def linode_create(datacenter_id, plan_id, payment_term)
  request(
    :expects  => 200,
    :method   => 'GET',
    :query    => {
      :api_action   => 'linode.create',
      :datacenterId => datacenter_id,
      :paymentTerm  => payment_term,
      :planId       => plan_id
    }
  )
end
linode_delete(linode_id, options={}) click to toggle source

List all linodes user has access or delete to

Parameters

  • linode_id<~Integer>: id of linode to delete

  • options<~Hash>:

    • skipChecks<~Boolean>: skips safety checks and always deletes

Returns

  • response<~Excon::Response>:

    • body<~Array>:

TODO: docs

# File lib/fog/linode/requests/compute/linode_delete.rb, line 16
def linode_delete(linode_id, options={})
  request(
    :expects  => 200,
    :method   => 'GET',
    :query    => { :api_action => 'linode.delete', :linodeId => linode_id }.merge!(options)
  )
end
linode_disk_create(linode_id, name, type, size) click to toggle source
# File lib/fog/linode/requests/compute/linode_disk_create.rb, line 5
def linode_disk_create(linode_id, name, type, size)
  request(
    :expects  => 200,
    :method   => 'GET',
    :query    => {
      :api_action => 'linode.disk.create',
      :linodeId => linode_id,
      :label => name,
      :type => type,
      :size => size
    }
  )
end
linode_disk_createfromdistribution(linode_id, distro_id, name, size, password) click to toggle source
# File lib/fog/linode/requests/compute/linode_disk_createfromdistribution.rb, line 5
def linode_disk_createfromdistribution(linode_id, distro_id, name, size, password)
  request(
    :expects  => 200,
    :method   => 'GET',
    :query    => {
      :api_action => 'linode.disk.createfromdistribution',
      :linodeId => linode_id,
      :distributionId => distro_id,
      :label => name,
      :size => size,
      :rootPass => password
    }
  )
end
linode_disk_createfromimage(linode_id, image_id, label, size, password, sshkey) click to toggle source
# File lib/fog/linode/requests/compute/linode_disk_createfromimage.rb, line 5
def linode_disk_createfromimage(linode_id, image_id, label, size, password, sshkey)
  request(
    :expects  => 200,
    :method   => 'GET',
    :query    => {
      :api_action => 'linode.disk.createfromimage',
      :linodeId => linode_id,
      :imageId => image_id,
      :label => label,
      :size => size,
      :rootPass => password,
      :rootSSHKey => sshkey
    }
  )
end
linode_disk_createfromstackscript(linode_id, script_id, distro_id, name, size, password, options={}) click to toggle source
# File lib/fog/linode/requests/compute/linode_disk_createfromstackscript.rb, line 5
def linode_disk_createfromstackscript(linode_id, script_id, distro_id, name, size, password, options={})
  request(
    :expects  => 200,
    :method   => 'GET',
    :query    => {
      :api_action => 'linode.disk.createfromstackscript',
      :linodeId => linode_id,
      :stackScriptID => script_id,
      :distributionId => distro_id,
      :label => name,
      :size => size,
      :rootPass => password,
      :stackScriptUDFResponses => Fog::JSON.encode(options)
    }
  )
end
linode_disk_delete(linode_id, disk_id) click to toggle source
# File lib/fog/linode/requests/compute/linode_disk_delete.rb, line 5
def linode_disk_delete(linode_id, disk_id)
  request(
    :expects  => 200,
    :method   => 'GET',
    :query    => {
      :api_action => 'linode.disk.delete',
      :linodeId => linode_id,
      :diskId => disk_id
    }
  )
end
linode_disk_duplicate(linode_id, disk_id) click to toggle source
# File lib/fog/linode/requests/compute/linode_disk_duplicate.rb, line 5
def linode_disk_duplicate(linode_id, disk_id)
  request(
    :expects  => 200,
    :method   => 'GET',
    :query    => {
      :api_action => 'linode.disk.duplicate',
      :linodeId => linode_id,
      :diskID => disk_id,
    }
  )
end
linode_disk_imagize(linode_id, disk_id, description, label) click to toggle source
# File lib/fog/linode/requests/compute/linode_disk_imagize.rb, line 5
def linode_disk_imagize(linode_id, disk_id, description, label)
  request(
    :expects  => 200,
    :method   => 'GET',
    :query    => {
      :api_action => 'linode.disk.imagize',
      :linodeId => linode_id,
      :diskId => disk_id,
      :description => description,
      :label => label
    }
  )
end
linode_disk_list(linode_id, disk_id=nil) click to toggle source
# File lib/fog/linode/requests/compute/linode_disk_list.rb, line 5
def linode_disk_list(linode_id, disk_id=nil)
  options = {}
  if disk_id
    options.merge!(:diskId => disk_id)
  end
  request(
    :expects  => 200,
    :method   => 'GET',
    :query    => { :api_action => 'linode.disk.list', :linodeId => linode_id }.merge!(options)
  )
end
linode_disk_resize(linode_id, disk_id, size) click to toggle source
# File lib/fog/linode/requests/compute/linode_disk_resize.rb, line 5
def linode_disk_resize(linode_id, disk_id, size)
  request(
    :expects  => 200,
    :method   => 'GET',
    :query    => {
      :api_action => 'linode.disk.resize',
      :linodeId => linode_id,
      :diskId => disk_id,
      :size => size
    }
  )
end
linode_disk_update(linode_id, disk_id, label, isreadonly) click to toggle source
# File lib/fog/linode/requests/compute/linode_disk_update.rb, line 5
def linode_disk_update(linode_id, disk_id, label, isreadonly)
  request(
    :expects  => 200,
    :method   => 'GET',
    :query    => {
      :api_action => 'linode.disk.update',
      :linodeId => linode_id,
      :diskId => disk_id,
      :label => label,
      :isReadOnly => isreadonly
    }
  )
end
linode_ip_addprivate(linode_id) click to toggle source
# File lib/fog/linode/requests/compute/linode_ip_addprivate.rb, line 5
def linode_ip_addprivate(linode_id)
  request(
    :expects  => 200,
    :method   => 'GET',
    :query    => { :api_action => 'linode.ip.addprivate', :linodeId => linode_id }
  )
end
linode_ip_list(linode_id, ip_id=nil) click to toggle source
# File lib/fog/linode/requests/compute/linode_ip_list.rb, line 5
def linode_ip_list(linode_id, ip_id=nil)
  options = {}
  if ip_id
    options.merge!(:ipaddressId => ip_id)
  end
  request(
    :expects  => 200,
    :method   => 'GET',
    :query    => { :api_action => 'linode.ip.list', :linodeId => linode_id }.merge!(options)
  )
end
linode_list(linode_id=nil) click to toggle source

List all linodes user has access or delete to

Parameters

  • linodeId<~Integer>: Limit the list to the specified LinodeID

Returns

  • response<~Excon::Response>:

    • body<~Array>:

TODO: docs

# File lib/fog/linode/requests/compute/linode_list.rb, line 14
def linode_list(linode_id=nil)
  options = {}
  if linode_id
    options.merge!(:linodeId => linode_id)
  end
  request(
    :expects  => 200,
    :method   => 'GET',
    :query    => { :api_action => 'linode.list' }.merge!(options)
  )
end
linode_reboot(linode_id, options={}) click to toggle source

Issues a shutdown, and then a boot job for a given linode

Parameters

  • linode_id<~Integer>: id of linode to reboot

  • options<~Hash>:

    • configId<~Boolean>: id of config to boot server with

Returns

  • response<~Excon::Response>:

    • body<~Array>:

TODO: docs

# File lib/fog/linode/requests/compute/linode_reboot.rb, line 16
def linode_reboot(linode_id, options={})
  request(
    :expects  => 200,
    :method   => 'GET',
    :query    => { :api_action => 'linode.reboot', :linodeId => linode_id }.merge!(options)
  )
end
linode_shutdown(linode_id) click to toggle source
# File lib/fog/linode/requests/compute/linode_shutdown.rb, line 5
def linode_shutdown(linode_id)
  request(
    :expects => 200,
    :method => 'GET',
    :query => { :api_action => 'linode.shutdown', :linodeId => linode_id }
  )
end
linode_update(linode_id, options={}) click to toggle source
# File lib/fog/linode/requests/compute/linode_update.rb, line 5
def linode_update(linode_id, options={})
  request(
    :expects  => 200,
    :method   => 'GET',
    :query    => { :api_action => 'linode.update', :linodeId => linode_id }.merge!(options)
  )
end
reload() click to toggle source
# File lib/fog/linode/compute.rb, line 97
def reload
  @connection.reset
end
request(params) click to toggle source
# File lib/fog/linode/compute.rb, line 101
def request(params)
  params[:query] ||= {}
  params[:query].merge!(:api_key => @linode_api_key)

  response = @connection.request(params)

  unless response.body.empty?
    response.body = Fog::JSON.decode(response.body)
    if data = response.body['ERRORARRAY'].first
      error = case data['ERRORCODE']
      when 5
        Fog::Compute::Linode::NotFound
      else
        Fog::Compute::Linode::Error
      end
      raise error.new(data['ERRORMESSAGE'])
    end
  end
  response
end
stackscript_list(script_id=nil) click to toggle source

Get available stack scripts

Parameters

  • scriptId<~Integer>: id to limit results to

Returns

  • response<~Excon::Response>:

    • body<~Array>:

TODO: docs

# File lib/fog/linode/requests/compute/stackscript_list.rb, line 14
def stackscript_list(script_id=nil)
  options = {}
  if script_id
    options.merge!(:stackScriptID => script_id)
  end
  result = request(
    :expects  => 200,
    :method   => 'GET',
    :query    => { :api_action => 'stackscript.list' }.merge!(options)
  )
  result.body['DATA'].each { |r| r['DISTRIBUTIONIDLIST'] = r['DISTRIBUTIONIDLIST'].to_s }
  result
end