mirror of
https://github.com/facebook/sapling.git
synced 2024-10-10 08:47:12 +03:00
57f5d72a27
Summary: This is a major change to Eden's Hg extension. Our initial attempt to implement `edendirstate` was to create a "clean room" implementation that did not share code with `mercurial/dirstate.py`. This was helpful in uncovering the subset of the dirstate API that matters for Eden. It also provided a better safeguard against upstream changes to `dirstate.py` in Mercurial itself. In this implementation, the state transition management was mostly done on the server in `Dirstate.cpp`. We also made a modest attempt to make `Dirstate.cpp` "SCM-agnostic" such that the same APIs could be used for Git at some point. However, as we have tried to support more of the sophisticated functionality in Mercurial, particularly `hg histedit`, achieving parity between the clean room implementation and Mercurial's internals has become more challenging. Ultimately, the clean room implementation is likely the right way to go for Eden, but for now, we need to prioritize having feature parity with vanilla Hg when using Eden. Once we have a more complete set of integration tests in place, we can reimplement Eden's dirstate more aggressively to optimize things. Fortunately, the [[ https://bitbucket.org/facebook/hg-experimental/src/default/sqldirstate/ | sqldirstate ]] extension has already demonstrated that it is possible to provide a faithful dirstate implementation that subclasses the original `dirstate` while using a different storage mechanism. As such, I used `sqldirstate` as a model when implementing the new `eden_dirstate` (distinguishing it from our v1 implementation, `edendirstate`). In particular, `sqldirstate` uses SQL tables as storage for the following private fields of `dirstate`: `_map`, `_dirs`, `_copymap`, `_filefoldmap`, `_dirfoldmap`. Because `_filefoldmap` and `_dirfoldmap` exist to deal with case-insensitivity issues, we do not support them in `eden_dirstate` and add code to ensure the codepaths that would access them in `dirstate` never get exercised. Similarly, we also implemented `eden_dirstate` so that it never accesses `_dirs`. (`_dirs` is a multiset of all directories in the dirstate, which is an O(repo) data structure, so we do not want to maintain it in Eden. It appears to be primarily used for checking whether a path to a file already exists in the dirstate as a directory. We can protect against that in more efficient ways.) That leaves only `_map` and `_copymap` to worry about. `_copymap` contains the set of files that have been marked "copied" in the current dirstate, so it is fairly small and can be stored on disk or in memory with little concern. `_map` is a bit trickier because it is expected to have an entry for every file in the dirstate. In `sqldirstate`, it is stored across two tables: `files` and `nonnormalfiles`. For Eden, we already represent the data analogous to the `files` table in RocksDB/the overlay, so we do not need to create a new equivalent to the `files` table. We do, however, need an equivalent to the `nonnormalfiles` table, which we store in as Thrift-serialized data in an ordinary file along with the `_copymap` data. In our Hg extension, our implementation of `_map` is `eden_dirstate_map`, which is defined in a Python file of the same name. Our implementation of `_copymap` is `dummy_copymap`, which is defined in `eden_dirstate.py`. Both of these collections are simple pass-through data structures that translate their method calls to Thrift server calls. I expect we will want to optimize this in the future via some client-side caching, as well as creating batch APIs for talking to the server via Thrift. One advantage of this new implementation is that it enables us to delete `eden/hg/eden/overrides.py`, which overrode the entry points for `hg add` and `hg remove`. Between the recent implementation of `dirstate.walk()` for Eden and this switch to the real dirstate, we can now use the default implementation of `hg add` and `hg remove` (although we have to play some tricks, like in the implementation of `eden_dirstate.status()` in order to make `hg remove` work). In the course of doing this revision, I discovered that I had to make a minor fix to `EdenMatchInfo.make_glob_list()` because `hg add foo` was being treated as `hg add foo/**/*` even when `foo` was just a file (as opposed to a directory), in which case the glob was not matching `foo`! I also had to do some work in `eden_dirstate.status()` in which the `match` argument was previously largely ignored. It turns out that `dirstate.py` uses `status()` for a number of things with the `match` specified as a filter, so the output of `status()` must be filtered by `match` accordingly. Ultimately, this seems like work that would be better done on the server, but for simplicity, we're just going to do it in Python, for now. For the reasons explained above, this revision deletes a lot of code `Dirstate.cpp`. As such, `DirstateTest.cpp` does not seem worth refactoring, though the scenarios it was testing should probably be converted to integration tests. At a high level, the role of `DirstatePersistence` has not changed, but the exact data it writes is much different. Its corresponding unit test is also disabled, for now. Note that this revision does not change the name of the file where "dirstate data" is written (this is defined as `kDirstateFile` in `ClientConfig.cpp`), so we should blow away any existing instances of this file once this change lands. (It is still early enough in the project that it does not seem worth the overhead of a proper migration.) The true test of the success of this new approach is the ease with which we can write more integration tests for things like `hg histedit` and `hg graft`. Ideally, these should require very few changes to `eden_dirstate.py`. Reviewed By: simpkins Differential Revision: D5071778 fbshipit-source-id: e8fec4d393035d80f36516ac050cad025dc3ba31
75 lines
2.7 KiB
Thrift
75 lines
2.7 KiB
Thrift
namespace cpp2 facebook.eden.hgdirstate
|
|
namespace java com.facebook.eden.hgdirstate
|
|
namespace py facebook.hgdirstate
|
|
|
|
typedef string RelativePath
|
|
|
|
// Note that if the dirstate sets the status to 'n', then the file should no
|
|
// longer have an entry in the DirstateNonnormalFiles map.
|
|
enum DirstateNonnormalFileStatus {
|
|
// Ideally, there would not be any entries marked `Normal` in the
|
|
// DirstateNonnormalFiles map. However, Mercurial sometimes marks a file as
|
|
// `Normal` but with DirstateMergeState.BothParents or
|
|
// DirstateMergeState.OtherParent, so we must include this value in the enum.
|
|
Normal = 0x0, // 'n'
|
|
|
|
// This can also be used with DirstateMergeState.OtherParent.
|
|
NeedsMerging = 0x1, // 'm'
|
|
|
|
// In this state, a file may also be marked as DirstateMergeState.BothParents
|
|
// or DirstateMergeState.OtherParent.
|
|
MarkedForRemoval = 0x2, // 'r'
|
|
|
|
MarkedForAddition = 0x3, // 'a'
|
|
|
|
NotTracked = 0x4, // '?'
|
|
}
|
|
|
|
enum DirstateMergeState {
|
|
NotApplicable = 0x0, // >= 0
|
|
BothParents = 0x1, // -1
|
|
OtherParent = 0x2, // -2
|
|
}
|
|
|
|
/**
|
|
* Represents two of the four fields in a dirstatetuple in Mercurial. The four
|
|
* fields are: status, mode, size, mtime. The mapping is as follows:
|
|
*
|
|
* - status: DirstateNonnormalFileStatus.
|
|
* - mode: Fetch the st_mode from Eden.
|
|
* - size: DirstateMergeState. We are not interested in Hg storing the actual
|
|
* size of the file, but we are interested in the case where it sets it to
|
|
* the special values -1 and -2, which is captured by the DirstateMergeState
|
|
* enum.
|
|
* - mtime: Fetch the mtime from Eden, if necessary, though we should eliminate
|
|
* all codepaths in Hg that read this field. Note that Mercurial sometimes
|
|
* sets the mtime to -1 as a hack to indicate that the file status is unknown
|
|
* and needs to be recalculated. Eden should never be in this indeterminate
|
|
* state, so if we see -1, we should either throw or ignore it.
|
|
*
|
|
* Unfortunately, not every (DirstateNonnormalFileStatus, DirstateMergeState)
|
|
* pair is a valid state in Hg, so we have to throw a runtime exception if we
|
|
* encounter value for this struct that we deem to be illegitimate.
|
|
*/
|
|
struct DirstateNonnormalFile {
|
|
1: DirstateNonnormalFileStatus status,
|
|
2: DirstateMergeState mergeState, // 'size' in Hg's native dirstate.
|
|
}
|
|
|
|
// Key is a repo-relative file path. Value is the corresponding metadata.
|
|
struct DirstateNonnormalFiles {
|
|
1: map<RelativePath, DirstateNonnormalFile> entries
|
|
}
|
|
|
|
// Keys and values are both repo-relative file paths.
|
|
// Keys are destinations whereas values are sources.
|
|
struct DirstateCopymap {
|
|
1: map<RelativePath, RelativePath> entries
|
|
}
|
|
|
|
struct DirstateTuple {
|
|
1: DirstateNonnormalFileStatus status,
|
|
2: i32 mode
|
|
3: DirstateMergeState mergeState,
|
|
}
|