Omnia - User contributions [en]

USA Territories

2026-08-01T08:57:35Z

Kenneth:

Insular Areas of the United States and Freely Associated States <ref>https://www.doi.gov/library/internet/insular</ref>
* American Samoa
* Guam
* Republic of the Marshall Islands
* Federated States of Micronesia
* Commonwealth of the Northern Mariana Islands
* Republic of Palau
* Puerto Rico
* U.S. Virgin Islands

https://i.imgur.com/Wly2bTf.png

<ref>https://www.reddit.com/r/MapPorn/comments/18yvs3s/us_territories/</ref>

2026-07-27T18:06:46Z

Kenneth:

== Python 3.14 with OpenSSL 3 ==
# Python 3.14 + OpenSSL 3.x on CentOS 8

This guide installs:

- OpenSSL 3.x in `/opt/openssl-3`
- Python 3.14 in `/opt/python3.14`
- Modern TLS support for Python `ssl`, `urllib`, `requests`, and `aiohttp`
- Isolation from the OS Python and OpenSSL versions

This approach is recommended for environments that use:

- Corporate TLS inspection appliances
- Internal Artifactory servers
- Self-signed enterprise CAs
- Modern TLS requirements

Python 3.14 requires OpenSSL 1.1.1 or newer for SSL support. [1](https://www.python.org/downloads/release/python-3140/)

---

# 1. Install Build Dependencies

```bash
dnf groupinstall -y "Development Tools"

dnf install -y \
gcc \
gcc-c++ \
make \
wget \
perl \
perl-IPC-Cmd \
zlib-devel \
bzip2-devel \
libffi-devel \
readline-devel \
sqlite-devel \
xz-devel \
tk-devel \
gdbm-devel \
ncurses-devel
```

---

# 2. Download and Build OpenSSL 3.x

```bash
cd /usr/src

wget https://www.openssl.org/source/openssl-3.5.1.tar.gz

tar xf openssl-3.5.1.tar.gz

cd openssl-3.5.1
```

Configure:

```bash
./Configure \
--prefix=/opt/openssl-3 \
--openssldir=/opt/openssl-3 \
shared \
linux-x86_64
```

Build:

```bash
make -j$(nproc)
```

Install:

```bash
make install
```

Verify:

```bash
/opt/openssl-3/bin/openssl version
```

Expected:

```text
OpenSSL 3.5.x
```

---

# 3. Configure Runtime Linker

Create:

```bash
cat >/etc/ld.so.conf.d/openssl3.conf <<EOF
/opt/openssl-3/lib64
EOF
```

Refresh:

```bash
ldconfig
```

Verify:

```bash
ldconfig -p | grep ssl
```

Expected output should include:

```text
libssl.so.3
libcrypto.so.3
```

---

# 4. Download Python 3.14

```bash
cd /usr/src

wget https://www.python.org/ftp/python/3make -j$(nproc)
```

---

# 7. Install Python

```bash
make install
```

Verify:

```bash
/opt/python3.14/bin/python3.14 --version
```

Expected:

```text
Python 3.14.6
```

---

# 8. Verify OpenSSL Integration

```bash
/opt/python3.14/bin/python3.14 -c "
import ssl
print(ssl.OPENSSL_VERSION)
"
```

Expected:

```text
OpenSSL 3.5.x
```

---

# 9. Verify HTTPS Works

```bash
/opt/python3.14/bin/python3.14 -c "
import ssl
import urllib.request

print(ssl.OPENSSL_VERSION)
print(urllib.request.urlopen('https://www.python.org').status)
"
```

Expected:

```text
OpenSSL 3.5.x
200
```

---

# 10. Install Common Packages

```bash
/opt/python3.14/bin/pip3.14 install \
requests \
aiohttp \
certifi \
truststore
```

Verify:

```bash
/opt/python3.14/bin/pip3.14 list
```

---

# 11. Verify Requests

```python
import ssl
import requests

print("OpenSSL:", ssl.OPENSSL_VERSION)

r = requests.get(
"https://www.python.org",
timeout=30
)

print(r.status_code)
```

Expected:

```text
OpenSSL: OpenSSL 3.x.x
200
```

---

# 12. Check Python Trust Stores

Show OpenSSL trust path:

```python
import ssl

print(ssl.get_default_verify_paths())
```

Show Certifi path:

```python
import certifi

print(certifi.where())
```

This helps troubleshoot situations where:

- `curl` works
- Browser works
- Python Requests fails

because Requests typically uses Certifi rather than the OS trust store.

---

# 13. Force Requests to Use the OS Trust Store

For enterprise environments this is often recommended.

```python
import truststore

truststore.inject_into_ssl()
```

Example:

```python
import truststore

truststore.inject_into_ssl()

import requests

r = requests.get(
"https://artifactory.company.com",
timeout=30
)

print(r.status_code)
```

---

# 14. Verify Corporate Certificates

Check the complete certificate chain:

```bash
echo | \
/opt/openssl-3/bin/openssl s_client \
-connect artifactory.company.com:443 \
-showcerts
```

Look for:

```text
Verify return code: 0 (ok)
```

---

# 15. Verify Which OpenSSL Python Is Actually Using

```bash
ldd /opt/python3.14/bin/python3.14 | grep ssl
```

Expected:

```text
libssl.so.3 => /opt/openssl-3/lib64/libssl.so.3
libcrypto.so.3 => /opt/openssl-3/lib64/libcrypto.so.3
```

---

# Optional: Create Convenience Symlinks

```bash
ln -s /opt/python3.14/bin/python3.14 /usr/local/bin/python3.14

ln -s /opt/python3.14/bin/pip3.14 /usr/local/bin/pip3.14
```

Verify:

```bash
python3.14 --version
pip3.14 --version
```

---

# Troubleshooting

## SSL module missing

```python
import ssl
```

fails with:

```text
ModuleNotFoundError: No module named '_ssl'
```

Rebuild Python and verify the configure output detects:

```text
checking for OpenSSL ...
```

and:

```text
_ssl module... yes
```

---

## Requests certificate errors

Enable debugging:

```python
import ssl

print(ssl.OPENSSL_VERSION)
print(ssl.get_default_verify_paths())
```

Check Certifi:

```python
import certifi

print(certifi.where())
```

Test with OS trust store:

```python
import truststore

truststore.inject_into_ssl()
```

---

# Final Installed Layout

```text
/opt/openssl-3
/opt/python3.14
```

Benefits:

- Does not interfere with system Python
- Does not interfere with DNF
- Uses OpenSSL 3.x
- Fully supports Python 3.14 TLS features
- Easier troubleshooting of enterprise certificate issues

2026-07-26T23:06:11Z

Kenneth: Redirected page to Hand and Foot

#REDIRECT [[Hand and Foot]]

Cards

2026-07-26T23:04:05Z

Kenneth: Created page with "X"

2026-07-23T22:19:17Z

Kenneth: /* Unverified Extensions */

== Sort Lines ==

Sort lines - Visual Studio Marketplace
https://marketplace.visualstudio.com/items?itemName=Tyriar.sort-lines

Shortcut key: F9

== Upper Case ==

In Visual Studio it was:

To convert text to all upper case, choose Edit > Advanced > Make Uppercase or press Ctrl+Shift+U. To convert text to all lower case, choose Edit > Advanced > Make Lowercase or press Ctrl+U.
Make Uppercase or press Ctrl+Shift+U
Make Lowercase or press Ctrl+U

So, to mimmic, set the following Keyboard Shortcuts:
* Transform to Uppercase -> editor.action.transformToUppercase -> Ctrl+Shift+U
* Transform to Uppercase -> editor.action.transformToUppercase -> Ctrl+U

They conflict with existing shortcuts, but doesn't appear to cause any problems...

== Chocolatey Install ==

choco install vscode

https://update.code.visualstudio.com/1.94.0/win32-x64/stable

== End of Line Character ==

Settings -> "files: Eol" and change from "auto" to "\n".

https://i.imgur.com/q8zR8Vp.png

.

Can switch live using the setting in the "status bar":

https://i.imgur.com/uPREQTr.png

== WSL ==

code --remote wsl+Ubuntu /home/jim/projects/c

ref: <ref>https://code.visualstudio.com/docs/remote/wsl</ref>

== Code Folding ==

Collapse Code Blocks

* Fold All: Ctrl+K Ctrl+0 (Windows/Linux) or Cmd+K Cmd+0 (macOS) collapses all foldable regions.
* Unfold All: Ctrl+K Ctrl+J (Windows/Linux) or Cmd+K Cmd+J (macOS) expands all collapsed regions.
* Fold Current Block: Ctrl+Shift+[ (Windows/Linux) or Cmd+Shift+[ (macOS) folds the innermost uncollapsed region at the cursor.
* Unfold Current Block: Ctrl+Shift+] (Windows/Linux) or Cmd+Shift+] (macOS) unfolds the collapsed region at the cursor.

Expand to 2nd level:
* First expand all:
** Ctrl+K Ctrl+J
* Second expand
** Ctrl+K Ctrl+2

== List Plugins and Versions ==

List VS Code extensions and Versions:
code --list-extensions --show-versions

=== Glassworm Malware Returns ===

Glassworm malware returns in third wave of malicious VS Code packages
https://www.bleepingcomputer.com/news/security/glassworm-malware-returns-in-third-wave-of-malicious-vs-code-packages/

== Settings Files ==

Open the command pallet and type ">" then "settings" to see the 3 options for:
* Preferences: Open Workspace Settings (JSON) - [projectpath]\ .vscode\settings.json
* Preferences: Open Default Settings (JSON) - \defaultSettings.jsonc
* Preferences: Open User Settings (JSON) - %APPDATA%\Code\User\settings.json

== New Windows Maximized ==

To make VS Code open maximized by default, you need to adjust two settings in the Settings UI or your settings.json file.

Configure Settings
# Open Settings: Open the VS Code Settings UI by pressing Ctrl+, (Windows/Linux) or Cmd+, (Mac).
# Search for newWindowDimensions: In the search bar, type "newWindowDimensions".
# Set the Value: In the dropdown menu for the Window: New Window Dimensions setting, select maximized. This ensures that new windows open in a maximized state.
# Search for restoreFullscreen: Next, search for "restoreFullscreen".
# Enable the Setting: Check the box for the Window: Restore Fullscreen setting. This makes VS Code remember its last state, including being maximized, when it is closed and reopened.
# Restart VS Code: Close all VS Code windows and reopen the application. It should now open maximized by default.

Alternatively, you can add these lines to your settings.json file (accessible via the command palette with Preferences: Open Settings (JSON) (ctrl-p, ">", "open user settings.json")
"window.newWindowDimensions": "maximized",
"window.restoreFullscreen": true

== Fix Already Published Branch ==

When cloning from a shallow clone, and switching to another branch, this will confuse Visual Code.

git config --get-all remote.origin.fetch && echo "---REMOTE REFS---" && git for-each-ref refs/remotes/origin | head -20

"This is the signature of a --single-branch clone/fetch. Because main wasn't covered by that refspec, Git didn't treat origin/main as a tracking branch — so VS Code thought main was unpublished."

Solution:
# Restored the standard refspec: +refs/heads/*:refs/remotes/origin/*
# Fetched all branches from origin
# Set main to track origin/main

If you hit this again (local branch shows "Publish" even though it exists on the remote), here's the sequence:

1. Diagnose** — check whether the branch has an upstream and whether the fetch refspec is restricted:

```
git status -sb # look for missing [origin/...] next to branch
git config --get-all remote.origin.fetch # should be +refs/heads/*:refs/remotes/origin/*
```

2. Fix the refspec** (only if it's narrowed to a single branch):

```
git config remote.origin.fetch "+refs/heads/*:refs/remotes/origin/*"
```

3. Fetch and set the upstream:**

```
git fetch origin
git branch --set-upstream-to=origin/main main
```

Quick one-liner for the common case:

```
git config remote.origin.fetch "+refs/heads/*:refs/remotes/origin/*" && git fetch origin && git branch --set-upstream-to=origin/main main
```

Notes:
* Replace `main` / `origin` with the relevant branch and remote names.
* If `origin/<branch>` truly doesn't exist on the remote yet, the real fix is to publish it: `git push -u origin <branch>` (the `-u` sets the upstream at the same time).
* For any branch you're currently on, `git push -u origin HEAD` both publishes and sets tracking in one step.

== Verified Extensions ==

A list of publishers who have been “verified”, and their popular extensions used by Developers.

=== CodeScene ===
* CodeScene - Integrates CodeScene analysis into VS Code. Keeps your code clean and maintainable.

=== GitKraken ===
* GitLens - Git supercharged - Supercharge Git within VS Code — Visualize code authorship at a glance via Git blame annotations and CodeLens, seamlessly navigate and explore Git repositories, gain valuable insights via rich visualizations and powerful comparison commands, and so much more

=== Microsoft ===
* autopep8 - Formatting support for Python files using the autopep8 formatter.
* C/C++ - C/C++ IntelliSense, debugging, and code browsing.
* C/C++ DevTools - Enhanced development tools for C++ in VS Code
* C/C++ Extension Pack - Popular extensions for C++ development in Visual Studio Code.
* C/C++ Themes - UI Themes for C/C++ extension.
* C# - Base language support for C#
* C# Dev Kit - Official C# extension from Microsoft
* Container Tools - Makes it easy to create, manage, and debug containerized applications.
* CMake Tools - Extended CMake support in Visual Studio Code
* Dev Containers - Open any folder or repository inside a Docker container and take advantage of Visual Studio Code's full feature set.
* Docker - Makes it easy to create, manage, and debug containerized applications.
* Flake8 - Linting support for Python files using Pylint.
* GitHub Copilot Chat - AI chat features powered by Copilot
* Hex Editor - Allows viewing and editing files in a hex editor
* Kubernetes - Develop, deploy and debug Kubernetes applications
* Makefile Tools - Provide makefile support in VS Code: C/C++ IntelliSense, build, debug/run.
* Mono Debug - Visual Studio Code debugger extension for Mono
* .NET Extension Pack - The ultimate collection of extensions for working with .NET in VS Code!
* .NET Install Tool - This extension installs and manages different versions of the .NET SDK and Runtime.
* PowerShell - Develop PowerShell modules, commands and scripts in Visual Studio Code!
* Pylance - A performant, feature-rich language server for Python in VS Code
* Pylint - Linting support for Python files using Pylint.
* Python - Python language support with extension access points for IntelliSense (Pylance), Debugging (Python Debugger), linting, formatting, refactoring, unit tests, and more.
* Python Debugger - Python Debugger extension using debugpy.
* Python Environments - Provides a unified python environment experience
* Remote - SSH - Open any folder on a remote machine using SSH and take advantage of VS Code's full feature set.
* Remote - SSH; Editing configuration Files - Edit SSH configuration files
* Remote Development - An extension pack that lets you open any folder in a container, on a remote machine, or in WSL and take advantage of VS Code's full feature set.
* Remote Explorer - View remote machines for SSH and Tunnels.
* Remote Repositories - Remotely browse and edit git repositories
* Remote Tunnels - Connect to a remote machine through a Tunnel
* Serial Monitor - Send and receive text from serial ports.
* WSL - Open any folder in the Windows Subsystem for Linux (WSL) and take advantage of Visual Studio Code's full feature set.

=== Red Hat ===
* Ansible - Ansible language support
* YAML - YAML Language Support by Red Hat, with built-in Kubernetes syntax support

== Unverified Extensions ==

A list of “unverified” publishers. Validated by the sheer number of download counts (in the millions).

=== Kevin Rose ===
==== Python Indent ====
Python Indent - Correct Python indentation

=== Matt Bierner ===
==== Markdown Preview Mermaid Support ====
Markdown Preview Mermaid Support - (Published: August 2017, Installs: 5M) Adds Mermaid diagram and flowchart support to VS Code's builtin markdown preview

=== Mermaid Chart ===
==== Mermaid ====
Mermaid - (Published: June 2023, Installs: 952k)() - "The official Mermaid Editor plugin by the Mermaid open source team, now with AI-powered diagramming! Create, edit and preview diagrams seamlessly within VS Code"

=== Mechatroner ===
==== Rainbow CSV ====
Rainbow CSV - (20M) Highlight CSV and TSV files, Run SQL-like queries

=== oderwat ===
==== indent-rainbow ====
indent-rainbow (Published: February 2016, Installs: 13M) - Makes indentation easier to read (colored indentation)

=== Ukoloff ===
==== win-ca ====
win-ca - (200k) "Make Trusted Root Certificates @Windows available to VSCode extensions"

== keywords ==

Git

2026-07-23T20:43:40Z

Kenneth: /* Show siged commits */

'''Subpage Table of Contents'''

{{Special:PrefixIndex/{{PAGENAME}}/}}

<br/>

== Git ==

[http://git-scm.com/ Git - Fast Version Control System]

:"Git is...
:Git is a free and open source distributed version control system designed to handle everything from small to very large projects with speed and efficiency.
:Git is easy to learn and has a tiny footprint with lightning fast performance. It outclasses SCM tools like Subversion, CVS, Perforce, and ClearCase with features like cheap local branching, convenient staging areas, and multiple workflows."

---

:Git is...

:Git is an open source, distributed version control system designed to handle everything from small to very large projects with speed and efficiency.

:Every Git clone is a full-fledged repository with complete history and full revision tracking capabilities, not dependent on network access or a central server. Branching and merging are fast and easy to do.

[http://en.wikipedia.org/wiki/Git_(software) Git (software) - Wikipedia]:
:"Git is a free distributed revision control, or software source code management project with an emphasis on being fast. Git was initially created by Linus Torvalds for Linux kernel development.

:Every Git working directory is a full-fledged repository with complete history and full revision tracking capabilities, not dependent on network access or a central server."

== .gitconfig ==

<pre>
[user]
name = Kenneth Burgener
email = kenneth@oeey.com
</pre>

To set from the command line:
<pre>
git config --global user.name "Kenneth Burgener"
git config --global user.email kenneth@oeey.com
</pre>

List settings:
git config -l

== [http://en.wikipedia.org/wiki/Git_(software)#Name Name] ==

Linus Torvalds has quipped about the name "git", which is British English slang for a stupid or unpleasant person:

:"I'm an egotistical bastard, and I name all my projects after myself. First Linux, now git."

== Custom Bash Prompt ==

Customize your Bash prompt - makandropedia - http://makandracards.com/makandra/1090-customize-your-bash-prompt

GIT adds a __git_ps1 function that will output your branch. You can add onto it by specifying a string argument. A '%s' in the string will be replaced by the branch. I configured it to also show the short hash. Below is how I did it:
<pre>
get_sha() {
git rev-parse --short HEAD 2>/dev/null
}

get_hg_id() {
id="$(hg id -bt 2> /dev/null| sed -r 's/[]+//g')"
if [ -n "$id" ]; then
echo "($id)"
fi
}

PS1='${debian_chroot:+($debian_chroot)}'
PS1=$PS1'\[\033[00;32m\]\u@\h\[\033[00m\]:'
PS1=$PS1'\[\033[02;48m\]\w\[\033[00m\]'
PS1=$PS1'\[\033[00;35m\]$(__git_ps1 "(%s $(get_sha))")$(get_hg_id)\[\033[00m\]'
PS1=$PS1'\[\033[01;38m\]\$\[\033[00m\] '
</pre>

== HEAD Alias ==

HEAD^ vs HEAD~ vs HEAD^3 vs HEAD~3

Rules of thumb
* Use ~ most of the time — to go back a number of generations, usually what you want
* Use ^ on merge commits — because they have two or more (immediate) parents

Mnemonics:
* Tilde ~ is almost linear in appearance and wants to go backward in a straight line
* Caret ^ suggests an interesting segment of a tree or a fork in the road

Caret:
* HEAD^ means the first immediate parent of the tip of the current branch. HEAD^ is short for HEAD^1, and you can also address HEAD^2 and so on as appropriate.

HEAD^ == HEAD^1
HEAD~ == HEAD~1

HEAD^^ == HEAD^2
HEAD~~ == HEAD~2

ref: [https://stackoverflow.com/questions/2221658/whats-the-difference-between-head-and-head-in-git]
ref: [https://www.golinuxcloud.com/git-head-caret-vs-tilde-at-sign-examples/]

== Config Locations ==

=== Local Repo Config ===

Local Repo Config (default context)
/REPOPATH/.git/config
C:\REPOPATH\.git\config (--edit will report /c/REPOPATH/.git/config)

# because default context...
git config --edit
git config --list

git config --local --edit
git config --local --list

=== Global Repo Config ===

~/.gitconfig
C:\Users\USERNAME\.gitconfig (--edit will report ~/.gitconfig)

git config --global --edit
git config --global --list

=== System Wide Config ===

/etc/gitconfig
C:\Program Files\Git\etc\gitconfig (--edit will report /etc/gitconfig)

git config --system --edit
git config --system --list

== Commands ==

=== gittutorial ===

gittutorial - A tutorial introduction to git (for version 1.5.1 or newer):
man gittutorial

=== config ===

Configure name and email:
$ git config --global user.name "Kenneth Burgener"
$ git config --global user.email kenneth@t0e.org

=== init ===

Initialize git repository:
git init # current folder
git init . # current folder
git init [dir] # initialize folder (create folder if needed)

=== clone ===

Clone an existing repository:
git clone [repo] # clone [repo] to local dir named [repo] (only current branch)
git clone [repo] [newrepo] # clone [repo] to new local dir named [newrepo]

==== clone reference ====

To speed up cloning using a local reference:
git clone --reference /local/repo/path ssh://remote_repo new_repo

=== add ===

Add files to be tracked:
git add .
git add [file1] [file2] ...

==== undo add ====

This will undo the git add:
git reset [file]

==== add removed ====

To add commits with 'rm' or 'mv': [https://stackoverflow.com/questions/492558/removing-multiple-files-from-a-git-repo-that-have-already-been-deleted-from-disk]
git add -u

To stage your whole working tree:
git add -u :/

To stage just the current path:
git add -u .

To handle only removed files:
git rm `git ls-files -d`
# or
git ls-files -z -d | xargs -0 --no-run-if-empty git rm

XY problem: [https://stackoverflow.com/questions/1856654/how-to-add-and-commit-removals-made-with-rm-instead-of-git-rm]
git commit -a
: which would automatically pick up deletions, committing current state of tracked files in working directory

git add -A
: which would add not ignored untracked files and remove no longer existing files, e.g. if you want to create commit from sideways update of working directory, e.g. unpacking a snapshot or result of rsync.

=== commit ===

Commit changes:
git commit # include only 'added' files
git commit -a # also include modified tracked files
git commit -a -m 'message' # specify message

=== status ===

Show status: (shows: Changes to be committed, Changed but not updated, Untracked files)
git status

=== log ===

View commit log:
git log
git log -1 # show last commit
git log -p # diffs at each step
git log --stat --summary # overview

git log --stat # show files with change summaries
git log --name-only # show files only
git log --name-status # show file names with simple mod attribute

git log --name-status HEAD^..HEAD

git log -1 --stat # show last commit stats

git log -n 8 --oneline --graph --decorate

==== glog ====

Graphical Log: (ascii art)
git log --graph

---
glog - a git log alias for a decent view of your repo [https://coderwall.com/p/syqplg/glog-a-git-log-alias-for-a-decent-view-of-your-repo]

To create this alias, add the following to your .gitconfig

[alias]
glog = log --all --pretty='format:%d %Cgreen%h%Creset %an - %s' --graph

==== gitk ====

Graphical Commit Viewer for Git

gitk [file]

gitk --follow [file]

Shows change history of file in nice graphical view.

ref: https://www.youtube.com/watch?v=wkJ4leOuK_o

=== show ===

git show # show summary and diff of current position
git show --summary # show summary of current position

=== git id ===

git show could be used as a git id:
git show
git show --summary
git show -q # seems to work like --summary but not mentioned

git rev-parse HEAD # hash only
git show -s --format=%H # hash only
git show -s --format=%h # short hash

.gitconfig:
<pre>
[alias]
id = rev-parse HEAD
sha = rev-parse HEAD
</pre>

=== diff ===

See difference between changes and committed:
git diff # Show only changes not added to the index
git diff --cached

git diff HEAD..origin # show change between fetch and pull
git diff origin/master

git diff HEAD@{1} # show changes since before the last pull
git diff HEAD@{1} [filename] # same, but specify file

git diff HEAD^
git diff HEAD^ -- /foo/bar/baz.txt

git diff [shaOfHisCheckIn]^ [shaOfHisCheckIn]
git diff [shaOfHisCheckIn]{^,}

After doing a 'git fetch':
git log HEAD..origin

Alias for origin/master:
<pre>
[alias]
difff = diff origin/master
</pre>

=== Diff Ignore White Space ===

These options can be combined as needed to achieve the desired level of whitespace ignoring for your specific git diff comparison.

git diff --ignore-all-space
--ignore-all-space: or -w: This option completely ignores all whitespace when comparing lines. It treats lines with different amounts of whitespace (including the presence or absence of whitespace) as identical if the non-whitespace content is the same.
Code

git diff --ignore-space-change
--ignore-space-change: or -b: This option ignores changes in the amount of whitespace, but still acknowledges the presence or absence of whitespace. For example, it would treat "a b" and "a b" as the same, but "ab" and "a b" as different.
Code

git diff --ignore-space-at-eol
--ignore-space-at-eol: This option specifically ignores whitespace changes that occur only at the end of lines (trailing whitespace).
Code

git diff --ignore-blank-lines
--ignore-blank-lines: This option skips diffs where the only changes are the addition or removal of blank lines.
Code

=== Color Diff ===

git diff --color=always | less -r

Use less -r as pager:

git config --global color.ui true
git config --global core.pager 'less -r'

<pre>
[color]
ui = true
[core]
pager = less -r
</pre>

Ref: https://unix.stackexchange.com/questions/19317/can-less-retain-colored-output

=== branch ===

Branching:
git branch # list branches - master is default
git branch [branch] # create branch
git checkout [branch] # checkout desired branch
git merge [branch] # merge desired branch into current branch
git branch -d [branch] # delete merged branch (close a branch)
git branch -D [branch] # Terminate with extreme prejudice

=== Remote Branch ===

git checkout master
git branch mybranch
# note: does not auto checkout the new branch!
git checkout mybranch

# ... make changes ...

git push --set-upstream origin mybranch

=== Auto Setup Remote Branch ===

git config --global push.autoSetupRemote true

<pre>
$ git push
fatal: The current branch SOMEBRANCH/SOMEBRANCH has no upstream branch.
To push the current branch and set the remote as upstream, use

git push --set-upstream origin SOMEBRANCH/SOMEBRANCH

To have this happen automatically for branches without a tracking
upstream, see 'push.autoSetupRemote' in 'git help config'.
</pre>

==== Delete Remote Branch ====

# git push <remote_name> --delete <branch_name>
git push origin --delete mybranch

ref: [https://stackoverflow.com/questions/2003505/how-do-i-delete-a-git-branch-locally-and-remotely]

Filter and delete remote branches:
git branch -a | grep remotes/origin/SOMETHING | sed 's#remotes/origin/##' | xargs -l1 git push origin --delete

==== List Remote Branches ====

List only remote branches fetched locally:
git branch -r

To fetch a list of all remote branches:
git fetch --all

# I believe this equivalent to:
git remote update

To update all locally fetched remote branches:
git pull --all

=== merge ===

Merge branches:
git merge [branch] # merge [branch] into current branch

Merge 'test' branch back into master:
git checkout master
git merge 'test'

To close (delete) the merged branch:
git branch -d 'test'

==== Squash Merge ====

Squash Merge: <ref>https://stackoverflow.com/questions/5308816/how-can-i-merge-multiple-commits-onto-another-branch-as-a-single-squashed-commit</ref>
git checkout master
git merge --squash bugfix
git commit

==== Diverged Branches ====

<pre>
repo# git pull
From github.com:myrepo
* branch releases/myrepo -> FETCH_HEAD
hint: You have divergent branches and need to specify how to reconcile them.
hint: You can do so by running one of the following commands sometime before
hint: your next pull:
hint:
hint: git config pull.rebase false # merge (the default strategy)
hint: git config pull.rebase true # rebase
hint: git config pull.ff only # fast-forward only
hint:
hint: You can replace "git config" with "git config --global" to set a default
hint: preference for all repositories. You can also pass --rebase, --no-rebase,
hint: or --ff-only on the command line to override the configured default per
hint: invocation.
fatal: Need to specify how to reconcile divergent branches.
</pre>

I prefer rebase.true

=== Merge Conflict ===

==== Abort Merge ====

git merge --abort
git reset --hard
git reset --soft HEAD~

=== pull ===

Merge clones and pull from remote:
git pull [repo] [branch] # pull changes from another clone

Dry run:
git pull --dry-run

To try a pull without staving:
git pull --no-commit
git reset --merge

Dry run: [http://stackoverflow.com/questions/17222440/is-there-in-git-git-pull-dry-run-option]
git fetch origin && git merge origin/master --no-commit --no-ff && git reset --merge

After a dirty pull merge to clean up log:
git rebase origin/master

=== Remotes ===

Working with Remotes:
git fetch [repo] [branch] # pull change info only (safe)
git log -p HEAD..FETCH_HEAD # review changes
git remote add [RemoteName] [RemoteRepoURL] # add remote repo
git remote -v # list remote repos
git branch -r # list remote repos branches
git fetch [rrepo] # pull changes info
git log -p [branch]..[rrepo]/[branch] # see changes to remote repo compared to local
git merge [rrepo]/[branch] # merge remote branch to local
git pull . remotes/[rrepo]/[branch] # alternate form of merge

git pull # can pull changes directly if is clone
git config --get remote.origin.url # see what original clone was (origin)

git push origin master

Change remote url: [https://help.github.com/articles/changing-a-remote-s-url/]
git remote set-url origin ssh://git@gitserver/git/path

=== Git Hub ===

~/.gitconfig:
<pre>
[user]
name = Kilo Force
email = kiloforce@oeey.com
</pre>

Initial setup:
mkdir gittest
cd gittest
git init .
touch README.TXT
git add README.TXT
git commit -m 'initial commit'
git remote add origin https://bitbucket.org/kiloforce/gittest
git push origin master

git clone https://bitbucket.org/kiloforce/gittest
git add file.txt
git commit -a -m 'file commit'
git push

=== Prune and Sync Branches ===

git fetch --prune --prune-tags

[alias]
cleanhouse = fetch --prune --prune-tags

[alias]
cleanhouse = !sh -c 'git fetch --prune --prune-tags && git prune && git gc'

=== Tags ===

git tag # list tags
git tag -l # list tags
git tag -l <pattern> # list tags matching pattern
git log --decorate # list tags in log
git tag [tag] # tag current position
git log master..[tag] # show logs from master to tag
git log [tag]..master # show logs from tag to master (rev)
git checkout [tag] # update to certain tag
git describe # show the current tag

Sync tags: [https://stackoverflow.com/questions/10491146/in-git-how-do-i-sync-my-tags-against-a-remote-server]
git fetch -p -P

# or
git fetch --prune --prune-tags
# or
git fetch -p -P origin
# or
git fetch --prune --prune-tags origin

# FORCE [rejected] ... (would clobber existing tag)
git fetch -p -P -f origin

git fetch [<options>] [<repository>
# -p, --prune
# -P, --prune-tags
# -f, --force
==== Force Sync Tags ====

If you get a "would clobber existing tag", you can delete and force: [https://stackoverflow.com/questions/1841341/remove-local-git-tags-that-are-no-longer-on-the-remote-repository]
git tag -l | xargs git tag -d
git fetch --tags

alias git-sync-tags='git tag -l | xargs git tag -d ; git fetch --tags'

=== clean ===

Show what will be deleted:
git clean -n

To Clean:
git clean -f

Remove directories:
git clean -fd

Remove ignored files:
git clean -fX

Remove ignored and non-ignored files:
git clean -fx

Ref: [http://stackoverflow.com/questions/61212/how-to-remove-local-untracked-files-from-the-current-git-working-tree]

=== reset ===

DON'T TRY THIS ON ONE FILE!

Reset whole tree: (revert changes) [http://book.git-scm.com/4_undoing_in_git_-_reset,_checkout_and_revert.html]
# won't touch new files
git reset --hard HEAD^ # reset to head (does not rm new files)
git reset --hard HEAD # return the entire working tree to the last committed state

Reset to changeset (similar to checkout):
git reset --hard <HASH>

Throw away local changes:
git reset --hard origin/[BRANCH]

Soft, Mixed, Hard:
https://i.stack.imgur.com/qRAte.jpg
* Soft - undo commit, but keep index
* Mixed - undo commit, and undo index, but keep working directory ** DEFAULT **
* Hard - reset commit, reset index and reset working directory
ref: [https://stackoverflow.com/questions/3528245/whats-the-difference-between-git-reset-mixed-soft-and-hard]

=== Reset Hard with Prejudice ===

git clean -xdf && git reset --hard HEAD

Drop local commits
git reset --hard origin/master

=== revert like ===

re-checkout all files, overwriting any local changes. This is most similar to "svn revert" if you're used to Subversion commands:
git checkout .

Reset on file:
git checkout -- hello.rb
git checkout HEAD hello.rb

=== rollback like ===

rollback or undo the last commit [http://stackoverflow.com/questions/927358/how-do-you-undo-the-last-commit]

git reset --soft HEAD~

git commit -m "Something terribly misguided"
git reset --soft HEAD~
<< edit files as necessary >>
git add ...
#git commit -c ORIG_HEAD
#git commit -a -m "Something right"

Or with prejudice:
git reset --hard HEAD

=== Stash ===

Stash changes
git stash
git stash save "message"

Apply last change without deleting:
git stash apply

Apply last change with deleting:
git stash pop

Delete last stash:
git stash drop
git stash drop stash@{1} # drop stash 1

List stashes:
git stash

Show files in last stash:
git show

=== Amend ===

(similar to annotate / amend commit message)

Changing a commit message, and/or files [https://help.github.com/articles/changing-a-commit-message/]

git commit --amend

Change author:
git commit --amend --author="Author Name <email@address.com>"

Changing an older commit with rebase: [http://stackoverflow.com/questions/3042437/change-commit-author-at-one-specific-commit]
<pre>
git rebase -i [change_set_prior_to_target]
# change "pick" for target changesets
git commit --amend --author="Author Name <email@address.com>"
git rebase --continue
</pre>

# or
git commit --amend --reset-author --no-edit

=== Cherry Pick ===

git cherry-pick [hash]

Cherry Pick a range: <ref>https://stackoverflow.com/questions/1670970/how-to-cherry-pick-multiple-commits</ref>
git cherry-pick [hash]^...[hash]

==== Cherry Pick From Anther Repository ====

Cherry Pick From Anther Repository <ref>https://stackoverflow.com/questions/5120038/is-it-possible-to-cherry-pick-a-commit-from-another-git-repository</ref>

git remote add other https://example.link/repository.git
git fetch other
# or git fetch other BRANCH
git cherry-pick first_commit...last_commit
...
# when done:
git remote remove other

=== Submodules ===

git submodule init
git submodule sync
git submodule update
# or
git submodule update --init --recursive

Show submodule commit versions and branches:
git submodule status

== Helpful Aliases ==

<pre>
[alias]

cp = cherry-pick

####CAN'T OVERRIDE BASE NAME pull = pull --rebase
pul = pull --rebase
rpull = pull --rebase
pulll = pull --rebase
unstage = restore --staged

# difff = diff origin/master
# difff = diff origin
difff = !sh -c 'git diff origin/`git rev-parse --abbrev-ref HEAD`'

# uncommit ref: https://stackoverflow.com/questions/2845731/how-to-uncommit-my-last-commit-in-git
# rollback just commit:
uncommit = reset --soft HEAD^
# rollback commit and changes:
uncommithard = reset --hard HEAD^

rollback = reset --soft HEAD^
rollbackhard = reset --hard HEAD~
resethard = reset --hard HEAD~

pending = log origin/master..HEAD
pendingdiff = diff origin/master..HEAD
# show changed files
flog = log --stat
# show graph of commits
glog = log --all --pretty='format:%d %Cgreen%h%Creset %an - %s' --graph
# show tags
tlog = log --decorate
ref = !sh -c 'git ls-remote | grep $(git rev-parse HEAD)'

amend = commit --amend

showpatch = am --show-current-patch

lfs-files = lfs ls-files
lfsfiles = lfs ls-files
lfs-ls = lfs ls-files
lfsls = lfs ls-files

cleanhouse = !sh -c 'git fetch --prune --prune-tags && git prune && git gc'

ignored = ls-files --others --ignored --exclude-standard

#gud = status -s
gud = !echo 'go home you'\\''re drunk'

</pre>

== Installation ==

=== Manual Installation ===

Remove existing:
yum remove git
apt-get remove git

Install dependencies:
yum -y install gcc make curl-devel openssl-devel expat-devel autoconf gettext
# ? perl-ExtUtils-MakeMaker
sudo apt-get install curl libcurl4-openssl-dev libexpat1-dev gettext zlib1g-dev autoconf
suod apt-get install tclsh # is this needed?

Visit here to determine the version you want:
https://git-scm.com/download/linux
# it will say "The latest version is "2.45.1" (as of 14-May-2024)

# or manually find in the list:
http://kernel.org/pub/software/scm/git

Download Git source:
# GIT_VER=1.7.8.3 # removed
# GIT_VER=1.8.2.3 # 09-May-2013 earliest 1.x still available
# GIT_VER=1.8.3.4 # 22-Jul-2013
# GIT_VER=2.6.3 # 05-Nov-2015
# GIT_VER=2.25.1 # 17-Feb-2020
# GIT_VER=2.44.0 # 23-Feb-2024
GIT_VER=2.45.1 # 14-May-2024

mkdir -p ~/.src ; cd ~/.src
# wget http://git-core.googlecode.com/files/git-$GIT_VER.tar.gz
wget http://kernel.org/pub/software/scm/git/git-$GIT_VER.tar.gz
tar -zvxf git-$GIT_VER.tar.gz
cd git-$GIT_VER

Configure install:
make configure
# ./configure --prefix=/opt/git
./configure
make clean
make all
sudo make install

Git man pages: (optional step)
mkdir -p ~/.src ; cd ~/.src
# wget http://git-core.googlecode.com/files/git-manpages-$GIT_VER.tar.gz
wget http://kernel.org/pub/software/scm/git/git-manpages-$GIT_VER.tar.gz
sudo tar -zvxf git-manpages-$GIT_VER.tar.gz -C /opt/git/share/man/

Paths: /etc/bashrc
export PATH=/opt/git/bin:$PATH
export MANPATH=/opt/git/share/man/:$MANPATH
echo -e "\n\nexport PATH=/opt/git/bin:\$PATH\n" >> ~/.bash_profile
echo -e "\n\nexport MANPATH=/opt/git/share/man/:\$MANPATH\n" >> ~/.bash_profile

Note: the NO_GETTEXT=1 is needed to avoid a "Makefile:252: po/bg.msg] Error 127" <ref>https://stackoverflow.com/questions/50800829/compile-git-without-gettext?newreg=5ed483890d174baf8ac5b4ee1edf0acb</ref>

=== Other Installation Options ===

Manually install man pages:
# dependencies: (need RPMforge)
# yum install asciidoc libxslt xmlto
make man
sudo make install-man

/etc/bashrc:
export PATH=/opt/git/bin:$PATH
export MANPATH=/opt/git/share/man/

# direct usage
man -M ~/share/man git-commit
# or
export MANPATH=~/share/man
man git-commit

Personal install: (non configure method)
# personal install ~/bin ~/lib ~/share ... (prefix=~):
make
make install

Global install: (non configure method)
$ make prefix=/usr/local all doc info
sudo make prefix=/usr/local install install-doc install-html install-info

=== Install with Ubuntu PPA ===

sudo add-apt-repository ppa:git-core/ppa

sudo apt update
sudo apt -y install git
sudo apt -y upgrade git

=== Installation with DAG ===

Install with DAG:
# http://dag.wieers.com/rpm/packages/git/git-1.5.2.1-1.el5.rf.i386.rpm
rpm -Uvh http://apt.sw.be/redhat/el5/en/i386/rpmforge/RPMS/rpmforge-release-0.3.6-1.el5.rf.i386.rpm
yum install rpmforge-release # update rpmforge
yum install git

=== FreeBSD Installation ===

pkg_add -r git

=== Installation OF LFS ===

# git clone git@github.com:git-lfs/git-lfs.git

wget https://github.com/git-lfs/git-lfs/releases/download/v3.5.1/git-lfs-linux-amd64-v3.5.1.tar.gz
tar -zvxf git-lfs-linux-amd64-v3.5.1.tar.gz
sudo cp git-lfs-3.5.1/git-lfs /opt/git/bin/

== Use alternative ssh key ==

export GIT_SSH_COMMAND="ssh -i /path/to/git-private-access-key"
git clone REPO

or

GIT_SSH_COMMAND="ssh -i /path/to/git-private-access-key" git clone REPO

or

git clone -c "core.sshCommand=ssh -i ~/.ssh/<key>" git@github.com:<user>/<repo>.git

or wrapper:

~/.gitwrap.sh:

#!/bin/bash
ssh -i ~/.ssh/gitkey_rsa "$@"

export GIT_SSH=~/gitwrap.sh

or per repo config:

vim .git/config

[core]
sshCommand = ssh -i <IDENTITY_KEY_LOCATION> -o IdentitiesOnly=yes

ref: bash - How to specify the private SSH-key to use when executing shell command on Git? - Stack Overflow - https://stackoverflow.com/questions/4565700/how-to-specify-the-private-ssh-key-to-use-when-executing-shell-command-on-git

== Create Central Repo ==

Create a shared bare repo:
## Set permission
umask 0002
mkdir git
chown :sharedgroup git
# chmod g+ws git
chmod g+s git
cd git

# git init --bare some_project.git
# git clone --mirror some_existing_project.git
# git init --bare --shared some_project.git
mkdir some_project.git ; cd some_project.git
git init --bare --shared .

## Fix permissions and ownership
# chown some_project.git :sharedgroup -R
# find some_project.git -type d -exec chmod g+ws {} \;

<pre>
# config - with shared setting
[core]
repositoryformatversion = 0
filemode = true
bare = true
sharedrepository = 1
[receive]
denyNonFastforwards = true
</pre>

Central Repo
git clone [workingrepo] [dir] --mirror # create bare repo (ie dir='central')

## Make group editable:
find test-git.git -type d -exec chmod g+s {} \;
chmod g+w test-git.git -R
chown :git -R test-git.git/

git clone [repo] # clone bare repo
... make changes and commit ...
git push # push changes to repo

git clone kenneth@git.oeey.com:/git/oeey-git.git oeey-git.git --mirror

=== Mirror Repo ===

Create local mirror:
git clone [URL] [dir] --mirror
cd [dir]
git update-server-info # DON'T FORGET THIS STEP!

==== Sync Mirror ====

git remote update

cron job:
# 1 AM Sync git mirror
0 1 * * * /usr/bin/git --git-dir=/git/some_git_repo.git remote update

==== Set Mirror Default Branch ====

Option #1 - hack HEAD directly
/HEAD
ref: refs/heads/main_branch

Option #2 - use symbolic-ref:
git symbolic-ref HEAD refs/heads/main_branch

ref:
* Set the default branch in a Git repository (Example) - https://coderwall.com/p/wmizjg/set-the-default-branch-in-a-git-repository
* Git: Correct way to change Active Branch in a bare repository? - Stack Overflow - https://stackoverflow.com/questions/3301956/git-correct-way-to-change-active-branch-in-a-bare-repository

== Migrate Repo ==

<pre>
mkdir new_repo
cd new_repo
git init .

cd ../old_repo
git remote add origin [path]/new_repo # or url
# or manually modify .git/config to point to new repo

git push origin master
</pre>

== Git add is different ==

"Many revision control systems provide an add command that tells the system to start tracking changes to a new file. Git's add command does something simpler and more powerful: git add is used both for new and newly modified files, and in both cases it takes a snapshot of the given files and stages that content in the index, ready for inclusion in the next commit." [http://www.kernel.org/pub/software/scm/git/docs/gittutorial.html]

== cheat git ==

[http://cheat.errtheblog.com/s/git cheat git]

[http://github.com/guides/git-cheat-sheet Git Cheat Sheet - Guides - GitHub]

== forking ==

http://phonegap.pbworks.com/Git%3A-Forking-PhoneGap%C2%A0Documentation

http://programblings.com/2008/07/21/setting-up-a-long-term-fork-with-git/

Help.GitHub - Forking a project - http://help.github.com/forking/
#Fork in GitHub

# setup
git clone git@github.com:billyanyteen/github-services.git
cd github-services
git remote add upstream git://github.com/pjhyett/github-services.git
git fetch upstream

# push changes
git push origin master

# pull changes
#git fetch upstream
#git merge upstream/master
git pull upstream master

* Git forking for fun and profit /by @assaf - http://labnotes.org/2008/04/30/git-forking-for-fun-and-profit/
* Setting up a long term fork with Git » Programblings - http://programblings.com/2008/07/21/setting-up-a-long-term-fork-with-git/
* Help.GitHub - Sending pull requests - http://help.github.com/pull-requests/

== Files ==

=== git-rm ===

git-rm - Remove files from the working tree and from the index - http://www.kernel.org/pub/software/scm/git/docs/git-rm.html

=== git-mv ===

git-mv - Move or rename a file, a directory, or a symlink - http://www.kernel.org/pub/software/scm/git/docs/git-mv.html

== Log ==

Committed history:
git log

Pretty one line logs: (last 3 logs)
git log --pretty=oneline -3

== Diff ==

Diff of dirty, tracked files in the tree to the content added to the index:
git diff

Diff between index and HEAD of the current branch -- i.e. the changes that will be committed on git commit:
git diff --cached

== Patch ==

Create patch:
git diff --no-prefix origin/master/HEAD > my_bugNNN.patch

Creating the patch: [http://ariejan.net/2009/10/26/how-to-create-and-apply-a-patch-with-git/]
git format-patch [remote]/master --stdout > fix_empty_poster.patch

What changes in patch:
git apply --stat fix_empty_poster.patch

Test patch before applying (for conflicting files):
git apply --check fix_empty_poster.patch

Apply patch:
git apply fix_empty_poster.patch

Apply and signoff patch: (alternate to apply patch with signoff)
git am --signoff

== Branches ==

List branches: (* indicates current)
git branch # list local branches
git branch -r # list remote branches
git branch -a # list remote and local branches
git branch -v # list local branches and source

Create branch:
git branch [BRANCH] # local branch of current point in history:
git push origin origin:refs/heads/[BRANCH] # remote empty branch

List origin of current checkout branch: (also lists remote branches)
git ls-remote

Checkout branch:
git checkout [BRANCH] # checkout branch
git checkout [REMOTE]/[BRANCH]
git checkout [LOCALNAME] [REMOTE]/[BRANCH]
git checkout -b [BRANCH] # create and checkout branch
#or
git switch -c [BRANCH]
git checkout --track -b [BRANCH] # create and set push to use upstream (if not default)

Delete branch:
git branch -d [BRANCH] # delete merged branch (close branch)
git branch -D [BRANCH] # delete non merged branch - destructive
git push origin :[BRANCH] # delete remote branch
git push origin :heads/[BRANCH] # delete remote branch (not sure difference from previous)

Create/Push remote branch:
git push [REMOTE] [BRANCH]
git push origin [BRANCH]
git push [REMOTE] [LOCALBRANCH]:[BRANCH]
git push origin origin:refs/heads/[BRANCH] # remote empty branch

Merge (See [[#Merging]])
git merge [BRANCH] # merge branch into current

Determine branch of a detached head: [http://stackoverflow.com/questions/6059336/what-is-the-simplest-way-to-find-the-current-git-branch-name-when-in-detached-he]
git describe --contains --all HEAD
git log -n 1 --pretty=%d HEAD
git show -s --pretty=%d HEAD
git branch --contains HEAD # not best

Automate creating remote branches: [http://www.zorched.net/2008/04/14/start-a-new-branch-on-your-remote-git-repository/]
<pre>
#!/bin/sh
# git-create-branch <branch_name>

if [ $# -ne 1 ]; then
echo 1>&2 Usage: $0 branch_name
exit 127
fi

set branch_name = $1
git push origin origin:refs/heads/${branch_name}
git fetch origin
git checkout --track -b ${branch_name} origin/${branch_name}
git pull
</pre>

=== Compare Branches ===

Show diff
git diff branch1..branch2
git diff branch2.. # compare to current branch
git diff branch1...branch2 # only with changes in one but not both with 3 dots (mutually exclusive)

Show only files changed:
git diff --name-only branch1..branch2
# with status change:
git diff --name-status branch1..branch2
# file with more status details:
git diff --stat branch2..

eg. diff --name-status
M somefile/file1

Show commits between branches
git cherry branch2 # and current branch
git cherry branch1 branch2
git cherry -v branch2 # commit and commit title

eg. cherry -v
+ 95aaeac2f9e446018479bd00fc280ab217xxxxxx some title1
+ 4854da061b80a902b0d2ca0ac367c53d47xxxxxx some title2

Show log between branches:
git log branch1..branch2
git log branch1...branch2 # show commits either but not both with 3 dots (mutually exclusive)
git log branch2.. # compare to current branch

-- others --

Pretty visual output (glog style): <Ref>https://stackoverflow.com/questions/13965391/how-do-i-see-the-commit-differences-between-branches-in-git</ref>

git log --left-right --graph --cherry-pick --oneline branch1..branch2
git log --left-right --graph --cherry-pick --oneline branch2..

git log --graph --pretty=format:'%Cred%h%Creset -%C(yellow)%d%Creset %s %Cgreen(%cr)%Creset' --abbrev-commit --date=relative master..branch-X

git log --oneline --graph --all --decorate --abbrev-commit
git log --oneline --graph --all --decorate --abbrev-commit branch2..

git log --all --graph --pretty=format:'%Cred%h%Creset -%C(yellow)%d%Creset %s %Cgreen(%cr)%Creset'

git log --oneline --graph --all --decorate
# --oneline is short for --pretty=oneline --abbrev-commit

# commits in develop that are not in master:
git log --oneline --no-merges origin/master..origin/develop

# show files which ones are modified (not glog style)
git diff --stat --no-merges origin/master..origin/develop

# show commits about to be merged
# HEAD is more convenient to use than branch name
git fetch
git log --oneline --no-merges origin/master..HEAD

== Make Two Branches Identical ==

Fake "theirs strategy":

if you want DOWNSTREAM to reflect exactly what UPSTREAM is:

git switch -c tmp UPSTREAM
git merge -s ours DOWNSTREAM # ignoring all changes from main
git switch DOWNSTREAM
git merge tmp # fast-forward to tmp HEAD, which is dev
git branch -D tmp # deleting tmp

This has the benefit of recording the upstream ancestor as the first parent, so that the merge means "absorb this out-of-date topic branch" rather than "destroy this topic branch and replace it with upstream".

ref: github - git command for making one branch like another - Stack Overflow https://stackoverflow.com/questions/4911794/git-command-for-making-one-branch-like-another/4912267#4912267

---

The three main ways to do this:

1. Don't bother. Abandon branch A, make a new A2, and use that.

2. Use git reset or equivalent to re-point A elsewhere.

Methods 1 and 2 are effectively the same in the long run. For instance, suppose you start by abandoning A. Everyone develops on A2 instead for a while. Then, once everyone is using A2, you delete the name A entirely. Now that A is gone, you can even rename A2 to A (everyone else using it will have to do the same rename, of course). At this point, what, if anything, looks different between the case where you used method 1 and the case where you used method 2? (There is one place you may still be able to see a difference, depending on how long your "long run" is and when you expire old reflogs.)

3. Make a merge, using a special strategy (see "alternative merge strategies" below). What you want here is -s theirs, but it doesn't exist and you must fake it.

git - Making two branches identical - Stack Overflow - https://stackoverflow.com/questions/36320517/making-two-branches-identical

== Tags ==

Create tag:
git tag [TAG]
git tag -a [TAG] # with message using editor
git tag -a [TAG] -m 'message' # with message

List tags:
git tag
git tag -l [PATTERN]
git show [TAG] # show tag details and messages

Delete tag:
git tag -d [TAG]

Push tags to remote:
git push --tags

Get tags from remote:
git fetch

Show current tag: [http://stackoverflow.com/questions/2863756/is-there-a-single-git-command-to-get-the-current-tag-branch-and-commit] [https://stackoverflow.com/questions/4211604/show-all-tags-in-git-log]
git describe
git describe --always --tag
git log --pretty=format:'%ad %h %d' --abbrev-commit --date=short -1
git log --no-walk --tags --pretty="%D-g%h %s" # show all base tags (for 'git describe')

== Remotes ==

git-remote - manage set of tracked repositories - http://www.kernel.org/pub/software/scm/git/docs/git-remote.html

Remote Git repository tracking

Help:
man git-remote
git help remote

Add remote:
git remote add test git://github.com/user/test.git
# add and fetch remote details
git remote add test git://github.com/user/test.git -f

List remotes:
git remote
git remote show

Remote details:
git remote -v
git remote show [REMOTE]
git remote show origin

List origin of current checkout branch:
git ls-remote

Remove remote:
git remote rm [REMOTE]

Rename remote:
git remote rename [REMOTE]

Resources:
* Help.GitHub - Working with remotes - http://help.github.com/remotes/

=== git-fetch ===

Download objects and refs from another repository - http://www.kernel.org/pub/software/scm/git/docs/git-fetch.html

Fetch remote details:
git fetch -v
git fetch [REMOTE]

Checkout new branch from remote:
git checkout -b [LOCALNAME] [REMOTE]/[BRANCH]

=== git-pull ===

git-pull - Fetch from and merge with another repository or a local branch - http://www.kernel.org/pub/software/scm/git/docs/git-pull.html

Pull changes:
# Pull changes (git fetch followed by git merge)
# defaults to current branch from remote
git pull
git pull [remote_name]/[branch]
git pull origin master
git pull --dry-run # don't actually do anything

<pre>
You asked me to pull without telling me which branch you
want to merge with, and 'branch.bob.merge' in
your configuration file does not tell me, either. Please
specify which branch you want to use on the command line and
try again (e.g. 'git pull <repository> <refspec>').
See git-pull(1) for details.

If you often merge with the same branch, you may want to
use something like the following in your configuration file:

[branch "bob"]
remote = <nickname>
merge = <remote-ref>

[remote "<nickname>"]
url = <url>
fetch = <refspec>

See git-config(1) for details.
</pre>

=== git-push ===

NOTE: only can push changes when the 'master' branch is checked out. Other branches do not appear to work.

git-push - Update remote refs along with associated objects - http://www.kernel.org/pub/software/scm/git/docs/git-push.html

Dry run:
git push --dry-run [...]

Push changes:
# defaults to current branch from remote
git push
git push remote_name my_branch:remote_branch

git push REMOTENAME BRANCHNAME
git push REMOTENAME LOCALBRANCHNAME:REMOTEBRANCHNAME

NOTE: One important thing is that you should push only to remote branches that are not currently checked out on the other side (for the same reasons you never switch to a remote branch locally)! Otherwise the working copy at the remote branch will get out of date and confusion will ensue.

Create/Push remote branch:
git push [REMOTE] [BRANCH]
git push [REMOTE] [LOCALBRANCH]:[BRANCH]

$ git push [ssh://yourserver.com/~you/proj.git] master:master
$ git push [ssh://yourserver.com/~you/proj.git] master
$ git push [public-repo] master
You may force git push to perform the update anyway by preceding the branch name with a plus sign:
$ git push ssh://yourserver.com/~you/proj.git +master

<pre>
To git@github.com:user/repo.git
! [rejected] master -> master (non-fast-forward)
error: failed to push some refs to 'git@github.com:user/repo.git'
To prevent you from losing history, non-fast-forward updates were rejected
Merge the remote changes (e.g. 'git pull') before pushing again. See the
'Note about fast-forwards' section of 'git push --help' for details.
</pre>
git pull
git push -f

Failure of branch to push: http://ken-blog.krugler.org/2010/02/25/git-failed-to-push-some-refs-the-multiple-branch-variant/

Push tag: [http://help.github.com/remotes/]
git push REMOTENAME TAGNAME
# push all tags
git push REMOTENAME BRANCHNAME --tags

Delete tag:
# You are literally telling git “push nothing into BRANCHNAME on REMOTENAME”
git push REMOTENAME :BRANCHNAME

=== change remote ===

"Changing a remote’s URL - There is no direct command to change a remote’s URL, so you will usually run git remote rm followed by git remote add to change a URL. You can also edit the repo’s .git/config file directly to change the URL without re-fetching the remote." [http://help.github.com/remotes/]
git remote rm [REMOTE]
git remote add [REMOTE]

=== Rebase ===

To fetch new items from the git mirror, just do

git fetch

Then, you'll need to merge your changes with those in the head. Two options: rebase or merge.

If you haven't published your changes, you can just use rebase:

# git rebase [BRANCH]
<s>git rebase master</s>

git rebase origin/master

If there are conflicts, it will ask you to resolve them. After all is done, your commits will lie on top of those in git. Note that if one of your commits exactly matches changes made in git, it will silently disappear in rebasing.

An alternative is merging, which does not rewrite history,

# git merge [BRANCH]
git merge master

References:
* Staying abreast SVN - http://projects.scipy.org/numpy/wiki/GitMirror

== Merging ==

Merge branch into current branch
git merge [BRANCH]

Don't auto commit merge:
git merge [BRANCH] --no-commit

Git TUI merge tool:
git mergetool

Git User’s Manual - Resolving a merge - http://www.kernel.org/pub/software/scm/git/docs/user-manual.html#resolving-a-merge

Show changes to a conflicting file:
git diff [FILE]

During the merge, the index holds three versions of each file. Each of these three "file stages" represents a different version of the file:
$ git show :1:file.txt # the file in a common ancestor of both branches
$ git show :2:file.txt # the version from HEAD.
$ git show :3:file.txt # the version from MERGE_HEAD.

# common base version of the file
git show :1:some_file.cpp
# 'ours' version of the file
git show :2:some_file.cpp
# 'theirs' version of the file
git show :3:some_file.cpp

Some special diff options allow diffing the working directory against any of these stages:
$ git diff -1 file.txt # diff against stage 1
$ git diff --base file.txt # same as the above
$ git diff -2 file.txt # diff against stage 2
$ git diff --ours file.txt # same as the above
$ git diff -3 file.txt # diff against stage 3
$ git diff --theirs file.txt # same as the above.

If you get stuck and decide to just give up and throw the whole mess away, you can always return to the pre-merge state with
$ git reset --hard HEAD

Or, if you’ve already committed the merge that you want to throw away,
$ git reset --hard ORIG_HEAD

git merge [rrepo]/[branch] # merge remote branch to local
git pull . remotes/[rrepo]/[branch] # alternate form of merge

== vimdiff ==

vimdiff:
vimdiff [options] file1 file2

<pre>
ctrl+w ctrl+w - switch windows
do - diff obtain change (do below missing)
dp - diff push changes
[c - previous difference
]c - next difference
:diffupdate - diff update ;)
:syntax off - syntax off
zo - open folded text
zc - close folded text
</pre>

== Change Commit Message ==

Change last commit message with:
git commit --amend
git commit --amend -m "some message"

== Compress Repository ==

Ensuring good performance - http://www.kernel.org/pub/software/scm/git/docs/user-manual.html#ensuring-good-performance

On large repositories, git depends on compression to keep the history information from taking up too much space on disk or in memory.

This compression is not performed automatically. Therefore you should occasionally run git-gc(1):

$ git gc

to recompress the archive. This can be very time-consuming, so you may prefer to run git gc when you are not doing other work.

== Ignore ==

gitignore - Specifies intentionally untracked files to ignore - http://www.kernel.org/pub/software/scm/git/docs/gitignore.html

Patterns read from a .gitignore file in the same directory as the path, or in any parent directory, with patterns in the higher level files (up to the toplevel of the work tree) being overridden by those in lower level files down to the directory containing the file

Patterns read from $GIT_DIR/info/exclude

$ cat Documentation/.gitignore
# ignore generated html files,
*.html
# except foo.html which is maintained by hand
!foo.html

== Archive (Export) ==

git-commit - Record changes to the repository

Help:
man git-archive
git help archive

SVN calls this export, Git calls this archive.

Simple method:
* git clone followed by removing the .git repository directory.

Export project:
git archive master | tar -x -C /somewhere/else

Export and compress:
git archive master | bzip2 >source-tree.tar.bz2

Zip archive:
git archive --format zip --output /full/path master

Prefix folder in zip:
git archive --format zip --output /path/to/file.zip --prefix=newdir/ master

Uncompressed archive (-0 for uncompressed)
git archive --format zip --output "output.zip" master -0

Archive latest:
git archive -o latest.zip HEAD

git export:
git checkout-index -a -f --prefix=/destination/path/
git checkout-index --prefix=git-export-dir/ -a

with remote:
git-archive --format=tar --remote=ssh://remote_server/remote_repository master | tar -xf -

other: [http://www.clientcide.com/best-practices/exporting-files-from-git-similar-to-svn-export/]
git archive HEAD | (cd ~/path/where/I/want/it/ && tar -xvf -)
rsync path/I/want/to/export/ -ri --del -m --exclude ".*" ~/path/where/I/want/it/ |grep sT

other 2: [http://www.devdaily.com/git/git-export-project-archive-cvs-svn-export]
git archive master | gzip > latest.tgz
git archive master | bzip2 > latest.tar.bz2

Resources:
* How to do a "git export" (like "svn export") - Stack Overflow - http://stackoverflow.com/questions/160608/how-to-do-a-git-export-like-svn-export

== Git Server ==

[http://tumblr.intranation.com/post/766290565/how-set-up-your-own-private-git-server-linux How to set up your own private Git server on Linux | Bradley Wright] (using SSH)

?? (using git-daemon)
man git-daemon

yum install git-daemon

== Destructive Operations ==

=== Rewrite Commit Authors ===

List authors:
git log --all --format='%aN <%aE> - %cN <%cE>' | sort -u

Redo all commits:
<pre>
for i in 1 2 ; do
git filter-branch -f --tag-name-filter cat --commit-filter '
GIT_AUTHOR_NAME="Admin";
GIT_AUTHOR_EMAIL="admin@t0e.org";
GIT_COMMITTER_NAME="Admin";
GIT_COMMITTER_EMAIL="admin@t0e.org";
git commit-tree "$@"' -- --all
done
</pre>

Note: will need a '-f' to overwrite backup if you ever run a second time.

Rewrite certain commits:
<pre>
for i in 1 2 ; do
git filter-branch --tag-name-filter cat --commit-filter '
if [ "$GIT_AUTHOR_NAME" = "Ryan" -o "$GIT_AUTHOR_NAME" = "Ryan Test" ];
then
GIT_AUTHOR_NAME="Ryan Test";
GIT_AUTHOR_EMAIL="rtest@oeey.com";
GIT_COMMITTER_NAME="Ryan Test";
GIT_COMMITTER_EMAIL="rtest@oeey.com";
elif [ "$GIT_AUTHOR_NAME" = "Mike Test" ];
then
GIT_AUTHOR_NAME="Mike Test";
GIT_AUTHOR_EMAIL="mtest@oeey.com";
fi;
git commit-tree "$@"' -- --all
done
</pre>

Fancier filter [http://stackoverflow.com/questions/392332/retroactively-correct-authors-with-git-svn]
<pre>
#!/bin/sh

git filter-branch --env-filter '

n=$GIT_AUTHOR_NAME
m=$GIT_AUTHOR_EMAIL

case ${GIT_AUTHOR_NAME} in
user1) n="User One" ; m="user1@example.com" ;;
"User Two") n="User Two" ; m="user2@example.com" ;;
esac

export GIT_AUTHOR_NAME="$n"
export GIT_AUTHOR_EMAIL="$m"
export GIT_COMMITTER_NAME="$n"
export GIT_COMMITTER_EMAIL="$m"
'
</pre>

== GitHub ==

SSH: git@github.com:kiloforce/test.git
HTTP: https://kiloforce@github.com/kiloforce/test.git
Git Read-Only: git://github.com/kiloforce/test.git

Global setup:
Download and install Git
git config --global user.name "Kilo Force"
git config --global user.email kiloforce@oeey.com

Next steps:
mkdir test
cd test
git init
touch README
git add README
git commit -m 'first commit'
git remote add origin git@github.com:kiloforce/test.git
git push origin master

Existing Git Repo?
cd existing_git_repo
git remote add origin git@github.com:kiloforce/test.git
git push origin master

Importing a Subversion Repo:
https://github.com/kiloforce/test/imports/new

When you're done:
https://github.com/kiloforce/test

Check out project:
git clone git@github.com:kiloforce/test.git test
( modify files )
git commit -a -m 'changes'
git push
# git push git@github.com:kiloforce/test.git

NOTE: don't check out from https://github.com/kiloforce/test or you will get this error:
fatal: remote error:
You can't push to git://github.com/kiloforce/test.git
Use git@github.com:kiloforce/test.git

=== SVN for GitHub ===

Ever wanted to use SVN to grab code from GitHub? Well, now you can, and just like that GitHub is the world's biggest Subversion host. Here's a few things you might like to do with it:
* Use any GitHub repository as an SVN external.
* Use TortoiseSVN or your favorite SVN tool to view Git repositories.
* Use existing build tools or continuous integrations systems that only work with SVN.

Check out projects through svn.github.com: (http or https)
svn checkout https://svn.github.com/kiloforce/test.git test

Notice, on checkout there will be the following error that can be ignored.
REPORT of '/kiloforce/test.git/!svn/vcc/default': 200 OK (https://svn.github.com)
References:
* Announcing SVN Support - GitHub - http://github.com/blog/626-announcing-svn-support
* Subversion Write Support - GitHub - https://github.com/blog/644-subversion-write-support

=== Caching Password ===

authentication - Git push requires username and password - Stack Overflow - http://stackoverflow.com/questions/6565357/git-push-requires-username-and-password

The following command will save your password in memory for sometime.
(For git 1.7.10 or newer.)

# Set git to use the credential memory cache
$ git config --global credential.helper cache

# Set the cache to timeout after 1 hour (setting is in seconds)
$ git config --global credential.helper 'cache --timeout=3600'

You can also add to your git config (in repo or common), to remember which user name:
<pre>
[credential "https://example.com"]
username = kiloforce
</pre>

=== Credential Store ===

~/.git-credentials

git config credential.helper 'store <options>'

ref: https://git-scm.com/docs/git-credential-store

== Notch anti Git ==

:Oh, and I’ve finally committed the Music Blocks to the repository.

:(Oh, wait, no, I didn’t.. Doing so broke git, so we’re changing to svn because git is horrible and evil)

-- Notch (Jan 06, 2011)

Source: http://notch.tumblr.com/post/2623477410/strategy-meeting-day-results

== Git vs the World ==

Why Git is Better Than X - http://whygitisbetterthanx.com/

== [http://git-scm.com/ Git Quick Start] ==

Cloning and Creating a Patch:
<pre>
$ git clone git://github.com/git/hello-world.git
$ cd hello-world
$ (edit files)
$ git add (files)
$ git commit -m 'Explain what I changed'
$ git format-patch origin/master
</pre>

Creating and Commiting:
<pre>
$ cd (project-directory)
$ git init
$ (add some files)
$ git add .
$ git commit -m 'Initial commit'
</pre>

== Documentation ==

[http://git.or.cz/gitwiki/GitFaq GitFaq - GitWiki]

[http://git-scm.com/documentation Git - Documentation]

[http://www.kernel.org/pub/software/scm/git/docs/user-manual.html Git User's Manual (for version 1.5.3 or newer)]

[http://www.kernel.org/pub/software/scm/git/docs/gittutorial.html Official Git Tutorial]

[http://git-scm.com/course/svn.html SVN to Git Crash Course]

[http://www.spheredev.org/wiki/Git_for_the_lazy Git for the lazy - Spheriki]

[http://www-cs-students.stanford.edu/~blynn/gitmagic/ Git Magic]

[http://linux.yyz.us/git-howto.html Kernel Hackers' Guide to git]

== Ports ==

Git uses port 9418:

git clone git://git.kernel.org/pub/scm/git/git.git

If you have problems connecting (Git uses port 9418), you can try to access the repository over the HTTP protocol:

git clone http://www.kernel.org/pub/scm/git/git.git

== Git vs SVN ==

<table border="1">
<tr>
<th>Git</th>
<th>SVN</th>
</tr>
<tr>
<td>git clone url</td>
<td>svn checkout url</td>
</tr>
<tr>
<td>git pull</td>
<td>svn update</td>
</tr>
</table>

== Git Turotials ==

[http://git.or.cz/course/svn.html Git - SVN Crash Course]

== [http://git-scm.com/download Download] ==

This includes links for binaries and source code.

== gerrit - code review ==

gerrit - Gerrit Code Review - Google Project Hosting - http://code.google.com/p/gerrit/

Web based code review and project management for Git based projects.

Gerrit is a web based code review system, facilitating online code reviews for projects using the Git version control system.

Gerrit makes reviews easier by showing changes in a side-by-side display, and allowing inline comments to be added by any reviewer.

Gerrit simplifies Git based project maintainership by permitting any authorized user to submit changes to the master Git repository, rather than requiring all approved changes to be merged in by hand by the project maintainer. This functionality enables a more centralized usage of Git.
Resources

See [[Gerrit Code Review]]

== ssh config ==

~/.ssh/config
<pre>
Host myserver
user bob
Host *
user jenkins
</pre>

<pre>
Host gh-foo
Hostname github.com
User git
IdentityFile ~/.ssh/foo_github_id
Host gh-bar
Hostname github.com
User git
IdentityFile ~/.ssh/bar_github_id
</pre>

=== Specify SSH Key from Command Line ===

GIT_SSH_COMMAND="ssh -i /path/to/id_rsa" git clone ssh://git@git.server.com/path/repo

== Create Empty Branch ==

November 2021 Update: As of git version 2.27, you can now use git switch --orphan <new branch> to create an empty branch with no history.

git switch --orphan <new branch>
git commit --allow-empty -m "Initial commit on orphan branch"
git push -u origin <new branch>

Original solution:

git checkout --orphan empty-branch
git rm -rf .
git commit --allow-empty -m "root commit"
git push origin empty-branch

ref: [https://stackoverflow.com/questions/34100048/create-empty-branch-on-github]

--

Use option --orphan to create branch with no parents.

git checkout --orphan new-empty-branch
git rm -rf .
git commit --allow-empty -m "Initial commit on orphan branch"

ref: [https://tecadmin.net/git-create-empty-branch/]

== Force Local Repository to Match Remote ==

git remote prune origin # remove branches not on origin

git fetch origin --prune --tags
git reset --hard origin/HEAD
git clean -df

Cleanup:
git gc
du --si --max-depth=1 .git

---

git fetch --prune # (optional) Updates the local snapshot of the remote repo. Further commands are local only.
git reset --hard @{upstream} # Puts the local branch pointer to where the snapshot of the remote is, as well as set the index and the working directory to the files of that commit.
git clean -d --force # Removes untracked files and directories which hinder git to say “working directory clean”.

---

reset-repo.sh :
<pre>
#!/bin/bash
# reset the current repository
# WF 2012-10-15
# AT 2012-11-09
# see http://stackoverflow.com/questions/1628088/how-to-reset-my-local-repository-to-be-just-like-the-remote-repository-head
timestamp=`date "+%Y-%m-%d-%H_%M_%S"`
branchname=`git rev-parse --symbolic-full-name --abbrev-ref HEAD`
read -p "Reset branch $branchname to origin (y/n)? "
[ "$REPLY" != "y" ] ||
echo "about to auto-commit any changes"
git commit -a -m "auto commit at $timestamp"
if [ $? -eq 0 ]
then
echo "Creating backup auto-save branch: auto-save-$branchname-at-$timestamp"
git branch "auto-save-$branchname-at-$timestamp"
fi
echo "now resetting to origin/$branchname"
git fetch origin
git reset --hard origin/$branchname
</pre>

ref: <ref>https://stackoverflow.com/questions/1628088/reset-local-repository-branch-to-be-just-like-remote-repository-head/13308579#13308579</ref>

---

To force your local Git repository to exactly match the remote, including branches, tags, and purging untracked files, a series of commands is typically used. This process is destructive and will discard all local changes and commits that are not on the remote.

1. Fetch the latest changes and prune remote-tracking branches:

git fetch origin --prune --tags

This command fetches all new branches and tags from the origin remote and removes any local remote-tracking branches that no longer exist on the remote.

2. Reset your current local branch to match the remote branch:

git reset --hard origin/<branch_name>

Replace <branch_name> with the name of the branch you are currently on and want to reset (e.g., main, master, develop). This command discards all local commits and changes on the current branch, making it identical to the specified remote branch.

3. Clean your working directory of untracked files and directories:

git clean -df

* git clean -d: Removes untracked directories in addition to untracked files.
* git clean -f: Forces the removal of untracked files and directories.

4. (Optional) Delete local branches that no longer exist on the remote:

While git fetch --prune handles remote-tracking branches, you might have local branches that are no longer relevant and don't have a remote counterpart. You can list and manually delete these:
Code

git branch -vv | grep ': gone]'

This command lists local branches that are tracking remote branches that have been deleted. You can then delete them using:

git branch -D <local_branch_name>

5. (Optional) Delete local tags that no longer exist on the remote:

If you need to synchronize tags, and some local tags are not present on the remote, you can delete them locally:

git tag -d <tag_name>

Caution: This entire process is destructive. Ensure you have backed up any work you wish to preserve before executing these commands. You cannot easily undo a git reset --hard or git clean -f.

ref: Google AI

== Sign Commit ==

Create GPG key, and set gpgsign = true

Sign all commits with gpgsign:
git config --global commit.gpgsign true

~/.gitconfig :
<pre>
[commit]
gpgsign = true
</pre>

Sign single commit:
git commit -S
git commit --gpg-sign

With signing key:
git config --global commit.gpgsign true
git config --global gpg.format openpgp # default
git config --global user.signingkey 123456789....

Get signing key:
gpg -K
=== SSH Signing ===

git config --global gpg.format ssh

git config --global commit.gpgsign true
git config --global gpg.format ssh
git config --global user.signingkey signingkey C:/Users/username/.ssh/id_ed25519.pub

-

If you get this error when doing a "git log --show-signature"
error: gpg.ssh.allowedSignersFile needs to be configured and exist for ssh signature verification
commit d04axxxxxxxxxxxxxxxxxx (HEAD -> some/branch)
No signature

Do this:
git config --global gpg.ssh.allowedSignersFile ~/.ssh/allowed_signers

And add allowed with something like the following:
echo "$(git config --get user.email) namespaces=\"git\" $(cat ~/.ssh/signing.pub)" >> ~/.ssh/allowed_signers

=== generate GPG keys ===

gpg --full-generate-key

=== Show siged commits ===

git log --show-signature

=== Linux gpg ===

Adding a GPG key to your GitHub account - GitHub Docs
https://docs.github.com/en/authentication/managing-commit-signature-verification/adding-a-gpg-key-to-your-github-account

Generate key:
gpg --full-generate-key

List keys to get keyID
gpg --list-keys

Export public key by keyID, and save to Github
gpg --armor --export 3AA5C34371xxx

You will probably get an error about being unable to sign if you are in a remote console, to fix this: <ref>https://stackoverflow.com/questions/51504367/gpg-agent-forwarding-inappropriate-ioctl-for-device</ref>
export GPG_TTY=$(tty)

Cache password in gpg-agent:
echo "" | gpg --clearsign

~/.bashrc
alias gpgpass="echo '' | gpg --clearsign"

If you really hate security, you can remove the passphrase:
gpg --edit-key XXX
passwd
enter password to unlock
then enter empty password twice
then save

Restart agent

==== Reset GPG Agent ====

Reset GPG agent: <ref>https://superuser.com/questions/1075404/how-can-i-restart-gpg-agent</ref>
gpgconf --kill gpg-agent

# or

gpg-connect-agent reloadagent /bye

systemctl --user status gpg-agent
systemctl --user stop gpg-agent
systemctl --user start gpg-agent

gpg-connect-agent /bye

# kill the agent
gpg-connect-agent killagent /bye
# start it again
gpg-connect-agent /bye

== Mercurial ==

=== Git for Mercurial users ===

Command equivalence table - http://mercurial.selenic.com/wiki/GitConcepts#Command_equivalence_table

Git vs Mercurial - WikiVS - http://www.wikivs.com/wiki/Git_vs_Mercurial

See [[Git vs Mercurial]]

=== Convert Git to Mercurial ===

Really easy!
hg convert [git_repo] [hg_repo]

=== Convert Mercurial to Git ===

<pre>
cd ~
git clone git://repo.or.cz/fast-export.git
git init git_repo
cd git_repo
~/fast-export/hg-fast-export.sh -r /path/to/old/mercurial_repo
git checkout HEAD
</pre>

Source: Convert Mercurial project to Git - Stack Overflow - http://stackoverflow.com/questions/16037787/convert-mercurial-project-to-git

=== hg id ===

git rev-parse HEAD

# git rev-parse HEAD
ecf4fb28be83f2f1fcfe56b7311ee3477ab742c2

=== incoming and outgoing ===

[alias]
out = log --pretty=oneline --abbrev-commit --graph @{u}..
outgoing = log --pretty=oneline --abbrev-commit --graph @{u}..
in = !git fetch && git log --pretty=oneline --abbrev-commit --graph ..@{u}
incoming = !git fetch && git log --pretty=oneline --abbrev-commit --graph ..@{u}

Note: run "git fetch" first

Reference:
* Coderwall | git outgoing/incoming changes - https://coderwall.com/p/fowimq/git-outgoing-incoming-changes

---

Mimic 'hg incoming' and 'hg outgoing'

hg incoming:
git log ..@{u}
hg outgoing:
git log @{u}..

git config --global alias.incoming '!git remote update -p; git log ..@{u}'
git config --global alias.outgoing 'log @{u}..'

[alias]
incoming = "!git remote update -p; git log ..@{u}"
outgoing = log @{u}..

Reference:
mercurial - Using Git how do I find changes between local and remote - Stack Overflow - http://stackoverflow.com/questions/231211/using-git-how-do-i-find-changes-between-local-and-remote

== Issues ==

=== Unable to find http helper ===

Issue:
$ git clone git://github.com/git/hello-world.git
fatal: Unable to find remote helper for 'http'

Solution:
* The curl library was missing when git was compiled
* Install curl-devel and recompile.

=== Connection Refused ===

Issue:
$ git clone git://github.com/git/hello-world.git
Initialized empty Git repository in /data/store/home/kenneth/git-1.7.1/hello-world/.git/
github.com[0: 207.97.227.239]: errno=Connection refused
fatal: unable to connect a socket (Connection refused)

Solution:
* Open outbound TCP port 9418 on the Firewall

=== bash: git-upload-pack: command not found ===

<pre>
$ git clone username@host:~/project/path/contactdb
Initialized empty Git repository in
c:/Documents and Settings/Administrator/My Documents/projects/contactdb/.git/
bash: git-upload-pack: command not found
fatal: The remote end hung up unexpectedly
</pre>

Why is this git clone command failing? - Stack Overflow - http://stackoverflow.com/questions/999195/why-is-this-git-clone-command-failing

test with:
ssh [server] git-upload-pack

Solution:
* If this fails, add the path to the program to the user's .bashrc on the remote server

=== insufficient permission ===

Error:
error: insufficient permission for adding an object to repository database ./objects

Fix:
sudo chown -R git:git repo.git/

sudo chmod -R gituser.gituser objects

git - Error pushing to GitHub - insufficient permission for adding an object to repository database - Stack Overflow - http://stackoverflow.com/questions/1918524/error-pushing-to-github-insufficient-permission-for-adding-an-object-to-reposit

=== ssl certificate verify failed ===

Error:
error:14090086:SSL routines:SSL3_GET_SERVER_CERTIFICATE:certificate verify failed

or with Git LFS:
tls: failed to verify certificate: x509: certificate signed by unknown authority

Ignore ssl certificate verification: [http://stackoverflow.com/questions/3777075/https-github-access]
export GIT_SSL_NO_VERIFY=true
# or
git config --global http.sslverify false

git clone https://github...

References:
* server certificate verification failed. CAfile: /etc/ssl/certs/ca-certificates.crt CRLfile: none - Stack Overflow - http://stackoverflow.com/questions/21181231/server-certificate-verification-failed-cafile-etc-ssl-certs-ca-certificates-c
* docker - Git LFS give x509: certificate signed by unknown authority - Stack Overflow - https://stackoverflow.com/questions/60349972/git-lfs-give-x509-certificate-signed-by-unknown-authority

=== insufficient permission for adding an object to repository database ./objects ===

$ git push origin master
...
error: insufficient permission for adding an object to repository database ./objects
fatal: failed to write object
error: unpack failed: unpack-objects abnormal exit

See shared setting:
git config core.sharedRepository
# "", "group", etc...

echo $?
# rc 0 means shared, rc 1 means NOT shared

Solution:
cd /path/to/repo.git
chgrp -R groupname .
chmod -R g+rwX .
find . -type d -exec chmod g+s '{}' +

# set share setting
git config core.sharedRepository group # set group shared

# Verify:
git config core.sharedRepository # "group"

If you really hate permissions:
git config core.sharedRepository world

Not sure what level this does:
git config core.sharedRepository true

References:
* Git Push Error: insufficient permission for adding an object to repository database - Stack Overflow - http://stackoverflow.com/questions/6448242/git-push-error-insufficient-permission-for-adding-an-object-to-repository-datab

== Windows SSH Debugging ==

set GIT_SSH_COMMAND=ssh -vvv

# or if from Windows Git-Bash:
export GIT_SSH_COMMAND="ssh -vvv"
export GIT_TRACE=1
export GIT_CURL_VERBOSE=1
export GIT_TRACE_PACKET=1

export GIT_TRACE=1 GIT_CURL_VERBOSE=1 GIT_TRANSFER_TRACE=1

ref: [https://stackoverflow.com/questions/47318691/how-can-i-run-git-commands-on-windows-with-ssh-verbose-mode]

== Empty Email Commit ==

git config --global user.name 'Snail Mail'
git config --global user.email '<>'

git commit --author "Snail Mail <>"

ref: [https://stackoverflow.com/questions/7372970/git-commit-with-no-email]

== Windows No Mutual Signature Algorithm ==

Set verbose:
set GIT_SSH_COMMAND=ssh -vvv

Try the git command:
git clone...

Error:
debug1: send_pubkey_test: no mutual signature algorithm

In order to re-enable ssh-rsa support, inserting the following line into the affected SSH client's config file can re-enable this algorithm:

PubkeyAcceptedKeyTypes +ssh-rsa

ref: [https://confluence.atlassian.com/bitbucketserverkb/ssh-rsa-key-rejected-with-message-no-mutual-signature-algorithm-1026057701.html]

== Samba Line Endings ==

Check line endings:
git ls-files --eol

Ignore file mode:
git config --system core.filemode false

Remove every file from Git's index. <ref>https://stackoverflow.com/questions/5787937/git-status-shows-files-as-changed-even-though-contents-are-the-same</ref>
git rm --cached -r .

Rewrite the Git index to pick up all the new line endings.
git reset --hard

== Windows Auto Line Ending ==

<pre>
[core]
# autocrlf - https://docs.github.com/en/get-started/getting-started-with-git/configuring-git-to-handle-line-endings
autocrlf = true
</pre>

git config --global core.autocrlf true

-

If you’re on a Linux or macOS system that uses LF line endings, then you don’t want Git to automatically convert them when you check out files; however, if a file with CRLF endings accidentally gets introduced, then you may want Git to fix it. You can tell Git to convert CRLF to LF on commit but not the other way around by setting core.autocrlf to input:

$ git config --global core.autocrlf input

-

Warning you will git when trying to add text files:
$ git add test.txt
warning: in the working copy of 'test.txt', LF will be replaced by CRLF the next time Git touches it

== Windows Long File Names Support ==

Global across all your repos (~/.gitconfig)
git config --global core.longpaths true

Systemwide for all users (C:\Program Files\Git\etc\gitconfig)
git config --system core.longpaths true

== Git Gud ==

gud = !echo 'Not likely, go home you'\\''re drunk'

== Notes ==

=== To Read ===

SVN for Git:
* http://git-scm.com/course/svn.html
* https://github.com/blog/626-announcing-svn-support
* http://hub.witness.org/en/blog/yat-tibet
* http://help.github.com/svn-importing/
* https://github.com/blog/644-subversion-write-support
* https://github.com/blog/626-announcing-svn-support
* http://learn.github.com/p/git-svn.html
* http://stackoverflow.com/questions/807782/google-code-svn-or-github-git
* http://tomas.markauskas.net/en/blog/20100505-github-subversion-support
* https://github.com/blog/626-announcing-svn-support
* https://github.com/blog/644-subversion-write-support
* https://github.com/blog/31-back-to-subversion
* http://svnhub.com/
* https://github.com/blog/31-back-to-subversion
* http://git-scm.com/course/svn.html
* https://github.com/blog/626-announcing-svn-support
* https://github.com/blog/626-announcing-svn-support
* http://tortoisesvn.net/docs/release/TortoiseSVN_en/tsvn-dug-rename.html
* http://www.devdaily.com/blog/post/svn/move-directory-with-subversion-svn
* http://book.git-scm.com/4_undoing_in_git_-_reset,_checkout_and_revert.html

== keywords ==

[[Category:Git]]
[[Category:Programming]]

GitHub/gpg

2026-07-23T20:43:39Z

Kenneth:

== gpg ==

Adding a GPG key to your GitHub account - GitHub Docs
https://docs.github.com/en/authentication/managing-commit-signature-verification/adding-a-gpg-key-to-your-github-account

Generate key:
gpg --full-generate-key

List keys to get keyID
gpg --list-keys

Export public key by keyID, and save to Github
gpg --armor --export 3AA5C34371xxx

You will probably get an error about being unable to sign if you are in a remote console, to fix this: <ref>https://stackoverflow.com/questions/51504367/gpg-agent-forwarding-inappropriate-ioctl-for-device</ref>
export GPG_TTY=$(tty)

Cache password in gpg-agent:
echo "" | gpg --clearsign

~/.bashrc
alias gpgpass="echo '' | gpg --clearsign"

If you really hate security, you can remove the passphrase:
gpg --edit-key XXX
passwd
enter password to unlock
then enter empty password twice
then save

Restart agent

==== Reset GPG Agent ====

Reset GPG agent: <ref>https://superuser.com/questions/1075404/how-can-i-restart-gpg-agent</ref>
gpgconf --kill gpg-agent

# or

gpg-connect-agent reloadagent /bye

systemctl --user status gpg-agent
systemctl --user stop gpg-agent
systemctl --user start gpg-agent

gpg-connect-agent /bye

# kill the agent
gpg-connect-agent killagent /bye
# start it again
gpg-connect-agent /bye

== keywords ==

Linux/git

2026-07-23T20:41:32Z

Kenneth: Created page with "See Git"

See [[Git]]

Artifactory

2026-07-23T20:38:55Z

Kenneth: /* Access Token Creation */

== jfrog cli ==

Installation - https://jfrog.com/getcli/

Debian/Ubuntu:
# Create the keyrings directory if it doesn't exist
sudo mkdir -p /usr/share/keyrings;

# Download and save the JFrog GPG key to a keyring file
wget -qO - https://releases.jfrog.io/artifactory/api/v2/repositories/jfrog-debs/keyPairs/primary/public | sudo gpg --dearmor -o /usr/share/keyrings/jfrog.gpg

# Add the JFrog repository to your APT sources with the signed-by option
echo "deb [signed-by=/usr/share/keyrings/jfrog.gpg] https://releases.jfrog.io/artifactory/jfrog-debs focal contrib" | sudo tee /etc/apt/sources.list.d/jfrog.list

# Update the package list
sudo apt update

# Install the JFrog CLI
sudo apt install -y jfrog-cli-v2-jf

# Run the JFrog CLI intro command
jf intro

OLD:
# wget -qO - https://releases.jfrog.io/artifactory/jfrog-gpg-public/jfrog_public_gpg.key | sudo apt-key add -
# # echo "deb https://releases.jfrog.io/artifactory/jfrog-debs xenial contrib" | sudo tee -a /etc/apt/sources.list.d/jfrog.list && sudo apt update
# echo "deb https://releases.jfrog.io/artifactory/jfrog-debs noble contrib" | sudo tee -a /etc/apt/sources.list.d/jfrog.list && sudo apt update
# sudo apt install -y jfrog-cli-v2-jf
# jf intro

Redhat:
# Create and configure the JFrog CLI YUM repository
echo "[jfrog-cli]" > jfrog-cli.repo &&
echo "name=JFrog CLI" >> jfrog-cli.repo &&
echo "baseurl=https://releases.jfrog.io/artifactory/jfrog-rpms" >> jfrog-cli.repo &&
echo "enabled=1" >> jfrog-cli.repo &&
echo "gpgcheck=1" >> jfrog-cli.repo &&

# Import GPG keys for verifying packages
# Note: Two keys are imported for backward compatibility with older versions
rpm --import https://releases.jfrog.io/artifactory/api/v2/repositories/jfrog-rpms/keyPairs/primary/public &&
rpm --import https://releases.jfrog.io/artifactory/api/v2/repositories/jfrog-rpms/keyPairs/secondary/public &&

# Move the repository file to the YUM configuration directory
sudo mv jfrog-cli.repo /etc/yum.repos.d/ &&

# Install the JFrog CLI package
yum install -y jfrog-cli-v2-jf &&

# Display an introductory message for JFrog CLI
jf intro

== Artifactory JFrog Client Commands ==

=== Ping server ===
jf rt ping
ok

=== Show config ===
jf c s # jf config show

=== Add artifactory ===
jf c add # jf config add
server id: simple name
url: http://artifactory.example.com/
save and continue (assuming the urls are correct)
username: your username
pass/api: your password or api key
reverse proxy? likely no

jf c add ...
CI=true jf c add sandisk --url [url] --artifactory-url [url]/artifactory
CI=true jf c add sandisk --url https://artifactory.example.com/ --artifactory-url https://artifactory.example.com/artifactory

=== Search file ===
jf rt s [repo/pattern] # pattern can use wild cards

<pre>
Example:
# jf rt s myrepo/test/BUILD_NUMBER
13:42:58 [🔵Info] Searching artifacts...
13:42:58 [🔵Info] Found 1 artifact.
[
{
"path": "myrepo/test/BUILD_NUMBER",
"type": "file",
"size": 38,
"created": "2023-07-26T18:25:55.912Z",
"modified": "2023-07-28T00:32:13.868Z",
"sha1": "b43cda47086846025ca5aaa6256372bc2550xxxx",
"sha256": "62cce4682d3700b62d5dba0a098b65af928149576f614c51f5c7a03b99xxxxx",
"md5": "bd11639e2c9022ce8ab12d1eda61xxx"
}
]
</pre>

=== Access Token Creation ===

jf access-token-create
jf atc

Refresh tokens are commonly UUID-like strings
eg. f1782ce5-5683-444d-8c17-1f62bdace278

Access tokens typically start with:
eyJ...

Reference tokens often start with something resembling:
cmVm...

Create a token that expires in 90 days:
jf atc --expiry=7776000 --description="CLI token"

90 days * 24 hours per day * 60 minutes per hour * 60 seconds per minute = 7776000 seconds

Create a token that expires in 180 days:
jf atc --expiry=15552000 --description="CLI token"

180 days * 24 hours per day * 60 minutes per hour * 60 seconds per minute = 15552000 seconds

Create a refreshable token:
jf atc --refreshable=true
jf atc --refreshable

Return a reference token as well:
jf atc --reference=true
jf atc --reference

Create a 90 day refreshable token with short reference token:
jf atc --expiry=7776000 --description="CLI token" --refreshable --reference

Example:
<pre>
{
"scope": "applied-permissions/user",
"access_token": "eyJ....xxx_REALLY_REALLY_LONG_TOKEN_xxx",
"expires_in": 7776000,
"token_type": "Bearer",
"refresh_token": "59372fb0-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
"reference_token": "cmVxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
"token_id": "f28a7682-xxxx-xxxx-xxxx-xxxxxxxxxxxx"
}
</pre>

Refresh refreshable access token:
<pre>
ACCESS_TOKEN="access_token content"
REFRESH_TOKEN="refresh_token content"

curl -v \
-X POST \
"https://artifactory.example.com/access/api/v1/tokens" \
-H "Authorization: Bearer ${ACCESS_TOKEN}" \
-H "Content-Type: application/x-www-form-urlencoded" \
-d "grant_type=refresh_token" \
-d "refresh_token=${REFRESH_TOKEN}"
</pre>

If you want to include a reference token:
-d "include_reference_token=true" \

<pre>
curl -v \
-X POST \
"https://artifactory.example.com/access/api/v1/tokens" \
-H "Authorization: Bearer ${ACCESS_TOKEN}" \
-H "Content-Type: application/x-www-form-urlencoded" \
-d "grant_type=refresh_token" \
-d "include_reference_token=true" \
-d "refresh_token=${REFRESH_TOKEN}"
</pre>

Decode the expiration date: (expiration = creation_time + expires_in)
<pre>
TOKEN="eyJhbGciOi..."

python3 -c '
import base64,json,time
t="'$TOKEN'"
payload=t.split(".")[1]
payload += "=" * (-len(payload) % 4)
d=json.loads(base64.urlsafe_b64decode(payload))
print(json.dumps(d, indent=2))
print("Expires:", time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(d["exp"])))
'

# or
echo $TOKEN | cut -d. -f2 | base64 -d | jq .
# "exp": 1787423456
</pre>

Get tokens:
<pre>
curl \
-H "Authorization: Bearer $ACCESS_TOKEN" \
https://artifactory.example.com/access/api/v1/tokens

{
"tokens" : [ {
"token_id" : "961cad32-...",
"subject" : "jf-access@a0a259fa-.../users/some.user@example.com",
"expiry" : 1800379731,
"issued_at" : 1784827731,
"issuer" : "jf-access@a0a259fa-...",
"description" : "CLI token",
"refreshable" : true,
"scope": "applied-permissions/user"
}, {
...
} ]
}

NOTE: this also worked:

curl -H "Authorization: Bearer $REFERENCE_TOKEN" \
https://artifactory.sandisk.com/access/api/v1/tokens
</pre>

== API ==

=== Test Connection ===

GET /api/v1/system/ping

curl -X GET "http://ARTIFACTORY_SERVER_HOSTNAME:8082/distribution/api/v1/system/ping"

Ref: https://jfrog.com/help/r/jfrog-rest-apis/test-connection

=== Get System Info ===

GET /api/v1/system/info

curl -u myUser:myP455w0rd! -X GET "http://ARTIFACTORY_SERVER_HOSTNAME:8082/distribution/api/v1/system/info"

ref: https://jfrog.com/help/r/jfrog-rest-apis/get-system-info

== keywords ==