Example #1
0
        private static List <AmClusterResource> AddIpAddressesToStrandedNetworks(ILogTraceHelper logger, AmClusterGroup group, AmClusterResource netname, IEnumerable <AmClusterNetwork> publicNetworks, IEnumerable <string> networksWithResources)
        {
            logger = (logger ?? NullLogTraceHelper.GetNullLogger());
            if (publicNetworks.Count <AmClusterNetwork>() <= networksWithResources.Count <string>())
            {
                logger.AppendLogMessage("AddIpAddressesToStrandedNetworks: publicNetworks.Count({0}) <= networksWithResources.Count({1}). So we're doing nothing.", new object[]
                {
                    publicNetworks.Count <AmClusterNetwork>(),
                    networksWithResources.Count <string>()
                });
                return(new List <AmClusterResource>(0));
            }
            List <AmClusterResource>       list       = new List <AmClusterResource>(publicNetworks.Count <AmClusterNetwork>() - networksWithResources.Count <string>());
            IEnumerable <AmClusterNetwork> enumerable = from publicNet in publicNetworks
                                                        where !networksWithResources.Contains(publicNet.Name)
                                                        select publicNet;

            foreach (AmClusterNetwork amClusterNetwork in enumerable)
            {
                logger.AppendLogMessage("AddIpAddressesToStrandedNetworks() There doesn't appear to be an IP resource on network '{0}'.", new object[]
                {
                    amClusterNetwork.Name
                });
                IEnumerable <string>     source     = amClusterNetwork.EnumerateAlternateIPv4Names();
                IEnumerable <string>     source2    = amClusterNetwork.EnumeratePureAlternateIPv6Names();
                List <AmClusterResource> collection = AmClusterResourceHelper.CreateIpAddressResources(logger, group, netname, null, source.ToArray <string>(), source2.ToArray <string>());
                list.AddRange(collection);
            }
            return(list);
        }
Example #2
0
        public static string ConstructIPDependencyExpression(ILogTraceHelper logger, IEnumerable <AmClusterResource> ipResList, bool enforceIPv4AndIPv6)
        {
            int           capacity       = 80;
            StringBuilder stringBuilder  = new StringBuilder(capacity);
            StringBuilder stringBuilder2 = new StringBuilder(capacity);
            StringBuilder stringBuilder3 = new StringBuilder(capacity);

            logger = (logger ?? NullLogTraceHelper.GetNullLogger());
            foreach (AmClusterResource amClusterResource in ipResList)
            {
                if (amClusterResource.IsIpv4())
                {
                    if (stringBuilder.Length > 0)
                    {
                        stringBuilder.Append(" OR ");
                    }
                    stringBuilder.Append("[" + amClusterResource.Name + "]");
                }
                else
                {
                    if (stringBuilder2.Length > 0)
                    {
                        stringBuilder2.Append(" OR ");
                    }
                    stringBuilder2.Append("[" + amClusterResource.Name + "]");
                }
            }
            if (enforceIPv4AndIPv6)
            {
                if (stringBuilder.Length > 0)
                {
                    stringBuilder3.Append("(" + stringBuilder + ")");
                }
                if (stringBuilder2.Length > 0 && stringBuilder.Length > 0)
                {
                    stringBuilder3.Append(" AND ");
                }
                if (stringBuilder2.Length > 0)
                {
                    stringBuilder3.Append("(" + stringBuilder2 + ")");
                }
            }
            else
            {
                stringBuilder3.Append(stringBuilder);
                if (stringBuilder2.Length > 0 && stringBuilder.Length > 0)
                {
                    stringBuilder3.Append(" OR ");
                }
                stringBuilder3.Append(stringBuilder2);
            }
            logger.AppendLogMessage("Constructed dependency expression: {0} (enforceIPv4AndIPv6={1})", new object[]
            {
                stringBuilder3,
                enforceIPv4AndIPv6
            });
            return(stringBuilder3.ToString());
        }
Example #3
0
 internal static string GetNetworkNameFromIpResource(ILogTraceHelper logger, AmClusterResource ipRes)
 {
     logger = (logger ?? NullLogTraceHelper.GetNullLogger());
     if (!ipRes.IsIpv4() && !ipRes.IsIpv6())
     {
         throw new ArgumentException("GetNetworkFromIpResource() needs an IP resource.");
     }
     return(ipRes.GetPrivateProperty <string>("Network"));
 }
