### Home Classes Methods

### In Files

- lib/fog/ecloud/compute.rb
- lib/fog/ecloud/requests/compute/get_group.rb
- lib/fog/ecloud/requests/compute/get_ssh_keys.rb
- lib/fog/ecloud/requests/compute/rows_delete.rb
- lib/fog/ecloud/requests/compute/get_templates.rb
- lib/fog/ecloud/requests/compute/get_public_ips.rb
- lib/fog/ecloud/requests/compute/get_admin_organization.rb
- lib/fog/ecloud/requests/compute/internet_service_create.rb
- lib/fog/ecloud/requests/compute/internet_service_delete.rb
- lib/fog/ecloud/requests/compute/get_servers.rb
- lib/fog/ecloud/requests/compute/get_layouts.rb
- lib/fog/ecloud/requests/compute/groups_delete.rb
- lib/fog/ecloud/requests/compute/get_hardware_configuration.rb
- lib/fog/ecloud/requests/compute/get_layout.rb
- lib/fog/ecloud/requests/compute/get_public_ip.rb
- lib/fog/ecloud/requests/compute/get_operating_system.rb
- lib/fog/ecloud/requests/compute/get_node.rb
- lib/fog/ecloud/requests/compute/virtual_machine_import.rb
- lib/fog/ecloud/requests/compute/get_organization.rb
- lib/fog/ecloud/requests/compute/node_service_create.rb
- lib/fog/ecloud/requests/compute/get_ssh_key.rb
- lib/fog/ecloud/requests/compute/node_service_delete.rb
- lib/fog/ecloud/requests/compute/virtual_machine_edit_assigned_ips.rb
- lib/fog/ecloud/requests/compute/get_rows.rb
- lib/fog/ecloud/requests/compute/virtual_machine_edit_hardware_configuration.rb
- lib/fog/ecloud/requests/compute/get_template.rb
- lib/fog/ecloud/requests/compute/virtual_machine_create_from_template.rb
- lib/fog/ecloud/requests/compute/get_ip_address.rb
- lib/fog/ecloud/requests/compute/virtual_machine_detach_disk.rb
- lib/fog/ecloud/requests/compute/get_compute_pools.rb
- lib/fog/ecloud/requests/compute/virtual_machine_attach_disk.rb
- lib/fog/ecloud/requests/compute/get_server.rb
- lib/fog/ecloud/requests/compute/get_environment.rb
- lib/fog/ecloud/requests/compute/get_compute_pool.rb
- lib/fog/ecloud/requests/compute/get_groups.rb
- lib/fog/ecloud/requests/compute/get_network.rb
- lib/fog/ecloud/requests/compute/get_virtual_machine_assigned_ips.rb
- lib/fog/ecloud/requests/compute/get_internet_services.rb
- lib/fog/ecloud/requests/compute/get_detached_disk.rb
- lib/fog/ecloud/requests/compute/get_detached_disks.rb
- lib/fog/ecloud/requests/compute/get_hardware_configurations.rb
- lib/fog/ecloud/requests/compute/virtual_machine_delete.rb
- lib/fog/ecloud/requests/compute/get_organizations.rb
- lib/fog/ecloud/requests/compute/get_internet_service.rb
- lib/fog/ecloud/requests/compute/get_task.rb
- lib/fog/ecloud/requests/compute/get_row.rb
- lib/fog/ecloud/requests/compute/get_operating_system_families.rb
- lib/fog/ecloud/requests/compute/get_networks.rb
- lib/fog/ecloud/requests/compute/get_nodes.rb

### Parent

Object

### Methods

- ::data
- ::new
- ::reset
- #data
- #deep_copy
- #get_admin_organization
- #get_compute_pool
- #get_compute_pools
- #get_detached_disk
- #get_detached_disks
- #get_environment
- #get_group
- #get_groups
- #get_hardware_configuration
- #get_hardware_configurations
- #get_internet_service
- #get_internet_services
- #get_ip_address
- #get_layout
- #get_layouts
- #get_network
- #get_networks
- #get_node
- #get_nodes
- #get_operating_system
- #get_operating_system_families
- #get_organization
- #get_organizations
- #get_public_ip
- #get_public_ips
- #get_row
- #get_server
- #get_servers
- #get_ssh_key
- #get_ssh_keys
- #get_task
- #get_template
- #get_templates
- #get_virtual_machine_assigned_ips
- #groups_delete
- #internet_service_create
- #internet_service_delete
- #node_service_create
- #node_service_delete
- #reset_data
- #response
- #rows_delete
- #virtual_machine_attach_disk
- #virtual_machine_create_from_template
- #virtual_machine_delete
- #virtual_machine_detach_disk
- #virtual_machine_edit_assigned_ips
- #virtual_machine_edit_hardware_configuration
- #virtual_machine_import

### Included Modules

- Fog::Compute::Ecloud::Shared

### Files

- README_HP.rdoc
- lorem.txt

### Class/Module Index

Quicksearch

