### Home Classes Methods

### In Files

- lib/fog/aws/rds.rb
- lib/fog/aws/requests/rds/delete_db_security_group.rb
- lib/fog/aws/requests/rds/describe_db_engine_versions.rb
- lib/fog/aws/requests/rds/create_db_snapshot.rb
- lib/fog/aws/requests/rds/create_db_security_group.rb
- lib/fog/aws/requests/rds/create_db_subnet_group.rb
- lib/fog/aws/requests/rds/add_tags_to_resource.rb
- lib/fog/aws/requests/rds/restore_db_instance_to_point_in_time.rb
- lib/fog/aws/requests/rds/describe_db_snapshots.rb
- lib/fog/aws/requests/rds/create_db_instance_read_replica.rb
- lib/fog/aws/requests/rds/delete_db_snapshot.rb
- lib/fog/aws/requests/rds/describe_db_instances.rb
- lib/fog/aws/requests/rds/list_tags_for_resource.rb
- lib/fog/aws/requests/rds/modify_db_instance.rb
- lib/fog/aws/requests/rds/describe_db_parameter_groups.rb
- lib/fog/aws/requests/rds/authorize_db_security_group_ingress.rb
- lib/fog/aws/requests/rds/modify_db_parameter_group.rb
- lib/fog/aws/requests/rds/describe_db_parameters.rb
- lib/fog/aws/requests/rds/remove_tags_from_resource.rb
- lib/fog/aws/requests/rds/revoke_db_security_group_ingress.rb
- lib/fog/aws/requests/rds/create_db_instance.rb
- lib/fog/aws/requests/rds/describe_db_subnet_groups.rb
- lib/fog/aws/requests/rds/delete_db_parameter_group.rb
- lib/fog/aws/requests/rds/restore_db_instance_from_db_snapshot.rb
- lib/fog/aws/requests/rds/create_db_parameter_group.rb
- lib/fog/aws/requests/rds/describe_db_security_groups.rb
- lib/fog/aws/requests/rds/describe_events.rb
- lib/fog/aws/requests/rds/reboot_db_instance.rb
- lib/fog/aws/requests/rds/delete_db_instance.rb
- lib/fog/aws/requests/rds/describe_db_reserved_instances.rb

### Parent

Object

### Methods

- ::data
- ::new
- ::reset
- #add_tags_to_resource
- #authorize_db_security_group_ingress
- #create_db_instance
- #create_db_instance_read_replica
- #create_db_parameter_group
- #create_db_security_group
- #create_db_snapshot
- #create_db_subnet_group
- #data
- #delete_db_instance
- #delete_db_parameter_group
- #delete_db_security_group
- #delete_db_snapshot
- #describe_db_engine_versions
- #describe_db_instances
- #describe_db_parameter_groups
- #describe_db_parameters
- #describe_db_reserved_instances
- #describe_db_security_groups
- #describe_db_snapshots
- #describe_db_subnet_groups
- #describe_events
- #list_tags_for_resource
- #modify_db_instance
- #modify_db_parameter_group
- #reboot_db_instance
- #remove_tags_from_resource
- #reset_data
- #restore_db_instance_from_db_snapshot
- #restore_db_instance_to_point_in_time
- #revoke_db_security_group_ingress
- #setup_credentials

### Files

- README_HP.rdoc

