Продолжаем марафон утилит, которые я беру с собой от проекта к проекту практически без изменений.

## 💊 Проблема и решение
Знакомая ситуация: на проекте запущено 5 разных тестовых стендов для заказчиков, аналитиков и QA. Фронтендеру нужно постоянно следить, чтобы на конкретном инстансе крутилась именно та ветка, которую сейчас должны тестировать. Делать это вручную - сущий ад: нужно переключиться на ветку, сделать pull, сбросить локальные изменения, зафорсить в нужный стенд... Ошибся одной буквой в консоли либо перепутал ветки - и обновил не тот (либо сломал чужой) стенд.

Этот скрипт создан как раз для экономии времени на синхронизацию веток. Он автоматизирует рутину, когда нужно быстро и безопасно раскатить конкретную версию проекта на тестовый инстанс.

<Alert
type='info'
header='Финальная версия'
text='Перед тем как отдать на растерзание тетировщикам новую фичу (накатить ее на тестовый инстанс), нужно синхронизировать удаленную ветку `test` с удаленной веткой `stable`, вам нужно вызвать этот скрипт без передачи аргументов.
Поскольку в коде уже зашиты нужные вам значения по умолчанию (`DEFAULT_DEST="test"` и `DEFAULT_SOURCE="stable"`), скрипт сам подставит их.'
/>

## 🔥 Способы вызова скрипта
Перед запуском убедитесь, что ваш терминал открыт в корне Git-репозитория.

### Вариант 1: Безопасный просмотр (Рекомендуется)
Флаг `--dry-run` покажет, какие коммиты будут удалены или добавлены, но не внесет никаких изменений в Git:
```bash
bash _aux.sync-branches.sh --dry-run
```

### Вариант 2: Прямая синхронизация
Запуск в обычном режиме. Скрипт автоматически запросит подтверждение (y/n) перед сбросом веток:
```bash
bash _aux.sync-branches.sh
```

### Вариант 3: Явное указание веток
Вы можете вручную переопределить ветки. Аргументы передаются в порядке 👉 **[КУДА] [ОТКУДА]**:

```bash
bash _aux.sync-branches.sh test stable
```

## ⚙️ Как это работает под капотом
- Обновление данных: Скрипт выполняет `git fetch origin`, запрашивая свежую историю из удаленного репозитория;
- Локальный сброс: Операция сброса веток (`git reset --hard`) происходит локально на вашем компьютере;
- Пуш в сеть: Результат отправляется в удаленный репозиторий через `git push --force`;

<Alert
type='danger'
header='Важное замечание по работе скрипта'
text='Скрипт выполняет команду `git fetch origin`. Это значит, что для анализа изменений он использует самые свежие данные из удаленного репозитория
Однако, саму операцию сброса (`git reset --hard`) он делает локально на вашем компьютере, после чего отправляет результат в сеть через `git push --force`.
⚠️ Поэтому соблюдайте два правила 👇
1️⃣ **У вас не должно быть незакоммиченных изменений в локальном репозитории;**
2️⃣ **Не работайте с локальной веткой `test` - она будет перезаписана каждый раз при использовании этого механизма синхронизации;**'
/>