Example #4
0
        private static List <AmClusterResource> CreateIpAddressResources(ILogTraceHelper logger, AmClusterGroup group, AmClusterResource netname, IPAddress ipv4StaticAddress, string[] ipv4Networks, string[] ipv6Networks)
        {
            logger = (logger ?? NullLogTraceHelper.GetNullLogger());
            logger.AppendLogMessage("CreateIpAddressResources(). IPv4Networks=[{0}]. IPv6Networks=[{1}].", new object[]
            {
                (ipv4Networks == null) ? string.Empty : string.Join(",", ipv4Networks),
                (ipv6Networks == null) ? string.Empty : string.Join(",", ipv6Networks)
            });
            List <AmClusterResource> list = new List <AmClusterResource>(2);

            if (ipv4Networks != null)
            {
                list.AddRange(AmClusterResourceHelper.ConfigureIPv4DhcpResources(logger, group, ipv4Networks));
            }
            if (ipv6Networks != null)
            {
                list.AddRange(AmClusterResourceHelper.ConfigureIPv6AutoCfgResources(logger, group, ipv6Networks));
            }
            return(list);
        }
Example #5
0
        public IAmClusterResource CreateUniqueResource(ILogTraceHelper logger, string resPrefix, string resType, ref int nextIndex)
        {
            int                num    = nextIndex;
            string             text   = null;
            IAmClusterResource result = null;

            logger = (logger ?? NullLogTraceHelper.GetNullLogger());
            if (resPrefix == null)
            {
                resPrefix = resType;
            }
            try
            {
IL_1A:
                text = string.Format("{0} {1} ({2})", resPrefix, num, this.Name);
                logger.AppendLogMessage("CreateUniqueResource() Trying to create a resource named '{0}'.", new object[]
                {
                    text
                });
                result = this.CreateResource(text, resType);
                num++;
                nextIndex = num;
                logger.AppendLogMessage("CreateUniqueResource() Created a resource named '{0}'.", new object[]
                {
                    text
                });
            }
            catch (ClusResourceAlreadyExistsException)
            {
                logger.AppendLogMessage("CreateUniqueResource() Resource '{0}' already exists. Trying again.", new object[]
                {
                    text
                });
                num++;
                goto IL_1A;
            }
            return(result);
        }
Example #6
0
        private static void ResolveServersInternal(ILogTraceHelper output, DatabaseAvailabilityGroup dag, Dictionary <AmServerName, Server> servers, Dictionary <AmServerName, Server> startedServers, Dictionary <AmServerName, Server> stoppedServers, bool startedListIsReadFromAd)
        {
            if (dag == null)
            {
                throw new ArgumentNullException("dag");
            }
            if (servers == null)
            {
                throw new ArgumentNullException("servers");
            }
            if (startedServers == null)
            {
                throw new ArgumentNullException("startedServers");
            }
            if (stoppedServers == null)
            {
                throw new ArgumentNullException("stoppedServers");
            }
            output = (output ?? NullLogTraceHelper.GetNullLogger());
            foreach (ADObjectId entryId in dag.Servers)
            {
                Server       server       = dag.Session.Read <Server>(entryId);
                AmServerName amServerName = new AmServerName(server.Fqdn);
                if (!server.IsMailboxServer)
                {
                    throw new OperationOnlyOnMailboxServerException(server.Name);
                }
                if (server.MajorVersion != Server.CurrentExchangeMajorVersion)
                {
                    throw new DagTaskErrorServerWrongVersion(server.Name);
                }
                servers.Add(amServerName, server);
                bool flag = false;
                if (dag.StoppedMailboxServers.Contains(amServerName.Fqdn))
                {
                    stoppedServers.Add(amServerName, server);
                    flag = true;
                }
                if (startedListIsReadFromAd)
                {
                    if (dag.StartedMailboxServers.Contains(amServerName.Fqdn))
                    {
                        startedServers.Add(amServerName, server);
                    }
                }
                else if (!flag)
                {
                    startedServers.Add(amServerName, server);
                }
            }
            output.AppendLogMessage("Successfully resolved the servers based on the stopped servers list.", new object[0]);
            string text;

            if (startedListIsReadFromAd)
            {
                text = "The list is the StartedServers property of the DAG in AD";
            }
            else
            {
                text = "The list is all of the servers that are not in the StoppedServers list.";
            }
            output.AppendLogMessage("The following servers are in the StartedServers list ({0}):", new object[]
            {
                text
            });
            foreach (AmServerName amServerName2 in startedServers.Keys)
            {
                output.AppendLogMessage("\t{0}", new object[]
                {
                    amServerName2.NetbiosName
                });
            }
            output.AppendLogMessage("The following servers are in the StoppedServers list:", new object[0]);
            foreach (AmServerName amServerName3 in stoppedServers.Keys)
            {
                output.AppendLogMessage("\t{0}", new object[]
                {
                    amServerName3.NetbiosName
                });
            }
        }