### 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::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::DNS
- Fog::Bluebox::DNS::Mock
- Fog::Bluebox::DNS::Real
- Fog::Brightbox
- 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::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::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::Unauthorized
- Fog::Compute::Cloudstack::Volume
- Fog::Compute::Cloudstack::Volumes
- Fog::Compute::Cloudstack::Zone
- Fog::Compute::Cloudstack::Zones
- 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::Ips
- Fog::Compute::Glesys::Mock
- Fog::Compute::Glesys::Real
- Fog::Compute::Glesys::Server
- Fog::Compute::Glesys::Servers
- 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::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::Mock
- Fog::Compute::HP::Real
- Fog::Compute::HP::SecurityGroup
- Fog::Compute::HP::SecurityGroups
- Fog::Compute::HP::Server
- Fog::Compute::HP::Servers
- 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::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::MetaParent
- Fog::Compute::RackspaceV2::Metadata
- Fog::Compute::RackspaceV2::Metadatum
- Fog::Compute::RackspaceV2::Mock
- 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::VirtualBox
- Fog::Compute::VirtualBox::Medium
- Fog::Compute::VirtualBox::MediumFormat
- Fog::Compute::VirtualBox::Mediums
- Fog::Compute::VirtualBox::Mock
- Fog::Compute::VirtualBox::NATEngine
- Fog::Compute::VirtualBox::NATRedirect
- Fog::Compute::VirtualBox::NATRedirects
- Fog::Compute::VirtualBox::NetworkAdapter
- Fog::Compute::VirtualBox::NetworkAdapters
- Fog::Compute::VirtualBox::Real
- Fog::Compute::VirtualBox::Server
- Fog::Compute::VirtualBox::Servers
- Fog::Compute::VirtualBox::StorageController
- Fog::Compute::VirtualBox::StorageControllers
- 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::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::VbdMetrics
- Fog::Compute::XenServer::Vbds
- Fog::Compute::XenServer::Vdis
- Fog::Compute::XenServer::Vifs
- 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::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::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::TimeoutError
- Fog::Glesys
- Fog::Glesys::Compute
- Fog::Glesys::Compute::Ip
- Fog::Glesys::Compute::Template
- Fog::GoGrid
- Fog::Google
- Fog::Google::Mock
- Fog::Google::Storage
- Fog::Google::Storage::Mock
- Fog::Google::Storage::Real
- Fog::HMAC
- Fog::HP
- Fog::HP::Errors
- Fog::HP::Errors::BadRequest
- Fog::HP::Errors::Conflict
- 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::JSON
- 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::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::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::NotFound
- 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::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::Rake
- Fog::Rake::ChangelogTask
- Fog::Rake::TestTask
- Fog::SCP
- Fog::SCP::Mock
- Fog::SCP::Real
- Fog::SSH
- Fog::SSH::Mock
- Fog::SSH::Real
- Fog::SSH::Result
- 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::Utils
- 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::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::Rackspace
- Fog::Storage::Rackspace::Directories
- Fog::Storage::Rackspace::Directory
- Fog::Storage::Rackspace::File
- Fog::Storage::Rackspace::Files
- Fog::Storage::Rackspace::Mock
- Fog::Storage::Rackspace::Real
- 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::VirtualBox
- 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
- Dynect
- Ecloud
- Glesys
- GoGrid
- Google
- HP
- Hash
- IBM
- IPAddr
- Joyent
- Libvirt
- Linode
- Local
- Ninefold
- OpenStack
- Ovirt
- Rackspace
- Serverlove
- StormOnDemand
- String
- Terremark
- VAppStatus
- Vcloud
- VirtualBox
- Vmfusion
- Voxel
- Vsphere
- XenServer
- Zerigo

No matching classes.

# Fog::AWS::RDS::Mock

### Public Class Methods

data() click to toggle source

    # File lib/fog/aws/rds.rb, line 73
    def self.data
      @data ||= Hash.new do |hash, region|
        hash[region] = Hash.new do |region_hash, key|
          region_hash[key] = {
            :servers => {},
            :security_groups => {},
            :subnet_groups => {},
            :snapshots => {},
            :parameter_groups => {"default.mysql5.1" => { "DBParameterGroupFamily"=>"mysql5.1",
                                                          "Description"=>"Default parameter group for mysql5.1",
                                                          "DBParameterGroupName"=>"default.mysql5.1"
                                                        },
                                  "default.mysql5.5" => {"DBParameterGroupFamily"=>"mysql5.5",
                                                        "Description"=>"Default parameter group for mysql5.5",
                                                        "DBParameterGroupName"=>"default.mysql5.5"
                                                        }
                                  }
                             }
        end
      end
    end

new(options={}) click to toggle source

    # File lib/fog/aws/rds.rb, line 99
    def initialize(options={})

      @use_iam_profile = options[:use_iam_profile]
      @region = options[:region] || 'us-east-1'

      unless ['ap-northeast-1', 'ap-southeast-1', 'ap-southeast-2', 'eu-west-1', 'us-east-1', 'us-west-1', 'us-west-2', 'sa-east-1'].include?(@region)
        raise ArgumentError, "Unknown region: #{@region.inspect}"
      end

    end

reset() click to toggle source

    # File lib/fog/aws/rds.rb, line 95
    def self.reset
      @data = nil
    end

### Public Instance Methods

add_tags_to_resource(rds_id, tags) click to toggle source

    # File lib/fog/aws/requests/rds/add_tags_to_resource.rb, line 29
    def add_tags_to_resource(rds_id, tags)
      response = Excon::Response.new
      if server = self.data[:servers][rds_id]
        self.data[:tags][rds_id].merge! tags
        response.status = 200
        response.body = {
          "ResponseMetadata"=>{ "RequestId"=> Fog::AWS::Mock.request_id }
        }
        response
      else
        raise Fog::AWS::RDS::NotFound.new("DBInstance #{rds_id} not found")
      end
    end

