示例#1
0
        public async Task <IActionResult> SaveAndRemoveExistingNotificationTresholds(Guid serverId,
                                                                                     [FromBody] NotificationResourceThresholdDTO notificationResourceThresholdDto)
        {
            var server = await ServerUtilController.GetServerFromJwt(serverId, HttpContext);

            if (server == null)
            {
                return(BadRequest("Server id is either null or you are not the owner"));
            }

            var notificationResourceThresholdToDelete =
                await _unitOfWork.NotificationThresholds.GetAll(q => q.ServerId == server.Id
                                                                );

            _unitOfWork.NotificationThresholds.DeleteRange(notificationResourceThresholdToDelete);

            var notificationResourceThresholdToSave =
                _mapper.Map <NotificationResourceThreshold>(notificationResourceThresholdDto);

            notificationResourceThresholdToSave.ServerId = server.Id;

            await _unitOfWork.NotificationThresholds.Insert(notificationResourceThresholdToSave);

            return(NoContent());
        }
示例#2
0
        public async Task <IActionResult> SetHardDisksForServer(
            Guid serverId,
            [FromBody] IList <CreateHardDiskServer> hardDiskServersDto
            )
        {
            var server = await ServerUtilController.GetUserHisServerFromApiKey(serverId, HttpContext);

            if (server == null)
            {
                return(BadRequest("Sever id is either null or you are not the owner of the server."));
            }

            var hardDiskServers = _mapper.Map <IList <HardDiskServer> >(hardDiskServersDto);

            // set the right server id
            hardDiskServers.ForAll(s => s.ServerId = serverId.ToString());

            // so we overwrite the existing.
            await RemoveExistingHardDisksOfServer(serverId.ToString());

            await _unitOfWork.HardDisksServers.InsertRange(hardDiskServers);

            await HardDiskEventChecker(server, hardDiskServers);

            return(NoContent());
        }
示例#3
0
        public async Task <IList <PortServer> > GetServerPorts(Guid serverId)
        {
            var server = await ServerUtilController.GetServerFromJwt(serverId, HttpContext);

            var portsOfServer = await _unitOfWork.PortsServer.GetAll(
                q => q.ServerId == server.Id
                );

            return(portsOfServer);
        }
示例#4
0
        public async Task <IList <HardDiskServer> > GetHardDisksOfServer(Guid serverId)
        {
            var server = await ServerUtilController.GetServerFromJwt(serverId, HttpContext);

            var hardDiskServers = await _unitOfWork.HardDisksServers.GetAll(
                q => q.ServerId == server.Id
                );

            return(hardDiskServers);
        }
        public async Task <IList <ServerEventDto> > GetEventsOfServer(Guid serverId)
        {
            var server = await ServerUtilController.GetServerFromJwt(serverId, HttpContext);

            var serverEvents = await _unitOfWork.ServerEvents.GetAll(
                q => q.ServerId == server.Id,
                orderBy => orderBy.OrderByDescending(s => s.CreatedAt)

                );

            return(_mapper.Map <IList <ServerEventDto> >(serverEvents));
        }
示例#6
0
        public async Task <IActionResult> SaveNetworkUSage(Guid serverId, [FromBody] CreateNetworkUsageDto networkUsageDto)
        {
            // TODO check if not something was already posted in the past minute
            var server = await ServerUtilController.GetUserHisServerFromApiKey(serverId, HttpContext);

            var networkUsage = _mapper.Map <NetworkUsage>(networkUsageDto);

            networkUsage.ServerId  = server.Id;
            networkUsage.CreatedAt = DateTime.Now;

            await _unitOfWork.NetworkUsages.Insert(networkUsage);

            return(Ok());
        }
示例#7
0
        public async Task <IActionResult> GetNotificationTresholdSettings(Guid serverId)
        {
            var server = await ServerUtilController.GetServerFromJwt(serverId, HttpContext);

            if (server == null)
            {
                return(BadRequest("Server id is either null or you are not the owner"));
            }

            var notificationResourceThreshold = await _unitOfWork.NotificationThresholds.Get(
                q => q.ServerId == server.Id
                );

            return(Ok(notificationResourceThreshold));
        }
示例#8
0
        public async Task <IActionResult> GetNetworkServerAdapters(Guid serverId)
        {
            var server = await ServerUtilController.GetServerFromJwt(serverId, HttpContext);

            if (server == null)
            {
                return(BadRequest("Server id is either null or you are not the owner"));
            }
            var networkAdapterServers = await _unitOfWork.NetworkAdaptersServer.GetAll(
                q => q.ServerId == server.Id
                );

            var networkAdaptersServersMapped = _mapper.Map <IList <NetworkAdapterServerDto> >(networkAdapterServers);

            return(Ok(networkAdaptersServersMapped));
        }
        public async Task <IActionResult> SaveRamUsageMinuteOfServer(Guid serverId, [FromBody] CreateRamUsageDto ramUsageDto)
        {
            // TODO check if not something was already posted in the past minute
            var server = await ServerUtilController.GetUserHisServerFromApiKey(serverId, HttpContext);

            var ramUsage = _mapper.Map <RamUsage>(ramUsageDto);

            ramUsage.ServerId  = server.Id;
            ramUsage.CreatedAt = DateTime.Now;

            await _unitOfWork.RAMUsages.Insert(ramUsage);

            ramUsage.Server = server;
            await RAMEventLoggerChecker(ramUsage);

            return(Ok());
        }