Example #7
0
        internal static int DeleteOrphanedIpAddresses(ILogTraceHelper logger, AmClusterGroup owningGroup, AmClusterResource netname, IEnumerable <AmClusterResource> currentIpResources, IEnumerable <IPAddress> staticIpAddresses, IEnumerable <AmClusterNetwork> allNetworks, out IList <string> networksWithResources)
        {
            logger = (logger ?? NullLogTraceHelper.GetNullLogger());
            int num = 0;

            networksWithResources = new List <string>(allNetworks.Count <AmClusterNetwork>());
            bool flag  = staticIpAddresses != null && staticIpAddresses.Count <IPAddress>() > 0;
            bool flag2 = staticIpAddresses != null && staticIpAddresses.Count <IPAddress>() == 0;

            if (currentIpResources.Count <AmClusterResource>() < 1)
            {
                logger.AppendLogMessage("DeleteOrphanedIpAddresses() found no IP address resources in the cluster at all!", new object[0]);
            }
            else
            {
                IAmCluster owningCluster            = owningGroup.OwningCluster;
                Dictionary <string, int> dictionary = new Dictionary <string, int>(networksWithResources.Count <string>());
                IEnumerable <string>     enumerable = netname.EnumerateDependentNames();
                logger.AppendLogMessage("Netname resource '{0}' depends on the following resources:", new object[]
                {
                    netname.Name
                });
                foreach (string text in enumerable)
                {
                    logger.AppendLogMessage("  -> {0}", new object[]
                    {
                        text
                    });
                }
                foreach (AmClusterResource amClusterResource in currentIpResources)
                {
                    bool   flag3            = false;
                    string privateProperty  = amClusterResource.GetPrivateProperty <string>("Network");
                    int    privateProperty2 = amClusterResource.GetPrivateProperty <int>("EnableDhcp");
                    logger.AppendLogMessage("Resource '{0}' is on network '{1}' (enableDhcp={2}).", new object[]
                    {
                        amClusterResource.Name,
                        privateProperty,
                        privateProperty2
                    });
                    if (!enumerable.Contains(amClusterResource.Name))
                    {
                        logger.AppendLogMessage("Resource '{0}' should be deleted because the cluster netname does not depend on it.", new object[]
                        {
                            amClusterResource.Name
                        });
                        flag3 = true;
                    }
                    else if (string.IsNullOrEmpty(privateProperty))
                    {
                        logger.AppendLogMessage("Resource '{0}' should be deleted because it does not have a valid network.", new object[]
                        {
                            amClusterResource.Name
                        });
                        flag3 = true;
                    }
                    else
                    {
                        if (flag)
                        {
                            if (privateProperty2 != 0)
                            {
                                logger.AppendLogMessage("Resource '{0}' should be deleted because it's a DHCP resource and we're converting to static addresses.", new object[]
                                {
                                    amClusterResource.Name
                                });
                                flag3 = true;
                            }
                            else if (amClusterResource.IsIpv6())
                            {
                                logger.AppendLogMessage("Resource '{0}' should be deleted because it's an IPv6 resource and we're converting to static addresses.", new object[]
                                {
                                    amClusterResource.Name
                                });
                                flag3 = true;
                            }
                            else
                            {
                                string    privateProperty3 = amClusterResource.GetPrivateProperty <string>("Address");
                                IPAddress ipaddress        = IPAddress.Parse(privateProperty3);
                                if (!staticIpAddresses.Contains(ipaddress))
                                {
                                    logger.AppendLogMessage("Resource '{0}' should be deleted because it's a static address ({1}) that is not in the list of updated addresses.", new object[]
                                    {
                                        amClusterResource.Name,
                                        ipaddress
                                    });
                                    flag3 = true;
                                }
                            }
                        }
                        else if (flag2 && privateProperty2 == 0 && amClusterResource.IsIpv4())
                        {
                            logger.AppendLogMessage("Resource '{0}' should be deleted because it's a static IPv4 resource and we're converting to dynamic addresses.", new object[]
                            {
                                amClusterResource.Name
                            });
                            flag3 = true;
                        }
                        if (!flag3)
                        {
                            using (AmClusterNetwork networkFromIpResource = AmClusterResourceHelper.GetNetworkFromIpResource(logger, amClusterResource))
                            {
                                if (networkFromIpResource == null)
                                {
                                    logger.AppendLogMessage("Resource '{0}' should be deleted because it does not have a valid network.", new object[]
                                    {
                                        amClusterResource.Name
                                    });
                                    flag3 = true;
                                }
                                else
                                {
                                    dictionary[networkFromIpResource.Name] = 1;
                                }
                            }
                        }
                    }
                    if (flag3)
                    {
                        logger.AppendLogMessage("Deleting resource named '{0}' because its network ({1}) does not appear to be valid (enableDhcp={2}).", new object[]
                        {
                            amClusterResource.Name,
                            privateProperty,
                            privateProperty2
                        });
                        amClusterResource.OfflineResource();
                        netname.RemoveDependency(amClusterResource);
                        amClusterResource.DeleteResource();
                        amClusterResource.Dispose();
                        num++;
                    }
                }
                foreach (string item in dictionary.Keys)
                {
                    networksWithResources.Add(item);
                }
            }
            return(num);
        }