authorize_db_security_group_ingress(name, opts = {}) click to toggle source

    # File lib/fog/aws/requests/rds/authorize_db_security_group_ingress.rb, line 35
    def authorize_db_security_group_ingress(name, opts = {})
      unless opts.key?('CIDRIP') || (opts.key?('EC2SecurityGroupName') && opts.key?('EC2SecurityGroupOwnerId'))
        raise ArgumentError, 'Must specify CIDRIP, or both EC2SecurityGroupName and EC2SecurityGroupOwnerId'
      end

      response = Excon::Response.new

      if sec_group = self.data[:security_groups][name]
        if opts.key?('CIDRIP')
          if sec_group['IPRanges'].detect{|h| h['CIDRIP'] == opts['CIDRIP']}
            raise Fog::AWS::RDS::AuthorizationAlreadyExists.new("AuthorizationAlreadyExists => #{opts['CIDRIP']} is alreay defined")
          end
          sec_group['IPRanges'] << opts.merge({"Status" => 'authorizing'})
        else
          if sec_group['EC2SecurityGroups'].detect{|h| h['EC2SecurityGroupName'] == opts['EC2SecurityGroupName']}
            raise Fog::AWS::RDS::AuthorizationAlreadyExists.new("AuthorizationAlreadyExists => #{opts['EC2SecurityGroupName']} is alreay defined")
          end
          sec_group['EC2SecurityGroups'] << opts.merge({"Status" => 'authorizing'})
        end
        response.status = 200
        response.body = {
          "ResponseMetadata"=>{ "RequestId"=> Fog::AWS::Mock.request_id },
          'AuthorizeDBSecurityGroupIngressResult' => {
            'DBSecurityGroup' => sec_group
          }
        }
        response
      else
        raise Fog::AWS::RDS::NotFound.new("DBSecurityGroupNotFound => #{name} not found")
      end

    end

create_db_instance(db_name, options={}) click to toggle source

    # File lib/fog/aws/requests/rds/create_db_instance.rb, line 50
            def create_db_instance(db_name, options={})
              response = Excon::Response.new
              if self.data[:servers] and self.data[:servers][db_name]
                # I don't know how to raise an exception that contains the excon data
                #response.status = 400
                #response.body = {
                #  'Code' => 'DBInstanceAlreadyExists',
                #  'Message' => "DB Instance already exists"
                #}
                #return response
                raise Fog::AWS::RDS::IdentifierTaken.new("DBInstanceAlreadyExists #{response.body.to_s}")
              end

              # These are the required parameters according to the API
              required_params = %{AllocatedStorage DBInstanceClass Engine MasterUserPassword MasterUsername }
              required_params.each do |key|
                unless options.has_key?(key) and options[key] and !options[key].to_s.empty?
                  #response.status = 400
                  #response.body = {
                  #  'Code' => 'MissingParameter',
                  #  'Message' => "The request must contain the parameter #{key}"
                  #}
                  #return response
                  raise Fog::AWS::RDS::NotFound.new("The request must contain the parameter #{key}")
                end
              end

              data =
                  {
                     "DBInstanceIdentifier"=> db_name,
                     "DBName" => options["DBName"],
                     "InstanceCreateTime" => nil,
                     "AutoMinorVersionUpgrade"=>true,
                     "Endpoint"=>{},
                     "ReadReplicaDBInstanceIdentifiers"=>[],
                     "PreferredMaintenanceWindow"=>"mon:04:30-mon:05:00",
                     "Engine"=> options["Engine"],
                     "EngineVersion"=> options["EngineVersion"] || "5.5.12",
                     "PendingModifiedValues"=>{"MasterUserPassword"=>"****"}, # This clears when is available
                     "MultiAZ"=> !!options['MultiAZ'],
                     "MasterUsername"=> options["MasterUsername"],
                     "DBInstanceClass"=> options["DBInstanceClass"],
                     "DBInstanceStatus"=>"creating",
                     "BackupRetentionPeriod"=> options["BackupRetentionPeriod"] || 1,
                     "AllocatedStorage"=> options["AllocatedStorage"],
                     "DBParameterGroups"=> # I think groups should be in the self.data method
                              [{"DBParameterGroupName"=>"default.mysql5.5",
                                "ParameterApplyStatus"=>"in-sync"}],
                     "DBSecurityGroups"=>
                              [{"Status"=>"active",
                                "DBSecurityGroupName"=>"default"}],
                     "LicenseModel"=>"general-public-license",
                     "PreferredBackupWindow"=>"08:00-08:30",
    #                 "ReadReplicaSourceDBInstanceIdentifier" => nil,
    #                 "LatestRestorableTime" => nil,
                     "AvailabilityZone" => options["AvailabilityZone"],
                     "DBSubnetGroupName" => options["DBSubnetGroupName"]
                 }

              self.data[:servers][db_name] = data
              response.body = {
                "ResponseMetadata"=>{ "RequestId"=> Fog::AWS::Mock.request_id },
                "CreateDBInstanceResult"=> {"DBInstance"=> data}
              }
              response.status = 200
              # This values aren't showed at creating time but at available time
              self.data[:servers][db_name]["InstanceCreateTime"] = Time.now
              self.data[:tags] ||= {}
              self.data[:tags][db_name] = {}
              response
            end

