In Files

Parent

Class/Module Index [+]

Quicksearch

Fog::Compute::Cloudstack::Mock

Public Class Methods

data() click to toggle source
# File lib/fog/cloudstack/compute.rb, line 264
def self.data
  @data ||= begin
    zone_id     = Fog.credentials[:cloudstack_zone_id]             || Fog::Cloudstack.uuid
    image_id    = Fog.credentials[:cloudstack_template_id]         || Fog::Cloudstack.uuid
    flavor_id   = Fog.credentials[:cloudstack_service_offering_id] || Fog::Cloudstack.uuid
    network_id  = (Array(Fog.credentials[:cloudstack_network_ids]) || [Fog::Cloudstack.uuid]).first
    domain_name = "exampleorg"
    account_id, user_id, domain_id = Fog::Cloudstack.uuid, Fog::Cloudstack.uuid, Fog::Cloudstack.uuid
    domain = {
      "id"               => domain_id,
      "name"             => domain_name,
      "level"            => 1,
      "parentdomainid"   => Fog::Cloudstack.uuid,
      "parentdomainname" => "ROOT",
      "haschild"         => false,
      "path"             => "ROOT/accountname"
    }
    user = {
      "id"          => user_id,
      "username"    => "username",
      "firstname"   => "Bob",
      "lastname"    => "Lastname",
      "email"       => "email@example.com",
      "created"     => "2012-05-14T16:25:17-0500",
      "state"       => "enabled",
      "account"     => "accountname",
      "accounttype" => 2,
      "domainid"    => domain_id,
      "domain"      => domain_name,
      "apikey"      => Fog::Cloudstack.uuid,
      "secretkey"   => Fog::Cloudstack.uuid
    }
    {
      :users    => { user_id    => user },
      :networks => { network_id => {
        "id"                          => network_id,
        "name"                        => "10.56.23.0/26",
        "displaytext"                 => "10.56.23.0/26",
        "broadcastdomaintype"         => "Vlan",
        "traffictype"                 => "Guest",
        "gateway"                     => "10.56.23.1",
        "netmask"                     => "255.255.255.192",
        "cidr"                        => "10.56.23.0/26",
        "zoneid"                      => zone_id,
        "zonename"                    => "zone-00",
        "networkofferingid"           => "af0c9bd5-a1b2-4ad0-bf4b-d6fa9b1b9d5b",
        "networkofferingname"         => "DefaultSharedNetworkOffering",
        "networkofferingdisplaytext"  => "Offering for Shared networks",
        "networkofferingavailability" => "Optional",
        "issystem"                    => false,
        "state"                       => "Setup",
        "related"                     => "86bbc9fc-d92e-49db-9fdc-296189090017",
        "broadcasturi"                => "vlan://800",
        "dns1"                        => "10.0.80.11",
        "type"                        => "Shared",
        "vlan"                        => "800",
        "acltype"                     => "Domain",
        "subdomainaccess"             => true,
        "domainid"                    => domain_id,
        "domain"                      => "ROOT",
        "service" => [
          {"name" => "UserData"},
          {"name" => "Dhcp"},
          {
            "name"       => "Dns",
            "capability" => [
              {
                "name"                       => "AllowDnsSuffixModification",
                "value"                      => "true",
                "canchooseservicecapability" => false
              }
            ]
        }],
        "networkdomain"     => "cs1cloud.internal",
        "physicalnetworkid" => "8f4627c5-1fdd-4504-8a92-f61b4e9cb3e3",
        "restartrequired"   => false,
        "specifyipranges"   => true}
      },
      :zones => { zone_id => {
        "id"                    => zone_id,
        "name"                  => "zone-00",
        "domainid"              => 1,
        "domainname"            => "ROOT",
        "networktype"           => "Advanced",
        "securitygroupsenabled" => false,
        "allocationstate"       => "Enabled",
        "zonetoken"             => Fog::Cloudstack.uuid,
        "dhcpprovider"          => "VirtualRouter"}},
      :images => { image_id => {
        "id"              => image_id,
        "name"            => "CentOS 5.6(64-bit) no GUI (XenServer)",
        "displaytext"     => "CentOS 5.6(64-bit) no GUI (XenServer)",
        "ispublic"        => true,
        "created"         => "2012-05-09T15:29:33-0500",
        "isready"         => true,
        "passwordenabled" => false,
        "format"          => "VHD",
        "isfeatured"      => true,
        "crossZones"      => true,
        "ostypeid"        => "a6a6694a-18f5-4765-8418-2b7a5f37cd0f",
        "ostypename"      => "CentOS 5.3 (64-bit)",
        "account"         => "system",
        "zoneid"          => zone_id,
        "zonename"        => "zone-00",
        "status"          => "Download Complete",
        "size"            => 21474836480,
        "templatetype"    => "BUILTIN",
        "domain"          => "ROOT",
        "domainid"        => "6023b6fe-5bef-4358-bc76-9f4e75afa52f",
        "isextractable"   => true,
        "checksum"        => "905cec879afd9c9d22ecc8036131a180",
        "hypervisor"      => "Xen"
      }},
      :flavors => { flavor_id => {
        "id"          => flavor_id,
        "name"        => "Medium Instance",
        "displaytext" => "Medium Instance",
        "cpunumber"   => 1,
        "cpuspeed"    => 1000,
        "memory"      => 1024,
        "created"     => "2012-05-09T14:48:36-0500",
        "storagetype" => "shared",
        "offerha"     => false,
        "limitcpuuse" => false,
        "issystem"    => false,
        "defaultuse"  => false}},
      :accounts => { account_id => {
        "id"                => account_id,
        "name"              => "accountname",
        "accounttype"       => 2,
        "domainid"          => domain_id,
        "domain"            => domain_name,
        "receivedbytes"     => 0,
        "sentbytes"         => 0,
        "vmlimit"           => "Unlimited",
        "vmtotal"           => 0,
        "vmavailable"       => "Unlimited",
        "iplimit"           => "Unlimited",
        "iptotal"           => 0,
        "ipavailable"       => "Unlimited",
        "volumelimit"       => "Unlimited",
        "volumetotal"       => 0,
        "volumeavailable"   => "Unlimited",
        "snapshotlimit"     => "Unlimited",
        "snapshottotal"     => 0,
        "snapshotavailable" => "Unlimited",
        "templatelimit"     => "Unlimited",
        "templatetotal"     => 0,
        "templateavailable" => "Unlimited",
        "vmstopped"         => 0,
        "vmrunning"         => 0,
        "projectlimit"      => "Unlimited",
        "projecttotal"      => 1,
        "projectavailable"  => "Unlimited",
        "networklimit"      => "Unlimited",
        "networktotal"      => 0,
        "networkavailable"  => "Unlimited",
        "state"             => "enabled",
        "user"              => [user]}
      },
      :domains         => {domain_id => domain},
      :servers         => {},
      :jobs            => {},
      :volumes         => {
        "89198f7c-0245-aa1d-136a-c5f479ef9db7" => {
          "id"=> "89198f7c-0245-aa1d-136a-c5f479ef9db7",
          "name"=>"test volume",
          "zoneid"=> zone_id,
          "zonename"=>"zone-00",
          "type"=>"DATADISK",
          "deviceid"=>1,
          "virtualmachineid"=> "51dcffee-5f9f-29a4-acee-2717e1a3656b",
          "vmname"=>"i-2824-11621-VM",
          "vmdisplayname"=>"test vm",
          "vmstate"=>"Running",
          "size"=>17179869184,
          "created"=>"2013-04-16T12:33:41+0000",
          "state"=>"Ready",
          "account"=> 'accountname',
          "domainid"=> domain_id,
          "domain"=> domain_name,
          "storagetype"=>"shared",
          "hypervisor"=>"KVM",
          "diskofferingid"=> "cc4de87d-672d-4353-abb5-6a8a4c0abf59",
          "diskofferingname"=>"Small Disk",
          "diskofferingdisplaytext"=>"Small Disk [16GB Disk]",
          "storage"=>"ps1",
          "attached"=>"2013-04-16T12:34:07+0000",
          "destroyed"=>false,
          "isextractable"=>false
          },
        },
      :security_groups => {},
      :snapshots       => {},
      :disk_offerings  => {
        "cc4de87d-672d-4353-abb5-6a8a4c0abf59" => {
          "id"           => "cc4de87d-672d-4353-abb5-6a8a4c0abf59",
          "domainid"     => domain_id,
          "domain"       => domain_name,
          "name"         => "Small Disk",
          "displaytext"  => "Small Disk [16GB Disk]",
          "disksize"     => 16,
          "created"      => "2013-02-21T03:12:520300",
          "iscustomized" => false,
          "storagetype"  =>  "shared"
        },
        "d5deeb0c-de03-4ebf-820a-dc74221bcaeb" => {
          "id"           => "d5deeb0c-de03-4ebf-820a-dc74221bcaeb",
          "domainid"     => domain_id,
          "domain"       => domain_name,
          "name"         => "Medium Disk",
          "displaytext"  => "Medium Disk [32GB Disk]",
          "disksize"     => 32,
          "created"      => "2013-02-21T03:12:520300",
          "iscustomized" => false,
          "storagetype"  => "shared"
        }
      },
      :os_types  => {
        "51ef854d-279e-4e68-9059-74980fd7b29b" => {
          "id"           => "51ef854d-279e-4e68-9059-74980fd7b29b",
          "oscategoryid" => "56f67279-e082-45c3-a01c-d290d6cd4ce2",
          "description"  => "Asianux 3(32-bit)"
          },
        "daf124c8-95d8-4756-8e1c-1871b073babb" => {
          "id"           => "daf124c8-95d8-4756-8e1c-1871b073babb",
          "oscategoryid" => "56f67279-e082-45c3-a01c-d290d6cd4ce2",
          "description"  => "Asianux 3(64-bit)"
          }
      }
    }
  end
