split repo on per-language basis

[laroque]

Motivation

It can be messy to keep track of updates to different languages in the same repo. At times features in develop for one end up accidentally merged into master when another language generates a release. There are administrative solutions that would probably allow us to clean this up, but public repos are free and so we might as well just split each language into its own repo (with its own issues, language-specific docs, etc.).

Proposal

1. project8/dripline will be used for documenting the dripline standard, without any implementations.
   • [x] The definition of the spec will be stored in .rst in the source of the repo (which is rendered by github), which will allow us to easily tag versions.
   • [x] The issue tracker for the repo will be available for proposing changes to the dripline standard and then discussing/approving them.
   • [x] For changes which are approved, we can use the issue tracker to also track which languages have implemented the new feature
   • [ ] We should also document and link to the implementation repos so that they all remain easy to find
2. Website
   • [ ] Move current gh-pages branch to dripline-python repo.
   • [ ] Replace gh-pages with Sphinx doc site based on .rst files in the repo
3. project8/dripline-python will contain the python implementation of dripline.
   • [x] Repo must be created and python source transferred with history
   • [x] All python-specific issues should be moved to the github issue tracker for that repo
   • [x] Automatic build scripts should update to point to the new repo
   • [ ] Insectarium components updated
4. project8/dripline-golang will contain golang implementation of dripline
   • [x] Repo must be created and golang source transferred with history
   • [x] All golang-specific issues should be moved to the github issue tracker for that repo
   • [x] Dependency update in swarm/mdreceiver and dungbeetle
5. project8/dripline-c++
   • [x] Repo must be created and C++ source transferred with history
   • [x] All C++-specific issues should be moved to the github issue tracker for that repo
   • [x] Submodule update in psyllid
   • [x] Remove cpp directory from dripline repo

Notes

• I have notes for extracting files/sub-directories from one repo and moving them to a new one here
• We should decide what the tagging model will be for the implementations. I propose normal semantic versioning, but perhaps a modification of the dripline standard's sender info such that there are included both a version for the dripline standard and a version for the library itself. The implementation source would then be storing internally what version of the standard it is implementing. This could be a data attribute of the dragonfly module, for example; I'm not sure how that applies to c++ or golang.
• We could make this procedure staged. For each language we could split off the new repo but make it a submodule in the dripline repo with the same location while we work out all of the above steps. Once the steps above are all resolved that submodule could then be removed.

[guiguem]

The installation scripts have been updated such as they will git clone https://github.com/project8/dripline-python.git and go to the associated sub-folders to pip install and python setup.py install

[nsoblath]

I agree with Ben's suggestion to move the code into separate repos, and then create submodules until all of the necessary steps have been completed.

Should we consider adding the dripline version to the wire protocol? Each implementation would be responsible for knowing what version it implements and filling that in on the messages. We could even consider a standard for, for example, accepting messages only if the major version number matches.

[nsoblath]

The move of dripline-cpp into a its own repo is now complete: https://github.com/project8/dripline-cpp

[nsoblath]

There's an even easier way to move directories into separate repos. Apparently the git people are aware that this is a popular thing to do, so it was added to git at some point.

http://stackoverflow.com/questions/359424/detach-move-subdirectory-into-separate-git-repository/17864475#17864475

[nsoblath]

I also noticed that, while the extracted files retain their history, separate branches are lost. So using essentially the method described in my last comment, I extracted progress on a development branch and moved it to the language-specific repo:

I had local repos of dripline and dripline-go. Dripline had the branch feature/h2d, which I wanted to move to dripline-go.

cd dripline
# isolate the "go" directory after switching to the relevant branch
git checkout feature/h2d
git subtree split -P go -b go-only-h2d
# push the changes over to the dripline-go repository
git checkout go-only-h2d
git push /path/to/dripline-go go-only-h2d
# change the name of the branch and push it to github
cd ../dripline-go
git checkout go-only-h2d
git branch feature/h2d
git checkout feature/h2d
git push origin feature/h2d

[nsoblath]

The move of dripline-go into a its own repo is now complete: https://github.com/project8/dripline-go

[nsoblath]

All golang to-do items are now complete.

[wcpettus]

dripline-python is now mostly done. Insectarium untouched and should be done by someone familiar with it.

• code migrated following Noah's rubric
  • major/minor tags added (revision tags ignored)
  • archive branch tagged in dripline repo and code removed
• issues migrated (Mathieu did this last month)
• scripts/DAQ_scripts updated for new path

Everything looks good against a test of services running on claude.