- Fog
- Fog::AWS
- Fog::AWS::AutoScaling
- Fog::AWS::AutoScaling::Activities
- Fog::AWS::AutoScaling::Activity
- Fog::AWS::AutoScaling::Configuration
- Fog::AWS::AutoScaling::Configurations
- Fog::AWS::AutoScaling::Group
- Fog::AWS::AutoScaling::Groups
- Fog::AWS::AutoScaling::IdentifierTaken
- Fog::AWS::AutoScaling::Instance
- Fog::AWS::AutoScaling::Instances
- Fog::AWS::AutoScaling::Mock
- Fog::AWS::AutoScaling::Policies
- Fog::AWS::AutoScaling::Policy
- Fog::AWS::AutoScaling::Real
- Fog::AWS::AutoScaling::ResourceInUse
- Fog::AWS::AutoScaling::ValidationError
- Fog::AWS::CloudFormation
- Fog::AWS::CloudFormation::Mock
- Fog::AWS::CloudFormation::Real
- Fog::AWS::CloudWatch
- Fog::AWS::CloudWatch::Alarm
- Fog::AWS::CloudWatch::AlarmData
- Fog::AWS::CloudWatch::AlarmDatum
- Fog::AWS::CloudWatch::AlarmHistories
- Fog::AWS::CloudWatch::AlarmHistory
- Fog::AWS::CloudWatch::Alarms
- Fog::AWS::CloudWatch::Metric
- Fog::AWS::CloudWatch::MetricStatistic
- Fog::AWS::CloudWatch::MetricStatistics
- Fog::AWS::CloudWatch::Metrics
- Fog::AWS::CloudWatch::Mock
- Fog::AWS::CloudWatch::Real
- Fog::AWS::CredentialFetcher
- Fog::AWS::CredentialFetcher::ConnectionMethods
- Fog::AWS::CredentialFetcher::ServiceMethods
- Fog::AWS::DataPipeline
- Fog::AWS::DataPipeline::Mock
- Fog::AWS::DataPipeline::Pipeline
- Fog::AWS::DataPipeline::Pipelines
- Fog::AWS::DataPipeline::Real
- Fog::AWS::DynamoDB
- Fog::AWS::DynamoDB::Mock
- Fog::AWS::DynamoDB::Real
- Fog::AWS::ELB
- Fog::AWS::ELB::DuplicatePolicyName
- Fog::AWS::ELB::IdentifierTaken
- Fog::AWS::ELB::InvalidConfigurationRequest
- Fog::AWS::ELB::InvalidInstance
- Fog::AWS::ELB::Listener
- Fog::AWS::ELB::Listeners
- Fog::AWS::ELB::LoadBalancer
- Fog::AWS::ELB::LoadBalancers
- Fog::AWS::ELB::Mock
- Fog::AWS::ELB::Policies
- Fog::AWS::ELB::Policy
- Fog::AWS::ELB::PolicyNotFound
- Fog::AWS::ELB::PolicyTypeNotFound
- Fog::AWS::ELB::Real
- Fog::AWS::ELB::Throttled
- Fog::AWS::ELB::TooManyPolicies
- Fog::AWS::ELB::ValidationError
- Fog::AWS::EMR
- Fog::AWS::EMR::IdentifierTaken
- Fog::AWS::EMR::Mock
- Fog::AWS::EMR::Real
- Fog::AWS::ElasticBeanstalk
- Fog::AWS::ElasticBeanstalk::Application
- Fog::AWS::ElasticBeanstalk::Applications
- Fog::AWS::ElasticBeanstalk::Environment
- Fog::AWS::ElasticBeanstalk::Environments
- Fog::AWS::ElasticBeanstalk::Event
- Fog::AWS::ElasticBeanstalk::Events
- Fog::AWS::ElasticBeanstalk::InvalidParameterError
- Fog::AWS::ElasticBeanstalk::Mock
- Fog::AWS::ElasticBeanstalk::Real
- Fog::AWS::ElasticBeanstalk::Template
- Fog::AWS::ElasticBeanstalk::Templates
- Fog::AWS::ElasticBeanstalk::Version
- Fog::AWS::ElasticBeanstalk::Versions
- Fog::AWS::Elasticache
- Fog::AWS::Elasticache::Cluster
- Fog::AWS::Elasticache::Clusters
- Fog::AWS::Elasticache::IdentifierTaken
- Fog::AWS::Elasticache::InvalidInstance
- Fog::AWS::Elasticache::Mock
- Fog::AWS::Elasticache::ParameterGroup
- Fog::AWS::Elasticache::ParameterGroups
- Fog::AWS::Elasticache::Real
- Fog::AWS::Elasticache::SecurityGroup
- Fog::AWS::Elasticache::SecurityGroups
- Fog::AWS::Glacier
- Fog::AWS::Glacier::Archive
- Fog::AWS::Glacier::Archives
- Fog::AWS::Glacier::Job
- Fog::AWS::Glacier::Jobs
- Fog::AWS::Glacier::Mock
- Fog::AWS::Glacier::Real
- Fog::AWS::Glacier::TreeHash
- Fog::AWS::Glacier::Vault
- Fog::AWS::Glacier::Vaults
- Fog::AWS::IAM
- Fog::AWS::IAM::AccessKey
- Fog::AWS::IAM::AccessKeys
- Fog::AWS::IAM::EntityAlreadyExists
- Fog::AWS::IAM::KeyPairMismatch
- Fog::AWS::IAM::LimitExceeded
- Fog::AWS::IAM::MalformedCertificate
- Fog::AWS::IAM::Mock
- Fog::AWS::IAM::Policies
- Fog::AWS::IAM::Policy
- Fog::AWS::IAM::Real
- Fog::AWS::IAM::User
- Fog::AWS::IAM::Users
- Fog::AWS::IAM::ValidationError
- Fog::AWS::Mock
- Fog::AWS::RDS
- Fog::AWS::RDS::AuthorizationAlreadyExists
- Fog::AWS::RDS::IdentifierTaken
- Fog::AWS::RDS::Mock
- Fog::AWS::RDS::Parameter
- Fog::AWS::RDS::ParameterGroup
- Fog::AWS::RDS::ParameterGroups
- Fog::AWS::RDS::Parameters
- Fog::AWS::RDS::Real
- Fog::AWS::RDS::SecurityGroup
- Fog::AWS::RDS::SecurityGroups
- Fog::AWS::RDS::Server
- Fog::AWS::RDS::Servers
- Fog::AWS::RDS::Snapshot
- Fog::AWS::RDS::Snapshots
- Fog::AWS::RDS::SubnetGroup
- Fog::AWS::RDS::SubnetGroups
- Fog::AWS::SES
- Fog::AWS::SES::Mock
- Fog::AWS::SES::Real
- Fog::AWS::SNS
- Fog::AWS::SNS::Mock
- Fog::AWS::SNS::Real
- Fog::AWS::SQS
- Fog::AWS::SQS::Mock
- Fog::AWS::SQS::Real
- Fog::AWS::STS
- Fog::AWS::STS::EntityAlreadyExists
- Fog::AWS::STS::Mock
- Fog::AWS::STS::Real
- Fog::AWS::STS::ValidationError
- Fog::AWS::SignatureV4
- Fog::AWS::SimpleDB
- Fog::AWS::SimpleDB::Mock
- Fog::AWS::SimpleDB::Real
- Fog::Atmos
- Fog::Attributes
- Fog::Attributes::ClassMethods
- Fog::Attributes::InstanceMethods
- Fog::BareMetalCloud
- Fog::Bin
- Fog::Bluebox
- Fog::Bluebox::BLB
- Fog::Bluebox::BLB::LbApplication
- Fog::Bluebox::BLB::LbApplications
- Fog::Bluebox::BLB::LbBackend
- Fog::Bluebox::BLB::LbBackends
- Fog::Bluebox::BLB::LbService
- Fog::Bluebox::BLB::LbServices
- Fog::Bluebox::BLB::Mock
- Fog::Bluebox::BLB::Real
- Fog::Bluebox::DNS
- Fog::Bluebox::DNS::Mock
- Fog::Bluebox::DNS::Real
- Fog::Brightbox
- Fog::Brightbox::Compute
- Fog::Brightbox::Compute::ImageSelector
- Fog::Brightbox::OAuth2
- Fog::Brightbox::OAuth2::ClientCredentialsStrategy
- Fog::Brightbox::OAuth2::CredentialSet
- Fog::Brightbox::OAuth2::GrantTypeStrategy
- Fog::Brightbox::OAuth2::RefreshTokenStrategy
- Fog::Brightbox::OAuth2::UserCredentialsStrategy
- Fog::CDN
- Fog::CDN::AWS
- Fog::CDN::AWS::Distribution
- Fog::CDN::AWS::DistributionHelper
- Fog::CDN::AWS::Distributions
- Fog::CDN::AWS::DistributionsHelper
- Fog::CDN::AWS::Invalidation
- Fog::CDN::AWS::Invalidations
- Fog::CDN::AWS::Mock
- Fog::CDN::AWS::Real
- Fog::CDN::AWS::StreamingDistribution
- Fog::CDN::AWS::StreamingDistributions
- Fog::CDN::HP
- Fog::CDN::HP::Mock
- Fog::CDN::HP::Real
- Fog::CDN::HP::Utils
- Fog::CDN::Rackspace
- Fog::CDN::Rackspace::Base
- Fog::CDN::Rackspace::Mock
- Fog::CDN::Rackspace::Real
- Fog::Clodo
- Fog::Cloudstack
- Fog::Collection
- Fog::Compute
- Fog::Compute::AWS
- Fog::Compute::AWS::Address
- Fog::Compute::AWS::Addresses
- Fog::Compute::AWS::DhcpOption
- Fog::Compute::AWS::DhcpOptions
- Fog::Compute::AWS::Flavor
- Fog::Compute::AWS::Flavors
- Fog::Compute::AWS::Image
- Fog::Compute::AWS::Images
- Fog::Compute::AWS::InternetGateway
- Fog::Compute::AWS::InternetGateways
- Fog::Compute::AWS::KeyPair
- Fog::Compute::AWS::KeyPairs
- Fog::Compute::AWS::Mock
- Fog::Compute::AWS::NetworkInterface
- Fog::Compute::AWS::NetworkInterfaces
- Fog::Compute::AWS::Real
- Fog::Compute::AWS::SecurityGroup
- Fog::Compute::AWS::SecurityGroups
- Fog::Compute::AWS::Server
- Fog::Compute::AWS::Servers
- Fog::Compute::AWS::Snapshot
- Fog::Compute::AWS::Snapshots
- Fog::Compute::AWS::SpotRequest
- Fog::Compute::AWS::SpotRequests
- Fog::Compute::AWS::Subnet
- Fog::Compute::AWS::Subnets
- Fog::Compute::AWS::Tag
- Fog::Compute::AWS::Tags
- Fog::Compute::AWS::VPC
- Fog::Compute::AWS::Volume
- Fog::Compute::AWS::Volumes
- Fog::Compute::AWS::Vpcs
- Fog::Compute::BareMetalCloud
- Fog::Compute::BareMetalCloud::Mock
- Fog::Compute::BareMetalCloud::Real
- Fog::Compute::Bluebox
- Fog::Compute::Bluebox::BlockInstantiationError
- Fog::Compute::Bluebox::Flavor
- Fog::Compute::Bluebox::Flavors
- Fog::Compute::Bluebox::Image
- Fog::Compute::Bluebox::Images
- Fog::Compute::Bluebox::Location
- Fog::Compute::Bluebox::Locations
- Fog::Compute::Bluebox::Mock
- Fog::Compute::Bluebox::Real
- Fog::Compute::Bluebox::Server
- Fog::Compute::Bluebox::Servers
- Fog::Compute::Brightbox
- Fog::Compute::Brightbox::Account
- Fog::Compute::Brightbox::Accounts
- Fog::Compute::Brightbox::ApiClient
- Fog::Compute::Brightbox::ApiClients
- Fog::Compute::Brightbox::Application
- Fog::Compute::Brightbox::Applications
- Fog::Compute::Brightbox::CloudIp
- Fog::Compute::Brightbox::CloudIps
- Fog::Compute::Brightbox::FirewallPolicies
- Fog::Compute::Brightbox::FirewallPolicy
- Fog::Compute::Brightbox::FirewallRule
- Fog::Compute::Brightbox::FirewallRules
- Fog::Compute::Brightbox::Flavor
- Fog::Compute::Brightbox::Flavors
- Fog::Compute::Brightbox::Image
- Fog::Compute::Brightbox::Images
- Fog::Compute::Brightbox::LoadBalancer
- Fog::Compute::Brightbox::LoadBalancers
- Fog::Compute::Brightbox::Mock
- Fog::Compute::Brightbox::Real
- Fog::Compute::Brightbox::Server
- Fog::Compute::Brightbox::ServerGroup
- Fog::Compute::Brightbox::ServerGroups
- Fog::Compute::Brightbox::Servers
- Fog::Compute::Brightbox::Shared
- Fog::Compute::Brightbox::User
- Fog::Compute::Brightbox::Users
- Fog::Compute::Brightbox::Zone
- Fog::Compute::Brightbox::Zones
- Fog::Compute::Clodo
- Fog::Compute::Clodo::Image
- Fog::Compute::Clodo::Images
- Fog::Compute::Clodo::Mock
- Fog::Compute::Clodo::Real
- Fog::Compute::Clodo::Server
- Fog::Compute::Clodo::Servers
- Fog::Compute::Cloudstack
- Fog::Compute::Cloudstack::Address
- Fog::Compute::Cloudstack::BadRequest
- Fog::Compute::Cloudstack::DiskOffering
- Fog::Compute::Cloudstack::DiskOfferings
- Fog::Compute::Cloudstack::Flavor
- Fog::Compute::Cloudstack::Flavors
- Fog::Compute::Cloudstack::Image
- Fog::Compute::Cloudstack::Images
- Fog::Compute::Cloudstack::Job
- Fog::Compute::Cloudstack::Jobs
- Fog::Compute::Cloudstack::Mock
- Fog::Compute::Cloudstack::Real
- Fog::Compute::Cloudstack::SecurityGroup
- Fog::Compute::Cloudstack::SecurityGroupRule
- Fog::Compute::Cloudstack::SecurityGroupRules
- Fog::Compute::Cloudstack::SecurityGroups
- Fog::Compute::Cloudstack::Server
- Fog::Compute::Cloudstack::Servers
- Fog::Compute::Cloudstack::Snapshot
- Fog::Compute::Cloudstack::Snapshots
- Fog::Compute::Cloudstack::Unauthorized
- Fog::Compute::Cloudstack::Volume
- Fog::Compute::Cloudstack::Volumes
- Fog::Compute::Cloudstack::Zone
- Fog::Compute::Cloudstack::Zones
- Fog::Compute::DigitalOcean
- Fog::Compute::DigitalOcean::Flavor
- Fog::Compute::DigitalOcean::Flavors
- Fog::Compute::DigitalOcean::Image
- Fog::Compute::DigitalOcean::Images
- Fog::Compute::DigitalOcean::Mock
- Fog::Compute::DigitalOcean::Real
- Fog::Compute::DigitalOcean::Region
- Fog::Compute::DigitalOcean::Regions
- Fog::Compute::DigitalOcean::Server
- Fog::Compute::DigitalOcean::Servers
- Fog::Compute::DigitalOcean::SshKey
- Fog::Compute::DigitalOcean::SshKeys
- Fog::Compute::Ecloud
- Fog::Compute::Ecloud::AdminOrganization
- Fog::Compute::Ecloud::AdminOrganizations
- Fog::Compute::Ecloud::ApiKey
- Fog::Compute::Ecloud::ApiKeys
- Fog::Compute::Ecloud::Association
- Fog::Compute::Ecloud::Associations
- Fog::Compute::Ecloud::AuthenticationLevel
- Fog::Compute::Ecloud::AuthenticationLevels
- Fog::Compute::Ecloud::BackupInternetService
- Fog::Compute::Ecloud::BackupInternetServices
- Fog::Compute::Ecloud::Catalog
- Fog::Compute::Ecloud::CatalogConfiguration
- Fog::Compute::Ecloud::CatalogConfigurations
- Fog::Compute::Ecloud::CatalogItem
- Fog::Compute::Ecloud::ComputePool
- Fog::Compute::Ecloud::ComputePools
- Fog::Compute::Ecloud::CpuUsageDetail
- Fog::Compute::Ecloud::CpuUsageDetailSummary
- Fog::Compute::Ecloud::DetachedDisk
- Fog::Compute::Ecloud::DetachedDisks
- Fog::Compute::Ecloud::Environment
- Fog::Compute::Ecloud::Environments
- Fog::Compute::Ecloud::Environments::Vdcs
- Fog::Compute::Ecloud::FirewallAcl
- Fog::Compute::Ecloud::FirewallAcls
- Fog::Compute::Ecloud::Group
- Fog::Compute::Ecloud::Groups
- Fog::Compute::Ecloud::GuestProcess
- Fog::Compute::Ecloud::GuestProcesses
- Fog::Compute::Ecloud::HardwareConfiguration
- Fog::Compute::Ecloud::HardwareConfigurations
- Fog::Compute::Ecloud::InternetService
- Fog::Compute::Ecloud::InternetServices
- Fog::Compute::Ecloud::IpAddress
- Fog::Compute::Ecloud::IpAddresses
- Fog::Compute::Ecloud::Layout
- Fog::Compute::Ecloud::Layouts
- Fog::Compute::Ecloud::Location
- Fog::Compute::Ecloud::Locations
- Fog::Compute::Ecloud::LoginBanner
- Fog::Compute::Ecloud::LoginBanners
- Fog::Compute::Ecloud::MemoryUsageDetail
- Fog::Compute::Ecloud::MemoryUsageDetailSummary
- Fog::Compute::Ecloud::Mock
- Fog::Compute::Ecloud::Monitor
- Fog::Compute::Ecloud::Monitors
- Fog::Compute::Ecloud::Network
- Fog::Compute::Ecloud::Networks
- Fog::Compute::Ecloud::Node
- Fog::Compute::Ecloud::Nodes
- Fog::Compute::Ecloud::OperatingSystem
- Fog::Compute::Ecloud::OperatingSystemFamilies
- Fog::Compute::Ecloud::OperatingSystemFamily
- Fog::Compute::Ecloud::OperatingSystems
- Fog::Compute::Ecloud::Organization
- Fog::Compute::Ecloud::Organizations
- Fog::Compute::Ecloud::PasswordComplexityRule
- Fog::Compute::Ecloud::PasswordComplexityRules
- Fog::Compute::Ecloud::PhysicalDevice
- Fog::Compute::Ecloud::PhysicalDevices
- Fog::Compute::Ecloud::PublicIp
- Fog::Compute::Ecloud::PublicIps
- Fog::Compute::Ecloud::Real
- Fog::Compute::Ecloud::Rnat
- Fog::Compute::Ecloud::Rnats
- Fog::Compute::Ecloud::Role
- Fog::Compute::Ecloud::Roles
- Fog::Compute::Ecloud::Row
- Fog::Compute::Ecloud::Rows
- Fog::Compute::Ecloud::Server
- Fog::Compute::Ecloud::ServerConfigurationOption
- Fog::Compute::Ecloud::ServerConfigurationOptions
- Fog::Compute::Ecloud::Servers
- Fog::Compute::Ecloud::Shared
- Fog::Compute::Ecloud::SshKey
- Fog::Compute::Ecloud::SshKeys
- Fog::Compute::Ecloud::StorageUsageDetail
- Fog::Compute::Ecloud::StorageUsageDetailSummary
- Fog::Compute::Ecloud::SupportTicket
- Fog::Compute::Ecloud::SupportTickets
- Fog::Compute::Ecloud::Tag
- Fog::Compute::Ecloud::Tags
- Fog::Compute::Ecloud::Task
- Fog::Compute::Ecloud::Tasks
- Fog::Compute::Ecloud::Template
- Fog::Compute::Ecloud::Templates
- Fog::Compute::Ecloud::TrustedNetworkGroup
- Fog::Compute::Ecloud::TrustedNetworkGroups
- Fog::Compute::Ecloud::User
- Fog::Compute::Ecloud::Users
- Fog::Compute::Ecloud::Vdc
- Fog::Compute::Ecloud::VirtualMachineAssignedIp
- Fog::Compute::Ecloud::VirtualMachineAssignedIps
- Fog::Compute::Glesys
- Fog::Compute::Glesys::Ip
- Fog::Compute::Glesys::Ips
- Fog::Compute::Glesys::Mock
- Fog::Compute::Glesys::Real
- Fog::Compute::Glesys::Server
- Fog::Compute::Glesys::Servers
- Fog::Compute::Glesys::Template
- Fog::Compute::Glesys::Templates
- Fog::Compute::GoGrid
- Fog::Compute::GoGrid::BlockInstantiationError
- Fog::Compute::GoGrid::Image
- Fog::Compute::GoGrid::Images
- Fog::Compute::GoGrid::Mock
- Fog::Compute::GoGrid::Password
- Fog::Compute::GoGrid::Passwords
- Fog::Compute::GoGrid::Real
- Fog::Compute::GoGrid::Server
- Fog::Compute::GoGrid::Servers
- Fog::Compute::Google
- Fog::Compute::Google::Flavor
- Fog::Compute::Google::Flavors
- Fog::Compute::Google::Image
- Fog::Compute::Google::Images
- Fog::Compute::Google::Mock
- Fog::Compute::Google::Real
- Fog::Compute::Google::Server
- Fog::Compute::Google::Servers
- Fog::Compute::HP
- Fog::Compute::HP::Address
- Fog::Compute::HP::Addresses
- Fog::Compute::HP::Flavor
- Fog::Compute::HP::Flavors
- Fog::Compute::HP::Image
- Fog::Compute::HP::Images
- Fog::Compute::HP::KeyPair
- Fog::Compute::HP::KeyPairs
- Fog::Compute::HP::Meta
- Fog::Compute::HP::MetaParent
- Fog::Compute::HP::Metadata
- Fog::Compute::HP::Mock
- Fog::Compute::HP::Real
- Fog::Compute::HP::SecurityGroup
- Fog::Compute::HP::SecurityGroups
- Fog::Compute::HP::Server
- Fog::Compute::HP::Servers
- Fog::Compute::HP::Utils
- Fog::Compute::IBM
- Fog::Compute::IBM::Address
- Fog::Compute::IBM::Addresses
- Fog::Compute::IBM::Image
- Fog::Compute::IBM::Images
- Fog::Compute::IBM::InstanceType
- Fog::Compute::IBM::InstanceTypes
- Fog::Compute::IBM::Key
- Fog::Compute::IBM::Keys
- Fog::Compute::IBM::Location
- Fog::Compute::IBM::Locations
- Fog::Compute::IBM::Mock
- Fog::Compute::IBM::Real
- Fog::Compute::IBM::Server
- Fog::Compute::IBM::Servers
- Fog::Compute::IBM::Vlan
- Fog::Compute::IBM::Vlans
- Fog::Compute::Joyent
- Fog::Compute::Joyent::Errors
- Fog::Compute::Joyent::Errors::BadRequest
- Fog::Compute::Joyent::Errors::Conflict
- Fog::Compute::Joyent::Errors::Forbidden
- Fog::Compute::Joyent::Errors::MessageParserMixin
- Fog::Compute::Joyent::Errors::MethodNotAllowed
- Fog::Compute::Joyent::Errors::NotAcceptable
- Fog::Compute::Joyent::Errors::NotFound
- Fog::Compute::Joyent::Errors::PolicyNotForfilled
- Fog::Compute::Joyent::Errors::RequestEntityTooLarge
- Fog::Compute::Joyent::Errors::RetryWith
- Fog::Compute::Joyent::Errors::ServiceUnavailable
- Fog::Compute::Joyent::Errors::Unauthorized
- Fog::Compute::Joyent::Errors::UnsupportedMediaType
- Fog::Compute::Joyent::Flavor
- Fog::Compute::Joyent::Flavors
- Fog::Compute::Joyent::Image
- Fog::Compute::Joyent::Images
- Fog::Compute::Joyent::Key
- Fog::Compute::Joyent::Keys
- Fog::Compute::Joyent::Mock
- Fog::Compute::Joyent::Real
- Fog::Compute::Joyent::Server
- Fog::Compute::Joyent::Servers
- Fog::Compute::Joyent::Snapshot
- Fog::Compute::Joyent::Snapshots
- Fog::Compute::Libvirt
- Fog::Compute::Libvirt::Interface
- Fog::Compute::Libvirt::Interfaces
- Fog::Compute::Libvirt::Mock
- Fog::Compute::Libvirt::Network
- Fog::Compute::Libvirt::Networks
- Fog::Compute::Libvirt::Nic
- Fog::Compute::Libvirt::Nics
- Fog::Compute::Libvirt::Node
- Fog::Compute::Libvirt::Nodes
- Fog::Compute::Libvirt::Pool
- Fog::Compute::Libvirt::Pools
- Fog::Compute::Libvirt::Real
- Fog::Compute::Libvirt::Server
- Fog::Compute::Libvirt::Servers
- Fog::Compute::Libvirt::Shared
- Fog::Compute::Libvirt::Volume
- Fog::Compute::Libvirt::Volumes
- Fog::Compute::LibvirtUtil
- Fog::Compute::LibvirtUtil::URI
- Fog::Compute::Linode
- Fog::Compute::Linode::DataCenter
- Fog::Compute::Linode::DataCenters
- Fog::Compute::Linode::Disk
- Fog::Compute::Linode::Disks
- Fog::Compute::Linode::Flavor
- Fog::Compute::Linode::Flavors
- Fog::Compute::Linode::Image
- Fog::Compute::Linode::Images
- Fog::Compute::Linode::Ip
- Fog::Compute::Linode::Ips
- Fog::Compute::Linode::Kernel
- Fog::Compute::Linode::Kernels
- Fog::Compute::Linode::Mock
- Fog::Compute::Linode::Real
- Fog::Compute::Linode::Server
- Fog::Compute::Linode::Servers
- Fog::Compute::Linode::StackScript
- Fog::Compute::Linode::StackScripts
- Fog::Compute::Ninefold
- Fog::Compute::Ninefold::Address
- Fog::Compute::Ninefold::Addresses
- Fog::Compute::Ninefold::Flavor
- Fog::Compute::Ninefold::Flavors
- Fog::Compute::Ninefold::Image
- Fog::Compute::Ninefold::Images
- Fog::Compute::Ninefold::IpForwardingRule
- Fog::Compute::Ninefold::IpForwardingRules
- Fog::Compute::Ninefold::Mock
- Fog::Compute::Ninefold::Real
- Fog::Compute::Ninefold::Server
- Fog::Compute::Ninefold::Servers
- Fog::Compute::OpenStack
- Fog::Compute::OpenStack::Address
- Fog::Compute::OpenStack::Addresses
- Fog::Compute::OpenStack::Flavor
- Fog::Compute::OpenStack::Flavors
- Fog::Compute::OpenStack::Host
- Fog::Compute::OpenStack::Hosts
- Fog::Compute::OpenStack::Image
- Fog::Compute::OpenStack::Images
- Fog::Compute::OpenStack::KeyPair
- Fog::Compute::OpenStack::KeyPairs
- Fog::Compute::OpenStack::MetaParent
- Fog::Compute::OpenStack::Metadata
- Fog::Compute::OpenStack::Metadatum
- Fog::Compute::OpenStack::Mock
- Fog::Compute::OpenStack::Network
- Fog::Compute::OpenStack::Networks
- Fog::Compute::OpenStack::Real
- Fog::Compute::OpenStack::SecurityGroup
- Fog::Compute::OpenStack::SecurityGroups
- Fog::Compute::OpenStack::Server
- Fog::Compute::OpenStack::Servers
- Fog::Compute::OpenStack::Snapshot
- Fog::Compute::OpenStack::Snapshots
- Fog::Compute::OpenStack::Tenant
- Fog::Compute::OpenStack::Tenants
- Fog::Compute::OpenStack::Volume
- Fog::Compute::OpenStack::Volumes
- Fog::Compute::Ovirt
- Fog::Compute::Ovirt::Cluster
- Fog::Compute::Ovirt::Clusters
- Fog::Compute::Ovirt::Interface
- Fog::Compute::Ovirt::Interfaces
- Fog::Compute::Ovirt::Mock
- Fog::Compute::Ovirt::Quota
- Fog::Compute::Ovirt::Quotas
- Fog::Compute::Ovirt::Real
- Fog::Compute::Ovirt::Server
- Fog::Compute::Ovirt::Servers
- Fog::Compute::Ovirt::Shared
- Fog::Compute::Ovirt::Template
- Fog::Compute::Ovirt::Templates
- Fog::Compute::Ovirt::Volume
- Fog::Compute::Ovirt::Volumes
- Fog::Compute::Rackspace
- Fog::Compute::Rackspace::Flavor
- Fog::Compute::Rackspace::Flavors
- Fog::Compute::Rackspace::Image
- Fog::Compute::Rackspace::Images
- Fog::Compute::Rackspace::Mock
- Fog::Compute::Rackspace::Real
- Fog::Compute::Rackspace::Server
- Fog::Compute::Rackspace::Servers
- Fog::Compute::RackspaceV2
- Fog::Compute::RackspaceV2::Attachment
- Fog::Compute::RackspaceV2::Attachments
- Fog::Compute::RackspaceV2::BadRequest
- Fog::Compute::RackspaceV2::Flavor
- Fog::Compute::RackspaceV2::Flavors
- Fog::Compute::RackspaceV2::Image
- Fog::Compute::RackspaceV2::Images
- Fog::Compute::RackspaceV2::InternalServerError
- Fog::Compute::RackspaceV2::InvalidImageStateException
- Fog::Compute::RackspaceV2::InvalidServerStateException
- Fog::Compute::RackspaceV2::InvalidStateException
- Fog::Compute::RackspaceV2::MetaParent
- Fog::Compute::RackspaceV2::Metadata
- Fog::Compute::RackspaceV2::Metadatum
- Fog::Compute::RackspaceV2::Mock
- Fog::Compute::RackspaceV2::Network
- Fog::Compute::RackspaceV2::Networks
- Fog::Compute::RackspaceV2::Real
- Fog::Compute::RackspaceV2::Server
- Fog::Compute::RackspaceV2::Servers
- Fog::Compute::RackspaceV2::ServiceError
- Fog::Compute::Server
- Fog::Compute::Serverlove
- Fog::Compute::Serverlove::Image
- Fog::Compute::Serverlove::Images
- Fog::Compute::Serverlove::Mock
- Fog::Compute::Serverlove::PasswordGenerator
- Fog::Compute::Serverlove::Real
- Fog::Compute::Serverlove::Server
- Fog::Compute::Serverlove::Servers
- Fog::Compute::StormOnDemand
- Fog::Compute::StormOnDemand::Balancer
- Fog::Compute::StormOnDemand::Balancers
- Fog::Compute::StormOnDemand::Config
- Fog::Compute::StormOnDemand::Configs
- Fog::Compute::StormOnDemand::Image
- Fog::Compute::StormOnDemand::Images
- Fog::Compute::StormOnDemand::Mock
- Fog::Compute::StormOnDemand::PrivateIp
- Fog::Compute::StormOnDemand::PrivateIps
- Fog::Compute::StormOnDemand::Real
- Fog::Compute::StormOnDemand::Server
- Fog::Compute::StormOnDemand::Servers
- Fog::Compute::StormOnDemand::Stat
- Fog::Compute::StormOnDemand::Stats
- Fog::Compute::StormOnDemand::Template
- Fog::Compute::StormOnDemand::Templates
- Fog::Compute::Vmfusion
- Fog::Compute::Vmfusion::Mock
- Fog::Compute::Vmfusion::Real
- Fog::Compute::Vmfusion::Server
- Fog::Compute::Vmfusion::Servers
- Fog::Compute::Voxel
- Fog::Compute::Voxel::Image
- Fog::Compute::Voxel::Images
- Fog::Compute::Voxel::Mock
- Fog::Compute::Voxel::Real
- Fog::Compute::Voxel::Server
- Fog::Compute::Voxel::Servers
- Fog::Compute::Vsphere
- Fog::Compute::Vsphere::Cluster
- Fog::Compute::Vsphere::Clusters
- Fog::Compute::Vsphere::Customfield
- Fog::Compute::Vsphere::Customfields
- Fog::Compute::Vsphere::Customvalue
- Fog::Compute::Vsphere::Customvalues
- Fog::Compute::Vsphere::Datacenter
- Fog::Compute::Vsphere::Datacenters
- Fog::Compute::Vsphere::Datastore
- Fog::Compute::Vsphere::Datastores
- Fog::Compute::Vsphere::Folder
- Fog::Compute::Vsphere::Folders
- Fog::Compute::Vsphere::Interface
- Fog::Compute::Vsphere::Interfaces
- Fog::Compute::Vsphere::Mock
- Fog::Compute::Vsphere::Network
- Fog::Compute::Vsphere::Networks
- Fog::Compute::Vsphere::Real
- Fog::Compute::Vsphere::ResourcePool
- Fog::Compute::Vsphere::ResourcePools
- Fog::Compute::Vsphere::Server
- Fog::Compute::Vsphere::Servers
- Fog::Compute::Vsphere::Shared
- Fog::Compute::Vsphere::Template
- Fog::Compute::Vsphere::Templates
- Fog::Compute::Vsphere::Volume
- Fog::Compute::Vsphere::Volumes
- Fog::Compute::XenServer
- Fog::Compute::XenServer::GuestMetrics
- Fog::Compute::XenServer::Host
- Fog::Compute::XenServer::HostCpu
- Fog::Compute::XenServer::HostMetrics
- Fog::Compute::XenServer::Hosts
- Fog::Compute::XenServer::Mock
- Fog::Compute::XenServer::Network
- Fog::Compute::XenServer::Networks
- Fog::Compute::XenServer::PBD
- Fog::Compute::XenServer::PIF
- Fog::Compute::XenServer::Pbds
- Fog::Compute::XenServer::Pifs
- Fog::Compute::XenServer::Pool
- Fog::Compute::XenServer::Pools
- Fog::Compute::XenServer::Real
- Fog::Compute::XenServer::Server
- Fog::Compute::XenServer::Servers
- Fog::Compute::XenServer::StorageRepositories
- Fog::Compute::XenServer::StorageRepository
- Fog::Compute::XenServer::VBD
- Fog::Compute::XenServer::VDI
- Fog::Compute::XenServer::VIF
- Fog::Compute::XenServer::VLAN
- Fog::Compute::XenServer::VbdMetrics
- Fog::Compute::XenServer::Vbds
- Fog::Compute::XenServer::Vdis
- Fog::Compute::XenServer::Vifs
- Fog::Compute::XenServer::Vlans
- Fog::Connection
- Fog::Core
- Fog::Core::DeprecatedConnectionAccessors
- Fog::CurrentMachine
- Fog::DNS
- Fog::DNS::AWS
- Fog::DNS::AWS::Mock
- Fog::DNS::AWS::Real
- Fog::DNS::AWS::Record
- Fog::DNS::AWS::Records
- Fog::DNS::AWS::Zone
- Fog::DNS::AWS::Zones
- Fog::DNS::Bluebox
- Fog::DNS::Bluebox::Mock
- Fog::DNS::Bluebox::Real
- Fog::DNS::Bluebox::Record
- Fog::DNS::Bluebox::Records
- Fog::DNS::Bluebox::Zone
- Fog::DNS::Bluebox::Zones
- Fog::DNS::DNSMadeEasy
- Fog::DNS::DNSMadeEasy::Mock
- Fog::DNS::DNSMadeEasy::Real
- Fog::DNS::DNSMadeEasy::Record
- Fog::DNS::DNSMadeEasy::Records
- Fog::DNS::DNSMadeEasy::Zone
- Fog::DNS::DNSMadeEasy::Zones
- Fog::DNS::DNSimple
- Fog::DNS::DNSimple::Mock
- Fog::DNS::DNSimple::Real
- Fog::DNS::DNSimple::Record
- Fog::DNS::DNSimple::Records
- Fog::DNS::DNSimple::Zone
- Fog::DNS::DNSimple::Zones
- Fog::DNS::Dreamhost
- Fog::DNS::Dreamhost::Mock
- Fog::DNS::Dreamhost::Real
- Fog::DNS::Dreamhost::Record
- Fog::DNS::Dreamhost::Records
- Fog::DNS::Dreamhost::Zone
- Fog::DNS::Dreamhost::Zones
- Fog::DNS::Dynect
- Fog::DNS::Dynect::JobIncomplete
- Fog::DNS::Dynect::Mock
- Fog::DNS::Dynect::Real
- Fog::DNS::Dynect::Record
- Fog::DNS::Dynect::Records
- Fog::DNS::Dynect::Zone
- Fog::DNS::Dynect::Zones
- Fog::DNS::Linode
- Fog::DNS::Linode::Mock
- Fog::DNS::Linode::Real
- Fog::DNS::Linode::Record
- Fog::DNS::Linode::Records
- Fog::DNS::Linode::Zone
- Fog::DNS::Linode::Zones
- Fog::DNS::Rackspace
- Fog::DNS::Rackspace::Callback
- Fog::DNS::Rackspace::CallbackError
- Fog::DNS::Rackspace::Mock
- Fog::DNS::Rackspace::Real
- Fog::DNS::Rackspace::Record
- Fog::DNS::Rackspace::Records
- Fog::DNS::Rackspace::Zone
- Fog::DNS::Rackspace::Zones
- Fog::DNS::Zerigo
- Fog::DNS::Zerigo::Mock
- Fog::DNS::Zerigo::Real
- Fog::DNS::Zerigo::Record
- Fog::DNS::Zerigo::Records
- Fog::DNS::Zerigo::Zone
- Fog::DNS::Zerigo::Zones
- Fog::DNSMadeEasy
- Fog::DNSimple
- Fog::Deprecation
- Fog::DigitalOcean
- Fog::Dreamhost
- Fog::Dynect
- Fog::Dynect::Mock
- Fog::Ecloud
- Fog::Ecloud::Collection
- Fog::Ecloud::MockDataClasses
- Fog::Ecloud::MockDataClasses::Base
- Fog::Ecloud::MockDataClasses::MockBackupInternetService
- Fog::Ecloud::MockDataClasses::MockCatalog
- Fog::Ecloud::MockDataClasses::MockCatalogItem
- Fog::Ecloud::MockDataClasses::MockCatalogItemCustomization
- Fog::Ecloud::MockDataClasses::MockCatalogItemVappTemplate
- Fog::Ecloud::MockDataClasses::MockData
- Fog::Ecloud::MockDataClasses::MockFirewallAcls
- Fog::Ecloud::MockDataClasses::MockNetwork
- Fog::Ecloud::MockDataClasses::MockNetworkExtensions
- Fog::Ecloud::MockDataClasses::MockNetworkIp
- Fog::Ecloud::MockDataClasses::MockNetworkIps
- Fog::Ecloud::MockDataClasses::MockOrganization
- Fog::Ecloud::MockDataClasses::MockPublicIp
- Fog::Ecloud::MockDataClasses::MockPublicIpInternetService
- Fog::Ecloud::MockDataClasses::MockPublicIpInternetServiceNode
- Fog::Ecloud::MockDataClasses::MockPublicIpInternetServiceNodes
- Fog::Ecloud::MockDataClasses::MockPublicIpInternetServices
- Fog::Ecloud::MockDataClasses::MockPublicIps
- Fog::Ecloud::MockDataClasses::MockTaskList
- Fog::Ecloud::MockDataClasses::MockVdc
- Fog::Ecloud::MockDataClasses::MockVdcInternetServices
- Fog::Ecloud::MockDataClasses::MockVersion
- Fog::Ecloud::MockDataClasses::MockVirtualMachine
- Fog::Ecloud::MockDataClasses::MockVirtualMachineDisk
- Fog::Ecloud::MockDataClasses::MockVirtualMachineDisks
- Fog::Ecloud::Model
- Fog::Errors
- Fog::Errors::Error
- Fog::Errors::LoadError
- Fog::Errors::MockNotImplemented
- Fog::Errors::NotFound
- Fog::Errors::NotImplemented
- Fog::Errors::TimeoutError
- Fog::Glesys
- Fog::GoGrid
- Fog::Google
- Fog::Google::Mock
- Fog::Google::Storage
- Fog::Google::Storage::Mock
- Fog::Google::Storage::Real
- Fog::HMAC
- Fog::HP
- Fog::HP::BlockStorage
- Fog::HP::BlockStorage::BootableVolumes
- Fog::HP::BlockStorage::Mock
- Fog::HP::BlockStorage::Real
- Fog::HP::BlockStorage::Snapshot
- Fog::HP::BlockStorage::Snapshots
- Fog::HP::BlockStorage::Utils
- Fog::HP::BlockStorage::Volume
- Fog::HP::BlockStorage::Volumes
- Fog::HP::Errors
- Fog::HP::Errors::BadRequest
- Fog::HP::Errors::Conflict
- Fog::HP::Errors::Forbidden
- Fog::HP::Errors::InternalServerError
- Fog::HP::Errors::NotFound
- Fog::HP::Errors::ServiceError
- Fog::HP::Errors::ServiceUnavailable
- Fog::HP::Mock
- Fog::IBM
- Fog::IBM::Connection
- Fog::IBM::Mock
- Fog::Identity
- Fog::Identity::OpenStack
- Fog::Identity::OpenStack::Ec2Credential
- Fog::Identity::OpenStack::Ec2Credentials
- Fog::Identity::OpenStack::Mock
- Fog::Identity::OpenStack::Real
- Fog::Identity::OpenStack::Role
- Fog::Identity::OpenStack::Roles
- Fog::Identity::OpenStack::Tenant
- Fog::Identity::OpenStack::Tenants
- Fog::Identity::OpenStack::User
- Fog::Identity::OpenStack::Users
- Fog::Image
- Fog::Image::OpenStack
- Fog::Image::OpenStack::Image
- Fog::Image::OpenStack::Images
- Fog::Image::OpenStack::Mock
- Fog::Image::OpenStack::Real
- Fog::InternetArchive
- Fog::InternetArchive::Mock
- Fog::InternetArchive::SignatureV4
- Fog::JSON
- Fog::JSON::LegacyJSON
- Fog::JSON::LoadError
- Fog::JSON::NewJSON
- Fog::Joyent
- Fog::Libvirt
- Fog::Linode
- Fog::Local
- Fog::Logger
- Fog::Mock
- Fog::Model
- Fog::Network
- Fog::Network::OpenStack
- Fog::Network::OpenStack::FloatingIp
- Fog::Network::OpenStack::FloatingIps
- Fog::Network::OpenStack::Mock
- Fog::Network::OpenStack::Network
- Fog::Network::OpenStack::Networks
- Fog::Network::OpenStack::Port
- Fog::Network::OpenStack::Ports
- Fog::Network::OpenStack::Real
- Fog::Network::OpenStack::Router
- Fog::Network::OpenStack::Routers
- Fog::Network::OpenStack::Subnet
- Fog::Network::OpenStack::Subnets
- Fog::Ninefold
- Fog::OpenStack
- Fog::OpenStack::Errors
- Fog::OpenStack::Errors::BadRequest
- Fog::OpenStack::Errors::ServiceError
- Fog::OpenStack::Errors::ServiceUnavailable
- Fog::Ovirt
- Fog::Ovirt::Errors
- Fog::Ovirt::Errors::NotFound
- Fog::Ovirt::Errors::SecurityError
- Fog::Ovirt::Errors::ServiceError
- Fog::Parsers
- Fog::Parsers::AWS
- Fog::Parsers::AWS::AutoScaling
- Fog::Parsers::AWS::AutoScaling::Basic
- Fog::Parsers::AWS::AutoScaling::DescribeAdjustmentTypes
- Fog::Parsers::AWS::AutoScaling::DescribeAutoScalingGroups
- Fog::Parsers::AWS::AutoScaling::DescribeAutoScalingInstances
- Fog::Parsers::AWS::AutoScaling::DescribeAutoScalingNotificationTypes
- Fog::Parsers::AWS::AutoScaling::DescribeLaunchConfigurations
- Fog::Parsers::AWS::AutoScaling::DescribeMetricCollectionTypes
- Fog::Parsers::AWS::AutoScaling::DescribeNotificationConfigurations
- Fog::Parsers::AWS::AutoScaling::DescribePolicies
- Fog::Parsers::AWS::AutoScaling::DescribeScalingActivities
- Fog::Parsers::AWS::AutoScaling::DescribeScalingProcessTypes
- Fog::Parsers::AWS::AutoScaling::DescribeScheduledActions
- Fog::Parsers::AWS::AutoScaling::DescribeTags
- Fog::Parsers::AWS::AutoScaling::DescribeTerminationPolicyTypes
- Fog::Parsers::AWS::AutoScaling::PutNotificationConfiguration
- Fog::Parsers::AWS::AutoScaling::PutScalingPolicy
- Fog::Parsers::AWS::AutoScaling::TerminateInstanceInAutoScalingGroup
- Fog::Parsers::AWS::CloudFormation
- Fog::Parsers::AWS::CloudFormation::Basic
- Fog::Parsers::AWS::CloudFormation::CreateStack
- Fog::Parsers::AWS::CloudFormation::DescribeStackEvents
- Fog::Parsers::AWS::CloudFormation::DescribeStackResources
- Fog::Parsers::AWS::CloudFormation::DescribeStacks
- Fog::Parsers::AWS::CloudFormation::GetTemplate
- Fog::Parsers::AWS::CloudFormation::UpdateStack
- Fog::Parsers::AWS::CloudFormation::ValidateTemplate
- Fog::Parsers::AWS::CloudWatch
- Fog::Parsers::AWS::CloudWatch::DeleteAlarms
- Fog::Parsers::AWS::CloudWatch::DescribeAlarmHistory
- Fog::Parsers::AWS::CloudWatch::DescribeAlarms
- Fog::Parsers::AWS::CloudWatch::DescribeAlarmsForMetric
- Fog::Parsers::AWS::CloudWatch::DisableAlarmActions
- Fog::Parsers::AWS::CloudWatch::EnableAlarmActions
- Fog::Parsers::AWS::CloudWatch::GetMetricStatistics
- Fog::Parsers::AWS::CloudWatch::ListMetrics
- Fog::Parsers::AWS::CloudWatch::PutMetricAlarm
- Fog::Parsers::AWS::CloudWatch::PutMetricData
- Fog::Parsers::AWS::CloudWatch::SetAlarmState
- Fog::Parsers::AWS::ELB
- Fog::Parsers::AWS::ELB::ApplySecurityGroupsToLoadBalancer
- Fog::Parsers::AWS::ELB::AttachLoadBalancerToSubnets
- Fog::Parsers::AWS::ELB::ConfigureHealthCheck
- Fog::Parsers::AWS::ELB::CreateLoadBalancer
- Fog::Parsers::AWS::ELB::DeleteLoadBalancer
- Fog::Parsers::AWS::ELB::DeregisterInstancesFromLoadBalancer
- Fog::Parsers::AWS::ELB::DescribeInstanceHealth
- Fog::Parsers::AWS::ELB::DescribeLoadBalancerPolicies
- Fog::Parsers::AWS::ELB::DescribeLoadBalancerPolicyTypes
- Fog::Parsers::AWS::ELB::DescribeLoadBalancers
- Fog::Parsers::AWS::ELB::DetachLoadBalancerFromSubnets
- Fog::Parsers::AWS::ELB::DisableAvailabilityZonesForLoadBalancer
- Fog::Parsers::AWS::ELB::Empty
- Fog::Parsers::AWS::ELB::EnableAvailabilityZonesForLoadBalancer
- Fog::Parsers::AWS::ELB::RegisterInstancesWithLoadBalancer
- Fog::Parsers::AWS::EMR
- Fog::Parsers::AWS::EMR::AddInstanceGroups
- Fog::Parsers::AWS::EMR::AddJobFlowSteps
- Fog::Parsers::AWS::EMR::DescribeJobFlows
- Fog::Parsers::AWS::EMR::ModifyInstanceGroups
- Fog::Parsers::AWS::EMR::RunJobFlow
- Fog::Parsers::AWS::EMR::SetTerminationProtection
- Fog::Parsers::AWS::EMR::TerminateJobFlows
- Fog::Parsers::AWS::ElasticBeanstalk
- Fog::Parsers::AWS::ElasticBeanstalk::BaseParser
- Fog::Parsers::AWS::ElasticBeanstalk::CheckDNSAvailability
- Fog::Parsers::AWS::ElasticBeanstalk::CreateApplication
- Fog::Parsers::AWS::ElasticBeanstalk::CreateApplicationVersion
- Fog::Parsers::AWS::ElasticBeanstalk::CreateConfigurationTemplate
- Fog::Parsers::AWS::ElasticBeanstalk::CreateEnvironment
- Fog::Parsers::AWS::ElasticBeanstalk::CreateStorageLocation
- Fog::Parsers::AWS::ElasticBeanstalk::DescribeApplicationVersions
- Fog::Parsers::AWS::ElasticBeanstalk::DescribeApplications
- Fog::Parsers::AWS::ElasticBeanstalk::DescribeConfigurationOptions
- Fog::Parsers::AWS::ElasticBeanstalk::DescribeConfigurationSettings
- Fog::Parsers::AWS::ElasticBeanstalk::DescribeEnvironmentResources
- Fog::Parsers::AWS::ElasticBeanstalk::DescribeEnvironments
- Fog::Parsers::AWS::ElasticBeanstalk::DescribeEvents
- Fog::Parsers::AWS::ElasticBeanstalk::Empty
- Fog::Parsers::AWS::ElasticBeanstalk::ListAvailableSolutionStacks
- Fog::Parsers::AWS::ElasticBeanstalk::RetrieveEnvironmentInfo
- Fog::Parsers::AWS::ElasticBeanstalk::TerminateEnvironment
- Fog::Parsers::AWS::ElasticBeanstalk::UpdateApplication
- Fog::Parsers::AWS::ElasticBeanstalk::UpdateApplicationVersion
- Fog::Parsers::AWS::ElasticBeanstalk::UpdateConfigurationTemplate
- Fog::Parsers::AWS::ElasticBeanstalk::UpdateEnvironment
- Fog::Parsers::AWS::ElasticBeanstalk::ValidateConfigurationSettings
- Fog::Parsers::AWS::Elasticache
- Fog::Parsers::AWS::Elasticache::AuthorizeCacheSecurityGroupIngress
- Fog::Parsers::AWS::Elasticache::Base
- Fog::Parsers::AWS::Elasticache::CacheClusterParser
- Fog::Parsers::AWS::Elasticache::DescribeCacheClusters
- Fog::Parsers::AWS::Elasticache::DescribeCacheParameters
- Fog::Parsers::AWS::Elasticache::DescribeEngineDefaultParameters
- Fog::Parsers::AWS::Elasticache::DescribeParameterGroups
- Fog::Parsers::AWS::Elasticache::DescribeReservedCacheNodes
- Fog::Parsers::AWS::Elasticache::DescribeSecurityGroups
- Fog::Parsers::AWS::Elasticache::EngineDefaultsParser
- Fog::Parsers::AWS::Elasticache::EventListParser
- Fog::Parsers::AWS::Elasticache::ModifyParameterGroup
- Fog::Parsers::AWS::Elasticache::ParameterGroupParser
- Fog::Parsers::AWS::Elasticache::ResetParameterGroup
- Fog::Parsers::AWS::Elasticache::SecurityGroupParser
- Fog::Parsers::AWS::Elasticache::SingleCacheCluster
- Fog::Parsers::AWS::Elasticache::SingleParameterGroup
- Fog::Parsers::AWS::Elasticache::SingleSecurityGroup
- Fog::Parsers::AWS::IAM
- Fog::Parsers::AWS::IAM::BaseInstanceProfile
- Fog::Parsers::AWS::IAM::Basic
- Fog::Parsers::AWS::IAM::CreateAccessKey
- Fog::Parsers::AWS::IAM::CreateGroup
- Fog::Parsers::AWS::IAM::CreateUser
- Fog::Parsers::AWS::IAM::GetGroup
- Fog::Parsers::AWS::IAM::GetGroupPolicy
- Fog::Parsers::AWS::IAM::GetRolePolicy
- Fog::Parsers::AWS::IAM::GetUser
- Fog::Parsers::AWS::IAM::GetUserPolicy
- Fog::Parsers::AWS::IAM::InstanceProfile
- Fog::Parsers::AWS::IAM::ListAccessKeys
- Fog::Parsers::AWS::IAM::ListAccountAliases
- Fog::Parsers::AWS::IAM::ListGroups
- Fog::Parsers::AWS::IAM::ListGroupsForUser
- Fog::Parsers::AWS::IAM::ListInstanceProfiles
- Fog::Parsers::AWS::IAM::ListPolicies
- Fog::Parsers::AWS::IAM::ListRoles
- Fog::Parsers::AWS::IAM::ListServerCertificates
- Fog::Parsers::AWS::IAM::ListSigningCertificates
- Fog::Parsers::AWS::IAM::ListUsers
- Fog::Parsers::AWS::IAM::LoginProfile
- Fog::Parsers::AWS::IAM::RoleParser
- Fog::Parsers::AWS::IAM::SingleRole
- Fog::Parsers::AWS::IAM::UpdateGroup
- Fog::Parsers::AWS::IAM::UpdateUser
- Fog::Parsers::AWS::IAM::UploadServerCertificate
- Fog::Parsers::AWS::IAM::UploadSigningCertificate
- Fog::Parsers::AWS::RDS
- Fog::Parsers::AWS::RDS::AuthorizeDBSecurityGroupIngress
- Fog::Parsers::AWS::RDS::Base
- Fog::Parsers::AWS::RDS::CreateDBInstance
- Fog::Parsers::AWS::RDS::CreateDBInstanceReadReplica
- Fog::Parsers::AWS::RDS::CreateDBSecurityGroup
- Fog::Parsers::AWS::RDS::CreateDBSnapshot
- Fog::Parsers::AWS::RDS::CreateDBSubnetGroup
- Fog::Parsers::AWS::RDS::CreateDbParameterGroup
- Fog::Parsers::AWS::RDS::DBEngineVersionParser
- Fog::Parsers::AWS::RDS::DbParser
- Fog::Parsers::AWS::RDS::DeleteDBInstance
- Fog::Parsers::AWS::RDS::DeleteDBSecurityGroup
- Fog::Parsers::AWS::RDS::DeleteDBSnapshot
- Fog::Parsers::AWS::RDS::DeleteDbParameterGroup
- Fog::Parsers::AWS::RDS::DescribeDBEngineVersions
- Fog::Parsers::AWS::RDS::DescribeDBInstances
- Fog::Parsers::AWS::RDS::DescribeDBParameterGroups
- Fog::Parsers::AWS::RDS::DescribeDBParameters
- Fog::Parsers::AWS::RDS::DescribeDBReservedInstances
- Fog::Parsers::AWS::RDS::DescribeDBSecurityGroups
- Fog::Parsers::AWS::RDS::DescribeDBSnapshots
- Fog::Parsers::AWS::RDS::DescribeDBSubnetGroups
- Fog::Parsers::AWS::RDS::EventListParser
- Fog::Parsers::AWS::RDS::ModifyDBInstance
- Fog::Parsers::AWS::RDS::ModifyDbParameterGroup
- Fog::Parsers::AWS::RDS::RebootDBInstance
- Fog::Parsers::AWS::RDS::RestoreDBInstanceFromDBSnapshot
- Fog::Parsers::AWS::RDS::RestoreDBInstanceToPointInTime
- Fog::Parsers::AWS::RDS::RevokeDBSecurityGroupIngress
- Fog::Parsers::AWS::RDS::SecurityGroupParser
- Fog::Parsers::AWS::RDS::SnapshotParser
- Fog::Parsers::AWS::RDS::SubnetGroupParser
- Fog::Parsers::AWS::RDS::TagListParser
- Fog::Parsers::AWS::SES
- Fog::Parsers::AWS::SES::DeleteVerifiedEmailAddress
- Fog::Parsers::AWS::SES::GetSendQuota
- Fog::Parsers::AWS::SES::GetSendStatistics
- Fog::Parsers::AWS::SES::ListVerifiedEmailAddresses
- Fog::Parsers::AWS::SES::SendEmail
- Fog::Parsers::AWS::SES::SendRawEmail
- Fog::Parsers::AWS::SES::VerifyEmailAddress
- Fog::Parsers::AWS::SNS
- Fog::Parsers::AWS::SNS::AddPermission
- Fog::Parsers::AWS::SNS::ConfirmSubscription
- Fog::Parsers::AWS::SNS::CreateTopic
- Fog::Parsers::AWS::SNS::DeleteTopic
- Fog::Parsers::AWS::SNS::GetTopicAttributes
- Fog::Parsers::AWS::SNS::ListSubscriptions
- Fog::Parsers::AWS::SNS::ListTopics
- Fog::Parsers::AWS::SNS::Publish
- Fog::Parsers::AWS::SNS::RemovePermission
- Fog::Parsers::AWS::SNS::SetTopicAttributes
- Fog::Parsers::AWS::SNS::Subscribe
- Fog::Parsers::AWS::SNS::Unsubscribe
- Fog::Parsers::AWS::SQS
- Fog::Parsers::AWS::SQS::Basic
- Fog::Parsers::AWS::SQS::CreateQueue
- Fog::Parsers::AWS::SQS::GetQueueAttributes
- Fog::Parsers::AWS::SQS::ListQueues
- Fog::Parsers::AWS::SQS::ReceiveMessage
- Fog::Parsers::AWS::SQS::SendMessage
- Fog::Parsers::AWS::STS
- Fog::Parsers::AWS::STS::GetSessionToken
- Fog::Parsers::AWS::SimpleDB
- Fog::Parsers::AWS::SimpleDB::Basic
- Fog::Parsers::AWS::SimpleDB::DomainMetadata
- Fog::Parsers::AWS::SimpleDB::GetAttributes
- Fog::Parsers::AWS::SimpleDB::ListDomains
- Fog::Parsers::AWS::SimpleDB::Select
- Fog::Parsers::Base
- Fog::Parsers::CDN
- Fog::Parsers::CDN::AWS
- Fog::Parsers::CDN::AWS::Distribution
- Fog::Parsers::CDN::AWS::GetDistributionList
- Fog::Parsers::CDN::AWS::GetInvalidation
- Fog::Parsers::CDN::AWS::GetInvalidationList
- Fog::Parsers::CDN::AWS::GetStreamingDistributionList
- Fog::Parsers::CDN::AWS::PostInvalidation
- Fog::Parsers::CDN::AWS::StreamingDistribution
- Fog::Parsers::Compute
- Fog::Parsers::Compute::AWS
- Fog::Parsers::Compute::AWS::AllocateAddress
- Fog::Parsers::Compute::AWS::AssociateAddress
- Fog::Parsers::Compute::AWS::AssociateDhcpOptions
- Fog::Parsers::Compute::AWS::AttachInternetGateway
- Fog::Parsers::Compute::AWS::AttachNetworkInterface
- Fog::Parsers::Compute::AWS::AttachVolume
- Fog::Parsers::Compute::AWS::Basic
- Fog::Parsers::Compute::AWS::CancelSpotInstanceRequests
- Fog::Parsers::Compute::AWS::CopySnapshot
- Fog::Parsers::Compute::AWS::CreateDhcpOptions
- Fog::Parsers::Compute::AWS::CreateImage
- Fog::Parsers::Compute::AWS::CreateInternetGateway
- Fog::Parsers::Compute::AWS::CreateKeyPair
- Fog::Parsers::Compute::AWS::CreateNetworkInterface
- Fog::Parsers::Compute::AWS::CreateSecurityGroup
- Fog::Parsers::Compute::AWS::CreateSnapshot
- Fog::Parsers::Compute::AWS::CreateSubnet
- Fog::Parsers::Compute::AWS::CreateVolume
- Fog::Parsers::Compute::AWS::CreateVpc
- Fog::Parsers::Compute::AWS::DeleteDhcpOptions
- Fog::Parsers::Compute::AWS::DeleteInternetGateway
- Fog::Parsers::Compute::AWS::DeleteNetworkInterface
- Fog::Parsers::Compute::AWS::DeleteSubnet
- Fog::Parsers::Compute::AWS::DeleteVpc
- Fog::Parsers::Compute::AWS::DeregisterImage
- Fog::Parsers::Compute::AWS::DescribeAddresses
- Fog::Parsers::Compute::AWS::DescribeAvailabilityZones
- Fog::Parsers::Compute::AWS::DescribeDhcpOptions
- Fog::Parsers::Compute::AWS::DescribeImages
- Fog::Parsers::Compute::AWS::DescribeInstanceStatus
- Fog::Parsers::Compute::AWS::DescribeInstances
- Fog::Parsers::Compute::AWS::DescribeInternetGateways
- Fog::Parsers::Compute::AWS::DescribeKeyPairs
- Fog::Parsers::Compute::AWS::DescribeNetworkInterfaceAttribute
- Fog::Parsers::Compute::AWS::DescribeNetworkInterfaces
- Fog::Parsers::Compute::AWS::DescribePlacementGroups
- Fog::Parsers::Compute::AWS::DescribeRegions
- Fog::Parsers::Compute::AWS::DescribeReservedInstances
- Fog::Parsers::Compute::AWS::DescribeReservedInstancesOfferings
- Fog::Parsers::Compute::AWS::DescribeSecurityGroups
- Fog::Parsers::Compute::AWS::DescribeSnapshots
- Fog::Parsers::Compute::AWS::DescribeSpotPriceHistory
- Fog::Parsers::Compute::AWS::DescribeSubnets
- Fog::Parsers::Compute::AWS::DescribeTags
- Fog::Parsers::Compute::AWS::DescribeVolumeStatus
- Fog::Parsers::Compute::AWS::DescribeVolumes
- Fog::Parsers::Compute::AWS::DescribeVpcs
- Fog::Parsers::Compute::AWS::DetachInternetGateway
- Fog::Parsers::Compute::AWS::DetachNetworkInterface
- Fog::Parsers::Compute::AWS::DetachVolume
- Fog::Parsers::Compute::AWS::GetConsoleOutput
- Fog::Parsers::Compute::AWS::GetPasswordData
- Fog::Parsers::Compute::AWS::ImportKeyPair
- Fog::Parsers::Compute::AWS::MonitorUnmonitorInstances
- Fog::Parsers::Compute::AWS::NetworkInterfaceParser
- Fog::Parsers::Compute::AWS::PurchaseReservedInstancesOffering
- Fog::Parsers::Compute::AWS::RegisterImage
- Fog::Parsers::Compute::AWS::RunInstances
- Fog::Parsers::Compute::AWS::SpotDatafeedSubscription
- Fog::Parsers::Compute::AWS::SpotInstanceRequests
- Fog::Parsers::Compute::AWS::StartStopInstances
- Fog::Parsers::Compute::AWS::TerminateInstances
- Fog::Parsers::Compute::Voxel
- Fog::Parsers::Compute::Voxel::Basic
- Fog::Parsers::Compute::Voxel::DevicesList
- Fog::Parsers::Compute::Voxel::ImagesList
- Fog::Parsers::Compute::Voxel::VoxcloudCreate
- Fog::Parsers::Compute::Voxel::VoxcloudDelete
- Fog::Parsers::Compute::Voxel::VoxcloudStatus
- Fog::Parsers::DNS
- Fog::Parsers::DNS::AWS
- Fog::Parsers::DNS::AWS::ChangeResourceRecordSets
- Fog::Parsers::DNS::AWS::CreateHostedZone
- Fog::Parsers::DNS::AWS::DeleteHostedZone
- Fog::Parsers::DNS::AWS::GetChange
- Fog::Parsers::DNS::AWS::GetHostedZone
- Fog::Parsers::DNS::AWS::ListHostedZones
- Fog::Parsers::DNS::AWS::ListResourceRecordSets
- Fog::Parsers::DNS::Bluebox
- Fog::Parsers::DNS::Bluebox::CreateRecord
- Fog::Parsers::DNS::Bluebox::CreateZone
- Fog::Parsers::DNS::Bluebox::GetRecord
- Fog::Parsers::DNS::Bluebox::GetRecords
- Fog::Parsers::DNS::Bluebox::GetZone
- Fog::Parsers::DNS::Bluebox::GetZones
- Fog::Parsers::DNS::Zerigo
- Fog::Parsers::DNS::Zerigo::CountHosts
- Fog::Parsers::DNS::Zerigo::CountZones
- Fog::Parsers::DNS::Zerigo::CreateHost
- Fog::Parsers::DNS::Zerigo::CreateZone
- Fog::Parsers::DNS::Zerigo::FindHosts
- Fog::Parsers::DNS::Zerigo::GetHost
- Fog::Parsers::DNS::Zerigo::GetZone
- Fog::Parsers::DNS::Zerigo::GetZoneStats
- Fog::Parsers::DNS::Zerigo::ListHosts
- Fog::Parsers::DNS::Zerigo::ListZones
- Fog::Parsers::Storage
- Fog::Parsers::Storage::AWS
- Fog::Parsers::Storage::AWS::AccessControlList
- Fog::Parsers::Storage::AWS::CompleteMultipartUpload
- Fog::Parsers::Storage::AWS::CopyObject
- Fog::Parsers::Storage::AWS::CorsConfiguration
- Fog::Parsers::Storage::AWS::DeleteMultipleObjects
- Fog::Parsers::Storage::AWS::GetBucket
- Fog::Parsers::Storage::AWS::GetBucketLifecycle
- Fog::Parsers::Storage::AWS::GetBucketLocation
- Fog::Parsers::Storage::AWS::GetBucketLogging
- Fog::Parsers::Storage::AWS::GetBucketObjectVersions
- Fog::Parsers::Storage::AWS::GetBucketVersioning
- Fog::Parsers::Storage::AWS::GetBucketWebsite
- Fog::Parsers::Storage::AWS::GetRequestPayment
- Fog::Parsers::Storage::AWS::GetService
- Fog::Parsers::Storage::AWS::InitiateMultipartUpload
- Fog::Parsers::Storage::AWS::ListMultipartUploads
- Fog::Parsers::Storage::AWS::ListParts
- Fog::Parsers::Storage::Google
- Fog::Parsers::Storage::Google::AccessControlList
- Fog::Parsers::Storage::Google::CopyObject
- Fog::Parsers::Storage::Google::GetBucket
- Fog::Parsers::Storage::Google::GetBucketObjectVersions
- Fog::Parsers::Storage::Google::GetBucketVersioning
- Fog::Parsers::Storage::Google::GetRequestPayment
- Fog::Parsers::Storage::Google::GetService
- Fog::Parsers::Storage::InternetArchive
- Fog::Parsers::Storage::InternetArchive::AccessControlList
- Fog::Parsers::Storage::InternetArchive::CompleteMultipartUpload
- Fog::Parsers::Storage::InternetArchive::CopyObject
- Fog::Parsers::Storage::InternetArchive::CorsConfiguration
- Fog::Parsers::Storage::InternetArchive::DeleteMultipleObjects
- Fog::Parsers::Storage::InternetArchive::GetBucket
- Fog::Parsers::Storage::InternetArchive::GetBucketLifecycle
- Fog::Parsers::Storage::InternetArchive::GetBucketLocation
- Fog::Parsers::Storage::InternetArchive::GetBucketLogging
- Fog::Parsers::Storage::InternetArchive::GetBucketWebsite
- Fog::Parsers::Storage::InternetArchive::GetRequestPayment
- Fog::Parsers::Storage::InternetArchive::GetService
- Fog::Parsers::Storage::InternetArchive::InitiateMultipartUpload
- Fog::Parsers::Storage::InternetArchive::ListMultipartUploads
- Fog::Parsers::Storage::InternetArchive::ListParts
- Fog::Parsers::Terremark
- Fog::Parsers::Terremark::Shared
- Fog::Parsers::Terremark::Shared::GetCatalog
- Fog::Parsers::Terremark::Shared::GetCatalogItem
- Fog::Parsers::Terremark::Shared::GetInternetServices
- Fog::Parsers::Terremark::Shared::GetKeysList
- Fog::Parsers::Terremark::Shared::GetNetworkIps
- Fog::Parsers::Terremark::Shared::GetNodeServices
- Fog::Parsers::Terremark::Shared::GetOrganization
- Fog::Parsers::Terremark::Shared::GetOrganizations
- Fog::Parsers::Terremark::Shared::GetPublicIps
- Fog::Parsers::Terremark::Shared::GetTasksList
- Fog::Parsers::Terremark::Shared::GetVappTemplate
- Fog::Parsers::Terremark::Shared::GetVdc
- Fog::Parsers::Terremark::Shared::InstantiateVappTemplate
- Fog::Parsers::Terremark::Shared::InternetService
- Fog::Parsers::Terremark::Shared::Network
- Fog::Parsers::Terremark::Shared::NodeService
- Fog::Parsers::Terremark::Shared::PublicIp
- Fog::Parsers::Terremark::Shared::Task
- Fog::Parsers::Terremark::Shared::Vapp
- Fog::Parsers::XenServer
- Fog::Parsers::XenServer::Base
- Fog::Parsers::XenServer::GetHosts
- Fog::Parsers::XenServer::GetNetworks
- Fog::Parsers::XenServer::GetPools
- Fog::Parsers::XenServer::GetRecords
- Fog::Parsers::XenServer::GetStorageRepositories
- Fog::Parsers::XenServer::GetVBDs
- Fog::Parsers::XenServer::GetVIFs
- Fog::Parsers::XenServer::GetVms
- Fog::Provider
- Fog::Rackspace
- Fog::Rackspace::BlockStorage
- Fog::Rackspace::BlockStorage::BadRequest
- Fog::Rackspace::BlockStorage::IdentifierTaken
- Fog::Rackspace::BlockStorage::InternalServerError
- Fog::Rackspace::BlockStorage::Mock
- Fog::Rackspace::BlockStorage::Real
- Fog::Rackspace::BlockStorage::ServiceError
- Fog::Rackspace::BlockStorage::Snapshot
- Fog::Rackspace::BlockStorage::Snapshots
- Fog::Rackspace::BlockStorage::Volume
- Fog::Rackspace::BlockStorage::VolumeType
- Fog::Rackspace::BlockStorage::VolumeTypes
- Fog::Rackspace::BlockStorage::Volumes
- Fog::Rackspace::Databases
- Fog::Rackspace::Databases::BadRequest
- Fog::Rackspace::Databases::Database
- Fog::Rackspace::Databases::Databases
- Fog::Rackspace::Databases::Flavor
- Fog::Rackspace::Databases::Flavors
- Fog::Rackspace::Databases::Instance
- Fog::Rackspace::Databases::Instances
- Fog::Rackspace::Databases::InternalServerError
- Fog::Rackspace::Databases::Mock
- Fog::Rackspace::Databases::Real
- Fog::Rackspace::Databases::ServiceError
- Fog::Rackspace::Databases::User
- Fog::Rackspace::Databases::Users
- Fog::Rackspace::Errors
- Fog::Rackspace::Errors::BadRequest
- Fog::Rackspace::Errors::Conflict
- Fog::Rackspace::Errors::InternalServerError
- Fog::Rackspace::Errors::ServiceError
- Fog::Rackspace::Errors::ServiceUnavailable
- Fog::Rackspace::Identity
- Fog::Rackspace::Identity::Credential
- Fog::Rackspace::Identity::Credentials
- Fog::Rackspace::Identity::Mock
- Fog::Rackspace::Identity::Real
- Fog::Rackspace::Identity::Role
- Fog::Rackspace::Identity::Roles
- Fog::Rackspace::Identity::ServiceCatalog
- Fog::Rackspace::Identity::Tenant
- Fog::Rackspace::Identity::Tenants
- Fog::Rackspace::Identity::User
- Fog::Rackspace::Identity::Users
- Fog::Rackspace::LoadBalancers
- Fog::Rackspace::LoadBalancers::AccessRule
- Fog::Rackspace::LoadBalancers::AccessRules
- Fog::Rackspace::LoadBalancers::BadRequest
- Fog::Rackspace::LoadBalancers::InternalServerError
- Fog::Rackspace::LoadBalancers::LoadBalancer
- Fog::Rackspace::LoadBalancers::LoadBalancers
- Fog::Rackspace::LoadBalancers::Mock
- Fog::Rackspace::LoadBalancers::Node
- Fog::Rackspace::LoadBalancers::Nodes
- Fog::Rackspace::LoadBalancers::Real
- Fog::Rackspace::LoadBalancers::ServiceError
- Fog::Rackspace::LoadBalancers::Shared
- Fog::Rackspace::LoadBalancers::VirtualIp
- Fog::Rackspace::LoadBalancers::VirtualIps
- Fog::Rackspace::MockData
- Fog::Rackspace::Service
- Fog::Rake
- Fog::Rake::ChangelogTask
- Fog::Rake::TestTask
- Fog::RiakCS
- Fog::RiakCS::MultipartUtils
- Fog::RiakCS::MultipartUtils::Headers
- Fog::RiakCS::Provisioning
- Fog::RiakCS::Provisioning::Mock
- Fog::RiakCS::Provisioning::Real
- Fog::RiakCS::Provisioning::ServiceUnavailable
- Fog::RiakCS::Provisioning::UserAlreadyExists
- Fog::RiakCS::Usage
- Fog::RiakCS::Usage::Mock
- Fog::RiakCS::Usage::Real
- Fog::RiakCS::Usage::Utils
- Fog::RiakCS::UserUtils
- Fog::RiakCS::Utils
- Fog::SCP
- Fog::SCP::Mock
- Fog::SCP::Real
- Fog::SSH
- Fog::SSH::Mock
- Fog::SSH::Real
- Fog::SSH::Result
- Fog::Schema
- Fog::Schema::DataValidator
- Fog::Serverlove
- Fog::Service
- Fog::Service::Collections
- Fog::Service::Error
- Fog::Service::NoLeakInspector
- Fog::Service::NotFound
- Fog::Storage
- Fog::Storage::AWS
- Fog::Storage::AWS::Directories
- Fog::Storage::AWS::Directory
- Fog::Storage::AWS::File
- Fog::Storage::AWS::Files
- Fog::Storage::AWS::GetObjectHttpUrl
- Fog::Storage::AWS::GetObjectHttpsUrl
- Fog::Storage::AWS::GetObjectUrl
- Fog::Storage::AWS::Mock
- Fog::Storage::AWS::PutObjectUrl
- Fog::Storage::AWS::Real
- Fog::Storage::AWS::Utils
- Fog::Storage::AWS::Version
- Fog::Storage::AWS::Versions
- Fog::Storage::Atmos
- Fog::Storage::Atmos::Directories
- Fog::Storage::Atmos::Directory
- Fog::Storage::Atmos::File
- Fog::Storage::Atmos::Files
- Fog::Storage::Atmos::Mock
- Fog::Storage::Atmos::Real
- Fog::Storage::Atmos::Utils
- Fog::Storage::Google
- Fog::Storage::Google::Directories
- Fog::Storage::Google::Directory
- Fog::Storage::Google::File
- Fog::Storage::Google::Files
- Fog::Storage::Google::GetObjectHttpUrl
- Fog::Storage::Google::GetObjectHttpsUrl
- Fog::Storage::Google::Mock
- Fog::Storage::Google::Real
- Fog::Storage::Google::Utils
- Fog::Storage::HP
- Fog::Storage::HP::Directories
- Fog::Storage::HP::Directory
- Fog::Storage::HP::File
- Fog::Storage::HP::Files
- Fog::Storage::HP::Mock
- Fog::Storage::HP::Real
- Fog::Storage::HP::SharedDirectories
- Fog::Storage::HP::SharedDirectory
- Fog::Storage::HP::SharedFile
- Fog::Storage::HP::SharedFiles
- Fog::Storage::HP::Utils
- Fog::Storage::IAAttributes
- Fog::Storage::IAAttributes::ClassMethods
- Fog::Storage::IAAttributes::InstanceMethods
- Fog::Storage::IBM
- Fog::Storage::IBM::Mock
- Fog::Storage::IBM::Offering
- Fog::Storage::IBM::Offerings
- Fog::Storage::IBM::Real
- Fog::Storage::IBM::Volume
- Fog::Storage::IBM::Volumes
- Fog::Storage::InternetArchive
- Fog::Storage::InternetArchive::Directories
- Fog::Storage::InternetArchive::Directory
- Fog::Storage::InternetArchive::File
- Fog::Storage::InternetArchive::Files
- Fog::Storage::InternetArchive::GetObjectHttpUrl
- Fog::Storage::InternetArchive::GetObjectHttpsUrl
- Fog::Storage::InternetArchive::GetObjectUrl
- Fog::Storage::InternetArchive::Mock
- Fog::Storage::InternetArchive::PutObjectUrl
- Fog::Storage::InternetArchive::Real
- Fog::Storage::InternetArchive::Utils
- Fog::Storage::Local
- Fog::Storage::Local::Directories
- Fog::Storage::Local::Directory
- Fog::Storage::Local::File
- Fog::Storage::Local::Files
- Fog::Storage::Local::Mock
- Fog::Storage::Local::Real
- Fog::Storage::Ninefold
- Fog::Storage::Ninefold::Mock
- Fog::Storage::Ninefold::Real
- Fog::Storage::Ninefold::Utils
- Fog::Storage::OpenStack
- Fog::Storage::OpenStack::Directories
- Fog::Storage::OpenStack::Directory
- Fog::Storage::OpenStack::File
- Fog::Storage::OpenStack::Files
- Fog::Storage::OpenStack::Mock
- Fog::Storage::OpenStack::Real
- Fog::Storage::Rackspace
- Fog::Storage::Rackspace::Account
- Fog::Storage::Rackspace::BadRequest
- Fog::Storage::Rackspace::Directories
- Fog::Storage::Rackspace::Directory
- Fog::Storage::Rackspace::File
- Fog::Storage::Rackspace::Files
- Fog::Storage::Rackspace::InternalServerError
- Fog::Storage::Rackspace::Metadata
- Fog::Storage::Rackspace::Mock
- Fog::Storage::Rackspace::Real
- Fog::Storage::Rackspace::ServiceError
- Fog::Storage::Rackspace::Utils
- Fog::StormOnDemand
- Fog::Terremark
- Fog::Terremark::Shared
- Fog::Terremark::Shared::Address
- Fog::Terremark::Shared::Addresses
- Fog::Terremark::Shared::Common
- Fog::Terremark::Shared::Image
- Fog::Terremark::Shared::Images
- Fog::Terremark::Shared::InternetService
- Fog::Terremark::Shared::InternetServices
- Fog::Terremark::Shared::Mock
- Fog::Terremark::Shared::Network
- Fog::Terremark::Shared::Networks
- Fog::Terremark::Shared::NodeService
- Fog::Terremark::Shared::NodeServices
- Fog::Terremark::Shared::Parser
- Fog::Terremark::Shared::Real
- Fog::Terremark::Shared::Server
- Fog::Terremark::Shared::Servers
- Fog::Terremark::Shared::Task
- Fog::Terremark::Shared::Tasks
- Fog::Terremark::Shared::Vdc
- Fog::Terremark::Shared::Vdcs
- Fog::Terremark::Vcloud
- Fog::Terremark::Vcloud::Bin
- Fog::Terremark::Vcloud::Defaults
- Fog::Terremark::Vcloud::Mock
- Fog::Terremark::Vcloud::Real
- Fog::Time
- Fog::ToHashDocument
- Fog::Vcloud
- Fog::Vcloud::Collection
- Fog::Vcloud::Compute
- Fog::Vcloud::Compute::Catalog
- Fog::Vcloud::Compute::CatalogItem
- Fog::Vcloud::Compute::CatalogItems
- Fog::Vcloud::Compute::Catalogs
- Fog::Vcloud::Compute::Helpers
- Fog::Vcloud::Compute::Helpers::Status
- Fog::Vcloud::Compute::Ip
- Fog::Vcloud::Compute::Ips
- Fog::Vcloud::Compute::Mock
- Fog::Vcloud::Compute::Network
- Fog::Vcloud::Compute::Networks
- Fog::Vcloud::Compute::Organization
- Fog::Vcloud::Compute::Organizations
- Fog::Vcloud::Compute::Real
- Fog::Vcloud::Compute::Server
- Fog::Vcloud::Compute::Servers
- Fog::Vcloud::Compute::Shared
- Fog::Vcloud::Compute::Task
- Fog::Vcloud::Compute::Tasks
- Fog::Vcloud::Compute::Vapp
- Fog::Vcloud::Compute::Vapps
- Fog::Vcloud::Compute::Vdc
- Fog::Vcloud::Compute::Vdcs
- Fog::Vcloud::Model
- Fog::Vmfusion
- Fog::Volume
- Fog::Volume::OpenStack
- Fog::Volume::OpenStack::Mock
- Fog::Volume::OpenStack::Real
- Fog::Volume::OpenStack::Volume
- Fog::Volume::OpenStack::Volumes
- Fog::Voxel
- Fog::Vsphere
- Fog::Vsphere::Errors
- Fog::Vsphere::Errors::NotFound
- Fog::Vsphere::Errors::SecurityError
- Fog::Vsphere::Errors::ServiceError
- Fog::XenServer
- Fog::XenServer::Connection
- Fog::XenServer::InvalidLogin
- Fog::XenServer::NokogiriStreamParser
- Fog::XenServer::NotFound
- Fog::XenServer::RequestFailed
- Fog::Zerigo
- AWS
- Atmos
- BareMetalCloud
- Bluebox
- Brightbox
- Clodo
- Cloudstack
- DNSMadeEasy
- DNSimple
- DigitalOcean
- Dreamhost
- Dynect
- Ecloud
- Glesys
- GoGrid
- Google
- HP
- Hash
- IBM
- IPAddr
- InternetArchive
- Joyent
- Libvirt
- Linode
- Local
- Ninefold
- Object
- OpenStack
- Ovirt
- Rackspace
- RiakCS
- Serverlove
- StormOnDemand
- String
- Terremark
- TerremarkParser
- VAppStatus
- Vcloud
- Vmfusion
- Voxel
- Vsphere
- XenServer
- Zerigo

