public async Task RecordBounces(Server oServer, StreamWriter oWriter)
{
var oPostmarkRestApiClient = new PostmarkRestApiClient(oServer.APIToken);
var sBounceJson = oPostmarkRestApiClient.GetBounces(oServer.MaxBounces);
JToken oJToken = JToken.Parse(sBounceJson);
var lstBouncedMails = new List <BouncedMail>();
foreach (var oChildJToken in oJToken.SelectToken("Bounces"))
{
lstBouncedMails.Add(new BouncedMail(oChildJToken));
}
int iTotalBounces = lstBouncedMails.Count();
DateTime?dtLatestBounce = lstBouncedMails.Any() ? lstBouncedMails.Max(oBouncedMail => oBouncedMail.BounceDate) : (DateTime?)null;
string sTimestamp = dtLatestBounce.HasValue ? $"; latest @ {dtLatestBounce.Value.ToDateFormatted()}" : String.Empty;
string sLog = $" - Server: {oServer.Name}|| # {iTotalBounces.ToString("#,##0")} bounces{sTimestamp}";
Console.WriteLine(sLog);
oWriter.WriteLine(sLog);
var oServerRepository = new ServerRepository();
lstBouncedMails.ToList().ForEach(async oBouncedMail => await oServerRepository.RecordBounce(oServer.Key, oBouncedMail.MessageID, oBouncedMail.BounceType, oBouncedMail.Description,
oBouncedMail.Detail, oBouncedMail.SendTo, oBouncedMail.SendFrom, oBouncedMail.BounceDate, oBouncedMail.Subject, oWriter));
}
public void GivenFieldBOfTheRecordR0HasBeenChangedOnTheServer()
{
var r0 = ServerRepository.Find(TestItemR0.Id);
r0.FieldB = FieldBServerChangedValue = Guid.NewGuid().ToString();
ServerRepository.Update(r0);
}
public void ThenTheServerR0RecordShouldHaveClientValueInFieldAAndServerValueInFieldB()
{
var r0 = ServerRepository.Find(TestItemR0.Id);
Assert.AreEqual(FieldAClientChangedValue, r0.FieldA);
Assert.AreEqual(FieldBServerChangedValue, r0.FieldB);
}
public void GivenTheR0RecordExistsOnTheServer()
{
if (ServerRepository.Find(TestItemR0.Id) == null)
{
ServerRepository.Insert(TestItemR0);
}
}
public void GivenTheRecordR1DoesNotExistOnTheServer()
{
if (ServerRepository.Find(TestItemR1.Id) != null)
{
ServerRepository.Delete(TestItemR1.Id);
}
}
private void SetupSync()
{
// Set up client
ILog clientLogger = LogManager.GetLogger("Client");
log4net.Config.XmlConfigurator.Configure(clientLogger.Logger.Repository);
ClientContainer.Register <ILog>(clientLogger);
ClientContainer.Register <IRepository <TestItem, Guid> >(ClientRepository);
ClientContainer.Register <ISyncResult <TestItem, Guid>, SyncResult <TestItem, Guid> >();
ClientContainer.Register <IReplica>(new Replica("Client"));
// Set up server
ILog serverLogger = LogManager.GetLogger("Server");
log4net.Config.XmlConfigurator.Configure(serverLogger.Logger.Repository);
ServerContainer.Register <ILog>(clientLogger);
ServerContainer.Register <IRepository <TestItem, Guid> >(ServerRepository);
ServerContainer.Register <ISyncResult <TestItem, Guid>, SyncResult <TestItem, Guid> >();
ServerContainer.Register <IReplica>(ServerReplica);
ServerRepository.Insert(TestItemR0); // Start with an item on the server
// Used for both client and server
Container.Register <ISyncConflictResolver <TestItem, Guid>, TestItemConflictResolver>();
// Just pass the sync requests directly between the server and client
// Ordinarily these would by serialized and sent over a wire, but the
// TestSyncRequestSender, just passes the object directly.
ClientContainer.Register <ISyncRequestSender <TestItem, Guid> >(new TestSyncRequestSender <TestItem, Guid>(ServerSendingSynchronizer));
ClientSendingSynchronizer.BeginSync(ServerReplica);
}
protected void OnFavouriteStatusChanged()
{
ServerModel.IsFavourite = !ServerModel.IsFavourite;
ServerModel.FavouriteSince = DateTime.Now.AddHours(1);
ServerRepository.Update(ServerModel);
FavouriteStatusChanged.InvokeAsync("");
}
public async Task OneTimeSetup()
{
var hourRepo = new HourRepository(ConnectionFactorySetup.ConnectionFactory);
this.metricRepository = new MetricRepository(ConnectionFactorySetup.ConnectionFactory);
var serverRepository = new ServerRepository(ConnectionFactorySetup.ConnectionFactory);
this.server = await serverRepository.CreateAsync(new Server
{
ServerName = Environment.MachineName,
CreatedOn = DateTime.Now,
DeletedOn = null,
ServerTypeId = 3,
ServerIpAddress = "127.0.0.1",
IgnoreServer = false,
ResponsibleAgent = "",
ArtifactId = 1234,
});
hour = await hourRepo.CreateAsync(new Hour { HourTimeStamp = DateTime.Now.NormilizeToHour() });
metric = await this.metricRepository.CreateAsync(new Metric { HourId = hour.Id, MetricType = MetricType.WebUptime });
this.metricDataRepository = new MetricDataRepository(ConnectionFactorySetup.ConnectionFactory);
metricData = await this.metricDataRepository.CreateAsync(new MetricData { MetricId = metric.Id, Score = 100.0m });
metricData.Score = 75.0m;
metricData.Data = "asdf";
await this.metricDataRepository.UpdateAsync(metricData);
metricData = await this.metricDataRepository.ReadAsync(metricData.Id);
}
public override Response Execute()
{
// If we're already initialized (Test path)
if (this.postInstallService != null)
{
return(this.ExecutePdb());
}
var logger = new TextLogger();
var connectionFactory = new HelperConnectionFactory(this.Helper);
var agentRepository = new AgentRepository(connectionFactory);
var agentManager = this.Helper.GetServicesManager().CreateProxy <IAgentManager>(ExecutionIdentity.System);
var agentManagerService = new AgentManagerService(agentManager, agentRepository, logger);
var textLogger = new TextLogger();
var resourceServerRepository = new ResourceServerRepository(connectionFactory);
var refreshServerService = new RefreshServerService(textLogger, resourceServerRepository);
var serverRepository = new ServerRepository(connectionFactory);
var configurationRepository = new ConfigurationRepository(connectionFactory);
this.postInstallService = new PostInstallService(agentManagerService, refreshServerService, serverRepository, configurationRepository, logger);
var response = this.ExecutePdb();
agentManager?.Dispose();
return(response);
}
public async Task Server_ReadWorkspaceIds()
{
var repo = new ServerRepository(connectionFactory);
var result = await repo.ReadServerWorkspaceIdsAsync(server.ServerId);
Assert.Pass($"Workspaces on Server {server.ServerId}: Count={result.Count}, {string.Join(", ", result)}");
}
public ActionResult ServerList(FormCollection formCollection)
{
var token = formCollection["token"];
var loginRepo = new LoginRepository();
var serversRepo = new ServerRepository();
if (loginRepo.IsTokenExists(token))
{
var servers = serversRepo.GetServers(1);
var responce = new ServerListResponce();
responce.Servers = new List <ServerInfo>();
foreach (var server in servers)
{
responce.Servers.Add(new ServerInfo {
ServerName = server.Name, ServerAddress = server.Address, UsersCount = server.UsersCount
});
}
var ms = new MemoryStream();
Serializer.Serialize(ms, responce);
ms.Position = 0;
return(new FileStreamResult(ms, "application/octet-stream"));
}
return(new EmptyResult());
}
public async Task Setup()
{
connectionFactory = TestUtilities.GetIntegrationConnectionFactory();
var repo = new ServerRepository(connectionFactory);
server = await repo.CreateAsync(new Server
{
ServerName = Environment.MachineName,
CreatedOn = DateTime.Now,
DeletedOn = null,
ServerTypeId = 3,
ServerIpAddress = "127.0.0.1",
IgnoreServer = false,
ResponsibleAgent = "",
ArtifactId = 1234,
LastChecked = null,
UptimeMonitoringResourceHost = null,
UptimeMonitoringResourceUseHttps = null,
LastServerBackup = null,
AdminScriptsVersion = null,
});
server.UptimeMonitoringResourceHost = UpdatedHost;
await repo.UpdateAsync(server);
}
public async Task SetUp()
{
var connFactory = TestUtilities.GetIntegrationConnectionFactory();
this.searchAuditBatchRepository = new SearchAuditBatchRepository(connFactory);
var hourRepo = new HourRepository(connFactory);
hour = await hourRepo.CreateAsync(new Hour { HourTimeStamp = DateTime.UtcNow.NormilizeToHour() });
Assert.That(hour, Is.Not.Null, "Must have a valid hour for tests");
var serverRepo = new ServerRepository(connFactory);
server = (await serverRepo.ReadAllActiveAsync()).FirstOrDefault();
Assert.That(server, Is.Not.Null, "Must have a valid server for tests");
this.HourAuditSearchBatchId =
await this.searchAuditBatchRepository.CreateHourSearchAuditBatch(hour.Id, server.ServerId, 1);
await this.searchAuditBatchRepository.CreateBatches(new[] {
new SearchAuditBatch
{
HourSearchAuditBatchId = this.HourAuditSearchBatchId,
WorkspaceId = Config.WorkSpaceId,
BatchStart = 0,
BatchSize = 5000
}
});
this.searchAuditBatch = (await this.searchAuditBatchRepository.ReadBatchesByHourAndServer(hour.Id, server.ServerId)).FirstOrDefault();
}
private string GetUrlFromServer(string gServerID)
{
IQueryable <AUTH_SERVER> query = ServerRepository.GetQueryable();
var system = query.Single(s => s.SERVER_ID == gServerID);
return(system.URL);
}
public async Task <List <Server> > List()
{
var oServerRepository = new ServerRepository();
IDataReader oDataReader = null;
try
{
oDataReader = await oServerRepository.List();
}
catch (Exception)
{
throw;
}
var lstServers = new List <Server>();
while (oDataReader.Read())
{
var oServer = new Server(oDataReader);
lstServers.Add(oServer);
}
oDataReader.Close();
return(lstServers);
}
public ServerService()
{
_serverRepository = new ServerRepository();
_gameModeRepository = new GameModeRepository();
_matchRepository = new MatchRepository();
_utilRepository = new UtilRepository();
}
public void Test1()
{
_server_api = new OpenServerApi("./server_information.json");
_server_mapper = new ServerEntityMapper();
_server_repository = new ServerRepository(_server_api, _server_mapper);
_server_creator = new ServerCreatorRequest(_server_repository);
_server_activator = new ServerActivatorRequest(_server_repository);
ServerEntity server = _server_creator.Handle(666);
Assert.IsNotNull(server);
Assert.AreEqual(666, server.Port);
ServerEntity server2 = _server_creator.Handle(667);
Assert.IsNotNull(server2);
Assert.AreEqual(667, server2.Port);
Assert.AreEqual(666, server.Port);
Assert.AreNotSame(server, server2);
server = _server_activator.Handle(server, true, new ServerAcceptCallback(server));
Socket socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
socket.Connect(new IPEndPoint(IPAddress.Parse("127.0.0.1"), 666));
Assert.AreEqual(true, socket.Connected);
Assert.AreEqual(true, server.IsRunning);
Assert.AreEqual(false, server2.IsRunning);
server = _server_activator.Handle(server, false, null);
Assert.AreEqual(false, server.IsRunning);
}
private string GetUrlFromServer(Guid gServerID)
{
IQueryable <THOK.Authority.DbModel.Server> query = ServerRepository.GetQueryable();
var system = query.Single(s => s.ServerID == gServerID);
return(system.Url);
}
public async Task GetAllShouldGetAllServersFromGivenGuild()
{
Server[] servers = new Server[]
{
new Server(0, 11u, "127.0.0.1", 123, "test"),
new Server(0, 11u, "24.1.2.1", 123, "test2"),
new Server(0, 11u, "17.1.0.1", 22, "test3"),
new Server(0, 11u, "12.0.2.1", 33, "wara4"),
new Server(0, 11u, "12.0.2.1", 11, "wara"),
};
IServerRepository repo = new ServerRepository(GetMysql());
foreach (var s in servers)
{
await repo.AddServer(s.GuildId, s.ServerIp, s.ServerPort, s.ServerName);
}
await repo.AddServer(12u, "10.0.0.1", 123, "different guild");
await repo.AddServer(13u, "10.0.0.1", 123, "different guild");
var response = await repo.GetAll(11u);
foreach (var s in servers)
{
Assert.NotNull(response.Single(x => x.ServerIp == s.ServerIp && x.ServerName == s.ServerName && x.ServerPort == s.ServerPort));
}
}
public object GetServerById(string serverID)
{
Guid sid = new Guid(serverID);
var server = ServerRepository.GetQueryable().FirstOrDefault(s => s.ServerID == sid);
return(server.ServerName);
}
public void InitializeViewModelExecute()
{
this.serverRepository = new ServerRepository();
this.settingsRepository = new SettingsRepository();
currentSettings = settingsRepository.GetCurrentSettings();
this.Refresh();
}
public TableItemsResponse Items(TableItemsRequest request)
{
TableItemsResponse response = new TableItemsResponse();
ServerRepository serverRepository = new ServerRepository();
var serverEntity = serverRepository.GetServer(request.ServerName);
if (serverEntity == null)
{
response.Message = "服务器不存在";
return(response);
}
OpenDBResult openDBResult = TheReaderBase.GetConnection(serverEntity);
if (openDBResult.Status != 0)
{
response.Status = openDBResult.Status;
response.Message = openDBResult.Message;
return(response);
}
using (var conn = openDBResult.Connection)
{
switch (serverEntity.ServerType)
{
case ServerTypeConstant.Mysql:
{
var entityList = MysqlReader.GetTableEntityList(conn as MySqlConnection, serverEntity.MysqlDBName);
response.TableList = entityList.Select(v => new SchemaTableVo {
Name = v.Name
}).ToList();
}
break;
case ServerTypeConstant.Sqlite:
{
var entityList = SqliteReader.GetTableEntityList(conn as SQLiteConnection);
response.TableList = entityList.Select(v => new SchemaTableVo {
Name = v.Name
}).ToList();
}
break;
default:
{
response.Message = "不支持的数据库类型";
return(response);
}
}
}
response.Status = 1;
return(response);
}
public object GetDetails(string cityID, string serverID)
{
Guid cityid = new Guid(cityID);
Guid serverid = new Guid(serverID);
var server = ServerRepository.GetQueryable().Where(s => s.City.CityID == cityid && s.ServerID == serverid).Select(s => s.ServerID);
var servers = ServerRepository.GetQueryable().Where(s => !server.Any(sv => sv == s.ServerID) && s.City.CityID == cityid).Select(s => new { s.ServerID, s.ServerName, s.Description, Status = s.IsActive ? "启用" : "禁用" });
return(servers.ToArray());
}
public ServersController(DbContextOptions <ApiContext> options, ILogger <ServersController> logger)
{
ApiContext ctx = new ApiContext(options);
ServerRepository repo = new ServerRepository(ctx);
_ctx = ctx;
_logger = logger;
_repo = repo;
}
protected override void OnInitialized()
{
Servers = ServerRepository.GetList();
ServersLeft = NumberOfServersAllowed - Servers.Count;
NumberOfServersOnlineLeft = MaximumAmountOfServersOnline - Servers.Where(s => s.Online).Count();
PrepareServerButtonName();
PrepareServerCreationStatus();
ValidateServerName();
}
public async Task Insert_ShouldBeAbleToInsertSameServersToDifferentGuilds()
{
IServerRepository repo = new ServerRepository(GetMysql());
// this should not trigger any exception - smoke test
await repo.AddServer(12u, "10.0.0.1", 123, "same");
await repo.AddServer(13u, "10.0.0.1", 123, "same");
}
public void UpdateListOfObjects()
{
var l = ServerRepository.GetAllInventoryObject();
if (l != null)
{
ListOfObjects = l;
}
}
public async Task GetAll_ShouldGetServersFromSpecificGuild()
{
ISubscribedServerRepository repo = new SubscribedServerRepository(GetMysql());
IServerRepository serverRepo = new ServerRepository(GetMysql());
async Task <SubscribedServer> AddServer(SubscribedServer s)
{
var server = await serverRepo.AddServer(s.Server.GuildId, s.Server.ServerIp, s.Server.ServerPort, s.Server.ServerName);
return(await repo.Add(server, s.Port, s.ChannelId));
}
var ss = new SubscribedServer[]
{
new SubscribedServer(
new Server(0, 11u, "10.0.0.1", 123, "GetAll_ShouldGetServersFromSpecificGuild"),
DateTimeOffset.Now, 100, null, 150
),
new SubscribedServer(
new Server(1, 11u, "10.0.5.1", 123, "GetAll_ShouldGetServersFromSpecificGuild2"),
DateTimeOffset.Now, 100, null, 150
),
};
var others = new SubscribedServer[]
{
new SubscribedServer(
new Server(0, 15u, "10.0.0.1", 123, "GetAll_ShouldGetServersFromSpecificGuild"),
DateTimeOffset.Now, 100, null, 150
),
new SubscribedServer(
new Server(1, 18u, "10.0.5.1", 123, "GetAll_ShouldGetServersFromSpecificGuild2"),
DateTimeOffset.Now, 100, null, 150
),
};
var toCheck = new List <SubscribedServer>();
foreach (var s in ss)
{
toCheck.Add(await AddServer(s));
}
foreach (var s in others)
{
await AddServer(s);
}
var servers = await repo.GetAll(11u);
foreach (var s in toCheck)
{
Assert.NotNull(servers.Single(x => x.ChannelId == s.ChannelId && x.Server.Id == s.Server.Id && x.Server.ServerIp == s.Server.ServerIp));
}
}
public async Task UpdatePassword_ShouldChangePassword()
{
IServerRepository repo = new ServerRepository(GetMysql());
var server = await repo.AddServer(11u, "192.168.0.1", 123, "testServerName");
await repo.UpdatePassword(server.Id, "pwd");
server = await repo.GetServer(11u, server.ServerName);
Assert.Equal("pwd", server.ServerPassword);
}
public async Task Server_ReadPrimaryStandaloneAsync()
{
// Arrange
var repo = new ServerRepository(connectionFactory);
// Act
var result = await repo.ReadPrimaryStandaloneAsync();
// Assert
Assert.Pass($"Result may differ, current standalone server: {result}");
}
