טיפ #7 - פקודות רצות אחרי סגירת ssh

לכל מי שלא הכיר, אם אתם בssh ולא רוצים שהפקודה שלכם תיסגר אם אתם פתאום מתנתקים (אינטרנט לדוג)

יש כמה דרכים להתמודד עם זה

1. תוכנות terminal multiplexerx
לדוג tmux או screen שעובדים בתצורת לקוח שרת, שאתה מדבר איתו דרך unix socket שנפתח בדרכ ב/run מאפשר לך בקליינט לפתוח כל מיני פקודות, תוכנות שבפועל רצות ב"שרת". בtmux הצירוף ctrl-b ואז d יאפשר לכם לעשות detach לסשן הנוכחי, ואז אפשר לחזור אליו עם tmux attach

2. סיגנל nohup עם &

אתם יכולים להתחיל פקודות עם nohup כדי לדרוס את סיגנל הhup, שזה סיגנל שנשלח לתהליכים כאשר הטרמינל שלהם (pty, tty) נסגר (כולל חיבור ssh)

ה& אומר לbash שמפרסר את האופרטור בתור "תריץ אסינכרוני, תריץ בshell אחר שהוא fork שלי"

3. שיטת job disown

נגיד והפקודה שלכם כבר רצה ואנחנו לא רוצים לעצור אותה, אפשר לדפוק ctrl z כדי להעביר אותה לתור הjobs, משם היא עוצרת, אז נמשיך את הריצה שלה עם bg, עכשיו היא רצה והטרמינל שלנו פתאום חופשי - מפה, נכתוב disown. זה bash builtin (לא תוכנה שנמצאת במקום כמו /usr/bin, אלא פקודה שממומשת בתוך המפרש של bash) שמאפשרת לבאש להסיר את הjobs ששייכים לו ומעכשיו הם יהיו תהליכים לגיטימיים. שימו לב שזה *לא* אותו הדבר כמו nohup, אתה לא משתיק סיגנל סגירת טרמינל ועושה fork לshell-ילד, הjob אחרי הdisown עדיין מכיל טבלת file descriptors של stdin stdout stderr שהם symlinkים לזרמים של... הטרמינל שעשה להם disown. אם התוכנה שלכם מתישהו תנסה לקרוא, לכתוב או אפילו להתלונן על שגיאות למסך - היא עלולה לקרוס. אפשר לטפל בזה מראש ע"י steam redirect לdev null, אבל זה קצת פוגע בפואנטה הרי לא יכלנו לחשוב על זה מראש באופציה 3. ראו הוזהרתם!


לסיום, חידה מגניבה - איך זה שכאשר אתם מרסטים את הsshd, חיבור הssh שלכם עדיין נשאר עובד? מוזמנים לחקור על זה, מבטיח שהתשובה מגניבה! :)

שפת הסקריפט awk

אחרי ראינו את העקרונות והמבנה הכללי של awk הנה עוד כמה דברים נחמדים שאפשר לעשות
נגטיב
$ cat test.awk
!(/Never logged in/) { print $1 }

$ lastlog | awk -f test.awk
Username
someone

רגע יש שם בפלט Username שאינו משתמש במערכת אלא רק כותרת של הפקודה, בא נוסיף חוק שיסיר גם אותו.
!(/Never logged in/ || /^Username/) { print $1 }

להשתמש בתוכן דינמי על ידי משתנים
בצורה זו אפשרי ליצור כלים הרבה יותר גמישים
$ cat test.awk
BEGIN {print var_a, var_b}

$ awk -f test.awk -v var_a=Username -v var_b=Login
Username Login

יש לא מעט משתני סביבה ל awk ראינו בפוסטים הקודמים את NR ואת FS
הנה עוד כמה מעניינים שכדאי להכיר

OFMT - The output format for numbers,
"%.6g", by default.
OFS - The output field separator,
a space by default.
ORS - The output record separator,
by default a newline.
NF - The number of fields in the current input record.

FIELDWIDTHS:
A whitespace-separated list of field widths.
ENVIRON:
An array of the environment variables.
FILENAME:
The name of the current input file.
p.s. filename is undefined inside the BEGIN rule (unless set by getline).