Example #8
0
        public static List <AmClusterResource> ConfigureIPv6AutoCfgResources(ILogTraceHelper logger, AmClusterGroup group, string[] ipv6Networks)
        {
            bool flag = false;
            Dictionary <string, AmClusterResource> dictionary  = new Dictionary <string, AmClusterResource>(8);
            Dictionary <string, AmClusterNetwork>  dictionary2 = null;

            AmClusterResource[]      array = null;
            List <AmClusterResource> list  = new List <AmClusterResource>(10);
            List <AmClusterResource> list2 = null;

            try
            {
                logger      = (logger ?? NullLogTraceHelper.GetNullLogger());
                dictionary2 = AmClusterResourceHelper.GetIpv6AutoCfgNetworkMap(group.OwningCluster, ipv6Networks);
                IEnumerable <AmClusterResource> source = group.EnumerateResourcesOfType("IPv6 Address");
                if (source.Count <AmClusterResource>() > 0)
                {
                    array = source.ToArray <AmClusterResource>();
                }
                if (array != null)
                {
                    foreach (string key in ipv6Networks)
                    {
                        for (int j = 0; j < array.Length; j++)
                        {
                            AmClusterResource amClusterResource = array[j];
                            string            privateProperty   = amClusterResource.GetPrivateProperty <string>("Network");
                            AmClusterNetwork  amClusterNetwork  = dictionary2[key];
                            if (SharedHelper.StringIEquals(amClusterNetwork.Name, privateProperty))
                            {
                                logger.AppendLogMessage("Reusing ipv6 resource because its network is matching. (resource:{0}, network:{1}/{2}", new object[]
                                {
                                    amClusterResource.Name,
                                    privateProperty,
                                    amClusterNetwork.Name
                                });
                                dictionary[key] = amClusterResource;
                                array[j]        = null;
                                break;
                            }
                        }
                    }
                }
                if (dictionary.Count < ipv6Networks.Length)
                {
                    int num = 1;
                    foreach (string text in ipv6Networks)
                    {
                        if (!dictionary.ContainsKey(text))
                        {
                            AmClusterResource amClusterResource = (AmClusterResource)group.CreateUniqueResource(logger, "IPv6 Auto Config Address", "IPv6 Address", ref num);
                            list.Add(amClusterResource);
                            logger.AppendLogMessage("Created new ipv6 resource. (resource:{0}, network:{1})", new object[]
                            {
                                amClusterResource.Name,
                                text
                            });
                            dictionary[text] = amClusterResource;
                        }
                    }
                }
                list2 = new List <AmClusterResource>(ipv6Networks.Length);
                foreach (string key2 in ipv6Networks)
                {
                    AmClusterResource amClusterResource = dictionary[key2];
                    AmClusterNetwork  amClusterNetwork  = dictionary2[key2];
                    logger.AppendLogMessage("ConfigureIPv6AutoCfgResources: Setting resource '{0}' to be on network '{1}' (role={2}).", new object[]
                    {
                        amClusterResource.Name,
                        amClusterNetwork.Name,
                        amClusterNetwork.GetNativeRole()
                    });
                    amClusterResource.SetPrivateProperty <string>("Network", amClusterNetwork.Name);
                    AmClusterResourceHelper.SetPossibleOwnersForIpResource(logger, amClusterResource);
                    list2.Add(amClusterResource);
                }
                flag = true;
            }
            finally
            {
                if (!flag)
                {
                    SharedHelper.DisposeObjectList <AmClusterResource>(list);
                }
                SharedHelper.DisposeObjectList <AmClusterResource>(array);
                if (dictionary2 != null)
                {
                    SharedHelper.DisposeObjectList <AmClusterNetwork>(dictionary2.Values);
                }
            }
            return(list2);
        }