No matching classes.

# Fog::Compute::Ecloud::Mock

### Public Class Methods

data() click to toggle source

    # File lib/fog/ecloud/compute.rb, line 413
    def self.data
      @data ||= Hash.new do |hash, key|
        hash[key] = begin
                      compute_pool_id            = Fog.credentials[:ecloud_compute_pool_id]  || Fog::Mock.random_numbers(3).to_i
                      environment_id             = Fog.credentials[:ecloud_environment_id]   || Fog::Mock.random_numbers(3).to_i
                      public_ip_id               = Fog.credentials[:ecloud_public_ip_id]     || Fog::Mock.random_numbers(6).to_i
                      internet_service_id        = Fog::Mock.random_numbers(6).to_i
                      node_service_id            = Fog::Mock.random_numbers(6).to_i
                      environment_name           = Fog.credentials[:ecloud_environment_name] || Fog::Mock.random_letters(12)
                      location_id                = Fog::Mock.random_numbers(4).to_i
                      network_id                 = Fog.credentials[:ecloud_network_id]       || Fog::Mock.random_numbers(6).to_i
                      network_ip                 = Fog::Ecloud.ip_address
                      public_ip                  = Fog.credentials[:ecloud_public_ip_name]   || Fog::Ecloud.ip_address
                      ip_address_id              = Fog::Ecloud.ip_address
                      ip_address2_id             = Fog::Ecloud.ip_address
                      operating_system_id        = Fog::Mock.random_numbers(7).to_i
                      operating_system_family_id = Fog::Mock.random_numbers(7).to_i
                      organization_id            = Fog::Mock.random_numbers(7).to_i
                      organization_name          = Fog::Mock.random_letters(7)
                      template_id                = Fog.credentials[:ecloud_template_id]      || Fog::Mock.random_numbers(7).to_i
                      ssh_key_id                 = Fog.credentials[:ecloud_ssh_key_id]       || Fog::Mock.random_numbers(4).to_i
                      ssh_key_name               = Fog.credentials[:ecloud_ssh_key_name]     || "root"

                      environment = {
                        :id   => environment_id,
                        :href => "/cloudapi/ecloud/environments/#{environment_id}",
                        :name => environment_name,
                        :type => "application/vnd.tmrk.cloud.environment"
                      }

                      organization = {
                        :href => "/cloudapi/ecloud/organizations/#{organization_id}",
                        :type => "application/vnd.tmrk.cloud.organization",
                        :name => organization_name,
                        :Links => {
                          :Link => [
                            Fog::Ecloud.keep(environment, :href, :name, :type),
                            {
                              :href => "/cloudapi/ecloud/admin/organizations/#{organization_id}",
                              :name => organization_name,
                              :type => "application/vnd.tmrk.cloud.admin.organization",
                              :rel  => "alternate",
                            },
                            {
                              :href => "/cloudapi/ecloud/devicetags/organizations/#{organization_id}",
                              :type => "application/vnd.tmrk.cloud.deviceTag; type=collection",
                              :rel  => "down",
                            },
                            {
                              :href => "/cloudapi/ecloud/alerts/organizations/#{organization_id}",
                              :type => "application/vnd.tmrk.cloud.alertLog",
                              :rel  => "down",
                            },
                          ],
                        },
                        :Locations => {
                          :Location => [
                            {
                              :href => "/cloudapi/ecloud/locations/#{location_id}",
                              :name => organization_name,
                              :Catalog => {
                                :href => "/cloudapi/ecloud/admin/catalog/organizations/#{organization_id}/locations/#{location_id}",
                              :type => "application/vnd.tmrk.cloud.admin.catalogEntry; type=collection"
                              },
                              :Environments => { :Environment => [environment] }
                            }
                          ]
                        }
                      }
                      environment.merge!(
                        :Links => {
                          :Link => [ Fog::Ecloud.keep(organization, :href, :name, :type), ]
                        }
                      )

                      admin_organization = {
                        :id    => organization_id,
                        :href  => "/cloudapi/ecloud/admin/organizations/#{organization_id}",
                        :type  => "application/vnd.tmrk.cloud.admin.organization",
                        :name  => organization_name,
                        :Links => {
                          :Link => [
                            Fog::Ecloud.keep(organization, :href, :type, :name)
                          ],
                        },
                        :organization_id => organization_id,
                      }

                      compute_pool = {
                        :id             => compute_pool_id,
                        :href           => "/cloudapi/ecloud/computepools/#{compute_pool_id}",
                        :name           => Fog::Mock.random_letters(12),
                        :type           => "application/vnd.tmrk.cloud.computePool",
                        :environment_id => environment_id,
                        :Links          => {
                          :Link => [
                            Fog::Ecloud.keep(organization, :href, :name, :type),
                            Fog::Ecloud.keep(environment, :href, :name, :type),
                          ]
                        }
                      }

                      public_ip = {
                        :id             => public_ip_id,
                        :href           => "/cloudapi/ecloud/publicips/#{public_ip_id}",
                        :name           => public_ip,
                        :type           => "application/vnd.tmrk.cloud.publicIp",
                        :IpType         => "none",
                        :environment_id => environment_id,
                        :Links          => {
                          :Link => [
                            Fog::Ecloud.keep(environment, :href, :name, :type),
                          ],
                        },
                        :InternetServices => {
                          :InternetService => [
                          ],
                        },
                      }

                      internet_service = {
                        :id           => internet_service_id,
                        :href         => "/cloudapi/ecloud/internetservices/#{internet_service_id}",
                        :name         => Fog::Mock.random_letters(6),
                        :type         => "application/vnd.tmrk.cloud.internetService",
                        :public_ip_id => public_ip_id,
                        :Links => {
                          :Link => [
                            Fog::Ecloud.keep(public_ip, :href, :name, :type),
                          ],
                        },
                        :NodeServices => {
                          :NodeService => [
                          ]
                        },
                      }

                      node_service = {
                        :id                  => node_service_id,
                        :href                => "/cloudapi/ecloud/nodeservices/#{node_service_id}",
                        :name                => Fog::Mock.random_letters(6),
                        :type                => "application/vnd.tmrk.cloud.nodeService",
                        :internet_service_id => internet_service_id,
                        :Links               => {
                          :Link => [
                            Fog::Ecloud.keep(internet_service, :href, :name, :type)
                          ],
                        },
                      }

                      internet_service[:NodeServices][:NodeService].push(node_service)
                      public_ip[:InternetServices][:InternetService].push(internet_service)

                      network = {
                        :id               => network_id,
                        :href             => "/cloudapi/ecloud/networks/#{network_id}",
                        :name             => "#{network_ip}/#{Fog::Mock.random_numbers(2)}",
                        :type             => "application/vnd.tmrk.cloud.network",
                        :Address          => network_ip,
                        :NetworkType      => "Dmz",
                        :BroadcastAddress => network_ip,
                        :GatewayAddress   => network_ip,
                        :environment_id   => environment_id,
                        :Links => {
                          :Link => [
                            Fog::Ecloud.keep(environment, :href, :name, :type),
                          ]
                        },
                        :IpAddresses => {
                          :IpAddress => [],
                        },
                      }

                      ip_address = {
                          :id         => ip_address_id,
                          :href       => "/cloudapi/ecloud/ipaddresses/networks/#{network_id}/#{ip_address_id}",
                          :name       => ip_address_id,
                          :type       => "application/vnd.tmrk.cloud.ipAddress",
                          :network_id => network_id,
                          :Links      => {
                            :Link     => [ Fog::Ecloud.keep(network, :href, :name, :type), ],
                          },
                          :Reserved   => "false",
                          :Host       => nil,
                          :DetectedOn => nil,
                      }

                      ip_address2 = ip_address.dup.merge(:id => ip_address2_id, :href => "/cloudapi/ecloud/ipaddresses/networks/#{network_id}/#{ip_address2_id}", :name => ip_address2_id)

                      network[:IpAddresses][:IpAddress].push(ip_address).push(ip_address2)

                      short_name = "solaris10_64guest"
                      operating_system = {
                        :short_name      => short_name,
                        :compute_pool_id => compute_pool_id,
                        :href            => "/cloudapi/ecloud/operatingsystems/#{short_name}/computepools/#{compute_pool_id}",
                        :name            => "Sun Solaris 10 (64-bit)",
                        :type            => "application/vnd.tmrk.cloud.operatingSystem",
                        :FamilyName      => "Solaris",
                        :Links           => {
                          :Link => Fog::Ecloud.keep(compute_pool, :href, :name, :type),
                        },
                        :ConfigurationOptions => {
                          :Processor => {
                            :Minimum    => "1",
                            :Maximum    => "8",
                            :StepFactor => "1"
                          },
                          :Memory => {
                            :MinimumSize => {
                              :Unit  => "MB",
                              :Value => "800"
                            },
                            :MaximumSize => {
                              :Unit  => "MB",
                              :Value => "16384"
                            },
                            :StepFactor => {
                              :Unit  => "MB",
                              :Value => "4"
                            }
                          },
                          :Disk => {
                            :Minimum => "1",
                            :Maximum => "15",
                            :SystemDisk => {
                              :ResourceCapacityRange => {
                                :MinimumSize => {
                                  :Unit => "GB",
                                  :Value => "1"
                                },
                                :MaximumSize => {
                                  :Unit => "GB",
                                  :Value => "512"
                                },
                                :StepFactor => {
                                  :Unit => "GB",
                                  :Value => "1"}
                              },
                              :MonthlyCost => "0"
                            },
                            :DataDisk => {
                              :ResourceCapacityRange => {
                                :MinimumSize => {
                                  :Unit => "GB",
                                  :Value => "1"
                                },
                                :MaximumSize => {
                                  :Unit => "GB",
                                  :Value => "512"
                                },
                                :StepFactor => {
                                  :Unit  => "GB",
                                  :Value => "1"
                                }
                              },
                              :MonthlyCost => "0"
                            }
                          },
                          :NetworkAdapter=> {
                            :Minimum    => "1",
                            :Maximum    => "4",
                            :StepFactor => "1"
                          }
                        }
                      }

                      template = {
                        :id              => template_id,
                        :href            => "/cloudapi/ecloud/templates/#{template_id}/computepools/#{compute_pool_id}",
                        :type            => "application/vnd.tmrk.cloud.template",
                        :name            => "Sun Solaris 10 (x64)",
                        :compute_pool_id => compute_pool_id,
                        :OperatingSystem => Fog::Ecloud.keep(operating_system, :href, :name, :type),
                        :Memory => {
                          :MinimumSize => {
                            :Unit  => "MB",
                            :Value => "800"
                          },
                          :MaximumSize => {
                            :Unit  => "MB",
                            :Value => "16384"
                          },
                          :StepFactor => {
                            :Unit  => "MB",
                            :Value => "4"
                          }
                        },
                        :Storage => {
                          :Size => {
                            :Unit  => "GB",
                            :Value => "7"
                          }
                        },
                        :NetworkAdapters => "1",
                        :Links           => {
                          :Link => [
                            Fog::Ecloud.keep(compute_pool, :href, :name, :type),
                          ]
                        }
                      }

                      operating_system_family = {
                        :id                    => operating_system_family_id,
                        :compute_pool_id       => compute_pool_id,
                        :OperatingSystemFamily => {
                          :Name             => "Linux",
                          :OperatingSystems => {
                            :OperatingSystem => [Fog::Ecloud.keep(operating_system, :href, :name, :type)],
                          }
                        },
                        :Links => {
                          :Link => [
                            Fog::Ecloud.keep(compute_pool, :href, :name, :type),
                          ]
                        }
                      }

                      ssh_key = {
                        :id                    => ssh_key_id,
                        :href                  => "/cloudapi/ecloud/admin/sshKeys/#{ssh_key_id}",
                        :name                  => ssh_key_name,
                        :admin_organization_id => organization_id,
                        :Links => {
                          :Link => [
                            Fog::Ecloud.keep(admin_organization, :href, :name, :type),
                            Fog::Ecloud.keep(organization, :href, :name, :type),
                          ]
                        },
                        :Default => "true",
                        :FingerPrint => Fog::Ecloud.mac_address
                      }

                      layout = {
                        :id => environment_id,
                        :href => "/cloudapi/ecloud/layout/environments/#{environment_id}",
                        :type => "application/vnd.tmrk.cloud.deviceLayout",
                        :Links => {
                          :Link => [
                            Fog::Ecloud.keep(environment, :name, :href, :type),
                          ],
                        },
                        :Rows => {
                          :Row => [
                          ],
                        },
                        :environment_id => environment_id
                      }

                      {
                        :compute_pools             => {compute_pool_id            => compute_pool},
                        :environments              => {environment_id             => environment},
                        :public_ips                => {public_ip_id               => public_ip},
                        :internet_services         => {internet_service_id        => internet_service},
                        :node_services             => {node_service_id            => node_service},
                        :networks                  => {network_id                 => network},
                        :organizations             => {organization_id            => organization},
                        :admin_organizations       => {organization_id            => admin_organization},
                        :operating_systems         => {operating_system_id        => operating_system},
                        :operating_system_families => {operating_system_family_id => operating_system_family},
                        :servers                   => {},
                        :tasks                     => {},
                        :templates                 => {template_id                => template},
                        :ssh_keys                  => {ssh_key_id                 => ssh_key},
                        :detached_disks            => {},
                        :template_href             => (Fog.credentials[:ecloud_template_href] || "/cloudapi/ecloud/templates/#{template_id}/computepools/#{compute_pool_id}"),
                        :rows                      => {},
                        :groups                    => {},
                        :layouts                   => {environment_id             => layout},
                      }
                    end
      end
    end