create_db_instance_read_replica(instance_identifier, source_identifier, options={}) click to toggle source

    # File lib/fog/aws/requests/rds/create_db_instance_read_replica.rb, line 35
    def create_db_instance_read_replica(instance_identifier, source_identifier, options={})
      # TODO: throw error when instance_identifier already exists,
      # or source_identifier doesn't exist

      source = self.data[:servers][source_identifier]
      data = {
        'AllocatedStorage' => source['AllocatedStorage'],
        'AutoMinorVersionUpgrade' => options.key?('AutoMinorVersionUpgrade') ? options['AutoMinorVersionUpgrade'] : true,
        'AvailabilityZone' => options['AvailabilityZone'],
        'DBInstanceClass' => options['DBInstanceClass'] || 'db.m1.small',
        'DBInstanceIdentifier' => instance_identifier,
        'DBInstanceStatus' => 'creating',
        'DBName' => source['DBName'],
        'DBParameterGroups' => source['DBParameterGroups'],
        'DBSecurityGroups' => source['DBSecurityGroups'],
        'Endpoint' => {},
        'Engine' => source['Engine'],
        'EngineVersion' => options['EngineVersion'] || '5.5.12',
        'InstanceCreateTime' => nil,
        'LatestRestorableTime' => nil,
        'LicenseModel' => 'general-public-license',
        'MasterUsername' => source['MasterUsername'],
        'MultiAZ' => false,
        'PendingModifiedValues' => {},
        'PreferredBackupWindow'=> '08:00-08:30',
        'PreferredMaintenanceWindow'=> "mon:04:30-mon:05:00",
        'ReadReplicaDBInstanceIdentifiers'=> [],
        'ReadReplicaSourceDBInstanceIdentifier'=> source_identifier
      }
      self.data[:servers][instance_identifier] = data
      self.data[:servers][source_identifier]['ReadReplicaDBInstanceIdentifiers'] << instance_identifier

      response = Excon::Response.new
      response.body = {
        "ResponseMetadata"=>{ "RequestId"=> Fog::AWS::Mock.request_id },
        "CreateDBInstanceReadReplicaResult"=> {"DBInstance"=> data}
      }
      response.status = 200
      # This values aren't showed at creating time but at available time
      self.data[:servers][instance_identifier]["InstanceCreateTime"] = Time.now

      response
    end

create_db_parameter_group(group_name, group_family, description) click to toggle source

    # File lib/fog/aws/requests/rds/create_db_parameter_group.rb, line 34
    def create_db_parameter_group(group_name, group_family, description)
      response = Excon::Response.new
      if self.data[:parameter_groups] and self.data[:parameter_groups][group_name]
        raise Fog::AWS::RDS::IdentifierTaken.new("Parameter group #{group_name} already exists")
      end

      data = {
        'DBParameterGroupName' => group_name,
        'DBParameterGroupFamily' => group_family.downcase,
        'Description' => description
      }
      self.data[:parameter_groups][group_name] = data

      response.body = {
        "ResponseMetadata"=>{ "RequestId"=> Fog::AWS::Mock.request_id },
        "CreateDBParameterGroupResult"=> {"DBParameterGroup"=> data}
      }
      response.status = 200
      response

    end

create_db_security_group(name, description = name) click to toggle source

    # File lib/fog/aws/requests/rds/create_db_security_group.rb, line 29
    def create_db_security_group(name, description = name)
      response = Excon::Response.new
      if self.data[:security_groups] and self.data[:security_groups][name]
        raise Fog::AWS::RDS::IdentifierTaken.new("DBInstanceAlreadyExists => The security group '#{name}' already exists")
      end

      data = {
        'DBSecurityGroupName' => name,
        'DBSecurityGroupDescription' => description,
        'EC2SecurityGroups' => [],
        'IPRanges' => [],
        'OwnerId' => '0123456789'
      }
      self.data[:security_groups][name] = data
      response.body = {
        "ResponseMetadata"=>{ "RequestId"=> Fog::AWS::Mock.request_id },
        'CreateDBSecurityGroupResult' => { 'DBSecurityGroup' => data }
      }
      response

    end

