/// <summary>
/// Bind to the
/// </summary>
/// <param name="port"></param>
public UdpListener(IPAddress serverAddress, int port, ServerFilter filter)
{
this.filter = filter;
UDPSocket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
UDPSocket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.Broadcast, true);
UDPSocket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);
UDPSocket.Bind(new IPEndPoint(serverAddress, port));
EndPoint tempRemoteEP = (EndPoint)sender;
UDPSocket.BeginReceiveFrom(buff, 0, buff.Length, SocketFlags.None, ref tempRemoteEP, GotUdpMessage, tempRemoteEP);
}
/// <summary>
/// Return the servers monitored by Contrast agents.
/// </summary>
/// <param name="organizationId">The uuid of the user's organization</param>
/// <param name="filter">Query params that can be added to filter request.</param>
/// <returns>A ServerResponse object which contains a list of Server objects being monitored</returns>
/// <exception cref="System.AggregateException">Thrown when there is an error communicating with TeamServer</exception>
public ServersResponse GetServers(string organizationId, ServerFilter filter)
{
string endpoint = String.Format(NgEndpoints.SERVERS, organizationId, string.Empty);
if (filter != null)
{
endpoint += filter.ToString();
}
return(GetResponseAndDeserialize <ServersResponse>(endpoint));
}
public async Task <IReadOnlyList <ServerDto> > GetAllServersAsync(ServerFilter filter)
{
var serverSpec = new ServerSpecification(filter);
var servers = await _serverRepository.ListAsync(serverSpec);
// Load Server Additional Data and calculate list of groups in this inventory
var serversDto = new System.Collections.Concurrent.ConcurrentBag <ServerDto>();
Parallel.ForEach <Server>(servers, async currentServer =>
{
var serverDto = await GetOrFillServerData(currentServer);
serversDto.Add(serverDto);
});
return(serversDto.ToList());
}
public IActionResult Get([FromQuery] ServerFilter filter)
{
try
{
var ServerList = _service.Get(filter);
if (ServerList == null || ServerList.Count() == 0)
{
return(NotFound());
}
return(Ok(ServerList));
}
catch (System.Exception e)
{
try { _logService.SendLogError(e); } catch (System.Exception ex) { return(StatusCode(503, ex.Message)); }
return(StatusCode(503, e));
}
}
public async Task <ILookup <int, ServerDto> > GetServersByEnvironmentAsync(IEnumerable <int> environmentIds, CancellationToken token)
{
var serverFilter = new ServerFilter()
{
EnvironmentIds = environmentIds.ToArray()
};
var serverGroups = await _serverRepository.ListAsync(new ServerSpecification(serverFilter));
var groupBy = serverGroups.SelectMany(s => s.ServerEnvironments, (s, se) => new { se.EnvironmentId, se.Server });
return(groupBy.ToLookup(s => s.EnvironmentId, s =>
{
var dtoServer = GetOrFillServerData(s.Server);
dtoServer.Wait();
return dtoServer.Result;
}));
}
//server side filter to disable some data for user
private ServerFilter GetServerFilter()
{
// get the user token from the request headers
HttpContext.Request.Headers.TryGetValue("UserToken", out StringValues userRole);
if (userRole.Count == 1)
{
// create a server filter
ServerFilter serverFilter = new ServerFilter();
// specify a field to filter
serverFilter.Field = new Field()
{
UniqueName = "Country", Type = ColumnType.StringType
};
// include the members that correspond to the user token
serverFilter.Include = _userPermissions[userRole[0]];
return(serverFilter);
}
return(null);
}
public ServerSpecification(ServerFilter filter) : this()
{
if (filter.LoadChildren)
{
Query.Include(s => s.OperatingSystem);
Query.Include(s => s.ServerDisks);
Query.Include(s => s.ServerEnvironments);
Query.Include(s => s.ServerGroups).ThenInclude(sg => sg.Group);
}
if (filter.IsPagingEnabled)
{
Query.Skip(filter.Skip);
Query.Take(filter.Take);
}
if (filter.EnvironmentIds != null)
{
Query.Include(s => s.ServerEnvironments).ThenInclude(se => se.Environment);
Query.Where(s => s.ServerEnvironments.Any(se => filter.EnvironmentIds.Contains(se.EnvironmentId)));
}
}
public void TestServerFilter()
{
ServerFilter filter = new ServerFilter();
filter.Limit = 10;
filter.Expand = new List <ServerExpandValue>();
filter.Expand.Add(ServerExpandValue.applications);
filter.IncludeArchived = false;
filter.Status = "Denied";
filter.QueryParam = "any";
string query = filter.ToString();
Assert.IsTrue(query.Contains("includeArchived"));
Assert.IsTrue(query.Contains("limit"));
Assert.IsTrue(query.Contains("expand=applications"));
Assert.IsTrue(query.Contains("status=Denied"));
Assert.IsTrue(query.Contains("q=any"));
Assert.IsFalse(query.Contains("applicationIds"));
Assert.IsFalse(query.Contains("logLevels"));
Assert.IsFalse(query.Contains("offset"));
}
public IActionResult Get(int id, string fields, string ref_fields)
{
try
{
ServerFilter filter = new ServerFilter()
{
ids = id + "",
fields = fields,
ref_fields = ref_fields
};
var ServerList = _service.Get(filter);
if (ServerList == null || ServerList.Count() == 0)
{
return(NotFound());
}
return(Ok(ServerList));
}
catch (System.Exception e)
{
try { _logService.SendLogError(e); } catch (System.Exception ex) { return(StatusCode(503, ex.Message)); }
return(StatusCode(503, e));
}
}
/// <summary>
/// Select the server with the ServerRoles.BackupCleanupSqlServer role for restoring database.
/// </summary>
private static string RetrieveRestoreSqlServer()
{
// Select the enabled sql server in the same datacenter with correct role.
ServerFilter serverFilter = new ServerFilter();
serverFilter.Roles = ServerRoles.BackupCleanupSqlServer;
serverFilter.State = ServerState.Enabled;
serverFilter.DatacenterId = LocatorService.Instance.GetDatacenterId(); // getting data from settings
CrmServerService crmServerService = new CrmServerService();
var res = crmServerService.RetrieveMultiple(serverFilter);
if (res.Length == 0)
{
throw new CrmException("cannot find BackupCleanupSqlServer has role: " + ServerRoles.BackupCleanupSqlServer);
}
// If multiple, randomly select one
// TODO: need to use queue item group id to control the number of allowed parallel queue items
Random rand = new Random();
int randNum = rand.Next();
return(res[randNum % res.Length].Name);
}
public IActionResult Create(ServerCreateRequestModel model)
{
try
{
// Check Server Master
if (model.ServerMaster != null && model.ServerMaster != 0)
{
ServerFilter filter = new ServerFilter()
{
ids = (int)model.ServerMaster + ""
};
if (_service.Get(filter).FirstOrDefault() == null)
{
return(BadRequest(new { error = "Server Master is not existed!" }));
}
}
else
{
model.ServerMaster = null;
}
if ((model.Type == 1 || model.Type == 2) && model.Os > 2)
{
return(BadRequest(new { error = "Web Server only be Windows or Linux" }));
}
if (model.Type == 3 && (model.Os < 3 || model.Os > 6))
{
return(BadRequest(new { error = "Repo Server - Server Os should be between 3 and 6" }));
}
if (model.Type == 4 && (model.Os < 7 || model.Os > 10))
{
return(BadRequest(new { error = "Database Server - Server Os should be between 7 and 10" }));
}
if (model.IpAddress != null && !IPAddress.TryParse(model.IpAddress, out IPAddress address))
{
return(BadRequest(new { error = "IpAdress is wrong format!" }));
}
var result = _service.Create(model);
if (result == null)
{
return(BadRequest("Invalid company_id or server name"));
}
// Create Server Detail
//if(model.ServerDetail != null)
//{
// var createServerDetail = _serverDetailService.Create(model.ServerDetail);
// if (createServerDetail == null)
// {
// return BadRequest("Server created but server detail is invalid");
// }
//}
return(Ok(result));
}
catch (System.Exception e)
{
try { _logService.SendLogError(e); } catch (System.Exception ex) { return(StatusCode(503, ex)); }
//
return(StatusCode(503, e));
}
}
public IActionResult Update(ServerUpdateRequestModel model)
{
try
{
// Check existed server name
var existServer = _repo.GetActive(p => p.Name == model.Name && p.Id != model.Id).FirstOrDefault();
if (existServer != null)
{
return(BadRequest(new { error = "Server Name is existed!" }));
}
// Check Server Master
if (model.ServerMaster != null)
{
ServerFilter filter = new ServerFilter()
{
ids = (int)model.ServerMaster + ""
};
if (_service.Get(filter).FirstOrDefault() == null)
{
return(BadRequest(new { error = "Server Master is not existed!" }));
}
}
if ((model.Type == 1 || model.Type == 2) && model.Os > 2)
{
return(BadRequest(new { error = "Web Server only be Windows or Linux" }));
}
if (model.Type == 3 && (model.Os < 3 || model.Os > 6))
{
return(BadRequest(new { error = "Repo Server - Server Os should be between 3 and 6" }));
}
if (model.Type == 4 && (model.Os < 7 || model.Os > 10))
{
return(BadRequest(new { error = "Database Server - Server Os should be between 7 and 10" }));
}
if (model.IpAddress != null && !IPAddress.TryParse(model.IpAddress, out IPAddress address))
{
return(BadRequest(new { error = "IpAdress is wrong format!" }));
}
var result = _service.Update(model);
if (model == null)
{
BadRequest(new { error = "Invalid Server" });
}
// Update ServerDetail
if (model.ServerDetail != null)
{
var updateServerDetail = _serverDetailService.Update(model.ServerDetail);
if (updateServerDetail == null)
{
return(BadRequest("Server updated but server detail is invalid"));
}
}
return(Ok(result));
}
catch (System.Exception e)
{
try { _logService.SendLogError(e); } catch (System.Exception ex) { return(StatusCode(503, ex.Message)); }
return(StatusCode(503, e));
}
}
