/// <summary>
/// On refresh event handler
/// </summary>
/// <param name="status">Status</param>
protected override void OnRefresh(AsyncStatus status)
{
try
{
base.OnRefresh(status);
RefreshTopology(_dto);
RefreshNodeTree();
}
catch (AggregateException exc)
{
if (exc.InnerExceptions.Count > 0)
{
var msg = exc.InnerExceptions.Select(x => x.Message).Aggregate((x, y) => x + " , " + y);
var message = string.Format(Constants.VMDirConnectFailure, msg);
MMCDlgHelper.ShowMessage(message);
}
var custom = new CustomExceptionExtractor().GetCustomMessage(exc);
PscHighAvailabilityAppEnvironment.Instance.Logger.LogException(exc, custom);
}
catch (Exception exc)
{
var custom = new CustomExceptionExtractor().GetCustomMessage(exc);
PscHighAvailabilityAppEnvironment.Instance.Logger.LogException(exc, custom);
MMCDlgHelper.ShowException(exc);
}
}
private void GetDomainFunctionalLevel()
{
try
{
var domainFucntionalLevel = string.Empty;
var serverNode = _formView.ScopeNode as ServerNode;
if (serverNode != null)
{
var dto = serverNode.Hosts.FirstOrDefault(x => x.NodeType == NodeType.Infrastructure && x.Active);
if (dto != null)
{
if (serverNode.ServerDto != null)
{
var serverDto = new ServerDto {
Server = dto.Name, Upn = serverNode.ServerDto.Upn, Password = serverNode.ServerDto.Password, DomainName = serverNode.ServerDto.DomainName
};
domainFucntionalLevel = PscHighAvailabilityAppEnvironment.Instance.Service.GetDomainFunctionalLevel(serverDto);
}
}
}
txtDomainFunctionalLevel.Text = domainFucntionalLevel;
}
catch (Exception exc)
{
var custom = new CustomExceptionExtractor().GetCustomMessage(exc);
PscHighAvailabilityAppEnvironment.Instance.Logger.LogException(exc, custom);
MiscUtilsService.ShowError(exc);
}
}
/// <summary>
/// Sets the management node to legacy mode
/// </summary>
/// <param name="legacy">True if legacy mode needs to be set false otherwise</param>
/// <param name="serverDto">Management node details</param>
public void SetLegacyMode(bool legacy, ServerDto serverDto)
{
try
{
using (Client client = new Client(serverDto.Server, serverDto.Upn, serverDto.Password))
{
if (legacy)
{
var message = string.Format("CdcDisableClientAffinity API call for Server: {0} ", serverDto.Server);
_logger.Log(message, LogLevel.Info);
client.CdcDisableClientAffinity();
message = string.Format("CdcDisableClientAffinity API call for Server: {0} complete", serverDto.Server);
_logger.Log(message, LogLevel.Info);
}
else
{
var message = string.Format("CdcEnableClientAffinity API call for Server: {0} ", serverDto.Server);
_logger.Log(message, LogLevel.Info);
client.CdcEnableClientAffinity();
message = string.Format("CdcEnableClientAffinity API call for Server: {0} complete", serverDto.Server);
_logger.Log(message, LogLevel.Info);
}
}
}
catch (Exception exc)
{
var custom = new CustomExceptionExtractor().GetCustomMessage(exc);
_logger.LogException(exc, custom);
throw;
}
}
/// <summary>
/// Gets the domain functional level for the server
/// </summary>
/// <param name="serverDto">Server details</param>
/// <returns>Domain functional level</returns>
public string GetDomainFunctionalLevel(ServerDto serverDto)
{
var dfl = string.Empty;
try
{
var message = string.Format("Method: GetDomainFunctionalLevel - LdapSearchHelper.Search API call for Server: {0} complete", serverDto.Server);
_logger.Log(message, LogLevel.Info);
var helper = new LdapSearchHelper(serverDto.Server, serverDto.Upn, serverDto.Password);
var searchDN = "DC=" + serverDto.DomainName.Replace(".", ", DC=");
Action <ILdapMessage, List <ILdapEntry> > action = delegate(ILdapMessage searchRequest, List <ILdapEntry> values)
{
dfl = GetDomainFunctionalLevel(searchRequest, values);
};
helper.Search(searchDN, LdapScope.SCOPE_BASE, "(objectClass=*)", new[] { "+" }, true, action);
message = string.Format("Method: GetDomainFunctionalLevel - CdcGetDCStatus API call for Server: {0} complete", serverDto.Server);
_logger.Log(message, LogLevel.Info);
}
catch (Exception exc)
{
var custom = new CustomExceptionExtractor().GetCustomMessage(exc);
_logger.LogException(exc, custom);
}
return(dfl);
}
/// <summary>
/// Login into an already added server
/// </summary>
/// <param name="node">Server node</param>
/// <returns>True on success false otherwise</returns>
public bool Login(ServerNode node)
{
try
{
_loginUI = new Login(node.ServerDto);
if (this.SnapIn.Console.ShowDialog(_loginUI) == DialogResult.OK)
{
node.ServerDto = _loginUI.Server;
node.AddLogoutActions();
_loginUI.Close();
node.Load(_loginUI.ManagementDto);
return(true);
}
}
catch (AggregateException exc)
{
if (exc.InnerExceptions.Count > 0)
{
var msg = exc.InnerExceptions.Select(x => x.Message).Aggregate((x, y) => x + " , " + y);
MMCDlgHelper.ShowMessage(msg);
}
var custom = new CustomExceptionExtractor().GetCustomMessage(exc);
PscHighAvailabilityAppEnvironment.Instance.Logger.LogException(exc, custom);
}
catch (Exception exp)
{
var custom = new CustomExceptionExtractor().GetCustomMessage(exp);
PscHighAvailabilityAppEnvironment.Instance.Logger.LogException(exp, custom);
node.AddLoginActions();
MMCDlgHelper.ShowException(exp);
}
return(false);
}
private async Task OnOkClick()
{
try
{
btnOK.Enabled = false;
if (IsValid())
{
if (Server == null)
{
Server = new ServerDto();
}
Server.Server = txtDirectoryServer.Text;
Server.Upn = txtBindUPN.Text;
Server.Password = txtPassword.Text;
var parts = Server.Upn.Split('@');
Server.UserName = parts[0];
Server.DomainName = parts[1];
var task = new Task(Connect);
task.Start();
if (task == await Task.WhenAny(task, Task.Delay(Constants.TopologyTimeout * Constants.MilliSecsMultiplier)))
{
await task;
}
if (ManagementDto != null)
{
this.DialogResult = DialogResult.OK;
}
else
{
MiscUtilsService.ShowError(Constants.LoginError, "Error", MessageBoxButtons.OK);
btnOK.Enabled = true;
}
}
else
{
btnOK.Enabled = true;
}
}
catch (AggregateException exc)
{
var custom = new CustomExceptionExtractor().GetCustomMessage(exc);
PscHighAvailabilityAppEnvironment.Instance.Logger.LogException(exc, custom);
if (exc.InnerExceptions.Count > 0)
{
var msg = exc.InnerExceptions.Select(x => x.Message).Aggregate((x, y) => x + " , " + y);
MMCDlgHelper.ShowError(msg);
}
}
catch (Exception exp)
{
var custom = new CustomExceptionExtractor().GetCustomMessage(exp);
PscHighAvailabilityAppEnvironment.Instance.Logger.LogException(exp, custom);
MiscUtilsService.ShowError(exp);
}
}
/// <summary>
/// Checked exception handling
/// </summary>
/// <param name="fn">Action</param>
public static void CheckedExec(System.Action fn)
{
try
{
fn();
}
catch (Exception exp)
{
var custom = new CustomExceptionExtractor().GetCustomMessage(exp);
PscHighAvailabilityAppEnvironment.Instance.Logger.LogException(exp, custom);
ShowError(exp);
}
}
private void btnRefresh_Click(object sender, EventArgs e)
{
try
{
RefreshView();
}
catch (Exception exc)
{
var custom = new CustomExceptionExtractor().GetCustomMessage(exc);
PscHighAvailabilityAppEnvironment.Instance.Logger.LogException(exc, custom);
MiscUtilsService.ShowError(exc);
}
}
public void RefreshDataSource()
{
try
{
RefreshView();
}
catch (Exception exc)
{
var custom = new CustomExceptionExtractor().GetCustomMessage(exc);
PscHighAvailabilityAppEnvironment.Instance.Logger.LogException(exc, custom);
MiscUtilsService.ShowError(exc);
}
}
/// <summary>
/// On delete event handler
/// </summary>
/// <param name="status">Status</param>
protected override void OnDelete(SyncStatus status)
{
try
{
base.OnDelete(status);
StopBackgroundRefresh();
RemoveServer();
}
catch (Exception exc)
{
var custom = new CustomExceptionExtractor().GetCustomMessage(exc);
PscHighAvailabilityAppEnvironment.Instance.Logger.LogException(exc, custom);
MMCDlgHelper.ShowException(exc);
}
}
void timer_Tick(object sender, EventArgs e)
{
try
{
RefreshView();
}
catch (Exception exc)
{
var custom = new CustomExceptionExtractor().GetCustomMessage(exc);
PscHighAvailabilityAppEnvironment.Instance.Logger.LogException(exc, custom);
MiscUtilsService.ShowError(exc);
_timer.Enabled = false;
chkAutoRefresh.Checked = false;
}
}
void _timer_Tick(object sender, System.EventArgs e)
{
if (Hosts != null && Hosts.Count > 0)
{
var infras = Hosts.Where(x => x.NodeType == VMPSCHighAvailability.Common.NodeType.Infrastructure).ToList();
if (infras != null)
{
foreach (var host in infras)
{
Task.Run(() =>
{
try
{
UpdateInfraNode(host, ServerDto);
}
catch (Exception exc)
{
var custom = new CustomExceptionExtractor().GetCustomMessage(exc);
PscHighAvailabilityAppEnvironment.Instance.Logger.LogException(exc, custom);
}
}
);
}
}
var mgmts = Hosts.Where(x => x.NodeType == VMPSCHighAvailability.Common.NodeType.Management);
if (mgmts != null)
{
foreach (var host in mgmts)
{
Task.Run(() =>
{
try
{
UpdateManagementNode(host, ServerDto);
}
catch (Exception exc)
{
var custom = new CustomExceptionExtractor().GetCustomMessage(exc);
PscHighAvailabilityAppEnvironment.Instance.Logger.LogException(exc, custom);
}
}
);
}
}
}
}
/// <summary>
/// Checks connectivity of the server
/// </summary>
/// <param name="serverDto">Server with credentials i.e. UPN and password</param>
/// <returns>True on success false otherwise</returns>
public ManagementDto Connect(ServerDto serverDto)
{
var dto = new ManagementDto {
Name = serverDto.Server
};
try
{
var message = string.Format("Method: Connect - new Client API call for Server: {0}", serverDto.Server);
_logger.Log(message, LogLevel.Info);
using (Client client = new Client(serverDto.Server, serverDto.Upn, serverDto.Password))
{
message = string.Format("Method: Connect - new Client API call for Server: {0} complete", serverDto.Server);
_logger.Log(message, LogLevel.Info);
message = string.Format("Method: Connect - VmAfdGetSiteName API call for Server: {0}", serverDto.Server);
_logger.Log(message, LogLevel.Info);
dto.Sitename = client.VmAfdGetSiteName();
message = string.Format("Method: Connect - VmAfdGetSiteName API call for Server: {0} Sitename: {1}", serverDto.Server, dto.Sitename);
_logger.Log(message, LogLevel.Info);
message = string.Format("Method: Connect - CdcGetDCName API call for Server: {0}", serverDto.Server);
_logger.Log(message, LogLevel.Info);
var domainController = client.CdcGetDCName(serverDto.DomainName, dto.Sitename, 0);
message = string.Format("Method: Connect - CdcGetDCName API call for Server: {0} complete", serverDto.Server);
_logger.Log(message, LogLevel.Info);
dto.DomainController = new InfrastructureDto
{
Name = domainController.pszDCName
};
}
}
catch (Exception exc)
{
var custom = new CustomExceptionExtractor().GetCustomMessage(exc);
_logger.LogException(exc, custom);
dto = null;
}
return(dto);
}
/// <summary>
/// Gets the infrastructure nodes.
/// </summary>
/// <returns>The infrastructure nodes.</returns>
/// <param name="serverDto">Server dto.</param>
/// <param name="dcName">Dc name.</param>
private List <NodeDto> GetInfrastructureNodes(ServerDto serverDto, string dcName)
{
var message = "GetInfrastructureNodes method for Server: " + serverDto.Server;
_logger.Log(message, LogLevel.Info);
var nodes = new List <NodeDto>();
// Get Infrastructure nodes
try
{
message = "VmDirGetDCInfos API call for Server: " + serverDto.Server;
_logger.Log(message, LogLevel.Info);
var entries = vmdirClient.Client.VmDirGetDCInfos(dcName, serverDto.UserName, serverDto.Password);
message = string.Format("VmDirGetDCInfos API Server: {0} complete. Entries retrieved: {1}", serverDto.Server, entries.Count.ToString());
_logger.Log(message, LogLevel.Info);
foreach (vmdirClient.VmDirDCInfo entry in entries)
{
var infraNode = new InfrastructureDto()
{
Name = entry.pszDCName,
Sitename = entry.pszSiteName,
Partners = entry.partners,
NodeType = NodeType.Infrastructure,
Ip = Network.GetIpAddress(entry.pszDCName)
};
nodes.Add(infraNode);
}
}
catch (Exception exc)
{
message = "VmDirGetDCInfos API returned error for Server: " + serverDto.Server;
_logger.Log(message, LogLevel.Error);
var custom = new CustomExceptionExtractor().GetCustomMessage(exc);
_logger.LogException(exc, custom);
}
return(nodes);
}
private void ChangeMode()
{
try
{
var node = _formView.ScopeNode as ManagementNode;
var serverDto = new ServerDto {
Server = node.DisplayName, Upn = node.ServerDto.Upn, Password = node.ServerDto.Password
};
PscHighAvailabilityAppEnvironment.Instance.Service.SetLegacyMode(!legacyMode, serverDto);
_dto.Legacy = !legacyMode;
btnHA.Text = _dto.Legacy ? Constants.EnableDefaultHA : Constants.EnableLegacy;
legacyMode = _dto.Legacy;
var state = _dto.Legacy ? CDC_DC_STATE.CDC_DC_STATE_LEGACY : CDC_DC_STATE.CDC_DC_STATE_NO_DC_LIST;
_dto.State = CdcDcStateHelper.GetStateDescription(state);
}
catch (Exception exc)
{
var custom = new CustomExceptionExtractor().GetCustomMessage(exc);
PscHighAvailabilityAppEnvironment.Instance.Logger.LogException(exc, custom);
MiscUtilsService.ShowError(exc);
}
UpdateState();
}
/// <summary>
/// Action event handler
/// </summary>
/// <param name="action">Action</param>
/// <param name="status">Status</param>
protected override void OnAction(Microsoft.ManagementConsole.Action action, AsyncStatus status)
{
try
{
base.OnAction(action, status);
switch ((ServerNodeAction)(int)action.Tag)
{
case ServerNodeAction.Login:
Login();
break;
case ServerNodeAction.Logout:
Logout();
break;
}
}
catch (Exception exc)
{
var custom = new CustomExceptionExtractor().GetCustomMessage(exc);
PscHighAvailabilityAppEnvironment.Instance.Logger.LogException(exc, custom);
MMCDlgHelper.ShowException(exc);
}
}
/// <summary>
/// Gets the management node details.
/// </summary>
/// <returns>The management node details.</returns>
/// <param name="serverDto">Server dto.</param>
public ManagementDto GetManagementNodeDetails(ServerDto serverDto)
{
var dto = new ManagementDto()
{
State = new StateDescriptionDto(), Name = serverDto.Server, Domain = serverDto.DomainName
};
using (Client client = new Client(serverDto.Server, serverDto.Upn, serverDto.Password))
{
var message = string.Format("Method: GetManagementNodeDetails - CdcGetCurrentState API call for Server: {0}", serverDto.Server);
_logger.Log(message, LogLevel.Info);
try
{
var state = client.CdcGetCurrentState();
dto.Legacy = (state == CDC_DC_STATE.CDC_DC_STATE_LEGACY);
dto.State = CdcDcStateHelper.GetStateDescription(state);
message = string.Format("Method: GetManagementNodeDetails - CdcGetCurrentState API call for Server: {0} complete", serverDto.Server);
_logger.Log(message, LogLevel.Info);
}
catch (Exception exc)
{
message = string.Format("Method: GetManagementNodeDetails - CdcGetCurrentState API call for Server: {0} failed", serverDto.Server);
_logger.Log(message, LogLevel.Error);
var custom = new CustomExceptionExtractor().GetCustomMessage(exc);
_logger.LogException(exc, custom);
}
try
{
message = string.Format("Method: GetManagementNodeDetails - VmAfdGetSiteName API call for Server: {0}", serverDto.Server);
_logger.Log(message, LogLevel.Info);
dto.Sitename = client.VmAfdGetSiteName();
message = string.Format("Method: GetManagementNodeDetails - VmAfdGetSiteName API call for Server: {0} complete", serverDto.Server);
_logger.Log(message, LogLevel.Info);
}
catch (Exception exc)
{
message = string.Format("Method: GetManagementNodeDetails - VmAfdGetSiteName API call for Server: {0} failed", serverDto.Server);
_logger.Log(message, LogLevel.Error);
var custom = new CustomExceptionExtractor().GetCustomMessage(exc);
_logger.LogException(exc, custom);
}
dto.Active = true;
dto.Ip = Network.GetIpAddress(dto.Name);
message = string.Format("Method: GetManagementNodeDetails - CdcGetDCName API call for Server: {0}", serverDto.Server);
_logger.Log(message, LogLevel.Info);
try
{
var dcInfo = client.CdcGetDCName(serverDto.DomainName, dto.Sitename, 0);
message = string.Format("Method: GetManagementNodeDetails - CdcGetDCName API call for Server: {0} complete", serverDto.Server);
_logger.Log(message, LogLevel.Info);
dto.DomainController = new InfrastructureDto
{
Name = dcInfo.pszDCName,
NodeType = NodeType.Infrastructure,
Domain = dcInfo.pszDomainName,
Ip = Network.GetIpAddress(dcInfo.pszDCName)
};
}
catch (Exception exc)
{
message = string.Format("Method: GetManagementNodeDetails - CdcGetDCName API call for Server: {0} failed", serverDto.Server);
_logger.Log(message, LogLevel.Error);
var custom = new CustomExceptionExtractor().GetCustomMessage(exc);
_logger.LogException(exc, custom);
dto.DomainController = new InfrastructureDto
{
Name = string.Empty,
NodeType = NodeType.Infrastructure,
Domain = string.Empty
};
}
dto.DomainControllers = new List <InfrastructureDto>();
try
{
message = string.Format("Method: GetManagementNodeDetails - CdcEnumDCEntries API call for Server: {0}", serverDto.Server);
_logger.Log(message, LogLevel.Info);
IList <string> entries = client.CdcEnumDCEntries();
message = string.Format("Method: GetManagementNodeDetails - CdcEnumDCEntries API call for Server: {0} complete. DCs returned: {1}", serverDto.Server, entries.Count());
_logger.Log(message, LogLevel.Info);
foreach (var entry in entries)
{
CDC_DC_STATUS_INFO info;
VMAFD_HEARTBEAT_STATUS hbStatus;
try
{
message = string.Format("Method: GetManagementNodeDetails - CdcGetDCStatus API call for Server: {0}", serverDto.Server);
_logger.Log(message, LogLevel.Info);
client.CdcGetDCStatus(entry, string.Empty, out info, out hbStatus);
message = string.Format("Method: GetManagementNodeDetails - CdcGetDCStatus API call for Server: {0} complete", serverDto.Server);
_logger.Log(message, LogLevel.Info);
var infraDto = new InfrastructureDto()
{
Name = entry,
Active = info.bIsAlive == 1,
Sitename = info.pszSiteName,
LastPing = DateTimeConverter.FromUnixToDateTime(info.dwLastPing),
Services = new List <ServiceDto>(),
Ip = Network.GetIpAddress(entry)
};
if (hbStatus.info != null)
{
foreach (var serviceInfo in hbStatus.info)
{
var service = new ServiceDto
{
ServiceName = ServiceHelper.GetServiceName(serviceInfo.pszServiceName),
Description = ServiceHelper.GetServiceDescription(serviceInfo.pszServiceName),
Alive = serviceInfo.bIsAlive == 1,
LastHeartbeat = DateTimeConverter.FromUnixToDateTime(serviceInfo.dwLastHeartbeat),
Port = serviceInfo.dwPort,
};
infraDto.Services.Add(service);
}
}
dto.DomainControllers.Add(infraDto);
}
catch (Exception exc)
{
message = string.Format("Method: GetManagementNodeDetails - CdcGetDCStatus API call for Server: {0} failed", serverDto.Server);
_logger.Log(message, LogLevel.Error);
var custom = new CustomExceptionExtractor().GetCustomMessage(exc);
_logger.LogException(exc, custom);
dto.DomainController = new InfrastructureDto
{
Name = string.Empty,
NodeType = NodeType.Infrastructure,
Domain = string.Empty
};
}
}
}
catch (Exception exc)
{
message = string.Format("Method: GetManagementNodeDetails - CdcEnumDCEntries API call for Server: {0} failed", serverDto.Server);
_logger.Log(message, LogLevel.Error);
var custom = new CustomExceptionExtractor().GetCustomMessage(exc);
_logger.LogException(exc, custom);
dto.DomainController = new InfrastructureDto
{
Name = string.Empty,
NodeType = NodeType.Infrastructure,
Domain = string.Empty
};
}
}
return(dto);
}
/// <summary>
/// Gets the management nodes.
/// </summary>
/// <returns>The management nodes.</returns>
/// <param name="serverDto">Server dto.</param>
/// <param name="dcName">Dc name.</param>
/// <param name="siteName">Site name.</param>
private List <NodeDto> GetManagementNodes(ServerDto serverDto, string dcName, string site)
{
var message = "GetManagementNodes method for Server: " + serverDto.Server;
_logger.Log(message, LogLevel.Info);
var nodes = new ConcurrentBag <NodeDto>();
try
{
message = "VmDirGetComputers method for Server: " + serverDto.Server;
_logger.Log(message, LogLevel.Info);
// Get Management nodes
var mgmtNodes = vmdirClient.Client.VmDirGetComputers(dcName, serverDto.UserName, serverDto.Password);
message = string.Format("VmDirGetComputers method for Server: {0} VC nodes: {1}", serverDto.Server, mgmtNodes.Count);
_logger.Log(message, LogLevel.Info);
if (mgmtNodes != null && mgmtNodes.Count > 0)
{
var tasks = new Task[mgmtNodes.Count];
var index = 0;
// Update management nodes with site name
foreach (var mgmt in mgmtNodes)
{
tasks[index++] = Task.Factory.StartNew(() =>
{
var siteName = string.Empty;
var s = new ServerDto
{
Server = mgmt,
Upn = serverDto.Upn,
Password = serverDto.Password,
UserName = serverDto.UserName
};
try
{
message = string.Format("VmAfdGetSiteName API call for Server: {0} ", s.Server);
_logger.Log(message, LogLevel.Info);
using (Client client = new Client(s.Server, s.Upn, s.Password))
{
siteName = client.VmAfdGetSiteName();
}
message = string.Format("VmAfdGetSiteName API call for Server: {0} succeeded.", s.Server);
_logger.Log(message, LogLevel.Info);
var mgmtNode = new ManagementDto()
{
Name = mgmt,
Sitename = siteName,
NodeType = NodeType.Management,
Ip = Network.GetIpAddress(mgmt)
};
nodes.Add(mgmtNode);
}
catch (Exception exc)
{
message = string.Format("VmAfdGetSiteName returned error for Server: {0} ", s.Server);
_logger.Log(message, LogLevel.Info);
var custom = new CustomExceptionExtractor().GetCustomMessage(exc);
_logger.LogException(exc, custom);
}
});
}
Task.WaitAll(tasks);
}
}
catch (Exception exc)
{
var custom = new CustomExceptionExtractor().GetCustomMessage(exc);
_logger.LogException(exc, custom);
}
return(nodes.ToList());
}
