Exemple #1
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());
        }
Exemple #2
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());
        }
        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());
        }
        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());
        }
Exemple #5
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());
        }