בשביל שיהיה ממש נחמד יש גם פונקציות מובנות
להלן חלקם
I/O
printf - Format and print.
system("cmd") - Execute the command cmd-line,
and return the exit status.

Numeric Functions
int(expr) | atan2(y, x) | sin(x) | cos(x) | sqrt(x) | exp(x) | log(x) | rand()

String Functions
length(s) | toupper(s) | tolower(s) | substr(s, i) | strtonum(s) |match(s, rgx) | index(s, t)

שאר ממתקים שיעבדו לכם כמו כל שפת תכנות C Like
תנאים: רגילים / ternary
לולאות: switch / for / while / do while

@bash_tips

להוריד עם חשבון wget

לעיתים אנו רוצים להוריד קבצים אבל אין לנו מושג בדיוק כמה, אז להוריד קבצים אנו יודעים איך

$ wget https://somehost/1.mp3

וכשאנו רוצים להוריד רצף קבצים אנו גם יודעים איך

$ wget https://somehost/{1..100}.mp3

הבעיה מתחילה כשאנו לא יודעים כמה קבצים אנו בדיוק רוצים להוריד, אנו בעצם מעוניינים שברגע שחוזרת שגיאה של 404 אז wget יפסיק את ההורדה.
בשביל שזה באמת יקרה ניתן להריץ את wget עם תנאי שברגע שהוא נכשל שיצא מהתוכנית

$ wget https://somehost/{1..100}.mp3 || exit

@bash_tips

לקרוא json עם jq ואתגרון בקצה

עולם האינטרנט מתקשר לא מעט דרך אובייקטי json בכדי שנוכן לעבוד בקלות גם בעולם הזה כדאי שיהיה לנו כלי שדובר את השפה, למזלנו יש כלי ממש חזק בסביבת ה shell שנותן לבצע מניפולציות ופרסור של json נעים להכיר jq.

כלי jq מנסה להיות מה שawk לטקסט רק בצורה טובה ואינטואיטיבית יותר, עוד לא החלטתי כמה זה הצליח להם אבל אחרי תרגול קל דברים נראים הגיוניים, יאללה לעבודה

הקובץ שלי מכיל מערך בודד עם 3 אובייקטים

$ cat my.json
[
    {"name":"John", "age":31, "city":"New York"},
    {"name":"Smith", "age":13, "city":"Bnei Brak"},
    {"name":"Joe", "age":21, "city":"Honolulu"}
]

אני מעוניין לשלוף את שמות האנשים עם jq זה יראה כך

$ cat my.json | jq ' .[].name '
"John"
"Smith"
"Joe"

הסבר
בדומה ל-awk גם jq מקבל את הפקודות שלו בתור מחרוזת (או בתור קובץ נפרד)
כדי לקבל את רשימת האובייקטים המחרוזת שלי ל-jq היא '.[]' שהמשמעות שלה זה תביא בבקשה את כל האובייקטים שקיימים למערך הנוכחי, באותה מידה אוכל להכניס טווח של אובייקטים (.[1:42]) או מספר ספציפי של אובייקט (.[42])
בשביל לקבל את התוכן שאני רוצה פשוט אוסיף את שם הkey הספציפי במקרה שלנו .name כעת jq יעבור באיטרציה על כל האובייקטים וישלוף את הערך של .name

בחירה של מספר keys
ניתן לבחור מספר keys על ידי שימוש בפסיק

$ cat my.json | jq '.[].name, .[].age'
"John"
"Smith"
"Joe"
31
13
21

בעיה, עכשיו אני לא יודע איזה גיל שייך לאיזה שם
אני רוצה שמתחת לכל שם יופיע גם הגיל

$ cat my.json | jq '.[] | .name, .age'   
"John"
31
"Smith"
13
"Joe"
21

בדומה ל-bash גם jq לקחו את הגישה של שרשור פלט מפקודה אחת לפקודה שניה עם | , בפעולה הראשונה בפקודה jq שולף את כל האובייקטים ומעביר אותם להמשך תהליך שם אנו בוחרים רק keys ספציפים מכל האובייקטים שהועברו

