Module: Fog::Vcloud::Terremark::Ecloud::Mock

Defined in:
lib/fog/vcloud/terremark/ecloud.rb,
lib/fog/vcloud/terremark/ecloud/models/vdcs.rb,
lib/fog/vcloud/terremark/ecloud/requests/get_vdc.rb,
lib/fog/vcloud/terremark/ecloud/models/public_ips.rb,
lib/fog/vcloud/terremark/ecloud/requests/get_public_ip.rb,
lib/fog/vcloud/terremark/ecloud/requests/get_public_ips.rb,
lib/fog/vcloud/terremark/ecloud/models/internet_services.rb,
lib/fog/vcloud/terremark/ecloud/requests/add_internet_service.rb,
lib/fog/vcloud/terremark/ecloud/requests/get_internet_services.rb,
lib/fog/vcloud/terremark/ecloud/requests/delete_internet_service.rb

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

.base_url ⇒ Object 



7
8
9
 
# File 'lib/fog/vcloud/terremark/ecloud.rb', line 7

def self.base_url
  "https://fakey.com/api/v0.8a-ext2.0"
end

.data ⇒ Object 



11
12
13
 
# File 'lib/fog/vcloud/terremark/ecloud.rb', line 11

def self.data
  @mock_data ||= Fog::Vcloud::Mock.data
end

.internet_service_href(internet_service) ⇒ Object 



19
20
21
 
# File 'lib/fog/vcloud/terremark/ecloud.rb', line 19

def self.internet_service_href(internet_service)
  "#{base_url}/extensions/internetService/#{internet_service[:id]}"
end

.internet_services_for_ip(xml, ip) ⇒ Object

Based off of: support.theenterprisecloud.com/kb/default.asp?id=580&Lang=1&SID= support.theenterprisecloud.com/kb/default.asp?id=560&Lang=1&SID=



26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
 
# File 'lib/fog/vcloud/terremark/ecloud/requests/get_internet_services.rb', line 26

def self.internet_services_for_ip(xml,ip)
  ip[:services].each do |service|
    xml.InternetService {
      xml.Id(service[:id])
      xml.Href(Fog::Vcloud::Terremark::Ecloud::Mock.internet_service_href(service))
      xml.Name(service[:name])
      xml.PublicIpAddress {
        xml.Id(ip[:id])
        xml.Href(Fog::Vcloud::Terremark::Ecloud::Mock.public_ip_href(ip))
        xml.Name(ip[:name])
      }
      xml.Port(service[:port])
      xml.Protocol(service[:protocol])
      xml.Enabled(service[:enabled])
      xml.Timeout(service[:timeout])
      xml.Description(service[:description])
      xml.UrlSendString
      xml.HttpHeader
    }
  end
end

.public_ip_href(ip) ⇒ Object 



15
16
17
 
# File 'lib/fog/vcloud/terremark/ecloud.rb', line 15

def self.public_ip_href(ip)
  "#{base_url}/extensions/publicIp/#{ip[:id]}"
end

Instance Method Details

#add_internet_service(internet_service_uri, service_data) ⇒ Object

Based on support.theenterprisecloud.com/kb/default.asp?id=561&Lang=1&SID=



48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
 
# File 'lib/fog/vcloud/terremark/ecloud/requests/add_internet_service.rb', line 48

def add_internet_service(internet_service_uri, service_data)
  Fog::Vcloud::Terremark::Ecloud::Real.validate_internet_service_request_data(service_data)

  if ip = Fog::Vcloud::Mock.ip_from_uri(internet_service_uri.to_s)
    new_service = service_data.merge!( { :id => rand(1000), :timeout => 2 } )
    ip[:services] << new_service
    builder = Builder::XmlMarkup.new
    xml = builder.InternetService(:xmlns => "urn:tmrk:eCloudExtensions-2.0",
                                  :"xmlns:i" => "http://www.w3.org/2001/XMLSchema-instance") {
      builder.Id(new_service[:id])
      builder.Href(Fog::Vcloud::Terremark::Ecloud::Mock.internet_service_href(new_service))
      builder.Name(new_service[:name])
      builder.PublicIpAddress {
        builder.Id(ip[:id])
        builder.Href(Fog::Vcloud::Terremark::Ecloud::Mock.public_ip_href(ip))
        builder.Name(ip[:name])
      }
      builder.Protocol(new_service[:protocol])
      builder.Port(new_service[:port])
      builder.Enabled(new_service[:enabled])
      builder.Description(new_service[:description])
      builder.Timeout(new_service[:timeout])
    }

    mock_it Fog::Parsers::Vcloud::Terremark::Ecloud::InternetService.new, 200, xml, {'Content-Type' => 'application/vnd.tmrk.ecloud.internetService+xml'}
  else
    mock_error 200, "401 Unauthorized"
  end