create_db_snapshot(identifier, name) click to toggle source

    # File lib/fog/aws/requests/rds/create_db_snapshot.rb, line 29
    def create_db_snapshot(identifier, name)
      response = Excon::Response.new
      if data[:snapshots][name]
        raise Fog::AWS::RDS::IndentifierTaken.new
      end

      server_data = data[:servers][identifier]
      unless server_data
        raise Fog::AWS::RDS::NotFound.new("DBInstance #{identifier} not found")
      end

      # TODO: raise an error if the server isn't in 'available' state

      snapshot_data = {
        'Status'               => 'creating',
        'SnapshotType'         => 'manual',
        'DBInstanceIdentifier' => identifier,
        'DBSnapshotIdentifier' => name,
        'InstanceCreateTime'   => Time.now
      }
      # Copy attributes from server
      %(Engine EngineVersion AvailabilityZone AllocatedStorage MasterUsername InstanceCreateTime).each do |key|
        snapshot_data[key] = server_data[key]
      end
      snapshot_data['Port'] = server_data['Endpoint']['Port']

      self.data[:snapshots][name] = snapshot_data

      # TODO: put the server in 'modifying' state

      response.body = {
        "ResponseMetadata"=>{ "RequestId"=> Fog::AWS::Mock.request_id },
        "CreateDBSnapshotResult"=> {"DBSnapshot"=> snapshot_data.dup}
      }
      response.status = 200
      # SnapshotCreateTime is not part of the response.
      self.data[:snapshots][name]['SnapshotCreateTime'] = Time.now
      response

    end

create_db_subnet_group(name, subnet_ids, description = name) click to toggle source

    # File lib/fog/aws/requests/rds/create_db_subnet_group.rb, line 30
    def create_db_subnet_group(name, subnet_ids, description = name)
      response = Excon::Response.new
      if self.data[:subnet_groups] && self.data[:subnet_groups][name]
        raise Fog::AWS::RDS::IdentifierTaken.new("DBSubnetGroupAlreadyExists => The subnet group '#{name}' already exists")
      end

      subnets = subnet_ids.map { |snid| Fog::Compute[:aws].subnets.get(snid) }
      vpc_id = subnets.first.vpc_id

      data = {
        'DBSubnetGroupName' => name,
        'DBSubnetGroupDescription' => description,
        'SubnetGroupStatus' => 'Complete',
        'Subnets' => subnet_ids,
        'VpcId' => vpc_id
      }
      self.data[:subnet_groups][name] = data
      response.body = {
        "ResponseMetadata"=>{ "RequestId"=> Fog::AWS::Mock.request_id },
        'CreateDBSubnetGroupResult' => { 'DBSubnetGroup' => data }
      }
      response

    end

data() click to toggle source

    # File lib/fog/aws/rds.rb, line 110
    def data
      self.class.data[@region][@aws_access_key_id]
    end

delete_db_instance(identifier, snapshot_identifier, skip_snapshot = false) click to toggle source

    # File lib/fog/aws/requests/rds/delete_db_instance.rb, line 33
    def delete_db_instance(identifier, snapshot_identifier, skip_snapshot = false)
      response = Excon::Response.new

      unless skip_snapshot
        create_db_snapshot(identifier, snapshot_identifier)
      end

      if server_set = self.data[:servers].delete(identifier)
        response.status = 200
        response.body = {
          "ResponseMetadata"=>{ "RequestId"=> Fog::AWS::Mock.request_id },
          "DeleteDBInstanceResult" => { "DBInstance" => server_set }
        }
        response
      else
        raise Fog::AWS::RDS::NotFound.new("DBInstance #{identifier} not found")
      end
    end

delete_db_parameter_group(group_name) click to toggle source

    # File lib/fog/aws/requests/rds/delete_db_parameter_group.rb, line 29
    def delete_db_parameter_group(group_name)
      response = Excon::Response.new

      if self.data[:parameter_groups].delete(group_name)
        response.status = 200
        response.body = {
          "ResponseMetadata"=>{ "RequestId"=> Fog::AWS::Mock.request_id },
        }
        response
      else
        raise Fog::AWS::RDS::NotFound.new("DBParameterGroup not found: #{group_name}")
      end
    end

delete_db_security_group(name, description = name) click to toggle source

    # File lib/fog/aws/requests/rds/delete_db_security_group.rb, line 27
    def delete_db_security_group(name, description = name)
      response = Excon::Response.new

      if self.data[:security_groups].delete(name)
        response.status = 200
        response.body = {
          "ResponseMetadata"=>{ "RequestId"=> Fog::AWS::Mock.request_id },
        }
        response
      else
        raise Fog::AWS::RDS::NotFound.new("DBSecurityGroupNotFound => #{name} not found")
      end
    end

delete_db_snapshot(name) click to toggle source

    # File lib/fog/aws/requests/rds/delete_db_snapshot.rb, line 29
    def delete_db_snapshot(name)
      # TODO: raise error if snapshot isn't 'available'
      response = Excon::Response.new
      snapshot_data = self.data[:snapshots].delete(name)

      raise Fog::AWS::RDS::NotFound.new("DBSnapshtoNotFound => #{name} not found") unless snapshot_data

      response.status = 200
      response.body = {
        "ResponseMetadata"=> { "RequestId"=> Fog::AWS::Mock.request_id },
        "DeleteDBSnapshotResult"=> {"DBSnapshot"=> snapshot_data}
      }
      response
    end

