lib/fog/ecloud/mock_data_classes.rb
module Fog
module Ecloud
module MockDataClasses
class Base < Hash
def self.base_url=(url)
@base_url = url
end
self.base_url = "http://vcloud.example.com"
def self.base_url
@base_url
end
def first
raise "Don't do this"
end
def last
raise "Don't do this"
end
def initialize(data = {}, parent = nil)
@parent = parent
replace(data)
end
def _parent
@parent
end
def base_url
Base.base_url
end
def href
[base_url, self.class.name.split("::").last, object_id].join("/")
end
def inspect
"<#{self.class.name} #{object_id} data=#{super}>"
end
end
class MockData < Base
def versions
@versions ||= []
end
def organizations
@organizations ||= []
end
def organization_collection_from_href(href)
find_href_in(href, all_organizations)
end
def all_organizations
organizations.map(&:environments).flatten
end
def organization_from_href(href)
find_href_in(href, all_organizations)
end
def all_vdcs
organizations.map(&:environments).flatten
end
def vdc_from_href(href)
find_href_in(href, all_vdcs)
end
def all_catalogs
all_vdcs.map(&:catalog).flatten
end
def catalog_from_href(href)
find_href_in(href, all_catalogs)
end
def all_catalog_items
all_catalogs.map(&:items).flatten
end
def catalog_item_from_href(href)
find_href_in(href, all_catalog_items)
end
def all_virtual_machines
all_vdcs.map(&:virtual_machines).flatten
end
def virtual_machine_from_href(href)
find_href_prefixed_in(href, all_virtual_machines)
end
def all_networks
all_vdcs.map(&:networks).flatten
end
def network_from_href(href)
find_href_in(href, all_networks)
end
def all_network_extensions
all_networks.map(&:extensions).flatten
end
def network_extension_from_href(href)
find_href_in(href, all_network_extensions)
end
def all_vdc_internet_service_collections
all_vdcs.map(&:internet_service_collection).flatten
end
def vdc_internet_service_collection_from_href(href)
find_href_in(href, all_vdc_internet_service_collections)
end
def all_backup_internet_services
all_vdc_internet_service_collections.map(&:backup_internet_services).flatten
end
def backup_internet_service_from_href(href)
find_href_in(href, all_backup_internet_services)
end
def all_public_ip_collections
all_vdcs.map {|v| v.public_ip_collection }.flatten
end
def public_ip_collection_from_href(href)
find_href_in(href, all_public_ip_collections)
end
def all_public_ips
all_public_ip_collections.map(&:items).flatten
end
def public_ip_from_href(href)
find_href_in(href, all_public_ips)
end
def all_public_ip_internet_service_collections
all_public_ips.map(&:internet_service_collection).flatten
end
def public_ip_internet_service_collection_from_href(href)
find_href_in(href, all_public_ip_internet_service_collections)
end
def all_public_ip_internet_services
all_public_ip_internet_service_collections.map(&:items).flatten
end
def public_ip_internet_service_from_href(href)
find_href_in(href, all_public_ip_internet_services)
end
def all_public_ip_internet_service_node_collections
all_public_ip_internet_services.map(&:node_collection).flatten
end
def public_ip_internet_service_node_collection_from_href(href)
find_href_in(href, all_public_ip_internet_service_node_collections)
end
def all_public_ip_internet_service_nodes
all_public_ip_internet_service_node_collections.map(&:items).flatten
end
def public_ip_internet_service_node_from_href(href)
find_href_in(href, all_public_ip_internet_service_nodes)
end
def all_network_ip_collections
all_networks.map(&:ip_collection)
end
def network_ip_collection_from_href(href)
find_href_in(href, all_network_ip_collections)
end
def all_network_ips
all_network_ip_collections.map {|c| c.items.values }.flatten
end
def network_ip_from_href(href)
find_href_in(href, all_network_ips)
end
private
def find_href_in(href, objects)
objects.find {|o| o.href == href }
end
def find_href_prefixed_in(href, objects)
objects.find {|o| href =~ %r{^#{o.href}($|/)} }
end
end
class MockVersion < Base
def version
self[:version]
end
def supported
!!self[:supported]
end
def login_url
href
end
end
class MockOrganization < Base
def name
self[:name]
end
def environments
@vdcs ||= []
end
end
class MockVdc < Base
def name
self[:name]
end
def storage_allocated
self[:storage_allocated] || 200
end
def storage_used
self[:storage_used] || 105
end
def cpu_allocated
self[:cpu_allocated] || 10000
end
def memory_allocated
self[:memory_allocated] || 20480
end
def catalog
@catalog ||= MockCatalog.new({}, self)
end
def networks
@networks ||= []
end
def virtual_machines
@virtual_machines ||= []
end
def task_list
@task_list ||= MockTaskList.new({}, self)
end
# for TM eCloud, should probably be subclassed
def public_ip_collection
@public_ip_collection ||= MockPublicIps.new({}, self)
end
def internet_service_collection
@internet_service_collection ||= MockVdcInternetServices.new({}, self)
end
def firewall_acls
@firewall_acls ||= MockFirewallAcls.new({}, self)
end
end
class MockTaskList < Base
def name
self[:name] || "Tasks List"
end
end
class MockCatalog < Base
def name
self[:name] || "Catalog"
end
def items
@items ||= []
end
end
class MockCatalogItem < Base
def name
self[:name]
end
def disks
@disks ||= MockVirtualMachineDisks.new(self)
end
def customization
@customization ||= MockCatalogItemCustomization.new({}, self)
end
def vapp_template
@vapp_template ||= MockCatalogItemVappTemplate.new({ :name => name }, self)
end
end
class MockCatalogItemCustomization < Base
def name
self[:name] || "Customization Options"
end
end
class MockCatalogItemVappTemplate < Base
def name
self[:name]
end
end
class MockNetwork < Base
def name
self[:name] || subnet
end
def subnet
self[:subnet]
end
def gateway
self[:gateway] || subnet_ips[1]
end
def netmask
self[:netmask] || subnet_ipaddr.mask_string
end
def dns
"8.8.8.8"
end
def features
[
{ :type => :FenceMode, :value => "isolated" }
]
end
def ip_collection
@ip_collection ||= MockNetworkIps.new({}, self)
end
def extensions
@extensions ||= MockNetworkExtensions.new({}, self)
end
def random_ip
usable_subnet_ips[rand(usable_subnet_ips.length)]
end
# for TM eCloud. should probably be a subclass
def rnat
self[:rnat]
end
def usable_subnet_ips
subnet_ips[3..-2]
end
def address
subnet_ips.first
end
def broadcast
subnet_ips.last
end
private
def subnet_ipaddr
@ipaddr ||= IPAddr.new(subnet)
end
def subnet_ips
subnet_ipaddr.to_range.to_a.map(&:to_s)
end
end
class MockNetworkIps < Base
def items
@items ||= _parent.usable_subnet_ips.reduce({}) do |out, subnet_ip|
out.update(subnet_ip => MockNetworkIp.new({ :ip => subnet_ip }, self))
end
end
def ordered_ips
items.values.sort_by {|i| i.ip.split(".").map(&:to_i) }
end
def name
"IP Addresses"
end
end
class MockNetworkIp < Base
def name
self[:name] || ip
end
def ip
self[:ip]
end
def used_by
self[:used_by] || _parent._parent._parent.virtual_machines.find {|v| v.ip == ip }
end
def status
if used_by
"Assigned"
else
"Available"
end
end
def rnat
self[:rnat] || _parent._parent.rnat
end
def rnat_set?
!!self[:rnat]
end
end
class MockNetworkExtensions < Base
def name
_parent.name
end
def gateway
_parent.gateway
end
def broadcast
_parent.broadcast
end
def address
_parent.address
end
def rnat
_parent.rnat
end
def type
self[:type] || "DMZ"
end
def vlan
object_id.to_s
end
def friendly_name
"#{name} (#{type}_#{object_id})"
end
end
class MockVirtualMachine < Base
def name
self[:name]
end
def ip
self[:ip]
end
def cpus
self[:cpus] || 1
end
def memory
self[:memory] || 1024
end
def disks
@disks ||= MockVirtualMachineDisks.new(self)
end
def status
self[:status] || 2
end
def power_off!
self[:status] = 2
end
def power_on!
self[:status] = 4
end
def size
disks.reduce(0) {|s, d| s + d.vcloud_size }
end
def network_ip
if network = _parent.networks.find {|n| n.ip_collection.items[ip] }
network.ip_collection.items[ip]
end
end
# from fog ecloud server's _compose_vapp_data
def to_configure_vapp_hash
{
:name => name,
:cpus => cpus,
:memory => memory,
:disks => disks.map {|d| { :number => d.address.to_s, :size => d.vcloud_size, :resource => d.vcloud_size.to_s } }
}
end
def href(purpose = :base)
case purpose
when :base
super()
when :power_on
super() + "/power/action/powerOn"
when :power_off
super() + "/power/action/powerOff"
end
end
end
class MockVirtualMachineDisks < Array
def initialize(parent = nil)
@parent = parent
end
def _parent
@parent
end
def <<(disk)
next_address = 0
disk_with_max_address = max {|a, b| a[:address] <=> b[:address] }
disk_with_max_address && next_address = disk_with_max_address.address + 1
disk[:address] ||= next_address
super(disk)
if (addresses = map {|d| d.address }).uniq.size != size
raise "Duplicate disk address in: #{addresses.inspect} (#{size})"
end
sort! {|a, b| a.address <=> b.address }
self
end
def at_address(address)
find {|d| d.address == address }
end
end
class MockVirtualMachineDisk < Base
def size
self[:size].to_i
end
def vcloud_size
# kilobytes
size * 1024
end
def address
self[:address].to_i
end
end
# for Terremark eCloud
class MockVdcInternetServices < Base
def href
_parent.href + "/internetServices"
end
def name
"Internet Services"
end
def items
public_ip_internet_services + backup_internet_services
end
def public_ip_internet_services
_parent.public_ip_collection.items.reduce([]) do |services, public_ip|
services + public_ip.internet_service_collection.items
end
end
def backup_internet_services
@backup_internet_services ||= []
end
end
class MockBackupInternetService < Base
def name
self[:name] || "Backup Internet Service #{object_id}"
end
def protocol
self[:protocol]
end
def port
0
end
def enabled
self[:enabled].to_s.downcase != "false"
end
def timeout
self[:timeout] || 2
end
def description
self[:description] || "Description for Backup Service #{name}"
end
def redirect_url
nil
end
def node_collection
@node_collection ||= MockPublicIpInternetServiceNodes.new({}, self)
end
end
class MockFirewallAcls < Base
def name
"Firewall Access List"
end
end
class MockPublicIps < Base
def name
self[:name] || "Public IPs"
end
def items
@items ||= []
end
end
class MockPublicIp < Base
def name
self[:name]
end
def internet_service_collection
@internet_service_collection ||= MockPublicIpInternetServices.new({}, self)
end
end
class MockPublicIpInternetServices < Base
def href
_parent.href + "/internetServices"
end
def items
@items ||= []
end
end
class MockPublicIpInternetService < Base
def name
self[:name] || "Public IP Service #{object_id}"
end
def description
self[:description] || "Description for Public IP Service #{name}"
end
def protocol
self[:protocol]
end
def port
self[:port]
end
def enabled
!!self[:enabled]
end
def redirect_url
self[:redirect_url]
end
def timeout
self[:timeout] || 2
end
def node_collection
@node_collection ||= MockPublicIpInternetServiceNodes.new({}, self)
end
def monitor
nil
end
def backup_service
self[:backup_service]
end
end
class MockPublicIpInternetServiceNodes < Base
def href
_parent.href + "/nodeServices"
end
def items
@items ||= [].tap do |node_array|
node_array.instance_variable_set("@default_port", _parent.port)
def node_array.<<(node)
node[:port] ||= @default_port
super
end
end
end
end
class MockPublicIpInternetServiceNode < Base
def ip_address
self[:ip_address]
end
def name
self[:name] || "Public IP Service Node #{object_id}"
end
def description
self[:description] || "Description for Public IP Service Node #{name}"
end
def port
self[:port]
end
def enabled
self[:enabled].to_s.downcase != "false"
end
def enabled=(new_value)
self[:enabled] = new_value
end
end
end
end
end