end
new(options={}) click to toggle source
# File lib/fog/cloudstack/compute.rb, line 260
def initialize(options={})
  @cloudstack_api_key = options[:cloudstack_api_key]
end
reset() click to toggle source
# File lib/fog/cloudstack/compute.rb, line 498
def self.reset
  @data = nil
end

Public Instance Methods

add_delete_snapshot_job(snapshot_id) click to toggle source
# File lib/fog/cloudstack/requests/compute/delete_snapshot.rb, line 38
def add_delete_snapshot_job(snapshot_id)
  job_id = Fog::Cloudstack.uuid

  job = {
    'id' => job_id,
    'user_id' => self.data[:users].first, # TODO use current user
    'account_id' => self.data[:accounts].first, # TODO use current user
    'cmd' => 'com.cloud.api.commands.DeleteSnapshotCmd',
    'job_status'=> 1,
    'job_result_type' => nil,
    'job_result_code' => 0,
    'job_proc_status' => 0,
    'created_at' => Time.now.iso8601,
    'job_result' => { "success" => true }
  }

  self.data[:jobs][job_id] = job
  job_id
end
attach_volume(options={}) click to toggle source
# File lib/fog/cloudstack/requests/compute/attach_volume.rb, line 21
def attach_volume(options={})
  volume_id = options['id']
  server_id = options['virtualmachineid']

  volume = self.data[:volumes][volume_id]
  unless volume
    raise Fog::Compute::Cloudstack::BadRequest.new("Unable to execute API command attachvolume due to invalid value. Object volumes(uuid: #{volume_id}) does not exist.")
  end

  server = self.data[:servers][server_id]
  unless server
    raise Fog::Compute::Cloudstack::BadRequest.new("Unable to execute API command attachvolume due to invalid value. Object vm_instance(uuid: #{server_id}) does not exist.")
  end

  volume['virtualmachineid']= server['id']
  volume['vmname']= server['name']
  volume['vmdisplayname']= server['displayname']

  job_id = Fog::Cloudstack.uuid

  # FIXME: need to determine current user
  account_id = self.data[:accounts].first
  user_id = self.data[:users].first

  job = {
    "accountid"     => account_id,
    "userid"        => user_id,
    "cmd"           => "com.cloud.api.commands.AttachVolumeCmd",
    "created"       => Time.now.iso8601,
    "jobid"         => job_id,
    "jobstatus"     => 1,
    "jobprocstatus" => 0,
    "jobresultcode" => 0,
    "jobresulttype" => "object",
    "jobresult"     =>
      {"volume"     => volume}
  }

  self.data[:jobs][job_id]= job

  {
    "attachvolumeresponse" => {
      "jobid" => job_id
    }
  }