end

#delete_internet_service(internet_service_uri) ⇒ Object

Based on support.theenterprisecloud.com/kb/default.asp?id=561&Lang=1&SID=



25
26
27
28
29
30
31
32
33
 
# File 'lib/fog/vcloud/terremark/ecloud/requests/delete_internet_service.rb', line 25

def delete_internet_service(internet_service_uri)
  if service = Fog::Vcloud::Mock.data[:organizations].map { |org| org[:vdcs].map { |vdc| vdc[:public_ips].map { |public_ip| public_ip[:services].map { |service| service } } } }.
    flatten.detect { |service| service[:id].to_s == internet_service_uri.to_s.split('/')[-1] }
    Fog::Vcloud::Mock.data[:organizations].map { |org| org[:vdcs].map { |vdc| vdc[:public_ips].map { |public_ip| public_ip[:services].delete(service) } } }
    mock_it nil, 200, "", {}
  else
    mock_error 200, "401 Unauthorized"
  end
end

#get_internet_services(internet_services_uri) ⇒ Object 



48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
 
# File 'lib/fog/vcloud/terremark/ecloud/requests/get_internet_services.rb', line 48

def get_internet_services(internet_services_uri)
  xml = nil
  builder = Builder::XmlMarkup.new
  if vdc = Fog::Vcloud::Mock.vdc_from_uri(internet_services_uri)
    xml = builder.InternetServices( :xmlns => "urn:tmrk:eCloudExtensions-2.0",:"xmlns:i" => "http://www.w3.org/2001/XMLSchema-instance" ) { |xml|
      vdc[:public_ips].each do |ip|
        Fog::Vcloud::Terremark::Ecloud::Mock.internet_services_for_ip(xml,ip)
      end
    }
  elsif ip = Fog::Vcloud::Mock.ip_from_uri(internet_services_uri)
    xml = builder.InternetServices( :xmlns => "urn:tmrk:eCloudExtensions-2.0",:"xmlns:i" => "http://www.w3.org/2001/XMLSchema-instance" ) { |xml|
      Fog::Vcloud::Terremark::Ecloud::Mock.internet_services_for_ip(xml,ip)
    }
  end
  if xml
    mock_it Fog::Parsers::Vcloud::Terremark::Ecloud::GetInternetServices.new, 200,
      xml, { 'Content-Type' => 'application/vnd.tmrk.ecloud.internetServicesList+xml' }
  else
    mock_error 200, "401 Unauthorized"
  end
end

#get_public_ip(public_ip_uri) ⇒ Object

Based off of: support.theenterprisecloud.com/kb/default.asp?id=567&Lang=1&SID=



29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
 
# File 'lib/fog/vcloud/terremark/ecloud/requests/get_public_ip.rb', line 29

def get_public_ip(public_ip_uri)
  ip_id = public_ip_uri.to_s.split('/')[-1]
  if ip = mock_data[:organizations].map { |org| org[:vdcs] }.flatten.map { |vdc| vdc[:public_ips] }.flatten.detect { |ip| ip[:id].to_s == ip_id }
    xml = Builder::XmlMarkup.new
    mock_it(Fog::Parsers::Vcloud::Terremark::Ecloud::GetPublicIp.new, 200,
      xml.PublicIp(:xmlns => "urn:tmrk:eCloudExtensions-2.0", :"xmlns:i" => "http://www.w3.org/2001/XMLSchema-instance") {
        xml.Id(ip[:id])
        xml.Href("#{Fog::Vcloud::Terremark::Ecloud::Mock.base_url}/extensions/publicIp/#{ip[:id]}")
        xml.Name(ip[:name])
      }, { 'Content-Type' => 'application/vnd.tmrk.ecloud.publicIp+xml' }
    )
  else
    mock_error 200, "401 Unauthorized"
  end
end

#get_public_ips(public_ips_uri) ⇒ Object

Based off of: support.theenterprisecloud.com/kb/default.asp?id=577&Lang=1&SID=



24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
 
# File 'lib/fog/vcloud/terremark/ecloud/requests/get_public_ips.rb', line 24