## 🚀 Код скрипта
`_aux.sync-branches.sh`
```bash
#!/usr/bin/env bash

# NOTE: 1. ПЕРЕМЕННЫЕ ПО УМОЛЧАНИЮ
DEFAULT_DEST="test"
DEFAULT_SOURCE="stable"

DRY_RUN=false
# NOTE: Проверяем наличие флага --dry-run
for arg in "$@"; do
    if [ "$arg" == "--dry-run" ]; then DRY_RUN=true; fi
done

# UPD: Безопасная очистка аргументов от флага без использования внешних утилит (sed)
ARGS=()
for arg in "$@"; do
    [[ "$arg" != "--dry-run" ]] && ARGS+=("$arg")
done

# UPD: Извлекаем элементы из правильно сформированного массива
DEST_BRANCH=${ARGS[0]:-$DEFAULT_DEST}
SOURCE_BRANCH=${ARGS[1]:-$DEFAULT_SOURCE}

# Логика определения целевой точки (если передан только 1 аргумент - это коммит для test)
if [ ${#ARGS[@]} -eq 1 ] && [ "${ARGS[0]}" != "prod" ] && [ "${ARGS[0]}" != "dev" ]; then
    TARGET_POINT=${ARGS[0]}
    DEST_BRANCH=$DEFAULT_DEST
else
    TARGET_POINT=$SOURCE_BRANCH
fi

START_BRANCH=$(git rev-parse --abbrev-ref HEAD)

# -- NOTE: Возврат при ошибках
# Функция вернет вас на исходную ветку, даже если скрипт упадет или вы нажмете Ctrl+C
cleanup() {
    local exit_code=$?
    trap - EXIT INT TERM # Предотвращаем бесконечный рекурсивный цикл trap
    echo "🔄 Возврат на исходную ветку: $START_BRANCH"
    git checkout "$START_BRANCH" >/dev/null 2>&1
    exit $exit_code
}
trap cleanup EXIT INT TERM
# --

TIMESTAMP=$(date +%Y%m%d_%H%M%S)
BACKUP_PREFIX="backup/${DEST_BRANCH}"
BACKUP_BRANCH="${BACKUP_PREFIX}_${TIMESTAMP}"

echo "📡 Обновление данных из origin..."
git fetch origin --prune

# --- NOTE: 2. Проверка существования целевой точки
if ! git rev-parse --verify "$TARGET_POINT" >/dev/null 2>&1; then
    echo "❌ Ошибка: Точка '$TARGET_POINT' не найдена."
    exit 1
fi
TARGET_SHA=$(git rev-parse "$TARGET_POINT")
# ---

# --- NOTE: 3. Анализ расхождений
REMOTE_DIFF=$(git rev-list --count "$TARGET_SHA..origin/$DEST_BRANCH" 2>/dev/null || echo 0)
LOCAL_DIFF=$(git rev-list --count "$TARGET_SHA..$DEST_BRANCH" 2>/dev/null || echo 0)

# UPD: Проверка на "обратное отставание"
BEHIND_COUNT=$(git rev-list --count "$DEST_BRANCH..$TARGET_SHA" 2>/dev/null || echo 0)

if [ "$BEHIND_COUNT" -eq 0 ] && [ "$REMOTE_DIFF" -eq 0 ] && [ "$LOCAL_DIFF" -eq 0 ]; then
    echo "✅ Ветки идентичны. Синхронизация не требуется."
    exit 0
fi

# Если источник (TARGET_SHA) сам отстает от цели (DEST_BRANCH)
if [ "$BEHIND_COUNT" -eq 0 ] && ([ "$REMOTE_DIFF" -gt 0 ] || [ "$LOCAL_DIFF" -gt 0 ]); then
    echo "⚠️  ВНИМАНИЕ: Кажется, ветки перепутаны местами!"
    echo "В целевой ветке [$DEST_BRANCH] ЕСТЬ новые коммиты, а в источнике [$TARGET_POINT] их НЕТ."
    echo "Сброс приведет к откату кода назад."
    read -p "Вы уверены, что хотите ОТКАТИТЬ $DEST_BRANCH к состоянию $TARGET_POINT? (y/n): " reverse_confirm
    [[ $reverse_confirm != "y" ]] && { echo "❌ Отмена."; exit 1; }
fi
# ---

# --- ПРОВЕРКА РАЗНИЦЫ (основная логика) ---
print_boxed_log() {
    local title="$1"
    local log_content="$2"

    # Если лог пустой, ничего не выводим
    [[ -z "$log_content" ]] && return

    # Определяем ширину рамки (минимум 60 символов, либо по ширине терминала - 4 символа для отступов)
    local term_width=$(tput cols 2>/dev/null || echo 80)
    local width=$(( term_width > 80 ? 80 : term_width - 4 ))
    [[ $width -lt 60 ]] && width=60

    # Линии рамки
    local horizontal_line=$(printf '─%.0s' $(seq 1 $width))

    # Верхняя граница
    echo -e "\e[33m┌${horizontal_line}┐\e[0m"

    # Заголовок блока
    printf "\e[33m│\e[0m %-${width}s \e[33m│\e[0m\n" "$title"
    echo -e "\e[33m├${horizontal_line}┤\e[0m"

    # Вывод строк лога с обрезкой по ширине, если они слишком длинные
    echo "$log_content" | while read -r line; do
        # Очищаем строку от спецсимволов, если нужно, и форматируем под рамку
        # Если строка длиннее рамки, она аккуратно обрезается, чтобы не ломать край
        if [ ${#line} -gt $((width - 2)) ]; then
            line="${line:0:$((width - 5))}..."
        fi
        printf "\e[33m│\e[0m %-$((width - 1))s \e[33m│\e[0m\n" "$line"
    done

    # Нижная граница
    echo -e "\e[33m└${horizontal_line}┘\e[0m"
}
if [ "$REMOTE_DIFF" -gt 0 ] || [ "$LOCAL_DIFF" -gt 0 ]; then
    echo "ℹ️  Цель [$DEST_BRANCH] получит $BEHIND_COUNT новых коммитов из [$TARGET_POINT]."
    echo -e "\e[31m⚠️  Будут УДАЛЕНЫ уникальные изменения из целевой ветки!\e[0m"
    echo ""

    # Собираем логи в переменные, используя origin/, чтобы избежать ошибки "unknown revision"
    # Также убираем дубликаты коммитов через sort -u
    LOCAL_LOG=$(git log --oneline "$TARGET_SHA..$DEST_BRANCH" 2>/dev/null || true)
    REMOTE_LOG=$(git log --oneline "$TARGET_SHA..origin/$DEST_BRANCH" 2>/dev/null || true)
    COMBINED_LOG=$(echo -e "${LOCAL_LOG}\n${REMOTE_LOG}" | grep -v '^$' | sort -u)

    # Выводим красивый блок
    print_boxed_log "Изменения на УДАЛЕНИЕ из [$DEST_BRANCH]:" "$COMBINED_LOG"
    echo ""

    if [ "$DRY_RUN" = true ]; then
        echo "🔍 [DRY-RUN]: Режим просмотра. Выход."
        exit 0
    fi

    read -p "Создать бэкап и перезаписать $DEST_BRANCH? (y/n): " confirm
    [[ $confirm != "y" ]] && { echo "❌ Отмена."; exit 1; }
fi
# ---

# --- NOTE: ВЫПОЛНЕНИЕ ---
# Проверяем чистоту рабочего каталога перед переключением
if ! git diff-index --quiet HEAD --; then
    echo "❌ Ошибка: У вас есть незакоммиченные изменения. Сделайте stash или commit."
    exit 1
fi

git checkout "$DEST_BRANCH"
echo "📦 Бэкап: $BACKUP_BRANCH"
git checkout -b "$BACKUP_BRANCH" && git push origin "$BACKUP_BRANCH"
git checkout "$DEST_BRANCH"

echo "🧹 Сброс $DEST_BRANCH до $TARGET_SHA..."
git reset --hard "$TARGET_SHA" && git push origin "$DEST_BRANCH" --force

# NOTE: Чистка бэкапов (удаленных и локальных)
THRESHOLD_DATE=$(date -d "7 days ago" +%Y%m%d 2>/dev/null || date -v-7d +%Y%m%d)

# Получаем уникальный список старых бэкапов (и локальных, и удаленных)
DELETED_BRANCHES=()
while read -r branch; do
    CLEAN_NAME=$(echo "$branch" | sed -E 's|[* ]+||g; s|remotes/origin/||; s|origin/||')

    # Проверяем, не обрабатывали ли мы эту ветку уже
    if [[ ! " ${DELETED_BRANCHES[@]} " =~ " ${CLEAN_NAME} " ]]; then
        BRANCH_DATE=$(echo "$CLEAN_NAME" | grep -oE '[0-9]{8}')

        if [ ! -z "$BRANCH_DATE" ] && [ "$BRANCH_DATE" -lt "$THRESHOLD_DATE" ]; then
            echo "🗑️ Удаляю старый бэкап: $CLEAN_NAME"
            git push origin --delete "$CLEAN_NAME" >/dev/null 2>&1
            git branch -D "$CLEAN_NAME" >/dev/null 2>&1
            DELETED_BRANCHES+=("$CLEAN_NAME")
        fi
    fi
done < <(git branch -a | grep "${BACKUP_PREFIX}_")
# ---

echo "✅ ГОТОВО! Ветка $DEST_BRANCH синхронизирована с $TARGET_POINT"
```