end
authorize_security_group_egress(options={}) click to toggle source
# File lib/fog/cloudstack/requests/compute/authorize_security_group_egress.rb, line 14
def authorize_security_group_egress(options={})
  security_group_id      = options['securitygroupid']
  security_group_rule_id = Fog::Cloudstack.uuid

  unless cidr = options['cidrlist']
    raise Fog::Compute::Cloudstack::BadRequest.new('Unable to execute API command missing parameter cidr')
  end

  unless start_port = options['startport']
    raise Fog::Compute::Cloudstack::BadRequest.new('Unable to execute API command missing parameter start_port')
  end

  unless end_port = options['endport']
    raise Fog::Compute::Cloudstack::BadRequest.new('Unable to execute API command missing parameter end_port')
  end

  unless protocol = options['protocol']
    raise Fog::Compute::Cloudstack::BadRequest.new('Unable to execute API command missing parameter protocol')
  end

  rule = {
    "ruleid"    => security_group_rule_id,
    "cidr"      => cidr,
    "startport" => start_port,
    "endport"   => end_port,
    "protocol"  => protocol
  }

  unless security_group = self.data[:security_groups][security_group_id]
    raise Fog::Compute::Cloudstack::BadRequest.new("Security group id #{security_group_id} does not exist")
  end

  security_group["egressrule"] ||= []
  security_group["egressrule"] << rule

  job_id = Fog::Cloudstack.uuid
  job = {
    "cmd"           => "com.cloud.api.commands.authorizeSecurityGroupEgress",
    "created"       => Time.now.iso8601,
    "jobid"         => job_id,
    "jobstatus"     => 1,
    "jobprocstatus" => 0,
    "jobresultcode" => 0,
    "jobresulttype" => "object",
    "jobresult"     => { "securitygroup" => security_group }
  }

  self.data[:jobs][job_id]= job

  { "authorizesecuritygroupegressresponse" => { "jobid" => job_id } }
