
## `rsync`

```shell
rsync -r dir1/ dir2
# Sync dir1 with dir2 on the same system; Recurse into directories
# Trailing slash means "the contents of dir1"

# Useful options
# -a, --archive: Preserve symlinks, modification times, group, owner, permissions, etc
# -n, --dry-run: Perform a trial run that doesn't make any changes
# -v, --verbose: Increase the amount of information you are given during the transfer
# -z, --compress: Compress file data during the transfer
# --progress: Show progress during transfer
# --partial: Keep partially transferred files
# -P: Same as --partial --progress
# --delete: Delete extraneous files from dest dirs

rsync -a --delete --backup --backup-dir=<path_to_backup> <source> <destination>
# Store backups of important files

rsync -a --exclude=<pattern_to_exclude> <source> <destination>
# Exclude certain files

rsync -a --exclude=<pattern_to_exclude> --include=<pattern_to_include> <source> <destination>
# Exclude files matching pattern_to_exclude but include files matching pattern_to_include
```

### Push

```shell
rsync [options] <source> <username@host>:<destination>
```

### Pull

```shell
rsync [options] <username@host>:<source> <destination>
```

## `rclone`

```shell
rclone config # Enter an interactive configuration session.
rclone listremotes # List remotes
rclone ls remote:path [options] # List objects in path
rclone lsd remote:path [options] # List directories in path
rclone copy <source> remote:<destination> # Copy source to the remote
rclone sync -i <source> remote:<destination> # Sync source to the remote

# Useful options
# -P: Show progress during transfer
# -i: Enable interactive mode
# -n, --dry-run: Do a trial run with no permanent changes
```


rsync

[Top]

`rsync`

Push

Pull

`rclone`


## GnuPG

[Official documentation](https://www.gnupg.org/gph/en/manual.html)

### Generate a GPG key

```shell
gpg --full-generate-key
gpg --gen-key # Equivalent to above
```

### Generate a revocation certificate

```shell
gpg --gen-revoke --output revoke.asc <user ID>
```

[Ways to specify a user ID](https://www.gnupg.org/documentation/manuals/gnupg/Specify-a-User-ID.html)

### List all keys

```shell
gpg --list-secret-keys
gpg --list-key # Equivalent to above
gpg -k # Equivalent to above
gpg --list-secret-keys --keyid-format=long # List the long form of the keys
```

### Export a public key

```shell
gpg --armor --export <user ID> # Print the GPG public key in ASCII armor format
gpg --output username.gpg --export <user ID> # Export in binary format
```

### Import a public key

```shell
gpg --import alice.gpg
```

### Export a fingerprint

```shell
gpg --fingerprint <user ID>
```

### Encrypt a document

```shell
gpg --output doc.gpg --encrypt --recipient <recipient_email> doc
```

### Decrypt a document

```shell
gpg --output doc --decrypt doc.gpg
```



## bash

```shell
<Ctrl-r> # reverse-i-search
set -o vi # Enable vi mode in Bash
```

Bash scripting tip:

```shell
> var="apple orange"
> echo $var
apple orange

> echo $var | awk '{print $1}'
apple
> time ( echo $var | awk '{print $1}' )
apple
( echo $var | awk '{print $1}'; )  0.01s user 0.00s system 107% cpu 0.008 total

> echo $var | awk '{print $2}'
orange
> time ( echo $var | awk '{print $2}' )
orange
( echo $var | awk '{print $2}'; )  0.00s user 0.01s system 107% cpu 0.008 total
```

awk takes ~0.008 seconds whereas these builtin alternatives take just ~0.002 seconds

```shell
> echo "${var%% *}"
apple
> time ( echo "${var%% *}" )
apple
( echo "${var%% *}"; )  0.00s user 0.00s system 71% cpu 0.002 total

> echo "${var##* }"
orange
> time ( echo "${var##* }" )
orange
( echo "${var##* }"; )  0.00s user 0.00s system 72% cpu 0.002 total
```

## zsh

```shell
bindkey -v # vi mode in zsh shell
bindkey '^R' history-incremental-search-backward # Backward reverse search in zsh
take <dir_name> # Create a new directory `dir_name` and change to it

# Batch rename files with `zmv`
autoload zmv
zmv -n '(*).log' '$1.txt' # Preview the result of a move without making any actual changes

<Ctrl-q>
# "Parks" the command you're currently typing and takes you back to the prompt,
# letting you start over and type another command. Once you run that other command,
# the original command is un-parked and refills the command line.
```
