webmatic/insight
webmatic/insight
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

testing remote stuff

Browse source
This commit is contained in:
kkb 2023-11-17 17:12:41 +01:00
parent 1e05d4576d
commit 3c9ccaafeb
374 changed files with 10526 additions and 2037 deletions
Download patch file Download diff file Expand all files Collapse all files

9
src/Server/Insight.Server/Insight.Server.csproj
View file

@ -5,7 +5,7 @@
<TargetFramework>net7.0</TargetFramework>
<Product>Insight</Product>
<AssemblyName>server</AssemblyName>
<AssemblyVersion>2023.9.21.1</AssemblyVersion>
<AssemblyVersion>2023.11.17.0</AssemblyVersion>
<RootNamespace>Insight.Server</RootNamespace>
<ImplicitUsings>enable</ImplicitUsings>
<Nullable>enable</Nullable>
@ -42,13 +42,6 @@
<PackageReference Include="Microsoft.Extensions.Hosting.WindowsServices" Version="7.0.1" />
<PackageReference Include="Serilog.Extensions.Logging.File" Version="3.0.0" />
<!--Unix Serilog stuff-->
<PackageReference Include="System.IO.FileSystem.Primitives" Version="4.3.0" />
<PackageReference Include="System.Text.Encoding.Extensions" Version="4.3.0" />
<PackageReference Include="System.Runtime.Handles" Version="4.3.0" />
<PackageReference Include="System.IO" Version="4.3.0" />
<PackageReference Include="System.Runtime.InteropServices" Version="4.3.0" />
<PackageReference Include="System.Threading" Version="4.3.0" />
<PackageReference Include="System.Threading.Tasks" Version="4.3.0" />
<PackageReference Include="Vaitr.Bus" Version="0.1.3" />
</ItemGroup>

17
src/Server/Insight.Server/Network/AgentSession.cs → src/Server/Insight.Server/Network/Agent/AgentSession.cs
View file

@ -1,11 +1,11 @@
using Insight.Domain.Interfaces;
using Insight.Domain.Messages;
using Insight.Domain.Messages.Agent;
using Insight.Server.Network.Handlers.Agent;
using Insight.Domain.Network;
using Insight.Domain.Network.Agent.Messages;
using Insight.Server.Network.Agent.Handlers;
using Microsoft.Extensions.Logging;
using Vaitr.Network;
namespace Insight.Server.Network;
namespace Insight.Server.Network.Agent;
public class AgentSession : TcpSession<IMessage>
{
@ -56,7 +56,7 @@ public class AgentSession : TcpSession<IMessage>
{
await base.OnReceivedAsync(context, cancellationToken);
if (Id is null && context.Packet is not Authentication) return;
if (Id is null && context.Packet is not AuthenticationResponse) return;
await _agentHandler.StatisticUpdateAsync(this, cancellationToken);
@ -69,13 +69,6 @@ public class AgentSession : TcpSession<IMessage>
catch (Exception ex)
{
_logger.LogWarning("Agent ({ep?}) {ex}", RemoteEndPoint, ex.ToString());
//await _mediator.Send(new AgentLog(new AgentLogEntity
//{
// Category = CategoryEnum.Network.ToString(),
// Status = StatusEnum.Error.ToString(),
// Message = e.StackTrace
//}, this), cancellationToken).ConfigureAwait(false);
}
}
}

25
src/Server/Insight.Server/Network/Handlers/Agent/AgentHandler.cs → src/Server/Insight.Server/Network/Agent/Handlers/AgentHandler.cs
View file

