public QueuedServerClientTests()
{
baseClient = A.Fake <IServerClient>();
queue = A.Fake <IMessageQueue>();
client = new QueuedServerClient(baseClient, queue);
}
protected override void Inject(ILifetimeScope scope)
{
serverClient = scope.Resolve <IServerClient>();
Logger.Info("Loading plugins.");
taskSolverFactory = scope.Resolve <TaskSolverFactory>();
taskSolverFactory.LoadTaskSolvers(libDirectory);
}
public MultiplierService(ILogger <MultiplierService> logger, IServerClient <Multiplication> serverClient, IConfiguration config)
{
_random = new Random();
_logger = logger;
_serverClient = serverClient;
_section = config.GetSection("ExternalService");
}
public ServerClientTests()
{
tcpClient = A.Fake <ITcpClient>();
stream = A.Fake <INetworkStream>();
reader = A.Fake <IMessageStreamReader>();
sender = A.Fake <IMessagesSender>();
config = A.Fake <ICsConfiguration>();
mediator = A.Fake <IMediator>();
A.CallTo(() => config.Address).Returns(IPAddress.Loopback);
A.CallTo(() => config.Port).Returns(1234);
A.CallTo(() => tcpClient.GetStream()).Returns(stream);
A.CallTo(() => reader.MayHaveMessages).ReturnsLazily(() => messagesRead = !messagesRead);
A.CallTo(() => reader.ReadAvailable()).ReturnsLazily(() => A.CollectionOfFake <IMessage>(1).ToArray());
Func <ITcpClient> clientFactory = () =>
{
tcpClientCreated = true;
return(tcpClient);
};
Func <INetworkStream, IMessageStreamReader> readerFactory = s =>
{
if (s == stream)
{
readerCreated = true;
return(reader);
}
throw new InvalidOperationException();
};
serverClient = new ServerClient(config, sender, mediator, clientFactory, readerFactory);
}
public FormMain()
{
InitializeComponent();
Disposed += p_Disposed;
Activated += p_Activated;
Deactivate += p_Deactivated;
fIcons[0] = this.notifyIcon.Icon;
fIcons[1] = Icons.Animation01;
fIcons[2] = Icons.Animation02;
fIcons[3] = Icons.Animation03;
fIcons[4] = Icons.Animation04;
fIcons[5] = Icons.Animation05;
fIcons[6] = Icons.Animation06;
fIcons[7] = Icons.Animation07;
fIcons[8] = Icons.Animation08;
fIcons[9] = Icons.Animation09;
fIcons[10] = Icons.Animation10;
fIcons[11] = Icons.Animation11;
CreateHandle();
var host = ConfigurationManager.AppSettings["serverHost"];
var parameters = new RemotingParameters(host, 570);
parameters.Cryptography = new RijndaelManaged();
fConnection = new RemotingClient(parameters);
fConnection.UserChannelCreated += p_UserChannelCreated;
var server = (IServer)fConnection.InvokeStaticMethod("GetServer");
string[] names = WindowsIdentity.GetCurrent().Name.Split('\\');
fNickName = names[names.Length - 1];
fClient = server.Connect(fNickName, new Client(this));
}
public GeneratorService(ILogger <GeneratorService> logger, IServerClient <BatchNumbersGenerated> serverClient, IConfiguration config)
{
_random = new Random();
_logger = logger;
_serverClient = serverClient;
_section = config.GetSection("ExternalService");
}
public InstanceManagerTest(IServerClient serverClient, string testRootPath)
{
this.serverClient = serverClient ?? throw new ArgumentNullException(nameof(serverClient));
this.instanceManagerClient = serverClient.Instances;
this.usersClient = serverClient.Users;
this.testRootPath = testRootPath ?? throw new ArgumentNullException(nameof(testRootPath));
}
public static void SendAuthentication(IServerClient worldClient, LoginClient loginClient)
{
using var packet = new Packet(PacketType.AES_KEY_RESPONSE);
packet.Write(loginClient.Id.ToByteArray());
packet.Write(loginClient.CryptoManager.Key);
packet.Write(loginClient.CryptoManager.IV);
worldClient.SendPacket(packet, false);
}
public StatusMessageSender(ITimeProvider time, IServerClient client, IMediator mediator)
{
log.Info("Create StatusMessageSender");
this.time = time;
this.client = client;
this.mediator = mediator;
previousDate = time.Now();
}
/// <summary>
/// Raises ClientDisconnected event.
/// </summary>
/// <param name="client">Disconnected client</param>
protected virtual void OnClientDisconnected(IServerClient client)
{
var handler = this.ClientDisconnected;
if (handler != null)
{
handler(this, new ServerClientEventArgs(client));
}
}
public StatusMessageSenderTests()
{
time = A.Fake <ITimeProvider>();
client = A.Fake <IServerClient>();
mediator = A.Fake <IMediator>();
A.CallTo(() => time.Now()).Returns(StartDate);
sender = new StatusMessageSender(time, client, mediator);
sender.Timeout = TimeSpan.FromSeconds(TimeoutInSeconds);
}
public OrderService(IOrderRepository orderRepository, IServerClient <Order> serverClient, IServerClient <Batch> batchClient, IConfiguration config, ICancellationService cancellationService, ILogger <OrderService> logger)
{
_orderRepository = orderRepository;
_orderClient = serverClient;
_batchClient = batchClient;
_section = config.GetSection("ExternalService");
_orders = new ObservableCollection <IModel>();
_orders.CollectionChanged += HandleChange;
_cancellationService = cancellationService;
_logger = logger;
}
//A Clicked handler must always take an array of clients as a parameter
private void HandleContextItemClicked(IServerClient[] clients)
{
if (clients.Length == 0)
return;
//If no clients where selected, do nothing
FormMessage F = new FormMessage(clients[0]);
F.Show();
FormMessageHandle = F;
//We keep an instance of this because we will need to close it in the unload event
}
public ServerHubImpl(IServerClient serverClient)
{
_serverClient = serverClient;
if (!(_serverClient is ServerClientImpl serverClientImpl))
{
return;
}
serverClientImpl.SetConnectSuccessLaterAction(ServerClientImpl_OnConnectSuccess);
Task task = Task.Run(async() =>
{
await serverClientImpl.ConnectWithRetryAsync();
});
Task.WaitAll(task);
}
public FileManagementViewModel(IFileViewModelFactory fileViewModelFactory,
IServerClient serverClient)
{
_fileViewModelFactory = fileViewModelFactory;
_serverClient = serverClient;
_serverClient.ProgressEvent += OnProgressChanged;
_serverClient.FinishedEvent += OnFinishedEvent;
NavigatedTo();
UploadToServerCommand = new Command <FileViewModel>(ExecuteUploadToServer);
}
protected SisoDatabase(ISisoConnectionInfo connectionInfo, IDbProviderFactory dbProviderFactory)
{
Ensure.That(connectionInfo, "connectionInfo").IsNotNull();
Ensure.That(dbProviderFactory, "dbProviderFactory").IsNotNull();
_lockObject = new object();
_connectionInfo = connectionInfo;
_providerFactory = dbProviderFactory;
Settings = ProviderFactory.GetSettings();
ServerClient = ProviderFactory.GetServerClient(ConnectionInfo);
StructureSchemas = new StructureSchemas(new StructureTypeFactory(), new AutoStructureSchemaBuilder());
Serializer = new DefaultSisoSerializer();
StructureBuilders = new StructureBuilders(() => Serializer, schema => ProviderFactory.GetGuidStructureIdGenerator(), (schema, dbClient) => ProviderFactory.GetIdentityStructureIdGenerator(dbClient));
Maintenance = new SisoDatabaseMaintenance(this);
_dbSchemas = ProviderFactory.GetDbSchemaManagerFor(this);
}
public static IServerClient CreateClient(IServerListener listeners, Protocols?proto)
{
IServerClient sc = null;
switch (proto)
{
case (Protocols.Tcp):
{
sc = new TcpServerClient(listeners.GetClientSocket());
break;
}
case (Protocols.Udp):
{
sc = new UdpServerClient(listeners.GetClientSocket());
break;
}
}
return(sc);
}
public void Run()
{
logger.Info($"Preparing.");
using (container = PrepareContainer())
{
configuration = container.Resolve <Loader>().Load <ClientConfiguration>(GetAddressFromConfig, GetPortFromConfig);
mediator = container.Resolve <SimpleMediator>();
client = container.Resolve <IServerClient>();
fileLoader = container.Resolve <FileLoader>();
serializer = container.Resolve <ISerializer>();
if (configuration.ProblemId.HasValue)
{
this.AskForResponse();
}
else
{
this.SendProblemRequest();
}
}
logger.Info("System stopped.");
}
public static async Task <int> Main()
{
var repo = Environment.GetEnvironmentVariable("TGS_REPO")?.Trim();
if (String.IsNullOrWhiteSpace(repo))
{
Console.WriteLine("ERROR: Environment variable TGS_REPO not set to a git url!");
return(1);
}
var byondStr = Environment.GetEnvironmentVariable("TGS_BYOND")?.Trim();
if (String.IsNullOrWhiteSpace(byondStr) || !Version.TryParse(byondStr, out Version byond) || byond.Build != -1)
{
Console.WriteLine("ERROR: Environment variable TGS_BYOND not set to a valid BYOND version!");
return(2);
}
var clientFactory = new ServerClientFactory(new ProductHeaderValue("LinuxOneShot", "1.0.0"));
IServerClient serverClient = null;
Instance instance = null;
IInstanceClient instanceClient;
void CreateInstanceClient() => instanceClient = serverClient.Instances.CreateClient(instance);
async Task CreateAdminClient()
{
Console.WriteLine("Attempting to reestablish connection to TGS (120s max wait)...");
var giveUpAt = DateTimeOffset.Now.AddSeconds(60);
do
{
try
{
serverClient = await clientFactory.CreateServerClient(new Uri("http://tgs:80"), User.AdminName, User.DefaultAdminPassword, default, default);
public void ReceiveClients()
{
while (_running)
{
if (listener == null || serializer == null || clientList == null)
{
ArgumentNullException ex = new ArgumentNullException();
Logger.Instance.WriteLog("Failed at Server recieve: " + ex.ToString());
throw ex;
}
IServerClient client = ServerClientCreator.CreateClient(listener, serverSettings.protocol);
clientList.Add(client);
foreach (IObserver o in observerList)
{
client.AddObserver(o);
}
client.AddSerializer(serializer);
client.Run();
Console.WriteLine("Client Connected to Server");
client.Send("Conencted");
}
}
public void IClientPacketReceived(IServerClient client, object[] @params)
{
//When a Client with the same plugin loaded sends you a packet
}
/// <summary>
/// Creates a new ServerClientEventArgs object.
/// </summary>
/// <param name="client">Client that is associated with this event</param>
public ServerClientEventArgs(IServerClient client)
{
Client = client;
}
/// <summary>
/// Creates a new service client object that is used in server-side.
/// </summary>
/// <param name="serverClient">Underlying server client object</param>
/// <param name="requestReplyMessenger">RequestReplyMessenger object to send/receive messages over serverClient</param>
/// <returns></returns>
public static IServiceClient CreateServiceClient(IServerClient serverClient, RequestReplyMessenger<IServerClient> requestReplyMessenger)
{
return new ServiceClient(serverClient, requestReplyMessenger);
}
/// <summary>
/// Creates a new service client object that is used in server-side.
/// </summary>
/// <param name="serverClient">Underlying server client object</param>
/// <param name="requestReplyMessenger">RequestReplyMessenger object to send/receive messages over serverClient</param>
/// <returns></returns>
public static IServiceClient CreateServiceClient(IServerClient serverClient, RequestReplyMessenger <IServerClient> requestReplyMessenger)
{
return(new ServiceClient(serverClient, requestReplyMessenger));
}
public FormMessage(IServerClient _IServerClient)
{
InitializeComponent();
IServerClient = _IServerClient;
this.Text = string.Format("Message - {0}", IServerClient.IServerState.UserName);
}
public SignalRInterceptorTests()
{
connection = Substitute.For <IHubConnection>();
interceptor = new SignalRInterceptor(connection);
proxy = generator.CreateInterfaceProxyWithoutTarget <IServerClient>(interceptor);
}
public void IClientConnectedStateChanged(bool connected, IServerClient client)
{
//When a new client connects to Imminent Monitor
}
/// <summary>
/// Raises ClientDisconnected event.
/// </summary>
/// <param name="client">Disconnected client</param>
protected virtual void OnClientDisconnected(IServerClient client)
{
var handler = ClientDisconnected;
if (handler != null) {
handler(this, new ServerClientEventArgs(client));
}
}
public ExceptionManager(ExceptionManagerOptions options, IServerClient serverClient)
{
_criticalExceptionTypes = options?.CriticalExceptionTypes?.Select(Type.GetType).ToList();
_serverClient = serverClient;
}
public void IClientPacketReceived(IServerClient client, object[] @params)
{
//When a Client with the same plugin loaded sends you a packet
}
//A Clicked handler must always take an array of clients as a parameter
private void HandleContextItemClicked(IServerClient[] clients)
{
if (clients.Length == 0)
return;
//If no clients where selected, do nothing
}
//Network events
public void IClientConnectedStateChanged(bool connected, IServerClient client)
{
//When a new client connects to Imminent Monitor
}
/// <summary>
/// Creates a new ServerClientEventArgs object.
/// </summary>
/// <param name="client">Client that is associated with this event</param>
public ServerClientEventArgs(IServerClient client)
{
Client = client;
}
/// <inheritdoc /> public void SendPacketTo(IServerClient client, byte[] packetData) => this.sender.AddPacketToQueue(new PacketData(client, packetData));
/// <inheritdoc /> public void DisconnectClient(IServerClient client) => this.DisconnectClient(client.Id);
async Task TestServerInformation(IServerClientFactory clientFactory, IServerClient serverClient, CancellationToken cancellationToken)
{
var serverInfo = await serverClient.ServerInformation(default).ConfigureAwait(false);
async Task TestRequestValidation(IServerClient serverClient, CancellationToken cancellationToken)
{
var url = serverClient.Url;
var token = serverClient.Token.Bearer;
// check that 400s are returned appropriately
using var httpClient = new HttpClient();
using (var request = new HttpRequestMessage(HttpMethod.Get, url.ToString()))
{
request.Headers.Accept.Clear();
request.Headers.UserAgent.Add(new ProductInfoHeaderValue("RootTest", "1.0.0"));
using var response = await httpClient.SendAsync(request, cancellationToken);
Assert.AreEqual(HttpStatusCode.NotAcceptable, response.StatusCode);
}
using (var request = new HttpRequestMessage(HttpMethod.Get, url.ToString()))
{
request.Headers.Accept.Clear();
request.Headers.UserAgent.Add(new ProductInfoHeaderValue("RootTest", "1.0.0"));
request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue(MediaTypeNames.Application.Xml));
using var response = await httpClient.SendAsync(request, cancellationToken);
Assert.AreEqual(HttpStatusCode.NotAcceptable, response.StatusCode);
}
using (var request = new HttpRequestMessage(HttpMethod.Get, url.ToString()))
{
request.Headers.Accept.Clear();
request.Headers.UserAgent.Add(new ProductInfoHeaderValue("RootTest", "1.0.0"));
request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue(MediaTypeNames.Application.Json));
using var response = await httpClient.SendAsync(request, cancellationToken);
Assert.AreEqual(HttpStatusCode.BadRequest, response.StatusCode);
var content = await response.Content.ReadAsStringAsync();
var message = JsonConvert.DeserializeObject <ErrorMessage>(content);
Assert.AreEqual(ErrorCode.BadHeaders, message.ErrorCode);
}
using (var request = new HttpRequestMessage(HttpMethod.Get, url.ToString()))
{
request.Headers.Accept.Clear();
request.Headers.UserAgent.Add(new ProductInfoHeaderValue("RootTest", "1.0.0"));
request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue(MediaTypeNames.Application.Json));
request.Headers.Add(ApiHeaders.ApiVersionHeader, "Tgstation.Server.Api/" + ApiHeaders.Version);
using var response = await httpClient.SendAsync(request, cancellationToken);
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
var content = await response.Content.ReadAsStringAsync();
var message = JsonConvert.DeserializeObject <ServerInformation>(content);
Assert.AreEqual(ApiHeaders.Version, message.ApiVersion);
}
using (var request = new HttpRequestMessage(HttpMethod.Get, url.ToString()))
{
request.Headers.Accept.Clear();
request.Headers.UserAgent.Add(new ProductInfoHeaderValue("RootTest", "1.0.0"));
request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("*/*"));
request.Headers.Add(ApiHeaders.ApiVersionHeader, "Tgstation.Server.Api/6.0.0");
request.Headers.Authorization = new AuthenticationHeaderValue(ApiHeaders.BearerAuthenticationScheme, token);
using var response = await httpClient.SendAsync(request, cancellationToken);
Assert.AreEqual(HttpStatusCode.UpgradeRequired, response.StatusCode);
var content = await response.Content.ReadAsStringAsync();
var message = JsonConvert.DeserializeObject <ErrorMessage>(content);
Assert.AreEqual(ErrorCode.ApiMismatch, message.ErrorCode);
}
using (var request = new HttpRequestMessage(HttpMethod.Get, url.ToString() + Routes.Administration.Substring(1)))
{
request.Headers.Accept.Clear();
request.Headers.UserAgent.Add(new ProductInfoHeaderValue("RootTest", "1.0.0"));
request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("*/*"));
request.Headers.Add(ApiHeaders.ApiVersionHeader, "Tgstation.Server.Api/6.0.0");
request.Headers.Authorization = new AuthenticationHeaderValue(ApiHeaders.BearerAuthenticationScheme, token);
using var response = await httpClient.SendAsync(request, cancellationToken);
Assert.AreEqual(HttpStatusCode.UpgradeRequired, response.StatusCode);
var content = await response.Content.ReadAsStringAsync();
var message = JsonConvert.DeserializeObject <ErrorMessage>(content);
Assert.AreEqual(ErrorCode.ApiMismatch, message.ErrorCode);
}
using (var request = new HttpRequestMessage(HttpMethod.Post, url.ToString() + Routes.Administration.Substring(1)))
{
request.Headers.Accept.Clear();
request.Headers.UserAgent.Add(new ProductInfoHeaderValue("RootTest", "1.0.0"));
request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue(MediaTypeNames.Application.Json));
request.Headers.Add(ApiHeaders.ApiVersionHeader, "Tgstation.Server.Api/" + ApiHeaders.Version);
request.Headers.Authorization = new AuthenticationHeaderValue(ApiHeaders.BearerAuthenticationScheme, token);
request.Content = new StringContent(
"{ newVersion: 1234 }",
Encoding.UTF8,
MediaTypeNames.Application.Json);
using var response = await httpClient.SendAsync(request, cancellationToken);
Assert.AreEqual(HttpStatusCode.BadRequest, response.StatusCode);
var content = await response.Content.ReadAsStringAsync();
var message = JsonConvert.DeserializeObject <ErrorMessage>(content);
Assert.AreEqual(ErrorCode.ModelValidationFailure, message.ErrorCode);
}
using (var request = new HttpRequestMessage(HttpMethod.Post, url.ToString() + Routes.DreamDaemon.Substring(1)))
{
request.Headers.Accept.Clear();
request.Headers.UserAgent.Add(new ProductInfoHeaderValue("RootTest", "1.0.0"));
request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue(MediaTypeNames.Application.Json));
request.Headers.Add(ApiHeaders.ApiVersionHeader, "Tgstation.Server.Api/" + ApiHeaders.Version);
using var response = await httpClient.SendAsync(request, cancellationToken);
Assert.AreEqual(HttpStatusCode.Unauthorized, response.StatusCode);
}
using (var request = new HttpRequestMessage(HttpMethod.Post, url.ToString() + Routes.DreamDaemon.Substring(1)))
{
request.Headers.Accept.Clear();
request.Headers.UserAgent.Add(new ProductInfoHeaderValue("RootTest", "1.0.0"));
request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue(MediaTypeNames.Application.Json));
request.Headers.Add(ApiHeaders.ApiVersionHeader, "Tgstation.Server.Api/" + ApiHeaders.Version);
request.Headers.Authorization = new AuthenticationHeaderValue(ApiHeaders.BearerAuthenticationScheme, token);
using var response = await httpClient.SendAsync(request, cancellationToken);
Assert.AreEqual(HttpStatusCode.BadRequest, response.StatusCode);
var content = await response.Content.ReadAsStringAsync();
var message = JsonConvert.DeserializeObject <ErrorMessage>(content);
Assert.AreEqual(ErrorCode.InstanceHeaderRequired, message.ErrorCode);
}
using (var request = new HttpRequestMessage(HttpMethod.Post, url.ToString()))
{
request.Headers.Accept.Clear();
request.Headers.UserAgent.Add(new ProductInfoHeaderValue("RootTest", "1.0.0"));
request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue(MediaTypeNames.Application.Json));
request.Headers.Add(ApiHeaders.ApiVersionHeader, "Tgstation.Server.Api/" + ApiHeaders.Version);
request.Headers.Authorization = new AuthenticationHeaderValue(ApiHeaders.OAuthAuthenticationScheme, token);
request.Headers.Add(ApiHeaders.OAuthProviderHeader, "FakeProvider");
using var response = await httpClient.SendAsync(request, cancellationToken);
Assert.AreEqual(HttpStatusCode.BadRequest, response.StatusCode);
var content = await response.Content.ReadAsStringAsync();
var message = JsonConvert.DeserializeObject <ErrorMessage>(content);
Assert.AreEqual(ErrorCode.BadHeaders, message.ErrorCode);
}
}
public MainViewModel(IServerClient _serverClient)
{
serverClient = _serverClient;
Calculate = new RelayCommand <string>(async(currency) => await CalculateExecute().ConfigureAwait(false), (currency) => IsCurrencyValid());
}
