fog-ifeel 2.2.0

data/lib/fog/vcloud_director/generators/compute/edge_gateway_service_configuration.rb

@@ -0,0 +1,243 @@
+module Fog
+  module Generators
+    module Compute
+      module VcloudDirector
+        class EdgeGatewayServiceConfiguration
+          def initialize(configuration={})
+            @configuration = configuration
+          end
+
+          def generate_xml
+            Nokogiri::XML::Builder.new do |xml|
+              xml.EdgeGatewayServiceConfiguration('xmlns' => "http://www.vmware.com/vcloud/v1.5"){
+                build_firewall_service(xml)
+                build_nat_service(xml)
+                build_load_balancer_service(xml)
+                build_vpn(xml)
+                build_dhcp(xml)
+                build_static_routing_service(xml)
+              }
+            end.to_xml
+          end
+
+          private
+
+          def build_dhcp(xml)
+            dhcp_config = @configuration[:GatewayDhcpService]
+            return unless dhcp_config
+
+            xml.GatewayDhcpService {
+              xml.IsEnabled dhcp_config[:IsEnabled] if dhcp_config.key?(:IsEnabled)
+              dhcp_config[:pools].each do |pool|
+                xml.Pool {
+                  xml.IsEnabled pool[:IsEnabled]
+                  xml.Network pool[:Network]
+                  xml.DefaultLeaseTime pool[:DefaultLeaseTime]
+                  xml.MaxLeaseTime pool[:MaxLeaseTime]
+                  xml.LowIpAddress pool[:LowIpAddress]
+                  xml.HighIpAddress pool[:HighIpAddress]
+                }
+              end
+            }
+          end
+
+          def build_vpn(xml)
+            vpn_config = @configuration[:GatewayIpsecVpnService]
+            return unless vpn_config
+
+            xml.GatewayIpsecVpnService {
+              xml.IsEnabled vpn_config[:IsEnabled] if vpn_config.key?(:IsEnabled)
+              vpn_config[:Tunnel].each do |tunnel_config|
+                xml.Tunnel {
+                  xml.Name tunnel_config[:Name]
+                  xml.Description tunnel_config[:Description]
+                  xml.IpsecVpnLocalPeer {
+                    xml.Id tunnel_config[:IpsecVpnLocalPeerId]
+                    xml.Name tunnel_config[:IpsecVpnLocalPeerName]
+                  }
+                  xml.PeerIpAddress tunnel_config[:PeerIpAddress]
+                  xml.PeerId tunnel_config[:PeerId]
+                  xml.LocalIpAddress tunnel_config[:LocalIpAddress]
+                  xml.LocalId tunnel_config[:LocalId]
+                  tunnel_config[:LocalSubnet].each do |subnet|
+                    xml.LocalSubnet {
+                      xml.Name subnet[:Name]
+                      xml.Gateway subnet[:Gateway]
+                      xml.Netmask subnet[:Netmask]
+                    }
+                  end
+                  tunnel_config[:PeerSubnet].each do |subnet|
+                    xml.PeerSubnet {
+                      xml.Name subnet[:Name]
+                      xml.Gateway subnet[:Gateway]
+                      xml.Netmask subnet[:Netmask]
+                    }
+                  end
+                  xml.SharedSecret tunnel_config[:SharedSecret]
+                  xml.SharedSecretEncrypted tunnel_config[:SharedSecretEncrypted] if tunnel_config.key?(:SharedSecretEncrypted)
+                  xml.EncryptionProtocol tunnel_config[:EncryptionProtocol]
+                  xml.Mtu tunnel_config[:Mtu]
+                  xml.IsEnabled tunnel_config[:IsEnabled]
+                }
+              end
+            }
+          end
+
+          def build_load_balancer_service(xml)
+            lb_config = @configuration[:LoadBalancerService]
+            return unless lb_config
+
+            xml.LoadBalancerService {
+              xml.IsEnabled lb_config[:IsEnabled] if lb_config.key?(:IsEnabled)
+              lb_config[:Pool].each do |pool|
+                xml.Pool {
+                  xml.Name pool[:Name]
+                  xml.Description pool[:Description] if pool.key?(:Description)
+                  pool[:ServicePort].each do |service_port|
+                    xml.ServicePort {
+                      xml.IsEnabled service_port[:IsEnabled]
+                      xml.Protocol service_port[:Protocol]
+                      xml.Algorithm service_port[:Algorithm]
+                      xml.Port service_port[:Port]
+                      xml.HealthCheckPort service_port[:HealthCheckPort]
+                      xml.HealthCheck {
+                        xml.Mode service_port[:HealthCheck][:Mode]
+                        xml.Uri service_port[:HealthCheck][:Uri]
+                        xml.HealthThreshold service_port[:HealthCheck][:HealthThreshold]
+                        xml.UnhealthThreshold service_port[:HealthCheck][:UnhealthThreshold]
+                        xml.Interval service_port[:HealthCheck][:Interval]
+                        xml.Timeout service_port[:HealthCheck][:Timeout]
+                      }
+                    }
+                  end
+                  pool[:Member].each do |member|
+                    xml.Member {
+                      xml.IpAddress member[:IpAddress]
+                      xml.Weight member[:Weight]
+                      member[:ServicePort].each do |member_service_port|
+                        xml.ServicePort {
+                          xml.Protocol member_service_port[:Protocol]
+                          xml.Port member_service_port[:Port]
+                          xml.HealthCheckPort member_service_port[:HealthCheckPort]
+                        }
+                      end
+                    }
+                  end
+
+                }
+              end
+              lb_config[:VirtualServer].each do |virtual_server|
+                xml.VirtualServer {
+                  xml.IsEnabled virtual_server[:IsEnabled]
+                  xml.Name virtual_server[:Name]
+                  xml.Description virtual_server[:Description]
+                  xml.Interface(:href => virtual_server[:Interface][:href], :name => virtual_server[:Interface][:name])
+                  xml.IpAddress virtual_server[:IpAddress]
+                  virtual_server[:ServiceProfile].each do |service_profile|
+                    xml.ServiceProfile {
+                      xml.IsEnabled service_profile[:IsEnabled]
+                      xml.Protocol service_profile[:Protocol]
+                      xml.Port service_profile[:Port]
+                      xml.Persistence {
+                        xml.Method service_profile[:Persistence][:Method]
+                        if service_profile[:Persistence][:Method] == 'COOKIE'
+                          xml.CookieName service_profile[:Persistence][:CookieName]
+                          xml.CookieMode service_profile[:Persistence][:CookieMode]
+                        end
+                      }
+                    }
+                  end
+                  xml.Logging virtual_server[:Logging]
+                  xml.Pool virtual_server[:Pool]
+                }
+              end
+            }
+          end
+
+          def build_nat_service(xml)
+            nat_config = @configuration[:NatService]
+            return unless nat_config
+
+            xml.NatService {
+              xml.IsEnabled nat_config[:IsEnabled]
+
+              nat_config[:NatRule].each do |rule|
+                xml.NatRule {
+                  xml.RuleType rule[:RuleType]
+                  xml.IsEnabled rule[:IsEnabled]
+                  xml.Id rule[:Id] if rule[:Id]
+                  gateway_nat_rule = rule[:GatewayNatRule]
+                  xml.GatewayNatRule {
+                    xml.Interface(:name => gateway_nat_rule[:Interface][:name], :href => gateway_nat_rule[:Interface][:href])
+                    xml.OriginalIp gateway_nat_rule[:OriginalIp]
+                    xml.OriginalPort gateway_nat_rule[:OriginalPort] if gateway_nat_rule.key?(:OriginalPort)
+                    xml.TranslatedIp gateway_nat_rule[:TranslatedIp]
+                    xml.TranslatedPort gateway_nat_rule[:TranslatedPort] if gateway_nat_rule.key?(:TranslatedPort)
+                    xml.Protocol gateway_nat_rule[:Protocol] if rule[:RuleType] == "DNAT"
+                  }
+                }
+              end
+            }
+          end
+
+          def build_static_routing_service(xml)
+            routing_config = @configuration[:StaticRoutingService]
+            return unless routing_config
+
+            xml.StaticRoutingService {
+              xml.IsEnabled routing_config[:IsEnabled]
+              routing_config[:StaticRoute].each do |rule|
+                xml.StaticRoute{
+                  xml.Name rule[:Name]
+                  xml.Network rule[:Network]
+                  xml.NextHopIp rule[:NextHopIp]
+                  xml.GatewayInterface(
+                    :type => rule[:GatewayInterface][:type],
+                    :name => rule[:GatewayInterface][:name],
+                    :href => rule[:GatewayInterface][:href]
+                  )
+                }
+              end
+            }
+          end
+
+          def build_firewall_service(xml)
+            firewall_config = @configuration[:FirewallService]
+            return unless firewall_config
+
+            xml.FirewallService {
+              xml.IsEnabled firewall_config[:IsEnabled]
+              xml.DefaultAction firewall_config[:DefaultAction] if firewall_config.key?(:DefaultAction)
+              xml.LogDefaultAction firewall_config[:LogDefaultAction] if firewall_config.key?(:LogDefaultAction)
+              firewall_config[:FirewallRule].each do |rule|
+                xml.FirewallRule {
+                  xml.Id rule[:Id] if rule[:Id]
+                  xml.IsEnabled rule[:IsEnabled] if rule.key?(:IsEnabled)
+                  xml.MatchOnTranslate rule[:MatchOnTranslate] if rule.key?(:MatchOnTranslate)
+                  xml.Description rule[:Description] if rule.key?(:Description)
+                  xml.Policy rule[:Policy] if rule.key?(:Policy)
+
+                  xml.Protocols {
+                    rule[:Protocols].each do |key, value|
+                    xml.send(key.to_s.capitalize, value)
+                    end
+                  }
+                  xml.IcmpSubType rule[:IcmpSubType] if rule.key?(:IcmpSubType)
+                  xml.Port rule[:Port] if rule.key?(:Port)
+                  xml.DestinationPortRange rule[:DestinationPortRange]
+                  xml.DestinationIp rule[:DestinationIp]
+                  xml.SourcePort rule[:SourcePort] if rule.key?(:SourcePort)
+                  xml.SourcePortRange rule[:SourcePortRange]
+                  xml.SourceIp rule[:SourceIp]
+                  xml.Direction rule[:Direction] if rule.key?(:Direction) #Firewall rule direction is allowed only in backward compatibility mode.
+                  xml.EnableLogging rule[:EnableLogging] if rule.key?(:EnableLogging)
+                }
+
+              end
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fog/vcloud_director/generators/compute/instantiate_vapp_template_params.rb

@@ -0,0 +1,30 @@
+require 'fog/vcloud_director/generators/compute/compose_common'
+
+module Fog
+  module Generators
+    module Compute
+      module VcloudDirector
+        # @see http://pubs.vmware.com/vcd-51/topic/com.vmware.vcloud.api.reference.doc_51/doc/types/VAppType.html
+        class InstantiateVappTemplateParams
+          attr_reader :options
+          
+          include ComposeCommon
+        
+          def generate_xml
+            Nokogiri::XML::Builder.new do |xml|
+
+              
+              xml.InstantiateVAppTemplateParams((vapp_attrs)) {
+                build_vapp_instantiation_params(xml)
+                build_source_template(xml)
+                build_source_items(xml)
+              }
+            end.to_xml
+
+          end
+          
+        end
+      end
+    end
+  end
+end

data/lib/fog/vcloud_director/generators/compute/metadata.rb

@@ -0,0 +1,104 @@
+module Fog
+  module Generators
+    module Compute
+      module VcloudDirector
+        #   {:metadata=>
+        #    {"buenas si"=>"no tanto ya",
+        #     "hola"=>"adios"},
+        #    :type=>"application/vnd.vmware.vcloud.metadata+xml",
+        #    :href=>
+        #     "https://example.com/api/vApp/vm-18545e82-d919-4071-ae7e-d1300d9d8112/metadata",
+        #    :id=>"vm-18545e82-d919-4071-ae7e-d1300d9d8112"}
+        #
+        # This is what it generates:
+        #
+        #   <Metadata xmlns="http://www.vmware.com/vcloud/v1.5" type="application/vnd.vmware.vcloud.metadata+xml"  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.vmware.com/vcloud/v1.5 http://10.194.1.65/api/v1.5/schema/master.xsd">
+        #     <MetadataEntry>
+        #       <Key>buenas si</Key>
+        #       <Value>no tanto ya</Value>
+        #     </MetadataEntry>
+        #     <MetadataEntry">
+        #       <Key>hola</Key>
+        #       <Value>adios</Value>
+        #     </MetadataEntry>
+        #   </Metadata>
+        #
+        # @see http://pubs.vmware.com/vcd-51/topic/com.vmware.vcloud.api.reference.doc_51/doc/types/MetadataType.html
+        class MetadataBase
+          attr_reader :attrs
+
+          def initialize(attrs={})
+            @attrs = attrs
+          end
+
+          def generate_xml
+            output = ""
+            output << header
+            attrs[:metadata].each_pair do |k,v|
+              output << metadata_entry(k,v)
+            end
+            output << tail
+            output
+          end
+
+          def add_item(k,v)
+            @attrs[:metadata].merge!(Hash[k,v])
+          end
+
+          # 1.5
+          def header
+            <<-END
+            <Metadata
+              xmlns="http://www.vmware.com/vcloud/v1.5"
+              xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+              type="application/vnd.vmware.vcloud.metadata+xml">
+            END
+          end
+
+          def metadata_entry
+            raise "This is an abstract class. Use the appropriate subclass"
+          end
+
+          # 5.1
+          #def header
+          #  '<Metadata xmlns="http://www.vmware.com/vcloud/v1.5"
+          #    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+          #    type="application/vnd.vmware.vcloud.metadata+xml"
+          #    href="https://devlab.mdsol.com/api/vApp/vm-345c3619-edcd-4a8c-a8b9-c69ace3f89d1/metadata"
+          #    xsi:schemaLocation="http://www.vmware.com/vcloud/v1.5 http://10.194.1.65/api/v1.5/schema/master.xsd">'
+          #end
+
+          def tail
+            <<-END
+            </Metadata>
+            END
+          end
+        end
+
+        class MetadataV51 < MetadataBase
+          def metadata_entry(key, value)
+            <<-END
+            <MetadataEntry type="application/vnd.vmware.vcloud.metadata.value+xml">
+              <Key>#{key}</Key>
+              <TypedValue xsi:type="MetadataStringValue">
+                <Value>#{value}</Value>
+              </TypedValue>
+            </MetadataEntry>
+            END
+          end
+        end
+
+        class MetadataV15 < MetadataBase
+          def metadata_entry(key, value)
+            <<-END
+            <MetadataEntry>
+              <Key>#{key}</Key>
+              <Value>#{value}</Value>
+            </MetadataEntry>
+            END
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fog/vcloud_director/generators/compute/network_config_section.rb

@@ -0,0 +1,68 @@
+module Fog
+  module Generators
+    module Compute
+      module VcloudDirector
+        # @see http://pubs.vmware.com/vcd-51/topic/com.vmware.vcloud.api.reference.doc_51/doc/types/NetworkConfigSectionType.html
+        class NetworkConfigSection
+          attr_reader :options
+
+          def initialize(options={})
+            @options = options
+          end
+
+          def generate_xml
+            body = Nokogiri::XML::Builder.new do |xml|
+              attrs = {
+                :xmlns => 'http://www.vmware.com/vcloud/v1.5',
+                'xmlns:ovf' => 'http://schemas.dmtf.org/ovf/envelope/1'
+              }
+              xml.NetworkConfigSection(attrs){
+                xml['ovf'].Info
+                options[:NetworkConfig].each do |network_config|
+                  network_name = {networkName: network_config[:networkName]} if network_config[:networkName]
+                  xml.NetworkConfig(network_name){
+                    xml.Description network_config[:Description]
+                    if configuration = network_config[:Configuration]
+                      xml.Configuration {
+                        if ipScopes = configuration[:IpScopes]
+                          xml.IpScopes {
+                            if ipScope = ipScopes[:IpScope]
+                              xml.IpScope {
+                                xml.IsInherited ipScope[:IsInherited]
+                                xml.Gateway ipScope[:Gateway]
+                                xml.Netmask ipScope[:Netmask]
+                                xml.Dns1 ipScope[:Dns1] if ipScope[:Dns1]
+                                xml.Dns2 ipScope[:Dns2] if ipScope[:Dns2]
+                                xml.IsEnabled ipScope[:IsEnabled] if ipScope[:IsEnabled]
+                                if ipRanges = ipScope[:IpRanges]
+                                  xml.IpRanges {
+                                    if ipRange = ipRanges[:IpRange]
+                                      xml.IpRange {
+                                        xml.StartAddress ipRange[:StartAddress]
+                                        xml.EndAddress ipRange[:EndAddress]
+                                      }
+                                    end
+                                  }
+                                end
+                              }
+                            end
+                          }
+                        end
+                        if parent_network = configuration[:ParentNetwork]
+                          xml.ParentNetwork({href: parent_network[:href], id: parent_network[:id], name: parent_network[:name]})
+                        end
+                        xml.FenceMode configuration[:FenceMode] if configuration[:FenceMode]
+                        xml.RetainNetInfoAcrossDeployments configuration[:RetainNetInfoAcrossDeployments] if configuration[:RetainNetInfoAcrossDeployments]
+                      }
+                    end #Configuraton
+                    xml.IsDeployed configuration[:IsDeployed] if configuration[:IsDeployed]
+                  }
+                end
+              }
+            end.to_xml
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fog/vcloud_director/generators/compute/org_vdc_network.rb

@@ -0,0 +1,88 @@
+module Fog
+  module Generators
+    module Compute
+      module VcloudDirector
+        # @see http://pubs.vmware.com/vcd-51/topic/com.vmware.vcloud.api.reference.doc_51/doc/types/OrgVdcNetworkType.html
+        class OrgVdcNetwork
+          attr_reader :options
+
+          def initialize(options={})
+            @options = options
+          end
+
+          def generate_xml
+            body = Nokogiri::XML::Builder.new do
+              attrs = {
+                :xmlns => 'http://www.vmware.com/vcloud/v1.5',
+                :name  => options[:name]
+              }
+              OrgVdcNetwork(attrs) {
+                Description options[:Description] if options.key?(:Description)
+                if configuration = options[:Configuration]
+                  Configuration {
+                    if ip_scopes = configuration[:IpScopes]
+                      IpScopes {
+                        if ip_scope = ip_scopes[:IpScope]
+                          IpScope {
+                            IsInherited  ip_scope[:IsInherited] if ip_scope.key?(:IsInherited)
+                            Gateway      ip_scope[:Gateway]     if ip_scope.key?(:Gateway)
+                            Netmask      ip_scope[:Netmask]     if ip_scope.key?(:Netmask)
+                            Dns1         ip_scope[:Dns1]        if ip_scope.key?(:Dns1)
+                            Dns2         ip_scope[:Dns2]        if ip_scope.key?(:Dns2)
+                            DnsSuffix    ip_scope[:DnsSuffix]   if ip_scope.key?(:DnsSuffix)
+                            IsEnabled    ip_scope[:IsEnabled]   if ip_scope.key?(:IsEnabled)
+                            if ip_ranges = ip_scope[:IpRanges]
+                              IpRanges {
+                                ip_ranges.each do |h|
+                                  if h.key?(:IpRange)
+                                    IpRange {
+                                      StartAddress h[:IpRange][:StartAddress]
+                                      EndAddress   h[:IpRange][:EndAddress]
+                                    }
+                                  end
+                                end
+                              }
+                            end
+                          }
+                        end
+                      }
+                    end
+                    FenceMode    configuration[:FenceMode]
+                    if router_info = configuration[:RouterInfo]
+                      RouterInfoType {
+                        ExternalIp router_info[:ExternalIp]
+                      }
+                    end
+                  }
+                end # Configuration
+
+                if edgegw = options[:EdgeGateway] and configuration[:FenceMode] != 'isolated'
+                  EdgeGateway(edgegw)
+                elsif options[:Configuration] && options[:Configuration][:FenceMode] == 'isolated'
+                  # isolated networks can specify ServiceConfig
+                  if sc = options[:ServiceConfig]
+                    ServiceConfig {
+                      if dhcp = sc[:GatewayDhcpService]
+                        IsEnabled dhcp[:IsEnabled] if dhcp[:IsEnabled]
+                        if pool = dhcp[:Pool]
+                          IsEnabled        pool[:IsEnabled]
+                          DefaultLeaseTime pool[:DefaultLeaseTime]
+                          MaxLeaseTime     pool[:MaxLeaseTime]
+                          LowIpAddress     pool[:LowIpAddress]
+                          HighIpAddress    pool[:HighIpAddress]
+                        end
+                      end
+                    }
+                  end
+                end
+
+                IsShared       options[:IsShared] if options.key?(:IsShared)
+
+              }
+            end.to_xml
+          end
+        end
+      end
+    end
+  end
+end