| Age | Commit message (Collapse) | Author |
|---|
|
...that std::filesystem::* calls produce. This is because existence
and type checks use almost exclusively std::filesystem::status,
which follows symbolic links, when being called with path arguments.
Instead, one should instead use these methods with the value
returned by a call of std::filesystem::symlink_status.
This commit also streamlines the FileSystemManager tests, as well
as replace bare calls to std::filesystem with their FileSystemManager
counterparts (where suitable).
|
|
The introduction of non-upwards symlinks as first-class objects
should have updated the handling of known git tree artifacts
containing symlinks. In particular, one should consider trees in
their entirety when uploading (irrespective of the ignore_special
flag), and git trees should only be reported as known only if
the ignore_special flag is set to false.
|
|
|
|
The command 'git add .' does not include paths found in .gitignore
files in the directory tree where the command is issued. This is
not the desired behaviour, as we expect for a tree with a given
commit id to contain all of the entries, irrespective of their
meaning to Git.
This commit addresses the issue as described.
For the just-mr.py script we modified the staging command to
'git add -f .'.
For the compiled just-mr, simply adding the force flag to
'git_index_add_all' did not work as intended for files found in
ignored subdirectories. This is a known libgit2 issue which has
been fixed in v1.6.3. Until we can upgrade our libgit2 version,
a workaround was implemented: we recursively read the directory
entries ourselves and add each of them iteratively using
'git_index_add_bypath', making sure to ignore the root '.git'
subtree (which cannot be staged).
At the moment the handling of Git submodules remains an open issue,
as Git does not allow '.git' subtrees to be forcefully added to the
index, and thus such directory entries will currently not be
considered as part of a git tree. This however is consistent
behavior between Git and libgit2.
|
|
...allowing the skipping of certain subtrees if needed. This is
useful, e.g., in simulating what a 'git add' call would do,
which ignores all '.git' subdirectories.
Also adds a corresponding test for the new method.
|
|
In this way, the user can specify which execution endpoint
to use depending on the execution properties.
|
|
|
|
Extend the configuration data structure by a dispatch list of endpoints
to chose based on the first match of the execution properties.
|
|
... in a way consistent with what we're using at other places
already.
|
|
|
|
... and hence should be declared as such.
|
|
A recent change made it so that the artifact type was wrongly being
taken into account when deciding whether the CAS entry of the
artifact would be read or not. This meant that non-file artifacts
would be skipped from their content being read, resulting in
missing CAS artifacts being reported.
This fixes the issue by reverting the offending change.
|
|
|
|
In preparation for the introduction of our blob splitting protocol as extension
to the remote execution api, we need to update the used remote execution api to
a more recent version than v2.0.0. Since no new tags are available right now,
we update to the preliminary protocol version v2.3 according to the following
discussion: https://github.com/bazelbuild/remote-apis/issues/253
|
|
|
|
|
|
|
|
|
|
|
|
|
|
via a 'SYMLINK' constructor function. This works similarly to the
'FILE' construct, but the name given must point to a non-upwards
symlink and a symlink artifact is being generated from it.
Also updates the relevant tests.
|
|
...and update tests accordingly.
|
|
...as early as possible. This ensures that callers always receive
only the tree entries for the supported object types.
For the symlinks non-upwardness check we pass a lambda capturing
the real backend of the tree entries, such that the symlinks can
be read.
Updates git_tree tests accordingly.
|
|
...but make sure it is still considered a special type.
The only non-special entry types remain file, executable, and tree.
|
|
|
|
|
|
|
|
After a fatal error, do not continue evaluation, but return immediately.
|
|
|
|
Allow rules to set (additional) execution properties for individual
action. In this way the need for a special image (e.g., with
additional, maybe test-only, tools) or execution platform (e.g.,
when cross-compiling but having to execute the tests on the native
platform) can be expressed.
|
|
|
|
A git CAS ist just a fall back, so it is OK if it is absent (e.g.,
the specificed directory does not exist). Therefore only log at
debug level, not at error level if we cannot open it.
|
|
... which became obsolete with the new fdless write/copy
implementations.
|
|
... to remove the risk of deadlocks on certain combinations
of C++ standard library and libc when performing the
copy/write in a child process. For 'fdless' copy/write, a
child process is used to prevent the parent from getting
polluted with open writable file descriptors (which might
get inherited by other children that keep them open and can
cause EBUSY errors).
|
|
This feature has been introduced with C++20.
|
|
... and in this way, continue to work correctly in the absence
of a current working directory.
|
|
... also, gracefully handle the case of a missing working
directory when determining the current module, falling back
to the top-level module.
|
|
|
|
... and set default stack size to 8 MB.
|
|
...and make the use of std::hash consistent.
This will make it easier to remove the fix once the libc
implementation we use catches up with the C++ standard.
|
|
|
|
|
|
|
|
Allow rules to set the timeout-scaling factor for their actions to
indicate that some actions are expected to take longer than others,
e.g., because they call a foreign build tool or are a very complex
end-to-end test.
|
|
|
|
As local execution is tightly coupled to storage, also specify the
layout in the storage configuration. In this way, we have a central
place specifying the layout of just's cache directory and avoid
accidentally getting into conflicting situations. While there, also
move the execution root under the generation regime, to ensure that
left-over execution directories (e.g., after a forceful termination
of the program) eventually get cleaned up by garbage collection.
|
|
|
|
|
|
|
|
...caused by incorrectly setting and resetting the library internal
state and the misuse of pthreads in libgit2.
Normally, git_libgit2_init and git_libgit2_shutdown should span the
life of a worker thread in order to be safely used. However, due to
an incorrect implementation of libgit2's threadstate with pthreads,
on unix systems there is a race condition.
Until the use of pthread_key_t is corrected in libgit2, we need to
apply a workaround by always ensuring that the main thread is the
first thread reaching the GitContext constructor.
|