סינון
ניקח את זה שלב אחד קדימה, אני רוצה רק את האובייקטים של מי שמבוגר מ-20
בשביל כך יש את פונקציית select שמאפשרת לנו להגדיר תנאי על פיו יסונן התוכן
לדוגמה

$ cat my.json | jq '.[] | select(.age >= 20) '
{
  "name": "John",
  "age": 31,
  "city": "New York"
}
{
  "name": "Joe",
  "age": 21,
  "city": "Honolulu"
}

@bash_tips


אתגרון לסיום
איזה משפט ישלוף לי את כל רשימות ההשמעה מהלינק הבא?

https://eco99fm.maariv.co.il/api/v1/public/playlist/12033

תשובות לתגובות

tee
זהו כלי שנמצא ברוב ההפצות כחלק מהמערכת
הפקודה משמשת לכתיבה למספר קבצים בנוסף לפלט הרגיל.

איך משתמשים?
echo "hi" | tee file1 file2 file1000

וכמובן אפשר להשתמש בwildcard כדי לכתוב למספר קבצים עם אותו סייומת
echo 'print("hi")' | tee {file1,file2}.py

אמת או שקר

ניתן לבצע מספר רב של תנאים בבאש החל מקיומם של קבצים סוגים וכו', דבר שצריך לקחת בחשבון הוא שבאש מבצעת השוואות רק על מחרוזות ומספרים
בואו נראה דוגמה

$ bool=true
$ declare -p bool
declare -- bool="true"

כפי שאפשר לראות משתנה bool מסומן עם ערך — שזה מקביל לשום ערך מיוחד, מה שמאפיין מחרוזות מה שאומר שהתנאי הבא לא יוכל להתקיים כי ערך של מחרוזת הוא תמיד true
if [[ $bool ]];
then echo print true
fi
print true

$ bool=false
if [[ $bool ]];
then echo print true
fi
print true

בשביל להשוות בוליאן ההשוואה תצטרך להיות או מספרית או של מחרוזת.

עד כאן זה בערך מה שתקראו בכל מקום בקשר לבוליאנים בבאש.
יצא לי להיתקל בסוף השרשור הזה בטיפ הבא שמראה שאפשר לעבוד עם בוליאנים בצורה פשוטה כמו בשאר השפות, זה נראה כך

$ bool=true
$ if ${bool};
> then echo some text here
> fi
some text here
וכמובן תנאי שלילי שלא יציג כלום
$ bool=false
$ if ${bool};
> then echo some text here
>fi

@bash_tips

לצמצם עם truncate
רמת קושי: #beginners

פקודת truncate מאפשרת לנו להגדיר משקל מוגדר לכל קובץ, אם לגומה יש לי לוג ששוקל 10MB ואני רוצה לשמור רק את 2 MB החדשים ביותר של הלוג

$ du -h myapp.log
10M myapp.log
$ truncate --size=2M myapp.log
$ du -h myapp.log
2.0M myapp.log

בעצם מה שקרה הוא שכל החלק הישן יותר של הקובץ נזרק לפח ונשארתי רק עם הרשומות החדשות ביותר.
עד כאן הכל נחמד, מה אם אני רוצה לחתוך שיר למשקל מוגדר מראש?

$ cat long_song.mp3 > shrink.mp3
$ du -h shrink.mp3
15M shrink.mp3

$ truncate --size=2M shrink.mp3
$ du -h shrink.mp3
2.0M shrink.mp3


#truncate
#cat
#du

@bash_tips

רצפים ופורמטים עם seq
רמת קושי: #beginners

כפי שאנו מכירים באש מאפשרת ליצור רצפים של מספרים על ידי שימוש ב Brace expansion (הביטוי שמתאר את הפעולה הבאה {10..1} ) וזה עובד יפה מאוד כשמשתמשים בזה עם מספרים
cat myscript.sh
for i in {1..10}; do
echo $i
done

$ bash myscript.sh
1
2
3
...

הבעיות מתחילות כשרוצים שהקוד יהיה קצת יותר דינמי ומחליטים במקום להכניס מספרים בצורה ישירה להכניס משתנים שיכילו את ההתחלה והסוף, אם כן הכירו את המשתנים שלנו start וend