new(options={}) click to toggle source

    # File lib/fog/ecloud/compute.rb, line 795
    def initialize(options={})
      @ecloud_api_key = options[:ecloud]
    end

reset() click to toggle source

    # File lib/fog/ecloud/compute.rb, line 791
    def self.reset
      @data = nil
    end

### Public Instance Methods

data() click to toggle source

    # File lib/fog/ecloud/compute.rb, line 799
    def data
      self.class.data[@ecloud_api_key]
    end

deep_copy(o) click to toggle source

    # File lib/fog/ecloud/compute.rb, line 821
    def deep_copy(o)
      Marshal.load(Marshal.dump(o))
    end

get_admin_organization(uri) click to toggle source

    # File lib/fog/ecloud/requests/compute/get_admin_organization.rb, line 10
    def get_admin_organization(uri)

      organization_id = id_from_uri(uri)
      admin_organization    = self.data[:admin_organizations][organization_id]

      if admin_organization
        body = Fog::Ecloud.slice(admin_organization, :id, :organization_id)

        response(:body => body)
      else response(:status => 404) # ?
      end
    end

get_compute_pool(uri) click to toggle source

    # File lib/fog/ecloud/requests/compute/get_compute_pool.rb, line 10
    def get_compute_pool(uri)
      compute_pool_id = id_from_uri(uri)
      compute_pool = self.data[:compute_pools][compute_pool_id]

      if compute_pool
        response(:body => Fog::Ecloud.slice(compute_pool, :id, :environment))
      else response(:status => 404) # ?
      end
    end