Job [2026.5] part 2 🎓 Синхронизация веток #git #bash #рабочие_моменты

https://russianblogs.com/article/35701401777/

> Интерфейсный проект работает в системной среде Ubuntu 18.04.npm run dev Следующая ошибка произошла во время выполнения команды

```bash
...
Running "browserSync:bsFiles" (browserSync) task
[Browsersync] Access URLs:
 ----------------------------------------
       Local: http://localhost:3000
    External: http://192.168.199.172:3000
 ----------------------------------------
          UI: http://localhost:3001
 UI External: http://192.168.199.172:3001
 ----------------------------------------
[Browsersync] Serving files from: ./
[Browsersync] Watching files...
Fatal error: ENOSPC: System limit for number of file watchers reached, watch '/home/w/my/project/...'
npm ERR! code ELIFECYCLE
npm ERR! errno 3
npm ERR! Exit status 3
npm ERR! 
...
```

> Проблема может быть решена путем выполнения следующих двух команд в терминале по порядку

```bash
echo fs.inotify.max_user_watches=524288 | sudo tee -a /etc/sysctl.conf && sudo sysctl -p
```

```bash
sudo sysctl --system
```

> Смысл в том, чтобы увеличить лимит файлов для наблюдения через inotify.
> Я не знаю, почему он по умолчанию такой маленький, но выбора всё равно нет
>
> 524288 это просто магическое число, можешь своё туда записать. По-умолчанию там 8192.
>
> Это максимальное количество файлов, за изменениями которых процесс может следить через интерфейс inotify на linux системе.
>
> Это у тебя инструменты разработки подписываются на изменения файлов, чтобы hot reload работал.