$ cat myscript.sh
start=1
end=10
for i in {$start..$end}; do
echo $i
done

$ bash myscript.sh
{1..10}

הופההה בעיה, במקום שבאש תפרש את הערכים ששמנו בסוגריים המסולסלות כביטוי שיש לחולל, באש מתייחסת לביטוי כמחרוזת ולכן משתנה i פשוט מדפיס את המחרוזת.


נעים להכיר seq
פקודה חביבה נוספת שמאפשרת ליצור רצפים היא seq, השימוש בה קל וכל שצריך הוא פשוט להעביר ערכים של התחלה וסוף ומקבלים רצף

$ cat myscript.sh
start=1
end=10
for i in $(seq $start $end); do
echo $i
done

$ bash myscript.sh
1
2
3
...

נשמע אחלה מעולה, אפשר מזה עוד?
יאפ, הפקודה מאפשרת ליצור רצפים בדילוג

$ seq 0 2 20
0
2
4
6

ודבר נחמד עוד יותר שהיא מאפשרת זה למלא אפסים לפני מספרים קטנים, וכך חסכנו את הצורך להשתמש ב printf כדי לפרמט רצף כרונולוגי

$ seq -w 100
001
002
003
...
010
011
012
...
099
100


#seq
#brace_expansion

@bash_tips

מעקב אחר שינויים במספר קבצים בזמן אמת עם tail
רמת קושי: #beginners

קבצי לוג מכילים מספר נאה מאוד של רשומות ובדרך כלל הרשומות הרלוונטיות הן בסוף הקובץ, בשביל להקל על החיים נולדה פקודת tail שמאפשרת לצפות ב 10 שורות האחרונות של הקובץ

$ tail blender_collector.sh
blend_dest=$(readlink -m "$dest/${file_name%.*}/")
mkdir -p "$blend_dest"
mv "$BLEND_FILES" "$blend_dest"
Organize_files
done
echo "Finished, files exist in: $dest"

ניתן כמובן לשנות את כמות השורות שהפקודה תדפיס על ידי השמת ערך מספרי לדגל n-

דבר נחמד שהכלי מאפשר הוא צפייה זמן אמת של שינויים בקובץ על ידי שימוש בדגל f- בדומה לפקודת journalctl שראינו בעבר

צפייה בקבצים מרובים
פקודת tail מאפשרת מעקב בזמן אמת אחרי שינויים במספר קבצים בו זמנית, אפשרי להעביר מספר שמות קבצים לפקודה או להשתמש ב wildcard

$ tail -f *
==> blender_collector.sh <==
blend_dest=$(readlink -m "$dest/${file_name%.*}/")
mkdir -p "$blend_dest"
blender -b "$BLEND_FILES" --python-expr "import bpy; bpy.ops.file.pack_all()" > /dev/null 2>&1
mv "$BLEND_FILES" "$blend_dest"
Organize_files
done
echo "Finished, files exist in: $dest"
exit 0



==> README.md <==
├── House(Texturing).blend
└── textures
├── 1725 Sun Clouds.jpg
├── studio024.hdr
├── style_cottage_Flanagan_IMG1.jpg
├── wood06.jpg
├── WoodFine0024_M.jpg
└── WoodFine0042_5_L.jpg


#tail
#journalctl

@bash_tips

לקבל קלט מהמשתמש עם read
רמת קושי: #beginners

פקודת read היא פקודה המאפשרת בזמן שהסקריפט רץ לקבל קלט מהמשתמש, מה שבעצם הופך את הסקריפט לאינטרקטיבי

$ cat test.sh
echo "Insert text here"
read myvar
echo "#### $myvar ####"

$ bash test.sh
Insert text here
GOD
#### GOD ####

אפשרי לכתוב את אותו הקוד בצורה קצרה יותר על ידי שימוש בדגל -p של פקודת read
$ cat test.sh
read -p "Insert text here " myvar
echo "#### $myvar ####"

$ bash test.sh
Insert text here GOD
#### GOD ####

עוד מהדברים הנחמדים שהפקודה מאפשרת היא להמתין זמן מוגדר לקלט מהמשתמש, ברגע שעובר הזמן הפקודה תמשיך הלאה והמשתנה ישאר ריק
הקוד הבא ימתין 30 שניות לקלט ובמידה והוא לא יקבל הוא ימשיך הלאה