describe_db_engine_versions(opts={}) click to toggle source

    # File lib/fog/aws/requests/rds/describe_db_engine_versions.rb, line 27
    def describe_db_engine_versions(opts={})
      Fog::Mock.not_implemented
    end

describe_db_instances(identifier=nil, opts={}) click to toggle source

    # File lib/fog/aws/requests/rds/describe_db_instances.rb, line 35
    def describe_db_instances(identifier=nil, opts={})
      response = Excon::Response.new
      server_set = []
      if identifier
        if server = self.data[:servers][identifier]
          server_set << server
        else
          raise Fog::AWS::RDS::NotFound.new("DBInstance #{identifier} not found")
        end
      else
        server_set = self.data[:servers].values
      end

      server_set.each do |server|
         case server["DBInstanceStatus"]
         when "creating"
             if Time.now - server['InstanceCreateTime'] >= Fog::Mock.delay * 2
               region = "us-east-1"
               server["DBInstanceStatus"] = "available"
               server["AvailabilityZone"] ||= region + 'a'
               server["Endpoint"] = {"Port"=>3306,
                                     "Address"=> Fog::AWS::Mock.rds_address(server["DBInstanceIdentifier"],region) }
               server["PendingModifiedValues"] = {}
             end
          when "rebooting"
            if Time.now - self.data[:reboot_time] >= Fog::Mock.delay
              # apply pending modified values
              server.merge!(server["PendingModifiedValues"])
              server["PendingModifiedValues"] = {}

              server["DBInstanceStatus"] = 'available'
              self.data.delete(:reboot_time)
            end
          when "modifying"
            # TODO there are some fields that only applied after rebooting
            if Time.now - self.data[:modify_time] >= Fog::Mock.delay
              server.merge!(server["PendingModifiedValues"])
              server["PendingModifiedValues"] = {}
              server["DBInstanceStatus"] = 'available'
            end
          when "available" # I'm not sure if amazon does this
            unless server["PendingModifiedValues"].empty?
              server["DBInstanceStatus"] = 'modifying'
            end

         end
      end

      response.status = 200
      response.body = {
        "ResponseMetadata"=>{ "RequestId"=> Fog::AWS::Mock.request_id },
        "DescribeDBInstancesResult" => { "DBInstances" => server_set }
      }
      response
    end

describe_db_parameter_groups(name=nil, opts={}) click to toggle source

    # File lib/fog/aws/requests/rds/describe_db_parameter_groups.rb, line 38
    def describe_db_parameter_groups(name=nil, opts={})
      response = Excon::Response.new
      parameter_set = []
      if name
        if server = self.data[:parameter_groups][name]
          parameter_set << server
        else
          raise Fog::AWS::RDS::NotFound.new("DBInstance #{name} not found")
        end
      else
        parameter_set = self.data[:parameter_groups].values
      end

      response.status = 200
      response.body = {
        "ResponseMetadata"=>{ "RequestId"=> Fog::AWS::Mock.request_id },
        "DescribeDBParameterGroupsResult" => { "DBParameterGroups" => parameter_set }
      }
      response
    end

describe_db_parameters(name, opts={}) click to toggle source

    # File lib/fog/aws/requests/rds/describe_db_parameters.rb, line 39
    def describe_db_parameters(name, opts={})
      Fog::Mock.not_implemented
    end

describe_db_reserved_instances(identifier=nil, opts={}) click to toggle source

    # File lib/fog/aws/requests/rds/describe_db_reserved_instances.rb, line 35
    def describe_db_reserved_instances(identifier=nil, opts={})
      Fog::Mock.not_implemented
    end

