Contributing to Meshery using git

Working by Forking

Just head over to the GitHub page and click the “Fork” button. It’s just that simple. Once you’ve done that, you can use your favorite git client to clone your repo or just head straight to the command line:

Clone your fork to your local machine

git clone git@github.com:USERNAME/FORKED-PROJECT.git

Keeping Your Fork Up to Date While this isn’t a necessary step, if you plan on doing anything more than just a tiny quick fix, you’ll want to make sure you keep your fork up to date by tracking the original “upstream” repo that you forked. To do this, you’ll need to add a remote:

Add ‘upstream’ repo to list of remotes

git remote add upstream https://github.com/meshery/meshery.git

(“meshery” is used as the example repo. Be sure to reference the actual repo you’re contributing to e.g. “meshery-linkerd”).

Verify the new remote named ‘upstream’

git remote -v

Whenever you want to update your fork with the latest upstream changes, you’ll need to first fetch the upstream repo’s branches and latest commits to bring them into your repository:

Fetch from upstream remote

git fetch upstream

View all branches, including those from upstream

git branch -va

Now, check out your master branch and merge the upstream repo’s master branch:

Checkout your master branch and merge upstream

git checkout master
git merge upstream/master

If there are no unique commits on the local master branch, git will simply perform a fast-forward. However, if you have been making changes on master (in the vast majority of cases you probably shouldn’t be - see the next section, you may have to deal with conflicts. When doing so, be careful to respect the changes made upstream.

Now, your local master branch is up-to-date with everything modified upstream.

Create a Branch (doing your work) Whenever you begin work on a new feature or bugfix, it’s important that you create a new branch. Not only is it proper git workflow, but it also keeps your changes organized and separated from the master branch so that you can easily submit and manage multiple pull requests for every task you complete.

To create a new branch and start working on it, perform the following flow.

Check out the master branch - you want your new branch to come from the master

git checkout master

Create a new branch (give your branch its own simple informative name)

For enhancements use feature/your_username/issue# or feature/your_username/name_of_feature

For bugs use bug/your_username/issue# or bug/your_username/name_of_bug

git branch feature/jdoe/567

Switch to your new branch

git checkout feature/jdoe/567

Now, go to town hacking away and making whatever changes you want to.

Submitting your changes (a Pull Request)

Before submitting your pull request, you might want to do a few things to clean up your branch and make it as simple as possible for the original repo’s maintainer to test, accept, and merge your work.

In the time that you’ve been working on your changes, if any commits have been made to the upstream master branch, you will need to rebase your development branch so that merging it will be a simple fast-forward that won’t require any conflict resolution work.

Fetch upstream master and merge with your repo’s master branch

git fetch upstream
git checkout master
git merge upstream/master

If there were any new commits, rebase your development branch

git checkout feature/jdoe/567
git rebase master

Now, it may be desirable to squash some of your smaller commits down into a small number of larger more cohesive commits. You can do this with an interactive rebase:

Rebase all commits on your development branch

git checkout
git rebase -i master

This will open up a text editor where you can specify which commits to squash.

Validate with the Quality Gate (No-Mistakes)

These steps target meshery/meshery; for another Meshery repository, substitute that repository’s parent and fork URLs throughout. Pull requests into master need a green no-mistakes run unless every changed path is under docs/**, the root CNAME, or .github/workflows/**. There is no separate lane for hand-written changes. Run the pipeline on your branch:

no-mistakes axi run --intent "<brief description of your changes>"

The pipeline reviews, tests, checks documentation and lint, then writes the attestation that the PR must be raised via no-mistakes check requires into the pull request description. Commit with git commit -s so the separate DCO check passes. See Running the pre-landing Quality Gate for installation and setup.

Submitting

Once you’ve committed your changes, push them through the gate remote with git push no-mistakes feature/jdoe/567: a plain push targets origin, which the setup guide repointed at meshery/meshery. The gate runs the pipeline and opens the pull request for you once every check passes, so do not open one by hand. If you need to make any adjustments to your pull request, first run no-mistakes axi status and follow its branch_sync.next_action: when it says sync, run no-mistakes axi sync first, since the gate may have advanced the published branch past your local copy. Then push the updates through the gate remote, and run the gate again on the same branch so the attestation matches the new head commit. An attestation for an older commit fails the PR must be raised via no-mistakes check. Pull requests that change only docs/**, the root CNAME, or .github/workflows/** are exempt from the gate. If you never ran the gate setup, origin still points at your fork, so push with git push origin feature/jdoe/567 and open the pull request from your fork’s page. If you ran the setup, origin points at meshery/meshery, so add a remote for your fork first (git remote add fork git@github.com:USERNAME/meshery.git), push with git push fork feature/jdoe/567, and open the pull request from your fork’s page. Your pull request will automatically track the changes in your development branch and update it.