get_compute_pools(uri) click to toggle source

    # File lib/fog/ecloud/requests/compute/get_compute_pools.rb, line 10
    def get_compute_pools(uri) # /cloudapi/ecloud/computepools/environments/534
      environment_id = id_from_uri(uri)
      environment    = self.data[:environments][environment_id]

      compute_pools  = self.data[:compute_pools].values.select{|cp| cp[:environment_id] == environment_id}

      compute_pools = compute_pools.map{|cp| Fog::Ecloud.slice(cp, :id, :environment_id)}

      compute_pool_response = {:ComputePool => (compute_pools.size > 1 ? compute_pools : compute_pools.first)} # GAH
      body = {
        :href  => uri,
        :type  => "application/vnd.tmrk.cloud.computePool; type=collection",
        :Links => {
          :Link => environment,
        }
      }.merge(compute_pool_response)

      response(:body => body)
    end

get_detached_disk(uri) click to toggle source

    # File lib/fog/ecloud/requests/compute/get_detached_disk.rb, line 9
    def get_detached_disk(uri)
      detached_disk_id = id_from_uri(uri)
      detached_disk    = self.data[:detached_disks][detached_disk_id]

      if detached_disk
        response(:body => Fog::Ecloud.slice(detached_disk, :id, :compute_pool_id))
      else raise Fog::Errors::NotFound
      end
    end