end
authorize_security_group_ingress(options={}) click to toggle source
# File lib/fog/cloudstack/requests/compute/authorize_security_group_ingress.rb, line 17
def authorize_security_group_ingress(options={})
  security_group_id      = options['securitygroupid']
  security_group_rule_id = Fog::Cloudstack.uuid

  unless cidr = options['cidrlist']
    raise Fog::Compute::Cloudstack::BadRequest.new('Unable to execute API command missing parameter cidr')
  end

  unless start_port = options['startport']
    raise Fog::Compute::Cloudstack::BadRequest.new('Unable to execute API command missing parameter start_port')
  end

  unless end_port = options['endport']
    raise Fog::Compute::Cloudstack::BadRequest.new('Unable to execute API command missing parameter end_port')
  end

  unless protocol = options['protocol']
    raise Fog::Compute::Cloudstack::BadRequest.new('Unable to execute API command missing parameter protocol')
  end

  rule = {
    "ruleid"    => security_group_rule_id,
    "cidr"      => cidr,
    "startport" => start_port,
    "endport"   => end_port,
    "protocol"  => protocol
  }

  unless security_group = self.data[:security_groups][security_group_id]
    raise Fog::Compute::Cloudstack::BadRequest.new("Security group id #{security_group_id} does not exist")
  end

  security_group["ingressrule"] ||= []
  security_group["ingressrule"] << rule

  job_id = Fog::Cloudstack.uuid
  job = {
    "cmd"           => "com.cloud.api.commands.authorizeSecurityGroupIngress",
    "created"       => Time.now.iso8601,
    "jobid"         => job_id,
    "jobstatus"     => 1,
    "jobprocstatus" => 0,
    "jobresultcode" => 0,
    "jobresulttype" => "object",
    "jobresult"     => { "securitygroup" => security_group }
  }

  self.data[:jobs][job_id]= job

  { "authorizesecuritygroupingressresponse" => { "jobid" => job_id } }
end
create_disk_offering(options={}) click to toggle source
# File lib/fog/cloudstack/requests/compute/create_disk_offering.rb, line 20
def create_disk_offering(options={})
  disk_offering_id = Fog::Cloudstack.uuid

  first_domain_data = data[:domains].first.last
  domain_id = options['domainid'] || first_domain_data['id']
  domain_name = data[:domains][domain_id]['name']

  storage_type = options['storagetype'] || 'shared'
  customized = options['customized'] || false
  disk_size = options['disk_size'] || 1

  disk_offering = {
    "id"           => disk_offering_id,
    "domainid"     => domain_id,
    "domain"       => domain_name,
    "name"         => options['name'],
    "displaytext"  => options['display_text'],
    "disksize"     => disk_size,
    "created"      => Time.now.iso8601,
    "iscustomized" => customized,
    "storagetype"  => storage_type
  }

  self.data[:disk_offerings][disk_offering_id] = disk_offering

  {'creatediskofferingresponse' => disk_offering}
end
create_security_group(options={}) click to toggle source
# File lib/fog/cloudstack/requests/compute/create_security_group.rb, line 15
def create_security_group(options={})
  security_group_id = Fog::Cloudstack.uuid

  security_group = {
    "id" => security_group_id,
  }.merge(options)

  self.data[:security_groups][security_group_id]= security_group
  {"createsecuritygroupresponse" => { "securitygroup" => security_group}}
