private static void Main(string[] args)
{
AppDomain.CurrentDomain.UnhandledException += CurrentDomain_UnhandledException;
var player = CreatePlayerFrom(args);
_logger = player.VerboseLogger;
if (_runtimeMode == RuntimeMode.Visualization)
{
var boardVisualizer = new BoardVisualizer();
for (var i = 0;; i++)
{
if (player.PlayerBoard != null)
{
Thread.Sleep(200);
boardVisualizer.VisualizeBoard(player.PlayerBoard, player.Id);
Console.WriteLine(i);
}
else
{
Thread.Sleep(2000);
}
}
}
}
public override int ExecuteCommand(ZipLinesOptions options)
{
var log = new VerboseLogger(options);
var inputStreams = options.InputFiles.Select(f => FileService.ReadLinesLazily(f).GetEnumerator()).ToList();
var coeffs = (options.Coefficients ?? Enumerable.Repeat(1, inputStreams.Count)).ToArray();
var result = new List <string>();
var hasLines = Enumerable.Repeat(true, inputStreams.Count).ToArray();
while (hasLines.Any(x => x))
{
for (int stream = 0; stream < inputStreams.Count; stream += 1)
{
for (int times = 0; times < coeffs[stream]; times += 1)
{
if (!hasLines[stream])
{
break;
}
if (inputStreams[stream].MoveNext())
{
result.Add(inputStreams[stream].Current);
}
else
{
hasLines[stream] = false;
}
}
}
}
FileService.WriteAllLines(options.OutputFile, result);
return(0);
}
/// <summary>
/// Ensures the service principal.
/// </summary>
/// <returns>PSADServicePrincipal.</returns>
public PSADServicePrincipal EnsureServicePrincipal()
{
string applicationId = CurrentApplicationId.ToString();
string appObjectId = ActiveDirectoryClient.GetServicePrincipalsIdByAppId(CurrentApplicationId);
PSADServicePrincipal servicePrincipal = ActiveDirectoryClient.GetServicePrincipalByObjectId(appObjectId);
if (servicePrincipal == null)
{
VerboseLogger.Invoke(StorageSyncResources.CreateServicePrincipalMessage);
// Create an application and get the applicationId
var passwordCredential = new PSADPasswordCredential()
{
StartDate = DateTime.Now,
EndDate = DateTime.Now.AddYears(1),
KeyId = Guid.NewGuid(),
Password = SecureStringExtensions.ConvertToString(Guid.NewGuid().ToString().ConvertToSecureString())
};
var createParameters = new CreatePSServicePrincipalParameters
{
ApplicationId = CurrentApplicationId,
AccountEnabled = bool.TrueString,
PasswordCredentials = new PSADPasswordCredential[]
{
passwordCredential
}
};
servicePrincipal = ActiveDirectoryClient.CreateServicePrincipal(createParameters);
}
return(servicePrincipal);
}
/// <summary>
/// Ensures the service principal.
/// </summary>
/// <returns>PSADServicePrincipal.</returns>
public PSADServicePrincipal EnsureServicePrincipal()
{
string applicationId = KailaniAppId.ToString();
var servicePrincipals = ActiveDirectoryClient.FilterServicePrincipals(new ODataQuery <ServicePrincipal>(s => s.AppId == applicationId));
PSADServicePrincipal servicePrincipal = servicePrincipals.FirstOrDefault();
if (servicePrincipal == null)
{
VerboseLogger.Invoke(StorageSyncResources.CreateServicePrincipalMessage);
// Create an application and get the applicationId
var passwordCredential = new PSADPasswordCredential()
{
StartDate = DateTime.Now,
EndDate = DateTime.Now.AddYears(1),
KeyId = Guid.NewGuid(),
Password = SecureStringExtensions.ConvertToString(Guid.NewGuid().ToString().ConvertToSecureString())
};
var createParameters = new CreatePSServicePrincipalParameters
{
ApplicationId = KailaniAppId,
AccountEnabled = true,
PasswordCredentials = new PSADPasswordCredential[]
{
passwordCredential
}
};
servicePrincipal = ActiveDirectoryClient.CreateServicePrincipal(createParameters);
}
return(servicePrincipal);
}
public Task StartAsync(CancellationToken cancellationToken)
{
// Generic implementation unrelated to Totem unless Serilog is doing magic.
LoggingServices.DefaultBackend = new SerilogLoggingBackend(
VerboseLogger.CreateLogger().ForContext <PostsharpBackendLogging>());
return(Task.CompletedTask);
}
public void MessageHandler(IMessage message)
{
IMessage response;
// TODO Log all player
lock (Board.Lock)
{
if (message is IRequestMessage request)
{
if (!_playerGuidToId.ContainsKey(request.PlayerGuid))
{
return;
}
PutActionLog(request);
}
else
{
VerboseLogger.Log(message.ToLog());
}
response = message.Process(this);
}
if (response != null)
{
_messagingHandler.CommunicationClient.Send(response);
}
}
public void PutActionLog(IRequestMessage record)
{
var playerId = _playerGuidToId[record.PlayerGuid];
var playerInfo = Board.Players[playerId];
var actionLog = new RequestLog(record, playerId, playerInfo.Team, playerInfo.Role);
VerboseLogger.Log(actionLog.ToLog());
}
public override int ExecuteCommand(StatisticalTableOptions options)
{
_log = new VerboseLogger(options);
List <Data> data = RetrieveData(options);
var secs = options.Secondaries.ToArray();
int numberOfGroups = 0;
var grouping = data.GroupBy(d => d.Secondaries[0].ToString() + d.Machine.ToString()).ToList();
foreach (var group in grouping)
{
numberOfGroups += 1;
var relativeOne = group.MinBy(d => d.Value).First();
relativeOne.IsRelativeOne = true;
foreach (var d in group)
{
d.RelativeValue = d.Value / relativeOne.Value;
}
}
var resultGrouping = data.GroupBy(d => d.Main + "M" + d.Machine);
var result = resultGrouping
.Select(group => new DataResult()
{
Main = group.First().Main,
Machine = group.First().Machine,
MainGroup = group.First().MainGroup,
GeoM = CalculateGeom(group, options, numberOfGroups / options.DatabaseTable.Count()),
Data = group.OrderBy(d => d.Secondaries[0]).ToList()
}).ToList();
var totalResultGrouping = data.GroupBy(d => d.Main);
var totalResult = options.OnlyGeoms
? totalResultGrouping
.Select(group => new DataResult()
{
Main = group.Key,
Machine = 0,
MainGroup = group.First().MainGroup,
GeoM = CalculateGeom(group, options, numberOfGroups),
Data = group.OrderBy(d => d.Secondaries[0]).ToList()
}).ToList()
: result;
var byGeom = totalResult.OrderBy(dr => dr.GeoM).ToList();
for (int i = 0; i < byGeom.Count; i += 1)
{
byGeom[i].Rank = i + 1;
}
var sb = new StringBuilder();
CreateText(sb, options, options.OnlyGeoms ? byGeom.Concat(result).ToList() : byGeom, numberOfGroups, secs, grouping);
FileService.WriteAllText(options.OutputFile, sb.ToString());
return(0);
}
private static void Main(string[] args)
{
AppDomain.CurrentDomain.UnhandledException += CurrentDomain_UnhandledException;
var cs = CreateCommunicationServerFrom(args);
_logger = CommunicationServer.VerboseLogger;
Console.Title = "Communication Server";
}
/// <summary>
/// Ensures the role assignment.
/// </summary>
/// <param name="serverPrincipal">The server principal.</param>
/// <param name="storageAccountSubscriptionId">The storage account subscription identifier.</param>
/// <param name="storageAccountResourceId">The storage account resource identifier.</param>
/// <returns>RoleAssignment.</returns>
public RoleAssignment EnsureRoleAssignment(MicrosoftGraphServicePrincipal serverPrincipal, string storageAccountSubscriptionId, string storageAccountResourceId)
{
string currentSubscriptionId = AuthorizationManagementClient.SubscriptionId;
bool hasMismatchSubscription = currentSubscriptionId != storageAccountSubscriptionId;
try
{
if (hasMismatchSubscription)
{
AuthorizationManagementClient.SubscriptionId = storageAccountSubscriptionId;
}
var resourceIdentifier = new ResourceIdentifier(storageAccountResourceId);
string roleDefinitionScope = "/";
RoleDefinition roleDefinition = AuthorizationManagementClient.RoleDefinitions.Get(roleDefinitionScope, BuiltInRoleDefinitionId);
var serverPrincipalId = serverPrincipal.Id.ToString();
var roleAssignments = AuthorizationManagementClient.RoleAssignments
.ListForResource(
resourceIdentifier.ResourceGroupName,
ResourceIdentifier.GetProviderFromResourceType(resourceIdentifier.ResourceType),
resourceIdentifier.ParentResource ?? "/",
ResourceIdentifier.GetTypeFromResourceType(resourceIdentifier.ResourceType),
resourceIdentifier.ResourceName,
odataQuery: new ODataQuery <RoleAssignmentFilter>(f => f.AssignedTo(serverPrincipalId)));
var roleAssignmentScope = storageAccountResourceId;
Guid roleAssignmentId = StorageSyncResourceManager.GetGuid();
RoleAssignment roleAssignment = roleAssignments.FirstOrDefault();
if (roleAssignment == null)
{
VerboseLogger.Invoke(StorageSyncResources.CreateRoleAssignmentMessage);
var createParameters = new RoleAssignmentCreateParameters
{
Properties = new RoleAssignmentProperties
{
PrincipalId = serverPrincipalId,
RoleDefinitionId = AuthorizationHelper.ConstructFullyQualifiedRoleDefinitionIdFromSubscriptionAndIdAsGuid(resourceIdentifier.Subscription, BuiltInRoleDefinitionId)
}
};
roleAssignment = AuthorizationManagementClient.RoleAssignments.Create(roleAssignmentScope, roleAssignmentId.ToString(), createParameters);
StorageSyncResourceManager.Wait();
}
return(roleAssignment);
}
finally
{
if (hasMismatchSubscription)
{
AuthorizationManagementClient.SubscriptionId = currentSubscriptionId;
}
}
}
public MarkupAggregator(
IHttpAgent httpAgent,
VerboseLogger verboseLogger,
string hrefRegex,
string[] invalidSiteLinkPatterns)
{
HttpAgent = httpAgent;
VerboseLogger = verboseLogger;
HrefRegex = hrefRegex;
InvalidSiteLinkPatterns = invalidSiteLinkPatterns;
}
public CommunicationServer(IMessageDeserializer messageDeserializer, TimeSpan keepAliveTimeout, int port,
IErrorsMessagesFactory
errorsMessagesFactory, LoggingMode loggingMode, IPAddress address)
{
VerboseLogger = new VerboseLogger(LogManager.GetCurrentClassLogger(), loggingMode);
_errorsMessagesFactory = errorsMessagesFactory;
_socketListener = new AsynchronousSocketListener(port, keepAliveTimeout,
messageDeserializer, HandleMessage, address
);
_communicationRouter = new CommunicationRouter();
new Thread(() => _socketListener.StartListening(HandleConnectionError)).Start();
}
public GameMaster(GameConfiguration gameConfiguration, ICommunicationClient communicationClient,
string gameName, IErrorsMessagesFactory errorsMessagesFactory, LoggingMode loggingMode,
IGameMasterMessageFactory gameMasterMessageFactory)
{
_gameHost = new GameHost(gameName, gameConfiguration, StartGame);
_errorsMessagesFactory = errorsMessagesFactory;
VerboseLogger = new VerboseLogger(LogManager.GetCurrentClassLogger(), loggingMode);
_messagingHandler = new MessagingHandler(gameConfiguration, communicationClient, HostNewGame,
gameMasterMessageFactory);
_messagingHandler.MessageReceived += (sender, args) => MessageHandler(args);
HostNewGame();
}
public override int ExecuteCommand(DuplicateLinesOptions options)
{
var log = new VerboseLogger(options);
if (options.Factor <= 1)
{
log.Error("Please specify a factor greater than 1");
}
log.Info($"reading file {options.InputFile}");
var lines = FileService.ReadLinesLazily(options.InputFile);
var duplicated = lines.SelectMany(l => Enumerable.Repeat(l, options.Factor));
FileService.WriteAllLines(options.OutputFile, duplicated);
return(0);
}
public void InitializePlayer(int id, Guid guid, TeamColor team, PlayerType role, PlayerBoard board,
Location location, LoggingMode loggingMode)
{
var factory = new LoggerFactory();
VerboseLogger = new VerboseLogger(factory.GetPlayerLogger(id), loggingMode);
Id = id;
Team = team;
Role = role;
PlayerGuid = guid;
GameId = 0;
PlayerBoard = board;
PlayerBoard.Players[id] = new PlayerInfo(id, team, role, location);
_stateCoordinator = new StateCoordinator("", team, role);
}
public void LogGameResults(TeamColor winners)
{
foreach (var player in Board.Players.Values)
{
var result = GameResult.Defeat;
var playerGuid = _playerGuidToId.FirstOrDefault(p => p.Value == player.Id).Key;
if (player.Team == winners)
{
result = GameResult.Victory;
}
VerboseLogger.Log(
$"{result}, {DateTime.Now}, {_gameHost.GameId}, {player.Id}, {playerGuid},{player.Team}, {player.Role}");
}
}
public ExtractionManager(
ExtractionRequest request,
IExtractionConfigProvider configProvider,
IHttpAgent httpAgent,
VerboseLogger verboseLogger)
{
Request = request;
HttpAgent = httpAgent;
VerboseLogger = verboseLogger;
_csvDelimiter = configProvider.GetCsvDelimiter();
_emailRegex = configProvider.GetEmailRegex();
_hrefRegex = configProvider.GetHrefRegex();
_invalidSiteLinkPatterns = configProvider.GetInvalidSiteLinkPatterns();
Response = new ExtractionResponse();
}
public Player(ICommunicationClient communicationClient, string gameName, TeamColor preferredColor,
PlayerType preferredRole, IErrorsMessagesFactory errorsMessagesFactory, LoggingMode loggingMode, Dictionary <TeamColor, StrategyGroup> strategyGroups)
{
CommunicationClient = communicationClient;
_gameName = gameName;
_preferredColor = preferredColor;
_preferredRole = preferredRole;
_errorsMessagesFactory = errorsMessagesFactory;
_strategyGroups = strategyGroups;
var factory = new LoggerFactory();
VerboseLogger = new VerboseLogger(factory.GetPlayerLogger(0), loggingMode);
_stateCoordinator = new StateCoordinator(gameName, preferredColor, preferredRole);
new Thread(() => CommunicationClient.Connect(HandleConnectionError, HandleResponse)).Start();
CommunicationClient.Send(_stateCoordinator.Start());
}
private void HandleResponse(IMessage message)
{
message.Process(this);
var responsesToSend = _stateCoordinator.Process(message).ToList();
if (_gameFinished)
{
_gameFinished = false;
return;
}
foreach (var response in responsesToSend)
{
VerboseLogger.Log(response.ToLog());
CommunicationClient.Send(response);
}
}
private static void Main(string[] args)
{
AppDomain.CurrentDomain.UnhandledException += CurrentDomain_UnhandledException;
var strategyGroups = new Dictionary <TeamColor, StrategyGroup>
{
{
TeamColor.Blue, StrategyGroupFactory.Create(StrategyGroupType.Basic)
},
{
TeamColor.Red, StrategyGroupFactory.Create(StrategyGroupType.Basic)
}
};
var simulation = new GameSimulation("../../../../ExampleConfig.xml", strategyGroups);
_logger = simulation.GameMaster.VerboseLogger;
while (true)
{
var boardVisualizer = new BoardVisualizer();
for (var i = 0;; i++)
{
if (simulation.GameFinished)
{
break;
}
Thread.Sleep(200);
boardVisualizer.VisualizeBoard(simulation.GameMaster.Board);
Console.WriteLine(i);
}
if (simulation.GameFinished)
{
Console.WriteLine($"Game finished - team {simulation.Winners} won!");
simulation.GameFinished = false;
}
Thread.Sleep(1000);
}
}
private static void Main(string[] args)
{
var inputFilePath = GetInputFilePath();
var outputDirectory = GetOutputDirectory();
var verboseEnabled = GetVerboseLoggingEnabled();
var verboseLogger = new VerboseLogger(verboseEnabled, Console.WriteLine);
var configProvider = new AppConfigProvider();
var httpWebRequestAgent = new HttpWebRequestAgent(verboseLogger);
var extractor = new ExtractionManager(new ExtractionRequest
{
InputFilePath = inputFilePath,
OutputDirectory = outputDirectory,
VerboseLogger = verboseLogger
}, configProvider, httpWebRequestAgent, verboseLogger);
var response = extractor.RunExtraction();
if (!string.IsNullOrEmpty(response.GeneralException))
{
Console.WriteLine($"Process failed. Error: {response.GeneralException}.");
Console.ReadKey();
return;
}
if (response.HasExtractionException)
{
foreach (var extrctException in response.ExtractionExceptions)
{
Console.WriteLine(
$"Extraction did not complete for url: {extrctException.InputUrl}. " +
$"Error: {extrctException}");
}
Console.ReadKey();
}
Console.WriteLine($"Process complete. {response.SuccessfulExtractions} website(s) successfully processed.");
Console.ReadKey();
}
private static void Main(string[] args)
{
AppDomain.CurrentDomain.UnhandledException += CurrentDomain_UnhandledException;
var gm = CreateGameMasterFrom(args);
gm.GameFinished += GenerateNewFinishedGameMessage;
_logger = gm.VerboseLogger;
Console.Title = "Game Master";
if (_runtimeMode == RuntimeMode.Visualization)
{
var boardVisualizer = new BoardVisualizer();
for (var i = 0; ; i++)
{
Thread.Sleep(200);
boardVisualizer.VisualizeBoard(gm.Board);
Console.WriteLine(i);
Console.WriteLine(_finishedGameMessage);
}
}
}
public void HandleGameMasterDisconnection()
{
VerboseLogger.Log($"GM for game {GameId} disconnected");
RestartStateCoordinator();
}
public override int ExecuteCommand(RemoveLinesOptions options)
{
var log = new VerboseLogger(options);
log.Info($"Reading file {options.InputFile}");
var input = FileService.ReadLinesLazily(options.InputFile);
var patternsConcatenated = options.Patterns;
patternsConcatenated = patternsConcatenated.Replace("\\#", " ");
var patterns = patternsConcatenated.Split('#');
for (int i = 0; i < patterns.Length; i += 1)
{
patterns[i] = patterns[i].Replace(" ", "#");
}
var matches = MatchesPatterns(patterns, options.ConjunctivePatterns);
var remaining = input.Where(x => !matches(x));
if (options.OutputFile == null || options.OutputFile == options.InputFile)
{
remaining = remaining.ToList();
}
FileService.WriteAllLines(options.OutputFile ?? options.InputFile, remaining);
//List<string>[] result;
//List<string> compare = new List<string>();
//if (input.Length < LineParallelThreshold)
//{
// result = new List<string>[1];
// result[0] = MatchSequentially(input, 0, input.Length, MatchesPatterns(patterns, options.ConjunctivePatterns));
//}
//else
//{
// var availableCores = System.Environment.ProcessorCount;
// var linesPerCore = input.Length / availableCores;
// result = new List<string>[availableCores];
// var tasks = new Task<List<string>>[availableCores - 1];
// for (int i = 0; i < availableCores - 1; i += 1)
// {
// var i1 = i;
// tasks[i] = Task.Run(() => MatchSequentially(input, i1 * linesPerCore,
// ( i1 + 1 ) * linesPerCore,
// MatchesPatterns(patterns, options.ConjunctivePatterns)));
// }
// result[availableCores - 1] = MatchSequentially(input, ( availableCores - 1 ) * linesPerCore,
// input.Length, MatchesPatterns(patterns, options.ConjunctivePatterns));
// for (int i = 0; i < availableCores - 1; i += 1)
// {
// result[i] = tasks[i].Result;
// }
//}
////var result = input.WhereNot(MatchesPatterns(patterns, options.ConjunctivePatterns)).ToArray();
//var destination = options.OutputFile ?? options.InputFile;
//var arrayResult = MakeArray(result);
//_fileService.WriteAllLines(destination, arrayResult);
return(0);
}
internal static void VerboseLog(string msg)
{
VerboseLogger?.Invoke(msg);
}
public HttpWebRequestAgent(
VerboseLogger verboseLogger)
{
VerboseLogger = verboseLogger;
}
public int ExecuteCommand(StatisticalFunctionsOptions options)
{
Log = new VerboseLogger(options);
List <Data> data;
try
{
data = RetrieveData(options);
}
catch (Exception exc)
{
Log.Error(exc, "Error while reading data from database");
return(-1);
}
if (data == null || data.Count == 0)
{
Log.Error($"No data found in table {options.DatabaseTable}");
return(1);
}
var funcs = options.Functions.ToArray();
var results = new string[funcs.Length];
Data[][] res = new Data[funcs.Length][];
for (int i = 0; i < funcs.Length; i += 1)
{
switch (funcs[i])
{
case "average":
Log.Info("Calculating average");
res[i] = Calculate(data, d => d.Average(x => x.Value));
break;
case "median":
Log.Info("Calculating median");
res[i] = Calculate(data, CalculateMedian);
break;
case "variance":
Log.Info("Calculating variance");
res[i] = Calculate(data, CalculateVariance);
break;
}
}
Log.Info($"Opening {options.DatabaseFile}");
using (var connection = SQLiteHelpers.CreateConnection(options.DatabaseFile))
{
connection.Open();
var command = new SQLiteCommand(connection)
{
CommandText =
$"CREATE TABLE IF NOT EXISTS {options.DatabaseTableOut} ({GetColumns(options.Groups, "TEXT")}, {GetColumns(funcs, "REAL")});"
};
Log.Info($"Executing Command: {command.CommandText}");
command.ExecuteNonQuery();
List <string> valuesList = new List <string>();
foreach (var d in res[0])
{
var groups = string.Join(",", d.Groups.Select(g => $"'{g}'"));
var values = string.Join(",", FindValues(d, res));
valuesList.Add($"({groups}, {values})");
}
command.CommandText = $"INSERT INTO {options.DatabaseTableOut} VALUES {string.Join(",", valuesList)};";
Log.Info($"Inserting Values into: {options.DatabaseTableOut}");
command.ExecuteNonQuery();
command.Dispose();
Log.Info("Closing Database");
connection.Close();
}
return(0);
}
