JetBrains.Platform.BuildInterfaces
Holds an object value of an arbitrary type, plus the logs.
Typical client is running some code under DistroCache so that the logs of the process saved while caching and replayed on cache hit.
The logs in either of representations.
The original logs recorder might give them as a collection of log records. Will be serialized into binary when serializing the whole object.
The main consumer of the logs is dumping them into another logger, which only needs one record at a time, sequentially. So no use in deserializing the collection when restoring from cache. Just take the binary dump (if lucky, would be a direct view into the storage substream), and deserialize on the fly later.
Use to enable a for your -implementing class.
Your class must also have a .ctor which takes a single for the value.
Pass this type to on your artifact, specialized to that same artifact class.
Helpers for implementees.
Use to enable a for your -implementing class.
Your class must also have a .ctor which takes a single for the value.
Pass this type to on your artifact, specialized to that same artifact class.
Makes a logger which turns logger messages into for recording or processing.
Only for handling queries. However, even though no explicit filtering is applied for any outputs, clients will most likely refuse logging events with a level whose is False, so this level will indirectly affect ALL outputs: recording, forwarding, and callbacks. If omitted, allows all messages / always enabled.
Only for handing out as . If omitted, uses one from . If not available, uses this class's type.
Optional. Any logged messages will be streamed into that logger.
Custom log event callback, with the original log event object from .
Custom log event callback, with the build log record created from an event object from .
Turns off recording into .
A default implementation for which just wraps an existing .
A ctor for factoring as a build helper. Use when creating in code.
Wraps the common interface.
Creates a working directory for realizing artifacts into files for the duration of the current build step.
The main idea is that this location is temporary and random, so files cannot be leaked unintendedly between steps and parties if each one uses workdirs for their operations. This avoids undeclared dependencies between resources.
A class which wraps a boolean as a typed value.
Gets the boolean value. An artifact cannot be modified.
For small files, uses the classic behavior with making a memory snapshot.
For larger files, locks the file on disk to prevent modifications, and uses a file stream or a memory mapped view to it.
Path to the file to open. It is an error if the file does not exist, or if there is a directory at that path.
Often you already have some info on the file, like its expected size (e.g. because you looked for those files with , or have assumptions on that). This would save querying filesystem info on the file to determine the way for opening it, which is a relatively slow operation (it's visible in the profiler).
It isn't fatal if you do not give the exact file size, it's only used for decision.
If you do not know, pass NULL. To make this an explicit decision, this isn't an optional parameter.
The impl which always opens from disk.
TODO: impl mmap?
Tries to preview the build environment (formerly, BuildRunnerEnvironment) for the needs of the Engine from artifact values in the current request.
This is needed to compile the script sources and build the part catalog, so the full reader of the request artifacts (with type matching) is not available yet.
For Nuget Config, also tries to guess it from the Product Root.
Build system mostly uses the list of Nuget sources out of this info, for retrieving the packages required for running the build.
The packages taking part in the build itself are managed elsewhere, in build tasks, and might be using another config file.
The request, in either form. Looks up input artifacts in there. “For real” they'd be used in the build, so this is only a “preview”.
See .
If we want to look up nuget config automatically under some “base” folder (eg Product Home Dir in our sln), pass the type of its artifact here, and the path extractor in . Pass to skip.
The config file body, if successful.
Call where possible, this one does just the path-related part of the job. See doc there.
Base iface if we want to enumerate some files or directories to track on disk whether they have changed.
Checking just a file list is simple, but we want to support the case when we're including a whole directory by mask, and if the set of files changes, we want to see that change too. We need to track the original mask and re-query the set of files (in addition to checking the files themselves).
The hierarchy of this interface is as follows:
• Descriptions for individual files.
• Descriptions for folders (with mask, recursive or not, etc).
• Current file bodies in addition to descriptions (when we want to return to caller the set of specific file bodies together with their tracking info) — that's a sub-hierarchy under .
To , adds the file bodies at this moment of time.
That's when we want to return to caller the set of specific file bodies together with their tracking info.
Base iface for those files whose bodies have been collected as file items.
Gets the list of file bodies currently matched by this trackable description.
The is relative to the base dir from which tracking info is constructed.
To get the tracking info for these files, downcast to the specific inheritor, because there is no common info for them.
We need to have the file item body, but it should not be tracked for changes.
An example scenario is when we return a set of file items to the caller as a set of , and need to include generated files among them.
A non-body version (…Description) does not exist.
Loads serialized tracking infos (with full file lists for directories, and file entries both top-level and under directory must have all content hashes and lengths defined).
Loads serialized tracking list (which just lists names of files and names/masks for folders, but does not list specific files in folders, and does not specify file content hashes and lengths for top-level file entries).
It is expensive to enum filesystem, so allow caching results for the short time (when we assume it unchanged).
It is expensive to enum filesystem, so allow caching results for the short time (when we assume it unchanged).
Info for tracking if a set of files under a directory changes (as a set or their bodies), by a specific mask, recursively or not; plus the file bodies collected from the current set.
All paths are relative to the tracking base dir.
Info for tracking if a set of files under a directory changes (as a set or their bodies), by a specific mask, recursively or not.
All paths are relative to the tracking base dir.
Describes one trackable file, either loaded from serialization, or with a body.
Gets info from a FS search entry, this DED MUST be based on the tracking base dir already.
A single file body plus the info for tracking it for changes on disc.
Path is rel to tracking base dir.
The file content. Its path must be relative to the known base dir (say, home dir).
Info for checking a single file for changes.
Path is rel to tracking base dir.
Designates the instance which is used during build for realizing assemblies of the build engine and build entities.
When a subplatform nuget package is produced, a pre-calculated part catalog for its assemblies can be placed in the nuget package jet metadata.
Lists the assemblies for which catalog has been calculated.
Lists the assemblies for which catalog has been calculated, as well as names of the files from which such assemblies should be loaded when needed.
A memory dump of the .
How to place this injection in relation with the standard language imports for this project (e.g. Microsoft.CSharp.Targets).
The “Before” stuff can predefine scalar property values to be used for paths in the standard imports.
The “After” stuff can inject into list property values at first/last position because the standard targets have already had their say.
Import this interface as a build helper for running MSBuild with recommended settings.
Creates a new session for running MSBuild, with all parameters set up accordingly with the currently preferred values, like toolset, degree of parallelism, and so on.
Prevents attempting to use the TC logger for MSBuild when running on TC. If not used, the MSBuild messages would be pumped thru as Logger messages and formatted for TC output.
Gets or sets the timeout for running the child MSBuild process.
The wait will be aborted when the timeout elapses, and child processes will be killed.
Passes name-value pairs as environment variables of the child process.
These are available as regular MSBuild property names in the script, first-level or nested, unless an MSBuild proprety with such a name has another value.
Also available in any executables run from within MSBuild.
MSBuild toolset, which defines the MSBuild version and the compilers it would use.
There is no default, you must supply the toolset to the ctor.
One or more projects to build.
Tells how the projects in the list should be ordered when being supplied to MSBuild.
Passes name-value pairs as MSBuild properties.
These can't be overridden within the first-level MSBuild script, but calling a nested MSBuild task might override any values.
Defines verbosity for MSBuild output.
This property is favored over PS standard "-Verbose" so that it could be easier parameterized on TC and so that it were uniform between MSBuild loggers and out output. All output always goes to the standard output pipeline.
Defines the logging level for informational messages from MSBuild.
These include greeting (with MSBuild toolset), progress messages upon completion of every project, and the final success message.
This does NOT affect any output from the build itself in the form of warnings and errors (regular build messages go as anyway), and the final non-success message for warnings or errors. To handle these fully, make a proxy logger (e.g. ) and filter / re-level messages as you'd wish.
The default level for these informational messages is .
A shortcut for setting certain well-known targets.
A shortcut for setting certain well-known targets for project.
https://docs.microsoft.com/en-us/visualstudio/msbuild/how-to-build-specific-targets-in-solutions-by-using-msbuild-exe?view=vs-2017
Starts the build session with an output into the default logger.
The logger has an unique random suffix to differentiate output from this specific run from other sessions running in parallel.
Starts the build session, allows to abort the run and to output build progress into a custom logger.
It is recommended for the custom logger to have an unique random suffix on the category if it gets output to the global common logger, for telling the sessions running in parallel apart.
A shortcut for setting certain well-known properties for the MSBuild with their typed values.
Problem: MSBuild.exe won't take multiple projects to build. But we still want to be able to do it (running them just in sequence is suboptimal and also fails to utilize the multi-node build).
If this is the case, we'd emit a temporary build file which spawns the build of our projects via the MSBuild task.
Prepares the cmdline for spawning MSBuild.exe (path to exe + args string).
Used to specify the targeted bitness of the .NET Framework for some methods of ToolLocationHelper
Cmdline modification if .
Whether we're not reporting build errors and warnings to the regular build , but rather pumping them directly into the Continuous Integration server, to let it track wrn/err/nesting/progress/whatever with its APIs.
Our own MSBuild in-process log listener is only used for counting errors and warnings in such a case.
Borrowed from MSBuild.
The finaly summary after an MSBuild run, about the warnings and the errors count, is posted to the logger as this exception object.
Runs on the single node.
Runs on multiple nodes, as many as there're CPUs on this machine.
ATTENTION: Don't use /m option for msbuild is case more than one separate msbuilds were run simultaneously!!!
/nodeReuse:false option doesn't grant that process tree will be the same as msbuild connection tree!!!
The windows job object can kill msbuilds which were used for another parallel build runs!!!
Runs on multiple nodes, twice as many as there're CPUs on this machine.
ATTENTION: Don't use /m option for msbuild is case more than one separate msbuilds were run simultaneously!!!
/nodeReuse:false option doesn't grant that process tree will be the same as msbuild connection tree!!!
The windows job object can kill msbuilds which were used for another parallel build runs!!!
Tells how the projects in the list should be ordered when being supplied to MSBuild.
No sorting applied, the projects are dumped into MSBuild in the same order as they're in , and MSBuild deals with their build order on itself.
The projects are sorted lexicographically, to impose some stable ordering. MSBuild still rules out how to make the build correct against all of the dependencies.
The invoker attempts to predict the correct build order of the projects and supply a partially-toposorted list to MSBuild. MSBuild still rules out how to make the build correct against all of the dependencies, so this sorting is not needed/guaranteed to be correct, but there's a supposition that it might improve build perf.
All projects are fed into MSBuild in one batch.
The invoker attempts to predict the correct build order of the projects and supply a partially-toposorted list to MSBuild. MSBuild still rules out how to make the build correct against all of the dependencies, so this sorting is not needed/guaranteed to be correct, but there's a supposition that it might improve build perf.
Projects are fed into MSBuild with smaller batches so that all projects in a batch were not referencing each other. Cons: on a build error, further batches are not executed, unlike the flat mode.
A property which allows to suppress the VC warning “Warning MSB8029. The Intermediate directory or Output directory cannot reside under the Temporary directory as it could lead to issues with incremental build.”, as defined in “C:\Program Files (x86)\MSBuild\Microsoft.Cpp\v4.0\V120\Microsoft.CppBuild.targets” etc.
Server build would use temp folders for int/out dirs to ensure clean rebuild, so this property might be worth using to avoid unwanted warnings.
OBJ directory.
Directory for all output files.
Path of the main output file (e.g. DLL).
Sets the VisualStudioVersion MSBuild global property.
Has no specific meaning, but without it somehow a C++ build might fail with messages like “Error MSB8008. Specified platform toolset (v110_xp) is not installed or invalid. Please make sure that a supported PlatformToolset value is selected.”.
If it does, set to the current VS version.
Names for well-known MSBuild targets, for lookup in intellisense when adding a target.
Gets added by its ToString.
The default MSBuild setup for build tasks.
Toolset name.
Creates a toolset for the given identity.
The identity (either a package id or a synthetic identity for the local machine, see class for details).
Optionally, the nuget package manager is required to fetch the toolset's nuget package when the specifies a package-based toolset.
The task host is required to drive async operations.
Gets a toolset of the specific version installed on the current machine.
A toolset which runs the MSBuild from the given .NET Core SDK with that same SDK runtime.
Gets the toolset' MSBuild version.
For packaged toolsets, this might mean retrieving and inspecting packages, so the async operation might not be immediate.
When running msbuild, the client side might want to receive its logged events, such as errors, warnings, output, and progress messages.
This gives the path to the -implementing assembly compatible with the current toolset.
Gets the path to the MSBuild executable in the toolset.
For packaged toolsets, this would mean retrieving ALL of the packages so that the toolset were ready for actually executing builds when the task completes, so the task might be slow when first called.
When a specific runtime is needed for running msbuild, and the runtime does not derive from the current runtime automatically (example: NetFX and Mono, where you can just run the child managed assembly and the runtime applies automatically), — gives path to the entry executable for that runtime.
Used if the logger assembly cannot be found alongside the current runtime files. Loads the default logger implementation supposedly compatible with the machine-installed MSBuild.
Type of the Logger API Entry-Point interface.
Assembly name of the assembly with the logger client implementation of the to be loaded into the client process.
Allows to use a custom MSBuild version from a Nuget package rather than
All toolsets' directory hierarchies are under this folder.
Change whenever algorithm changes.
Creates the runnable MSBuild toolset.
A package which defines the toolset: contains MSBuild itself, plus references all of the SDK packages which need to be retrieved for it.
Knows how to retrieve packages.
Knows how to run async operations, such as when local-restoring toolset files.
Optional. The directory into which the toolset would be installed, if given. Otherwise, a uniquely-named folder under .
Calculates the hash identity for the current toolset.
Uses the original package names; patched msbuild package name is formed from this identity.
Takes the MSBuild config file, applies our macros which should reference the requested package expand locations on disk.
Filters entries in the MSBuild package by the current runtime, if applicable.
Path to the MSBuild Toolset Logger, see , if found in this toolset.
Path to the expanded MSBuild.exe (which is invoked to start the build).
Our toolset (specific to the set of packages and version) is expanded under this folder.
Other toolset versions / sets of packages occupy other folders.
Either autogenerated based on a hash of toolset props, or user-provided.
Reads the config, finds what looks like references to other packages.
The msbuild config file XML.
Path from the Packages folder to the dir which has msbuild.exe and this config file, supposing that msbuild is also expanded as a package. Needed to detect which of the paths are paths to the sibling packages.
Checks that we've encoded the correct directory into the package.
Tracks receiving log messages.
Uses an MSBuild installed on the local machine for running the build.
Quick-checks if the given toolset version is installed locally on this machine, and if you might create a locally-installed msbuild toolset object of the said version.
Writes an MSBuild project file which invokes a set of other project files.
From the targets which we need to execute, gets the list to be passed to the list of projects being executed..
From the targets which we need to execute, gets the list to be executed in the top-level project rather than passed inside.
This class implements static methods to assist with unescaping of %XX codes
in the MSBuild file format.
PERF: since we escape and unescape relatively frequently, it may be worth caching
the last N strings that were (un)escaped
Copyright (c) Microsoft. All rights reserved.
Licensed under the MIT license. See LICENSE file in the MSBuild project root for full license information.
Special characters that need escaping.
It's VERY important that the percent character is the FIRST on the list - since it's both a character
we escape and use in escape sequences, we can unintentionally escape other escape sequences if we
don't process it first. Of course we'll have a similar problem if we ever decide to escape hex digits
(that would require rewriting the algorithm) but since it seems unlikely that we ever do, this should
be good enough to avoid complicating the algorithm at this point.
Optional cache of escaped strings for use when needing to escape in performance-critical scenarios with significant
expected string reuse.
Append the escaped version of the given character to a .
The to which to append.
The character to escape.
Append the escaped version of the given string to a .
The to which to append.
The unescaped string.
Determines whether the string contains the escaped form of '*' or '?'.
Before trying to actually escape the string, it can be useful to call this method to determine
if escaping is necessary at all. This can save lots of calls to copy around item metadata
that is really the same whether escaped or not.
Adds instances of %XX in the input string where the char to be escaped appears
XX is the hex value of the ASCII code for the char.
The string to escape.
escaped string
Adds instances of %XX in the input string where the char to be escaped appears
XX is the hex value of the ASCII code for the char. Interns and caches the result.
NOTE: Only recommended for use in scenarios where there's expected to be significant
repetition of the escaped string. Cache currently grows unbounded.
Adds instances of %XX in the input string where the char to be escaped appears
XX is the hex value of the ASCII code for the char. Caches if requested.
The string to escape.
True if the cache should be checked, and if the resultant string
should be cached.
Convert the given integer into its hexadecimal representation.
The number to convert, which must be non-negative and less than 16
The character which is the hexadecimal representation of .
Replaces all instances of %XX in the input string with the character represented
by the hexadecimal number XX.
The string to unescape.
unescaped string
Replaces all instances of %XX in the input string with the character represented
by the hexadecimal number XX.
The string to unescape.
Whether any replacements were made.
unescaped string
NOTE: no XName version of this class because MSBuild uses attributes in the default namespace.
On an item in an , the file or wildcard to exclude from the list of items.
On an item in an , gives the item spec, just like , but updates an existing item with such an item spec rather than declares a new one.
A version, like with an version.
Results in an inclusion of a file with Build Action = None.
Design-time item from CollectPackageDownloads target.
Design-time item from CollectCentralPackageVersions target.
Well-known MSBuild metadata, produced automatically for file-based task items.
Well-known MSBuild metadata, produced automatically for file-based task items.
Well-known MSBuild metadata, produced automatically for file-based task items.
Metadata on .
Well-known MSBuild metadata, produced automatically for file-based task items.
Well-known MSBuild metadata, produced automatically for file-based task items.
Metadata on .
On an item, the desired logical name of the resource when it gets compiled to the assembly (otherwise it's derived from project root NS and path of the file under project dir).
Well-known MSBuild metadata, produced automatically for file-based task items.
Metadata on .
Metadata on .
Metadata on .
Metadata on return items.
One of the values for .
Metadata on .
Metadata on .
Metadata on .
Metadata on .
Well-known MSBuild metadata, produced automatically for file-based task items.
Well-known MSBuild metadata, produced automatically for file-based task items.
Metadata on .
Well-known MSBuild metadata, produced automatically for file-based task items.
The root project element name.
Defines the level of debug information that you want generated. Valid values are "full," "pdbonly," "portable", "embedded", and "none."
A semicolon-separated list of feature names (custom format) passed to the Roslyn compiler to convey values for which there are no individual task parameters yet.
These paths are not used directly by this .targets file but are available for pre and post build steps.
These paths are not used directly by this .targets file but are available for pre and post build steps.
These paths are not used directly by this .targets file but are available for pre and post build steps.
These paths are not used directly by this .targets file but are available for pre and post build steps.
These paths are not used directly by this .targets file but are available for pre and post build steps.
These paths are not used directly by this .targets file but are available for pre and post build steps.
Special property for avoid override some important parts in new csproj project.
The type of the runtime that is currently executing. Introduced in MSBuild 15. Value may be undefined (prior to MSBuild 15), Full indicating that MSBuild is running on the desktop .NET Framework, Core indicating that MSBuild is running on .NET Core (for example in dotnet build), or Mono indicating that MSBuild is running on Mono.
This were borrowed from the standard MSBuild and set in our isolated toolset template for MSBuild, but they appear to be unused in Common Targets, so let's prevent their use.
Standard prop, CPU choice.
Set by std roslyn targets.
This were borrowed from the standard MSBuild and set in our isolated toolset template for MSBuild, but they appear to be unused in Common Targets, so let's prevent their use.
This were borrowed from the standard MSBuild and set in our isolated toolset template for MSBuild, but they appear to be unused in Common Targets, so let's prevent their use.
These paths are not used directly by this .targets file but are available for pre and post build steps.
Option for Roslyn which defines whether it's allowed to compile everything within the single process rather than run each compilation separately.
This is how MS CPP props files are mounted into MSBuild.
This is how MS CPP props files are mounted into MSBuild.
This is how MS CPP props files are mounted into MSBuild.
This is how MS CPP props files are mounted into MSBuild.
This is how MS CPP props files are mounted into MSBuild.
This is how MS CPP props files are mounted into MSBuild.
This is how MS CPP props files are mounted into MSBuild.
This is how MS CPP props files are mounted into MSBuild.
Values for properties etc.
Value for assets metadata (, , ) on a . All of the above (except none)
Value for assets metadata (, , ) on a . .NET analyzers
A version of with a space, an allowed variation.
Value for assets metadata (, , ) on a . .props and .targets in the build folder
Value for assets metadata (, , ) on a . (4.0) .props and .targets in the buildMultitargeting folder, for cross-framework targeting
Value for assets metadata (, , ) on a . (5.0+) .props and .targets in the buildTransitive folder, for assets that flow transitively to any consuming project. See the feature page.
Value for assets metadata (, , ) on a . Contents of the lib folder and controls whether your project can compile against the assemblies within the folder
Value for assets metadata (, , ) on a . Contents of the contentfiles folder
variant.
Value for attribute on the , by default newer MSBuild versions expect this rather than a real version.
OR
variant.
for Roslyn value for the latest supported language version.
/// <summary>
/// The latest version of the language supported.
/// </summary>
Latest = int.MaxValue,
variant.
Value for assets metadata (, , ) on a . Contents of the native folder
Value for assets metadata (, , ) on a . None of the above are used.
One of the values for .
A possible value.
On and , metadata value.
A member in for deterministic builds in Roslyn.
A possible value.
Value for .
Value for assets metadata (, , ) on a . Contents of the lib and runtimes folder and controls whether these assemblies will be copied out to the build output directory
SDK dir in Nuget package.
SDK Props file (included "before") under .
SDK Targets file (included "after") under .
A possible value.
This project is either a packages.config project or one that does not use NuGet at all.
Properly escapes a string so that it could be written as element text or attribute value by the means of an XML writer and then interpreted as the string by MSBuild. For example, having $(Stuff) in a value would cause it be evaluated to the value of the Stuff property / envvar. Need to get escaped to be read literally by MSBuild.
MSBuild escaping looks much like URI escaping.
Takes a value as written in MSBuild XML element text or attribute value (after reading with an XML reader) and unescapes to the raw value which would be read by MSBuild.
MSBuild escaping looks much like URI escaping.
Results in an inclusion of a file with Build Action = None.
Design-time item from CollectPackageDownloads target.
Design-time item from CollectCentralPackageVersions target.
A typed wrapper for the package identity (or a fake identity for a local toolset) to be used as a toolset spec, for
locating all such places in the solutuion.
To specify a toolset installed locally on the machine, give a with this ID for the
package id, and the toolset version for the version.
Helps with installing the toolset for loading/building projects.
Previously, we were making custom MSBuild packages with all the deps including C#, C++ etc support, sufficient for building on a clean machine.
Now we prefer not to ship the whole toolset alongside the MSBuild, but instead plug in the relevant parts into each of the projects.
So this has two parts, some recommended MSBuild, and a set of packages to add on per-project basis.
This class manages knowledge on how we stuff individual projects to make them buildable with an empty (or any installed) MSBuild package.
Like , but might use macros to make stuff moveable on disk if together with the solution.
Now this is a "void" msbuild package which only has the msbuild and none additional stuff like Roslyn or assemblies or PSDK, those should be added per-project.
Common Targets expect this file to be right under the dir.
RefAsm packages, their origin is either NugetOrg AS IS (if MSFT) or DotNetLibs (if ours).
Roslyn for compiling projects which do take part in the bootstrap. Can be updated freely.
Origin in DotNetLibs, taken from a VS installation.
7.1A and below are a VS-updated version of a full SDK, while 8A and above only have managed tools. For NetFX compilation needs, we take 10A.
Windows compilations can do without it (take the tools from NetFX dir), while on other OSes we need some of it.
A set of reference assemblies for use by compiler when building for a certain target framework.
A short designation, right now mostly used for display and not as a real id.
A set of reference assemblies for use by compiler when building for a certain target framework.
A short designation, right now mostly used for display and not as a real id.
A short designation, right now mostly used for display and not as a real id.
How to scan the refasm package for assemblies to be available as references.
The package is not formed as a Package Reference, assemblies are scattered under unrelated folders (often build) nested deeper under folders.
The recommended approach is to take all assemblies from the package, i.e. + for assembly set flags, and for filtering.
The package looks as if it's a valid Package Reference from one side, and has extra DLLs in it which should not go as assembly references, on another side.
So you should take it as any reference, + for assembly set flags, and filtering could be done by the target framework for which the reference assemblies are retrieved (or, possibly, unfiltered, since it's a set of refasm for just one fx).
Windows Platform SDKs. These are mostly headers and libs for building for the specific target system.
Their origins are in DotNet Test Data repo, because they are shared with tests, and because they are HUGE in size.
See Microsoft SDKs\Windows and Windows Kits dirs.
Two-digit version, for 71, 71A is assumed.
Windows Platform SDKs. These are mostly headers and libs for building for the specific target system.
Their origins are in DotNet Test Data repo, because they are shared with tests, and because they are HUGE in size.
See Microsoft SDKs\Windows and Windows Kits dirs.
Two-digit version, for 71, 71A is assumed.
Two-digit version, for 71, 71A is assumed.
Packages with Visual C++ Compilers (no PSDK). Their origins are in DotNet Test Data repo, mainly because they're HUGE in size, and parts of them were reused in tests.
A 3-digit version of the tools, e.g. 120 for VS 12 and 141 for VS 15, 142 for VS 16 %-/.
Packages with Visual C++ Compilers (no PSDK). Their origins are in DotNet Test Data repo, mainly because they're HUGE in size, and parts of them were reused in tests.
A 3-digit version of the tools, e.g. 120 for VS 12 and 141 for VS 15, 142 for VS 16 %-/.
A 3-digit version of the tools, e.g. 120 for VS 12 and 141 for VS 15, 142 for VS 16 %-/.
7.1A and below are a VS-updated version of a full SDK, while 8A and above only have managed tools. For NetFX compilation needs, we take 10A.
Windows compilations can do without it (take the tools from NetFX dir), while on other OSes we need some of it.
The full toolset stuff for a typical managed project compilation.
Projects which do not need bootstrapping, and might use the latest Roslyn version.
The full toolset stuff for a typical managed project compilation.
Projects which do not need bootstrapping, and might use the FSharp Compiler.
By default, ResGen is called as an external EXE tool. But on NetCore this is not supported because it's not compatible. Force using the built-in version available in recent MSBuild versions.
Adds packages for building into native C++.
Language versions, as to be given in MSBuild, as supported by the current Roslyn toolset.
NOTE: might still be having more than one Roslyn in settings here, but actually all bootstrappable projects have switched to SDK and all the other use toolset-version of the roslyn.
Optional. An MSBuild conditional expression.
Whether the entity shoud be applied before or after the common targets.
For a prop, goes to the real prop name. Otherwise, just identifies the entity.
Explains why we added this. Helps with tracking the origin. Should get into the final rendering.
Optional. If this entity needs to mention a package, references that package, it will be downloaded and restored and given its path.
An import from a package, the build file (single) is looked up in the package's build folder.
An import from a package, the build file (single) is looked up in the package's build folder.
A prop ref to a package, path has a forced backslash at the end, as required by MSBuild.
Takes the root dir of the package.
A prop ref to a package, path has a forced backslash at the end, as required by MSBuild.
Looks for the dir inside the package which has the given file in it.
A prop ref to a package, path has a forced backslash at the end, as required by MSBuild.
Takes just the hardcoded dir out of the package. You can use for more flexible connection.
Prop value for use in proj.
Prop parts (strings and nugets).
When a nuget is needed, finds the path it's been installed into.
Package gives a full path, shorten this down to well-known base dirs (like home dir) to make the whole setup movable to another location. Or just return the full path.
Consider calling the non-static version, its main profit is asserting names are unique.
The main entry to the process. Expands properties from some of the , downloads and expands Nuget packages required for them.
Which props to expand — and fetch nugets for them.
ID of the folder with toolsets. MUST be unique among calls to this method.
Title for progress messages if dloading toolsets takes a long time.
Component.
Component.
Logger for messages and errors.
, after its value has been expanded for all packages downloaded etc.
, after its value has been expanded for all packages downloaded etc.
This property is filled when the request is executed.
Denotes an assembly item which has been retrieved from a Nuget package.
Defers loading the actual assembly file content bytes until they're requested.
A special case of an assembly item which has been extracted from a Nuget package, it fast-knows its assembly name, but lazily decompresses the assembly body.
The original package from which the assembly item has been extracted.
Raw part path in the Nuget, and the effective path (which originally applies to the bin dir).
Fast reading of assembly items from nugets. Can fetch names from jet metadata quickly, can read precalculated catalogs if avail, can pre-read assembly names with lazy-loading of the bodies if no jet metadata.
Checks an effective path of a nuget entry to see if it looks like the Jet Package Metadata entry.
Nuget entries which do not have an effective path (i.e. do not sit under content folders) are never metadata.
If you're querying for refasm, makes flags for .
Tries to peek for the assembly name without decompressing the whole item, but just pre-reaing the relevant header bytes.
True if all OK, False is not fully OK (might be having non-NULL out, but missing partial info).
Only files in Jet Content folders (for which is defined, see also ), and only either on top-level, or in a folder named against an assembly (so that Fusion resolver can find such DLLs), filtered by known module extensions.
Takes files outside Jet Content folders (for which is defined, see also ).
Takes files from any folders, not only default-Fusion-visible.
Does not limit to module extensions. Tries for assembly names in any files.
Historically, we've been taking the (lib) folder from non-ours packages.
With newer nugets and multiple supported target frameworks, it is sometimes needed to take the specifically tailored references from the (ref) folder.
Still falls back to lib folder if no refs.
Historically, we've been taking the (lib) folder from non-ours packages.
With newer nugets and multiple supported target frameworks, it is sometimes needed to take the specifically tailored assemblies from the (runtime) folder when running on a specific target system.
Still falls back to lib folder if no refs.
If the package has a Part Catalog inside, would fetch the list of assemblies from the catalog and skip checking actual files.
For most cases of treating product assemblies, this is OK.
However, this will skip any assembly we've skipped from cataloging (e.g. which should not have product components inside), and sometimes you need those.
Check each file which looks like a possible assembly on whether it has an assembly name.
This also will not read and will not return the part catalog.
The assembly items of the package.
Optional. The package might have a pre-calculated part catalog for its assemblies.
The assembly items of the package.
Optional. The package might have a pre-calculated part catalog for its assemblies.
The assembly items of the package.
Optional. The package might have a pre-calculated part catalog for its assemblies.
Configuration file for Nuget which tells where to download packages from.
In current layout, is a requirement for most builds.
Serves its direct purpose — lists the Nuget sources to download packages from, and packages are needed for various purposes during the build, both as requested by payload builds, and for tools to use in the build.
Its secondary purpose is storing confguration values for the environment, such as: credentials to Nuget server, Distributed Cache remote URI, Distributed Cache credentials, etc etc. The reason these are coupled into the Nuget Settings File is that (a) it's ubiquitous and pulled into every piece of build; (b) it is a proper config file which supports setting arbitrary parameters; (c) first parameters were needed for nuget itself.
If not given explicitly, gets loaded from from either local path or app-specific locations. If you already have a in the build, pass it to child builds AS IS; otherwise, locate or something it can be derived from (such as Product Home Dir).
When local nuget file path is known, loads it.
Might be given either explicitly (as in most server / bootstrap scripts), or inferred from locations like Product Home Dir.
Loads given Nuget settings in gen2 format.
TODO: not in Util because it does not reference the gen2 nuget yet
Nuget config file as an optional typed artifact, extracted from the package manager.
Nuget config file as an optional typed artifact, extracted from the package manager.
Loads the Nuget Config settings file, reads the package sources, gives them in a stable order.
Input artifact for defining with outer-world parameters for a build runner, as a path to the disk file.
In-build entities use these pre-configured Nuget package managers to retrieve or locally-install packages during build.
This version is bound to build-specific Nuget servers.
Caches the nuget in-mem while it's still in use somewhere. Access must be protected by locking on this instance.
Checks if it's time to clean up expired folders in CC, does so if yes.
Gives access to .NET Core SDK packaged as a Nuget package.
Manages retrieval, expansion to the given directory, and locating entry points and tools inside.
All objects and methods are as lazy as possible, so that no downloading or expanding would happen until required to.
Binds to a specific local expand directory. Does not do any retrieval or expansion immediately.
NOTE the is the base dir under which the expansion happens, not necessarily the nuget root.
Retrieves the package body. Looks for tools. No local expanding yet, bind to a folder with for that.
The static implementation method.
Does the download part, and looks for tools.
A lazy wrapper which binds to a specific (lazy) local install dir and can tell about local paths.
The base dir for locally expanding packages, child directories might be created as needed. Do not assume paths, use methods to get specific locations.
The owning object (not bound to a dir).
Local-expands the SDK package into a subfolder under and locates the dotnet.exe host under it.
Local-expands the SDK package into a subfolder under and locates the msbuild.dll entry point under it.
Creates a wrapper fitted for another .
Emulates TC properties.
Loads a properties file in Java Properties Xml format which has all the kinds of properties in it (config & system), told apart by the prefix.
Loads a properties file in Java Properties Xml format which has all the kinds of properties in it (config & system), told apart by the prefix.
Loads a properties file in Java Properties Xml format which has all the kinds of properties in it (config & system), told apart by the prefix.
Loads a properties file in Java Properties Xml format which has all the kinds of properties in it (config & system), told apart by the prefix.
Assumes that we are running under a TeamCity Agent.
Issues a Service Message to StdOut which is registers a file as a build output artifact.
Allows to fake running on TC in context of another TC build.
This artifact specifies the Build ID of some real TC build whose properties would then be downloaded and used as artifact.
Format 1: just the build id string. In this case this is not enough info to make queries, you also need the server URI and credentials, so you must also provide them in a form of a local TC props file , which bootstraps the download of your props from build ID on that server.
Format 2: an URI to some build on the server, with credentials also specified on the URI. In this case the server URI and the build ID would be guessed from the URI with some heuristics (works for build view pages), and credentionals are given explicitly in the URI.
The string value of the artifact, see format description for details.
Allows to fake running on TC locally by using a downloaded TeamCity properties file for .
This artifact defines the source for then creating the artifact with the props, , which should be then used by the build.
The props lack credentials for accessing TC (wiped out when downloading from TC UI, or outdated when fetching directly from agent because it uses one-time per-build creds). If you want to make queries, those must be given separately.
Format:
username:password@fullpath
fullpath
Nonprintable characters and :, @ MUST be XML-escaped.
Required. Full path to the disk file with hybrid TC properties.
File format: either XML or Java properties file.
Hybrid means that it holds all of the system, config and environment properties together in the same file (with approproate property name prefixing). This is important because prefixes must be stripped off correctly.
Optional. Override credentials to give out in the mocked props file for querying into TC.
Optional. Override credentials to give out in the mocked props file for querying into TC.
TeamCity properties, either from the currently running build, or from a local file, or from another TC real-life build.
Performs TeamCity-format escaping of a string.
Performs TeamCity-format escaping of a string.
Writes the message.
Writing MUST occur in one write operation to ensure thread-safety.
Sends a nameless value.
Writes the message.
Writing MUST occur in one write operation to ensure thread-safety.
Gets the parameter value for MSBuild's "/logger:" parameter which connects it to the TeamCity logger, if currently running in a TeamCity build agent.
Gets the parameter value for MSBuild's "/logger:" parameter which connects it to the TeamCity logger, if currently running in a TeamCity build agent.
While running within a TeamCity build, we have three sets of properties available:
(1) Environment. These are available thru the process environment block.
(2) System. There's a pointer to the properties file in one of the environment variables.
(3) Configuration.There's a pointer to the properties file in one of the system properties (see the chain?).
Creates from the currently running TeamCity instance.
Throws an exception if there is none. See .
Properties for the currently running TeamCity instance.
NULL if there is none.
Gets whether we're running inside a TeamCity agent process.
Gets whether we're running inside a TeamCity agent process.
Reads the native version of the JAVA properties file.
Reads the native version of the JAVA properties file.
Reads the XML version of the JAVA properties file.
Reads the XML version of the JAVA properties file.
Returns success, a non-empty path in if OK, and the log text in in any case.
Marks a class which is a build artifact type.
Artifact is what you request of the build as its result. There're also intermediate artifacts which are required to produce the final result.
All of the information required for build steps must be conveyed in the form of artifacts (on which the build step explicitly depends), rather than files on disk, environment variables, or other means of implicit dependencies.
Build steps and artifacts together would make the build chain.
Formats a build message in a way which is compatible with MSBuild output, which makes it parseable by standard build output parsers (for detecting build errors from text etc).
Message kind, like "error", "warning", etc. The exception uses "error" by default.
Formats a build message in a way which is compatible with MSBuild output, which makes it parseable by standard build output parsers (for detecting build errors from text etc).
Message kind, like "error", "warning", etc.
Base for all build-related attributes which should be pulled into the part catalog.
Defines a build step by marking either a class or a method.
A method is the simplest build step: its parameters are inputs it requires, and its return value is the artifacts it produces. To produce more than one artifact, use family types.
While artifacts hold the build data, build steps define the actions which produce artifacts.
There're no explicit dependencies between build steps. By inputing and outputing artifacts, the steps get dependent on each other via the information they deal with.
Whether the artifact is allowed to have more than one value.
Each build artifact is either having only one value, or holding a set of values.
This property is defined when declaring the artifact, and all of the usages must match the choice.
You cannot mismatch cardinality when importing an artifact into your build step (even though you might output a single value for supplying a plural artifact).
The basic implementation which operates on scattered DLLs, and can be used to locate the engine DLLs for a simple non-shelled build runner. Might use the part catalog as a hint.
Assume well-known assembly name (once again this is for manual bootstrapping, so will be updated if seen failing).
We're running the Build Runner Core on a set of scattered DLLs, all in one folder.
This implementation loads the Build Engine DLL by its well-known name and traces all of the DLL refs from it.
Gets the engine assembly either from the part catalog by the well-known attribute, or by loading the disk assembly by well-known name in the ad-hoc scenario.
Gets the engine assembly either from the part catalog by the well-known attribute, or by loading the disk assembly by well-known name in the ad-hoc scenario.
Marks the class which creates the entry point to the build engine implementation. Helps with locating it in the catalog (and its assembly as well).
Record metadata which allows to transfer machine-readable notifications alongside with regular text logging.
Base class for build artifacts which are designated as build stage output files, and which should be available as individual files on disk after the build runs.
Checks if the storage has been written with a serialized form of some , and reads the file contents if so.
Base class for build artifacts which are designated as build stage output files, and which should be available as individual files on disk after the build runs.
Specifically stores a package.
Core impl for the external simple shell-less build runners, like cmdline and TeamCity.
If a message channel is specified in the command string, uploads log records from the session. Returns if the channel has been set up OK. Should not throw out.
Called before the session is started (and created).
The build request to create the session off, partly filled with , fill with any additional stuff.
Optional. The engine environment, if available.
Called after the session starts.
LT of the sessinsession, synced.
The session object, along with the session's log entries and results.
Whether the build runner command string specified a , and the channel were set up successfully. Having this OK means we should not log to stdout, and vice versa, if there's no running channel for build log, then it should be rendered to stdout.
A task, in case the callee has to complete certain async tasks before shutting down the build completely. This would be waited before the runner returns.
A stub for calling cross-domain.
Runs the core version of the build, without spawning the full shell, with direct stdout (no TC formatting).
Build runner command string in the standard format.
The return value of the run: a pointer to a DWORD where it should be written.
Result code, negative for a failure, S_OK if clean, S_FALSE if nearly ok but there were warnings.
Called in the original appdomain (where the type is from the old currently running version). Takes the set of DLLs with the new , loads into another appdomain, and runs there.
When no build log record channel were set up, renders into stdout.
v1
Defines the format of a JSON-formatted string to be passed as the build runner input in a lossless form (while cmdline args on Windows are not lossless for arbitrary text values because of the vage formatting/parsing rules).
This format MUST NOT be changed as it is used by different-version build engine to talk to each other. Any newer reader MUST correctly read any previous format.
The current version.
Artifact values in string-serialized form, keyed by artifact names.
Extends by allowing to specify values for multiple instances of a plural artifact.
Implementations should populate artifacts with values from both and ; plural artifacts all the values from both sets, specifying values for a singular artifact in more than one set is an error.
v2
Artifact values in string-serialized form, keyed by artifact names.
This is the original dictionary which only allows for one value per each name, thus prohibiting assignment of plural artifacts this way. See .
Implementations should populate artifacts with values from both and ; plural artifacts all the values from both sets, specifying values for a singular artifact in more than one set is an error.
v1
Raw artifact values in a container in a structured storage.
v1
File paths to build engine files.
v1
Optional. Type and name of the message channel () to be used by the running build for sending out build messages as typed data. If missing, would be logged as text to stdout.
v4
File paths to build script binary files.
v1
Paths to directories with build script source files under them, or to individual build script source files.
v1
Optional. A custom display name for the build state which would run from this command. If omitted, would present the list of objectives.
Might be specified to either name the stage in a custom manner, or include stage names of the parent builds if this is not a top-level build.
v4
Build objective artifact names.
v1
Optional. If build outputs are file-based, they would be written to this directory as disk files.
v1
Optional. Build outputs would be written to this file, as a structured storage.
v1
Optional. Full path to the file which has the full build request in the structured storage serialized form. Note that this request is not format-invariant and MUST match exactly the version of the build engine you will be running it with. It must be produced and executed by the same version of the runner.
v3
Version marker, for side-by-side formats.
v1
Enumerates artifact string name-value pairs from both and . Names might thus repeat in these pairs.
Values for .
Default implementation for .
The source code of the build script which is compiled by the build engine.
Custom engine files (or packages) for the choice in .
If custom engine is selected, must contain the custom engine assemblies and their satellite files.
Input artifacts whose values are known before the build begins — from external parameters, or from the previous stage. In serialized form.
Input artifacts whose values are known before the build begins — from external parameters, or from the previous stage. In string form, to be turned into a real artifact with or .
The artifacts to be calculated by the build.
Build steps will be run so that to trace value from known and to the .
Output values in would contain these objectives, as well as any other artifacts which support serialization.
Display name for the stage which will be run from this request.
If omitted, the stage would use the objectives for the name.
If starting a nested build stage, the runner might also prepend the parent stage name and the index of the child build to the given name.
Gets a non-empty stage name by making from if available, or a stub.
Gets a non-empty stage name, if defined, or makes from if available, or a stub.
Given artifact names, reads them (in the form of files) from the input artifact instances (not strings).
This is used for resolving into actual files as if they were written to .
Adds build script sources from the given list.
The request to be filled.
Base dir for relative paths.
The list of source directories in absolute or relative form, relative are based on the which must be specificed in this case.
Adds build script sources from the given list.
The request to be filled.
Base dir for relative paths.
The list of source directories in absolute or relative form, relative are based on the which must be specificed in this case.
The storage with the output artifacts serialized values resolver, in the format of directly reading/writing on this storage.
Opens the output artifacts as objects for temporary access.
Uses a more specific type binder, e.g. resolves artifact types in the context of the outer build.
Extracts any embedded files from the build runner results.
Actually, looks for any serialized records which look like files, and rips them out.
Extracts any embedded files from the build runner results.
Actually, looks for any serialized records which look like files, and rips them out.
Resolves the component by its type from the build result output artifacts.
Resolves the components list by its type from the build result output artifacts.
It is not an error if there are no components of such type.
Opens the output artifacts as objects for temporary access.
Opens the output artifacts as objects for temporary access.
Gets the build result when it's ready.
Describes a build step input parameter.
Base type for a descriptor for build step's input and output items.
Whether this item has one or multple values.
Parameter kinds.
For a singular item, same as , unless wrapped in a task or an optional. This would be the most unwrapped item type.
For a plural item, the might be the generic specialization of the container type, and this is the actual type of the plural item (container type parameter). Dependencies linking goes over this type.
The raw type of the parameter — type of the method parameter, or method return value.
If the method returns a tuple, it gets split before declaring individual output parameters for each member, so this field will be one of the tuple item types.
For plurals, it is the container type. For wrappings (for tasks and optionals), it's the fully wrapped type.
Describes a build step output parameter.
Modifier flags on build step params.
The parameter is optional.
It is OK to import NULL or an empty collection if the artifact value is not defined, or a helper is not available.
Currently, valid on input parameters only.
The parameter is a async parameter.
Initially implemented for output parameters to support async build steps. Possibly, might make sense to allow async input parameters for higher parallellism.
Build steps implemented as classes.
Build steps implemented as methods.
NOTE: must match the logic in .
Before reflection-invoking the method, fills its parameters list with the step input values.
The input values for the step.
Current input index.
The parameter array which will be used for the call.
After reflection-invoking the method, maps its outputs into the step outputs list.
The return values of the method, after splitting any possible tuples.
The parameter array used for the call, might hold the out parameters.
Current output index.
Assign step output here.
An intrinsic artifact of the build engine. Allows to suppress running build steps/helpers/etc in parallel. Logging from each build entity execution would come out without mixing with other entities.
Adapter for methods which can prepare for either build request interface: for early-bound same-version calls, and for loosely-coupled version-independent interfacing.
Given as the raw resolver (e.g. from a runtime guest-side request). DO NOT use this overload when you have .
Given as a runtime host-side request object.
Given as a serializable request string.
Given as a serializable request string.
Either taken from or .
Either taken from or .
Given as a runtime host-side request object.
Info that we have on the request when we're just starting up the build guest (and still need to run some operations with it before we load it into the build storage for real).
You implement this callback to fill the request with your data for the nested build. The request is pre-filled with input artifacts, in object and string form, as taken from the currently running build, so that you could run the nested build on the same inputs (or filter them down).
This is the Build Runner Request object. Describes the inputs, objectives, and engine choice for the run.
The already-compiled build script in the binary form. Build script is the set of Build Artifacts, Steps and Helpers which are available for execution to obtain the .
Supports managed assemblies and Nuget package files as file items.
This is the part of the build script which is already available in the compiled form and not present in any of the input artifacts in the same time. The build script in source code form should be set to . If the build script is in the binary form and is also supplied to the build in the form of build input artifacts, you can either put here a copy, or specify the artifact type in .
See : if build script binaries are also supplied as build input artifacts in , you can optionally reuse them from input artifacts to avoid passing a second copy of the DLL/Nuget bodeis in .
Specify the type name of the input artifact type.
The build artifact type must be deserializable from (in a simple case, derived from it). This is required to get the body without having the artifact type available as the CLR type, because the DLL required to load that type would usually be present inside this same artifact values being loaded.
The source code of the build script which is compiled by the build engine. Build script is the set of Build Artifacts, Steps and Helpers which are available for execution to obtain the .
This is the part of the script which you have in source code form. Already compiled DLLs with build entities are set to .
Custom engine files (or packages) for the choice in .
If custom engine is selected, must contain the custom engine assemblies and their satellite files.
Input artifacts whose values are known before the build begins — from external parameters, or from the previous stage. In serialized form.
Input artifacts whose values are known before the build begins — from external parameters, or from the previous stage. In string form, to be turned into a real artifact with or .
The artifacts to be calculated by the build.
Build steps will be run so that to trace value from known and to the .
Output values in would contain these objectives, as well as any other artifacts which support serialization.
Display name for the stage which will be run from this request.
If omitted, the stage would use the objectives for the name.
If starting a nested build stage, the runner might also prepend the parent stage name and the index of the child build to the given name.
A Build Helper designated task host interface.
An interface for separating Shell logic (which knows the files possibly belonging to the built-in build engine) and the build engine runner which needs the files but does not reference the Shell and all of than infrastructure.
Entry point interface to the build runner engine (top-level).
When running inside the build, import the build helper into your build step or helper to initiate a nested build.
Initiates a new build, async.
Build-limiting lifetime.
Build request (defines what to build and initial artifacts).
Async build result.
Basic control of the Incremental Build mode in the build process.
Should be OFF on the server to ensure a clean and repeatable build.
With a local process, allows to speed up things considerably by turning off much of the sandboxing and re-generation.
Runs a nested build, asynchronously. You should await the result in your build step.
The lifetime for entities returned as a result of the build (as well as for all the build objects). Use local lifetimes if running many builds, to release build results.
Build request.
Build result.
Runs a nested build, asynchronously. You should await the result in your build step.
Allows to inherit parameters from the parent (=current) request to run a variation of the current build.
The lifetime for entities returned as a result of the build (as well as for all the build objects). Use local lifetimes if running many builds, to release build results.
What parameters are to be copied from the parent request.
You implement this callback to fill the request with your data for the nested build. The request is pre-filled with input artifacts, in object and string form, as taken from the currently running build, so that you could run the nested build on the same inputs (or filter them down).
Build result.
Runs a nested build, asynchronously. You should await the result in your build step.
The lifetime for entities returned as a result of the build (as well as for all the build objects). Use local lifetimes if running many builds, to release build results.
You implement this callback to fill the request with your data for the nested build. The request is pre-filled with input artifacts, in object and string form, as taken from the currently running build, so that you could run the nested build on the same inputs (or filter them down).
Build result.
Runs a nested build, synchronously, which means that your build step does not proceed until the nested build completes.
The lifetime for entities returned as a result of the build (as well as for all the build objects). Use local lifetimes if running many builds, to release build results.
Build request.
Build result.
Build inputs (in serialized and string form) will be copied to the nested request from its parent (current) build.
Build script (sources and binaries) will be copied to the nested request from its parent (current) build.
Build script as pointers (type names) to input artifacts will be copied as pointers if the flag is also included; otherwise, those artifacts would be loaded from the parent request and passed as actual files.
Build engine choice, and binaries if custom.
Build objectives will be copied to the nested request from its parent (current) build.
When specifying input artifact values as strings, gives the name of the artifact to assign the string value to.
Name of the artifact class type, as either a full or a local name (for nested classes, it's just the local name of the nested class, no outers' names added).
It's OK of the targeted artifact does not exist. Just skip assigning the value and issue a warning instead of an error.
Should potentially be used when new artifacts are introduced to the build in some branch, but other branches still don't know about them — this allows the build configuration which is shared by all branches to define the values for the new artifacts without ruining older builds.
Applies the default convention where a name of the build artifact class which is OK to be missing is followed by a question sign.
Makes a new instance with set to False.
Makes a new instance with set to True.
Exposes some of the context which is available to the running Isolated Build guest (guest means we're in the guest appdomain context, rather than the side which spins up the isolated build).
Binds type names of artifact types to actual types in the context if this build.
Gives access to the low-level writer into the build log records stream.
To be used for relaying records from the nested step ONLY. Any own logging should go to the real logger, so that all of its attached listeners were duly notified.
Reuses assemblies realized on disk (incl the parent context of this build).
Core planner, creates the step-by-step graph for dependencies.
The build entities which have been hit while tracing undefined outputs back to available inputs (with unreachable optional parts dropped). We have to add specific Create/Delete/Execute steps for them, and impose ordering.
These should be available as outputs after the plan is executed, so they should not be deleted.
Build entities storage.
The plan, with detailed steps and a topo ordering on them.
Assert that any of the unresolved artifacts can actually be resolved with some steps.
Prefers singular and very much prefers non-optional edges in the path.
For each output, add what it depends on, transitively.
That would be the largest possible work set, might only get filtered down if there're uncomposable optional subgraphs.
The logger for regular writes.
Optional lowlevel writer ONLY for passing metadata. All significant messages should go via .
Build entity declarations and states, like artifact values and helper instances.
The execution plan, a sequence of steps, helper creation/destruction, and artifact value decommissions.
Optional. The low-level writer to send up metadata on special activities, like passing the nested steps state.
Threading provider.
The main logger for submitting progress messages and errors.
The currently executing item, if doing one right now. Might get Nulls during a run.
High when running.
You can tell if it's “not yet run” or “have already run” by the value of .
This property changes free-threadedly, but under an exclusive lock together with other properties.
The current position in the plan.
It's 0 before execution.
When executing an item, it's equal to the index of the currently executing item, in case of single-threaded execution. In multithreaded case, it's the number of items ever started to execute, and does not directly correspond to the Plan indices.
After the run, it's the index after the end of the plan (equal to the Count).
This property changes free-threadedly, but under an exclusive lock together with other properties.
For the priority queue on planned items. Queue only holds items which do not have interdependencies, so this lines them up for optimal execution.
Retrieve artifact values from the storage to fill step inputs.
Advertise the item executed; as with tasks we now have parallel execution, only flash each item at the end of its execution
Just invokes the step run on step-native data.
The step MIGHT return unwaited tasks in some of its outputs. The only case when the step MUST wait for the tasks and unwrap the value is when the task covers more than one output, e.g. is a task of a tuple. As the step has to return split outputs, it has to await the task to split them.
After a step is executed, assigns its calculated outputs to the artifacts.
Controls formatting of machine readable log messages.
Whether planned items might be executed in parallel.
The next planned item only starts to execute after the previous completes its task chain. Even if the prev item sits on an await, the next item is not unblocked for execution. This does not prevent individual items from running activities in parallel, even by means of tasks.
The items are started as soon as all of their inputs are ready. Any number of items.
The parallelism is then limited by the task scheduler capacity for active threads (by CPU count usually), which does not exactly mean the number of planned items, because if planned items are yielding on an await, a larger number might be in process of execution on the limited pool.
A helper method to create a build artifact from the specific type.
A helper method to create a build artifact from the specific type.
A helper method to create a build artifact from the specific artifact value (singular artifacts only).
Creates artifact and build steps by reading the catalog.
Lifetime for the entities to be created.
For a type, calculates the set of types hidden by it — base types and cases.
Gets the wrapping kind by checking the type, which should be in the form of the open generic definition type (e.g. Full.Type.Name`1).
Checks the outermost wrapping only.
Gets the wrapping kind by checking the type, which should be in the form of the open generic definition type (e.g. Full.Type.Name`1).
Checks the outermost wrapping only.
For a wrapped item (with an or a or else of the supported values), wraps up the value to get the required outside type.
The raw item value.
Flags on the item, shows which wrappings are legal and expected.
The type which should be achieved after all of the wrappings are applied. Flags are not enough because the nesting order might vary.
The wrapped object whose type equals to the runtime binding of the .
The original raw parameter with which we start the resolve.
The current (possibly partially unwrapped) type which we are processing. This will eventually become the Item Type.
The flags collected so far.
True for method return values, allows to unwrap multiple params from tuples.
A single type for in-params our out-params, and single or multiple for a return value (multiple if it's got a tuple).
Implementation support: for read (from out params / retvals), expecting all containers to implement ; for write (creating an object to be passed to an in param), expecting to implement all of the supported container interfaces, but for the , which is handled separately.
Support for tuples which allow passing more than one output type in method's return value.
In case a method build step returns multiple artifact types, those might be packed into a tuple. This method returns the list of types to work with.
Either type type parameters, or an empty list if not recognized as a tuple.
An interface for driving a proxy build executor object across the thread or apartment boundary.
Tells the build that it SHOULD work offline, i.e. not download anything from the Internet, and report an error if such download was attempted.
NOTE that at this stage it is an experimental flag, and is only selectively applied to a couple spots, but could be extended. The initial client is the offline installer.
Tells the build that it SHOULD work offline, i.e. not download anything from the Internet, and report an error if such download was attempted.
NOTE that at this stage it is an experimental flag, and is only selectively applied to a couple spots, but could be extended. The initial client is the offline installer.
Sets up type binding which can bind the type by its fullname into another assembly in case it can't be found in its original assembly.
Stores binary files for use as a custom build engine, or a the pre-compiled build script.
Serves as a typed wrapper for telling apart storages with such data from any other ones.
The binary files for use as a custom build engine, or a the pre-compiled build script.
Possible file types:
• A managed assembly.
• A satellite file.
• A Nuget package, which is to be extracted to get any of these files yet again.
• A Structured Storage with a serialized object of type inside, which is to be extracted to get any of these files yet again.
Gets whether this storage contains this object in a serialized form.
// TODO: use serialization infrastructure info for this instead
Wraps a with previous build results for typed access to a structured storage on disk.
Creates over an existing resolver.
Creates over a storage with data. As usual, storage must be open while you're accessing this object.
Gets whether this storage contains this object in a serialized form.
// TODO: use serialization infrastructure info for this instead
Opens the child storage under the stored copy of which can be treated as backend.
Current artifact type info, keeps just the build entity pointer in text form.
Prev-gen artifact type info, in the property class.
Helper for reading the entity pointer to the artifact, which gives the artifact type to create the instance.
serialization helper.
Handles importing a lifetime into a build entity.
Handles importing a logger into a build entity so that the logger were configured with the entity's namespace and type name.
A serializable identification of a build entity.
An index of the build entity kind in the array.
Short name of the assembly which declares the entity.
Might be empty for some entities because it does not form the strong identity anymore.
Note: assembly excluded from identity because the same build entity might be compiled either as a part of the build script (into the source build entities assembly) or into the product package (into a product assembly). The entity equality must be retained, even though assembly names do differ.
Gets the build entity kind of this entity.
Calculates the local name of the type, or type and member.
For type-based entities, an empty string.
For member-based entities, the member name.
Full name of the type which declares the entity.
Should be defined for all entities.
Dependencies between the items in , as pairs of indices in the list: the from-index and the to-index along the dependency flow, meaning that the to-item depends on the from-item. As the planned items are sorted in a ready-for-execution order, the second index in any pair is always larger than the first one.
The objectives of this plan.
We're running this execution to obtain the values of these artifacts.
The items planned for execution/creation/deletion.
Sorted in a safe to execute order.
A context for the whole build run.
Works for the single build step only.
A lifetime which is broader than that passed to the user in the build step body — to make sure all of the stuff created under it outlives any user code.
The lifeitme passed in constructor governs our object. For passing to user, make a nested lifetime.
Basically equivalent to user's creating a lifetime, but more handy.
Lifetime for the context. Created only for the time of the single build step operation.
The owning step.
An outer context, for this build executor run.
An interface to the runtime storage of build steps and artifacts, as well as their relations (which steps are involved with the given artifact, etc).
Resolves the input/output item into a type-based entity by its item type, also validating the cardinality.
Resolves a type-based entity by its originating type.
Backend for which calculates and maintains all of the relations.
An outgoing reference means that its origin hides its destination (e.g. inherits).
All type-based build entities, by their exact type (as reported by entitry) and all of its assignable-to types, which includes base classes and interfaces. Runtime access: free, R/O.
All build entities cached by their local name. Runtime access: free, R/O.
Note that there's no uniqueness guarantee for the local name really, so there might be more than one result.
All type-based build entities, by their exact type (as reported by entitry). Runtime access: free, R/O.
Caches resolved inputs when filling the storage. Runtime access: free, R/O.
Caches resolved outputs when filling the storage. Runtime access: free, R/O.
Immediate dependencies between all the build entities.
Edges go from outputs to inputs. If A depends on B, then it's from A and to B. This might be if step A takes input B, or step B returns output A.
Stores entity instances. Runtime access: free, R/W, beware concurrent modifications (by the build plan, should not be races on access to instances of the same entity).
Looks up entities by entity pointers. Runtime access: free, R/O.
Adds a pack of (possibly mutually-dependent) entities to the build storage.
All of the references must resolve either into this group or into the previously-registered entities.
Makes sure that if the entity being added references the custom object entities, those are actually added to the storage too.
Emits their entities on demand and adds to the list.
Type-based access to entities which are type-based.
Checks whether what we have resolved is legal to be assigned to a build helper's input.
Flags on the entity dependency edges in the graph.
Note that flags are not necessarily mutually exclusive because there might be multiple dependencies between two entities, and flags are merged among them.
Gets an already-created instance.
This method is kept separated from because an instance is created as a part of the execution plan at a certain iteration, and then must be available when the other iterations need its value.
NotNull if throwing.
A pairing method for in case you already have an entity instance.
Resolves an overload list to possible assignable type-based entities.
Resolves the input item into a type-based entity assignable to the parameter type, also validating the cardinality.
NotNull, but reports an error if nothing were found.
Resolves type-based entities which are assignable to the requested type.
NotNull, but reports an error if nothing were found.
Resolves the input/output item into a type-based entity by its item type, also validating the cardinality.
NotNull in case of a throwing onerror.
Resolves a type-based entity by its originating type.
NotNull in case of a throwing onerror.
Checks if it's valid for an entity to be resolved from the specific type.
E.g. build artifacts cannot be resolved by an arbitrary base type.
Builds an exception with an outline with all the information we collected, mostly in the exception data.
By traversing the data tree, all of the details will be rendered.
Unwraps a runtime value possibly wrapped with or or . This is for reading the method output values. Sync version.
Unwraps a runtime value possibly wrapped with or or . This is for reading the method output values. Async version: chains waiting for the task result if async.
Adds a capacity of associating attributes to the graph edges.
Data on the edge.
Sets edge data replacing the previous one, if there were any. Registers the dependency if the edge does not exist yet.
From-node of the edge.
To-node of the edge.
The new data to associate with the edge.
Sets edge data replacing the previous one, if there were any. Registers the dependency if the edge does not exist yet.
From-node of the edge.
To-node of the edge.
The new data to associate with the edge.
Optional function to handle assigning data to an edge which already has data on it. Has a chance to combine datas based on whatever rules the graph owner thinks applicable.
Gets the data associated with an edge.
If there is no such edge in the graph, returns NULL.
If the edge exists, but has no data associated with it, also returns NULL.
Gets the data associated with an edge.
If there is no such edge in the graph, returns NULL.
If the edge exists, but has no data associated with it, also returns NULL.
Some end of the edge, depending of whether we're considering incoming our outgoing edges.
The lifetime, as it should be imported into the entity. It's a func mostly not because it's a lazy instance, but to outline that it's not a lifetime for this object.
The entity for which the values are imported in this context.
Represents a build artifact and its calculated value, if any.
Mark a class with to let use it as an artifact.
Empty, if the artifact has not been calculated yet by the build.
A single value, for a fully-defined artifact.
One or more values, for a (partially or fully) defined artifact.
New values might be added, but never removed.
Whether the artifact value is singular or plural.
If your data is a list of values, there's a choice: either define a singular artifact which holds the complete list inside, or a plural artifact class whch holds just one item, and there'll be a set of them during the build. The determination is whether different build steps might contribute to the list: a singular artifact can only be produced once by a single build step, and values for a plural artifact will be collected from all the producing steps.
A singular artifact is imported just with the type of the artifact class. A plural artifact is imported as a , or of the artifact class type.
An entity for importing dynamically-created objects into other build entities, such as they're specific to those entities, such as lifetime, logger, etc.
Common base for build-related entities which could have dependencies on each other etc.
A delay-rendered string value.
A delay-rendered string value.
A delay-rendered string value.
A delay-rendered string value.
A delay-rendered string value.
A delay-rendered string value.
Gets or creates instances for build entities in a specific context.
Common base for a build entity which is produced out of a type member, and can be uniquely identified by that type member.
An example is a method-based build step.
The type member on which this build entity is based on.
Common base for a build entity which is produced out of a type, and can be uniquely identified by that type.
Most entities are, but for maybe method-based build steps.
The type on which this build entity is based on.
A build helper class, which could be imported into a build step as an input parameter.
If not marked with the flag, which is the preferrable default, is a throw-away class which can be created on-demand (maybe in multiple instances) and discarded at any time. These don't have to be serializable because a new instance can be created at any moment.
If , the one and only instance might exist, and it should be serializable to support suspended builds.
Free-threaded access possible.
Input parameters from various constructor overloads.
Creates an instance of the build helper object.
The inputs set, out of , chosen for the instantiation. This tells which .ctor to use.
Values for the .ctor input parameters.
The instance.
Represents a build step which can be run if we known its inputs and need to learn its outputs.
Input parameters.
Output parameters.
Runs the build step implementation.
Inputs. Indices correspond to the collection.
Outputs. Indices correspond to the collection.
Tells whether it's singular or plural.
Exact semantic depends on the object it's applied to.
Tells whether it's singular or plural.
Exact semantic depends on the object it's applied to.
Writes and reads build message records on some channel.
Which channel engine handles communication and how to open the media.
Must not contain slashes.
Name of the instance of the channel in this specific channel engine.
Might contain slashes.
Version of the data serialization or channel engine or both.
Must not contain slashes.
Represents an assembly-qualified type name with a name of a member in the type.
Optionally supports loose-matching with some allowance for a difference in version numbers (expected with assembly binding redirections in effect).
Requires a match in Major.Minor, but allows a difference in subsequent version components.
Ignores the assembly name completely when checking for type equality.
Gets or sets the assembly name of the assembly containing the type identified by this object.
Gets or sets the name of the member identified by this object.
Gets or sets the full name of the type identified by this object.
Gets the local name of the type, if the type name is set.
Calculated.
Gets the namespace of the type, if the type name is set.
Calculated.
Returns a copy which has only the bare assembly name, without any version, culture, or public key specifications on it.
Represents an assembly-qualified type name.
Optionally supports loose-matching with some allowance for a difference in version numbers (expected with assembly binding redirections in effect).
Requires a match in Major.Minor, but allows a difference in subsequent version components.
Ignores the assembly name completely when checking for type equality.
Gets or sets the assembly name of the assembly containing the type identified by this object.
Gets or sets the full name of the type identified by this object.
Gets the local name of the type, if the type name is set.
Calculated.
Gets the namespace of the type, if the type name is set.
Calculated.
Returns a copy which has only the bare assembly name, without any version, culture, or public key specifications on it.
Binds to a fully-initialized part catalog type.
This requires binding to a runtime type currently, so the assembly name must resolve in the current appdomain.
Binds to the runtime type.
The assembly name must resolve in the current appdomain.
Considers assemblies loaded into the current appdomain for remapping by full type name.
Default impl. Just looks up the runtime type.
The default instance of the default binder.
if the binder is a hinted binder, and tries to apply binding ad hoc locally otherwise.
The original type the client is trying to bind.
The possible redirection target type.
Hints possible binding if (a) the binder is a hinted binder, and (b) the two types have the same full name (but possibly not the same assembly).
When you only know the target type, adds a hint for that type's full name (essentially, tells in which an assembly to look for such a name).
serialization helper.
Binds a type upon deserialization when only its assembly-qualified name is known.
Allows to apply redirection rules, such as changing the version in the assembly full name, or even redirecting assemblies when dealing with build artifacts in script/comnpiled transition.
Gets the equality comparer for comparing type names before they're bound, assuming that two different type names that bind into the same type should be deemed equal.
Binds the type to runtime type by its name.
This should perform two things:
(1) Load the appropriate assembly, if needed.
(2) Loosely bind by partial type name match (e.g. if redirecting to another assembly name), if required.
Type name. Some binders are not looking at the assembly name, for example.
Gets or lazy-loads the resolver object.
Stores a list of values.
Can give out values by base types / interfaces.
Can serialize them into a storage.
Upon deserialization, does not unpack the actual values until the instance is actually requested, which allows to install the
Threading: not safe for RW access, safe for R access after you stop adding instances ( to be safer).
Read: directly.
Write: ONLY thru .
Looks up types by their AQN (matching rules depend on the binder) or by AQNs of their bases and interfaces, hence “assignable”.
The lifetime for this object, AND the lifetime during which we can still access the for on-demand deserialization of the actual values. This also applies to all the storages added later with calls.
Object instances to add. Same as calling .
The serialized storage. MUST be available for reading throughout the whole . Same as calling later.
Knows how to bind the types written in the storage to actual runtime types. In case there might be multiple alternatives it's critical to match the specific type expected for the usage, e.g. in case of build artifacts.
Exposes this with the interface suitable for chaining from child containers.
If you then use the standard function, it will prevent NULL instances from leaking along the chain (which prevents looking them up along the chain as the value is found, even though it holds NULL).
Loads serialized instances from a storage.
As the storage object must be available thru the whole lifetime of this instance, simplifies tracking by giving you the lifetime to load the storage in.
Loads serialized instances from a storage.
The provided storage object must be available thru the whole lifetime of this instance. Use an overload with lifetime if not sure.
Registers a new instance in this resolver.
Fluent.
Resolves the component by its type.
Resolves the component by its type.
Resolves the components list by its type.
It is an error if there are no components of such type.
For the .
Resolves the components list by its type.
It is an error if there are no components of such type.
Handles wrapping types like , , etc.
Some of the base types occur on every or most of the objects, but have no value for querying components by them => cut such types out to save on serialization and data structure sizes.
Write access for .
A single object instance in this container, either coming as a runtime object instance, or being deserialized from the container.
V3 format: a single SEXP file with type infos for ALL instances, and per-instance substorages hold right the value without an intermediate level.
V1 format: each instance has its own storage with the name info XAML stream and a substorage for the value itself.
V2 format: same as V1, but SEXP not XAML, for faster deserialization and to avoid setting up XAML infrastructure on load.
For V1 and V2 format, a substorage with the value.
Serialization-specific accessor, which allows restored instance to keep FLList all around.
An instance which got the real live value as an input.
An instance restored from the persistent storage.
V1, V2, V3 fmt based on how we deserialized.
V1, V2 deserialization ctor.
Exposes the APIs as the interface, for calling the standard value resolvers for Optional, Lazy, Enumerable, etc.
Implements string serialization via a or a attached to the class.
An accessor for calling the generic method from non-generic code via its ctor, since it's the most trivial reflection call.