end
create_snapshot(options={}) click to toggle source
# File lib/fog/cloudstack/requests/compute/create_snapshot.rb, line 20
def create_snapshot(options={})
  snapshot_id = Fog::Cloudstack.uuid

  unless volume_id = options['volumeid']
    raise Fog::Compute::Cloudstack::BadRequest.new('Unable to execute API command createsnapshot due to missing parameter volumeid')
  end

  snapshot = {
     "id"                      => snapshot_id,
     "name"                    => "ROOT-6",
     "created"                 => "2013-05-22T14:52:55-0500",
     "state"                   => "BackedUp",
     "account"                 => "accountname",
     "domainid"                => "6023b6fe-5bef-4358-bc76-9f4e75afa52f",
     "domain"                  => "ROOT",
     "intervaltype"            => "weekly"
  }

  self.data[:snapshots][snapshot_id]= snapshot
  {'createsnapshotresponse' => snapshot}
end
create_volume(options={}) click to toggle source
# File lib/fog/cloudstack/requests/compute/create_volume.rb, line 20
def create_volume(options={})
  volume_id = Fog::Cloudstack.uuid

  unless volume_name = options['name']
    raise Fog::Compute::Cloudstack::BadRequest.new('Unable to execute API command createvolume due to missing parameter name')
  end

  unless zone_id = options['zoneid']
    raise Fog::Compute::Cloudstack::BadRequest.new('Unable to execute API command createvolume due to missing parameter zoneid')
  end

  unless disk_offering_id = options['diskofferingid']
    raise Fog::Compute::Cloudstack::BadRequest.new('Unable to execute API command createvolume due to missing parameter diskofferingid')
  end

  volume = {
     "id"                      => volume_id,
     "name"                    => volume_name,
     "zoneid"                  => zone_id,
     "zonename"                => "ey-wdc-00",
     "type"                    => "DATADISK",
     "size"                    => 5368709120,
     "created"                 => "2012-05-22T14:52:55-0500",
     "state"                   => "Allocated",
     "account"                 => "accountname",
     "domainid"                => "6023b6fe-5bef-4358-bc76-9f4e75afa52f",
     "domain"                  => "ROOT",
     "storagetype"             => "shared",
     "hypervisor"              => "None",
     "diskofferingid"          => disk_offering_id,
     "diskofferingname"        => "Small",
     "diskofferingdisplaytext" => "Small Disk, 5 GB",
     "storage"                 => "none",
     "destroyed"               => false,
     "isextractable"           => false
  }

  self.data[:volumes][volume_id]= volume
  {'createvolumeresponse' => volume}
end
data() click to toggle source
# File lib/fog/cloudstack/compute.rb, line 502
def data
  self.class.data
end
delete_disk_offering(options={}) click to toggle source
# File lib/fog/cloudstack/requests/compute/delete_disk_offering.rb, line 20
def delete_disk_offering(options={})
  disk_offering_id = options['id']
  data[:disk_offerings].delete(disk_offering_id) if data[:disk_offerings][disk_offering_id]

  { 'deletediskofferingresponse' => { 'success' => 'true' } }
end
delete_security_group(options={}) click to toggle source
# File lib/fog/cloudstack/requests/compute/delete_security_group.rb, line 20
def delete_security_group(options={})
  security_group_id = options['id']
  if self.data[:security_groups][security_group_id]
    self.data[:security_groups].delete(security_group_id)
    {
      "deletesecuritygroupresponse" => {
        "success" => "true"
      }
    }
  else
    raise Fog::Compute::Cloudstack::BadRequest.new('No security_group found')
  end
end
delete_snapshot(options={}) click to toggle source

Deletes a specified snapashot.

CloudStack API Reference

# File lib/fog/cloudstack/requests/compute/delete_snapshot.rb, line 24
def delete_snapshot(options={})
  snapshot_id = options['id']
  snapshots = self.data[:snapshots]

  if snapshots[snapshot_id]

    snapshots.delete(snapshot_id)
    job_id = add_delete_snapshot_job(snapshot_id)

    {'deletesnapshotresponse' => {'jobid' => job_id}}
  end
  # TODO add cases for empty or wrong id
end
delete_volume(options={}) click to toggle source
# File lib/fog/cloudstack/requests/compute/delete_volume.rb, line 19
def delete_volume(options={})
  volume_id = options['id']
  if self.data[:volumes][volume_id]
    self.data[:volumes].delete(volume_id)
    {
      "deletevolumeresponse" => {
        "success" => "true"
      }
    }
  else # FIXME: mayhaps
    self.data[:volumes].delete(volume_id)
    {
      "deletevolumeresponse" => {
        "success" => "false"
      }
    }
  end