@ -1,13 +1,12 @@
using Insight.Domain.Enums;
using Insight.Domain.Interfaces;
using Insight.Domain.Messages;
using Insight.Domain.Messages.Agent;
using Insight.Infrastructure;
using Insight.Domain.Network;
using Insight.Domain.Network.Agent.Messages;
using Insight.Infrastructure.Entities;
using Microsoft.Extensions.Logging;
using MongoDB.Driver;
namespace Insight.Server.Network.Handlers.Agent;
namespace Insight.Server.Network.Agent.Handlers;
public class AgentHandler : IMessageHandler<AgentSession>
{
@ -22,18 +21,18 @@ public class AgentHandler : IMessageHandler<AgentSession>
public async ValueTask HandleAsync<TMessage>(AgentSession sender, TMessage message, CancellationToken cancellationToken) where TMessage : IMessage
{
if (message is AuthenticationRequest authenticationRequest)
switch (message)
{
await AuthenticationRequestAsync(sender, authenticationRequest, cancellationToken);
}
if (message is Authentication authentication)
{
await AuthenticationAsync(sender, authentication, cancellationToken);
case AuthenticationRequest authenticationRequest:
await OnAuthenticationRequestAsync(sender, authenticationRequest, cancellationToken);
break;
case AuthenticationResponse authenticationResponse:
await OnAuthenticationResponseAsync(sender, authenticationResponse, cancellationToken);
break;
}
}
private async ValueTask AuthenticationRequestAsync(AgentSession session, AuthenticationRequest message, CancellationToken cancellationToken)
private async ValueTask OnAuthenticationRequestAsync(AgentSession session, AuthenticationRequest message, CancellationToken cancellationToken)
{
await session.SendAsync(message, cancellationToken);
@ -52,7 +51,7 @@ public class AgentHandler : IMessageHandler<AgentSession>
session.Disconnect();
}
private async ValueTask AuthenticationAsync(AgentSession session, Authentication authentication, CancellationToken cancellationToken)
private async ValueTask OnAuthenticationResponseAsync(AgentSession session, AuthenticationResponse authentication, CancellationToken cancellationToken)
{
if (authentication is null)
{

31
src/Server/Insight.Server/Network/Agent/Handlers/CustomHandler.cs Normal file
View file

@ -0,0 +1,31 @@
using Insight.Domain.Interfaces;
using Insight.Domain.Network;
using Insight.Domain.Network.Agent.Messages;
using Microsoft.Extensions.Logging;
namespace Insight.Server.Network.Agent.Handlers;
public class CustomHandler : IMessageHandler<AgentSession>
{
private readonly ILogger<CustomHandler> _logger;
public CustomHandler(ILogger<CustomHandler> logger)
{
_logger = logger;
}
public async ValueTask HandleAsync<TMessage>(AgentSession sender, TMessage message, CancellationToken cancellationToken) where TMessage : IMessage
{
switch (message)
{
case Response response:
await OnResponseAsync(sender, response, cancellationToken);
break;
}
}
private async ValueTask OnResponseAsync(AgentSession sender, Response response, CancellationToken cancellationToken)
{
_logger.LogWarning($"Response: {response.ResponseData}");
}
}

13
src/Server/Insight.Server/Network/Handlers/Agent/DriveHandler.cs → src/Server/Insight.Server/Network/Agent/Handlers/DriveHandler.cs
View file

@ -1,12 +1,11 @@
using Insight.Domain.Interfaces;
using Insight.Domain.Messages;
using Insight.Domain.Messages.Agent;
using Insight.Infrastructure;
using Insight.Domain.Network;
using Insight.Domain.Network.Agent.Messages;
using Insight.Infrastructure.Entities;
using MongoDB.Bson;
using MongoDB.Driver;
namespace Insight.Server.Network.Handlers.Agent;
namespace Insight.Server.Network.Agent.Handlers;
public class DriveHandler : IMessageHandler<AgentSession>
{
@ -19,9 +18,11 @@ public class DriveHandler : IMessageHandler<AgentSession>
public async ValueTask HandleAsync<TMessage>(AgentSession sender, TMessage message, CancellationToken cancellationToken) where TMessage : IMessage
{
if (message is DriveList drives)
switch (message)
{
await OnDrivesAsync(sender, drives, cancellationToken);
case Collection<Drive> drives:
await OnDrivesAsync(sender, drives, cancellationToken);
break;
}
}

15
src/Server/Insight.Server/Network/Handlers/Agent/EventHandler.cs → src/Server/Insight.Server/Network/Agent/Handlers/EventHandler.cs
View file

@ -1,14 +1,13 @@
using Insight.Domain.Enums;
using Insight.Domain.Interfaces;
using Insight.Domain.Messages;
using Insight.Domain.Messages.Agent;
using Insight.Infrastructure;
using Insight.Domain.Network;
using Insight.Domain.Network.Agent.Messages;
using Insight.Infrastructure.Entities;
using Microsoft.Extensions.Logging;
using MongoDB.Driver;
using static Insight.Domain.Messages.Agent.Event;
using static Insight.Domain.Network.Agent.Messages.Event;
namespace Insight.Server.Network.Handlers.Agent;
namespace Insight.Server.Network.Agent.Handlers;
public class EventHandler : IMessageHandler<AgentSession>
{
@ -23,9 +22,11 @@ public class EventHandler : IMessageHandler<AgentSession>
public async ValueTask HandleAsync<TMessage>(AgentSession sender, TMessage message, CancellationToken cancellationToken) where TMessage : IMessage
{
if (message is Event @event)
switch (message)
{
await OnEventAsync(sender, @event, cancellationToken);
case Event @event:
await OnEventAsync(sender, @event, cancellationToken);
break;
}
}

13
src/Server/Insight.Server/Network/Handlers/Agent/InterfaceHandler.cs → src/Server/Insight.Server/Network/Agent/Handlers/InterfaceHandler.cs
View file

@ -1,12 +1,11 @@
using Insight.Domain.Interfaces;
using Insight.Domain.Messages;
using Insight.Domain.Messages.Agent;
using Insight.Infrastructure;
using Insight.Domain.Network;
using Insight.Domain.Network.Agent.Messages;
using Insight.Infrastructure.Entities;
using MongoDB.Bson;
using MongoDB.Driver;
namespace Insight.Server.Network.Handlers.Agent;
namespace Insight.Server.Network.Agent.Handlers;
public class InterfaceHandler : IMessageHandler<AgentSession>
{
@ -19,9 +18,11 @@ public class InterfaceHandler : IMessageHandler<AgentSession>
public async ValueTask HandleAsync<TMessage>(AgentSession sender, TMessage message, CancellationToken cancellationToken) where TMessage : IMessage
{
if (message is InterfaceList interfaces)
switch (message)
{
await OnInterfacesAsync(sender, interfaces, cancellationToken);
case Collection<Interface> interfaces:
await OnInterfacesAsync(sender, interfaces, cancellationToken);
break;
}
}

13
src/Server/Insight.Server/Network/Handlers/Agent/MainboardHandler.cs → src/Server/Insight.Server/Network/Agent/Handlers/MainboardHandler.cs
View file

@ -1,11 +1,10 @@
using Insight.Domain.Interfaces;
using Insight.Domain.Messages;
using Insight.Domain.Messages.Agent;
using Insight.Infrastructure;
using Insight.Domain.Network;
using Insight.Domain.Network.Agent.Messages;
using Insight.Infrastructure.Entities;
using MongoDB.Driver;
namespace Insight.Server.Network.Handlers.Agent
namespace Insight.Server.Network.Agent.Handlers
{
public class MainboardHandler : IMessageHandler<AgentSession>
{
@ -18,9 +17,11 @@ namespace Insight.Server.Network.Handlers.Agent
public async ValueTask HandleAsync<TMessage>(AgentSession sender, TMessage message, CancellationToken cancellationToken) where TMessage : IMessage
{
if (message is Mainboard mainboard)
switch (message)
{
await OnMainboardAsync(sender, mainboard, cancellationToken);
case Mainboard mainboard:
await OnMainboardAsync(sender, mainboard, cancellationToken);
break;
}
}

13
src/Server/Insight.Server/Network/Handlers/Agent/MemoryHandler.cs → src/Server/Insight.Server/Network/Agent/Handlers/MemoryHandler.cs
View file

@ -1,12 +1,11 @@
using Insight.Domain.Interfaces;
using Insight.Domain.Messages;
using Insight.Domain.Messages.Agent;
using Insight.Infrastructure;
using Insight.Domain.Network;
using Insight.Domain.Network.Agent.Messages;
using Insight.Infrastructure.Entities;
using MongoDB.Bson;
using MongoDB.Driver;
namespace Insight.Server.Network.Handlers.Agent;
namespace Insight.Server.Network.Agent.Handlers;
public class MemoryHandler : IMessageHandler<AgentSession>
{
@ -19,9 +18,11 @@ public class MemoryHandler : IMessageHandler<AgentSession>
public async ValueTask HandleAsync<TMessage>(AgentSession sender, TMessage message, CancellationToken cancellationToken) where TMessage : IMessage
{
if (message is MemoryList memory)
switch (message)
{
await OnMemoryAsync(sender, memory, cancellationToken);
case Collection<Memory> memory:
await OnMemoryAsync(sender, memory, cancellationToken);
break;
}
}

13
src/Server/Insight.Server/Network/Handlers/Agent/OperationSystemHandler.cs → src/Server/Insight.Server/Network/Agent/Handlers/OperationSystemHandler.cs
View file

@ -1,11 +1,10 @@
using Insight.Domain.Interfaces;
using Insight.Domain.Messages;
using Insight.Domain.Messages.Agent;
using Insight.Infrastructure;
using Insight.Domain.Network;
using Insight.Domain.Network.Agent.Messages;
using Insight.Infrastructure.Entities;
using MongoDB.Driver;
namespace Insight.Server.Network.Handlers.Agent;
namespace Insight.Server.Network.Agent.Handlers;
public class OperationSystemHandler : IMessageHandler<AgentSession>
{
@ -18,9 +17,11 @@ public class OperationSystemHandler : IMessageHandler<AgentSession>
public async ValueTask HandleAsync<TMessage>(AgentSession sender, TMessage message, CancellationToken cancellationToken) where TMessage : IMessage
{
if (message is OperationSystem os)
switch (message)
{
await OnOperationSystemAsync(sender, os, cancellationToken);
case OperationSystem os:
await OnOperationSystemAsync(sender, os, cancellationToken);
break;
}
}

13
src/Server/Insight.Server/Network/Handlers/Agent/PrinterHandler.cs → src/Server/Insight.Server/Network/Agent/Handlers/PrinterHandler.cs
View file

@ -1,12 +1,11 @@
using Insight.Domain.Interfaces;
using Insight.Domain.Messages;
using Insight.Domain.Messages.Agent;
using Insight.Infrastructure;
using Insight.Domain.Network;
using Insight.Domain.Network.Agent.Messages;
using Insight.Infrastructure.Entities;
using MongoDB.Bson;
using MongoDB.Driver;
namespace Insight.Server.Network.Handlers.Agent;
namespace Insight.Server.Network.Agent.Handlers;
public class PrinterHandler : IMessageHandler<AgentSession>
{
@ -19,9 +18,11 @@ public class PrinterHandler : IMessageHandler<AgentSession>
public async ValueTask HandleAsync<TMessage>(AgentSession sender, TMessage message, CancellationToken cancellationToken) where TMessage : IMessage
{
if (message is PrinterList printers)
switch (message)
{
await OnPrintersAsync(sender, printers, cancellationToken);
case Collection<Printer> printers:
await OnPrintersAsync(sender, printers, cancellationToken);
break;
}
}

13
src/Server/Insight.Server/Network/Handlers/Agent/ProcessorHandler.cs → src/Server/Insight.Server/Network/Agent/Handlers/ProcessorHandler.cs
View file

@ -1,12 +1,11 @@
using Insight.Domain.Interfaces;
using Insight.Domain.Messages;
using Insight.Domain.Messages.Agent;
using Insight.Infrastructure;
using Insight.Domain.Network;
using Insight.Domain.Network.Agent.Messages;
using Insight.Infrastructure.Entities;
using MongoDB.Bson;
using MongoDB.Driver;
namespace Insight.Server.Network.Handlers.Agent;
namespace Insight.Server.Network.Agent.Handlers;
public class ProcessorHandler : IMessageHandler<AgentSession>
{
@ -19,9 +18,11 @@ public class ProcessorHandler : IMessageHandler<AgentSession>
public async ValueTask HandleAsync<TMessage>(AgentSession sender, TMessage message, CancellationToken cancellationToken) where TMessage : IMessage
{
if (message is ProcessorList processors)
switch (message)
{
await OnProcessorsAsync(sender, processors, cancellationToken);
case Collection<Processor> processors:
await OnProcessorsAsync(sender, processors, cancellationToken);
break;
}
}

13
src/Server/Insight.Server/Network/Handlers/Agent/ServiceHandler.cs → src/Server/Insight.Server/Network/Agent/Handlers/ServiceHandler.cs
View file

@ -1,12 +1,11 @@
using Insight.Domain.Interfaces;
using Insight.Domain.Messages;
using Insight.Domain.Messages.Agent;
using Insight.Infrastructure;
using Insight.Domain.Network;
using Insight.Domain.Network.Agent.Messages;
using Insight.Infrastructure.Entities;
using MongoDB.Bson;
using MongoDB.Driver;
namespace Insight.Server.Network.Handlers.Agent;
namespace Insight.Server.Network.Agent.Handlers;
public class ServiceHandler : IMessageHandler<AgentSession>
{
@ -19,9 +18,11 @@ public class ServiceHandler : IMessageHandler<AgentSession>
public async ValueTask HandleAsync<TMessage>(AgentSession sender, TMessage message, CancellationToken cancellationToken) where TMessage : IMessage
{
if (message is ServiceList services)
switch (message)
{
await OnServicesAsync(sender, services, cancellationToken);
case Collection<Service> services:
await OnServicesAsync(sender, services, cancellationToken);
break;
}
}

13
src/Server/Insight.Server/Network/Handlers/Agent/SessionHandler.cs → src/Server/Insight.Server/Network/Agent/Handlers/SessionHandler.cs
View file

@ -1,12 +1,11 @@
using Insight.Domain.Interfaces;
using Insight.Domain.Messages;
using Insight.Domain.Messages.Agent;
using Insight.Infrastructure;
using Insight.Domain.Network;
using Insight.Domain.Network.Agent.Messages;
using Insight.Infrastructure.Entities;
using MongoDB.Bson;
using MongoDB.Driver;
namespace Insight.Server.Network.Handlers.Agent;
namespace Insight.Server.Network.Agent.Handlers;
public class SessionHandler : IMessageHandler<AgentSession>
{
@ -19,9 +18,11 @@ public class SessionHandler : IMessageHandler<AgentSession>
public async ValueTask HandleAsync<TMessage>(AgentSession sender, TMessage message, CancellationToken cancellationToken) where TMessage : IMessage
{
if (message is SessionList sessions)
switch (message)
{
await OnSessionsAsync(sender, sessions, cancellationToken);
case Collection<Session> sessions:
await OnSessionsAsync(sender, sessions, cancellationToken);
break;
}
}

13
src/Server/Insight.Server/Network/Handlers/Agent/SoftwareHandler.cs → src/Server/Insight.Server/Network/Agent/Handlers/SoftwareHandler.cs
View file

@ -1,12 +1,11 @@
using Insight.Domain.Interfaces;
using Insight.Domain.Messages;
using Insight.Domain.Messages.Agent;
using Insight.Infrastructure;
using Insight.Domain.Network;
using Insight.Domain.Network.Agent.Messages;
using Insight.Infrastructure.Entities;
using MongoDB.Bson;
using MongoDB.Driver;
namespace Insight.Server.Network.Handlers.Agent;
namespace Insight.Server.Network.Agent.Handlers;
public class SoftwareHandler : IMessageHandler<AgentSession>
{
@ -19,9 +18,11 @@ public class SoftwareHandler : IMessageHandler<AgentSession>
public async ValueTask HandleAsync<TMessage>(AgentSession sender, TMessage message, CancellationToken cancellationToken) where TMessage : IMessage
{
if (message is ApplicationList applications)
switch (message)
{
await OnApplicationsAsync(sender, applications, cancellationToken);
case Collection<Application> applications:
await OnApplicationsAsync(sender, applications, cancellationToken);
break;
}
}

13
src/Server/Insight.Server/Network/Handlers/Agent/StoragePoolHandler.cs → src/Server/Insight.Server/Network/Agent/Handlers/StoragePoolHandler.cs
View file

@ -1,12 +1,11 @@
using Insight.Domain.Interfaces;
using Insight.Domain.Messages;
using Insight.Domain.Messages.Agent;
using Insight.Infrastructure;
using Insight.Domain.Network;
using Insight.Domain.Network.Agent.Messages;
using Insight.Infrastructure.Entities;
using MongoDB.Bson;
using MongoDB.Driver;
namespace Insight.Server.Network.Handlers.Agent;
namespace Insight.Server.Network.Agent.Handlers;
public class StoragePoolHandler : IMessageHandler<AgentSession>
{
@ -19,9 +18,11 @@ public class StoragePoolHandler : IMessageHandler<AgentSession>
public async ValueTask HandleAsync<TMessage>(AgentSession sender, TMessage message, CancellationToken cancellationToken) where TMessage : IMessage
{
if (message is StoragePoolList storagePools)
switch (message)
{
await OnStoragePoolsAsync(sender, storagePools, cancellationToken);
case Collection<StoragePool> storagePools:
await OnStoragePoolsAsync(sender, storagePools, cancellationToken);
break;
}
}

13
src/Server/Insight.Server/Network/Handlers/Agent/SystemInfoHandler.cs → src/Server/Insight.Server/Network/Agent/Handlers/SystemInfoHandler.cs
View file

@ -1,11 +1,10 @@
using Insight.Domain.Interfaces;
using Insight.Domain.Messages;
using Insight.Domain.Messages.Agent;
using Insight.Infrastructure;
using Insight.Domain.Network;
using Insight.Domain.Network.Agent.Messages;
using Insight.Infrastructure.Entities;
using MongoDB.Driver;
namespace Insight.Server.Network.Handlers.Agent;
namespace Insight.Server.Network.Agent.Handlers;
public class SystemInfoHandler : IMessageHandler<AgentSession>
{
@ -18,9 +17,11 @@ public class SystemInfoHandler : IMessageHandler<AgentSession>
public async ValueTask HandleAsync<TMessage>(AgentSession sender, TMessage message, CancellationToken cancellationToken) where TMessage : IMessage
{
if (message is SystemInfo systemInfo)
switch (message)
{
await OnSystemInfoAsync(sender, systemInfo, cancellationToken);
case SystemInfo systemInfo:
await OnSystemInfoAsync(sender, systemInfo, cancellationToken);
break;
}
}

13
src/Server/Insight.Server/Network/Handlers/Agent/TrapHandler.cs → src/Server/Insight.Server/Network/Agent/Handlers/TrapHandler.cs
View file

@ -1,8 +1,7 @@
using Insight.Domain.Enums;
using Insight.Domain.Interfaces;
using Insight.Domain.Messages;
using Insight.Domain.Messages.Agent;
using Insight.Infrastructure;
using Insight.Domain.Network;
using Insight.Domain.Network.Agent.Messages;
using Insight.Infrastructure.Entities;
using Insight.Server.Models;
using MongoDB.Driver;
@ -10,7 +9,7 @@ using System.Text;
using System.Text.RegularExpressions;
using static Insight.Server.Models.MonitorMessage;
namespace Insight.Server.Network.Handlers.Agent;
namespace Insight.Server.Network.Agent.Handlers;
public class TrapHandler : IMessageHandler<AgentSession>
{
@ -23,9 +22,11 @@ public class TrapHandler : IMessageHandler<AgentSession>
public async ValueTask HandleAsync<TMessage>(AgentSession sender, TMessage message, CancellationToken cancellationToken) where TMessage : IMessage
{
if (message is Trap trap)
switch (message)
{
await OnTrapAsync(sender, trap, cancellationToken);
case Trap trap:
await OnTrapAsync(sender, trap, cancellationToken);
break;
}
}

15
src/Server/Insight.Server/Network/Handlers/Agent/UpdateHandler.cs → src/Server/Insight.Server/Network/Agent/Handlers/UpdateHandler.cs
View file

@ -1,12 +1,11 @@
using Insight.Domain.Interfaces;
using Insight.Domain.Messages;
using Insight.Domain.Messages.Agent;
using Insight.Infrastructure;
using Insight.Domain.Network;
using Insight.Domain.Network.Agent.Messages;
using Insight.Infrastructure.Entities;
using MongoDB.Bson;
using MongoDB.Driver;
namespace Insight.Server.Network.Handlers.Agent;
namespace Insight.Server.Network.Agent.Handlers;
public class UpdateHandler : IMessageHandler<AgentSession>
{
@ -19,13 +18,15 @@ public class UpdateHandler : IMessageHandler<AgentSession>
public async ValueTask HandleAsync<TMessage>(AgentSession sender, TMessage message, CancellationToken cancellationToken) where TMessage : IMessage
{
if (message is UpdateList updates)
switch (message)
{
await OnUpdatesAsync(sender, updates, cancellationToken);
case UpdateCollection updates:
await OnUpdatesAsync(sender, updates, cancellationToken);
break;
}
}
private async ValueTask OnUpdatesAsync(AgentSession session, UpdateList updates, CancellationToken cancellationToken)
private async ValueTask OnUpdatesAsync(AgentSession session, UpdateCollection updates, CancellationToken cancellationToken)
{
var agentEntity = await _database.Agent().Find(Builders<AgentEntity>.Filter.Eq(p => p.Id, session.Id)).FirstOrDefaultAsync(cancellationToken);
if (agentEntity is null) return;

73
src/Server/Insight.Server/Network/Handlers/Agent/UserHandler.cs → src/Server/Insight.Server/Network/Agent/Handlers/UserHandler.cs
View file

@ -1,12 +1,11 @@
using Insight.Domain.Interfaces;
using Insight.Domain.Messages;
using Insight.Domain.Messages.Agent;
using Insight.Infrastructure;
using Insight.Domain.Network;
using Insight.Domain.Network.Agent.Messages;
using Insight.Infrastructure.Entities;
using MongoDB.Bson;
using MongoDB.Driver;
namespace Insight.Server.Network.Handlers.Agent;
namespace Insight.Server.Network.Agent.Handlers;
public class UserHandler : IMessageHandler<AgentSession>
{
@ -19,9 +18,11 @@ public class UserHandler : IMessageHandler<AgentSession>
public async ValueTask HandleAsync<TMessage>(AgentSession sender, TMessage message, CancellationToken cancellationToken) where TMessage : IMessage
{
if (message is UserList users)
switch (message)
{
await OnUsersAsync(sender, users, cancellationToken);
case Collection<User> users:
await OnUsersAsync(sender, users, cancellationToken);
break;
}
}
@ -40,18 +41,18 @@ public class UserHandler : IMessageHandler<AgentSession>
if (users is not null && users.Any())
{
var userBulk = new List<WriteModel<HostUserEntity>>();
var userBulk = new List<WriteModel<HostSysUserEntity>>();
foreach (var user in users)
{
var userFilter = Builders<HostUserEntity>.Filter.And(new List<FilterDefinition<HostUserEntity>>
var userFilter = Builders<HostSysUserEntity>.Filter.And(new List<FilterDefinition<HostSysUserEntity>>
{
Builders<HostUserEntity>.Filter.Eq(x => x.Host, hostEntity.Id),
Builders<HostUserEntity>.Filter.Eq(x => x.Domain, user?.Domain),
Builders<HostUserEntity>.Filter.Eq(x => x.Name, user?.Name)
Builders<HostSysUserEntity>.Filter.Eq(x => x.Host, hostEntity.Id),
Builders<HostSysUserEntity>.Filter.Eq(x => x.Domain, user?.Domain),
Builders<HostSysUserEntity>.Filter.Eq(x => x.Name, user?.Name)
});
var userUpdate = Builders<HostUserEntity>.Update
var userUpdate = Builders<HostSysUserEntity>.Update
.SetOnInsert(p => p.Insert, date)
.SetOnInsert(p => p.Host, hostEntity.Id)
.SetOnInsert(p => p.Domain, user?.Domain)
@ -70,16 +71,16 @@ public class UserHandler : IMessageHandler<AgentSession>
.Set(p => p.PasswordExpires, user?.PasswordExpires)
.Set(p => p.PasswordRequired, user?.PasswordRequired);
userBulk.Add(new UpdateOneModel<HostUserEntity>(userFilter, userUpdate)
userBulk.Add(new UpdateOneModel<HostSysUserEntity>(userFilter, userUpdate)
{
IsUpsert = true
});
}
userBulk.Add(new DeleteManyModel<HostUserEntity>(Builders<HostUserEntity>.Filter.And(new List<FilterDefinition<HostUserEntity>>
userBulk.Add(new DeleteManyModel<HostSysUserEntity>(Builders<HostSysUserEntity>.Filter.And(new List<FilterDefinition<HostSysUserEntity>>
{
Builders<HostUserEntity>.Filter.Eq(x => x.Host, hostEntity.Id),
Builders<HostUserEntity>.Filter.Ne(x => x.Batch, batch)
Builders<HostSysUserEntity>.Filter.Eq(x => x.Host, hostEntity.Id),
Builders<HostSysUserEntity>.Filter.Ne(x => x.Batch, batch)
})));
var userResult = await _database.HostSystemUser().BulkWriteAsync(userBulk, cancellationToken: cancellationToken);
@ -89,7 +90,7 @@ public class UserHandler : IMessageHandler<AgentSession>
if (users is not null && users.Any())
{
var groupBulk = new List<WriteModel<HostGroupEntity>>();
var groupBulk = new List<WriteModel<HostSysGroupEntity>>();
var distinctGroups = users.SelectMany(p => p.Groups)
.GroupBy(p => new { p?.Domain, p?.Name })
@ -97,14 +98,14 @@ public class UserHandler : IMessageHandler<AgentSession>
foreach (var group in distinctGroups)
{
var groupFilter = Builders<HostGroupEntity>.Filter.And(new List<FilterDefinition<HostGroupEntity>>
var groupFilter = Builders<HostSysGroupEntity>.Filter.And(new List<FilterDefinition<HostSysGroupEntity>>
{
Builders<HostGroupEntity>.Filter.Eq(x => x.Host, hostEntity.Id),
Builders<HostGroupEntity>.Filter.Eq(x => x.Domain, group?.Domain),
Builders<HostGroupEntity>.Filter.Eq(x => x.Name, group?.Name)
Builders<HostSysGroupEntity>.Filter.Eq(x => x.Host, hostEntity.Id),
Builders<HostSysGroupEntity>.Filter.Eq(x => x.Domain, group?.Domain),
Builders<HostSysGroupEntity>.Filter.Eq(x => x.Name, group?.Name)
});
var groupUpdate = Builders<HostGroupEntity>.Update
var groupUpdate = Builders<HostSysGroupEntity>.Update
.SetOnInsert(p => p.Insert, date)
.SetOnInsert(p => p.Host, hostEntity.Id)
.SetOnInsert(p => p.Domain, group?.Domain)
@ -116,16 +117,16 @@ public class UserHandler : IMessageHandler<AgentSession>
.Set(p => p.Description, group?.Description)
.Set(p => p.LocalAccount, group?.LocalAccount);
groupBulk.Add(new UpdateOneModel<HostGroupEntity>(groupFilter, groupUpdate)
groupBulk.Add(new UpdateOneModel<HostSysGroupEntity>(groupFilter, groupUpdate)
{
IsUpsert = true
});
}
groupBulk.Add(new DeleteManyModel<HostGroupEntity>(Builders<HostGroupEntity>.Filter.And(new List<FilterDefinition<HostGroupEntity>>
groupBulk.Add(new DeleteManyModel<HostSysGroupEntity>(Builders<HostSysGroupEntity>.Filter.And(new List<FilterDefinition<HostSysGroupEntity>>
{
Builders<HostGroupEntity>.Filter.Eq(x => x.Host, hostEntity.Id),
Builders<HostGroupEntity>.Filter.Ne(x => x.Batch, batch)
Builders<HostSysGroupEntity>.Filter.Eq(x => x.Host, hostEntity.Id),
Builders<HostSysGroupEntity>.Filter.Ne(x => x.Batch, batch)
})));
var groupResult = await _database.HostSystemGroup().BulkWriteAsync(groupBulk, cancellationToken: cancellationToken);
@ -135,7 +136,7 @@ public class UserHandler : IMessageHandler<AgentSession>
if (users is not null && users.Any())
{
var relationBulk = new List<WriteModel<HostUserGroupEntity>>();
var relationBulk = new List<WriteModel<HostSysUserSysGroupEntity>>();
foreach (var user in users)
{
@ -153,14 +154,14 @@ public class UserHandler : IMessageHandler<AgentSession>
.Project(p => p.Id)
.FirstOrDefaultAsync();
var relationFilter = Builders<HostUserGroupEntity>.Filter.And(new List<FilterDefinition<HostUserGroupEntity>>
var relationFilter = Builders<HostSysUserSysGroupEntity>.Filter.And(new List<FilterDefinition<HostSysUserSysGroupEntity>>
{
Builders<HostUserGroupEntity>.Filter.Eq(x => x.Host, hostEntity.Id),
Builders<HostUserGroupEntity>.Filter.Eq(x => x.User, userId),
Builders<HostUserGroupEntity>.Filter.Eq(x => x.Group, groupId)
Builders<HostSysUserSysGroupEntity>.Filter.Eq(x => x.Host, hostEntity.Id),
Builders<HostSysUserSysGroupEntity>.Filter.Eq(x => x.User, userId),
Builders<HostSysUserSysGroupEntity>.Filter.Eq(x => x.Group, groupId)
});
var relationUpdate = Builders<HostUserGroupEntity>.Update
var relationUpdate = Builders<HostSysUserSysGroupEntity>.Update
.SetOnInsert(p => p.Insert, date)
.SetOnInsert(p => p.Host, hostEntity.Id)
.SetOnInsert(p => p.User, userId)
@ -168,7 +169,7 @@ public class UserHandler : IMessageHandler<AgentSession>
.Set(p => p.Update, date)
.Set(p => p.Batch, batch);
relationBulk.Add(new UpdateOneModel<HostUserGroupEntity>(relationFilter, relationUpdate)
relationBulk.Add(new UpdateOneModel<HostSysUserSysGroupEntity>(relationFilter, relationUpdate)
{
IsUpsert = true
});
@ -176,10 +177,10 @@ public class UserHandler : IMessageHandler<AgentSession>
}
}
relationBulk.Add(new DeleteManyModel<HostUserGroupEntity>(Builders<HostUserGroupEntity>.Filter.And(new List<FilterDefinition<HostUserGroupEntity>>
relationBulk.Add(new DeleteManyModel<HostSysUserSysGroupEntity>(Builders<HostSysUserSysGroupEntity>.Filter.And(new List<FilterDefinition<HostSysUserSysGroupEntity>>
{
Builders<HostUserGroupEntity>.Filter.Eq(x => x.Host, hostEntity.Id),
Builders<HostUserGroupEntity>.Filter.Ne(x => x.Batch, batch)
Builders<HostSysUserSysGroupEntity>.Filter.Eq(x => x.Host, hostEntity.Id),
Builders<HostSysUserSysGroupEntity>.Filter.Ne(x => x.Batch, batch)
})));
var relationResult = await _database.HostSystemUserSystemGroup().BulkWriteAsync(relationBulk, cancellationToken: cancellationToken);

13
src/Server/Insight.Server/Network/Handlers/Agent/VideocardHandler.cs → src/Server/Insight.Server/Network/Agent/Handlers/VideocardHandler.cs
View file

@ -1,12 +1,11 @@
using Insight.Domain.Interfaces;
using Insight.Domain.Messages;
using Insight.Domain.Messages.Agent;
using Insight.Infrastructure;
using Insight.Domain.Network;
using Insight.Domain.Network.Agent.Messages;
using Insight.Infrastructure.Entities;
using MongoDB.Bson;
using MongoDB.Driver;
namespace Insight.Server.Network.Handlers.Agent;
namespace Insight.Server.Network.Agent.Handlers;
public class VideocardHandler : IMessageHandler<AgentSession>
{
@ -19,9 +18,11 @@ public class VideocardHandler : IMessageHandler<AgentSession>
public async ValueTask HandleAsync<TMessage>(AgentSession sender, TMessage message, CancellationToken cancellationToken) where TMessage : IMessage
{
if (message is VideocardList videocards)
switch (message)
{
await OnVideocardsAsync(sender, videocards, cancellationToken);
case Collection<Videocard> videocards:
await OnVideocardsAsync(sender, videocards, cancellationToken);
break;
}
}

13
src/Server/Insight.Server/Network/Handlers/Agent/VirtualMaschineHandler.cs → src/Server/Insight.Server/Network/Agent/Handlers/VirtualMaschineHandler.cs
View file

@ -1,12 +1,11 @@
using Insight.Domain.Interfaces;
using Insight.Domain.Messages;
using Insight.Domain.Messages.Agent;
using Insight.Infrastructure;
using Insight.Domain.Network;
using Insight.Domain.Network.Agent.Messages;
using Insight.Infrastructure.Entities;
using MongoDB.Bson;
using MongoDB.Driver;
namespace Insight.Server.Network.Handlers.Agent;
namespace Insight.Server.Network.Agent.Handlers;
public class VirtualMaschineHandler : IMessageHandler<AgentSession>
{
@ -19,9 +18,11 @@ public class VirtualMaschineHandler : IMessageHandler<AgentSession>
public async ValueTask HandleAsync<TMessage>(AgentSession sender, TMessage message, CancellationToken cancellationToken) where TMessage : IMessage
{
if (message is VirtualMaschineList virtualMaschines)
switch (message)
{
await OnVirtualMaschinesAsync(sender, virtualMaschines, cancellationToken);
case Collection<VirtualMaschine> virtualMaschines:
await OnVirtualMaschinesAsync(sender, virtualMaschines, cancellationToken);
break;
}
}

41
src/Server/Insight.Server/Network/Handlers/Agent/ConsoleHandler.cs
View file

@ -1,41 +0,0 @@
using Insight.Domain.Interfaces;
using Insight.Domain.Messages;
using Insight.Domain.Messages.Agent;
using Microsoft.Extensions.Logging;
using MongoDB.Driver;
using Vaitr.Network;
namespace Insight.Server.Network.Handlers.Agent;
public class ConsoleHandler : IMessageHandler<AgentSession>
{
private readonly ISessionPool<WebSession, IMessage> _webPool;
private readonly IMongoDatabase _database;
private readonly ILogger<ConsoleHandler> _logger;
public ConsoleHandler(
ISessionPool<WebSession, IMessage> webPool,
IMongoDatabase database,
ILogger<ConsoleHandler> logger)
{
_webPool = webPool;
_database = database;
_logger = logger;
}
public async ValueTask HandleAsync<TMessage>(AgentSession sender, TMessage message, CancellationToken cancellationToken) where TMessage : IMessage
{
if (message is Proxy<ConsoleQuery> consoleResponse)
{
await OnConsoleQueryAsync(sender, consoleResponse, cancellationToken);
}
}
private async ValueTask OnConsoleQueryAsync(AgentSession session, Proxy<ConsoleQuery> consoleResponse, CancellationToken cancellationToken)
{
// check if web online
if (_webPool.FirstOrDefault().Value is not WebSession web) return;
await web.SendAsync(consoleResponse, cancellationToken);
}
}

111
src/Server/Insight.Server/Network/Remote/Handlers/RemoteHandler.cs Normal file
View file

@ -0,0 +1,111 @@
using Insight.Domain.Interfaces;
using Insight.Domain.Network;
using Insight.Domain.Network.Remote.Messages;
using Microsoft.Extensions.Logging;
using Vaitr.Bus;
using Vaitr.Network;
namespace Insight.Server.Network.Remote.Handlers;
public class RemoteHandler : IMessageHandler<RemoteSession>
{
private readonly Bus _bus;
private readonly ISessionPool<RemoteSession, IMessage> _remotePool;
private readonly ILogger<RemoteHandler> _logger;
public RemoteHandler(Bus bus, ISessionPool<RemoteSession, IMessage> remotePool, ILogger<RemoteHandler> logger)
{
_bus = bus;
_remotePool = remotePool;
_logger = logger;
}
public async ValueTask HandleAsync<TMessage>(RemoteSession sender, TMessage message, CancellationToken cancellationToken) where TMessage : IMessage
{
if (message is RemoteSessionRequest sessionRequest)
{
await OnSessionRequest(sender, sessionRequest, cancellationToken);
}
else if (message is CastRequestResponse castRequestResponse)
{
await OnCastRequestResponse(sender, castRequestResponse, cancellationToken);
}
else if (message is CastMetric metricData)
{
await OnMetricData(sender, metricData, cancellationToken);
}
else if (message is CastScreen screenData)
{
await OnScreenData(sender, screenData, cancellationToken);
}
else if (message is CastCursor cursorData)
{
await OnCursorData(sender, cursorData, cancellationToken);
}
else if (message is CastClipboardReceived clipboardData)
{
await OnClipboardData(sender, clipboardData, cancellationToken);
}
else if (message is CastAudio audioData)
{
await OnAudioData(sender, audioData, cancellationToken);
}
}
private async Task OnSessionRequest(RemoteSession session, RemoteSessionRequest sessionRequest, CancellationToken cancellationToken)
{
_logger.LogInformation($"Remote {session.Id} => SessionRequest");
session.Mode = sessionRequest.Mode;
await session.SendAsync(new RemoteSessionResponse
{
SessionId = session.Id
}, cancellationToken);
}
private async Task OnCastRequestResponse(RemoteSession session, CastRequestResponse castRequestResponse, CancellationToken cancellationToken)
{
await _bus.PublishAsync(castRequestResponse, cancellationToken);
}
private async Task OnMetricData(RemoteSession session, CastMetric streamMetrics, CancellationToken cancellationToken)
{
//_logger.LogInformation($"Remote {session.Id} => MetricData");
await _bus.PublishAsync(streamMetrics, cancellationToken);
}
private async Task OnScreenData(RemoteSession session, CastScreen screenData, CancellationToken cancellationToken)
{
//_logger.LogInformation($"Remote {session.Id} => ScreenData");
await _bus.PublishAsync(screenData, cancellationToken);
await session.SendAsync(new CastScreenReceived
{
Timestamp = screenData.Timestamp
}, cancellationToken);
}
private async Task OnCursorData(RemoteSession session, CastCursor cursorChanged, CancellationToken cancellationToken)
{
//_logger.LogInformation($"Remote {session.Id} => CursorData");
await _bus.PublishAsync(cursorChanged, cancellationToken);
}
private async Task OnClipboardData(RemoteSession session, CastClipboardReceived clipboardChanged, CancellationToken cancellationToken)
{
_logger.LogInformation($"Remote {session.Id} => ClipboardData");
await _bus.PublishAsync(clipboardChanged, cancellationToken);
}
private async Task OnAudioData(RemoteSession session, CastAudio audioSample, CancellationToken cancellationToken)
{
_logger.LogInformation($"Remote {session.Id} => AudioData");
await _bus.PublishAsync(audioSample, cancellationToken);
}
}

92
src/Server/Insight.Server/Network/Remote/RemoteSession.cs Normal file
View file

@ -0,0 +1,92 @@
using Insight.Domain.Enums;
using Insight.Domain.Interfaces;
using Insight.Domain.Network;
using Insight.Server.Network.Web;
using Microsoft.Extensions.Logging;
using Vaitr.Bus;
using Vaitr.Network;
namespace Insight.Server.Network.Remote;
public class RemoteSession : TcpSession<IMessage>
{
public string Id { get; }
public RemoteControlMode Mode { get; set; }
private readonly Bus _bus;
private readonly ISessionPool<WebSession, IMessage> _webPool;
private readonly IEnumerable<IMessageHandler<RemoteSession>> _handlers;
public RemoteSession(
ISessionPool<WebSession, IMessage> webPool,
IEnumerable<IMessageHandler<RemoteSession>> handlers,
ISerializer<IMessage> serializer,
ILogger<RemoteSession> logger) : base(serializer, logger)
{
Id = GenerateRandomId();
_webPool = webPool;
_handlers = handlers;
}
public async ValueTask ProxyAsync<TMessage>(TMessage message, CancellationToken cancellationToken)
where TMessage : IMessage
{
// check if web online
if (_webPool.FirstOrDefault().Value is not WebSession web) return;
// proxy-send request packet to web
await web.SendAsync(new Proxy<TMessage>
{
Message = message
}, cancellationToken);
}
protected override async ValueTask OnConnectedAsync(CancellationToken cancellationToken)
{
_logger.LogInformation("Remote ({ep?}) connected", RemoteEndPoint);
if (_webPool.FirstOrDefault().Value is not WebSession webSession) return;
}
protected override async ValueTask OnDisconnectedAsync(CancellationToken cancellationToken)
{
_logger.LogInformation("Remote ({ep?}) disconnected", RemoteEndPoint);
}
protected override async ValueTask OnSentAsync(IPacketContext<IMessage> context, CancellationToken cancellationToken)
{
await base.OnSentAsync(context, cancellationToken);
}
protected override async ValueTask OnReceivedAsync(IPacketContext<IMessage> context, CancellationToken cancellationToken)
{
await base.OnReceivedAsync(context, cancellationToken);
foreach (var handler in _handlers)
{
try
{
await handler.HandleAsync(this, context.Packet, cancellationToken);
}
catch (Exception ex)
{
_logger.LogWarning("Remote ({ep?}) {ex}", RemoteEndPoint, ex.ToString());
}
}
}
protected override async ValueTask OnHeartbeatAsync(CancellationToken cancellationToken)
{
_logger.LogInformation("Remote ({ep?}) Heartbeat", RemoteEndPoint);
}
private static string GenerateRandomId()
{
var random = new Random();
string? sessionId = string.Empty;
for (var i = 0; i < 3; i++) sessionId += random.Next(0, 999).ToString().PadLeft(3, '0');
return sessionId;
}
}

52
src/Server/Insight.Server/Network/Handlers/Web/ConsoleProxyHandler.cs → src/Server/Insight.Server/Network/Shared/ProxyHandler.cs
View file

@ -1,55 +1,61 @@
using Insight.Domain.Interfaces;
using Insight.Domain.Messages;
using Insight.Domain.Messages.Agent;
using Insight.Infrastructure;
using Insight.Domain.Network;
using Insight.Domain.Network.Agent.Messages;
using Insight.Infrastructure.Entities;
using Insight.Server.Network.Agent;
using Insight.Server.Network.Web;
using Microsoft.Extensions.Logging;
using MongoDB.Driver;
using Vaitr.Bus;
using Vaitr.Network;
namespace Insight.Server.Network.Handlers.Web;
namespace Insight.Server.Network.Globals;
public class ConsoleProxyHandler : IMessageHandler<WebSession>
public class ProxyHandler : IMessageHandler<AgentSession>, IMessageHandler<WebSession>
{
private readonly List<IDisposable> _subscriptions = new();
private readonly ISessionPool<AgentSession, IMessage> _agentPool;
private readonly ISessionPool<WebSession, IMessage> _webPool;
private readonly IMongoDatabase _database;
private readonly Bus _bus;
private readonly ILogger<ConsoleProxyHandler> _logger;
private readonly ILogger<ProxyHandler> _logger;
public ConsoleProxyHandler(
public ProxyHandler(
ISessionPool<AgentSession, IMessage> agentPool,
ISessionPool<WebSession, IMessage> webPool,
IMongoDatabase database,
Bus bus,
ILogger<ConsoleProxyHandler> logger)
ILogger<ProxyHandler> logger)
{
_agentPool = agentPool;
_webPool = webPool;
_database = database;
_bus = bus;
_logger = logger;
}
public async ValueTask HandleAsync<TMessage>(WebSession sender, TMessage message, CancellationToken cancellationToken) where TMessage : IMessage
{
if (message is Proxy<ConsoleQueryRequest> consoleRequest)
switch (message)
{
_logger.LogCritical("received: {0}" + consoleRequest.Message);
await OnConsoleQueryRequestAsync(sender, consoleRequest, cancellationToken);
case Proxy<Request> proxyRequest:
await OnProxyRequestAsync(sender, proxyRequest, cancellationToken);
break;
}
}
private async ValueTask OnConsoleQueryRequestAsync(WebSession session, Proxy<ConsoleQueryRequest> request, CancellationToken cancellationToken)
public async ValueTask HandleAsync<TMessage>(AgentSession sender, TMessage message, CancellationToken cancellationToken) where TMessage : IMessage
{
switch (message)
{
case Proxy<Response> proxyResponse:
await OnProxyResponseAsync(sender, proxyResponse, cancellationToken);
break;
}
}
private async ValueTask OnProxyRequestAsync(WebSession session, Proxy<Request> request, CancellationToken cancellationToken)
{
// get host
var hostEntity = await _database.Host()
.Find(Builders<HostEntity>
.Filter
.Eq(p => p.Id, request.HostId))
.Eq(p => p.Id, request.ProxyId))
.FirstOrDefaultAsync(cancellationToken);
if (hostEntity is null)
@ -77,4 +83,12 @@ public class ConsoleProxyHandler : IMessageHandler<WebSession>
// proxy-send request packet to agent
await agent.SendAsync(request, cancellationToken);
}
private async ValueTask OnProxyResponseAsync(AgentSession session, Proxy<Response> response, CancellationToken cancellationToken)
{
// check if web online
if (_webPool.FirstOrDefault().Value is not WebSession web) return;
await web.SendAsync(response, cancellationToken);
}
}

4
src/Server/Insight.Server/Network/WebSession.cs → src/Server/Insight.Server/Network/Web/WebSession.cs
View file

@ -1,9 +1,9 @@
using Insight.Domain.Interfaces;
using Insight.Domain.Messages;
using Insight.Domain.Network;
using Microsoft.Extensions.Logging;
using Vaitr.Network;
namespace Insight.Server.Network;
namespace Insight.Server.Network.Web;
public class WebSession : TcpSession<IMessage>
{

153
src/Server/Insight.Server/Program.cs
View file

@ -1,11 +1,12 @@
using Insight.Domain.Constants;
using Insight.Domain.Interfaces;
using Insight.Domain.Messages;
using Insight.Domain.Network;
using Insight.Infrastructure;
using Insight.Server.Extensions;
using Insight.Server.Network;
using Insight.Server.Network.Handlers.Agent;
using Insight.Server.Network.Handlers.Web;
using Insight.Server.Network.Agent;
using Insight.Server.Network.Agent.Handlers;
using Insight.Server.Network.Globals;
using Insight.Server.Network.Web;
using Insight.Server.Services;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
@ -48,74 +49,16 @@ internal class Program
builder.ConfigureServices((host, services) =>
{
//var databaseLoggerFactory = LoggerFactory.Create(b =>
//{
// b.AddSimpleConsole();
// b.SetMinimumLevel(LogLevel.Debug);
//});
// AGENT
services.AddAgentServices(host.Configuration);
// WEB
services.AddWebServices(host.Configuration);
// INFRASTRUCTURE
services.AddDatabase(host.Configuration);
// AGENT SERVER
services.UseHostedServer<AgentSession, IMessage>(options =>
{
options.Address = IPAddress.Any;
options.Port = host.Configuration.GetValue<int?>(Appsettings.AgentServerPort) ?? throw new Exception($"{Appsettings.AgentServerPort} value not set (appsettings)");
options.Keepalive = 10000;
options.Timeout = 30000;
options.Backlog = 128;
options.Compression = true;
options.Encryption = Encryption.Tls12;
options.Certificate = host.Configuration.GetValue<string?>(Appsettings.AgentServerCertificate) ?? throw new Exception($"{Appsettings.AgentServerCertificate} value not set (appsettings)");
options.CertificatePassword = host.Configuration.GetValue<string?>(Appsettings.AgentServerCertificatePassword) ?? throw new Exception($"{Appsettings.AgentServerCertificatePassword} value not set (appsettings)");
options.UseSerializer<MemPackSerializer<IMessage>, IMessage>();
});
services.AddSingleton<AgentHandler>();
services.AddSingleton<IMessageHandler<AgentSession>, AgentHandler>();
services.AddSingleton<IMessageHandler<AgentSession>, DriveHandler>();
services.AddSingleton<IMessageHandler<AgentSession>, Network.Handlers.Agent.EventHandler>();
services.AddSingleton<IMessageHandler<AgentSession>, InterfaceHandler>();
services.AddSingleton<IMessageHandler<AgentSession>, MainboardHandler>();
services.AddSingleton<IMessageHandler<AgentSession>, MemoryHandler>();
services.AddSingleton<IMessageHandler<AgentSession>, OperationSystemHandler>();
services.AddSingleton<IMessageHandler<AgentSession>, PrinterHandler>();
services.AddSingleton<IMessageHandler<AgentSession>, ProcessorHandler>();
services.AddSingleton<IMessageHandler<AgentSession>, ServiceHandler>();
services.AddSingleton<IMessageHandler<AgentSession>, SessionHandler>();
services.AddSingleton<IMessageHandler<AgentSession>, SoftwareHandler>();
services.AddSingleton<IMessageHandler<AgentSession>, StoragePoolHandler>();
services.AddSingleton<IMessageHandler<AgentSession>, SystemInfoHandler>();
services.AddSingleton<IMessageHandler<AgentSession>, TrapHandler>();
services.AddSingleton<IMessageHandler<AgentSession>, UpdateHandler>();
services.AddSingleton<IMessageHandler<AgentSession>, UserHandler>();
services.AddSingleton<IMessageHandler<AgentSession>, VideocardHandler>();
services.AddSingleton<IMessageHandler<AgentSession>, VirtualMaschineHandler>();
services.AddSingleton<IMessageHandler<AgentSession>, ConsoleHandler>();
// WEB (FRONTEND-PROXY) SERVER
services.UseHostedServer<WebSession, IMessage>(options =>
{
options.Address = IPAddress.Any;
options.Port = host.Configuration.GetValue<int?>(Appsettings.WebServerPort) ?? throw new Exception($"{Appsettings.WebServerPort} value not set (appsettings)");
options.Keepalive = 10000;
options.Timeout = 30000;
options.Backlog = 128;
options.Compression = true;
options.Encryption = Encryption.Tls12;
options.Certificate = host.Configuration.GetValue<string?>(Appsettings.WebServerCertificate) ?? throw new Exception($"{Appsettings.WebServerCertificate} value not set (appsettings)");
options.CertificatePassword = host.Configuration.GetValue<string?>(Appsettings.WebServerCertificatePassword) ?? throw new Exception($"{Appsettings.WebServerCertificatePassword} value not set (appsettings)");
options.UseSerializer<MemPackSerializer<IMessage>, IMessage>();
});
services.AddSingleton<IMessageHandler<WebSession>, ConsoleProxyHandler>();
// DISPATCH
// BACKGROUND SERVICES
services.AddHostedService<JobService>();
services.AddHostedService<DispatchService>();
@ -131,4 +74,78 @@ internal class Program
var host = builder.Build();
await host.RunAsync().ConfigureAwait(false);
}
}
internal static class ServiceExtensions
{
internal static IServiceCollection AddAgentServices(this IServiceCollection services, IConfiguration configuration)
{
// AGENT SERVER
services.UseHostedServer<AgentSession, IMessage>(options =>
{
options.Address = IPAddress.Any;
options.Port = configuration.GetValue<int?>(Appsettings.AgentServerPort) ?? throw new Exception($"{Appsettings.AgentServerPort} value not set (appsettings)");
options.Keepalive = 10000;
options.Timeout = 30000;
options.Backlog = 128;
options.Compression = true;
options.Encryption = Encryption.Tls12;
options.Certificate = configuration.GetValue<string?>(Appsettings.AgentServerCertificate) ?? throw new Exception($"{Appsettings.AgentServerCertificate} value not set (appsettings)");
options.CertificatePassword = configuration.GetValue<string?>(Appsettings.AgentServerCertificatePassword) ?? throw new Exception($"{Appsettings.AgentServerCertificatePassword} value not set (appsettings)");
options.UseSerializer<AgentSession, IMessage, MemPackSerializer<IMessage>>();
});
// HANDLER
services.AddSingleton<AgentHandler>();
services.AddSingleton<IMessageHandler<AgentSession>, CustomHandler>();
services.AddSingleton<IMessageHandler<AgentSession>, ProxyHandler>();
services.AddSingleton<IMessageHandler<AgentSession>, AgentHandler>();
services.AddSingleton<IMessageHandler<AgentSession>, DriveHandler>();
services.AddSingleton<IMessageHandler<AgentSession>, Network.Agent.Handlers.EventHandler>();
services.AddSingleton<IMessageHandler<AgentSession>, InterfaceHandler>();
services.AddSingleton<IMessageHandler<AgentSession>, MainboardHandler>();
services.AddSingleton<IMessageHandler<AgentSession>, MemoryHandler>();
services.AddSingleton<IMessageHandler<AgentSession>, OperationSystemHandler>();
services.AddSingleton<IMessageHandler<AgentSession>, PrinterHandler>();
services.AddSingleton<IMessageHandler<AgentSession>, ProcessorHandler>();
services.AddSingleton<IMessageHandler<AgentSession>, ServiceHandler>();
services.AddSingleton<IMessageHandler<AgentSession>, SessionHandler>();
services.AddSingleton<IMessageHandler<AgentSession>, SoftwareHandler>();
services.AddSingleton<IMessageHandler<AgentSession>, StoragePoolHandler>();
services.AddSingleton<IMessageHandler<AgentSession>, SystemInfoHandler>();
services.AddSingleton<IMessageHandler<AgentSession>, TrapHandler>();
services.AddSingleton<IMessageHandler<AgentSession>, UpdateHandler>();
services.AddSingleton<IMessageHandler<AgentSession>, UserHandler>();
services.AddSingleton<IMessageHandler<AgentSession>, VideocardHandler>();
services.AddSingleton<IMessageHandler<AgentSession>, VirtualMaschineHandler>();
return services;
}
internal static IServiceCollection AddWebServices(this IServiceCollection services, IConfiguration configuration)
{
// SERVER
services.UseHostedServer<WebSession, IMessage>(options =>
{
options.Address = IPAddress.Any;
options.Port = configuration.GetValue<int?>(Appsettings.WebServerPort) ?? throw new Exception($"{Appsettings.WebServerPort} value not set (appsettings)");
options.Keepalive = 10000;
options.Timeout = 30000;
options.Backlog = 128;
options.Encryption = Encryption.Tls12;
options.Compression = true;
options.Certificate = configuration.GetValue<string?>(Appsettings.WebServerCertificate) ?? throw new Exception($"{Appsettings.WebServerCertificate} value not set (appsettings)");
options.CertificatePassword = configuration.GetValue<string?>(Appsettings.WebServerCertificatePassword) ?? throw new Exception($"{Appsettings.WebServerCertificatePassword} value not set (appsettings)");
options.UseSerializer<WebSession, IMessage, MemPackSerializer<IMessage>>();
});
// HANDLER
services.AddSingleton<IMessageHandler<WebSession>, ProxyHandler>();
return services;
}
}

80
src/Server/Insight.Server/Services/JobService.cs
View file

@ -1,9 +1,9 @@
using Insight.Domain.Messages;
using Insight.Domain.Messages.Agent;
using Insight.Infrastructure;
using Amazon.Runtime.Internal;
using Insight.Domain.Network;
using Insight.Domain.Network.Agent.Messages;
using Insight.Infrastructure.Entities;
using Insight.Server.Extensions;
using Insight.Server.Network;
using Insight.Server.Network.Agent;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;
using MongoDB.Driver;
@ -30,25 +30,8 @@ internal class JobService : BackgroundService
var jobs = new List<Task>
{
Task.Run(async () =>
{
while (cancellationToken.IsCancellationRequested is false)
{
try
{
foreach (var agent in await GetAssignedAgentsAsync(cancellationToken))
{
await agent.SendAsync(new InventoryRequest(), cancellationToken);
}
}
catch (OperationCanceledException) { }
catch (Exception) { }
finally
{
await Task.Delay(TimeSpan.FromHours(1), cancellationToken);
}
}
}, default)
RunInventoryAsync(cancellationToken),
RunCustomsAsync(cancellationToken)
};
try
@ -59,6 +42,57 @@ internal class JobService : BackgroundService
catch (Exception) { }
}
private async Task RunInventoryAsync(CancellationToken cancellationToken)
{
_logger.LogTrace("RunInventoryAsync");
while (cancellationToken.IsCancellationRequested is false)
{
try
{
foreach (var agent in await GetAssignedAgentsAsync(cancellationToken))
{
await agent.SendAsync(new InventoryRequest(), cancellationToken);
}
}
catch (OperationCanceledException) { }
catch (Exception) { }
finally
{
await Task.Delay(TimeSpan.FromHours(1), cancellationToken);
}
}
}
private async Task RunCustomsAsync(CancellationToken cancellationToken)
{
_logger.LogTrace("RunCustomsAsync");
while (cancellationToken.IsCancellationRequested is false)
{
try
{
// check if agent online
if (_agentPool.FirstOrDefault().Value is not AgentSession agent) continue;
// proxy-send request packet to agent
await agent.SendAsync(new Request
{
RequestId = "test",
RequestData = "Get-Date"
}, cancellationToken);
}
catch (OperationCanceledException) { }
catch (Exception) { }
finally
{
await Task.Delay(TimeSpan.FromSeconds(3), cancellationToken);
}
}
}
private async ValueTask<IEnumerable<AgentSession>> GetAssignedAgentsAsync(CancellationToken cancellationToken)
{
var valid = new List<AgentSession>();

5
src/Server/Insight.Server/appsettings.Development.json
View file

@ -1,5 +1,10 @@
{
"database": "mongodb://db.insight.local:27017",
"remote.server.port": 3003,
"remote.server.certificate": "localhost.pfx",
"remote.server.certificate.password": "Webmatic12",
"agent.server.port": 3002,
"agent.server.certificate": "localhost.pfx",
"agent.server.certificate.password": "Webmatic12",

1
src/Server/Insight.Server/appsettings.json
View file

@ -1,5 +1,6 @@
{
"database": "mongodb://127.0.0.1:27017",
"agent.server.port": 3002,
"agent.server.certificate": "localhost.pfx",
"agent.server.certificate.password": "Webmatic12",