get_detached_disks(uri) click to toggle source

    # File lib/fog/ecloud/requests/compute/get_detached_disks.rb, line 10
    def get_detached_disks(uri)

      compute_pool_id = id_from_uri(uri)
      compute_pool    = self.data[:compute_pools][compute_pool_id]

      detached_disks  = self.data[:detached_disks].values.select{|cp| cp[:compute_pool_id] == compute_pool_id}

      detached_disks = detached_disks.map{|dd| Fog::Ecloud.slice(dd, :id, :compute_pool_id)}

      detached_disk_response = {:DetachedDisk => (detached_disks.size > 1 ? detached_disks : detached_disks.first)} # GAH
      body = {
        :href  => uri,
        :type  => "application/vnd.tmrk.cloud.detachedDisk; type=collection",
        :Links => {
          :Link => Fog::Ecloud.keep(compute_pool, :name, :href, :type),
        }
      }.merge(detached_disk_response)

      response(:body => body)
    end

get_environment(uri) click to toggle source

    # File lib/fog/ecloud/requests/compute/get_environment.rb, line 10
    def get_environment(uri)
      environment_id = id_from_uri(uri)
      organizations = self.data[:organizations].values
      environment = nil
      catch(:found) do
        organizations.each do |organization|
          organization[:Locations][:Location].each do |location|
            environment = location[:Environments][:Environment].find{|e| e[:id] == environment_id}
            throw :found if environment
          end
        end
      end
      if environment
        body = environment.dup
        body.delete(:id)
        response(:body => body)
      else response(:status => 404) # ?
      end
    end

get_group(uri) click to toggle source

    # File lib/fog/ecloud/requests/compute/get_group.rb, line 9
    def get_group(uri)
      group_id = id_from_uri(uri)
      group = self.data[:groups][group_id]

      response(:body =>  group)
    end

get_groups(uri) click to toggle source

    # File lib/fog/ecloud/requests/compute/get_groups.rb, line 9
    def get_groups(uri)
      row_id = id_from_uri(uri)
      row = self.data[:rows][row_id]

      response(:body =>  row)
    end

get_hardware_configuration(uri) click to toggle source

    # File lib/fog/ecloud/requests/compute/get_hardware_configuration.rb, line 10
    def get_hardware_configuration(uri)
      server_id = uri.match(/(\d+)/)[1]

      server = self.data[:servers][server_id.to_i]
      server_hardware_configuration = server[:HardwareConfiguration]

      new_hardware_configuration = {
        :href           => server_hardware_configuration[:href],
        :type           => server_hardware_configuration[:type],
        :ProcessorCount => server_hardware_configuration[:ProcessorCount],
        :Memory         => server_hardware_configuration[:Memory],
        :Disks          => server_hardware_configuration[:Disks],
        :Nics           => server_hardware_configuration[:Nics],
      }

      response(:body => {:HardwareConfiguration => new_hardware_configuration})
    end

get_hardware_configurations(uri) click to toggle source

    # File lib/fog/ecloud/requests/compute/get_hardware_configurations.rb, line 10
    def get_hardware_configurations(uri)
    end