describe_db_security_groups(opts={}) click to toggle source

    # File lib/fog/aws/requests/rds/describe_db_security_groups.rb, line 31
    def describe_db_security_groups(opts={})
      response = Excon::Response.new
      sec_group_set = []
      if opts.is_a?(String)
        sec_group_name = opts
        if sec_group = self.data[:security_groups][sec_group_name]
          sec_group_set << sec_group
        else
          raise Fog::AWS::RDS::NotFound.new("Security Group #{sec_group_name} not found")
        end
      else
        sec_group_set = self.data[:security_groups].values
      end

      # TODO: refactor to not delete items that we're iterating over. Causes
      # model tests to fail (currently pending)
      sec_group_set.each do |sec_group|
        sec_group["IPRanges"].each do |iprange|
          if iprange["Status"] == "authorizing" || iprange["Status"] == "revoking"
            iprange[:tmp] ||= Time.now + Fog::Mock.delay * 2
            if iprange[:tmp] <= Time.now
              iprange["Status"] = "authorized" if iprange["Status"] == "authorizing"
              iprange.delete(:tmp)
              sec_group["IPRanges"].delete(iprange) if iprange["Status"] == "revoking"
            end
          end
        end

        # TODO: refactor to not delete items that we're iterating over. Causes
        # model tests to fail (currently pending)
        sec_group["EC2SecurityGroups"].each do |ec2_secg|
          if ec2_secg["Status"] == "authorizing" || ec2_secg["Status"] == "revoking"
            ec2_secg[:tmp] ||= Time.now + Fog::Mock.delay * 2
            if ec2_secg[:tmp] <= Time.now
              ec2_secg["Status"] = "authorized" if ec2_secg["Status"] == "authorizing"
              ec2_secg.delete(:tmp)
              sec_group["EC2SecurityGroups"].delete(ec2_secg) if ec2_secg["Status"] == "revoking"
            end
          end
        end
      end

      response.status = 200
      response.body = {
        "ResponseMetadata"=>{ "RequestId"=> Fog::AWS::Mock.request_id },
        "DescribeDBSecurityGroupsResult" => { "DBSecurityGroups" => sec_group_set }
      }
      response
    end

describe_db_snapshots(opts={}) click to toggle source

    # File lib/fog/aws/requests/rds/describe_db_snapshots.rb, line 37
    def describe_db_snapshots(opts={})
      response = Excon::Response.new
      snapshots = self.data[:snapshots].values
      if opts[:identifier]
        snapshots = snapshots.select{|snapshot| snapshot['DBInstanceIdentifier'] == opts[:identifier]}
      end

      if opts[:snapshot_id]
        snapshots = snapshots.select{|snapshot| snapshot['DBSnapshotIdentifier'] == opts[:snapshot_id]}
        raise Fog::AWS::RDS::NotFound.new("DBSnapshot #{opts[:snapshot_id]} not found") if snapshots.empty?
      end

      snapshots.each do |snapshot|
        case snapshot['Status']
        when 'creating'
          if Time.now - snapshot['SnapshotCreateTime'] > Fog::Mock.delay
            snapshot['Status'] = 'available'
          end
        end
      end

      # Build response
      response.status = 200
      response.body = {
        "ResponseMetadata"=>{ "RequestId"=> Fog::AWS::Mock.request_id },
        "DescribeDBSnapshotsResult" => { "DBSnapshots" => snapshots }
      }
      response

    end

describe_db_subnet_groups(name = nil, opts = {}) click to toggle source

    # File lib/fog/aws/requests/rds/describe_db_subnet_groups.rb, line 38
    def describe_db_subnet_groups(name = nil, opts = {})
      response = Excon::Response.new

      subnet_group_set = []
      if name
        if subnet_group = self.data[:subnet_groups][name]
          subnet_group_set << subnet_group
        else
          raise Fog::AWS::RDS::NotFound.new("Subnet Group #{name} not found")
        end
      else
        subnet_group_set = self.data[:subnet_groups].values
      end

      response.status = 200
      response.body = {
        "ResponseMetadata"=>{ "RequestId"=> Fog::AWS::Mock.request_id },
        "DescribeDBSubnetGroupsResult" => { "DBSubnetGroups" => subnet_group_set }
      }
      response
    end

describe_events() click to toggle source

    # File lib/fog/aws/requests/rds/describe_events.rb, line 46
    def describe_events
      Fog::Mock.not_implemented
    end

list_tags_for_resource(rds_id) click to toggle source

    # File lib/fog/aws/requests/rds/list_tags_for_resource.rb, line 27
    def list_tags_for_resource(rds_id)
      response = Excon::Response.new
      if server = self.data[:servers][rds_id]
        response.status = 200
        response.body = {
          "ListTagsForResourceResult" =>
            {"TagList" =>  self.data[:tags][rds_id]}
        }
        response
      else
        raise Fog::AWS::RDS::NotFound.new("DBInstance #{rds_id} not found")
      end
    end

modify_db_instance(db_name, apply_immediately, options={}) click to toggle source

    # File lib/fog/aws/requests/rds/modify_db_instance.rb, line 47
    def modify_db_instance(db_name, apply_immediately, options={})
      response = Excon::Response.new
      if self.data[:servers][db_name]
        if self.data[:servers][db_name]["DBInstanceStatus"] != "available"
          raise Fog::AWS::RDS::NotFound.new("DBInstance #{db_name} not available for modification")
        else
          self.data[:modify_time] = Time.now
          # TODO verify the params options
          # if apply_immediately is false, all the options go to pending_modified_values and then apply and clear after either
          # a reboot or the maintainance window
          #if apply_immediately
          #  modified_server = server.merge(options)
          #else
          #  modified_server = server["PendingModifiedValues"].merge!(options) # it appends
          #end
          self.data[:servers][db_name]["PendingModifiedValues"].merge!(options) # it appends
          self.data[:servers][db_name]["DBInstanceStatus"] = "modifying"
          response.status = 200
          response.body = {
            "ResponseMetadata"=>{ "RequestId"=> Fog::AWS::Mock.request_id },
            "ModifyDBInstanceResult" => { "DBInstance" => self.data[:servers][db_name] }
          }
          response

        end
      else
        raise Fog::AWS::RDS::NotFound.new("DBInstance #{db_name} not found")
      end
    end

