public void UpdateWorkerConnectionCache(WorkerConnection connection)
{
//foreach (ProcessSession session in sessionCache.Value.Values.Where(s => s.WorkerConnectionId == connection.Id))
//{
// session.WorkerConnection = connection;
//}
}
public void RegisterNewWorker(string connectionId, RegisterWorkerArguments args)
{
WorkerConnection workerDb =
(from worker in dbContext.WorkerConnections
where worker.WorkerName == args.WorkerName
select worker).FirstOrDefault();
if (workerDb == null)
{
WorkerConnection worker = new WorkerConnection()
{
ConnectionId = connectionId,
WorkerName = args.WorkerName,
MaxSessions = args.MaxSessions,
ActiveSessions = args.ActiveSessionCount,
AllSessions = args.AllSessionCount,
State = WorkerConnectionState.Connected,
};
dbContext.WorkerConnections.Add(worker);
}
else
{
workerDb.ConnectionId = connectionId;
workerDb.MaxSessions = args.MaxSessions;
workerDb.AllSessions = args.ActiveSessionCount;
workerDb.ActiveSessions = args.AllSessionCount;
workerDb.State = WorkerConnectionState.Connected;
sessionManager.UpdateWorkerConnectionCache(workerDb);
dbContext.Entry(workerDb).State = EntityState.Modified;
}
dbContext.SaveChanges();
}
public async Task <string> PingAsync(WorkerConnection connection)
{
_Logger?.Debug("Sending ping: " + connection.ToString());
var client = new Pinger();
var packet = new Packet <string> {
Payload = "ping", Type = "ping"
};
var pong = await client.SendAsync <string, string>(Connection.Name, packet, connection.IpAddress, connection.Port);
_Logger?.Debug("Response: " + (string.IsNullOrWhiteSpace(pong) ? "none" : pong));
return(pong);
}
public void WorkerConnection_ToString()
{
// Arrange
var ip = "192.168.0.1";
var port = 2700;
var connection = new WorkerConnection(ip, port);
// Act
var actual = connection.ToString();
// Assert
Assert.AreEqual($"{ip}.{port}", actual);
}
public Task <ElectionResponse> ResignAsync(WorkerConnection connection)
{
var packet = new Packet <ElectionRequest>
{
Type = "Elect",
Payload = new ElectionRequest {
RequestType = ElectionRequestType.Resignation
}
};
var result = _Client.SendAsync(null, packet, connection.IpAddress,
connection.Port, OnSuccess, OnFailure, OnTimeout);
return(result);
}
public void UnregisterWorker(WorkerConnection worker)
{
var sessionList = (from session in dbContext.ProcessSessions
where session.WorkerConnectionId == worker.Id
select session).ToList();
foreach (var session in sessionList)
{
session.WorkerConnection = null;
session.WorkerConnectionId = null;
dbContext.Entry(session).State = EntityState.Modified;
}
dbContext.SaveChanges();
}
private dynamic GetWorkerContext(WorkerConnection worker)
{
if (worker == null)
{
throw new Exception("Brak dostępnych sererów wykonawczych.");
}
var workerContext = Clients.Client(worker.ConnectionId);
if (workerContext == null)
{
throw new Exception("Brak połączenia z serwerem wykonawczym.");
}
return(workerContext);
}
/// <summary>
/// Main procedure.
/// </summary>
/// <param name="args">Command-line arguments.</param>
public static void Main(string[] args)
{
using (var f = new StreamWriter("foo.txt"))
{
f.WriteLine("Started");
f.Flush();
using (var x = new WorkerConnection())
{
f.WriteLine("WorkerConnection created");
f.Flush();
var y = x.Run("Query", "Cursor");
f.WriteLine("Cursor is {0}", y);
f.Flush();
}
}
Environment.Exit(0);
}
private static async Task RunAsync(IWorkerOptions options)
{
if (string.IsNullOrEmpty(options.LogFileName))
{
options.LogFileName = Path.Combine(Environment.CurrentDirectory, options.WorkerName ?? WorkerType + ".log");
}
Log.Logger = new LoggerConfiguration()
.Enrich.FromLogContext()
.MinimumLevel.Debug()
.WriteTo.Console()
.WriteTo.File(options.LogFileName)
.CreateLogger();
Log.Debug($"Opened logfile {options.LogFileName}");
var connectionParameters = new ConnectionParameters
{
EnableProtocolLoggingAtStartup = true,
ProtocolLogging = new ProtocolLoggingParameters
{
LogPrefix = Path.ChangeExtension(options.LogFileName, string.Empty) + "-protocol"
},
WorkerType = WorkerType,
DefaultComponentVtable = new ComponentVtable()
};
using (var connection = await WorkerConnection.ConnectAsync(options, connectionParameters).ConfigureAwait(false))
{
connection.StartSendingMetrics();
foreach (var opList in connection.GetOpLists())
{
ProcessOpList(opList);
}
}
Log.Information("Disconnected from SpatialOS");
}
public async Task ClientJoinSession(long sessionId)
{
await HubOperation(nameof(ClientJoinSession), sessionId, async() =>
{
ProcessSession session = sessionManager.GetSession(sessionId);
var user = userManager.GetUserById(Context.User.GetUserId());
await Groups.AddToGroupAsync(Context.ConnectionId, session.GroupName);
_ = Clients.Group(session.GroupName).SendAsync("AddSystemMessage", $"Użytkownik {user.DisplayName} dołączył do sesji.");
if (session.State == SessionState.NotStarted)
{
_ = Clients.Group(session.GroupName).SendAsync("AddSystemMessage", "Rozpoczynanie procesu zdalnego.");
WorkerConnection worker = workerManager.GetAvaliableWorker(session.App.Name);
StartProcessArguments args = new StartProcessArguments()
{
UserName = user.Email,
SessionId = session.Id,
ApplicationName = session.App.Name,
UserId = user.Id,
};
dynamic workerSignalR = GetWorkerContext(worker);
await workerSignalR.StartProcess(args);
session.State = SessionState.Active;
session.WorkerConnection = worker;
session.WorkerConnectionId = worker.Id;
sessionManager.Update(session);
}
else
{
await Clients.Client(session.WorkerConnection.ConnectionId).SendAsync("GetProcessOutput", new GetProcessOutputArguments()
{
SessionId = sessionId,
ConnectionId = Context.ConnectionId,
});
}
});
}
public static bool FanoutIfNotBusyAndHasMatchingTag(WorkerConnection <StartUnitTest, UnitTestResult> worker, StartUnitTest work)
{
return(!worker.Worker.IsBusy.Value() &&
HasMatchingTag(GetTagsFromWorker(worker), work));
}
public static IEnumerable <string> GetTagsFromWorker(WorkerConnection <StartUnitTest, UnitTestResult> worker)
{
return(worker.Worker.Info.ContainsKey(WorkerTag) ? worker.Worker.Info[WorkerTag].Split(' ').Select(t => t.Trim('#')) : new string[0]);
}
public static void SendCommandFailure(this WorkerConnection connection, long requestId, CommandErrors error)
{
connection.SendCommandFailure(requestId, error.ToString("D"));
}
public void UpdateWorker(WorkerConnection worker)
{
dbContext.Entry(worker).State = EntityState.Modified;
dbContext.SaveChanges();
}
private static async Task RunAsync(IOptions options)
{
if (string.IsNullOrEmpty(options.LogFileName))
{
options.LogFileName = Path.Combine(Environment.CurrentDirectory, options.WorkerName + ".log");
}
Log.Logger = new LoggerConfiguration()
.Enrich.FromLogContext()
.MinimumLevel.Debug()
.WriteTo.Console()
.WriteTo.File(options.LogFileName)
.CreateLogger();
Log.Debug($"Opened logfile {options.LogFileName}");
var connectionParameters = new ConnectionParameters
{
EnableProtocolLoggingAtStartup = true,
ProtocolLogging = new ProtocolLoggingParameters
{
LogPrefix = Path.ChangeExtension(options.LogFileName, string.Empty) + "-protocol"
},
WorkerType = WorkerType,
DefaultComponentVtable = new ComponentVtable()
};
using (var connection = await WorkerConnection.ConnectAsync(options, connectionParameters))
{
var postgresOptions = new PostgresOptions(GetPostgresFlags(options, connection));
DatabaseSyncLogic databaseLogic = null;
var tableName = connection.GetWorkerFlag("postgres_tablename") ?? "postgres";
var databaseService = Task.Run(async() =>
{
using (var response = await connection.SendEntityQueryRequest(new EntityQuery {
Constraint = new ComponentConstraint(DatabaseSyncService.ComponentId), ResultType = new SnapshotResultType()
}))
{
if (response.ResultCount == 0)
{
throw new ServiceNotFoundException(nameof(DatabaseSyncService));
}
databaseLogic = new DatabaseSyncLogic(postgresOptions, tableName, connection, response.Results.First().Key, DatabaseSyncService.CreateFromSnapshot(response.Results.First().Value));
connection.StartSendingMetrics(databaseLogic.UpdateMetrics);
}
});
using (var databaseChanges = new DatabaseChanges <DatabaseSyncItem.DatabaseChangeNotification>(postgresOptions, tableName))
{
foreach (var opList in connection.GetOpLists(TimeSpan.FromMilliseconds(16)))
{
var changes = databaseChanges.GetChanges();
if (!changes.IsEmpty)
{
databaseLogic?.ProcessDatabaseSyncChanges(changes);
}
ProcessOpList(opList);
if (options.PostgresFromWorkerFlags)
{
postgresOptions.ProcessOpList(opList);
}
connection.ProcessOpList(opList);
databaseLogic?.ProcessOpList(opList);
// Propagate exceptions.
databaseService.Wait(TimeSpan.FromTicks(1));
}
}
}
Log.Information("Disconnected from SpatialOS");
}
private static PostgresOptions.GetStringDelegate GetPostgresFlags(IOptions options, WorkerConnection connection)
{
return((key, value) =>
{
if (options.PostgresFromWorkerFlags)
{
var flagValue = connection.GetWorkerFlag(key);
if (!string.IsNullOrEmpty(flagValue))
{
return flagValue;
}
}
var envFlag = Environment.GetEnvironmentVariable(key.ToUpperInvariant());
if (!string.IsNullOrEmpty(envFlag))
{
return envFlag;
}
return PostgresOptions.GetFromIOptions(options, key, value);
});
}