get_internet_service(uri) click to toggle source

    # File lib/fog/ecloud/requests/compute/get_internet_service.rb, line 10
    def get_internet_service(uri)

      internet_service_id = id_from_uri(uri)
      internet_service    = self.data[:internet_services][internet_service_id.to_i]

      if internet_service
        response(:body => Fog::Ecloud.slice(internet_service, :id, :public_ip))
      else raise Fog::Errors::NotFound
      end
    end

get_internet_services(uri) click to toggle source

    # File lib/fog/ecloud/requests/compute/get_internet_services.rb, line 10
    def get_internet_services(uri)
      public_ip_id = id_from_uri(uri)
      public_ip    = self.data[:public_ips][public_ip_id]

      response(:body => Fog::Ecloud.slice(public_ip, :environment_id))
    end

get_ip_address(uri) click to toggle source

    # File lib/fog/ecloud/requests/compute/get_ip_address.rb, line 10
    def get_ip_address(uri)

      network_id, ip_address_id = uri.match(/\/networks\/(\d+)\/(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})$/).captures
      ip_address = self.data[:networks][network_id.to_i][:IpAddresses][:IpAddress].detect{|ip| ip[:name] == ip_address_id }.dup
      if ip_address
        response(:body => ip_address)
      else response(:status => 404) # ?
      end
    end

get_layout(uri) click to toggle source

    # File lib/fog/ecloud/requests/compute/get_layout.rb, line 9
    def get_layout(uri)
      environment_id = id_from_uri(uri)
      layout = self.data[:layouts][environment_id]

      response(:body =>  layout)
    end

get_layouts(uri) click to toggle source

    # File lib/fog/ecloud/requests/compute/get_layouts.rb, line 9
    def get_layouts(uri)
      environment_id = id_from_uri(uri)
      layout = self.data[:layouts][environment_id]

      response(:body =>  layout)
    end

get_network(uri) click to toggle source

    # File lib/fog/ecloud/requests/compute/get_network.rb, line 10
    def get_network(uri)
      network_id = id_from_uri(uri)
      network    = self.data[:networks][network_id].dup

      if network
        response(:body => Fog::Ecloud.slice(network, :id, :environment_id))
      else response(:status => 404) # ?
      end
    end

get_networks(uri) click to toggle source

    # File lib/fog/ecloud/requests/compute/get_networks.rb, line 10
    def get_networks(uri)
      environment_id = id_from_uri(uri)
      environment = self.data[:environments][environment_id]

      networks = self.data[:networks].values.select{|n| n[:environment_id] == environment_id}.dup
      networks = networks.map{|n| Fog::Ecloud.slice(n, :environment, :id)}

      body = {
        :href  => uri,
        :type  => "application/vnd.tmrk.cloud.network; type=collection",
        :Links => {
          :Link => Fog::Ecloud.keep(environment, :name, :href, :type)
        },
        :Network => (networks.size > 1 ? networks : networks.first),
      }

      response(:body =>  body)
    end

get_node(uri) click to toggle source

    # File lib/fog/ecloud/requests/compute/get_node.rb, line 10
    def get_node(uri)
      node_service_id = id_from_uri(uri)
      node_service    = self.data[:node_services][node_service_id.to_i]

      if node_service
        response(:body => Fog::Ecloud.slice(node_service, :id, :internet_service_id))
      else raise Fog::Errors::NotFound
      end
    end

get_nodes(uri) click to toggle source

    # File lib/fog/ecloud/requests/compute/get_nodes.rb, line 10
    def get_nodes(uri)

      internet_service_id = id_from_uri(uri)
      internet_service    = self.data[:internet_services][internet_service_id]

      response(:body => internet_service)
    end

get_operating_system(uri) click to toggle source

    # File lib/fog/ecloud/requests/compute/get_operating_system.rb, line 10
    def get_operating_system(uri)
      os_name, compute_pool_id = uri.match(/operatingsystems\/(.*)\/computepools\/(\d+)$/).captures
      compute_pool_id          = compute_pool_id.to_i

      operating_systems = self.data[:operating_systems].values.select{|os| os[:compute_pool_id] == compute_pool_id}
      operating_system = operating_systems.find{|os| os[:short_name] == os_name}

      if operating_system
        response(:body => Fog::Ecloud.slice(operating_system, :id, :compute_pool_id, :short_name))
      else response(:status => 404) # ?
      end
    end

get_operating_system_families(uri) click to toggle source

    # File lib/fog/ecloud/requests/compute/get_operating_system_families.rb, line 10
    def get_operating_system_families(uri)
      compute_pool_id = id_from_uri(uri)
      compute_pool    = self.data[:compute_pools][compute_pool_id]

      operating_system_families = self.data[:operating_system_families].values.select{|osf| osf[:compute_pool_id] == compute_pool_id}
      operating_system_families = operating_system_families.map{|osf| Fog::Ecloud.slice(osf, :id, :compute_pool_id)}.map{|osf| osf[:OperatingSystemFamily]}

      operating_system_family_response = {:OperatingSystemFamily => (operating_system_families.size > 1 ? operating_system_families : operating_system_families.first)} # GAH
      body = {
        :href  => uri,
        :type  => "application/vnd.tmrk.cloud.operatingSystemFamily; type=collection",
        :Links => {
          :Link => compute_pool,
        }
      }.merge(operating_system_family_response)

      response(:body => body)
    end

get_organization(uri) click to toggle source

    # File lib/fog/ecloud/requests/compute/get_organization.rb, line 10
    def get_organization(uri)
      organization_id = id_from_uri(uri)
      organization    = self.data[:organizations][organization_id]

      body = {
        :xmlns_i => "http://www.w3.org/2001/XMLSchema-instance",
        :href    => "/cloudapi/ecloud/organizations/",
        :type    => "application/vnd.tmrk.cloud.organization; type=collection"
      }.merge(organization)

      response(:body => body)
    end

get_organizations(uri) click to toggle source

    # File lib/fog/ecloud/requests/compute/get_organizations.rb, line 9
    def get_organizations(uri)
      organizations = self.data[:organizations].values.dup
      organizations.each{|org| org.delete(:id)}
      body = {
        :xmlns_i => "http://www.w3.org/2001/XMLSchema-instance",
        :href    => "/cloudapi/ecloud/organizations/",
        :type    => "application/vnd.tmrk.cloud.organization; type=collection"
      }.merge(:Organization => (organizations.size > 1 ? organizations : organizations.first))

      response(:body => body)
    end

get_public_ip(uri) click to toggle source

    # File lib/fog/ecloud/requests/compute/get_public_ip.rb, line 9
    def get_public_ip(uri)
      public_ip_id = id_from_uri(uri)
      public_ip    = self.data[:public_ips][public_ip_id]

      if public_ip
        response(:body => Fog::Ecloud.slice(public_ip, :id, :environment_id))
      else raise Fog::Errors::NotFound
      end
    end

get_public_ips(uri) click to toggle source

    # File lib/fog/ecloud/requests/compute/get_public_ips.rb, line 10
    def get_public_ips(uri)

      environment_id = id_from_uri(uri)
      environment    = self.data[:environments][environment_id]

      public_ips  = self.data[:public_ips].values.select{|cp| cp[:environment_id] == environment_id}

      public_ips = public_ips.map{|pi| Fog::Ecloud.slice(pi, :id, :environment_id)}

      public_ip_response = {:PublicIp => (public_ips.size > 1 ? public_ips : public_ips.first)} # GAH
      body = {
        :href  => uri,
        :type  => "application/vnd.tmrk.cloud.publicIp; type=collection",
        :Links => {
          :Link => environment,
        }
      }.merge(public_ip_response)

      response(:body => body)
    end

get_row(uri) click to toggle source

    # File lib/fog/ecloud/requests/compute/get_row.rb, line 9
    def get_row(uri)
      row_id = id_from_uri(uri)
      row = self.data[:rows][row_id]

      response(:body =>  row)
    end

get_server(uri) click to toggle source

    # File lib/fog/ecloud/requests/compute/get_server.rb, line 10
    def get_server(uri)
      server_id = uri.match(/(\d+)/)
      server_id = server_id.nil? ? nil : server_id[1].to_i
      server = self.data[:servers][server_id]
      if server
        response(:body => Fog::Ecloud.slice(server, :id, :compute_pool_id))
      else raise Fog::Errors::NotFound
      end
    end

get_servers(uri) click to toggle source

    # File lib/fog/ecloud/requests/compute/get_servers.rb, line 8
    def get_servers(uri)
      if uri =~ /layoutgroups/
        group_id        = id_from_uri(uri)
        group           = self.data[:groups][group_id]
        servers         = group[:VirtualMachines][:VirtualMachine]
        compute_pool_id = servers.first[:compute_pool_id] unless servers.empty?
        compute_pool    = self.data[:compute_pools][compute_pool_id] unless compute_pool_id.nil?
      elsif uri =~ /computepool/
        compute_pool_id = id_from_uri(uri)
        compute_pool    = self.data[:compute_pools][compute_pool_id]
        servers = self.data[:servers].values.select{|cp| cp[:compute_pool_id] == compute_pool_id}
        servers = servers.map{|server| Fog::Ecloud.slice(server, :id, :compute_pool_id)}
      end

      links = if compute_pool.nil?
                []
              else
                [Fog::Ecloud.keep(compute_pool, :name, :href, :type),]
              end

      server_response = {:VirtualMachine => (servers.size > 1 ? servers : servers.first)} # GAH
      body = {
        :href  => uri,
        :type  => "application/vnd.tmrk.cloud.virtualMachine; type=collection",
        :Links => {
          :Link => links
        }
      }.merge(server_response)

      response(:body => body)
    end

get_ssh_key(uri) click to toggle source

    # File lib/fog/ecloud/requests/compute/get_ssh_key.rb, line 10
    def get_ssh_key(uri)
      ssh_key_id = id_from_uri(uri).to_i
      ssh_key    = self.data[:ssh_keys][ssh_key_id.to_i]

      if ssh_key
        response(:body => Fog::Ecloud.slice(ssh_key, :id, :admin_organization))
      else response(:status => 404) # ?
      end
    end

get_ssh_keys(uri) click to toggle source

    # File lib/fog/ecloud/requests/compute/get_ssh_keys.rb, line 10
    def get_ssh_keys(uri)
      organization_id = id_from_uri(uri)
      organization    = self.data[:organizations][organization_id]

      ssh_keys = self.data[:ssh_keys].values.select{|key| key[:admin_organization_id] == organization_id}
      ssh_keys = ssh_keys.map{|key| Fog::Ecloud.slice(key, :id, :admin_organization)}

      ssh_key_response = {:SshKey => (ssh_keys.size > 1 ? ssh_keys : ssh_keys.first)} # GAH
      body = {
        :href  => "/cloudapi/ecloud/admin/organizations/#{organization_id}/sshKeys",
        :type  => "application/vnd.tmrk.cloud.sshKey; type=collection",
        :Links => {
          :Link => organization,
        },
      }.merge(ssh_key_response)

      response(:body => body)
    end

get_task(uri) click to toggle source

    # File lib/fog/ecloud/requests/compute/get_task.rb, line 8
    def get_task(uri)
    end

get_template(uri) click to toggle source

    # File lib/fog/ecloud/requests/compute/get_template.rb, line 10
    def get_template(uri)
      template_id, compute_pool_id = uri.match(/(\d+).*\/(\d+)$/).captures
      template    = self.data[:templates][template_id.to_i]

      if template
        response(:body => Fog::Ecloud.slice(template, :id, :environment))
      else response(:status => 404) # ?
      end
    end

get_templates(uri) click to toggle source

    # File lib/fog/ecloud/requests/compute/get_templates.rb, line 10
    def get_templates(uri) # /cloudapi/ecloud/computepools/compute_pools/534
      compute_pool_id = id_from_uri(uri)
      compute_pool    = self.data[:compute_pools][compute_pool_id]

      templates = self.data[:templates].values.select{|template| template[:compute_pool_id] == compute_pool_id}
      templates = templates.map{|template| Fog::Ecloud.slice(template, :id, :compute_pool)}

      template_response = {:Template => (templates.size > 1 ? templates : templates.first)} # GAH
      body = {
        :href  => uri,
        :type  => "application/vnd.tmrk.cloud.template; type=collection",
        :Links => {
          :Link => compute_pool,
        },
        :Families => {
          :Family => {
            :Name => "Standard Templates",
            :Categories => {
              :Category => [
                {
                  :Name => "OS Only",
                  :OperatingSystems => {
                    :OperatingSystem => {
                      :Name => "Linux",
                      :Templates => template_response,
                    }
                  }
                }
              ]
            }
          }
        }
      }

      response(:body => body)
    end

get_virtual_machine_assigned_ips(virtual_machine_id) click to toggle source

    # File lib/fog/ecloud/requests/compute/get_virtual_machine_assigned_ips.rb, line 15
    def get_virtual_machine_assigned_ips(virtual_machine_id)
      server         = self.data[:servers][virtual_machine_id.to_i]
      compute_pool   = self.data[:compute_pools][server[:compute_pool_id]]
      environment_id = compute_pool[:environment_id]
      environment    = self.data[:environments][environment_id]

      networks = self.data[:networks].values.select{|n| n[:environment_id] == environment_id}
      networks = networks.map{|n| deep_copy(Fog::Ecloud.slice(n, :environment, :id))}

      networks.each do |network|
        address = network[:IpAddresses][:IpAddress].map{|ia| ia[:name]}
        network[:IpAddresses][:IpAddress] = address.first
      end

      body = {
        :href  => "/cloudapi/ecloud/virtualMachines/#{virtual_machine_id}/assignedIps",
        :type  => "application/vnd.tmrk.cloud.network",
        :Links => {
          :Link => Fog::Ecloud.keep(environment, :name, :href, :type)
        },
        :Networks => {:Network => (networks.size > 1 ? networks : networks.first)},
      }

      response(:body =>  body)
    end

groups_delete(uri) click to toggle source

    # File lib/fog/ecloud/requests/compute/groups_delete.rb, line 9
    def groups_delete(uri)
      group_id = id_from_uri(uri)
      self.data[:groups].delete(group_id)
      self.data[:rows].values.each do |row|
        row[:Groups][:Group].delete_if { |g| g[:id] == group_id }
      end
      self.data[:layouts].values.each do |layout|
        layout[:Rows][:Row].each do |row|
          row[:Groups][:Group].delete_if { |g| g[:id] == group_id }
        end
      end

      response(:body =>  nil, :status => 204)
    end

internet_service_create(service_data) click to toggle source

    # File lib/fog/ecloud/requests/compute/internet_service_create.rb, line 67
    def internet_service_create(service_data)
      validate_internet_service_data(service_data)
      public_ip_id = service_data[:uri].match(/(\d+)/)[1]
      public_ip    = self.data[:public_ips][public_ip_id.to_i].dup
      service_id   = Fog::Mock.random_numbers(6).to_i
      service = {
        :href => "/cloudapi/ecloud/internetServices/#{service_id}",
        :name => service_data[:name],
        :type => "application/vnd.tmrk.cloud.internetService",
        :Links => {
          :Link => [
            Fog::Ecloud.keep(public_ip, :href, :name, :type),
          ],
        },
        :Protocol    => service_data[:protocol],
        :Port        => service_data[:port],
        :Enabled     => service_data[:enabled],
        :Description => service_data[:description],
        :PublicIp    => Fog::Ecloud.keep(public_ip, :href, :name, :type),
        :Persistence => {
          :Type => service_data[:persistence][:type],
        },
      }

      internet_service_response = response(:body => service)

      service.merge!(:public_ip => public_ip)

      self.data[:internet_services][service_id] = service

      internet_service_response
    end

internet_service_delete(uri) click to toggle source

    # File lib/fog/ecloud/requests/compute/internet_service_delete.rb, line 10
    def internet_service_delete(uri)
      service_id = id_from_uri(uri)

      service = self.data[:internet_services][service_id].dup
      self.data[:internet_services].delete(service_id)

      task_id = Fog::Mock.random_numbers(10).to_i
      task = {
        :id            => task_id,
        :href          => "/cloudapi/ecloud/tasks/#{task_id}",
        :type          => "application/vnd.tmrk.cloud.task",
        :Operation     => "Delete Service",
        :Status        => "Complete",
        :ImpactedItem  => Fog::Ecloud.keep(service, :name, :href, :type),
        :StartTime     => Time.now.iso8601,
        :CompletedTime => Time.now.iso8601,
        :InitiatedBy   => {},
      }
      self.data[:tasks][task_id] = task
      response(:body => task)
    end

node_service_create(service_data) click to toggle source

    # File lib/fog/ecloud/requests/compute/node_service_create.rb, line 45
    def node_service_create(service_data)
      validate_node_service_data(service_data)

      internet_service_id = service_data[:uri].match(/(\d+)/)[1]
      internet_service    = self.data[:internet_services][internet_service_id.to_i].dup
      network_id, ip_address_name     = service_data[:ip_address].match(/\/(\d+)\/(.*)$/).captures
      network = self.data[:networks][network_id.to_i]
      ip_addresses = network[:IpAddresses][:IpAddress]
      ip_addresses = ip_addresses.is_a?(Array) ? ip_addresses : [ip_addresses]
      ip_address = ip_addresses.detect { |ip| ip[:name] == ip_address_name }

      service_id   = Fog::Mock.random_numbers(6).to_i
      service = {
        :href => "/cloudapi/ecloud/nodeservices/#{service_id}",
        :name => service_data[:name],
        :type => "application/vnd.tmrk.cloud.nodeService",
        :Links => {
          :Link => [
            Fog::Ecloud.keep(internet_service, :href, :name, :type),
          ],
        },
        :Protocol    => service_data[:protocol],
        :Port        => service_data[:port],
        :Enabled     => service_data[:enabled],
        :Description => service_data[:description],
        :IpAddress   => {
          :href => ip_address[:href],
          :name => ip_address[:name],
          :type => ip_address[:type],
          :Network => {
            :href => network[:href],
            :name => network[:name],
            :type => network[:type],
          },
        },
      }

      node_service_response = response(:body => service)

      service.merge!(:internet_service => internet_service)

      self.data[:node_services][service_id] = service

      node_service_response
    end