def get_public_ips(public_ips_uri)
  if vdc = mock_data[:organizations].map { |org| org[:vdcs] }.flatten.detect { |vdc| vdc[:href].split('/').last == public_ips_uri.to_s.split('/')[-2] }
    xml = Builder::XmlMarkup.new
    mock_it Fog::Parsers::Vcloud::Terremark::Ecloud::GetPublicIps.new, 200,
      xml.PublicIPAddresses {
        vdc[:public_ips].each do |ip|
          xml.PublicIPAddress {
            xml.Id(ip[:id])
            xml.Href("#{Fog::Vcloud::Terremark::Ecloud::Mock.base_url}/extensions/publicIp/#{ip[:id]}")
            xml.Name(ip[:name])
          }
        end
      }, { 'Content-Type' => 'application/vnd.tmrk.ecloud.publicIpsList+xml'}
  else
    mock_error 200, "401 Unauthorized"
  end
end

#get_vdc(vdc_uri) ⇒ Object

Based off of: support.theenterprisecloud.com/kb/default.asp?id=545&Lang=1&SID=



24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
 
# File 'lib/fog/vcloud/terremark/ecloud/requests/get_vdc.rb', line 24

def get_vdc(vdc_uri)
  if vdc = mock_data[:organizations].map { |org| org[:vdcs] }.flatten.detect { |vdc| URI.parse(vdc[:href]) == vdc_uri }
    xml = Builder::XmlMarkup.new
    mock_it Fog::Parsers::Vcloud::Terremark::Ecloud::GetVdc.new, 200,
      xml.Vdc(xmlns.merge(:href => vdc[:href], :name => vdc[:name])) {
        xml.Link(:rel => "down",
                 :href => vdc[:href] + "/catalog",
                 :type => "application/vnd.vmware.vcloud.catalog+xml",
                 :name => vdc[:name])
        xml.Link(:rel => "down",
                 :href => vdc[:href].gsub('/vdc','/extensions/vdc') + "/publicIps",
                 :type => "application/vnd.tmrk.ecloud.publicIpsList+xml",
                 :name => "Public IPs")
        xml.Link(:rel => "down",
                 :href => vdc[:href] + "/internetServices",
                 :type => "application/vnd.tmrk.ecloud.internetServicesList+xml",
                 :name => "Internet Services")
        xml.Link(:rel => "down",
                 :href => vdc[:href].sub('/vdc','/extensions/vdc') + "/firewallAcls",
                 :type => "application/vnd.tmrk.ecloud.firewallAclsList+xml",
                 :name => "Firewall Access List")
        xml.Description("")
        xml.StorageCapacity {
          xml.Units("bytes * 10^9")
          xml.Allocated(vdc[:storage][:allocated])
          xml.Used(vdc[:storage][:used])
        }
        xml.ComputeCapacity {
          xml.Cpu {
            xml.Units("hz * 10^6")
            xml.Allocated(vdc[:cpu][:allocated])
          }
          xml.Memory {
            xml.Units("bytes * 2^20")
            xml.Allocated(vdc[:memory][:allocated])
          }
          xml.DeployedVmsQuota {
            xml.Limit("-1")
            xml.Used("-1")
          }
          xml.InstantiatedVmsQuota {
            xml.Limit("-1")
            xml.Used("-1")
          }
        }
        xml.ResourceEntities {
          vdc[:vms].each do |vm|
            xml.ResourceEntity(:href => vm[:href],
                               :type => "application/vnd.vmware.vcloud.vApp+xml",
                               :name => vm[:name])
          end
        }
        xml.AvailableNetworks {
          vdc[:networks].each do |network|
            xml.Network(:href => network[:href],
                        :type => "application/vnd.vmware.vcloud.network+xml",
                        :name => network[:name])
          end
        }
      }, { 'Content-Type' => 'application/vnd.vmware.vcloud.vdc+xml'}
  else
    mock_error 200, "401 Unauthorized"
  end
end

#internet_services(options = {}) ⇒ Object 



7
8
9
 
# File 'lib/fog/vcloud/terremark/ecloud/models/internet_services.rb', line 7

def internet_services(options = {})
  @internet_services ||= Fog::Vcloud::Terremark::Ecloud::InternetServices.new(options.merge(:connection => self))
end

#public_ips(options = {}) ⇒ Object 



7
8
9
 
# File 'lib/fog/vcloud/terremark/ecloud/models/public_ips.rb', line 7

def public_ips(options = {})
  @public_ips ||= Fog::Vcloud::Terremark::Ecloud::PublicIps.new(options.merge(:connection => self))
end

#vdcs(options = {}) ⇒ Object 



6
7
8
 
# File 'lib/fog/vcloud/terremark/ecloud/models/vdcs.rb', line 6

def vdcs(options = {})
  @vdcs ||= Fog::Vcloud::Terremark::Ecloud::Vdcs.new(options.merge(:connection => self))
end