Beispiel #1
0
        internal static void DeconfigureScopeFailover(DhcpServerScope scope)
        {
            var relationship = scope.GetFailoverRelationship();
            var partner      = relationship.ConnectToPartner();
            var partnerScope = partner.Scopes.GetScope(scope.Address);

            // deactivate scope on the failover relationship
            partnerScope.Deactivate();

            using (var relationshipNative = new DHCP_FAILOVER_RELATIONSHIP_Managed(relationshipName: relationship.Name,
                                                                                   scopes: new DHCP_IP_ARRAY_Managed(scope.Address.ToNativeAsNetwork())))
            {
                // remove scope from failover relationship on partner server
                var result = Api.DhcpV4FailoverDeleteScopeFromRelationship(partner.Address, in relationshipNative);
                if (result != DhcpErrors.SUCCESS)
                {
                    throw new DhcpServerException(nameof(Api.DhcpV4FailoverDeleteScopeFromRelationship), result, "Failed to delete scope from relationship on partner server");
                }

                // remove scope from failover relationship on server
                result = Api.DhcpV4FailoverDeleteScopeFromRelationship(scope.Server.Address, in relationshipNative);
                if (result != DhcpErrors.SUCCESS)
                {
                    throw new DhcpServerException(nameof(Api.DhcpV4FailoverDeleteScopeFromRelationship), result, "Failed to delete scope from relationship");
                }
            }

            // delete scope on partner server
            partnerScope.Delete();
        }
Beispiel #2
0
        internal static void AddScopeToFailoverRelationship(DhcpServerFailoverRelationship relationship, DhcpServerScope scope)
        {
            var partnerServer = (DhcpServer)relationship.ConnectToPartner();

            // create/replicate
            var partnerScope = CreateOrReplicatePartnerScope(partnerServer, scope);

            // determine relationship primary/secondary servers
            DhcpServer primaryServer;
            DhcpServer secondaryServer;

            if (relationship.ServerType == DhcpServerFailoverServerType.PrimaryServer)
            {
                primaryServer   = relationship.Server;
                secondaryServer = partnerServer;
            }
            else
            {
                primaryServer   = partnerServer;
                secondaryServer = relationship.Server;
            }

            using (var relationshipNative = new DHCP_FAILOVER_RELATIONSHIP_Managed(relationshipName: relationship.Name,
                                                                                   scopes: new DHCP_IP_ARRAY_Managed(scope.Address.ToNativeAsNetwork())))
            {
                // update relationship on primary server
                var result = Api.DhcpV4FailoverAddScopeToRelationship(primaryServer.Address, in relationshipNative);
                if (result != DhcpErrors.SUCCESS)
                {
                    throw new DhcpServerException(nameof(Api.DhcpV4FailoverAddScopeToRelationship), result, "Failed to add scope to failover relationship on primary server");
                }

                // update relationship on secondary server
                result = Api.DhcpV4FailoverAddScopeToRelationship(secondaryServer.Address, in relationshipNative);
                if (result != DhcpErrors.SUCCESS)
                {
                    throw new DhcpServerException(nameof(Api.DhcpV4FailoverAddScopeToRelationship), result, "Failed to add scope to failover relationship on secondary server");
                }
            }

            // update local cache
            relationship.scopeAddresses.Add(scope.Address);

            // activate scope on partner (if the scope is active on primary)
            if (scope.State == DhcpServerScopeState.Enabled || scope.State == DhcpServerScopeState.EnabledSwitched)
            {
                partnerScope = (DhcpServerScope)partnerServer.Scopes.GetScope(partnerScope.Address);
                partnerScope.Activate();
            }
        }
