Adds an Endpoint to the Virtual Machine which in effect creates a firewall rule
Inheritance: ICustomXmlSerializer
Exemplo n.º 1
0
        /// <summary>
        /// Used to direct the user to the image for the default Sql Server 2012 image
        /// </summary>
        /// <returns>A persistent VM Role containing the data to execute the image</returns>
        public static PersistentVMRole GetDefaultSqlServer2012VMRole(VmSize vmSize, string storageAccount)
        {
            // build the default endpoints
            var inputEndpoints = new InputEndpoints();

            inputEndpoints.AddEndpoint(InputEndpoint.GetDefaultRemoteDesktopSettings());
            inputEndpoints.AddEndpoint(InputEndpoint.GetDefaultSqlServerSettings());
            // add the endpoints collections to a network configuration set
            var network = new NetworkConfigurationSet
            {
                InputEndpoints = inputEndpoints
            };
            // build the windows configuration set
            var windows = new WindowsConfigurationSet
            {
                AdminPassword             = "******",
                ResetPasswordOnFirstLogon = true
            };
            OSVirtualHardDisk   osDisk   = OSVirtualHardDisk.GetSqlServerOSImage(storageAccount);
            DataVirtualHardDisk dataDisk = DataVirtualHardDisk.GetDefaultDataDisk(storageAccount);
            var disks = new DataVirtualHardDisks();

            disks.HardDiskCollection.Add(dataDisk);
            return(new PersistentVMRole
            {
                NetworkConfigurationSet = network,
                OperatingSystemConfigurationSet = windows,
                RoleSize = vmSize,
                RoleName = "Elastarole",
                HardDisks = disks,
                OSHardDisk = osDisk
            });
        }
        private NetworkConfigurationSet GetNetworkConfigurationSet(XElement configurationSet)
        {
            NetworkConfigurationSet networkConfigurationSet = null;

            if (configurationSet.Element(Namespace + "ConfigurationSetType").Value == "NetworkConfiguration")
            {
                networkConfigurationSet = new NetworkConfigurationSet();
                var subnets = configurationSet.Element(Namespace + "SubnetNames");
                if (subnets != null)
                {
                    var subnet = subnets.Element(Namespace + "SubnetName");
                    if (subnet != null)
                    {
                        networkConfigurationSet.SubnetName = (string)subnet;
                    }
                }
                networkConfigurationSet.InputEndpoints = new InputEndpoints();
                var endpoints = configurationSet.Descendants(Namespace + "InputEndpoint");
                foreach (var endpoint in endpoints)
                {
                    var inputEndpoint = new InputEndpoint
                    {
                        EndpointName = GetStringValue(endpoint.Element(Namespace + "Name")),
                        Port         = GetIntValue(endpoint.Element(Namespace + "Port")),
                        LocalPort    = GetIntValue(endpoint.Element(Namespace + "LocalPort")),
                        Protocol     = GetEnumValue <Protocol>(endpoint.Element(Namespace + "Protocol")),
                        Vip          = GetStringValue(endpoint.Element(Namespace + "Vip"))
                    };
                    networkConfigurationSet.InputEndpoints.AddEndpoint(inputEndpoint);
                }
            }
            return(networkConfigurationSet);
        }
 /// <summary>
 /// Adds an endpoint checking to see whether the name and ports have been taken 
 /// </summary>
 /// <param name="endpoint">An InputEndpoint which should be added to the collection</param>
 public void AddEndpoint(InputEndpoint endpoint)
 {
     // check to see whether the endpoint exists or not
     IEnumerable<InputEndpoint> endpoints =
         _endpoints.Where(a => a.LocalPort == endpoint.LocalPort || (a.Port == endpoint.LocalPort && a.Port != 0)
                               || a.EndpointName == endpoint.EndpointName);
     if (endpoints.Any())
         throw new ApplicationException(
             "An endpoint containing the Local/Remote port and/or endpoint name already exists");
     // continue if it doesn't
     _endpoints.Add(endpoint);
 }