node_service_delete(uri) click to toggle source

    # File lib/fog/ecloud/requests/compute/node_service_delete.rb, line 10
    def node_service_delete(uri)

      service_id = id_from_uri(uri)

      service = self.data[:node_services][service_id].dup
      self.data[:node_services].delete(service_id)

      task_id = Fog::Mock.random_numbers(10).to_i
      task = {
        :id            => task_id,
        :href          => "/cloudapi/ecloud/tasks/#{task_id}",
        :type          => "application/vnd.tmrk.cloud.task",
        :Operation     => "Delete Node Service",
        :Status        => "Complete",
        :ImpactedItem  => Fog::Ecloud.keep(service, :name, :href, :type),
        :StartTime     => Time.now.iso8601,
        :CompletedTime => Time.now.iso8601,
        :InitiatedBy   => {},
      }
      self.data[:tasks][task_id] = task
      response(:body => task)
    end

reset_data() click to toggle source

    # File lib/fog/ecloud/compute.rb, line 803
    def reset_data
      self.class.data.delete(@ecloud_api_key)
    end

response(params={}) click to toggle source

    # File lib/fog/ecloud/compute.rb, line 807
    def response(params={})
      body    = params[:body]
      headers = {
        "Content-Type" => "application/xml"
      }.merge(params[:headers] || {})
      status  = params[:status] || 200

      response = Excon::Response.new(:body => body, :headers => headers, :status => status)
      if params.has_key?(:expects) && ![*params[:expects]].include?(response.status)
        raise(Excon::Errors.status_error(params, response))
      else response
      end
    end

rows_delete(uri) click to toggle source

    # File lib/fog/ecloud/requests/compute/rows_delete.rb, line 9
    def rows_delete(uri)
      row_id = id_from_uri(uri)
      self.data[:rows].delete(row_id)
      self.data[:layouts].values.each do |layout|
        layout[:Rows][:Row].delete_if { |r| r[:id] == row_id }
      end

      response(:body =>  nil, :status => 204)
    end

virtual_machine_attach_disk(href, options) click to toggle source

    # File lib/fog/ecloud/requests/compute/virtual_machine_attach_disk.rb, line 31
    def virtual_machine_attach_disk(href, options)
      server_id        = href.match(/(\d+)/)[1].to_i
      server           = self.data[:servers][server_id]
      compute_pool_id  = server[:compute_pool_id]
      compute_pool     = self.data[:compute_pools][compute_pool_id]
      detached_disk_id = options[:href].match(/(\d+)/)[1].to_i
      detached_disk    = self.data[:detached_disks][detached_disk_id]
      new_index        = (server[:HardwareConfiguration][:Disks][:Disk].map { |h| h[:Index].to_i }.sort.last + 1).to_s
      detached_disk[:Index] = new_index
      server[:HardwareConfiguration][:Disks][:Disk] << Fog::Ecloud.keep(detached_disk, :Index, :Size, :Name)

      self.data[:detached_disks].delete(detached_disk_id)

      task_id = Fog::Mock.random_numbers(10).to_i
      task = {
        :id            => task_id,
        :href          => "/cloudapi/ecloud/tasks/#{task_id}",
        :type          => "application/vnd.tmrk.cloud.task",
        :Operation     => "Attach Disk",
        :Status        => "Complete",
        :ImpactedItem  => Fog::Ecloud.keep(server, :href, :type),
        :StartTime     => Time.now.iso8601,
        :CompletedTime => Time.now.iso8601,
        :InitiatedBy   => {},
      }
      self.data[:tasks][task_id] = task
      response(:body => task)
    end

virtual_machine_create_from_template(template_uri, options) click to toggle source

    # File lib/fog/ecloud/requests/compute/virtual_machine_create_from_template.rb, line 117
    def virtual_machine_create_from_template(template_uri, options)
      options                      = validate_create_server_options(template_uri, options)
      server_id                    = Fog::Mock.random_numbers(7).to_i
      row_id                       = Fog::Mock.random_numbers(6).to_i
      group_id                     = Fog::Mock.random_numbers(6).to_i
      template_id, compute_pool_id = template_uri.match(/\/templates\/(\d+)\/computepools\/(\d+)$/).captures
      compute_pool                 = self.data[:compute_pools][compute_pool_id.to_i].dup
      environment                  = self.data[:environments][compute_pool[:environment_id]]
      layout                       = self.data[:layouts][environment[:id]]
      networks                     = options[:network_uri]
      nics                         = networks.each_with_index.map do |network, i|
        {
          :UnitNumber => i.to_s,
          :Name       => "Network adapter #{i}",
          :MacAddress => Fog::Ecloud.mac_address,
          :Network    => Fog::Ecloud.keep(network, :name, :href, :type),
        }
      end

      links = [Fog::Ecloud.keep(compute_pool, :name, :href, :type), Fog::Ecloud.keep(environment, :name, :href, :type)]
      networks.each do |network|
        links << Fog::Ecloud.keep(network, :name, :href, :type)
        network_id = id_from_uri(network[:href])
        ip = self.data[:networks][network_id][:IpAddresses][:IpAddress].detect { |ip| ip[:id] = network[:ip] }
        ip[:DetectedOn] = {:href => "/cloudapi/ecloud/networkhosts/#{server_id}", :name => options[:name], :type => "application/vnd.tmrk.cloud.networkHost"}
        ip[:Host]       = {:href => "/cloudapi/ecloud/networkhosts/#{server_id}", :name => options[:name], :type => "application/vnd.tmrk.cloud.networkHost"}
      end

      server = {
        :href                  => "/cloudapi/ecloud/virtualmachines/#{server_id}",
        :name                  => options[:name],
        :type                  => "application/vnd.tmrk.cloud.virtualMachine",
        :Description           => options[:description],
        :Status                => "Deployed",
        :HardwareConfiguration => {
          :href => "/cloudapi/ecloud/virtualmachines/#{server_id}/hardwareconfiguration",
          :type => "application/vnd.tmrk.cloud.virtualMachineHardware",
          :Links => {
            :Link => {
              :href => "/cloudapi/ecloud/virtualmachines/#{server_id}",
              :name => options[:name],
              :type => "application/vnd.tmrk.cloud.virtualMachine",
              :rel  => "up",
            }
          },
          :ProcessorCount => options[:cpus],
          :Memory => {
            :Unit  => "MB",
            :Value => options[:memory],
          },
          :Disks => {
            :Disk => [{
              :Index => "0",
              :Name  => "Hard Disk 1",
              :Size  => {
                :Unit  => "GB",
                :Value => "25",
              },
            }],
          },
          :Nics => {
            :Nic => nics,
          },
        },
        :IpAddresses => {
          :AssignedIpAddresses => {
            :Networks => {
              :Network => self.data[:networks].dup.values,
            }
          }
        },
        :Links => { :Link => links },
      }

      row = {
        :id => row_id,
        :name => options[:row],
        :href => "/cloudapi/ecloud/layoutrows/#{row_id}",
        :type => "application/vnd.tmrk.cloud.layoutRow",
        :Links => {
          :Link => [
            Fog::Ecloud.keep(environment, :name, :href, :type)
          ],
        },
        :Index => 0,
        :Groups => {
          :Group => [
          ],
        },
        :environment_id => environment[:id],
      }

      group = {
        :id => group_id,
        :name => options[:group],
        :href => "/cloudapi/ecloud/layoutgroups/#{group_id}",
        :type => "application/vnd.tmrk.cloud.layoutGroup",
        :Links => {
          :Link => [
            Fog::Ecloud.keep(row, :name, :href, :type),
          ],
        },
        :Index => 0,
        :VirtualMachines => {
          :VirtualMachine => [
            server,
          ],
        },
        :row_id => row_id,
      }
      row[:Groups][:Group].push(group)
      layout[:Rows][:Row].push(row)

      server.merge!(:OperatingSystem => options[:operating_system].merge(:type => "application/vnd.tmrk.cloud.operatingSystem")) if options[:operating_system]

      server_response = response(:body =>  server)

      server.merge!(:compute_pool_id => compute_pool[:id])

      self.data[:servers][server_id] = server
      self.data[:rows][row_id]       = row
      self.data[:groups][group_id]   = group

      server_response
    end

virtual_machine_delete(uri) click to toggle source

    # File lib/fog/ecloud/requests/compute/virtual_machine_delete.rb, line 9
    def virtual_machine_delete(uri)
      server_id = id_from_uri(uri)

      server = self.data[:servers][server_id]
      self.data[:servers].delete(server_id)
      self.data[:groups].values.each do |group|
        group[:VirtualMachines][:VirtualMachine].delete_if { |s| s[:name] == server[:name] }
      end
      self.data[:networks].values.each do |network|
        network[:IpAddresses][:IpAddress].each do |ip|
          unless ip[:Host].nil?
            ip[:Host] = nil if ip[:Host][:name] == server[:name]
          end
          unless ip[:DetectedOn].nil?
            ip[:DetectedOn] = nil if ip[:DetectedOn][:name] == server[:name]
          end
        end
      end
      task_id = Fog::Mock.random_numbers(10)
      task = {
        :id            => task_id,
        :href          => "/cloudapi/ecloud/tasks/#{task_id}",
        :type          => "application/vnd.tmrk.cloud.task",
        :Operation     => "Delete Server",
        :Status        => "Complete",
        :ImpactedItem  => Fog::Ecloud.keep(server, :name, :href, :type),
        :StartTime     => Time.now.iso8601,
        :CompletedTime => Time.now.iso8601,
        :InitiatedBy   => {},
      }
      self.data[:tasks][task_id] = task

      response(:body =>  task)
    end

virtual_machine_detach_disk(href, options) click to toggle source

    # File lib/fog/ecloud/requests/compute/virtual_machine_detach_disk.rb, line 32
    def virtual_machine_detach_disk(href, options)
      server_id        = href.match(/(\d+)/)[1].to_i
      server           = self.data[:servers][server_id]
      compute_pool_id  = server[:compute_pool_id]
      compute_pool     = self.data[:compute_pools][compute_pool_id]
      detached_disk_id = Fog::Mock.random_numbers(6).to_i
      detached_disk    = {
        :id              => detached_disk_id,
        :href            => "/cloudapi/ecloud/detacheddisks/#{detached_disk_id}",
        :name            => options[:name],
        :type            => "application/vnd.tmrk.cloud.detachedDisk",
        :Links => {
          :Link => [
            Fog::Ecloud.keep(compute_pool, :href, :name, :type),
          ],
        },
        :Description => options[:description],
        :LastKnownVirtualMachineConfiguration => Fog::Ecloud.keep(server, :name, :ProcessorCount, :Memory, :OperatingSystem),
        :Type => "Data",
        :Size => {
          :Unit  => "GB",
          :Value => options[:disk][:Size][:Value],
        },
        :Status => "Available",
      }

      server[:HardwareConfiguration][:Disks][:Disk].delete_if { |disk| disk[:Index] == options[:disk][:Index] }

      detached_disk_response = response(:body => detached_disk)

      detached_disk.merge!(:compute_pool_id => compute_pool_id)

      self.data[:detached_disks][detached_disk_id] = detached_disk

      detached_disk_response
    end

virtual_machine_edit_assigned_ips(href, options) click to toggle source

    # File lib/fog/ecloud/requests/compute/virtual_machine_edit_assigned_ips.rb, line 40
    def virtual_machine_edit_assigned_ips(href, options)
      server_id       = href.match(/(\d+)/)[1].to_i
      server          = self.data[:servers][server_id]
      options.each do |network|
        network_id     = id_from_uri(network[:href])
        network        = self.data[:networks][network_id]
        options.each.each do |net|
          net[:ips].each do |ip|
            ip = network[:IpAddresses][:IpAddress].detect { |iph| iph[:name] == ip }
            ip[:Host] = {
              :href => "/clouapi/ecloud/networkhosts/#{server_id}",
              :name => server[:name],
              :type => "application/vnd.tmrk.cloud.networkHost"
            }
            ip[:DetectedOn] = {
              :href => "/clouapi/ecloud/networkhosts/#{server_id}",
              :name => server[:name],
              :type => "application/vnd.tmrk.cloud.networkHost"
            }
          end
        end
      end

      task_id = Fog::Mock.random_numbers(10)
      task = {
        :id            => task_id,
        :href          => "/cloudapi/ecloud/tasks/#{task_id}",
        :type          => "application/vnd.tmrk.cloud.task",
        :Operation     => "Delete Server",
        :Status        => "Complete",
        :ImpactedItem  => Fog::Ecloud.keep(server, :name, :href, :type),
        :StartTime     => Time.now.iso8601,
        :CompletedTime => Time.now.iso8601,
        :InitiatedBy   => {},
      }
      self.data[:tasks][task_id] = task

      response(:body =>  task)
    end

virtual_machine_edit_hardware_configuration(vm_uri, data) click to toggle source

    # File lib/fog/ecloud/requests/compute/virtual_machine_edit_hardware_configuration.rb, line 53
    def virtual_machine_edit_hardware_configuration(vm_uri, data)

      server_id = vm_uri.match(/(\d+)/)[1]

      server  = self.data[:servers][server_id.to_i]
      task_id = Fog::Mock.random_numbers(10)
      task = {
        :id            => task_id,
        :href          => "/cloudapi/ecloud/tasks/#{task_id}",
        :type          => "application/vnd.tmrk.cloud.task",
        :Operation     => "Configure Server",
        :Status        => "Complete",
        :ImpactedItem  => Fog::Ecloud.keep(server, :name, :href, :type),
        :StartTime     => Time.now.iso8601,
        :CompletedTime => Time.now.iso8601,
        :InitiatedBy   => {},
      }
      self.data[:tasks][task_id] = task

      response(:body =>  task)
    end

virtual_machine_import(template_uri, options) click to toggle source

    # File lib/fog/ecloud/requests/compute/virtual_machine_import.rb, line 66
    def virtual_machine_import(template_uri, options)
      options         = validate_import_server_options(template_uri, options)

      compute_pool_id = options[:uri].match(/computePools\/(\d+)/)[1].to_i
      compute_pool    = self.data[:compute_pools][compute_pool_id].dup
      environment     = self.data[:environments][compute_pool[:environment_id]]
      networks        = options[:network_uri].map{|nuri| self.data[:networks][id_from_uri(nuri)].dup}
      server_id       = Fog::Mock.random_numbers(6).to_i
      row_id          = Fog::Mock.random_numbers(6).to_i
      group_id        = Fog::Mock.random_numbers(6).to_i
      nics            = networks.each_with_index.map do |network, i|
        {
          :UnitNumber => i.to_s,
          :Name       => "Network adapter #{i}",
          :MacAddress => Fog::Ecloud.mac_address,
          :Network    => Fog::Ecloud.keep(network, :name, :href, :type)
        }
      end

      links = [Fog::Ecloud.keep(compute_pool, :name, :href, :type), Fog::Ecloud.keep(environment, :name, :href, :type)]
      networks.each{|network| links << Fog::Ecloud.keep(network, :name, :href, :type)}
      server = {
        :href        => "/cloudapi/ecloud/virtualmachines/#{server_id}",
        :name        => options[:name],
        :type        => "application/vnd.tmrk.cloud.virtualMachine",
        :Description => options[:description],
        :Status      => "Deployed",
        :PoweredOn   => "false",
        :HardwareConfiguration => {
          :href => "/cloudapi/ecloud/virtualmachines/#{server_id}/hardwareconfiguration",
          :type => "application/vnd.tmrk.cloud.virtualMachineHardware",
          :Links => {
            :Link => {
              :href => "/cloudapi/ecloud/virtualmachines/#{server_id}",
              :name => options[:name],
              :type => "application/vnd.tmrk.cloud.virtualMachine",
              :rel  => "up"
            }
          },
          :ProcessorCount => options[:cpus],
          :Memory => {
            :Unit  => "MB",
            :Value => options[:memory],
          },
          :Disks => { # Default drive
            :Disk => [{
              :Index => "0",
              :Name  => "Hard Disk 1",
              :Size  => {
                :Unit  => "GB",
                :Value => "25"
              },
            }],
          },
          :Nics => {
            :Nic => nics,
          },
        },
        :Links => { :Link => links },
      }

      row = {
        :id => row_id,
        :name => options[:row],
        :href => "/cloudapi/ecloud/layoutrows/#{row_id}",
        :type => "application/vnd.tmrk.cloud.layoutRow",
        :Links => {
          :Link => [
            Fog::Ecloud.keep(environment, :name, :href, :type)
          ],
        },
        :Index => 0,
        :Groups => {
          :Group => [
          ],
        },
        :environment_id => environment[:id],
      }

      group = {
        :id => group_id,
        :name => options[:group],
        :href => "/cloudapi/ecloud/layoutgroups/#{group_id}",
        :type => "application/vnd.tmrk.cloud.layoutGroup",
        :Links => {
          :Link => [
            Fog::Ecloud.keep(row, :name, :href, :type),
          ],
        },
        :Index => 0,
        :VirtualMachines => {
          :VirtualMachine => [
            server,
          ],
        },
        :row_id => row_id,
      }
      row[:Groups][:Group].push(group)
      layout[:Rows][:Row].push(row)

      server.merge!(:OperatingSystem => options[:operating_system].merge(:type => "application/vnd.tmrk.cloud.operatingSystem")) if options[:operating_system]

      server_response = response(:body =>  server)

      server.merge!(:compute_pool_id => compute_pool_id)

      self.data[:servers][server_id] = server
      self.data[:rows][row_id]       = row
      self.data[:groups][group_id]   = group

      server_response
    end

[Validate]

Generated with the Darkfish Rdoc Generator 2.