#bash Fatal error: ENOSPC: System limit for number of file watchers reached, watch '...path...'

## Удалить все файлы директории

Просто удалить все файлы в текущей директории, не трогая поддиректории и файлы в них

```bash
rm *
```

А если трогая, то так

```bash
rm -r *
```

Вместе со скрытыми

```bash
rm -rf .* *
```

## Как найти папку по имени?

```bash
find / -type d -name 'workers'
# / - искать по всей системе, то есть начинать с точки монтирования "/"
# type d - искать только папки
# name 'workers' - в данном случае точное совпадение с workers
```

## Как найти файл по части имени?

```bash
find / -type f -name '*_workers.rb'
# / - искать по всей системе, то есть начинать с точки монтирования "/"
# type f - искать только файлы
# name '*_workers.rb' - в данном случае все, что заканчивается на "_workers.rb"
```


#bash | Найти файл/папку по (части-) имени | Удалить все файлы директории

## CMD sample
```bash
GIT_SHA1=$(git show --format=\"%h\" --no-patch) NODE_ENV=production rollup -c rollup.config.js

# Or branch name:
GIT_BRANCH_NAME=$(git rev-parse --abbrev-ref HEAD)
```

`package.json`
```bash
{
  "scripts": {
    "dev": "yarn watch:spa",
    "build": "GIT_SHA1=$(git show --format=\"%h\" --no-patch) NODE_ENV=production rollup -c rollup.config.js",
    "watch": "GIT_SHA1=$(git show --format=\"%h\" --no-patch) NODE_ENV=development OPEN_SPA=0 rollup -c rollup.config.js --watch",
    "watch:spa": "GIT_SHA1=$(git show --format=\"%h\" --no-patch) NODE_ENV=development OPEN_SPA=1 rollup -c rollup.config.js --watch",
    "test": "echo \"Error: no test specified\" && exit 1"
  },
}
```

`./rollup.config.js`
```js
import { writeStaticFileAsync } from './scripts/write_static_file_async'

const gitSHA1 = process.env.GIT_SHA1 || 'No process.env.GIT_SHA1'
const buildInfoFilePath = path.join(__dirname, 'front/static/js/common/constants/build-info.js')
writeStaticFileAsync(buildInfoFilePath, `const gitSHA1 = '${gitSHA1}';`)
```

`./scripts/write_static_file_async.js`
```js
import fs from 'fs'

export const writeStaticFileAsync = (storageFilePath, text) => {
  fs.writeFile(storageFilePath, text, 'utf8', (err) => {
    if (!!err) console.log(err)
  })
}
```

Не забудьте добавить создаваемый файл в `.gitignore`

#git #bash | Get commit hash for build // GIT_SHA1 #smartpriceRINGEO

## Convert to webm