$ cat test.sh
read -t 30 -p "press any key to continue (or wait)" myvar
echo "#### $myvar ####"


#read

@bash_tips

קריאת שורות מקובץ while read

שילוב של read ביחד עם לולאת while יספק לנו דרך גמישה לקריאת קבצים שורה אחר שורה

$ test.sh
cat script.py | while read -r line;
do 
    echo "[*] $line"
done

$ bash test.sh
[*] #!/usr/bin/python3
[*] # -*- coding: utf-8 -*-
[*] 
[*] import os
...

אנו משרשרים קובץ אל הלולאה ומכאן read לוקח פיקוד, כהתחלה הוא מקבל את הקלט בצורה גולמית על ידי שימוש בדגל r- ולאחר מכן הוא מפצל את הקלט על פי התו n\ מה שאומר שכל שורה היא יחידה אחת.

במידה ונחליט שאנו רוצים שכל שורה חדשה תפוצל על ידי כל תו אחר נוכל להגדיר IFS תוך כדי הלולאה, השינוי של הIFS ישאר רק בגבול הלולאה ולא לכלל הסקריפט

$ test.sh
cat script.py | while IFS=$'\t' read -r line;
do 
    echo "[*] $line"
done

@bash_tips

פריסת ערכים למספר משתנים while read

בכדי לעשות אנפאקינג למספר משתנים עם באש ניתן להשתמש עם while read
הקוד שלי
my_text="Lorem Ipsum is
simply dummy text
of the printing
and typesetting industry."

echo "$my_text" | while read -r one two three;
do
echo "[*] $one $two $three"
done

לולאת read מאפשרת להעביר מספר משתנים בכל איטרציה
הטקסט שלי הוא 4 שורות שבכל שורה יש 3 מילים.
לולאת הread כפי שראינו בטיפ הקודם שולפת שורה שורה מה שאומר שכל שורה מכילה 3 מילים, ברגע שמעבירים מספר משתנים שונה התוכן מחולק לכל משתנה היכן שיש רווח

$ bash test.sh
[*] Lorem Ipsum is
[*] simply dummy text
[*] of the printing
[*] and typesetting industry.

במידה והתוכן ארוך יותר ומספר המשתנים שהשתמשתי בלולאת הwhile read קטן יותר, אזי המשתנה הראשון יקבל מילה וכן השני והמשתנה השלישי יקבל את שאר השורה

$ cat test.sh
my_text="Lorem Ipsum is simply dummy text
of the printing and typesetting industry."

echo "$my_text" | while read -r one two three;
do
echo "[*] $one $two [last variable] $three"
done

$ bash test.sh
[*] Lorem Ipsum [last variable] is simply dummy text
[*] of the [last variable] printing and typesetting industry.

@bash_tips

כמה דברים שיתכן ולא ידעתם על tree
רמת קושי: #beginners

פקודה שימושית ונחמדה שלא מותקנת ברירת מחדל היא tree, מדובר על פקודה שמציגה עץ של תיקיות מהמיקום בו היא הורצה.

~/snap $ tree
.
├── audacity
│ └── current -> 532
├── blender
│ ├── 38
│ ├── common
│ └── current -> 38
├── code
│ ├── 33
│ ├── common
│ └── current -> 33
...

הבעיה מתחילה כשיש תיקיות שעמוסים בתוכן והן פשוט תופסות לנו את כל השטח של המסך, לדוגמה במידה ואריץ את הפקודה על פרויקט nodeJS, תיקיית node_modules תמלא את כל המסך בתוכן לא רלוונטי וכל היתרון הויזואלי של הכלי הולך לאיבוד.

להחריג תיקיות
בשביל להתמודד עם הבעיה הזאת יש לנו את הדגל -I שמאשר לנו להחריג תיקיות שעליהן הפקודה לא תעבוד, זה נראה כך

$ tree -I 'node_modules|npm|test_*'

יש לפקודה עוד כמה אפשרויות חביבות להלן בקצרה

