This is a unified repository for Earth Computing, intended to painlessly keep work on different subsystems in sync, for as long as it is practical to do so in this way.

Various subsystems are arranged abstractly as follows, both as directories and as branches:

  ^
  |
  |\
  | \
  |  \
  |   \
  |\   \
  | \   \
  |  \   \
  |   \   \
  |    \   \
  |     \   \
  |      |   \
  |      |    \
 top     |     \
         |\     \
         | \     \
         |  \     \
         |   \     \
         |\   \     \
         | \   \     \
         |  \   \     \
         |   \   \     \
         |    \   \     \
         |     |   \     \
         |     |    \     \
         |     |     \     \
         |     |      |     \
         |  e1000e    |      |
         |            |      |
         |          ecnl     |
         |                   |\
       driver                | \
                             |  \
                             |   \
                             |\   \
                             | \   \
                             |  \   \
                             |   \   \
                             |    \   \
                             |     \   \
                             |      |   \
                         userspace  |    \
                                    |     \
                                    |      |
                                cellagent  |
                                           |
                                           |
                                        actix_
                                        server

For each subsystem, there is a branch -master and a branch -staging, such that each 'staging' branch is fed by the 'master' branches of its downstream subsystems and is the sole feed of a 'master' branch of the same subsystem, the intention being that 'staging' branches accept merges from various downstream subsystems in some arbitrary order, and that these are merged into the 'master' branch only when a consistent set of subsystems is in place, so that every commit in a 'master' branch is consistent. The branches for the 'top' subsytem are simply called 'master' and 'staging'. Another motivation for this system is that the history of subsystems remains untangled with that of parallel subsystems, although their commits intermingle at higher levels in the hierarchy. This makes it feasible to separate out subsystems into their own repository if we ultimately find it useful to do that.

Feature branches should be named -. Commit work in the lowest-level branch for which it is meaningful and appropriate. It is sometimes useful to work in a temporary branch off of master and then distribute the commits to where they belong. The instructions below assume that commits are not changed in any remote subsystem branch through a forced push. The instructions below are not intended as a substitute for a working knowledge of git.

To create a feature branch -:

$ git checkout <subsystem>-<master>
$ git checkout -b <subsystem>-<feature>

To track a remote branch for the feature:

$ git branch -u origin/<subsystem>-<feature>

To include into a feature branch upstream changes to the subsystem branch:

$ git checkout <subsystem>-<feature>
$ git rebase --preserve-merges -i <subsystem>-master

Mark the last (most recent) commit as 'edit'. Skip any commits from -master and resolve any conflicts in commits from -. Test that the feature is still working, updating the feature as necessary. If the feature can be made to work:

$ git rebase --continue

If not:

$ git rebase --abort

Upon successful completion of the rebase (coordinate with other users if branch is shared):

$ git push --force origin <subsystem>-<feature>

To promote enhancements to a feature branch to the subsystem branch:

$ git checkout <subsystem>-master

Obtain any previous feature enhancements:

$ git pull origin <subsystem>-master

Ensure nothing is broken by the previous feature enhancements.

$ git merge --no-ff <subsystem>-<feature>

If there are no conflicts, the merge will complete automatically. If there are conflicts, you need to resolve them. Once you do that:

$ git commit
$ git push origin <subsystem>-master

If you want to back out of the merge instead of resolving the conflicts:

$ git merge --abort

To undo a merge after it's completed, use interactive rebase and delete the new commits.

1. Build e1000e kernel module as described here
2. Build ECNL kernel module as described here
3. Build ECNL-Rust interface and cell binary as described here
4. Restart, loading drivers as described here
5. Disconnect machines
6. Run cell binary on each machine as described here
7. Connect 3rd port of one machine to second port of another