modify_db_parameter_group(group_name, parameters) click to toggle source

    # File lib/fog/aws/requests/rds/modify_db_parameter_group.rb, line 48
    def modify_db_parameter_group(group_name, parameters)
      Fog::Mock.not_implemented
    end

reboot_db_instance(instance_identifier) click to toggle source

    # File lib/fog/aws/requests/rds/reboot_db_instance.rb, line 27
    def reboot_db_instance(instance_identifier)
      response = Excon::Response.new
      if server = self.data[:servers][instance_identifier]
        if server["DBInstanceStatus"] != "available"
          raise Fog::AWS::RDS::NotFound.new("DBInstance #{instance_identifier} not available for rebooting")
        else
          server["DBInstanceStatus"] = 'rebooting'
          self.data[:reboot_time] = Time.now
          response.status = 200
          response.body = {
            "ResponseMetadata"=>{ "RequestId"=> Fog::AWS::Mock.request_id },
            "RebootDBInstanceResult" => { "DBInstance" => server }
          }
          response

        end
      else
        raise Fog::AWS::RDS::NotFound.new("DBInstance #{instance_identifier} not found")
      end
    end

remove_tags_from_resource(rds_id, keys) click to toggle source

    # File lib/fog/aws/requests/rds/remove_tags_from_resource.rb, line 27
    def remove_tags_from_resource(rds_id, keys)
      response = Excon::Response.new
      if server = self.data[:servers][rds_id]
        keys.each {|key| self.data[:tags][rds_id].delete key}
        response.status = 200
        response.body = {
          "ResponseMetadata"=>{ "RequestId"=> Fog::AWS::Mock.request_id }
        }
        response
      else
        raise Fog::AWS::RDS::NotFound.new("DBInstance #{rds_id} not found")
      end
    end

reset_data() click to toggle source

    # File lib/fog/aws/rds.rb, line 114
    def reset_data
      self.class.data[@region].delete(@aws_access_key_id)
    end

restore_db_instance_from_db_snapshot(snapshot_id, db_id, options={}) click to toggle source

    # File lib/fog/aws/requests/rds/restore_db_instance_from_db_snapshot.rb, line 26
    def restore_db_instance_from_db_snapshot(snapshot_id, db_id, options={})
      Fog::Mock.not_implemented
    end

restore_db_instance_to_point_in_time(source_db_name, target_db_name, opts={}) click to toggle source

    # File lib/fog/aws/requests/rds/restore_db_instance_to_point_in_time.rb, line 26
    def restore_db_instance_to_point_in_time(source_db_name, target_db_name, opts={})
      Fog::Mock.not_implemented
    end

revoke_db_security_group_ingress(name, opts = {}) click to toggle source

    # File lib/fog/aws/requests/rds/revoke_db_security_group_ingress.rb, line 35
    def revoke_db_security_group_ingress(name, opts = {})
      unless opts.key?('CIDRIP') || (opts.key?('EC2SecurityGroupName') && opts.key?('EC2SecurityGroupOwnerId'))
        raise ArgumentError, 'Must specify CIDRIP, or both EC2SecurityGroupName and EC2SecurityGroupOwnerId'
      end

      response = Excon::Response.new

      if sec_group = self.data[:security_groups][name]
        if opts.key?('CIDRIP')
          sec_group['IPRanges'].each do |iprange|
            iprange['Status']= 'revoking' if iprange['CIDRIP'] == opts['CIDRIP']
          end
        else
          sec_group['EC2SecurityGroups'].each do |ec2_secg|
            ec2_secg['Status']= 'revoking' if ec2_secg['EC2SecurityGroupName'] == opts['EC2SecurityGroupName']
          end
        end
        response.status = 200
        response.body = {
          "ResponseMetadata"=>{ "RequestId"=> Fog::AWS::Mock.request_id },
          'RevokeDBSecurityGroupIngressResult' => {
            'DBSecurityGroup' => sec_group
          }
        }
        response
      else
        raise Fog::AWS::RDS::NotFound.new("DBSecurityGroupNotFound => #{name} not found")
      end
    end

setup_credentials(options) click to toggle source

    # File lib/fog/aws/rds.rb, line 118
    def setup_credentials(options)
      @aws_access_key_id = options[:aws_access_key_id]
    end

[Validate]

Generated with the Darkfish Rdoc Generator 2.