end
deploy_virtual_machine(options={}) click to toggle source
# File lib/fog/cloudstack/requests/compute/deploy_virtual_machine.rb, line 32
def deploy_virtual_machine(options={})
  zone_id = options['zoneid']
  unless zone_id
    raise Fog::Compute::Cloudstack::BadRequest.new('Unable to execute API command deployvirtualmachine due to missing parameter zoneid')
  end
  unless zone = self.data[:zones][zone_id]
    raise Fog::Compute::Cloudstack::BadRequest.new("Unable to execute API command deployvirtualmachine due to invalid value. Object zone(uuid: #{zone_id}) does not exist.")
  end
  zone_name = zone[:name]

  template_id = options['templateid']
  unless template = self.data[:images][template_id]
    raise Fog::Compute::Cloudstack::BadRequest.new('Unable to execute API command deployvirtualmachine due to missing parameter templateid')
  end
  template_name = template[:name]
  template_display_text = template[:display_text]

  service_offering_id = options['serviceofferingid']
  unless service_offering = self.data[:flavors][service_offering_id]
    raise Fog::Compute::Cloudstack::BadRequest.new('Unable to execute API command deployvirtualmachine due to missing parameter serviceofferingid')
  end

  service_offering_name = service_offering[:name]
  service_offering_cpu_number = service_offering[:cpunumber]
  service_offering_cpu_speed = service_offering[:cpuspeed]
  service_offering_memory = service_offering[:cpumemory]

  identity = Fog::Cloudstack.uuid
  name = options['name'] || Fog::Cloudstack.uuid
  display_name = options['displayname'] || name
  account_name = options['account'] || self.data[:accounts].first[1]["name"]

  domain = options['domainid'] ? self.data[:domains][options['domainid']] : self.data[:domains].first[1]
  domain_id = domain[:id]
  domain_name = domain[:name]

  # how is this setup
  password = nil
  password_enabled = false

  guest_os_id = Fog::Cloudstack.uuid

  security_group_ids = options['securitygroupids'] || [] # TODO: for now

  network_ids = Array(options['networkids']) || [self.data[:networks].first[1]["id"]]
  networks = network_ids.map{|nid| self.data[:networks][nid]}
  nic = networks.map do |network|
    {
      "id" => Fog::Cloudstack.uuid,
      "networkid" => network["id"],
      "netmask" => Fog::Cloudstack.ip_address,
      "gateway" => network["gateway"],
      "ipaddress" => Fog::Cloudstack.ip_address,
      "traffictype" => "Guest", # TODO: ?
      "type" => network["type"],
      "isdefault" => true, # TODO: ?
      "macaddress" => Fog::Cloudstack.mac_address
    }
  end

  virtual_machine = {
    "id" => identity,
    "name" => name,
    "displayname" => display_name,
    "account" => account_name,
    "domainid" => domain_id,
    "domain" => domain_name,
    "created" => Time.now.to_s,
    "state" => "Running",
    "haenable" => false,
    "zoneid" => zone_id,
    "zonename" => zone_name,
    "templateid" => template_id,
    "templatename" => template_name,
    "templatedisplaytext" => template_display_text,
    "passwordenabled" => false,
    "serviceofferingid" => service_offering_id,
    "serviceofferingname" => service_offering_name,
    "cpunumber" => service_offering_cpu_number,
    "cpuspeed" => service_offering_cpu_speed,
    "memory" => service_offering_memory,
    "cpuused" => "0%",
    "networkkbsread" => 0,
    "networkkbswrite" => 0,
    "guestosid" => guest_os_id,
    "rootdeviceid" => 0,
    "rootdevicetype" => "NetworkFilesystem",
    "securitygroup" => security_group_ids, # TODO: mayhaps?
    "nic" => nic
  }

  self.data[:servers][identity]= virtual_machine
  {'deployvirtualmachineresponse' => virtual_machine}
end
destroy_virtual_machine(options={}) click to toggle source
# File lib/fog/cloudstack/requests/compute/destroy_virtual_machine.rb, line 21
def destroy_virtual_machine(options={})
  identity = options["id"]

  server = self.data[:servers][identity]
  unless server
    raise Fog::Compute::Cloudstack::BadRequest.new("Unable to execute API command attachserver due to invalid value. Object servers(uuid: #{identity}) does not exist.")
  end

  job_id = Fog::Cloudstack.uuid

  job = {
    "cmd"           => "com.cloud.api.commands.DestroyVirtualMachineCmd",
    "created"       => Time.now.iso8601,
    "jobid"         => job_id,
    "jobstatus"     => 1,
    "jobprocstatus" => 0,
    "jobresultcode" => 0,
    "jobresulttype" => "object",
    "jobresult"     =>
      {"virtualmachine" => server}
  }

  self.data[:jobs][job_id]= job
  self.data[:servers].delete(identity)

  {"destroyvirtualmachineresponse" => {"jobid" => job_id}}