- Install the main tool by `$ sudo apt install ffmpeg`
- Create new file by `$ touch encode_to_webm.sh` with the content below: 
```bash
#!/bin/bash

if [ $# -eq 3 ]
then
	ffmpeg -y -i $1 -c:v libvpx-vp9 -pass 1 -b:v $3 -threads 1 -speed 4 -g 9999 -aq-mode 0 -an -f webm /dev/null && \
	ffmpeg -i $1 -c:v libvpx-vp9 -pass 2 -b:v $3 -threads 1 -speed 0 -auto-alt-ref 1 -lag-in-frames 25 -g 9999 -aq-mode 0 -an -f webm $2
else
	echo "Используйте три аргумента:"
	echo $0 "<файл_источник>" "<выходной файл>" "<битрейт>"
	echo
	echo "Пример:"
	echo $0 "file.mp4" "file.webm" "500K"
fi
```
- *So, you can use this file like this:*
```bash
bash ./encode_to_webm.sh [input file name] [output file name] [bitrate]
```

*For example:*
```bash
bash ./encode_to_webm.sh file.mp4 file.webm 500K
```
*And also try this if necessary:*
```bash
chmod +x encode_to_webm.sh
```
## Other formats
For everything else there is a [HandBrake](https://handbrake.fr/).

#bash #video convertion utility with `ffmpeg`

https://linuxize.com/post/bash-source-command/

See also: **[this example](https://github.com/pravosleva/pravosleva-blog-2021-frontend.cra/commit/19c29cb02e5a28b693f67a06687f689fc507b9a1#diff-f625acb6e05d00c8369ccb90cb8895ae475d9364ccbceeca643e65628dd1bc5e)**

> Импорт всего файла происходит командой `source`
>
> Вообще, команда source запускает скрипт в той же оболочке (не запускает новый процесс bash).
> Если там только функции объявлены и переменные, они как бы "импортируются".

`deploy2.prod.sh`
```bash
#!/bin/bash

source ./read-env.sh

deploy_dist_dir=$(read_env DEPLOY_CRA_DIST_DIR .env.production.local)

echo '-- DEPLOY STARTED' &&

EXTERNAL_DIR=""$(dirname "$PWD")""

rsync -av --delete ${EXTERNAL_DIR}/frontend.cra/build/ $deploy_dist_dir &&

echo '-- DEPLOY COMPLETED'
```

`read_env.sh`
```bash
# NOTE: Read env name $1 from file $2 (optional: .env by default)

read_env() {
  if [ -z "$1" ]; then
    echo "environment variable name is required"
    return 1
  fi

  local ENV_FILE='.env'
  if [ ! -z "$2" ]; then
    ENV_FILE="$2"
  fi

  local VAR=$(grep $1 "$ENV_FILE" | xargs)
  IFS="=" read -ra VAR <<< "$VAR"
  echo ${VAR[1]}
}
```

#bash | functions source import

<Alert header='Формулировка задачи' text='Написать на баше функцию, которая получает три аргумента: `srcDir`, `destDir` (абсолютные пути) и `ext`.<br />Скрипт в функции просматривает содержимое директории (и поддиректории) **srcDir** и копирует в точно такие же директории (и поддиректории) **destDir**, применимо только к файлам конкретного расширения **ext**.' />

## Google search: bash copy by extension preserving directory structure...
```bash
#!/bin/bash

# quaint_copy копирует файлы определённого расширения $3 из каталога $1 в
# каталог $2

quaint_copy(){
  srcDir=$1
  destDir=$2
  ext=$3
  
  rsync -r -f '+ *.'"$ext" -f '+ **/' -f '- *' --prune-empty-dirs $srcDir $destDir
}

quaint_copy $1 $2 $3
```

## Проблема

<Alert text='Подскажите по настройке **tsconfig.json**.
Как переместить `.yaml` файлы вместе с компилируемыми файлами `.ts` -> `.js`?
**TS**, естесственно, их игнорит.' />

*Файлы читаются в коде в момент срабатывания express middleware, но не учавствуют в транспайлинге тайпскриптом:*

```js
// Код до переписывания на ts:

const express = require('express')
const path = require('path')

const swagger = express()
const swaggerUi = require('swagger-ui-express')
const YAML = require('yamljs')

swagger.use(
  '/',
  function (req, _res, next) {
    req.swaggerDoc = YAML.load(path.join(__dirname, './swagger.yaml'))
    next()
  },
  swaggerUi.serve,
  swaggerUi.setup()
)

module.exports = swagger
```

> See also: https://www.cyberciti.biz/faq/copy-command/

#bashSamples | Quaint files copy

# Way 1

```bash
npm pkg get version --raw
```

```json
{
  "scripts": {
    "build:staging": "tsc && VITE_APP_VERSION=$(npm pkg get version --raw) VITE_GIT_SHA1=$(git show --format=\"%h\" --no-patch) vite build --mode staging --emptyOutDir"
  }
}
```

# Way 2

```bash
cat package.json | grep version | head -1 | awk -F: '{ print $2 }' | sed 's/[\",]//g'
```

```json
{
  "scripts": {
    "build:prod": "tsc && VITE_APP_VERSION=$(cat package.json | grep version | head -1 | awk -F: '{ print $2 }' | sed 's/[\",]//g') VITE_GIT_SHA1=$(git show --format=\"%h\" --no-patch) vite build --mode production --emptyOutDir"
  }
}
```

#npm #bash | Get package version

```bash
1089  ls
1090  ls -l
1091  nano test
1092  ls -l
1093  rm test 
1094  df -H
1095  htop
1096  du -sh /
1097  du -sh / 2> /dev/null
1098  apt install ncdu
1099  du -h / 2> /dev/null
1100  du -h --max-depth 3 / 2> /dev/null
1101  du -h --max-depth 1 / 2> /dev/null
1102  ls /root
1103  ls -l root
1104  ls -l /root
1105  ls -al /root
1106  du -h --max-depth 1 /root 2> /dev/null
1107  du -h --max-depth 1 /root/.pm2 2> /dev/null
1108  du -h --max-depth 1 /root/.pm2/logs 2> /dev/null
1109  pm2 flush
1110  apt update && apt full-upgrade
1111  apt install apt-transport-https
1112  apt update && apt full-upgrade
```

#bash #pravosleva blog history | Как определить размер папок, #логи #logs

`package.json`
```json
{
  "scripts": {
    "start": "bash inotify-tool.sh && node scripts/start.js",
  }
}
```

`inotify-tool.sh`
```bash
echo fs.inotify.max_user_watches=100000 | sudo tee -a /etc/sysctl.conf && sudo sysctl -p
```

https://github.com/pravosleva/react-material-admin-boilerplate-2020/blob/master/inotify-tool.sh

#bash | yarn start; inotify-tool

`.gitignore`
```bash
html/*
!html/.gitkeep
```

`clean-up.sh`
```bash
rm -rf ./html/* !./html/.gitkeep
rm -rf ./sources/.yarn/* !./html/.gitkeep
```

#bash | #smartprice #лендос cleanup

Загрузить какие-то файлы на веб-сервер из командной строки: ввод имени пользователя и пароля, изменение каталога может быть немного утомительной работой.

```bash
#!/bin/bash

ftp_site=myhostname
username=myusername
passwd=mypass

PS3='Select a destination directory: '

# bash select
select path in".""public_html/""public_html/myblog/""backup/images/"
do
ftp -in <<EOF
open $ftp_site
user $username$passwd
cd $path
put $1
close 
bye
EOF
echo$1 uploaded to $path ! 

# Break, otherwise endless loop
break
done
```

*Execute:*
```bash
$ chmod +x ftp_bash_script.sh
$ ./ftp_bash_script.sh file1
```

#bashSamples | Example of simple bash script ftp client

```bash
parallel_commands() {
  for cmd in "$@"; do {
    echo "Process \"$cmd\" started";
    $cmd & pid=$!
    PID_LIST+=" $pid";

    # NOTE: If necessary
    sleep 10
  } done

  trap "kill $PID_LIST" SIGINT

  echo "Parallel processes have started";

  wait $PID_LIST

  echo
  echo "All processes have completed";
}

parallel_commands "yarn dev" "yarn start"
```

#bashSamples | Parallel commands run

## How to delete all files in a directory except some?

```bash
rm -rf ./server-dist/*
# Что дописать чтоб не удалять файл ./server-dist/.gitkeep ?

rm -rf ./server-dist/* !./server-dist/.gitkeep
```

```bash
# Там можно так же восклицательным знаком исключать файлы:
find ./server-dist/ -mindepth 1 ! -name '.gitkeep' -exec rm -rf {} +
```

#bashSamples | Remove files in dir with exeption

**Q:** Во время запуска `npm`, возникает ошибка:

```
Error: ENOSPC: System limit for number of file watchers reached, watch
```

**A: В ядре определенное количество обработчиков inotify. Поэтому их число нужно увеличить:**
```bash
echo fs.inotify.max_user_watches=100000 | sudo tee -a /etc/sysctl.conf && sudo sysctl -p
```

#bash #nodeFAQ Error: ENOSPC: System limit for number of file watchers reached, watch

Bash script to generate SSL csr/key/crt 

<Gist gistId='6321633' />

#ssl #bash Bash script to generate SSL csr/key/crt 

## Read from `.env`

```bash
read_var() {
  if [ -z "$1" ]; then
    echo "environment variable name is required"
    return 1
  fi

  local ENV_FILE='.env'
  if [ ! -z "$2" ]; then
    ENV_FILE="$2"
  fi

  local VAR=$(grep $1 "$ENV_FILE" | xargs)
  IFS="=" read -ra VAR <<< "$VAR"
  echo ${VAR[1]}
}
```

**Example:**

```bash
local my_var=$(read_var MY_VAR)
local my_other_var=$(read_var MY_VAR staging.env)
```

## See also

- **[bash-samples](https://github.com/pravosleva/bash-samples)**
- [postbuild sample](https://github.com/pravosleva/open-chat-2019/blob/master/client/postbuild.sh)
- [How do I prompt for Yes/No/Cancel input in a Linux shell script?](https://stackoverflow.com/questions/226703/how-do-i-prompt-for-yes-no-cancel-input-in-a-linux-shell-script)
- **[How To Create Simple Menu with the Shell Select Loop?](https://www.shell-tips.com/bash/select-loop/)**

#bashSamples | Read value from .env file #environments

## Case 1: Base

```bash
sudo mv ./ssr/ /home/den/projects/ssr
```

## Case 2: From txt file

```bash
#!bin/bash

# Base example:
# sed -e "s/^/${PWD//\//\\/}\/folder-1\//" files-to-moving-from-1-to-2.txt | xargs mv -t ${PWD}/folder-2

EXTERNAL_DIR=""$(dirname "$PWD")""
TARGET_LIST_FILE_PATH="${EXTERNAL_DIR}/reporter/pre-archive-files.txt"
INPUT_FOLDER="${PWD}/public/uploads/"
TARGET_FOLDER="${EXTERNAL_DIR}/uploads-archive"

if [ ! -f ${TARGET_LIST_FILE_PATH} ]
then
  echo "FUCKUP! File does not exists: ${TARGET_LIST_FILE_PATH}"
  exit 1
fi

if [ ! -d $INPUT_FOLDER ]
then
  echo "FUCKUP! Dir does not exists: ${INPUT_FOLDER}"
  exit 1
fi

if [ ! -d $TARGET_FOLDER ]
then
  echo "Dir should be created: ${TARGET_FOLDER}"
  mkdir $TARGET_FOLDER
  if [ ! -d $TARGET_FOLDER ]
  then
    echo "FUCKUP! Dir could not be created: ${TARGET_FOLDER}"
    exit 1
  fi
fi

sed -e "s/^/${PWD//\//\\/}\/public\/uploads\//" $TARGET_LIST_FILE_PATH | xargs mv -t $TARGET_FOLDER
if [ $? -ne 0 ]
then
  echo "FAIL: Files was not moved!"
  exit 1
else
  echo "SUCCESS: Files moved successfully!"
  exit 0
fi
```

[set-files-to-pre-archive-list.js sample](https://github.com/pravosleva/get-money-reporter/blob/master/routes/remote-strapi/middleware/set-files-to-pre-archive-list.js)

#bashSamples | Move files

- [Bash-скрипты: начало](https://habr.com/ru/company/ruvds/blog/325522/)
- [https://github.com/pravosleva/bash-samples](https://github.com/pravosleva/bash-samples)

#bash

```
x = 536870912 / 1024 -> kB
x / 1024 -> MB
```

#bash | available #memory

*Скорировать все директории и файлы из папки в папку:*

```bash
for i in ../next-app-with-redux-saga-sample/*; do cp -r $i ./frontend; done;
```

**[https://www.cyberciti.biz/faq/copy-command/](https://www.cyberciti.biz/faq/copy-command/)**

bash