/// <summary>
/// Creates availability group using Smo
/// </summary>
/// <param name="agName">Availability group name.</param>
/// <param name="dbNames">Datbases to be part of the AG.</param>
/// <param name="replicas">replicas to be part of the AG.</param>
/// <param name="server">smo server.</param>
public static AvailabilityGroup CreateAG(string agName, IEnumerable <string> dbNames, IEnumerable <Smo.Server> replicas, Smo.Server server)
{
if (!AGHelper.IsAGExist(agName, server))
{
AvailabilityGroup ag = new AvailabilityGroup(server, agName);
foreach (string dbName in dbNames)
{
ag.AvailabilityDatabases.Add(new AvailabilityDatabase(ag, dbName));
}
foreach (Smo.Server replica in replicas)
{
AvailabilityReplica ar = new AvailabilityReplica(ag, replica.Name);
ar.EndpointUrl = ARHelper.GetHadrEndpointUrl(replica);
ar.AvailabilityMode = AvailabilityReplicaAvailabilityMode.AsynchronousCommit;
ar.FailoverMode = AvailabilityReplicaFailoverMode.Manual;
ag.AvailabilityReplicas.Add(ar);
}
ag.Create();
return(ag);
}
else
{
throw new Exception(string.Format("The requested availability Group {0} already exist in the given server {1}", agName, server.Name));
}
}
/// <summary>
/// Removes a database from an Availability Group.
/// </summary>
/// <param name="agName">Availability Group name</param>
/// <param name="databaseNames">Database names to be removed from AG</param>
/// <param name="server">smo server</param>
public static void RemoveDatabasesFromAG(string agName, IEnumerable <string> databaseNames, Smo.Server server)
{
foreach (string databaseName in databaseNames)
{
AGHelper.RemoveDatabaseFromAG(agName, databaseName, server);
}
}
// helper that runs query
public void ExecuteQuery(int cpuCount, int workloadCount)
{
bool hasTraffic = false;
try
{
if (workloadCount == 10)
{
StartPartialTraffic();
hasTraffic = true;
}
else if (workloadCount == 100)
{
StartFullTraffic();
hasTraffic = true;
}
}catch (Exception e)
{
Console.WriteLine("Exception catched during simulate traffic. Please check your traffic simulator client");
Console.WriteLine(e);
return;
}
int failoverCount = replicas.FindIndex(t => t.Name == primary.Name);
// find current primary's index from replica list
while (failoverCount < 21)
{
// pick new primary
int primaryIndex = (failoverCount + 1) % replicas.Count;
Smo.Server newPrimary = replicas[primaryIndex];
Console.WriteLine("Checking AG Synced");
while (!IsAGSynchronized())
{
Thread.Sleep(10);
}
DateTime beforeFailover = DateTime.Now;
string primaryName = primary.Name;
AGHelper.FailoverToServer(newPrimary, agName, AGHelper.ActionType.ManualFailover);
primary = newPrimary;
Console.WriteLine("AG: {0} failover to {1}. ", agName, primary.Name);
while (!IsAGSynchronized())
{
Thread.Sleep(10);
}
DateTime afterFailover = DateTime.Now;
TimeSpan failoverInterval = afterFailover - beforeFailover;
Console.WriteLine("Failover takes {0}", failoverInterval.TotalSeconds);
InsertFailoverReport(beforeFailover, afterFailover, dbCount, cpuCount, workloadCount, primaryName);
failoverCount += 1;
Thread.Sleep(new TimeSpan(0, 2, 0));
}
Console.WriteLine("Thread Stop");
if (hasTraffic)
{
DrainTraffic();
}
}
/// <summary>
/// Drop the given ag using Smo.
/// </summary>
/// <param name="agName">Availability group name.</param>
/// <param name="server">smo server.</param>
public static void DropAG(string agName, Smo.Server server)
{
if (AGHelper.IsAGExist(agName, server))
{
AvailabilityGroup ag = server.AvailabilityGroups[agName];
ag.Drop();
}
}
/// <summary>
/// Drop availability replica from an availability group.
/// NoOp, if availability group isn't exist or replica isn't part of the given AG.
/// </summary>
/// <param name="arName">Availability replica name</param>
/// <param name="agName">Availability groups name</param>
/// <param name="server">SMO server</param>
public static void DropAR(string arName, string agName, SMO.Server server)
{
if (AGHelper.IsAGExist(agName, server) && AGHelper.AGContainsReplicas(agName, new string[] { arName }, server))
{
AvailabilityGroup ag = server.AvailabilityGroups[agName];
ag.AvailabilityReplicas.Remove(arName);
}
}
public void CleanUp()
{
if (AGHelper.IsAGExist(agName, primary))
{
AGHelper.DropAG(agName, primary);
}
CleanupDatabases();
StopBackup();
}
/// <summary>
/// Checks whether the give availability groups is enabled or not.
/// </summary>
/// <param name="agName">Availability group name.</param>
/// <param name="server">smo server.</param>
/// <returns>true if the given ag is enabled, otherwise false.</returns>
public static bool IsAGEnabled(string agName, Smo.Server server)
{
if (!AGHelper.IsAGExist(agName, server))
{
AvailabilityGroup ag = server.AvailabilityGroups[agName];
//TODO: AvailabilityGroup doesn't have method to enable it
throw new NotImplementedException();
}
else
{
throw new Exception(string.Format("The requested availability Group {0} is not exist in the given server {1}", agName, server.Name));
}
}
// When we called this primary and secondary should being create
public void TestCreateAGWithTwoReplicasWithoutDatabase()
{
Smo.Server primary = replicas[0];
AvailabilityGroup ag = new AvailabilityGroup(primary, agName);
List <Smo.Server> secondaries = replicas.GetRange(1, replicas.Count - 1);
for (int i = 0; i < replicas.Count; ++i)
{
AvailabilityReplica ar = ARHelper.BuildAR(ag, replicas[i].Name, replicaEndpointUrls[i]);
ag.AvailabilityReplicas.Add(ar);
}
try
{
Console.WriteLine("Creating availability group '{0}' on server '{1}",
ag.Name, primary.Name);
ag.Create();
Thread.Sleep(1000); //Sleep a tick to let AG create take effect
foreach (Smo.Server srv in secondaries)
{
srv.JoinAvailabilityGroup(agName);
}
CreateAGListener();
// enable autoseeding in secondary
//secondary.GrantAvailabilityGroupCreateDatabasePrivilege(agName);
}
catch (Exception e)
{
Console.WriteLine(e.Message);
Console.WriteLine("Failed to create AG {0}", ag.Name);
AGHelper.DropAG(ag.Name, primary);
}
}
/// <summary>
/// Drop the given ag using Smo and wait until, the ag is dropped in all servers.
/// </summary>
/// <param name="agName">Availability group name.</param>
/// <param name="targetServer">Server on which the AG needs to be dropped</param>
/// <param name="otherServer">Check whether the AG is dropped on this server</param>
public static void DropAGAndWaitForDrop(string agName, Smo.Server targetServer, Smo.Server otherServer)
{
AGHelper.DropAG(agName, targetServer);
}
/// <summary>
/// Avaiability group is online if property PrimaryReplicaServerName returns valid value.
/// </summary>
/// <param name="agName">Availability Group Name</param>
/// <param name="server">Target server name. This server must be the primary replica, else ths method will always return false.</param>
/// <returns></returns>
public static bool IsAgOnline(string agName, Smo.Server server)
{
return(!string.IsNullOrEmpty(AGHelper.GetAG(agName, server).PrimaryReplicaServerName));
}
public void Setup()
{
agName = "HadrBenchTest";
baseDBpath = @"\\zechen-d1\dbshare\";
dbshare = @"\\zechen-d1\dbshare\bench\";
//primaryServerName = @"ze-2016-v1\sql16rtm01";
//secondaryServerName = @"ze-2016-v2\sql16rtm01";
// start point of dbCount, lets say 500
primaryDbsNames = new List <string>();
primaryDbs = new List <Database>();
dbCacheLock = new ReaderWriterLockSlim();
dbCount = 0;
// create three replicas
replicas = new List <Server>();
secondaries = new List <Server>();
replicaEndpointUrls = new List <string>();
primaryServerName = string.Empty;
Smo.Server srv;
srv = new Smo.Server(@"ze-bench-01\hadrBenchMark01");
replicas.Add(srv);
// primary is important
primaryServerName = @"ze-bench-01\hadrBenchMark01";
primary = srv;
//report server always point to 01
reportSrv = srv;
reportServerName = primaryServerName;
reportDBName = @"FailoverResult";
string username = "******";
string password = "******";
reportConnecionString = string.Format("server={0}; Initial Catalog={1};uid={2}; pwd={3} ", primaryServerName, reportDBName, username, password);
srv = new Smo.Server(@"ze-bench-02\hadrBenchMark01");
replicas.Add(srv);
secondaries.Add(srv);
srv = new Smo.Server(@"ze-bench-03\hadrBenchMark01");
replicas.Add(srv);
secondaries.Add(srv);
string replicaEndpointUrl = string.Empty;
foreach (Smo.Server server in replicas)
{
replicaEndpointUrl = ARHelper.GetHadrEndpointUrl(server);
replicaEndpointUrls.Add(replicaEndpointUrl);
}
if (!AGHelper.IsAGExist(agName, primary))
{
TestCreateAGWithTwoReplicasWithoutDatabase();
}
this.notConnectedDBs = new List <string>();
stopBackup = false;
}