להגדיר עומק
ישנה אפשרות להגדיר כמה עומק רוצים להציג בעץ התיקיות על ידי שימוש בדגל 3 L- שאומר בעצם תציג לי עד עומק של 3 תיקיות.

להציג רק תיקיות

$ tree -d
.
├── charts-external
│ ├── yoyo
│ │ ├── docker
│ │ │ └── postgres-postgis
│ │ └── templates
│ ├── cluster-admin.
├── charts-external
│ ├── yoyo
...

להציג תוכן על ידי תבנית

$ tree -P '*.sh'
...
├── force_update.sh
├── functions.sh
├── helm_healthcheck.sh
├── helm_lint_all.sh
...
הצגת הרשאות בדומה לls

$ tree -p
...
├── [-rwxrwxr-x] force_update.sh
├── [-rw-rw-r--] functions.sh
├── [-rwxrwxr-x] helm_healthcheck.sh
├── [-rwxrwxr-x] helm_lint_all.sh
...

ואפילו לקבל משקל של כל קובץ

$ tree —du
...
├── [ 532] helm_healthcheck.sh
├── [ 971] helm_lint_all.sh
├── [ 1730] helm_lint_external_chart.sh
├── [ 1673] helm_update_values.sh
├── [ 300] helm_upgrade_all.sh
...

אה רגע רצינו את זה בשפה קריאה לבני אנוש

$ tree —du -h
...
├── [ 532] helm_healthcheck.sh
├── [ 971] helm_lint_all.sh
├── [1.7K] helm_lint_external_chart.sh
├── [1.6K] helm_update_values.sh
├── [ 300] helm_upgrade_all.sh
...


#tree

@bash_tips

לטעון עם source
רמת קושי: #beginners

פקודה שנתקלים בה לא מעט בלינוקס היא source, בדרך כלל כשעורכים את קובץ .bashrc, מהי הפקודה הזאת ולמה היא חשובה לנו

אנו פותחים טרמינל ויוצרים משתנה חביב

$ my_var=123

כעת אם נקרא למשתנה הזה נקבל את הערך שלו

$ echo $my_var
123

אם כך יש לנו משתנה שמוגדר במערכת, במידה ואני יפתח חלונית טרמינל חדשה ואני יקרא למשתנה הזה המערכת לא תכיר בו, הסיבה לכך היא שכל משתנה מוכר רק לאותו סשן בו הוא הורץ.
הדבר הזה נכון הן למשתנים והן לפונקציות.

אז אנו רוצים לעבוד על הטרמינל וליצור סביבה עם משתנים פונקציות וכל דבר אחר, מה כל פעם נצטרך להקליד או להעתיק ולהדביק את תוכן הפונקציות לטרמינל?

זהו בעצם השלב בו נכנסת פקודת source, הפקודה מאפשרת לקחת קובץ כלשהו שמכיל ערכים ופונקציות ולטעון את כל התוכן שלו לסשן של הטרמינל שמריץ אותו (דוגמאות בתמונה).

אז מה בעצם קורה עם קובץ bashrc?
קובץ bashrc נטען בעת יצירת הסשן, ברגע שאנו עושים בו שינויים תוך כדי הסשן bash לא מתחשב בשינויים הללו עד שנכריח את bash לטעון את הקובץ שוב.

$ nano ~/.bashrc && source ~/.bashrc

#source
#bashrc

@bash_tips

📢 ערוץ Bash Tips

✨✨ אתם אוהבים שליטה, לגרום לכלי העבודה שלכם לעבוד בשבילכם ולבצע מניפולציות וקסמים שרק לכם נראים הגיוניים וברורים מאליהם... ✨✨

אהמ טוב נסחפתי מעט

בערוץ Bash Tips תמצאו אוסף טיפים ב-Bash
הכרות עם כלים שונים שעשויים לחסוך לכם המון זמן ומאמץ.

להוריד קבצים מהרשת? שורת קוד ואתם שם.
להמיר ולפצל קבצים באיזה חלוקה וגודל שתרצו? קבלתם

טיפים אלו ועוד רבים אחרים ממתינים לכם בערוץ
מוזמנים להירשם ולעשות קסמים