Beispiel #3
0
        internal static DhcpServerFailoverRelationship CreateFailoverRelationship(DhcpServerScope scope, DhcpServer partnerServer, string name, string sharedSecret, DhcpServerFailoverMode mode, byte modePercentage, TimeSpan maximumClientLeadTime, TimeSpan?stateSwitchInterval)
        {
            if (scope == null)
            {
                throw new ArgumentNullException(nameof(scope));
            }
            if (partnerServer == null)
            {
                throw new ArgumentNullException(nameof(partnerServer));
            }
            if (string.IsNullOrWhiteSpace(sharedSecret))
            {
                throw new ArgumentNullException(nameof(sharedSecret));
            }

            if (string.IsNullOrWhiteSpace(name))
            {
                name = BuildRelationshipName(scope.Server, partnerServer);
            }

            if (!scope.Server.IsCompatible(DhcpServerVersions.Windows2012) || !partnerServer.IsCompatible(DhcpServerVersions.Windows2012))
            {
                throw new DhcpServerException(nameof(Api.DhcpV4FailoverCreateRelationship), DhcpErrors.ERROR_INVALID_PARAMETER, "Windows Server 2012 is required to establish a failover relationship");
            }

            var primaryServerAddress = scope.Server.Address;

            if (primaryServerAddress == (DhcpServerIpAddress)0x7F_00_00_01) // localhost: 127.0.0.1
            {
                primaryServerAddress = scope.Server.BindingElements.First().AdapterPrimaryIpAddress;
            }

            var existingRelationship = scope.GetFailoverRelationship();

            if (existingRelationship != null)
            {
                throw new DhcpServerException(nameof(Api.DhcpV4FailoverCreateRelationship), DhcpErrors.FO_SCOPE_ALREADY_IN_RELATIONSHIP);
            }

            // create/replicate
            var partnerScope = CreateOrReplicatePartnerScope(partnerServer, scope);

            // define relationship
            using (var primaryRelationship = new DHCP_FAILOVER_RELATIONSHIP_Managed(primaryServer: primaryServerAddress.ToNativeAsNetwork(),
                                                                                    secondaryServer: partnerServer.Address.ToNativeAsNetwork(),
                                                                                    mode: (DHCP_FAILOVER_MODE)mode,
                                                                                    serverType: DHCP_FAILOVER_SERVER.PrimaryServer,
                                                                                    state: FSM_STATE.NO_STATE,
                                                                                    prevState: FSM_STATE.NO_STATE,
                                                                                    mclt: (int)maximumClientLeadTime.TotalSeconds,
                                                                                    safePeriod: (int)(stateSwitchInterval?.TotalSeconds ?? -1),
                                                                                    relationshipName: name,
                                                                                    primaryServerName: scope.Server.Name,
                                                                                    secondaryServerName: partnerServer.Name,
                                                                                    scopes: new DHCP_IP_ARRAY_Managed(scope.Address.ToNativeAsNetwork()),
                                                                                    percentage: modePercentage,
                                                                                    sharedSecret: sharedSecret))
            {
                // create relationship on partner server
                var partnerRelationship = primaryRelationship.InvertRelationship();
                var result = Api.DhcpV4FailoverCreateRelationship(partnerServer.Address, in partnerRelationship);
                if (result != DhcpErrors.SUCCESS)
                {
                    throw new DhcpServerException(nameof(Api.DhcpV4FailoverCreateRelationship), result, "Failed to create relationship on partner server");
                }

                // create relationship on primary server
                result = Api.DhcpV4FailoverCreateRelationship(scope.Server.Address, in primaryRelationship);
                if (result != DhcpErrors.SUCCESS)
                {
                    throw new DhcpServerException(nameof(Api.DhcpV4FailoverCreateRelationship), result, "Failed to create relationship on primary server");
                }

                // activate scope on partner (if the scope is active on primary)
                if (scope.State == DhcpServerScopeState.Enabled || scope.State == DhcpServerScopeState.EnabledSwitched)
                {
                    partnerScope = (DhcpServerScope)partnerServer.Scopes.GetScope(partnerScope.Address);
                    partnerScope.Activate();
                }

                return(FromNative(scope.Server, in primaryRelationship));
            }
        }