Exemplo n.º 4
0
        /// <summary>
        /// Adds an endpoint checking to see whether the name and ports have been taken
        /// </summary>
        /// <param name="endpoint">An InputEndpoint which should be added to the collection</param>
        public void AddEndpoint(InputEndpoint endpoint)
        {
            // check to see whether the endpoint exists or not
            IEnumerable <InputEndpoint> endpoints =
                _endpoints.Where(a => a.LocalPort == endpoint.LocalPort || (a.Port == endpoint.LocalPort && a.Port != 0) ||
                                 a.EndpointName == endpoint.EndpointName);

            if (endpoints.Any())
            {
                throw new ApplicationException(
                          "An endpoint containing the Local/Remote port and/or endpoint name already exists");
            }
            // continue if it doesn't
            _endpoints.Add(endpoint);
        }
 private NetworkConfigurationSet GetNetworkConfigurationSet(XElement configurationSet)
 {
     NetworkConfigurationSet networkConfigurationSet = null;
     if (configurationSet.Element(Namespace + "ConfigurationSetType").Value == "NetworkConfiguration")
     {
         networkConfigurationSet = new NetworkConfigurationSet();
         networkConfigurationSet.InputEndpoints= new InputEndpoints();
         var endpoints = configurationSet.Descendants(Namespace + "InputEndpoint");
         foreach (var endpoint in endpoints)
         {
             var inputEndpoint = new InputEndpoint
             {
                 EndpointName = GetStringValue(endpoint.Element(Namespace + "Name")),
                 Port = GetIntValue(endpoint.Element(Namespace + "Port")),
                 LocalPort = GetIntValue(endpoint.Element(Namespace + "LocalPort")),
                 Protocol = GetEnumValue<Protocol>(endpoint.Element(Namespace + "Protocol")),
                 Vip = GetStringValue(endpoint.Element(Namespace + "Vip"))
             };
             networkConfigurationSet.InputEndpoints.AddEndpoint(inputEndpoint);
         }
     }
     return networkConfigurationSet;
 }
Exemplo n.º 6
0
        public static PersistentVMRole GetAdHocTemplate(VirtualMachineProperties properties, ConfigurationSet operatingSystemConfigurationSet)
        {
            // build the default endpoints
            var inputEndpoints = new InputEndpoints();

            if (properties.PublicEndpoints == null)
            {
                properties.PublicEndpoints = new List <InputEndpoint>();
            }
            // add all of the endpoints
            foreach (var endpoint in properties.PublicEndpoints)
            {
                inputEndpoints.AddEndpoint(endpoint);
            }

            if (operatingSystemConfigurationSet.ConfigurationSetType == ConfigurationSetType.WindowsProvisioningConfiguration)
            {
                if (properties.PublicEndpoints.All(endpoint => endpoint.Port != 3389))
                {
                    inputEndpoints.AddEndpoint(InputEndpoint.GetDefaultRemoteDesktopSettings());
                }
            }

            // add the endpoints collections to a network configuration set
            var network = new NetworkConfigurationSet
            {
                InputEndpoints = inputEndpoints
            };

            if (properties.EndpointAclRules != null)
            {
                network.EndpointAcl = new EndpointAcl(new EndpointAclRules(properties.EndpointAclRules));
            }

            if (properties.VirtualNetwork != null)
            {
                network.SubnetName = properties.VirtualNetwork.SubnetName;
            }

            OSVirtualHardDisk osDisk = OSVirtualHardDisk.GetOSImageFromTemplate(properties);
            var disks = new DataVirtualHardDisks();

            if (properties.DataDisks != null)
            {
                for (int i = 0; i < properties.DataDisks.Count; i++)
                {
                    var label = properties.DataDisks[i].DiskLabel ?? "DataDisk" + i;
                    var name  = properties.DataDisks[i].DiskName ?? "DataDisk" + i;
                    var size  = properties.DataDisks[i].LogicalDiskSizeInGB < 30
                                   ? 30
                                   : properties.DataDisks[i].LogicalDiskSizeInGB;
                    var disk = DataVirtualHardDisk.GetDefaultDataDisk(properties.StorageAccountName, size, i, name, label);
                    disks.HardDiskCollection.Add(disk);
                }
            }
            var pvm = new PersistentVMRole
            {
                NetworkConfigurationSet         = network,
                OperatingSystemConfigurationSet = operatingSystemConfigurationSet,
                RoleSize   = properties.VmSize,
                RoleName   = properties.RoleName,
                HardDisks  = disks,
                OSHardDisk = osDisk
            };

            if (properties.AvailabilitySet != null)
            {
                pvm.AvailabilityNameSet = properties.AvailabilitySet;
            }

            return(pvm);
        }