示例#10
0
        public async Task <IList <NetworkUsageDTO> > GetNetworkUsageOfServer(Guid serverId, [FromQuery] CreatedBetween createdBetween)
        {
            var server = await ServerUtilController.GetServerFromJwt(serverId, HttpContext);

            var networkUsages = await _unitOfWork.NetworkUsages.GetAll(
                q => q.ServerId == server.Id &&
                createdBetween.From >= q.CreatedAt && createdBetween.To <= q.CreatedAt
                );

            // year 1 is the default which means the user dit not provide a year.
            if (createdBetween.From.Year != 1 && createdBetween.From.Year != 1)
            {
                networkUsages = await _unitOfWork.NetworkUsages.GetAll(
                    q =>
                    server.Id == q.ServerId
                    );
            }
            return(_mapper.Map <IList <NetworkUsageDTO> >(networkUsages));
        }
        public async Task <IList <CpuUsageDto> > GetCpuUsageOfServer(Guid serverId, [FromQuery] CreatedBetween createdBetween)
        {
            var server = await ServerUtilController.GetServerFromJwt(serverId, HttpContext);

            var cpusUsageServers = await _unitOfWork.CpuUsagesServers.GetAll(
                q => q.ServerId == server.Id
                );

            // year 1 is the default which means the user dit not provide a year.
            if (createdBetween.From.Year != 1 && createdBetween.From.Year != 1)
            {
                cpusUsageServers = await _unitOfWork.CpuUsagesServers.GetAll(
                    q =>
                    server.Id == q.ServerId &&
                    q.CreatedAt >= createdBetween.From && q.CreatedAt <= createdBetween.To
                    );
            }
            return(_mapper.Map <IList <CpuUsageDto> >(cpusUsageServers));
        }
        public async Task <IList <RamUsageDto> > GetRamUsageOfServer(Guid serverId, [FromQuery] CreatedBetween createdBetween)
        {
            var server = await ServerUtilController.GetServerFromJwt(serverId, HttpContext);

            var ramUsages = await _unitOfWork.RAMUsages.GetAll(
                q => q.ServerId == server.Id &&
                createdBetween.From >= q.CreatedAt && createdBetween.To <= q.CreatedAt
                );

            // TODO refactor (or on unit of work layer)
            // year 1 is the default which means the user dit not provide a year.
            if (createdBetween.From.Year != 1 && createdBetween.From.Year != 1)
            {
                ramUsages = await _unitOfWork.RAMUsages.GetAll(
                    q =>
                    server.Id == q.ServerId &&
                    q.CreatedAt >= createdBetween.From && q.CreatedAt <= createdBetween.To
                    );
            }
            return(_mapper.Map <IList <RamUsageDto> >(ramUsages));
        }
        public async Task <IActionResult> SaveCpuUsageMinuteOfServer(Guid serverId, [FromBody] CpuUsageDto cpuUsageDto)
        {
            var server = await ServerUtilController.GetUserHisServerFromApiKey(serverId, HttpContext);

            var cpuUsage = _mapper.Map <CpuUsageServer>(cpuUsageDto);

            cpuUsage.ServerId  = server.Id;
            cpuUsage.CreatedAt = DateTime.Now;

            await _unitOfWork.CpuUsagesServers.Insert(cpuUsage);

            cpuUsage.Server = server;
            // check if within a minute a new cpu usage was reported. It has 40 seconds to post.
            // This check is to see if the server is offline or not
            _backgroundJobClient.Schedule <ServerPowerStatusSetter>(s =>
                                                                    s.SetServerPowerStatus(server),
                                                                    new TimeSpan(0, 1, 10)
                                                                    );

            await CPUEventLoggerChecker(cpuUsage);

            return(NoContent());
        }
示例#14
0
        public async Task <IActionResult> SetNetworkAdapterServer(
            Guid serverId,
            [FromBody] IList <CreateNetworkAdapterServerDto> networkAdapterServerDto
            )
        {
            var server = await ServerUtilController.GetUserHisServerFromApiKey(serverId, HttpContext);

            if (server == null)
            {
                return(BadRequest("Server id is either null or you are not the owner of the server."));
            }

            var networkAdaptersOfServer = _mapper.Map <IList <NetworkAdapterServer> >(networkAdapterServerDto);

            // set the right server id
            networkAdaptersOfServer.ForAll(s => s.ServerId = serverId.ToString());

            // so we overwrite the existing.
            await RemoveExistingNetworkAdaptersOfServer(serverId.ToString());

            await _unitOfWork.NetworkAdaptersServer.InsertRange(networkAdaptersOfServer);

            return(NoContent());
        }