Example #9
0
        public static List <AmClusterResource> ConfigureIPv4DhcpResources(ILogTraceHelper logger, AmClusterGroup group, string[] ipv4Networks)
        {
            bool flag = false;
            Dictionary <string, AmClusterResource> dictionary  = new Dictionary <string, AmClusterResource>(8);
            Dictionary <string, AmClusterNetwork>  dictionary2 = null;

            AmClusterResource[]      array = null;
            List <AmClusterResource> list  = new List <AmClusterResource>(10);
            List <AmClusterResource> list2 = new List <AmClusterResource>(10);
            List <AmClusterResource> list3 = null;

            try
            {
                logger      = (logger ?? NullLogTraceHelper.GetNullLogger());
                dictionary2 = AmClusterResourceHelper.GetIpv4DhcpNetworkMap(group.OwningCluster, ipv4Networks);
                IEnumerable <AmClusterResource> enumerable = group.EnumerateResourcesOfType("IP Address");
                if (enumerable != null)
                {
                    array = enumerable.ToArray <AmClusterResource>();
                    for (int i = 0; i < array.Length; i++)
                    {
                        AmClusterResource amClusterResource = array[i];
                        if (amClusterResource.GetPrivateProperty <int>("EnableDhcp") != 0)
                        {
                            list.Add(amClusterResource);
                            array[i] = null;
                        }
                    }
                }
                foreach (string key in ipv4Networks)
                {
                    for (int k = 0; k < list.Count; k++)
                    {
                        AmClusterResource amClusterResource2 = list[k];
                        string            privateProperty    = amClusterResource2.GetPrivateProperty <string>("Network");
                        AmClusterNetwork  amClusterNetwork   = dictionary2[key];
                        if (SharedHelper.StringIEquals(amClusterNetwork.Name, privateProperty))
                        {
                            logger.AppendLogMessage("Reusing ipv4 dhcp resource because its network is matching. (resource:{0}, network:{1}/{2}", new object[]
                            {
                                amClusterResource2.Name,
                                privateProperty,
                                amClusterNetwork.Name
                            });
                            dictionary[key] = amClusterResource2;
                            list[k]         = null;
                            break;
                        }
                    }
                }
                if (dictionary.Count < ipv4Networks.Length)
                {
                    int num = 1;
                    foreach (string text in ipv4Networks)
                    {
                        if (!dictionary.ContainsKey(text))
                        {
                            AmClusterResource amClusterResource2 = (AmClusterResource)group.CreateUniqueResource(logger, "IPv4 DHCP Address", "IP Address", ref num);
                            list2.Add(amClusterResource2);
                            logger.AppendLogMessage("Created new ipv4 dhcp resource. (resource:{0}, network:{1})", new object[]
                            {
                                amClusterResource2.Name,
                                text
                            });
                            dictionary[text] = amClusterResource2;
                        }
                    }
                }
                list3 = new List <AmClusterResource>(ipv4Networks.Length);
                foreach (string key2 in ipv4Networks)
                {
                    AmClusterResource amClusterResource2 = dictionary[key2];
                    AmClusterNetwork  amClusterNetwork   = dictionary2[key2];
                    int num2;
                    using (AmClusterPropListDisposable amClusterPropListDisposable = AmClusPropListMaker.CreatePropListInt("EnableDhcp", 1, out num2))
                    {
                        using (AmClusterPropListDisposable amClusterPropListDisposable2 = AmClusPropListMaker.DupeAndAppendPropListString(amClusterPropListDisposable.RawBuffer, (int)amClusterPropListDisposable.BufferSize, "Network", amClusterNetwork.Name, out num2))
                        {
                            logger.AppendLogMessage("ConfigureIPv4DhcpResources: Setting resource '{0}' to be DHCP-enabled on network '{1}' (role={2}).", new object[]
                            {
                                amClusterResource2.Name,
                                amClusterNetwork.Name,
                                amClusterNetwork.GetNativeRole()
                            });
                            amClusterResource2.SetPrivatePropertyList(amClusterPropListDisposable2);
                        }
                    }
                    AmClusterResourceHelper.SetPossibleOwnersForIpResource(logger, amClusterResource2);
                    list3.Add(amClusterResource2);
                }
                flag = true;
            }
            finally
            {
                if (!flag)
                {
                    SharedHelper.DisposeObjectList <AmClusterResource>(list2);
                }
                SharedHelper.DisposeObjectList <AmClusterResource>(array);
                SharedHelper.DisposeObjectList <AmClusterResource>(list);
                if (dictionary2 != null)
                {
                    SharedHelper.DisposeObjectList <AmClusterNetwork>(dictionary2.Values);
                }
            }
            return(list3);
        }