public Parser(CommandLineConfiguration configuration)
{
Configuration = configuration ?? throw new ArgumentNullException(nameof(configuration));
}
internal static TokenizeResult Tokenize(
this IReadOnlyList <string> args,
CommandLineConfiguration configuration)
{
var tokenList = new List <Token>();
var errorList = new List <TokenizeError>();
ICommand?currentCommand = null;
var foundEndOfArguments = false;
var foundEndOfDirectives = !configuration.EnableDirectives;
var argList = NormalizeRootCommand(configuration, args);
var argumentDelimiters = configuration.ArgumentDelimitersInternal.ToArray();
var knownTokens = configuration.RootCommand.ValidTokens();
for (var i = 0; i < argList.Count; i++)
{
var arg = argList[i];
if (foundEndOfArguments)
{
tokenList.Add(Operand(arg));
continue;
}
if (arg == "--")
{
tokenList.Add(EndOfArguments());
foundEndOfArguments = true;
continue;
}
if (!foundEndOfDirectives)
{
if (arg.StartsWith("[") &&
arg.EndsWith("]") &&
arg[1] != ']' &&
arg[1] != ':')
{
tokenList.Add(Directive(arg));
continue;
}
if (!configuration.RootCommand.HasAlias(arg))
{
foundEndOfDirectives = true;
}
}
if (configuration.ResponseFileHandling != ResponseFileHandling.Disabled &&
arg.GetResponseFileReference() is { } filePath)
{
ReadResponseFile(filePath, i);
continue;
}
if (configuration.EnablePosixBundling &&
CanBeUnbundled(arg, out IReadOnlyCollection <string>?replacement))
{
argList.InsertRange(i + 1, replacement);
argList.RemoveAt(i);
arg = argList[i];
}
if (arg.TrySplitIntoSubtokens(argumentDelimiters,
out var first,
out var rest))
{
if (knownTokens.TryGetValue(first !, out var token) &&
token.Type == TokenType.Option)
{
tokenList.Add(Option(first !));
// trim outer quotes in case of, e.g., -x="why"
var secondPartWithOuterQuotesRemoved = rest !.Trim('"');
tokenList.Add(Argument(secondPartWithOuterQuotesRemoved));
}
internal static TokenizeResult Tokenize(
this IReadOnlyList <string> args,
CommandLineConfiguration configuration,
bool inferRootCommand = true)
{
var errorList = new List <string>();
var currentCommand = configuration.RootCommand;
var foundDoubleDash = false;
var foundEndOfDirectives = !configuration.EnableDirectives;
var argList = NormalizeRootCommand(args, configuration.RootCommand, inferRootCommand);
var tokenList = new List <Token>(argList.Count);
var knownTokens = configuration.RootCommand.ValidTokens();
for (var i = 0; i < argList.Count; i++)
{
var arg = argList[i];
if (foundDoubleDash)
{
tokenList.Add(CommandArgument(arg, currentCommand !));
continue;
}
if (!foundDoubleDash &&
arg == "--")
{
tokenList.Add(DoubleDash());
foundDoubleDash = true;
continue;
}
if (!foundEndOfDirectives)
{
if (arg.Length > 2 &&
arg[0] == '[' &&
arg[1] != ']' &&
arg[1] != ':' &&
arg.EndsWith("]", StringComparison.Ordinal))
{
tokenList.Add(Directive(arg));
continue;
}
if (!configuration.RootCommand.HasAlias(arg))
{
foundEndOfDirectives = true;
}
}
if (configuration.EnableTokenReplacement &&
configuration.TokenReplacer is { } replacer&&
arg.GetReplaceableTokenValue() is { } value)
{
if (replacer(
value,
out var newTokens,
out var error))
{
argList.InsertRange(i + 1, newTokens ?? Array.Empty <string>());
continue;
}
protected virtual void UpdateConfiguration(CommandLineConfiguration config)
{
}
private static ICommandLineConfiguration CreateConfiguration(
IEnumerable <string> sdksToResolve,
PathTable pathTable,
AbsolutePath testFolderPath)
{
var configFilePath = testFolderPath.Combine(pathTable, Names.ConfigDsc);
var packageFilePath = testFolderPath.Combine(pathTable, Names.ModuleConfigBm);
var sdkPackages = sdksToResolve
.SelectMany(folder =>
Directory.EnumerateFiles(folder, Names.PackageConfigDsc, SearchOption.AllDirectories).Concat(
Directory.EnumerateFiles(folder, Names.ModuleConfigBm, SearchOption.AllDirectories).Concat(
Directory.EnumerateFiles(folder, Names.ModuleConfigDsc, SearchOption.AllDirectories))))
.Select(packageFile => AbsolutePath.Create(pathTable, packageFile))
.ToList();
var configuration =
new CommandLineConfiguration
{
// Have to new up the list because we have some bad semantics dealing with the list being null or not.
Packages = new List <AbsolutePath>
{
packageFilePath,
},
Resolvers =
{
new SourceResolverSettings
{
Kind = "SourceResolver",
Modules = sdkPackages,
},
},
FrontEnd =
{
MaxFrontEndConcurrency = 1, // Single threaded for deterministic evaluation
NameResolutionSemantics = NameResolutionSemantics.ImplicitProjectReferences,
// PreserveFullNames = true, Some comment in code as not to turn on, check with folks....
UsePartialEvaluation = true,
UseSpecPublicFacadeAndAstWhenAvailable = false,
ConstructAndSaveBindingFingerprint = false,
// Some of the DS tests fail when incremental frontend is not used
EnableIncrementalFrontEnd = true,
},
Engine =
{
TrackBuildsInUserFolder = false,
},
Layout =
{
OutputDirectory = testFolderPath.Combine(pathTable, "Out"),
ObjectDirectory = testFolderPath.Combine(pathTable, "Out").Combine(pathTable, "Objects"),
PrimaryConfigFile = configFilePath,
SourceDirectory = testFolderPath,
TempDirectory = testFolderPath.Combine(pathTable, "Out").Combine(pathTable, "Temp"),
},
Mounts =
{
},
Startup =
{
ConfigFile = configFilePath,
},
};
return(configuration);
}
private GraphReuseResult ReloadPipGraphOnly(
EngineSerializer serializer,
LoggingContext loggingContext,
EngineState engineState,
InputTracker.InputChanges inputChanges)
{
Tuple <PipGraph, EngineContext> t = null;
try
{
t = EngineSchedule.LoadPipGraphAsync(
Context,
serializer,
Configuration,
loggingContext,
engineState).GetAwaiter().GetResult();
}
catch (BuildXLException e)
{
Logger.Log.FailedReloadPipGraph(loggingContext, e.ToString());
}
if (t == null)
{
return(GraphReuseResult.CreateForNoReuse(inputChanges));
}
var newContext = t.Item2;
if (!ShouldReuseReloadedEngineContextGivenHistoricData(loggingContext, newContext.NextHistoricTableSizes))
{
return(GraphReuseResult.CreateForNoReuse(inputChanges));
}
var newPathTable = newContext.PathTable;
var pathRemapper = new PathRemapper(Context.PathTable, newPathTable);
Configuration = new ConfigurationImpl(Configuration, pathRemapper);
m_initialCommandLineConfiguration = new CommandLineConfiguration(m_initialCommandLineConfiguration, pathRemapper);
// Invalidate the old context to ensure nothing uses it anymore
// Update engine state to deserialized state
Context.Invalidate();
Context = newContext;
// Additionally recreate front end controller, because the old one uses the invalidated context.
// - to fully initialize the front end, we have to go through all the steps that have already been
// executed on the old controller; those steps are (1) InitializeHost, and (2) ParseConfig
FrontEndController = m_frontEndControllerFactory.Create(Context.PathTable, Context.SymbolTable);
FrontEndController.InitializeHost(Context.ToFrontEndContext(loggingContext), m_initialCommandLineConfiguration);
var configurationEngine = new BasicFrontEndEngineAbstraction(Context.PathTable, Context.FileSystem, m_initialCommandLineConfiguration);
if (!configurationEngine.TryPopulateWithDefaultMountsTable(loggingContext, Context, m_initialCommandLineConfiguration, m_initialCommandLineConfiguration.Startup.Properties))
{
Contract.Assert(loggingContext.ErrorWasLogged);
return(null);
}
FrontEndController.ParseConfig(configurationEngine, m_initialCommandLineConfiguration);
return(GraphReuseResult.CreateForPartialReuse(t.Item1, inputChanges));
}
protected BaseEngineTest(ITestOutputHelper output)
: base(output)
{
m_testOutput = output;
m_ignoreWarnings = OperatingSystemHelper.IsUnixOS; // ignoring /bin/sh is being used as a source file
RegisterEventSource(global::BuildXL.Scheduler.ETWLogger.Log);
RegisterEventSource(global::BuildXL.FrontEnd.Script.ETWLogger.Log);
RegisterEventSource(global::BuildXL.FrontEnd.Core.ETWLogger.Log);
RegisterEventSource(global::BuildXL.Engine.ETWLogger.Log);
RegisterEventSource(global::BuildXL.Processes.ETWLogger.Log);
ParseAndEvaluateLogger = Logger.CreateLogger();
InitializationLogger = InitializationLogger.CreateLogger();
var pathTable = new PathTable();
FileSystem = new PassThroughMutableFileSystem(pathTable);
Context = EngineContext.CreateNew(CancellationToken.None, pathTable, FileSystem);
MainSourceResolverModules = new List <AbsolutePath>();
var rootPath = AbsolutePath.Create(Context.PathTable, TestRoot);
var logsPath = Combine(AbsolutePath.Create(Context.PathTable, TemporaryDirectory), "logs");
Configuration = new CommandLineConfiguration()
{
DisableDefaultSourceResolver = true,
Resolvers = new List <IResolverSettings>
{
new SourceResolverSettings
{
Kind = "SourceResolver",
Modules = MainSourceResolverModules,
},
new SourceResolverSettings
{
Kind = "SourceResolver",
Modules = new List <AbsolutePath>
{
AbsolutePath.Create(Context.PathTable, Path.Combine(GetTestExecutionLocation(), "Sdk", "Prelude", "package.config.dsc")),
AbsolutePath.Create(Context.PathTable, Path.Combine(GetTestExecutionLocation(), "Sdk", "Transformers", "package.config.dsc")),
AbsolutePath.Create(Context.PathTable, Path.Combine(GetTestExecutionLocation(), "Sdk", "Deployment", "module.config.dsc")),
},
},
},
Layout =
{
SourceDirectory = rootPath,
OutputDirectory = Combine(rootPath, "out"),
ObjectDirectory = Combine(rootPath, "obj"),
CacheDirectory = Combine(AbsolutePath.Create(Context.PathTable, TemporaryDirectory), "cache"),
},
Cache =
{
CacheSpecs = SpecCachingOption.Disabled,
CacheLogFilePath = logsPath.Combine(Context.PathTable,PathAtom.Create(Context.StringTable, "cache.log")),
},
Engine =
{
ReuseEngineState = false,
LogStatistics = false,
TrackBuildsInUserFolder = false,
},
FrontEnd =
{
MaxFrontEndConcurrency = 1,
LogStatistics = false,
},
Schedule =
{
MaxIO = 1,
MaxProcesses = 1,
},
Sandbox =
{
FileSystemMode = FileSystemMode.RealAndMinimalPipGraph,
OutputReportingMode = OutputReportingMode.FullOutputOnError,
},
Logging =
{
LogsDirectory = logsPath,
LogStats = false,
LogExecution = false,
LogCounters = false,
LogMemory = false,
StoreFingerprints = false,
NoWarnings =
{
909, // Disable warnings about experimental feature
},
}
};
AbsolutePath Combine(AbsolutePath parent, string name)
{
return(parent.Combine(Context.PathTable, PathAtom.Create(Context.StringTable, name)));
}
}
private static void ShowUsage(CommandLineConfiguration configuration, string parseResult = "")
{
Usage usage = new UsageComposer(configuration).Compose();
if (String.IsNullOrEmpty(parseResult))
{
var build = ((AssemblyInformationalVersionAttribute)Assembly
.GetAssembly(typeof(Program))
.GetCustomAttributes(typeof(AssemblyInformationalVersionAttribute), false)[0])
.InformationalVersion;
Console.WriteLine(@"
██▓███ ▓█████ ██▀███ ▄████▄ ██▓ ██▓███ ██▓ ▒█████
▓██░ ██▒▓█ ▀ ▓██ ▒ ██▒▒██▀ ▀█ ▓██▒▓██░ ██▒ ▓██▒▒██▒ ██▒
▓██░ ██▓▒▒███ ▓██ ░▄█ ▒▒▓█ ▄ ▒██▒▓██░ ██▓▒ ▒██▒▒██░ ██▒
▒██▄█▓▒ ▒▒▓█ ▄ ▒██▀▀█▄ ▒▓▓▄ ▄██▒░██░▒██▄█▓▒ ▒ ░██░▒██ ██░
▒██▒ ░ ░░▒████▒░██▓ ▒██▒▒ ▓███▀ ░░██░▒██▒ ░ ░ ██▓ ░██░░ ████▓▒░
▒▓▒░ ░ ░░░ ▒░ ░░ ▒▓ ░▒▓░░ ░▒ ▒ ░░▓ ▒▓▒░ ░ ░ ▒▓▒ ░▓ ░ ▒░▒░▒░
░▒ ░ ░ ░ ░ ░▒ ░ ▒░ ░ ▒ ▒ ░░▒ ░ ░▒ ▒ ░ ░ ▒ ▒░
░░ ░ ░░ ░ ░ ▒ ░░░ ░ ▒ ░░ ░ ░ ▒
░ ░ ░ ░ ░ ░ ░ ░ ░ ░
░ ░
Percip.io {0} - The working time logger by antic_eye ;)
Use this tool to track your productivity. MyLock generates an
encrypted database file that contains timestamps and ""in""
or ""out"".
When you call myLock with ""lock"" it tracks:
01.01.2016T08: 15 Max.Mustermann Out
When you call without args it tracks:
01.01.2016T08: 19 Max.Mustermann In
When you want to show your times, call it with ""--query"".It will
read the db and calculate your working time beginning with the
first ""in"" per day, ending with the last ""out"".
To automate the tracking, use ""--init"" and myLock will generate
Windows Scheduled tasks for screen lock/unlock and session
login/-out. You will need administrative permissions for this
task. Open an elevated command prompt.
", build);
Console.WriteLine("Usage: percip.io.exe {0}", usage.Arguments);
Console.WriteLine();
Console.WriteLine(usage.Options);
Console.WriteLine("Exit codes:");
foreach (var e in Enum.GetValues(typeof(ExitCode)))
{
Console.WriteLine(string.Format("{0,4}\t{1}",
(int)e,
e.ToString()));
}
}
else
{
Console.WriteLine(parseResult);
Console.WriteLine();
}
}
internal static TokenizeResult Tokenize(
this IReadOnlyList <string> args,
CommandLineConfiguration configuration)
{
var tokenList = new List <Token>();
var errorList = new List <TokenizeError>();
ICommand currentCommand = null;
var foundEndOfArguments = false;
var foundEndOfDirectives = !configuration.EnableDirectives;
var argList = NormalizeRootCommand(configuration, args);
var argumentDelimiters = configuration.ArgumentDelimiters.ToArray();
var knownTokens = new HashSet <Token>(configuration.Symbols.SelectMany(ValidTokens));
var knownTokensStrings = new HashSet <string>(knownTokens.Select(t => t.Value));
for (var i = 0; i < argList.Count; i++)
{
var arg = argList[i];
if (foundEndOfArguments)
{
tokenList.Add(Operand(arg));
continue;
}
if (arg == "--")
{
tokenList.Add(EndOfArguments());
foundEndOfArguments = true;
continue;
}
if (!foundEndOfDirectives)
{
if (arg.StartsWith("[") &&
arg.EndsWith("]") &&
arg[1] != ']' &&
arg[1] != ':')
{
tokenList.Add(Directive(arg));
continue;
}
if (!configuration.RootCommand.HasRawAlias(arg))
{
foundEndOfDirectives = true;
}
}
if (configuration.ResponseFileHandling != ResponseFileHandling.Disabled &&
arg.GetResponseFileReference() is { } filePath)
{
ReadResponseFile(filePath, i);
continue;
}
if (configuration.EnablePosixBundling &&
CanBeUnbundled(arg, out var replacement))
{
argList.InsertRange(i + 1, replacement);
argList.RemoveAt(i);
arg = argList[i];
}
if (arg.SplitByDelimiters(argumentDelimiters) is { } subtokens&&
subtokens.Length > 1)
{
if (knownTokensStrings.Contains(subtokens[0]))
{
tokenList.Add(Option(subtokens[0]));
if (subtokens.Length > 1)
{
// trim outer quotes in case of, e.g., -x="why"
var secondPartWithOuterQuotesRemoved = subtokens[1].Trim('"');
tokenList.Add(Argument(secondPartWithOuterQuotesRemoved));
}
}
else
{
tokenList.Add(Argument(arg));
}
}
protected BaseEngineTest(ITestOutputHelper output)
: base(output)
{
TestOutput = output;
m_ignoreWarnings = OperatingSystemHelper.IsUnixOS; // ignoring /bin/sh is being used as a source file
RegisterEventSource(global::BuildXL.Scheduler.ETWLogger.Log);
RegisterEventSource(global::BuildXL.Pips.ETWLogger.Log);
RegisterEventSource(global::BuildXL.FrontEnd.Script.ETWLogger.Log);
RegisterEventSource(global::BuildXL.FrontEnd.Core.ETWLogger.Log);
RegisterEventSource(global::BuildXL.Engine.ETWLogger.Log);
RegisterEventSource(global::BuildXL.Processes.ETWLogger.Log);
ParseAndEvaluateLogger = Logger.CreateLoggerWithTracking();
InitializationLogger = InitializationLogger.CreateLogger();
var pathTable = new PathTable();
FileSystem = new PassThroughMutableFileSystem(pathTable);
Context = EngineContext.CreateNew(CancellationToken.None, pathTable, FileSystem);
MainSourceResolverModules = new List <AbsolutePath>();
var rootPath = AbsolutePath.Create(Context.PathTable, TestRoot);
var logsPath = Combine(AbsolutePath.Create(Context.PathTable, TemporaryDirectory), "logs");
Configuration = new CommandLineConfiguration()
{
DisableDefaultSourceResolver = true,
Resolvers = new List <IResolverSettings>
{
new SourceResolverSettings
{
Kind = "SourceResolver",
Modules = MainSourceResolverModules,
},
new SourceResolverSettings
{
Kind = "SourceResolver",
Modules = new List <AbsolutePath>
{
AbsolutePath.Create(Context.PathTable, Path.Combine(GetTestExecutionLocation(), "Sdk", "Prelude", "package.config.dsc")),
AbsolutePath.Create(Context.PathTable, Path.Combine(GetTestExecutionLocation(), "Sdk", "Transformers", "package.config.dsc")),
AbsolutePath.Create(Context.PathTable, Path.Combine(GetTestExecutionLocation(), "Sdk", "Deployment", "module.config.dsc")),
},
},
},
Layout =
{
SourceDirectory = rootPath,
OutputDirectory = Combine(rootPath, "out"),
ObjectDirectory = Combine(rootPath, "obj"),
CacheDirectory = Combine(AbsolutePath.Create(Context.PathTable, TemporaryDirectory), "cache"),
},
Cache =
{
CacheSpecs = SpecCachingOption.Disabled,
CacheLogFilePath = logsPath.Combine(Context.PathTable,PathAtom.Create(Context.StringTable, "cache.log")),
},
Engine =
{
ReuseEngineState = false,
LogStatistics = false,
TrackBuildsInUserFolder = false,
},
FrontEnd =
{
MaxFrontEndConcurrency = 1,
LogStatistics = false,
},
Schedule =
{
MaxIO = 1,
MaxProcesses = 1,
},
Sandbox =
{
FileSystemMode = FileSystemMode.RealAndMinimalPipGraph,
OutputReportingMode = OutputReportingMode.FullOutputOnError,
},
Logging =
{
LogsDirectory = logsPath,
LogStats = false,
LogExecution = false,
LogCounters = false,
LogMemory = false,
StoreFingerprints = false,
NoWarnings =
{
909, // Disable warnings about experimental feature
},
}
};
if (TryGetSubstSourceAndTarget(out string substSource, out string substTarget))
{
// Directory translation is needed here particularly when the test temporary directory
// is inside a directory that is actually a junction to another place.
// For example, the temporary directory is D:\src\BuildXL\Out\Object\abc\t_1, but
// the path D:\src\BuildXL\Out or D:\src\BuildXL\Out\Object is a junction to K:\Out.
// Some tool, like cmd, can access the path in K:\Out, and thus the test will have a DFA
// if there's no directory translation.
// This problem does not occur when only substs are involved, but no junctions. The method
// TryGetSubstSourceAndTarget works to get translations due to substs or junctions.
AbsolutePath substSourcePath = AbsolutePath.Create(Context.PathTable, substSource);
AbsolutePath substTargetPath = AbsolutePath.Create(Context.PathTable, substTarget);
Configuration.Engine.DirectoriesToTranslate.Add(
new TranslateDirectoryData(I($"{substSource}<{substTarget}"), substSourcePath, substTargetPath));
}
}
public ConfigurationConverterTests()
{
m_context = FrontEndContext.CreateInstanceForTesting();
m_defaultConf = new CommandLineConfiguration();
}
/// <nodoc />
public Args(string[] args, Func <AnalyzerKind, Analyzer> analyzerFactory, PathTable pathTable)
: base(args)
{
m_pathTable = pathTable;
CommandLineConfig = new CommandLineConfiguration();
Analyzers = new List <Analyzer>();
Analyzer currentAnalyzer = null;
foreach (Option opt in Options)
{
if (opt.Name.Equals("filter", StringComparison.OrdinalIgnoreCase) ||
opt.Name.Equals("f", StringComparison.OrdinalIgnoreCase))
{
CommandLineConfig.Filter = opt.Value;
}
else if (opt.Name.Equals("config", StringComparison.OrdinalIgnoreCase) ||
opt.Name.Equals("c", StringComparison.OrdinalIgnoreCase))
{
CommandLineConfig.Startup.ConfigFile = AbsolutePath.Create(m_pathTable, opt.Value);
}
else if (opt.Name.Equals("property", StringComparison.OrdinalIgnoreCase) || opt.Name.Equals("p", StringComparison.OrdinalIgnoreCase))
{
ParsePropertyOption(opt, CommandLineConfig.Startup.Properties);
}
else if (opt.Name.Equals("InCloudBuild", StringComparison.OrdinalIgnoreCase))
{
CommandLineConfig.InCloudBuild = ParseBooleanOption(opt);
}
else if (opt.Name.Equals("objectDirectory", StringComparison.OrdinalIgnoreCase))
{
CommandLineConfig.Layout.ObjectDirectory = AbsolutePath.Create(m_pathTable, GetFullPath(opt.Value, opt));
}
else if (opt.Name.Equals("outputDirectory", StringComparison.OrdinalIgnoreCase))
{
CommandLineConfig.Layout.OutputDirectory = AbsolutePath.Create(m_pathTable, GetFullPath(opt.Value, opt));
}
else if (opt.Name.Equals("RedirectedUserProfileJunctionRoot", StringComparison.OrdinalIgnoreCase))
{
CommandLineConfig.Layout.RedirectedUserProfileJunctionRoot = AbsolutePath.Create(m_pathTable, GetFullPath(opt.Value, opt));
}
else if (opt.Name.Equals("fix", StringComparison.OrdinalIgnoreCase))
{
Fix = ParseBooleanOption(opt);
}
else if (opt.Name.Equals("analyzer", StringComparison.OrdinalIgnoreCase) ||
opt.Name.Equals("a", StringComparison.OrdinalIgnoreCase))
{
var analyzerType = ParseEnumOption <AnalyzerKind>(opt);
var newAnalyzer = analyzerFactory(analyzerType);
if (newAnalyzer == null)
{
throw Error(I($"Unsupported Analyzer type '{analyzerType}'. Supported types are: {string.Join(", ", Enum.GetValues(typeof(AnalyzerKind)).Cast<string>())}"));
}
currentAnalyzer = newAnalyzer;
Analyzers.Add(currentAnalyzer);
}
else if (s_helpStrings.Any(s => opt.Name.Equals(s, StringComparison.OrdinalIgnoreCase)))
{
Help = true;
WriteHelp(analyzerFactory);
}
else
{
if (currentAnalyzer == null)
{
throw Error(I($"Unsupported option: {opt.Name}."));
}
else
{
if (!currentAnalyzer.HandleOption(opt))
{
throw new InvalidOperationException(I($"Unsupported option '{opt.Name}'. This option is not supported by analyzer {currentAnalyzer.Kind}."));
}
}
}
}
if (string.IsNullOrEmpty(CommandLineConfig.Filter) && !CommandLineConfig.Startup.ConfigFile.IsValid)
{
throw Error("Must specify at least /Config -or- /Filter argument.");
}
if (Analyzers.Count == 0)
{
throw Error("Must specify at least one Analyzer.");
}
}
/// <summary>
/// Runs the scheduler allowing various options to be specifically set
/// </summary>
public ScheduleRunResult RunSchedulerSpecific(
PipGraph graph,
SchedulerTestHooks testHooks = null,
SchedulerState schedulerState = null,
RootFilter filter = null,
TempCleaner tempCleaner = null)
{
var config = new CommandLineConfiguration(Configuration);
// Populating the configuration may modify the configuration, so it should occur first.
BuildXLEngine.PopulateLoggingAndLayoutConfiguration(config, Context.PathTable, bxlExeLocation: null, inTestMode: true);
BuildXLEngine.PopulateAndValidateConfiguration(config, config, Context.PathTable, LoggingContext);
FileAccessWhitelist whitelist = new FileAccessWhitelist(Context);
whitelist.Initialize(config);
IReadOnlyList <string> junctionRoots = Configuration.Engine.DirectoriesToTranslate?.Select(a => a.ToPath.ToString(Context.PathTable)).ToList();
var map = VolumeMap.TryCreateMapOfAllLocalVolumes(LoggingContext, junctionRoots);
var optionalAccessor = TryGetJournalAccessor(map);
// Although scan change journal is enabled, but if we cannot create an enabled journal accessor, then create a disabled one.
m_journalState = map == null || !optionalAccessor.IsValid
? JournalState.DisabledJournal
: JournalState.CreateEnabledJournal(map, optionalAccessor.Value);
if (config.Schedule.IncrementalScheduling)
{
// Ensure that we can scan the journal when incremental scheduling is enabled.
XAssert.IsTrue(m_journalState.IsEnabled, "Incremental scheduling requires that journal is enabled");
}
// Seal the translator if not sealed
DirectoryTranslator.Seal();
// .....................................................................................
// some dummy setup in order to get a PreserveOutputsSalt.txt file and an actual salt
// .....................................................................................
string dummyCacheDir = Path.Combine(TemporaryDirectory, "Out", "Cache");
Directory.CreateDirectory(dummyCacheDir); // EngineSchedule tries to put the PreserveOutputsSalt.txt here
ContentHash?previousOutputsSalt =
EngineSchedule.PreparePreviousOutputsSalt(LoggingContext, Context.PathTable, config);
Contract.Assert(previousOutputsSalt.HasValue);
// .....................................................................................
testHooks = testHooks ?? new SchedulerTestHooks();
Contract.Assert(!(config.Engine.CleanTempDirectories && tempCleaner == null));
using (var queue = new PipQueue(config.Schedule))
using (var testQueue = new TestPipQueue(queue, LoggingContext, initiallyPaused: false))
using (var testScheduler = new TestScheduler(
graph: graph,
pipQueue: testQueue,
context: Context,
fileContentTable: FileContentTable,
loggingContext: LoggingContext,
cache: Cache,
configuration: config,
journalState: m_journalState,
fileAccessWhitelist: whitelist,
fingerprintSalt: Configuration.Cache.CacheSalt,
directoryMembershipFingerprinterRules: new DirectoryMembershipFingerprinterRuleSet(Configuration, Context.StringTable),
tempCleaner: tempCleaner,
previousInputsSalt: previousOutputsSalt.Value,
successfulPips: null,
failedPips: null,
ipcProvider: null,
directoryTranslator: DirectoryTranslator,
testHooks: testHooks))
{
if (filter == null)
{
EngineSchedule.TryGetPipFilter(LoggingContext, Context, config, config, Expander.TryGetRootByMountName, out filter);
}
XAssert.IsTrue(testScheduler.InitForMaster(LoggingContext, filter, schedulerState), "Failed to initialized test scheduler");
testScheduler.Start(LoggingContext);
bool success = testScheduler.WhenDone().GetAwaiter().GetResult();
testScheduler.SaveFileChangeTrackerAsync(LoggingContext).Wait();
if (ShouldLogSchedulerStats)
{
// Logs are not written out normally during these tests, but LogStats depends on the existence of the logs directory
// to write out the stats perf JSON file
var logsDir = config.Logging.LogsDirectory.ToString(Context.PathTable);
Directory.CreateDirectory(logsDir);
testScheduler.LogStats(LoggingContext);
}
return(new ScheduleRunResult
{
Graph = graph,
Config = config,
Success = success,
PipResults = testScheduler.PipResults,
PipExecutorCounters = testScheduler.PipExecutionCounters,
PathSets = testScheduler.PathSets,
ProcessPipCountersByFilter = testScheduler.ProcessPipCountersByFilter,
ProcessPipCountersByTelemetryTag = testScheduler.ProcessPipCountersByTelemetryTag,
SchedulerState = new SchedulerState(testScheduler)
});
}
}
protected string[] ExtractRelevantTokens(
CommandLineConfiguration cmdLineConfig,
string[] args)
{
var readOnly = new ReadOnlyCollection <string>(args);
var tokenized = readOnly.Tokenize(cmdLineConfig);
if (tokenized.Errors.Count > 0)
{
throw new InvalidOperationException(
$"Couldn't parse command line arguments for command '{Command.Name}'");
}
// first token appears to contain the command we're tokenizing for
var cmdName = tokenized.Tokens.First().Value;
var retVal = new List <string>();
var extract = false;
var completed = false;
// scan all the tokens but only extract them for parsing when
// they relate to our command. There are two ways that is signified.
// For RootCommands there will be a Command type token whose value
// matches cmdName (it appears to always be the first token).
// For regular Commands there will be an Argument type token whose
// value matches cmdName. Note that for regular Commands we skip
// the first token because it's not relevant
foreach (var token in tokenized.Tokens.Skip(ObjectBinder.Command is RootCommand ? 0 : 1))
{
switch (token.Type)
{
case TokenType.Argument:
// if we're already extracting the token is related to
// an option that should have already been captured
if (extract)
{
retVal.Add(token.Value);
}
else
{
// if the argument value matches the cmdName start extracting
if (token.Value.Equals(cmdName, StringComparison.OrdinalIgnoreCase))
{
extract = true;
retVal.Add(token.Value);
}
}
break;
case TokenType.Command:
if (token.Value.Equals(Command.Name, StringComparison.OrdinalIgnoreCase))
{
extract = true;
retVal.Add(token.Value);
}
else
{
completed = true;
}
break;
case TokenType.Option:
case TokenType.Operand:
if (extract)
{
retVal.Add(token.Value);
}
break;
case TokenType.Directive:
// no op; we don't handle directives yet so ignore them
break;
case TokenType.EndOfArguments:
extract = false;
completed = true;
break;
}
if (completed)
{
break;
}
}
return(retVal.ToArray());
}
private static void ShowUsage(CommandLineConfiguration configuration, string parseResult = "")
{
Usage usage = new UsageComposer(configuration).Compose();
if (String.IsNullOrEmpty(parseResult))
{
var build = ((AssemblyInformationalVersionAttribute)Assembly
.GetAssembly(typeof(Program))
.GetCustomAttributes(typeof(AssemblyInformationalVersionAttribute), false)[0])
.InformationalVersion;
Console.WriteLine(@"
██▓███ ▓█████ ██▀███ ▄████▄ ██▓ ██▓███ ██▓ ▒█████
▓██░ ██▒▓█ ▀ ▓██ ▒ ██▒▒██▀ ▀█ ▓██▒▓██░ ██▒ ▓██▒▒██▒ ██▒
▓██░ ██▓▒▒███ ▓██ ░▄█ ▒▒▓█ ▄ ▒██▒▓██░ ██▓▒ ▒██▒▒██░ ██▒
▒██▄█▓▒ ▒▒▓█ ▄ ▒██▀▀█▄ ▒▓▓▄ ▄██▒░██░▒██▄█▓▒ ▒ ░██░▒██ ██░
▒██▒ ░ ░░▒████▒░██▓ ▒██▒▒ ▓███▀ ░░██░▒██▒ ░ ░ ██▓ ░██░░ ████▓▒░
▒▓▒░ ░ ░░░ ▒░ ░░ ▒▓ ░▒▓░░ ░▒ ▒ ░░▓ ▒▓▒░ ░ ░ ▒▓▒ ░▓ ░ ▒░▒░▒░
░▒ ░ ░ ░ ░ ░▒ ░ ▒░ ░ ▒ ▒ ░░▒ ░ ░▒ ▒ ░ ░ ▒ ▒░
░░ ░ ░░ ░ ░ ▒ ░░░ ░ ▒ ░░ ░ ░ ▒
░ ░ ░ ░ ░ ░ ░ ░ ░ ░
░ ░
Percip.io {0} - The working time logger by antic_eye ;)
Use this tool to track your productivity. MyLock generates an
encrypted database file that contains timestamps and ""in""
or ""out"".
When you call myLock with ""lock"" it tracks:
01.01.2016T08: 15 Max.Mustermann Out
When you call without args it tracks:
01.01.2016T08: 19 Max.Mustermann In
When you want to show your times, call it with ""--query"".It will
read the db and calculate your working time beginning with the
first ""in"" per day, ending with the last ""out"".
To automate the tracking, use ""--init"" and myLock will generate
Windows Scheduled tasks for screen lock/unlock and session
login/-out. You will need administrative permissions for this
task. Open an elevated command prompt.
", build);
Console.WriteLine("Usage: percip.io.exe {0}", usage.Arguments);
Console.WriteLine();
Console.WriteLine(usage.Options);
Console.WriteLine("Exit codes:");
foreach (var e in Enum.GetValues(typeof(ExitCode)))
Console.WriteLine(string.Format("{0,4}\t{1}",
(int)e,
e.ToString()));
}
else
{
Console.WriteLine(parseResult);
Console.WriteLine();
}
}
internal static TokenizeResult Tokenize(
this IReadOnlyList <string> args,
CommandLineConfiguration configuration)
{
var errorList = new List <TokenizeError>();
Command?currentCommand = null;
var foundDoubleDash = false;
var foundEndOfDirectives = !configuration.EnableDirectives;
var argList = NormalizeRootCommand(configuration, args);
var tokenList = new List <Token>(argList.Count);
var knownTokens = configuration.RootCommand.ValidTokens();
for (var i = 0; i < argList.Count; i++)
{
var arg = argList[i];
if (foundDoubleDash)
{
if (configuration.EnableLegacyDoubleDashBehavior)
{
tokenList.Add(Unparsed(arg));
}
else
{
tokenList.Add(Argument(arg));
}
continue;
}
if (!foundDoubleDash &&
arg == "--")
{
tokenList.Add(DoubleDash());
foundDoubleDash = true;
continue;
}
if (!foundEndOfDirectives)
{
if (arg.Length > 2 &&
arg[0] == '[' &&
arg[1] != ']' &&
arg[1] != ':' &&
arg.EndsWith("]", StringComparison.Ordinal))
{
tokenList.Add(Directive(arg));
continue;
}
if (!configuration.RootCommand.HasAlias(arg))
{
foundEndOfDirectives = true;
}
}
if (configuration.ResponseFileHandling != ResponseFileHandling.Disabled &&
arg.GetResponseFileReference() is { } filePath)
{
ReadResponseFile(filePath, i);
continue;
}
if (knownTokens.TryGetValue(arg, out var token))
{
if (PreviousTokenIsAnOptionExpectingAnArgument())
{
tokenList.Add(Argument(arg));
}
else
{
switch (token.Type)
{
case TokenType.Option:
tokenList.Add(Option(arg, (Option)token.Symbol !));
break;
case TokenType.Command:
Command cmd = (Command)token.Symbol !;
if (cmd != currentCommand)
{
if (!(currentCommand is null && cmd == configuration.RootCommand))
{
knownTokens = cmd.ValidTokens();
}
currentCommand = cmd;
tokenList.Add(Command(arg, cmd));
}
else
{
tokenList.Add(Argument(arg));
}
break;
}
}
}
else if (arg.TrySplitIntoSubtokens(out var first, out var rest) &&
knownTokens.TryGetValue(first, out var subtoken) && subtoken.Type == TokenType.Option)
{
tokenList.Add(Option(first, (Option)subtoken.Symbol !));
if (rest is { })
private static void WriteUsageToConsole(CommandLineConfiguration commandLineConfiguration, ParseResult parseResult)
{
Usage usage = new UsageComposer(commandLineConfiguration).Compose();
Console.WriteLine(parseResult.Message);
Console.WriteLine("usage:" + usage.Arguments);
Console.WriteLine("options");
Console.WriteLine(usage.Options.IndentBy(4));
Console.WriteLine();
}
public ParseOperation(TokenizeResult tokenizeResult, CommandLineConfiguration configuration)
{
_tokenizeResult = tokenizeResult;
_configuration = configuration;
}
