/// <summary>
/// init objects for DomainStore
/// </summary>
static void InitDomainObjects()
{
#region domain objects
DsDomain primaryDomain = ldapAd.GetDomainInfo(
ADCommonServerAdapter.Instance(testSite).PDCNetbiosName + "." + ADCommonServerAdapter.Instance(testSite).PrimaryDomainDnsName + (testDS == true ? "" : ":" + testSite.Properties[Machine.WritableDC1.ToString() + ".LDSPort"]),
UserStore[User.ParentDomainAdmin]
);
DomainStore.Add(DomainEnum.PrimaryDomain, primaryDomain);
UserStore[User.ParentDomainAdmin].Domain = primaryDomain;
//Should initialize child domain and trust domain object here
if (testDS)
{
DsDomain InvalidDomain = new AddsDomain();
InvalidDomain.FsmoRoleOwners = new Dictionary <FSMORoles, string>();
InvalidDomain.DNSName = testSite.Properties[DomainEnum.InvalidDomain.ToString() + ".DS.DNSName"];
DomainStore.Add(DomainEnum.InvalidDomain, InvalidDomain);
}
else
{
DsDomain InvalidDomain = new AdldsDomain();
InvalidDomain.FsmoRoleOwners = new Dictionary <FSMORoles, string>();
InvalidDomain.DNSName = testSite.Properties[DomainEnum.InvalidDomain.ToString() + ".LDS.DNSName"];
DomainStore.Add(DomainEnum.InvalidDomain, InvalidDomain);
}
#endregion
}
/// <summary>
/// finish objects for UserStore
/// </summary>
static void InitUserObjects()
{
#region user objects
string[] enum_vals = Enum.GetNames(typeof(EnvironmentConfig.User));
foreach (string s in enum_vals)
{
User tmpU = (EnvironmentConfig.User)Enum.Parse(typeof(EnvironmentConfig.User), s);
if (tmpU == User.None)
{
continue;
}
DsUser user = new DsUser();
if (s.Contains("Admin"))
{
user.Username = ADCommonServerAdapter.Instance(testSite).DomainAdministratorName;
}
else
{
user.Username = DomainUserName;
}
user.Password = ADCommonServerAdapter.Instance(testSite).DomainUserPassword;
//force load domain dns name for loading domain info via ldap adapter
switch (tmpU)
{
case User.ExternalDomainAdmin:
user.Domain = new AddsDomain();
user.Domain.NetbiosName = testSite.Properties[DomainEnum.ExternalDomain.ToString() + ".NetbiosName"];
user.Domain.DNSName = testSite.Properties[DomainEnum.ExternalDomain.ToString() + ".DNSName"];
break;
case User.LDSDomainAdmin:
user.Domain = new AdldsDomain();
user.Domain.DNSName = testSite.Properties[DomainEnum.LDSDomain.ToString() + ".DNSName"];
break;
case User.MainDCAccount:
//machine account not initialized yet
continue;
case User.WritableDC2Account:
continue;
case User.RODCMachineAccount:
continue;
default:
user.Domain = new AddsDomain();
user.Domain.NetbiosName = testSite.Properties[DomainEnum.PrimaryDomain.ToString() + ".NetbiosName"];
user.Domain.DNSName = ADCommonServerAdapter.Instance(testSite).PrimaryDomainDnsName;
break;
}
UserStore.Add((EnvironmentConfig.User)Enum.Parse(typeof(EnvironmentConfig.User), s), user);
}
#endregion
}
public override void Do()
{
if (Site == null)
{
return;
}
if (!ADCommonServerAdapter.Instance(Site).AllowBreakEnvironment)
{
throw new ApplicationException("Case is not allowed to run because PTFConfig set \"AllowBreakEnvironment\" to false");
}
Site.Log.Add(LogEntryKind.Comment, "Test case will break environment, only can be recovered by reverting VM");
EnvironmentConfig.EnvBroken = true;
}
public void DRSR_DRSGetMemberships_Get_Group_Members_Transitive()
{
DrsrTestChecker.Check();
// Init the data.
EnvironmentConfig.Machine srv = EnvironmentConfig.Machine.WritableDC1;
DsServer server = (DsServer)EnvironmentConfig.MachineStore[srv];
DsUser user = EnvironmentConfig.UserStore[EnvironmentConfig.User.ParentDomainAdmin];
uint ret = 0;
ret = drsTestClient.DrsBind(
srv,
EnvironmentConfig.User.ParentDomainAdmin,
DRS_EXTENSIONS_IN_FLAGS.DRS_EXT_BASE
);
BaseTestSite.Assert.AreEqual <uint>(
0,
ret,
"IDL_DRSBind: should return 0 with a success bind to DC");
string groupDn = "CN=Domain Users,CN=Users," + DrsrHelper.GetDNFromFQDN(ADCommonServerAdapter.Instance(Site).PrimaryDomainDnsName);
DSNAME dsGroup = LdapUtility.CreateDSNameForObject(
server,
groupDn
);
ret = drsTestClient.DrsGetMemberships(
srv,
dwInVersion_Values.V1,
dsGroup,
false,
REVERSE_MEMBERSHIP_OPERATION_TYPE.GroupMembersTransitive,
null);
BaseTestSite.Assert.AreEqual <uint>(
0,
ret,
"IDL_DRSGetMemberships: return value should be 0");
// Unbind
ret = drsTestClient.DrsUnbind(srv);
BaseTestSite.Assert.AreEqual <uint>(
0,
ret,
"IDL_DRSUnbind: return value should be 0");
}
public void UpdateConfigStore(TestTools.ITestSite s)
{
string[] keys = s.Properties.AllKeys;
List <string> unusedKeys = new List <string>();
foreach (string str in keys)
{
if (!str.StartsWith("MS_FRS2."))
{
continue;
}
string ss = str.Replace("MS_FRS2.", "");
string refactorString = ss.Replace("-", "_");
refactorString = refactorString[0].ToString().ToUpper() + refactorString.Substring(1);
FieldInfo fi = typeof(ConfigStore).GetField(refactorString);
if (fi != null)
{
if (fi.FieldType == typeof(string))
{
fi.SetValue(null, s.Properties[str]);
}
else if (fi.FieldType == typeof(bool))
{
fi.SetValue(null, bool.Parse(s.Properties[str]));
}
else if (fi.FieldType == typeof(int))
{
fi.SetValue(null, int.Parse(s.Properties[str]));
}
else if (fi.FieldType == typeof(Guid))
{
fi.SetValue(null, new Guid(s.Properties[str]));
}
}
else if (ss.ToLower().StartsWith("reqimplemented."))
{
ConfigStore.WillingToCheckReq.Add(int.Parse(ss.ToLower().Replace("reqimplemented.", "")), bool.Parse(s.Properties[str]));
}
else if (ss.StartsWith("MAYRequirements."))
{
ConfigStore.WillingToCheckReq.Add(int.Parse(ss.Replace("MAYRequirements.", "")), bool.Parse(s.Properties[str]));
}
else
{
unusedKeys.Add(ss);
}
}
IFRS2ServerControllerAdapter serverControllerAdapter = s.GetAdapter <IFRS2ServerControllerAdapter>();
ConfigStore.IsTestSYSVOL = true;
if (ADCommonServerAdapter.Instance(s).PDCOSVersion >= ServerVersion.Win2012R2)
{
ConfigStore.OSVer = SUTOSVersion.Win2012R2;
}
else if (ADCommonServerAdapter.Instance(s).PDCOSVersion == ServerVersion.Win2012)
{
ConfigStore.OSVer = SUTOSVersion.Win2012;
}
else if (ADCommonServerAdapter.Instance(s).PDCOSVersion == ServerVersion.Win2008R2)
{
ConfigStore.OSVer = SUTOSVersion.Win2008R2;
}
ConfigStore.IsWindows = ADCommonServerAdapter.Instance(s).PDCIsWindows;
ConfigStore.Should = false;
ConfigStore.Win2k8 = false;
ConfigStore.Win2K8R2 = true;
ConfigStore.DomainDnsName = ADCommonServerAdapter.Instance(s).PrimaryDomainDnsName;
ConfigStore.DomainNetbiosName = ADCommonServerAdapter.Instance(s).PrimaryDomainNetBiosName;
// Check if SDC is set in ptfcofig file
if (string.IsNullOrWhiteSpace(ADCommonServerAdapter.Instance(s).SDCNetbiosName))
{
s.Assume.Fail("The test requires a Secondary writable DC in the environment. Please set the corresponding field in PTF config. ");
}
ConfigStore.RepPartnerNetbiosName = ADCommonServerAdapter.Instance(s).SDCNetbiosName;
ConfigStore.RepPartnerPassword = ADCommonServerAdapter.Instance(s).SDCPassword;
ConfigStore.SutIp = ADCommonServerAdapter.Instance(s).PDCIPAddress;
ConfigStore.SutLdapAddress = ConfigStore.SutIp + ":389";
ConfigStore.SutDnsName = ADCommonServerAdapter.Instance(s).PDCNetbiosName + "." + ConfigStore.DomainDnsName;
ConfigStore.AdminName = ADCommonServerAdapter.Instance(s).DomainAdministratorName;
ConfigStore.AdminPassword = ADCommonServerAdapter.Instance(s).DomainUserPassword;
ConfigStore.RepPartnerNTDSConnectionGUID = serverControllerAdapter.GetNtdsConnectionGuid(FRS2Helpers.ComputeNTDSConnectionPath(ConfigStore.DomainDnsName, ConfigStore.RepPartnerNetbiosName), FRS2Helpers.ComputeNTDSConnectionPath(ConfigStore.DomainDnsName, ADCommonServerAdapter.Instance(s).PDCNetbiosName));
s.Log.Add(LogEntryKind.Checkpoint, "Detected partner's NTDS Connection GUID is: " + ConfigStore.RepPartnerNTDSConnectionGUID);
ConfigStore.TransportProtocol = "ncacn_ip_tcp";
ConfigStore.FRS2RpcUuid = "5bc1ed07-f5f5-485f-9dfd-6fd0acf9a23c";
ConfigStore.SPNUuid = "e3514235-4b06-11d1-ab04-00c04fc2dcd2";
string domainDn = DrsrHelper.GetDNFromFQDN(ConfigStore.DomainDnsName);
ConfigStore.SutDN = "CN=" + ADCommonServerAdapter.Instance(s).PDCNetbiosName + ",OU=Domain Controllers," + domainDn;
ConfigStore.Ms_DFSRLocalSettings = "CN=DFSR-LocalSettings," + ConfigStore.SutDN;
ConfigStore.Ms_DFSRSubscriber = "CN=Domain System Volume," + ConfigStore.Ms_DFSRLocalSettings;
ConfigStore.Ms_DFSR_Subscription1 = (ConfigStore.Ms_DFSR_Subscription = "CN=SYSVOL Subscription," + ConfigStore.Ms_DFSRSubscriber);
ConfigStore.Ms_DFSR_GlobalSettings = "CN=DFSR-GlobalSettings,CN=System," + domainDn;
ConfigStore.Ms_DFSR_Content = (ConfigStore.MsDFSR_Content = "CN=Content,CN=Domain System Volume," + ConfigStore.Ms_DFSR_GlobalSettings);
ConfigStore.Ms_DFSR_Topology = "CN=Topology,CN=Domain System Volume," + ConfigStore.Ms_DFSR_GlobalSettings;
ConfigStore.Ms_DFSR_Member = "CN=" + ADCommonServerAdapter.Instance(s).PDCNetbiosName + "," + ConfigStore.Ms_DFSR_Topology;
ConfigStore.ReplicaId5 = (ConfigStore.ReplicaId4 = (ConfigStore.ReplicaId3 = (ConfigStore.ReplicaId2 = (ConfigStore.ReplicaId1 = "CN=Domain System Volume," + ConfigStore.Ms_DFSR_GlobalSettings))));
ConfigStore.ContentId6 = (ConfigStore.ContentId4 = (ConfigStore.ContentId3 = (ConfigStore.ContentId2 = (ConfigStore.ContentId1 = "CN=SYSVOL Share," + ConfigStore.Ms_DFSR_Content))));
ConfigStore.ContentId5 = "84a453ae-7902-4063-b9d7-8921aa793b11";
ConfigStore.ConnectionId1 = "f40bb5f0-aa59-4d01-b81c-735555955e3a";
ConfigStore.ConnectionId2 = "e4cc5b30-20f4-4de1-bcc9-b2b66551d7da";
ConfigStore.ConnectionId3 = "320a49a6-46b8-48b5-85e5-9ba7cbf47f57";
ConfigStore.ConnectionId4 = "cf3d2bd9-f3cc-4310-89b9-ae5f5bedbf4c";
ConfigStore.ConnectionId5 = "9f65fe10-bdb7-4d32-88ad-ec05fc86c016";
ConfigStore.InvalidGUID = "cf3d2bd9-f3cc-4310-89b9-ae5f5bedbfff";
ConfigStore.CreditsAvailable = "10";
ConfigStore.HashRequested = "0";
ConfigStore.Offset = "0";
ConfigStore.Length = "200";
ConfigStore.BufferSize = "262144";
ConfigStore.Reqnoblocked536 = "true";
ConfigStore.Reqnoblocked764 = "true";
ConfigStore.AuthenticationSVC = "16";
}
public static void Check()
{
StackTrace trace = new System.Diagnostics.StackTrace();
StackFrame[] frames = trace.GetFrames();
//find who is calling me
System.Reflection.MethodBase method = frames[1].GetMethod();
DrsrTestAttribute.Site = EnvironmentConfig.TestSite;
object[] attrs = method.GetCustomAttributes(false);
if (attrs == null)
{
return;
}
string level = null;
foreach (object o in attrs)
{
//for out test attribute, invoke "Do" method, for MSTEST attributes, do accordingly
Type thisType = o.GetType();
switch (thisType.Name)
{
case "DescriptionAttribute":
{
EnvironmentConfig.TestSite.Log.Add(LogEntryKind.Comment, "Test description: " + typeof(DescriptionAttribute).GetProperty("Description").GetValue(o, null).ToString());
}
break;
case "PriorityAttribute":
{
EnvironmentConfig.TestSite.Log.Add(LogEntryKind.Comment, "Implementation priority of this scenario is: " + typeof(PriorityAttribute).GetProperty("Priority").GetValue(o, null).ToString());
}
break;
case "TestCategoryAttribute":
{
TestCategoryAttribute tca = o as TestCategoryAttribute;
foreach (string s in tca.TestCategories)
{
if (s.StartsWith("Win"))
{
level = s;
continue;
}
// Check if SDC, RODC exist when TestCategory contain SDC, RODC
if (s.Equals("SDC"))
{
if (!EnvironmentConfig.MachineStore.ContainsKey(EnvironmentConfig.Machine.WritableDC2))
{
EnvironmentConfig.TestSite.Assume.Fail("The test requires a Secondary writable DC in the environment. Please set the corresponding field in PTF config, or make sure the machine can be connected.");
}
continue;
}
if (s.Equals("RODC"))
{
if (!EnvironmentConfig.MachineStore.ContainsKey(EnvironmentConfig.Machine.RODC))
{
EnvironmentConfig.TestSite.Assume.Fail("The test requires a Read-Only DC in the environment. Please set the corresponding field in PTF config, or make sure the machine can be connected.");
}
continue;
}
}
}
break;
default:
if (thisType.BaseType == typeof(DrsrTestAttribute))
{
try
{
thisType.GetMethod("Do").Invoke(o, null);
}
catch (Exception e)
{
DrsrTestAttribute.Site.Assert.Fail(e.InnerException.Message);
}
}
break;
}
}
if (level == null)
{
throw new Exception("Test Case not set in any domain functional level category");
}
FunctionLevelAttribute fl = null;
switch (level)
{
case "Win2000":
fl = new FunctionLevelAttribute(DrsrDomainFunctionLevel.DS_BEHAVIOR_WIN2000);
break;
case "Win2003":
fl = new FunctionLevelAttribute(DrsrDomainFunctionLevel.DS_BEHAVIOR_WIN2003);
break;
case "Win2008":
fl = new FunctionLevelAttribute(DrsrDomainFunctionLevel.DS_BEHAVIOR_WIN2008);
break;
case "Win2008R2":
fl = new FunctionLevelAttribute(DrsrDomainFunctionLevel.DS_BEHAVIOR_WIN2008R2);
break;
case "Win2012":
fl = new FunctionLevelAttribute(DrsrDomainFunctionLevel.DS_BEHAVIOR_WIN2012);
break;
case "Win2012R2":
fl = new FunctionLevelAttribute(DrsrDomainFunctionLevel.DS_BEHAVIOR_WIN2012R2);
break;
case "WinThreshold":
fl = new FunctionLevelAttribute(DrsrDomainFunctionLevel.DS_BEHAVIOR_WINTHRESHOLD);
break;
case "Winv1803":
ADCommonServerAdapter adapter = new ADCommonServerAdapter();
adapter.Initialize(DrsrTestAttribute.Site);
ServerVersion curVersion = adapter.PDCOSVersion;
if (curVersion < ServerVersion.Winv1803)
{
DrsrTestAttribute.Site.Assert.Inconclusive("Test case expects PDCOSVersion {0} should be Equal or Greater than Winv1803", curVersion);
}
fl = new FunctionLevelAttribute(DrsrDomainFunctionLevel.DS_BEHAVIOR_WINTHRESHOLD);
break;
default:
throw new Exception("Unknown domain functional level category: " + level);
}
fl.Do();
}
/// <summary>
/// init objects for MachineStore
/// </summary>
static void InitMachineObjects()
{
#region machine objects
string[] enum_vals = Enum.GetNames(typeof(EnvironmentConfig.Machine));
//first loop only initialize physical machines
foreach (string s in enum_vals)
{
DsMachine machine = null;
EnvironmentConfig.Machine val = (EnvironmentConfig.Machine)Enum.Parse(typeof(EnvironmentConfig.Machine), s);
switch (val)
{
case Machine.None:
continue;
case Machine.Endpoint:
//initialize client
machine = new ClientMachine();
machine.Domain = DomainStore[DomainEnum.PrimaryDomain];
machine.NetbiosName = ADCommonServerAdapter.Instance(testSite).ENDPOINTNetbiosName;
machine.DnsHostName = machine.NetbiosName + "." + machine.Domain.DNSName;
break;
case Machine.MainDC:
if (MachineStore.ContainsKey(Machine.WritableDC1))
{
machine = MachineStore[Machine.WritableDC1];
}
else
{
machine = ldapAd.GetDCInfo(ADCommonServerAdapter.Instance(testSite).PDCNetbiosName + "." + ADCommonServerAdapter.Instance(testSite).PrimaryDomainDnsName, UserStore[User.ParentDomainAdmin]);
if (testDS)
{
//do this in AD LDS will assign an AD LDS domain
machine.Domain = DomainStore[DomainEnum.PrimaryDomain];
}
}
break;
case Machine.RODC:
if (string.IsNullOrWhiteSpace(ADCommonServerAdapter.Instance(testSite).RODCNetbiosName))
{
continue;
}
try
{
machine = ldapAd.GetDCInfo(ADCommonServerAdapter.Instance(testSite).RODCNetbiosName + "." + ADCommonServerAdapter.Instance(testSite).PrimaryDomainDnsName, UserStore[User.ParentDomainAdmin]);
if (testDS)
{
//do this in AD LDS will assign an AD LDS domain
machine.Domain = DomainStore[DomainEnum.PrimaryDomain];
}
((AddsServer)machine).IsRODC = true;
}
catch (System.DirectoryServices.Protocols.LdapException)
{
continue;
}
break;
case Machine.WritableDC1:
if (MachineStore.ContainsKey(Machine.MainDC))
{
machine = MachineStore[Machine.MainDC];
}
else
{
machine = ldapAd.GetDCInfo(ADCommonServerAdapter.Instance(testSite).PDCNetbiosName + "." + ADCommonServerAdapter.Instance(testSite).PrimaryDomainDnsName, UserStore[User.ParentDomainAdmin]);
if (testDS)
{
//do this in AD LDS will assign an AD LDS domain
machine.Domain = DomainStore[DomainEnum.PrimaryDomain];
}
}
break;
case Machine.WritableDC2:
if (string.IsNullOrWhiteSpace(ADCommonServerAdapter.Instance(testSite).SDCNetbiosName))
{
continue;
}
try
{
machine = ldapAd.GetDCInfo(ADCommonServerAdapter.Instance(testSite).SDCNetbiosName + "." + ADCommonServerAdapter.Instance(testSite).PrimaryDomainDnsName, UserStore[User.ParentDomainAdmin]);
if (testDS)
{
//do this in AD LDS will assign an AD LDS domain
machine.Domain = DomainStore[DomainEnum.PrimaryDomain];
}
}
catch (System.DirectoryServices.Protocols.LdapException)
{
continue;
}
break;
default:
//by default, it should be a DC
if (testDS)
{
if (string.IsNullOrEmpty(testSite.Properties[s + ".NetbiosName"]))
{
continue;
}
machine = ldapAd.GetDCInfo(testSite.Properties[s + ".NetbiosName"] + "." + GetDomainFromMachineType(val).DNSName, GetDomainFromMachineType(val).Admin);
}
else
{
if (string.IsNullOrEmpty(testSite.Properties[s + ".LDSPort"]))
{
continue;
}
machine = ldapAd.GetDCInfo(
ADCommonServerAdapter.Instance(testSite).PDCNetbiosName
+ "."
+ ADCommonServerAdapter.Instance(testSite).PrimaryDomainDnsName
+ ":"
+ testSite.Properties[s + ".LDSPort"],
UserStore[User.ParentDomainAdmin]);
((AdldsServer)machine).DsaNetworkAddress =
ADCommonServerAdapter.Instance(testSite).PDCNetbiosName
+ "."
+ ADCommonServerAdapter.Instance(testSite).PrimaryDomainDnsName
+ ":"
+ ((AdldsServer)machine).DsaNetworkAddress;
}
((DsServer)machine).IsWindows = bool.Parse(testSite.Properties[s + ".IsWindows"]);
if (machine != null)
{
switch (val)
{
case Machine.CDC:
machine.Domain = DomainStore[DomainEnum.ChildDomain];
break;
case Machine.ExternalDC:
machine.Domain = DomainStore[DomainEnum.ExternalDomain];
break;
default:
machine.Domain = DomainStore[DomainEnum.PrimaryDomain];
break;
}
}
break;
}
if (machine != null)
{
MachineStore.Add(val, machine);
if (val != Machine.MainDC)
{
PhysicalMachineStore.Add(val, machine);
}
}
}
//second loop initialize roles
foreach (string s in enum_vals)
{
EnvironmentConfig.Machine val = (EnvironmentConfig.Machine)Enum.Parse(typeof(EnvironmentConfig.Machine), s);
switch (val)
{
case Machine.DC_With_DomainNamingMasterRole:
break;
case Machine.DC_With_RidAllocationMasterRole:
break;
case Machine.GCServer:
break;
case Machine.PDC:
break;
default:
continue;
}
MachineStore.Add(val, MachineStore[Machine.WritableDC1]);
}
#endregion
}
/// <summary>
/// load all infos
/// </summary>
/// <param name="site">PTD test site</param>
public static void Initialize(ITestSite site)
{
if (site == null)
{
throw new ApplicationException("TestSite could not be NULL.");
}
//only initialize once
if (dataLoaded)
{
if (!init_succeed)
{
site.Assert.Fail("EnvironmentConfig init failed in previous cases");
}
return;
}
//try
//{
testSite = site;
ldapAd = site.GetAdapter <ILdapAdapter>();
ldapAd.Site = site;
testDS = bool.Parse(site.Properties["MS_DRSR.TestDS"]);
funcLv = (Microsoft.Protocols.TestTools.StackSdk.ActiveDirectory.Drsr.DrsrDomainFunctionLevel)(ADCommonServerAdapter.Instance(testSite).DomainFunctionLevel);
UseKerberos = bool.Parse(site.Properties["MS_DRSR.UseKerberos"]);
UseNativeRpcLib = bool.Parse(site.Properties["MS_DRSR.UseNativeRpcLib"]);
//create normal user account if it does not exist yet
string serverName = ADCommonServerAdapter.Instance(testSite).PDCNetbiosName;
string serverPort = ADCommonServerAdapter.Instance(testSite).ADDSPortNum;
string domainNC = "DC=" + ADCommonServerAdapter.Instance(testSite).PrimaryDomainDnsName.Replace(".", ",DC=");
string parentDN = string.Format("CN=Users,{0}", domainNC);
string userDN = string.Format("CN={0},CN=Users,{1}", DomainUserName, domainNC);
string userPassword = ADCommonServerAdapter.Instance(testSite).DomainUserPassword;
if (!Utilities.IsObjectExist(userDN, serverName, serverPort))
{
Utilities.NewUser(serverName, serverPort, parentDN, DomainUserName, userPassword);
}
//please do all object intialization in this call following example
InitUserObjects();
InitDomainObjects();
InitMachineObjects();
FinishUserObjects();
//load DS AppNC late due to rootDSE search issue
if (testDS && !string.IsNullOrEmpty(AppNCDistinguishedName))
{
((AddsDomain)DomainStore[DomainEnum.PrimaryDomain]).OtherNCs = new DSNAME[1];
((AddsDomain)DomainStore[DomainEnum.PrimaryDomain]).OtherNCs[0] = ldapAd.GetDsName((DsServer)MachineStore[Machine.WritableDC1], AppNCDistinguishedName).Value;
}
MainDC = (AddsServer)EnvironmentConfig.MachineStore[Machine.MainDC];
DsServer s1 = (DsServer)EnvironmentConfig.MachineStore[Machine.WritableDC1];
transport_obj = ldapAd.GetDsName(
s1,
"cn=ip,cn=inter-site transports,cn=sites,"
+ LdapUtility.ConvertUshortArrayToString(s1.Domain.ConfigNC.StringName)
).Value;
DsUser dcAccount = new DsUser();
dcAccount.Domain = s1.Domain;
dcAccount.Username = s1.NetbiosName + "$";
dcAccount.Password = ADCommonServerAdapter.Instance(testSite).PDCPassword;
UserStore.Add(User.MainDCAccount, dcAccount);
//not always need dc2
if (EnvironmentConfig.MachineStore.ContainsKey(Machine.WritableDC2))
{
DsServer s2 = (DsServer)EnvironmentConfig.MachineStore[Machine.WritableDC2];
DsUser dcAccount2 = new DsUser();
dcAccount2.Domain = s2.Domain;
dcAccount2.Username = s2.NetbiosName + "$";
dcAccount2.Password = ADCommonServerAdapter.Instance(testSite).SDCPassword;
UserStore.Add(User.WritableDC2Account, dcAccount2);
}
if (EnvironmentConfig.MachineStore.ContainsKey(Machine.RODC))
{
DsServer rodc = (DsServer)EnvironmentConfig.MachineStore[Machine.RODC];
DsUser rodcAccount = new DsUser();
rodcAccount.Domain = rodc.Domain;
rodcAccount.Username = rodc.NetbiosName + "$";
rodcAccount.Password = ADCommonServerAdapter.Instance(testSite).RODCPassword;
UserStore.Add(User.RODCMachineAccount, rodcAccount);
}
//}
//catch (Exception e)
//{
// init_succeed = false;
// site.Assert.Fail("data initialization failed due to exception:" + e.InnerException == null ? e.Message : e.InnerException.Message);
//}
//alwasy only init once
dataLoaded = true;
}