לינק לערוץ https://t.me/bash_tips

⠀

לפצל וידאו עם MP4Box
רמת קושי: #beginners

אנו משתמשים בשירותי רשת שונים להעלות ולסנכרן תוכן, לא מעט פעמים אנו מוגבלים על ידי השירות למשקל או אורך מסויים של קבצים, נעים להכיר MP4Box

בשביל להשתמש ב MP4Box נצטרך להתקין את החבילה gpac שמספקת עוד כלים שונים לעבודה עם קבצי וידאו, יש המון אפשרויות לפקודה כך ששווה להציץ על man MP4Box

מתחילים
פקודת MP4Box מספקת לנו מספר אופציות לפיצול הקובץ, אפשר לראות את כל אפשרויות הפיצול שזמינות על ידי הרצה של
$ MP4Box -h general

חלוקה לפי משקל
הקובץ שברשותי שוקל כ 3GB אני רוצה לפצל אותו ל2 חלקים של 1.5GB

$ MP4Box -split-size 1500000 myfile.mp4

אז מה זה המספר הארוך הזה בפקודה?
אנו משתמשים בדגל -split-size (אפשרי גם לכתוב רק splits-) הפרמטר שהוא מקבל הוא משקל הקובץ שנרצה שיהיה לכל חלק, העניין הוא שהפקודה מצפה לקבל את הערך ב-KB לא הדבר הכי נח להסתכל עליו ומאוד קל לטעות.
אבל היי הכל עניין של הסתכלות תחשבו ב MB ופשוט תוסיפו 3 אפסים בסוף
1500 + 000 = 1500000

חלוקה לפי שניות
אפשרות נוספת לחלוקה היא על ידי הגדת זמן, לדוגמה הסרטון שלנו הוא במשך 10 דקות ואנו מעוניינים לחלק אותו כך שכל סרטון יהיה במשך דקה

$ MP4Box -split 60 myfile.mp4

גם כאן כמו מקודם הכל עובד לנו בצורה נחמדה כשאנו צריכים את הסרטון שניות או דקות בודדות, ברגע שנצטרך משהו קצת יותר גדול לדוגמה שכל חלק יהיה באורך של 21 דקות זה יהיה פחות נח לשימוש.

$ MP4Box -split $(( 60*21 )) myfile.mp4

הנה ככה הרבה יותר יותר טוב.
במקום לחשב כמה הם 21 דקות, פשוט ניתן למחשב לעשות את החשבון. בשביל לבצע פעולה חשבונית בבאש נכניס את הפעולה האריתמטית לסוגריים ( 60*21 ), וכדי להוציא לפועל את הפעולה החשבונית אנו עוטפים אותה עם ()$

#mp4_box
#gpac

@bash_tips

לפצל ולאחד קבצים עם split ו cat
רמת קושי: #beginners

מכירים את זה שקבלתם לידכם התקן USB כדי להעביר אליו איזשהו קובץ גדול?
ואז בדיוק ברגע השיא כשפעולת העתקה כמעט מסתיימת אתם מגלים שמערכת הקבצים של הכונן היא FAT, ולכן העתקה נכשלת כי לא ניתן להעתיק קבצים מעל 4GB. לא כיף

פקודת split מאפשרת לפצל קבצים לאיזה גודל שתרצו, בעיקרון היא עובדת נפלא על קבצי טקסט, אבל היות והיא לא משנה את תוכן הקובץ היא עדין נהדרת כדי לפתור בעיות גם בסוגי קבצים אחרים, הם אומנם לא יהיו קריאים באותה העת אבל אחרי האיחוד הם יחזרו לכשהיו.

$ split -b 2G my_file.mp4 my_file_part-

מה בעצם יש לנו כאן?
דגל b- מאפשר לפצל לפי גודל (K/M/G), שם הקובץ עליו אני רוצה לפעול, ומהו השם התחלתי של הקבצים שיפוצלו.
זה נראה כך.

$ ls
my_file.mp4
my_file_part-aa
my_file_part-ab

הפקודה ממספרת חלקים לפי אותיות, ברירת מחדל היא שני אותיות, דבר זה נתון לשינוי על ידי שימוש בדגל a- ומספר שמייצג כמה אותיות יתווספו.