end
detach_volume(options={}) click to toggle source
# File lib/fog/cloudstack/requests/compute/detach_volume.rb, line 21
def detach_volume(options={})
  volume_id = options['id']

  volume = self.data[:volumes][volume_id]
  unless volume
    raise Fog::Compute::Cloudstack::BadRequest.new("Unable to execute API command attachvolume due to invalid value. Object volumes(uuid: #{volume_id}) does not exist.")
  end

  volume['virtualmachineid']= volume['vmname']= volume['vmdisplayname']= nil

  job_id = Fog::Cloudstack.uuid

  # FIXME: need to determine current user
  account_id = self.data[:accounts].first
  user_id = self.data[:users].first

  job = {
    "accountid"     => account_id,
    "userid"        => user_id,
    "cmd"           => "com.cloud.api.commands.DetachVolumeCmd",
    "created"       => Time.now.iso8601,
    "jobid"         => job_id,
    "jobstatus"     => 1,
    "jobprocstatus" => 0,
    "jobresultcode" => 0,
    "jobresulttype" => "object",
    "jobresult"     =>
      {"volume"     => volume}
  }

  self.data[:jobs][job_id]= job

  {
    "detachvolumeresponse" => {
      "jobid" => job_id
    }
  }
end
list_async_jobs(options={}) click to toggle source
# File lib/fog/cloudstack/requests/compute/list_async_jobs.rb, line 19
def list_async_jobs(options={})
  # FIXME: support paging
  jobs = self.data[:jobs]
  {
    'listasyncjobsresponse' => {
      'count' => jobs.size,
      'asyncjobs' => jobs
    }
  }
end
list_disk_offerings(options={}) click to toggle source

TODO: add id, name filters and paging params

# File lib/fog/cloudstack/requests/compute/list_disk_offerings.rb, line 21
def list_disk_offerings(options={})
  disk_offerings = self.data[:disk_offerings]
  { "listdiskofferingsresponse" => { "count"=> disk_offerings.count, "diskoffering"=> disk_offerings.values } }
end
list_os_types(options={}) click to toggle source

TODO: add id, category_id filters and paging params

# File lib/fog/cloudstack/requests/compute/list_os_types.rb, line 21
def list_os_types(options={})
  os_types = self.data[:os_types]
  { "listostypesresponse" => { "count"=> os_types.count, "ostype"=> os_types.values } }
end
list_security_groups(options={}) click to toggle source
# File lib/fog/cloudstack/requests/compute/list_security_groups.rb, line 17
def list_security_groups(options={})
  security_groups = []
  if security_group_id = options['id']
    security_group = self.data[:security_groups][security_group_id]
    raise Fog::Compute::Cloudstack::BadRequest unless security_group
    security_groups = [security_group]
  else
    security_groups = self.data[:security_groups].values
  end

  {
    "listsecuritygroupsresponse" =>
    {
      "count"         => security_groups.size,
      "securitygroup" => security_groups
    }
  }
end
list_service_offerings(options={}) click to toggle source
# File lib/fog/cloudstack/requests/compute/list_service_offerings.rb, line 21
def list_service_offerings(options={})
  flavors = []
  if service_offering_id = options['id']
    flavor = self.data[:flavors][service_offering_id]
    raise Fog::Compute::Cloudstack::BadRequest unless flavor
    flavors = [flavor]
  else
    flavors = self.data[:flavors].values
  end

  {
    "listserviceofferingsresponse" =>
    {
      "count" => flavors.size,
      "serviceoffering"=> flavors
    }
  }
end
list_snapshots(options={}) click to toggle source
# File lib/fog/cloudstack/requests/compute/list_snapshots.rb, line 21
def list_snapshots(options={})
  snapshot_id = options.delete('id')
  if snapshot_id
    snapshots = [self.data[:snapshots][snapshot_id]]
  else
    snapshots = self.data[:snapshots].values
  end

  {
    'listsnapshotsresponse' => {
      'count' => snapshots.size,
      'snapshot' => snapshots
    }
  }
end
list_templates(options={}) click to toggle source
# File lib/fog/cloudstack/requests/compute/list_templates.rb, line 21
def list_templates(options={})
  templates = self.data[:images].values

  {
    "listtemplatesresponse" =>
      {
        "count" => templates.size,
        "template"=> templates
      }
  }
end
list_virtual_machines(options={}) click to toggle source
# File lib/fog/cloudstack/requests/compute/list_virtual_machines.rb, line 19
def list_virtual_machines(options={})
  {"listvirtualmachinesresponse" =>
    {"count" => self.data[:servers].values.size, "virtualmachine" => self.data[:servers].values}}
