private AuthTokenDto GetJwtTokenByCertificate(ServiceGateway service, ServerDto serverDto)
{
var cert = new X509Certificate2(txtCertificate.Text);
var rsaKey = ShaWithRsaSigner.PrivatePemKeyToRSACryptoServiceProvider(txtPrivateKey.Text);
return(service.JwtTokenService.GetTokenFromCertificate(serverDto, cert, rsaKey));
}
public override void AnnounceServer(string serverId, ServerContext context)
{
if (serverId == null)
{
throw new ArgumentNullException(nameof(serverId));
}
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
var server = new ServerDto
{
Id = serverId,
WorkerCount = context.WorkerCount,
Queues = context.Queues,
StartedAt = DateTime.UtcNow,
LastHeartbeat = DateTime.UtcNow
};
_dbContext.Server.ReplaceOne(Builders <ServerDto> .Filter.Eq(_ => _.Id, serverId), server, new UpdateOptions {
IsUpsert = true
});
}
/// <summary>
/// Raises the server tool bar item activated event.
/// </summary>
/// <param name="sender">Sender.</param>
/// <param name="e">E.</param>
void OnServerToolBarItem_Activated(object sender, EventArgs e)
{
if (_serverState == ServerState.Connected)
{
_serverState = ServerState.Disconnected;
_isLoggedIn = false;
if (_rootNode != null)
{
_rootNode.OnCacheRefresh -= OnCacheRefresh;
}
_rootNode = null;
_managementDto = null;
ServerToolBarItem.Image = NSImage.ImageNamed(Constants.ConnectIcon);
ServerToolBarItem.Label = Constants.ConnectLabel;
_serverDto = null;
RefreshToolBarItem.Active = false;
for (int index = 0; index < this.ContainerView.Subviews.Length; index++)
{
this.ContainerView.Subviews[index].RemoveFromSuperview();
}
LoggedInLabel.StringValue = (NSString)string.Empty;
}
else
{
ConnectToServer();
}
}
public AllGroupsPropertyManager(ServiceGateway service, ServerDto serverDto, string tenantName, string domainName)
{
_service = service;
_serverDto = serverDto;
_domainName = domainName;
_tenantName = tenantName;
}
public TenantNode(ServerDto serverDto, string tenantName)
{
_serverDto = serverDto;
_tenantName = tenantName;
Active = true;
IsSystemTenant = false;
}
public List <ServerDto> GetServersInPast7Days()
{
var servers = GetQueryableSummary().ToList();
var serverStatues = new List <ServerDto>();
foreach (var server in servers)
{
var color = server.Status.Equals(ServerStatusEnum.Success.ToString()) ? ServerColorEnum.Orange.ToString() : ServerColorEnum.Green.ToString();
var latency = GetLatencyFromServer(server.SvcNo, DateTime.Now.AddDays(-7));
var newServerStatus = new ServerDto
{
ServerName = server.SvcName,
Color = color,
Latency = latency,
ExclamationCount = server.Failed7,
CheckCount = server.Count7,
HourTimeAvgLatency = server.AvgLatency7,
CheckDateTime = server.CheckDateTime
};
serverStatues.Add(newServerStatus);
}
return(serverStatues);
}
private void LoadCachedDetails()
{
var node = _formView.ScopeNode as ManagementNode;
lblName.Text = node.DisplayName;
var serverNode = node.GetServerNode();
var siteName = node.GetSiteName();
lblSitename.Text = siteName;
//_infraDtos = serverNode.Hosts.Where(x => x.NodeType == NodeType.Infrastructure && x.Sitename == siteName);
_serverDto = new ServerDto {
Server = node.DisplayName, Upn = node.ServerDto.Upn, Password = node.ServerDto.Password, DomainName = node.ServerDto.DomainName
};
_dto = serverNode.Hosts.First(x => x.Name == node.DisplayName) as ManagementDto;
_dto.DomainControllers = GetInfraNodesForTheSite(_dto.DomainControllers, siteName);
_infraDtos = _dto.DomainControllers;
txtIpAddress.Text = _dto.Ip;
if (_dto.State == null)
{
_dto = PscHighAvailabilityAppEnvironment.Instance.Service.GetManagementNodeDetails(_serverDto);
}
UpdateState();
foreach (InfrastructureDto dc in _infraDtos)
{
AddNewDomainController(dc);
}
lblLastRefreshed.Text = DateTime.Now.ToString(Constants.DateFormat);
if (lstdcs.Items.Count > 0)
{
lstdcs.Items[node.SelectedInfrastructureItem].Selected = true;
}
UpdateServices();
}
public AuthTokenDto GetAuthToken(ServerDto serverDto, string tenant)
{
var key = string.Format("{0}|{1}", serverDto.ServerName, tenant);
var authToken = _localData.Get(key);
return(authToken);
}
public NewExternalIdp(ExternalIdentityProviderDto externalIdentityProviderDto, ServiceGateway service, ServerDto serverDto, string tenantName)
{
_service = service;
_serverDto = serverDto;
_tenantName = tenantName;
_externalIdentityProviderDtoOrig = externalIdentityProviderDto;
InitializeComponent();
txtEntityId.ReadOnly = true;
btnCreate.Visible = false;
btnAddCert.Visible = false;
btnRemoveCert.Visible = false;
btnAddNameIdFormat.Visible = false;
btnRemoveNameIdFormat.Visible = false;
btnAddSsoService.Visible = false;
btnRemoveSsoService.Visible = false;
btnAddSubjectFormat.Visible = false;
btnRemoveSubjectFormat.Visible = false;
btnSloService.Visible = false;
btnRemoveSloService.Visible = false;
lstNameIdFormats.Enabled = false;
lstSubjectFormat.Enabled = false;
lstSloServices.Enabled = false;
lstSsoServices.Enabled = false;
chkJit.Enabled = false;
DtoToView(_externalIdentityProviderDtoOrig);
if (lstCertificateChain.Items.Count > 0)
{
lstCertificateChain.Items[0].Selected = true;
}
Text = "External Identity Provider";
btnCreate.Text = "Update";
}
public void RemoveServer_RemovesAServerRecord()
{
var realm = _storage.GetRealm();
realm.Write(() =>
{
var server1 = new ServerDto
{
Id = "server1",
LastHeartbeat = DateTime.UtcNow
};
realm.Add(server1);
var server2 = new ServerDto
{
Id = "server2",
LastHeartbeat = DateTime.UtcNow
};
realm.Add(server2);
});
_connection.RemoveServer("server1");
var servers = realm.All <ServerDto>();
Assert.IsTrue(servers.Any(s => s.Id == "server2"));
Assert.IsFalse(servers.Any(s => s.Id == "server1"));
}
public ExternalDomainPropertyManager(string tenantName, ServiceGateway service, ServerDto server, IdentityProviderDto provider)
{
_tenantName = tenantName;
_service = service;
_server = server;
_provider = provider;
}
public void Heartbeat_UpdatesLastHeartbeat_OfTheServerWithGivenId()
{
var realm = _storage.GetRealm();
realm.Write(() =>
{
var server1 = new ServerDto
{
Id = "server1",
LastHeartbeat = new DateTime(2012, 12, 12, 12, 12, 12, DateTimeKind.Utc)
};
var server2 = new ServerDto
{
Id = "server2",
LastHeartbeat = new DateTime(2012, 12, 12, 12, 12, 12, DateTimeKind.Utc)
};
realm.Add(server1);
realm.Add(server2);
});
_connection.Heartbeat("server1");
var servers = realm.All <ServerDto>().ToList()
.ToDictionary(x => x.Id, x => x.LastHeartbeat);
Assert.True(servers.ContainsKey("server1"));
Assert.True(servers.ContainsKey("server2"));
Assert.AreNotEqual(2012, servers["server1"].Value.Year);
Assert.AreEqual(2012, servers["server2"].Value.Year);
}
private string GetSamlTokenByGss(ServiceGateway service, ServerDto serverDto)
{
var gssTicket = KerberosHelper.GetKerberosContext(txtGssUsername.Text, txtGssPassword.Text, txtGssDomain.Text, txtGssSpn.Text);
var token = service.SamlTokenService.GetSamlTokenFromGss(serverDto, gssTicket);
return(token);
}
private AuthTokenDto GetJwtTokenByGssTicket(ServiceGateway service, ServerDto serverDto)
{
var gssTicket = KerberosHelper.GetKerberosContext(txtGssUsername.Text, txtGssPassword.Text, txtGssDomain.Text, txtGssSpn.Text);
var gssBase64Encoded = Uri.EscapeDataString(gssTicket);
return(service.JwtTokenService.GetTokenFromGssTicket(serverDto, gssBase64Encoded, Guid.NewGuid().ToString()));
}
protected override void OnAction(Action action, AsyncStatus status)
{
base.OnAction(action, status);
switch ((SnapInNodeAction)(int)action.Tag)
{
case SnapInNodeAction.AddServer:
_dto = NavigateToAddServerView();
if (_dto != null)
{
AddServerNodeAndAskForLogin(_dto);
}
break;
case SnapInNodeAction.ShowHttpTransport:
NavigateToHttpTransportView();
break;
case SnapInNodeAction.ActionTokenWizard:
ShowTokenWizard();
break;
case SnapInNodeAction.OfflineSuperLog:
ShowSuperLog();
break;
}
}
/// <summary>
/// Gets the nodes.
/// </summary>
/// <returns>The nodes.</returns>
/// <param name="serverDto">Server dto.</param>
/// <param name="dcName">Dc name.</param>
/// <param name="siteName">Site name.</param>
private List <NodeDto> GetNodes(ServerDto serverDto, string dcName, string siteName)
{
List <NodeDto> list1 = null, list2 = null;
var t1 = Task.Run(() => { list1 = GetInfrastructureNodes(serverDto, dcName); });
var t2 = Task.Run(() => { list2 = GetManagementNodes(serverDto, dcName, siteName); });
var tasks = new Task[] { t1, t2 };
var result = Task.WaitAll(tasks, Constants.TopologyTimeout * Constants.MilliSecsMultiplier);
if (!result)
{
throw new Exception(Constants.TolologyApiIsTakenLonger);
}
else
{
if (t1.Exception != null)
{
throw t1.Exception;
}
if (t2.Exception != null)
{
throw t2.Exception;
}
}
if (list2 != null)
{
list2.AddRange(list1);
return(list2);
}
return(list1);
}
public List <ServerDto> GetServersInPast24Hours()
{
var servers = GetQueryableSummary().ToList();
var serverStatues = new List <ServerDto>();
foreach (var server in servers)
{
var color = server.Status.Equals(ServerStatusEnum.Success.ToString())
? ServerColorEnum.Green.ToString() : ServerColorEnum.Orange.ToString();
var latency = GetLatencyFromServer(server.SvcNo, DateTime.Now.AddDays(-1));
var checkDateTime = server.CheckDateTime.ToUniversalTime() <= DateTimeOffset.MinValue.UtcDateTime
? DateTimeOffset.MinValue : new DateTimeOffset(server.CheckDateTime);
var newServerStatus = new ServerDto
{
ServerName = server.SvcName,
Color = color,
Latency = latency,
ExclamationCount = server.Failed24,
CheckCount = server.Count24,
HourTimeAvgLatency = server.AvgLatency24,
CheckDateTime = DateTimeOffset.Parse(checkDateTime.ToString(), null).DateTime
};
serverStatues.Add(newServerStatus);
}
return(serverStatues);
}
/// <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)
{
_logger.LogException(exc);
throw;
}
}
public SolutionUserPropertyManager(ServiceGateway service, SolutionUserDto dto, ServerDto serverDto, string tenantName)
{
_tenantName = tenantName;
_dtoOriginal = dto;
_service = service;
_serverDto = serverDto;
}
/// <summary>
/// Gets the vmdir service status.
/// </summary>
/// <returns>The infrastructure nodes.</returns>
/// <param name="serverDto">Server dto.</param>
private ServiceDto GetVmDirServiceStatus(ServerDto serverDto)
{
var dto = new ServiceDto
{
HostName = serverDto.Server,
ServiceName = Constants.DirectoryServiceName,
Description = Constants.DirectoryServiceDesc,
LastHeartbeat = System.DateTime.UtcNow
};
try
{
var message = string.Format("Method: GetVmDirServiceStatus - VmDirGetDCInfos API call for Server: {0} complete", serverDto.Server);
_logger.Log(message, LogLevel.Info);
var entries = vmdirClient.Client.VmDirGetDCInfos(serverDto.Server, serverDto.UserName, serverDto.Password);
dto.Alive = true;
message = string.Format("Method: GetVmDirServiceStatus - VmDirGetDCInfos API call for Server: {0} complete", serverDto.Server);
_logger.Log(message, LogLevel.Info);
}
catch (Exception exc)
{
dto.Alive = false;
}
return(dto);
}
private void UpdateManagementNode(NodeDto host, ServerDto serverDto)
{
var message = string.Format("Method: UpdateManagementNode refresh cache cycle start for Server: {0}", host.Name);
var logger = PscHighAvailabilityAppEnvironment.Instance.Logger;
logger.Log(message, LogLevel.Info);
var service = PscHighAvailabilityAppEnvironment.Instance.Service;
var server = new ServerDto
{
Server = host.Name,
Upn = serverDto.Upn,
UserName = serverDto.UserName,
Password = serverDto.Password,
DomainName = serverDto.DomainName
};
var dto = service.GetManagementNodeDetails(server);
dto.Name = server.Server;
dto.Domain = server.DomainName;
message = string.Format("Method: UpdateManagementNode - for Server: {0}", host.Name);
logger.Log(message, LogLevel.Info);
var index = Hosts.FindIndex(x => x.Name == dto.Name);
if (index > -1 && index < Hosts.Count)
{
Hosts[index] = dto;
message = string.Format("Method: UpdateManagementNode updated VC Server: {0}", host.Name);
logger.Log(message, LogLevel.Info);
}
message = string.Format("Method: UpdateManagementNode refresh cache cycle end for Server: {0}", host.Name);
logger.Log(message, LogLevel.Info);
}
/// <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)
{
_logger.LogException(exc);
}
return(dfl);
}
public GroupDto Update(ServerDto serverDto, string tenant, GroupDto groupDto, Token token)
{
var principalName = Uri.EscapeDataString(groupDto.GroupName + "@" + groupDto.GroupDomain);
tenant = Uri.EscapeDataString(tenant);
var url = string.Format(ServiceConfigManager.GroupEndPoint, serverDto.Protocol, serverDto.ServerName, serverDto.Port, tenant, principalName);
var g = new GroupDto()
{
GroupDetails = new GroupDetailsDto {
Description = groupDto.GroupDetails.Description
}
};
var json = JsonConvert.Serialize(g);
ServicePointManager.ServerCertificateValidationCallback = delegate { return(true); };
var requestConfig = new RequestSettings
{
Method = HttpMethod.Put,
};
var headers = ServiceHelper.AddHeaders(ServiceConfigManager.JsonContentType);
json = "access_token=" + token.AccessToken + "&token_type=" + token.TokenType.ToString().ToLower() + "&" + json;
var response = _webRequestManager.GetResponse(url, requestConfig, headers, null, json);
return(JsonConvert.Deserialize <GroupDto>(response));
}
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>
/// Updates the management node.
/// </summary>
/// <param name="host">Host.</param>
/// <param name="serverDto">Server dto.</param>
public void UpdateManagementNode(NodeDto host, ServerDto serverDto)
{
var server = new ServerDto
{
Server = host.Name,
Upn = serverDto.Upn,
UserName = serverDto.UserName,
Password = serverDto.Password,
DomainName = serverDto.DomainName
};
var dto = _service.GetManagementNodeDetails(server);
dto.Name = server.Server;
dto.Domain = server.DomainName;
var index = Hosts.FindIndex(x => x.Name == dto.Name);
if (index < Hosts.Count)
{
Hosts[index] = dto;
}
if (OnCacheRefresh != null)
{
OnCacheRefresh(this, EventArgs.Empty);
}
}
public override void AnnounceServer(string serverId, ServerContext context)
{
if (serverId == null)
{
throw new ArgumentNullException(nameof(serverId));
}
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
try
{
using var realm = _storage.GetRealm();
using var transaction = realm.BeginWrite();
var server = new ServerDto
{
Id = serverId,
WorkerCount = context.WorkerCount,
StartedAt = DateTime.UtcNow,
LastHeartbeat = DateTime.UtcNow
};
((List <string>)server.Queues).AddRange(context.Queues);
realm.Add(server, update: true);
transaction.Commit();
}
catch (Exception e)
{
_logger.ErrorException($"Error announcing {serverId}.", e);
throw;
}
}
/// <summary>
/// Connects to server.
/// </summary>
/// <returns>The to server.</returns>
/// <param name="server">Server.</param>
public ServerDto ConnectToServer(string server)
{
var form = new LoginWindowController()
{
Server = server
};
var serverDto = new ServerDto {
Server = server
};
NSApplication.SharedApplication.BeginSheet(form.Window, this.Window, () => {
});
try {
nint result = NSApplication.SharedApplication.RunModalForWindow(form.Window);
if (result == VMIdentityConstants.DIALOGOK)
{
serverDto = new ServerDto {
Server = form.Server,
UserName = form.UserName,
Password = form.Password,
DomainName = form.DomainName,
Upn = form.Upn
};
}
} finally {
Window.EndSheet(form.Window);
form.Close();
form.Dispose();
}
return(serverDto);
}
public string GetSamlTokenFromGss(ServerDto serverDto, string bet, int lifeTimeSeconds=300)
{
var soapString = XmlResourceHelper.GetResourceXml("Vmware.Tools.RestSsoAdminSnapIn.Service.xml.BETLoginRequest.xml");
var dt = DateTime.Now;
dt = TimeZoneInfo.ConvertTimeToUtc(dt);
ServicePointManager.ServerCertificateValidationCallback = delegate { return true; };
var dtEnd = dt.AddSeconds(lifeTimeSeconds);
string format = "yyyy-MM-ddTHH:mm:ss.fffZ";
var dt1 = dt.ToString(format);
var dt2 = dtEnd.ToString(format);
soapString = string.Format(soapString, dt1, dt2, dt1, dt2, bet);
var customHeaders = new Dictionary<string, string>();
customHeaders.Add("SOAPAction", "http://docs.oasis-open.org/ws-sx/ws-trust/200512/RST/Issue");
var headers = ServiceHelper.AddHeaders("text/xml");
var url = serverDto.Url;
var requestConfig = new RequestSettings
{
Method = HttpMethod.Post,
};
var responseFromServer = _webRequestManager.GetResponse(url, requestConfig, headers, customHeaders, soapString);
XmlDocument doc = new XmlDocument();
doc.PreserveWhitespace = false;
using (var reader = new StringReader(responseFromServer))
doc.Load(reader);
var node = doc.GetElementsByTagName("saml2:Assertion")[0];
if (node != null)
return node.OuterXml;
else
throw new Exception(responseFromServer);
}
public UserGeneralPropertyManager(ServiceGateway service, UserDto dto, ServerDto serverDto, string tenantName)
{
_tenantName = tenantName;
_dtoOriginal = dto;
_service = service;
_serverDto = serverDto;
}
public IHttpActionResult Create([FromBody] ServerDto server)
{
server.CreatorId = UserHelper.CurrUserInfo.UserId;
server.CreatorName = UserHelper.CurrUserInfo.NickName;
_serverSvc.CreateServer(server);
return(Ok());
}