$ split -b 2G my_file.mp4 my_file_part -a 1
$ ls
my_file.mp4
my_file_part-a
my_file_part-b

אפשרויות נוספות הן
חלוקה לפי מספר החלקים ולא לפי גודל הקובץ בעזרת דגל n-.
שימוש במספרים במקום באותיות בעזרת הדגל --numeric-suffixes.
פיצול קבצי טקסט לפי מספר השורות לקובץ (l-).


אוקי צלחנו את החלק של פיצול הקבצים אבל איך מאחדים אותם חזרה?

כפי שראינו בפוסטים הקודמים פקודת cat יודעת לאחד קבצים על ידי שירשור, אפשרי להשתמש ב wildcard כדי לאסוף את כל הקבצים הרלוונטים ולאחד את כולם.

$ cat my_file_part-* > my_new_file.mp4
$ ls
my_file.mp4
my_file_part-a
my_file_part-b
my_new_file.mp4

לא מאמינים שזה אותו הקובץ בדיוק בלי שום שינויים?
נוכל לאמת את זה עם גיבוב של md5 לשני הקבצים

$ md5sum my_file.mp4
f86e0306d4c2a4fd3f18edd1a199a840 my_file.mp4

$ md5sum my_new_file.mp4
f86e0306d4c2a4fd3f18edd1a199a840 my_new_file.mp4


כמה הערות בקשר לפקודת split
הפקודה לא מעבדת את הפלט ולכן קבצים המכילים בכותרות הקובץ מידע על סוג הקובץ וערכים נוספים, מידע זה לא יועתק לקבצי הפיצול.

מהסיבה הזאת ניסיון לנגן קבצי מוסיקה ווידאו שפוצלו לא יצלח פרט לחלק הראשון שמכיל את המידע הדרוש לפיענוח, וגם אותו חלק יציג את האורך המלא של הקובץ כמו המקור אבל יעבוד תכלס רק עד החלק שפיצלנו.

#split
#cat

@bash_tips

צ'יט שיטס
רמת קושי: #beginners

מושג המתאר תוכן מקוצר המיועד לתזכר או להכיר יכולות וקיצורי דרך של כלים בעולם התוכנה.

כלי מעולה בשם cheat.sh מאפשר לחפש תזכורות וטיפים לאיזה שפת תכנות שתבחרו, יש רשימה יפה מאוד של שפות, dbs, ופקודות שנתמכות והכי נחמד שלא חייבים להתקין כלום.

השירות מאפשר לתשאל את השרת בקשר לפקודות ישירות מהקונסול על ידי בקשת curl פשוטה

$ curl cht.sh/grep

או לתשאל ספציפית לשפת תכנות, על ידי הגדרת השפה ואיזה תוכן מחפשים.

$ curl cht.sh/python/grep

אבל זה לא נגמר פה
ישנן פקודות שיספקו לכם מידע הרבה יותר מקיף על נושא מסויים ואפילו להריץ שאילתות

$ curl cht.sh/:list
$ curl cht.sh/python+print+vertical

השירות מאפשר להתקין כלי על המערכת כך שהוא יהיה מקומי ומאפשר בנוסף להתקין השלמה אוטומטית, יותר פרטים בעזרה של הפקודה.

למי שלא נוהג להריץ סקריפטים מהרשת על המחשב בלי לבדוק אותם, ולמי שאין כח לעבור על הקוד של הכלי מוזמן ליצור קיצור מקומי.

$ echo 'cht() { curl cht.sh/$1; }' >> ~/.bashrc && source ~/.bashrc

כעת נוכל להשתמש בשירות כפקודה

$ cht ssh
$ cht wget/file

#bashrc
#tools

@bash_tips

להכיר נקודה
רמת קושי: #beginners

דברנו בעבר על כך שפקודת source מאפשרת לטעון מידע שנמצא בקובץ כגון משתני סביבה, משתנים, ופונקציות לסביבת העבודה שלנו.

קיצור דרך נחמד שבאש מאפשרת לנו הוא הרצה של source על ידי נקודה, רווח ושם הקובץ.

$ . myenv


#source

@bash_tips