end
list_volumes(options={}) click to toggle source
# File lib/fog/cloudstack/requests/compute/list_volumes.rb, line 20
def list_volumes(options={})
  volume_id = options.delete('id')
  if volume_id
    volumes = [self.data[:volumes][volume_id]]
  else
    volumes = self.data[:volumes].values
  end

  {
    'listvolumesresponse' => {
      'count' => volumes.size,
      'volume' => volumes
    }
  }
end
list_zones(options={}) click to toggle source
# File lib/fog/cloudstack/requests/compute/list_zones.rb, line 20
def list_zones(options={})
  zones = self.data[:zones].values

  {
    "listzonesresponse"=>
    {
      "count" => zones.size,
      "zone" => zones
    }
  }
end
query_async_job_result(options={}) click to toggle source
# File lib/fog/cloudstack/requests/compute/query_async_job_result.rb, line 17
def query_async_job_result(options={})
  unless job_id = options['jobid']
    raise Fog::Compute::Cloudstack::BadRequest.new("Missing required parameter jobid")
  end

  unless job = self.data[:jobs][job_id]
    raise Fog::Compute::Cloudstack::BadRequest.new("Unknown job id #{job_id}")
  end

  {'queryasyncjobresultresponse' => job }
end
reboot_virtual_machine(options={}) click to toggle source
# File lib/fog/cloudstack/requests/compute/reboot_virtual_machine.rb, line 20
def reboot_virtual_machine(options={})
  job_id = Fog::Cloudstack.uuid
  {
    "rebootvirtualmachineresponse" => {
      "jobid" => job_id
    }
  }
end
register_template(options={}) click to toggle source
# File lib/fog/cloudstack/requests/compute/register_template.rb, line 20
def register_template(options={})
  mock_template_id = self.data[:images].keys.first
  registered_template = self.data[:images][mock_template_id]

  {
      'registertemplateresponse' =>
      {
          'count' => 1,
          'template' => [registered_template]
      }
  }
end
reset_data() click to toggle source
# File lib/fog/cloudstack/compute.rb, line 506
def reset_data
  self.class.data.delete(@cloudstack_api_key)
end
revoke_security_group_egress(options={}) click to toggle source
# File lib/fog/cloudstack/requests/compute/revoke_security_group_egress.rb, line 14
def revoke_security_group_egress(options={})
  unless security_group_rule_id = options['id']
    raise Fog::Compute::Cloudstack::BadRequest.new('Unable to execute API command missing parameter id')
  end

  security_group = self.data[:security_groups].values.find do |group|
    (rule = (group['egressrule'] || []).find{|r| r['ruleid'] == security_group_rule_id}) && group['egressrule'].delete(rule)
  end

  job_id = Fog::Cloudstack.uuid
  job = {
    "cmd"           => "com.cloud.api.commands.revokeSecurityGroupEgress",
    "created"       => Time.now.iso8601,
    "jobid"         => job_id,
    "jobstatus"     => 1,
    "jobprocstatus" => 0,
    "jobresultcode" => 0,
    "jobresulttype" => "object",
    "jobresult"     => { "securitygroup" => security_group }
  }

  self.data[:jobs][job_id]= job

  {"revokesecuritygroupegress" => { "jobid" => job_id }}
end
revoke_security_group_ingress(options={}) click to toggle source
# File lib/fog/cloudstack/requests/compute/revoke_security_group_ingress.rb, line 17
def revoke_security_group_ingress(options={})
  unless security_group_rule_id = options['id']
    raise Fog::Compute::Cloudstack::BadRequest.new('Unable to execute API command missing parameter id')
  end

  security_group = self.data[:security_groups].values.find do |group|
    (rule = (group['ingressrule'] || []).find{|r| r['ruleid'] == security_group_rule_id}) && group['ingressrule'].delete(rule)
  end

  job_id = Fog::Cloudstack.uuid
  job = {
    "cmd"           => "com.cloud.api.commands.revokeSecurityGroupIngress",
    "created"       => Time.now.iso8601,
    "jobid"         => job_id,
    "jobstatus"     => 1,
    "jobprocstatus" => 0,
    "jobresultcode" => 0,
    "jobresulttype" => "object",
    "jobresult"     => { "securitygroup" => security_group }
  }

  self.data[:jobs][job_id]= job

  {"revokesecuritygroupingress" => { "jobid" => job_id }}
end

[Validate]

Generated with the Darkfish Rdoc Generator 2.