Been out, sorry for just catching up now…
I feel this thread pidgin hold on the word Accord and ignored the fact we are dealing with this pain today with python/jvm dtest and trying to improve that would help the project…. We also have other related projects that we are developing in parallel to Cassandra such as Harry, and there is interest in exporting our utils + simulator for other projects to use…. We also depend on related projects such as JAMM which clog us from bumping JDK versions...
Accord is just 1 example of a Cassandra dependency needed for a release… by only focusing on Accord and “should it be external” this thread is ignoring the pain we face today and how we could improve.
We tried in-tree for in-jvm dtest and found that this broke every other commit… maintaining the APIs across all our supported branches was too hard to do and moving it outside of the tree helped make the upgrade tests more stable (there were breakage but less frequent)…. We currently have to release this for every patch, which has actually caused us to rely on class path ordering to have some branches fork the classes so they can avoid this…. We tried to do snapshot builds where the version contained the SHA, but this has the issue that snapshot builds “may” go away over time and made older SHAs no longer building… Jvm-dtest is in bad shape and really could benefit from us looking to improve this process…
We break python-dtest when cross-cutting changes are added as CI is hard to do correctly or not supported (testing downstream users (our 4 supported branches) is rarely done).
We want to start using Harry as part of our test suite, so if a patch needs to change harry then what “should” we do? Do we block merging into Cassandra until we vote on a Harry release?
Maybe we should be asking what capabilities we need and how to address each? I believe Mick has focused on this capabilities conversation and feel its 100% the best route to do, we should be listing out what we need to do our work and if/how the different solutions address this.
For me I need the following:
* be able to make cross-cutting changes in 1 ticket
** in my PR override CI to use my PRs for sub-projects
* commits to Cassandra should be reproducible and buildable
* downstream testing support… if we make a change to python-dtest or Harry we should know if this breaks Cassandra before merging and which supported branches
* [nice to have] be able to work with all subprojects in one IDE and not have to switch between windows while making cross-cutting changes
* [nice to have] commit understand dependencies and commits things in correct order
Now, for the “how”, I am open but see the two leading cases are: git submodule and script that mimics git submodules…. I have used other tools that boil down to fetching a list of repo/sha into specific directories and find them more annoying than git submodules…
For me, both ways address my needs above; I can make cross cutting change with easy and could change CI to build my changes rather than the HEAD of a specific branch.
To address Mick’s capabilities I think I saw the following (correct me if missing any):
- you can no longer just `git clone …` (and we clone automatically in a number of places)
But submodules and script that no longer works, but we can make this less painful by enhancing build.xml to make sure it builds out the gate; we can’t see all the code on a fresh commit but we would still be buildable
- same with `git pull …` (easy to be left with out-of-sync submodules)
Correct, if you use submodules/script you have a text file saying what we “should” use, but this does not enforce actually using them… again we could make sure build.xml does the right thing, but this can be confusing for people who mainly build in IDE and don’t depend on build.xml until later in development… this is something we should think about…
A project I am familiar with has their build auto-inject git hooks to make sure things “just work”, we may be able to solve this in a similar way?
- permanence from a git SHA no longer exists
Why is this? The SHA points to other SHAs, so it is still immutable. If we claim that pointing to other SHAs doesn’t count then why do library versions? Both are immutable snapshots of code at a specific point in time?
- our releases get more complicated (our source tarballs are the asf releases)
We don’t include our dependencies do we? If so, then does it really? If Accord is a library we use, why would we include it’s source in the build? Isn’t it just another library from this point of view?
- handling patches cover submodules
I don’t know what you mean by this, do you mean how do we submit cross-cutting patches? How I do this in the cep-15-accord branch is by updating the pointer to point to my dependency PR, that way the build “does the right thing”, I just have to fix this up before merging into Cassandra (have to commit in the “correct" order)
- switching branches, and using git worktrees, during dv
What is the concern her? I am using work trees for PR review and cep-15-accord development and have zero issues with this; can you expand more on this?
And who would be fixing our build/test/release scripts to accommodate?
100% valid question to ask. I personally am in favor of the proposer doing the work and not depend on specific CI people to do the work for them…. But cool with others helping out… I do feel its not good to depend on a single CI person to do all this; w/e it is we define.
I'm thinking about reproducible builds,
Is the concern that checking out a sub-modules’s SHA may not compile, breaking C*? Is there another concern here? Want to fully understand
switching between branches,
This is a pain point that I feel should be handled by git hooks. We have this issue when you try to reuse the same directory for different release branches, and its super annoying when you go back in time when jars were in-tree as you need to cleanup after switching back…. I do agree that we should flesh this out as its going to be the common case, so how do we “do the right thing” should be handled
and git bisecting
Isn’t this just another example of switching branches? If we solve that case then doesn’t git bisect come in for free?
To include forward-merging
What is the concern here?
Rather that you need to know in advance when the SHA is not HEAD.
Do you? Or do you really need to know which “branch” it is following? For example, lets say we release 5.0 then 5.1 then 5.2, and there are accord versions for each: 1.0, 1.2, 2.0… do we not need to really know which branch it is following, and only when you are trying to do a cross-cutting change?
For example, if I want to fix a bug in 5.1 that modifies accord, I need to know to use the accord-1.2 branch? I think this is a solvable progress with submodules and script, but green we should think about this case as its going to come up
Correct. submodules does not solve/remove the need to commit to multiple branches and forward merge. Furthermore submodules means at least one additional commit, and possibly twice as many commits.
We have 4 maintained branches atm, so if there is a bug in accord that needs to be fixed in all 4 we need
4 commits for C*
1 to 4 for Accord, depending on release history.
If we make sure all branches are using the latest “stable” accord then this is 6 commits (4 for C*, 1 for accord the stable branch, then 1 to merge into trunk)
Our current commit process is human controlled, so every commit is a chance for human error. Maybe we should look to improve this? I know I have my own script to avoid human error (which supports jvm/python dtest), maybe it would be best if the project had automation to make sure everyone “does the right thing”?
Linking or merging while it is still also being a separate library and repo.
I am still unclear why you think this is “a significant thing”?
You would reference the snapshot dependency by the timestamped snapshot. This makes it a reproducible build.
How confident are we that the repository will not alter or delete them?
I see artefacts there that are more than a decade old. But we cannot rely on their permanence.
Given there's no guaranteed permanence to the snapshots, we would need to have the git sha in the version, so if much older versions can't be downloaded it can still be rebuilt.
This is done like: <revision>1.0.0_${sha1}-SNAPSHOT</revision>
linking in the source code into in-tree is a significant thing to do
Could you explain why? I thought your preferred alternative was merging the source trees permanently
Linking or merging while it is still also being a separate library and repo.
If we are really not that interested in it as a separate library, and dev change is high, or the code is somewhere less accessible, then in tree makes sense IMHO.
