Laborator 05 - Îmbunătățirea lucrului în linia de comandă

Îmbunătățirea lucrului în linia de comandă

Înainte să începeți laboratorul, dați comanda cd ~/uso-lab && git pull.

Principalul atu al utilizării aplicațiilor în linie de comandă, și nu în mediul grafic, este viteza cu care rezolvăm anumite sarcini. Această viteză este dată de posibilitatea de a combina utilitare în linia de comandă pentru a automatiza procese manuale, repetitive. Întotdeauna ne dorim să fim mai rapizi și să automatizăm cât mai mult din sarcinile noastre, deoarece cu cât ne terminăm treaba mai repede, cu atât avem mai mult timp liber la dispoziție.

De regulă, cu cât petrecem mai mult timp cu mâna pe tastatură și mai puțin pe mouse, cu atât suntem mai rapizi. Aliniate la această idee, aplicațiile ne pun la dispoziție scurtături pe care suntem încurajați să le folosim pentru a ne utiliza timpul mai eficient.

Scurtături în terminal

Tab completion

Funcția de tab completion este probabil una dintre cele mai utile funcții expuse de către terminal. Prin simpla apăsare a tastei Tab în timp ce scriem numele unei comenzi, al unei opțiuni a unei comenzi sau calea către un director sau fișier, terminalul va completa în mod automat textul. În cazul în care există mai multe opțiuni pentru auto-complete, prin dubla apăsare a tastei Tab ne va sugera opțiunile de auto-complete.

În imaginea de mai jos putem observa că pentru comanda cd D funcția de Tab completion a găsit mai multe opțiuni valide pentru auto-complete. În astfel de scenarii, cu mai multe opțiuni valide, apăsarea tastei Tab o singură dată nu produce niciun rezultat; trebuie să apăsăm tasta Tab de două ori consecutiv pentru a genera afișarea opțiunilor de auto-complete.

student@uso:~$ cd D
Desktop/   Documents/ Downloads/
student@uso:~$ cd D

Funcția de auto-complete este extrem de utilă și îmbunătățește semnificativ viteza cu care realizăm acțiuni în terminal.

Funcția este extrem de utilă atunci când lucrăm cu nume de fișiere, directoare și căi din sistem. În loc să scriem manual o cale către un nume foarte lung, lăsăm tasta Tab să facă asta pentru noi.

Atunci când avem o eroare în comandă (am scris greșit o anumită parte din numele comenzii sau al fișierului, fișierul nu există, etc.), tasta Tab nu produce nici un rezultat. Acesta este un alt motiv pentru care să folosim tasta Tab.

Folosiți funcția de Tab completion cât mai des cu putință1).

Shellul implementează funcția de a reține istoricul comenzilor pe care le-am executat. Pentru a vedea istoricul curent putem rula comanda history. Vom obține un rezultat asemănător cu cel de mai jos:

student@uso:~$ history
[...]
21  ls
22  cd sorting/
23  ls -l
24  ls
25  cd
26  ls ~/Desktop ~/Documents ~/Downloads
27  ls ~/Desktop
28  ls Desktop/todos.txt
29  cp Desktop/todos.txt cp
30  ls
31  rm cp
[...]

Ciclăm prin comenzile date anterior folosind combinația de taste Arrow Up sau Ctrl+p, respectiv Arrow Down sau Ctrl+n.

Exercițiu: Ciclați prin istoricul de comenzi folosind combinația de taste Ctrl+p, respectiv Ctrl+n.

Căutarea în istoricul comenzilor

Terminalul ne pune la dispoziție un mod mai inteligent de a căuta în istoricul comenzilor prin combinația de taste Ctrl+r, ordinea căutării fiind de la cea mai recentă comandă la cea mai veche. Funcția este cunoscută sub numele de history search.

Pentru a porni căutarea, apăsați combinația de taste Ctrl+r și începeți să scrieți o parte din textul comenzii pe care o căutați, de exemplu cd.

(reverse-i-search)`cd': cd workspace/hello

De aici, avem următoarele opțiuni:

  • Căutăm în continuare o comandă care conține șirul cd, folosind combinația de taste Ctrl+r
  • Rulăm comanda pe care am găsit-o, folosind combinația de taste Ctrl+o
  • Anulăm căutarea comenzii și revenim la starea inițială, folosind combinația de taste Ctrl+g

Căutarea este incrementală. Adică se rafinează pe măsură ce tastăm un caracter. Orice caracter apăsat rafinează căutarea.

Textul căutat se poate afla oriunde în interiorul comenzii; nu trebuie să fie primele litere din comandă. Pentru exemplul de mai sus, căutarea folosind textul work ar fi produs același rezultat

(reverse-i-search)`work': cd workspace/hello

Ne găsim des în situația în care căutăm o comandă în istoric folosind funcția de history search, modificăm un argument al comenzii și apoi o executăm. Pentru navigarea în cadrul textului comenzii putem folosi Arrow Keys, iar pentru ștergeri putem folosi tasta Backspace sau Del.

Terminalul ne pune la dispoziție și o serie de scurtături cu ajutorul cărora putem face realiza aceeași acțiune mai rapid. Dacă vreți să vă impresionați prietenii, acesta este un mod simplu, dar eficient, de a o face.

Pentru a naviga în istoricul de comenzi putem folosi combinațiile de taste:

  • Ctrl+p - accesăm ultima comandă dată; prin apăsări succesive ciclăm prin istoricul de comenzi, de la ultima la prima comandă dată
  • Ctrl+n - accesăm comenzile în sens invers față de Ctrl+p, de la comanda actuală până la ultima comandă dată

Pentru a naviga în corpul textului putem folosi combinațiile de taste:

  • Ctrl+a - mută cursorul la începutul liniei
  • Ctrl+e - mută cursorul la sfârșitul liniei
  • Ctrl+f - mută cursorul cu un caracter înainte
  • Ctrl+b - mută cursorul cu un caracter înapoi
  • Alt+f - mută cursorul cu un cuvânt înainte
  • Alt+b - mută cursorul cu un cuvânt înapoi

Pentru a efectua ștergeri în corpul textului putem folosi combinațiile de taste:

  • Ctrl+k - șterge tot textul de la cursor până la sfârșitul liniei
  • Ctrl+u - șterge tot textul de la cursor până la începutul liniei
  • Alt+d - șterge tot textul de la cursor până la sfârșitul cuvântului

Textul șters este salvat într-un registru și poate fi folosit folosind combinația de taste Ctrl+y. Funcționalitatea este similară cu procesul de Cut (Ctrl+k, Ctrl+u sau Alt+d) și Paste (Ctrl+y).

Inspectarea sistemului de fișiere

Cea mai importantă comandă

Așa cum spuneam mai devreme, marele avantaj al utilizării terminalului este că ne ajută să rezolvăm sarcini foarte rapid. Rezolvăm sarcini folosind utilitarele pe care le avem disponibile în linia de comandă, fie că acestea fac parte din sistemul nostru sau le-am instalat.

Cel mai important utilitar pe care îl avem la dispoziție este man. Utilitarul man ne deschide pagina de manual în care este documentat un alt utilitar pe care dorim să-l folosim.

student@uso:~$ man
What manual page do you want?

Putem consulta însăși pagina de manual a utilitarului man

student@uso:~$ man man

Vom fi întâmpinați de următorul program interactiv:

MAN(1)                        Manual pager utils                        MAN(1)
 
NAME
       man - an interface to the on-line reference manuals
 
SYNOPSIS
       man  [-C  file]  [-d]  [-D]  [--warnings[=warnings]]  [-R encoding] [-L
       locale] [-m system[,...]] [-M path] [-S list]  [-e  extension]  [-i|-I]
       [--regex|--wildcard]   [--names-only]  [-a]  [-u]  [--no-subpages]  [-P
       pager] [-r prompt] [-7] [-E encoding] [--no-hyphenation] [--no-justifi‐
       cation]  [-p  string]  [-t]  [-T[device]]  [-H[browser]] [-X[dpi]] [-Z]
       [[section] page[.section] ...] ...
       man -k [apropos options] regexp ...
       man -K [-w|-W] [-S list] [-i|-I] [--regex] [section] term ...
       man -f [whatis options] page ...
       man -l [-C file] [-d] [-D] [--warnings[=warnings]]  [-R  encoding]  [-L
       locale]  [-P  pager]  [-r  prompt]  [-7] [-E encoding] [-p string] [-t]
       [-T[device]] [-H[browser]] [-X[dpi]] [-Z] file ...
       man -w|-W [-C file] [-d] [-D] page ...
       man -c [-C file] [-d] [-D] page ...
       man [-?V]
 
 Manual page man(1) line 1 (press h for help or q to quit)

Observăm că ultima linie din terminal, Manual page man(1) line 1 (press h for help or q to quit), ne oferă mai multe informații:

  • Ne aflăm pe prima linie din prima pagină a manualului
  • Putem apăsa tasta h pentru a acesa meniul de ajutor
  • Putem apăsa tasta q pentru a ieși din manual

Navigăm cu câte o linie de terminal în joș și în sus folosind folosind tastele Ctrl+n și Ctrl+p. Putem folosi tastele Ctrl+f și Ctrl+b pentru a naviga, cu câte un ecran de terminal, în jos și în sus în pagină. Mai simplu, putem folosi tasta Enter pentru a naviga cu câte o linie în jos și tasta Space pentru a naviga cu câte un ecran în jos. Navigăm la începutul paginii folosind tasta g. Navigăm la sfârșit paginii folosind tasta G.

Putem folosi tastele j și k ca alternative pentru Arrow Down și Arrow Up. Astfel suntem mai rapizi pentru că nu ne mai mutăm mâna de pe tastele caractere.

Folosim man ca să vedem dacă un utilitar oferă o anumită funcționaltiate. Citim întreaga pagină de manual ca să vedem toate funcționalitățile sau căutăm o funcționalitate folosind cuvinte cheie. Pașii pentru căutarea unui cuvânt cheie sunt următorii:

  1. Pentru a porni funcția de căutare apăsăm tasta / în sesiunea interactivă din man.
  2. În continuare vom introduce textul pe care dorim să-l căutăm: poate să fie un cuvântul cheie pe care îl știm deja sau orice text care sperăm că ne duce la rezultatul dorit.
  3. Acum apăsăm tasta Enter. Vom fi duși la primul rezultat care se potrivește căutării, dacă acesta există.
  4. Dacă vrem să navigăm la următorul rezultat apăsăm tasta n. Dacă vrem să navigăm la un rezultat anterior apăsăm tasta N.

Căutarea2) are loc de la poziția curentă în pagină către sfârșitul paginii. Dacă am navigat deja în interiorul paginii, trebuie să avem în vedere că rezultatul de interes al căutării noastre se poate alfa undeva între începutul paginii și poziția noastră curentă3).

Interpretarea paginii de manual

La o primă vedere, textul paginii de manual poate fi intimidant; unele utilitare au mai multe opțiuni și argumente, unele opționale, altele nu. O să trecem prin sintaxă și o să vedem că lucrurile sunt mult mai simple decât par. Să analizăm pagina de manual a utilitarului ls; man ls:

LS(1)                            User Commands                           LS(1)
 
NAME
       ls - list directory contents
 
SYNOPSIS
       ls [OPTION]... [FILE]...
 
DESCRIPTION
       List  information  about  the FILEs (the current directory by default).
       Sort entries alphabetically if none of -cftuvSUX nor --sort  is  speci‐
       fied.
 
       Mandatory  arguments  to  long  options are mandatory for short options
       too.
 
       -a, --all
              do not ignore entries starting with .
 
       -A, --almost-all
              do not list implied . and ..
 
       --author
 Manual page ls(1) line 1 (press h for help or q to quit)
  • Prima secțiune care ne interesează este “DESCRIPTION”. Citim descrierea și ne dăm seama dacă utilitarul ne va ajuta în rezolvarea sarcinii pe care o avem. În cazul utilitarului ls, descrierea ne informează că acesta afișează informații despre fișierele din calea indicată, sau din directorul curent atunci când nu specificăm o cale.
  • Cea de-a doua secțiune care ne interesează este “SYNOPSIS”. Aceasta ne spune cum putem să rulăm utilitarul, ce opțiuni și argumente sunt opționale (pot lipsi) și ce opțiuni și argumente sunt obligatorii.
  <code bash>
  SYNOPSIS
         ls [OPTION]... [FILE]...
  </code>

Sintaxa [ ] ne spune că acea categorie este opțională. Astfel, pentru ls, deducem că atât opțiunile ([OPTION]...) cât și argumentele ([FILE]..., calea către fișiere sau directoare) sunt opționale. Cele trei puncte ... înseamnă mai multe din categoria precedentă: deci [OPTION]... înseamnă că nu suntem limitați la o singură opțiune, dar opțiunile pot să și lipsească în totalitate datorită [ ].

O comandă poate avea atât opțiuni, cât și argumente. Opțiunile îi spun unei comenzi cum să își modifice comportamentul, și de obicei sunt precedate de - (ex. -l, --verbose, etc.). Argumentele îi spun unei comenzi pe ce să acționeze.

În exemplul de mai jos:

student@uso:~$ ls -l Desktop/

Avem utilitarul ls care primește opțiunea -l și argumentul Desktop/.

  • Ultima observație pe care o facem este că opțiunile unei comenzi pot avea o formă prescurtată, -a, sau o formă lungă, --all. Nu este obligatoriu ca o opțiune să expună ambele forme, deși majoritatea o fac. Opțiunile în formă prescurtată pot fi concatenate și precedate de un singur -, ca în exemplul de mai jos:
student@uso:~$ ls -la Desktop/
Exerciții

Deschideți pagina de manual a utilitarului ls.

  1. Căutați opțiunea -a. Rulați comanda ls -a.

Selectarea multiplelor fișiere folosind globbing

Întotdeauna când deschidem un terminal o facem pentru că vrem să realizăm o sarcină: vrem să redenumim rapid ultimele poze făcute cu telefonul de la genericul DCIM1001 la ceva util Excursie Sinaia, Ian 2020, 1001, vrem să ne testăm proiectul și să urcăm modificările pe GitHub, etc.

Până acum am aplicat diferite comenzi fie pe fișiere individuale, fie pe întreg directorul. Foarte des vom avea nevoie de un mijloc prin care să putem selecta un număr variabil de fișiere care au un nume care corespunde unui tipar (pattern) comun.

Să revenim la scenariul prezentat anterior: vrem să selectăm pozele din excursia din Sinaia. În directorul în care avem pozele din excursie avem și alte poze de la alte evenimente. Știm că pozele din excursie încep toate cu numele DCIM și apoi sunt urmate de un număr. Ceea ce vrem să facem este să selectăm toate pozele al căror nume corespunde acestui tipar și să le mutăm într-un director separat. Pentru a face acest lucru, folosim globbing, ca în exemplul de mai jos:

student@uso:~/Pictures$ mv DCIM* excursie-Sinaia-2020/

Observăm argumentul pe care l-am dat comenzii mv, și anume DCIM*. Expresia DCIM* este un exemplu de globbing: adică o expresie care descrie un tipar prin folosirea unor caractere speciale, așa cum este caracterul *. În cazul de față, expresia DCIM* înseamnă orice fișier al cărui nume începe cu șirul de caractere DCIM.

Caracterul special *

În sintaxa globbing, caracterul * poate fi înlocuit cu orice caracter de oricâte ori, sau poate lipsi cu totul. În directorul nostru home (~), executăm următoarele comenzi:

student@uso:~$ ls
Desktop    Downloads  Pictures  Templates  examples.desktop  vm-actions-log.txt
Documents  Music      Public    Videos     uso.git           workspace
 
student@uso:~$ ls -d D*
Desktop  Documents  Downloads
 
student@uso:~$ ls -d Music*
Music

Observăm că în expresia D*, caracterul * înglobează toate caracterele care urmează literei D: “esktop”, “ocuments” și “ownloads”. Observăm că în cazul expresie Music*, * nu ține locul nici unui caracter.

Folosirea ad-litteram a caracterelor speciale

Există cazuri când numele fișierelor conțin caractere speciale. Unele fișiere pot fi prefixate cu o categorie din care fac parte, ca în exemplul de mai jos:

student@uso:~$ ls Documents/uni
'PC*Course 01.pdf'  'USO*Course 01.pdf'  'USO*Course 02.pdf'

În exemplul de mai sus, fișierele pdf de curs contin caracterul *. Vrem să îi spunem sintaxei de globbing că în acest caz, acest caracter nu trebuie tratat ca o expresie, ci ca un caracter normal. Pentru a face acest lucru, încadrăm șirul între :

student@uso:~$ touch 'PC*Course 01.pdf'

Operația prin care eliminăm semnificația specială a unui caracter poartă numele de escaping; cu alte cuvinte, informal, spunem că am făcut escaping semnificației speciale a sintaxei []. Termenul vine de la cuvântul escape (a scăpa), și exprimă că scăpăm de semnificația specială a unui caracter / set de caractere.

Căutarea unui fișier în sistem

De multe ori ne aflăm în situația în care căutăm un fișier pe disc: ex. doar ce am clonat un proiect de pe GitHub și vrem să inspectăm fișierul Makefile pentru a vedea cum compilăm și rulăm proiectul. Un alt exemplu poate fi că vrem să vedem cum arată fișierele de test existente în proiect; de multe ori, ințelegem mai bine proiectul doar prin simpla inspectare a testelor.

Utilitarul find

Utilitarul find îndeplinește scopul de căuta în fișierele de pe sistem. Acesta ne permite să căutăm fișiere după nume, permisiuni, tipul fișierelor, data ultimei modificări și multe altele. Inspectăm pagina de manual a utilitarului pentru a vedea cum îl putem folosi.

student@uso:~$ man find
 
SYNOPSIS
       find  [-H]  [-L]  [-P]  [-D  debugopts]  [-Olevel]  [starting-point...]
       [expression]

La o primă vedere, find poate părea complex și intimidant, dar lucrurile stau foarte simplu. Folosim find cu sintaxa find [starting-point] [expression], ca în exemplul de mai jos:

student@uso:~$ find . -name "*search*"
./C/searching
./C/searching/linear_search.c
./C/searching/other_binary_search.c
./C/searching/binary_search.c
./C/searching/modified_binary_search.c
./C/searching/jump_search.c
./C/searching/interpolation_search.c
./C/searching/fibonacci_search.c
./C/searching/ternary_search.c
./C/searching/pattern_searc h
./C/searching/pattern_search/naive_search.c
./C/searching/pattern_search/boyer_moore_search.c
./C/searching/pattern_search/rabin_karp_search.c
./C/data_structures/binary_trees/binary_search_tree.c

În exemplul de mai sus observă că am folosit ca starting-point . (căutarea pleacă din directorul curent), iar ca expression -name "*search*".

Utilitarul find folosește o expresie compusă pentru căutare. În exemplul anterior am folosit opțiunea -name PATTERN. Exact ca în cazul utilitarului locate, PATTERN poate folosi sintaxa globbing, așa cum am făcut în exemplul de mai sus "*search*".

Atunci când folosim sintaxa globbing, trebuie să fim atenți să încadrăm PATTERN între " (ghilimele), așa cum am făcut în exemplul de mai sus. Trebuie să facem asta pentru ca sintaxa globbing să fie interpretată de către utilitarul find și nu de către terminalul (bash) din care lansăm utilitarul.

Scenarii complexe de căutare

Utilitarul find are o lungă listă de opțiuni pe care le putem folosi în expresii de căutare. Una din opțiunile mai cunoscute este -type care ne oferă posibilitatea de a căuta după tipul unui fișier:

student@uso:~$ find workspace/C -type f
workspace/C/leetcode/src/226.c
workspace/C/leetcode/src/700.c
workspace/C/leetcode/src/278.c
[...]

În exemplul de mai sus i-am transmis utilitarului find că vrem să căutăm în directorul ~/workspace/C toate fișierele text (regular file) -type f.

Exercițiu: Accesați pagina de manual a utilitarului find (man find) și căutați opțiunea -type. Căutați în directorul workspace/C după fiecare tip de fișier pentru care oferă suport opțiunea -type.

Reminder: pentru a căuta în man folosim / pentru a intra în search mode și apoi introducem textul pe care îl căutam -type urmat de tasta Enter; pentru a ne duce la următorul rezultat al căutării folosim tasta n (next).

În cadrul unei căutări putem să combinăm opțiunile de căutare:

student@uso:~$ find workspace/C -type f -name "*search*"
workspace/C/searching/modified_binary_search.c
workspace/C/searching/ternary_search.c
workspace/C/searching/jump_search.c
workspace/C/searching/binary_search.c

În exemplul de mai sus căutăm toate fișierele text care conțin șirul search în nume.

Exerciții
  1. Folosind find căutați fișierele care conțin șirul bubble_sort în nume.
  2. Folosind find căutați fișierele care conțin șirul quick_sort în nume.

Note de subsol

Inspectarea fișierelor

Inspectarea rapida a conținutului fișierelor

În secțiunea anterioară, improve_cli_inspect_fs, am văzut cum căutăm fișiere în sistem cu ajutorul utilitarului find. Căutăm un fișier cu un scop: vrem să găsim fișierul README pentru informații despre compilarea proiectului, vrem să ne amintim un detaliu de implementare din cod, etc.

De cele mai multe ori acțiunea noastră se poate grupa în una din următoarele două categorii:

  • Ne dorim să inspectăm rapid conținutul fișierelor pentru a ne da seama dacă am găsit informația căutată.
  • Ne dorim să afișăm pe ecran conținutul fișierelor pentru a extrage și prelucra informații din acestea.

Prelucrarea informației dintr-un fișier

Pentru a afișa pe ecran conținutul unui fișier folosim utlitarul cat. Rulăm comanda de mai jos, pentru a exemplifica:

student@uso:~$ cat workspace/C/searching/binary_search.c
/**
 * @file
 * @brief Program to perform [binary
 * search](https://en.wikipedia.org/wiki/Binary_search_algorithm) of a target
 * value in a given *sorted* array.
 * @authors [James McDermott](https://github.com/theycallmemac) - recursive
 * algorithm
 * @authors [Krishna Vedala](https://github.com/kvedala) - iterative algorithm
 */
#include <assert.h>
#include <stdio.h>
 
[...]

Observăm că pentru un fișier cu un număr mare de linii, așa cum este binary_search.c, afișarea întregului conținut pe ecran devine un impediment în a putea înțelege și urmări conținutul. De aceea vă încurajăm să folosiți less în loc de cat pentru a inspecta un fișier: vă este mult mai ușor să vă plimbați în interiorul fișierului și puteți folosi funcția search pentru a căuta în fișier. De asemeni, folosind less vă păstrați consola curată și puteți urmări mai ușor ce comenzi ați dat anterior și care au fost rezultatele acestora.

Folosim comanda cat în combinație cu alte comenzi pentru a extrage sau filtra conținutul anumitor fișiere. Comanda cat primește ca argumente calea către unul sau mai multe fișiere și afișează pe ecran conținutul concatenat al acestora.

Un exemplu uzual este faptul că vrem să extragem informațiile despre starea memoriei sistemului din fișierul /proc/meminfo. Pentru aceasta rulăm comanda de mai jos:

student@uso:~$ cat /proc/meminfo | grep "Mem"
MemTotal:        2041248 kB
MemFree:          236092 kB
MemAvailable:     874420 kB

În exemplul de mai sus folosim cat pentru a oferi ca intrare conținutul fișierului /proc/meminfo utilitarului grep; cu utilitarul grep filtrăm conținutul după textul "Mem". Cu alte cuvinte, outputul comenzii cat /proc/meminfo, adică conținutul fișierului /proc/meminfo este textul pe care utilitarul grep îl prelucrează.

Exercițiu: Plecând de la exemplul de mai sus, extrageți din fișierul /proc/cpuinfo dimensiunea memoriei cache a procesorului vostru; filtrați conținutul după textul "cache".

Afișarea parțială a unui fișier

Am văzut că utilitarul cat afișează întreg conținutul unui fișier. Există scenarii în care suntem interesați doar de începutul sau sfârșitul unui conținut. Pentru aceste cazuri putem folosi utilitarele:

  • head - afișează primele 10 linii din conținut
  • tail - afișează ultimele 10 linii din conținut

Valoarea 10 este valoarea implicită a ambelor utilitare, dar putem specifica un alt număr de linii.

Așa cum am observat în capitolul despre procese, putem folosi utilitarul ps pentru a vedea care sunt procesele din sistem și ce resurse consumă acestea. Memoria sistemului este una dintre cele mai importante resurse; dacă sistemul nostru rămâne fără memorie disponibilă, tot sistemul este afectat: sistemul se va “mișca” mai greu, procesele se vor “mișca” mai greu sau pot chiar să își întrerupă activitatea. Știind acest lucru, suntem interesați să vedem care sunt primele zece procese care consumă cea mai multă memorie.

Folosim utilitarul ps pentru a afișa toate procesele din sistem:

student@uso:~$ ps -e -ouser,uid,pid,%mem,%cpu,rss,cmd --sort=%mem
 
USER       UID   PID %MEM %CPU   RSS CMD
root         0     2  0.0  0.0     0 [kthreadd]
 
[...]
 
student   1000  8338  3.0  0.0 61860 /usr/lib/evolution/evolution-calendar-factory-subprocess --factory all --bus-name org.gnome.evolution.dataserver.Subprocess.Backend.Calendarx8307x2 --own-path /org/gnome/evolution/dataserver/Subprocess/Backend/Calendar/8307/2
student   1000  8307  3.1  0.0 64628 /usr/lib/evolution/evolution-calendar-factory
root         0  1338  3.8  0.0 78880 /usr/bin/dockerd -H fd:// --containerd=/run/containerd/containerd.sock
student   1000  7782  3.9  0.0 81312 /usr/lib/xorg/Xorg vt1 -displayfd 3 -auth /run/user/1000/gdm/Xauthority -background none -noreset -keeptty -verbose 3
student   1000  8437  8.4  0.0 171916 /usr/bin/gnome-software --gapplication-service
student   1000  7938 18.0  0.1 368304 /usr/bin/gnome-shell

Am folosit opțiunea -ouser,uid,pid,%mem,%cpu,rss,cmd pentru a selecta coloanele pe care să le afișeze ps.

Am folosit opțiunea --sort cu argumentul %mem pentru a sorta procesele după procentul de memorie folosită.

Folosiți comanda ps -e -ouser,uid,pid,%mem,%cpu,rss,cmd --sort=%mem | less pentru a vizualiza rezultatul comenzii ps într-o sesiune interactivă less.

Observăm că avem procesele sortate crescător după coloana %MEM. Folosim utilitarul tail pentru a extrage din rezultatul ps cele mai consumatoare zece procese:

student@uso:~$ ps -e -ouser,uid,pid,%mem,%cpu,rss,cmd --sort=%mem | tail
student   1000 12966  1.8  0.0 38216 /usr/lib/gnome-terminal/gnome-terminal-server
root         0  1074  2.2  0.0 45460 /usr/bin/containerd
student   1000  8274  2.3  0.0 48296 nautilus-desktop
root         0   336  2.6  0.0 53612 /lib/systemd/systemd-journald
student   1000  8338  3.0  0.0 61860 /usr/lib/evolution/evolution-calendar-factory-subprocess --factory all --bus-name org.gnome.evolution.dataserver.Subprocess.Backend.Calendarx8307x2 --own-path /org/gnome/evolution/dataserver/Subprocess/Backend/Calendar/8307/2
student   1000  8307  3.1  0.0 64628 /usr/lib/evolution/evolution-calendar-factory
root         0  1338  3.8  0.0 78880 /usr/bin/dockerd -H fd:// --containerd=/run/containerd/containerd.sock
student   1000  7782  3.9  0.0 81312 /usr/lib/xorg/Xorg vt1 -displayfd 3 -auth /run/user/1000/gdm/Xauthority -background none -noreset -keeptty -verbose 3
student   1000  8437  8.4  0.0 171916 /usr/bin/gnome-software --gapplication-service
student   1000  7938 18.0  0.1 368248 /usr/bin/gnome-shell

În acest moment am găsit răspunsul căutat, dar avem două mici neajunsuri:

  • Ne lipsește antetul, așa că nu știm ce informații avem pe coloane
  • Procesele sunt sortate crescător, a.î. cel mai consumator este ultimul; vrem să fie sortate descrescător

Rezolvăm cele două probleme prin intermediul opțiunii --sort: dacă punem un - (minus) în fața argumentului după care sortăm, o să sortăm descrescător. Rulăm comanda:

student@uso:~$ ps -e -ouser,uid,pid,%mem,%cpu,rss,cmd --sort=-%mem | less
USER       UID   PID %MEM %CPU   RSS CMD
student   1000  7938 18.0  0.1 368248 /usr/bin/gnome-shell
student   1000  8437  8.4  0.0 171916 /usr/bin/gnome-software --gapplication-service
student   1000  7782  3.9  0.0 81312 /usr/lib/xorg/Xorg vt1 -displayfd 3 -auth /run/user/1000/gdm/Xauthority -background none -noreset -keeptty -verbose 3
root         0  1338  3.8  0.0 78880 /usr/bin/dockerd -H fd:// --containerd=/run/containerd/containerd.sock
student   1000  8307  3.1  0.0 64628 /usr/lib/evolution/evolution-calendar-factory
 
[...]

Observăm că acum avem formatul dorit. Ne mai rămâne să extragem primele 11 linii din rezultatul comenzii de mai sus; 11 deoarece prima este linia antetului iar următoarele zece sunt procesele de interes. Pentru aceasta utilizăm comanda head cu opțiunea -11 ca în exemplul de mai jos:

student@uso:~$ ps -e -ouser,uid,pid,%mem,%cpu,rss,cmd --sort=-%mem | head -11
USER       UID   PID %MEM %CPU   RSS CMD
student   1000  7938 18.0  0.1 367952 /usr/bin/gnome-shell
student   1000  8437  8.4  0.0 171916 /usr/bin/gnome-software --gapplication-service
student   1000  7782  3.9  0.0 81312 /usr/lib/xorg/Xorg vt1 -displayfd 3 -auth /run/user/1000/gdm/Xauthority -background none -noreset -keeptty -verbose 3
root         0  1338  3.8  0.0 78880 /usr/bin/dockerd -H fd:// --containerd=/run/containerd/containerd.sock
student   1000  8307  3.1  0.0 64628 /usr/lib/evolution/evolution-calendar-factory
student   1000  8338  3.0  0.0 61860 /usr/lib/evolution/evolution-calendar-factory-subprocess --factory all --bus-name org.gnome.evolution.dataserver.Subprocess.Backend.Calendarx8307x2 --own-path /org/gnome/evolution/dataserver/Subprocess/Backend/Calendar/8307/2
root         0   336  2.6  0.0 53612 /lib/systemd/systemd-journald
student   1000  8274  2.3  0.0 48296 nautilus-desktop
root         0  1074  2.2  0.0 45460 /usr/bin/containerd
student   1000 12966  1.8  0.0 38216 /usr/lib/gnome-terminal/gnome-terminal-server

Căutarea în fișiere

Așa cum am văzut până în acest punct din carte, majoritatea comenzilor Linux afișează o gamă largă de informații pe care apoi utilizatorul (adică noi) le filtrează pentru a extrage ceea ce îl intresează. La începutul acestei secțiuni, dar și de-a lungul cărții, am folosit utilitarul grep ca să filtrăm rezultatul unei comenzi.

Comanda grep este una dintre cele mai folosite în linie de comandă. Sintaxa de folosire a grep este următoarea:

SYNOPSIS
       grep [OPTIONS] PATTERN [FILE...]

grep caută PATTERN în lista de fișiere primită ca argument și afișează liniile care conțin PATTERN-ul căutat. Atunci când nu primește nici un fișier, citește text de la tastatură (intrarea standard) și afișează liniile care conțin PATTERN-ul căutat.

Până acum noi am utilizat grep după modelul de mai jos:

student@uso:~$ cat workspace/C/searching/binary_search.c | grep search
 * search](https://en.wikipedia.org/wiki/Binary_search_algorithm) of a target
 * \param[in] arr array to search
 * \param l left index of search range
 * \param r right index of search range
 * \param x target value to search for
int binarysearch1(const int *arr, int l, int r, int x)
 
[...]

În exemplul de mai sus, operatorul | trimite textul afișat de comanda cat către intrarea standard a comenzii grep. Vom discuta mai multe despre acesta în secțiunea improve_cli_improve_shell_oneliners.

Comanda următoare este echivalentă cu cea de mai sus:

student@uso:~$ grep search workspace/C/searching/binary_search.c
 * search](https://en.wikipedia.org/wiki/Binary_search_algorithm) of a target
 * \param[in] arr array to search
 * \param l left index of search range
 * \param r right index of search range
 * \param x target value to search for
int binarysearch1(const int *arr, int l, int r, int x)
[...]

Observăm modul de folosire: grep PATTERN cale/către/fișier.

Exerciții

  1. Căutați patternul “l” în fișierul binary_search.c, pentru a vedea unde este folosit parametrul left. Observați cât de multe rezultate irelevante ați găsit datorită faptului că am căutat doar caracterul l. Aici există o lecție de învățat. Numele variabilelor sunt foarte improtante: nu fac doar codul mai ușor de înțeles, dar ajută și căutarea. Folosiți patternul “param l” în încercarea de a restrânge căutarea.

O înțelegere mai bună a shellului

Execuția comenzilor

Încheierea execuției unei comenzi

Atunci când rulăm o comandă aceasta își poate încheia execuția în două moduri: cu succes sau cu eșec. Atunci când își încheie execuția, orice proces întoarce un cod de eroare, care este un număr:

  • Dacă numărul întors are valoarea 0, procesul și-a încheiat execuția cu succes.
  • Dacă numărul întors are orice altă valoare, procesul și-a încheiat execuția cu eroare, iar codul întors poate fi folosit pentru a afla mai multe informații despre eroarea pe care a întors-o procesul. În pagina man a utilitarului ls este specificat:
    Exit status:
           0      if OK,
     
           1      if minor problems (e.g., cannot access subdirectory),
     
           2      if serious trouble (e.g., cannot access command-line argument).

Pentru a vedea codul cu care și-a încheiat execuția o comandă folosim sintaxa $?. Urmărim exemplul de mai jos:

student@uso:~$ ls Desktop/
todos.txt
student@uso:~$ echo $?
0
student@uso:~$ ls non-existent
ls: cannot access 'non-existent': No such file or directory
student@uso:~$ echo $?
2

Observăm că în cazul fișierului inexistet, comanda ls non-existent a întors valoarea 2, așa cum era specificat și în pagina de manual.

Înlănțuirea comenzilor în funcție de succes sau eșec

De multe ori vrem să executăm o succesiune de comenzi pentru a realiza o sarcină. De exemplu, atunci când vrem să instalăm o aplicație o rulăm trei comenzi:

  • O să actualizăm indexul surselor de pachete folosind apt update
  • O să instalăm pachetul care conține aplicația folosind apt install
  • O să rulăm aplicația pentru a valida că instalarea a fost cu succes.

Preferăm să înlănțuim cele trei comenzi într-una singură pentru că astfel putem să pornim tot acest proces, să plecăm de la calculator, iar când ne întoarcem avem tot sistemul pregătit.

Pentru a înlănțui comenzi în terminalul bash avem trei operatori disponibili:

Operatorul ; - este folosit pentru separarea comenzilor Urmăm exemplul de mai jos:

student@uso:~$ mkdir demo; cd demo; touch Hello; ls
Hello

În exemplul de mai sus am creat directorul demo, am navigat în interiorul său, am creat fișierul Hello și am afișat conținutul directorului. Am făcut toate acestea înlănțuind comenzile mkdir, cd, touch și ls cu ajutorul operatorului ;. Operatorul ; este folosit pentru separarea comenzilor, dar nu ține cont dacă comenzile anterioare au fost executate cu succes sau nu. Urmăm exemplul de mai jos:

student@uso:~$ mkdir operators/demo; cd operators/demo
mkdir: cannot create directory ‘operators/demo’: No such file or directory
-bash: cd: operators/demo: No such file or directory

În exemplul de mai sus, comanda mkdir a eșuat deoarece nu a găsit directorul operators în care să creeze directorul demo. Cu toate acestea, operatorul ; doar separă comenzile între ele, așa că și comanda cd operators/demo a fost executată, și și aceasta a eșuat deoarece nu există calea operators/demo. Folosim operatorul ; pentru a înlănțui comenzi care sunt independente unele de altele, și deci execuția lor nu depinde de succesul unei comenzi precedente.

Operatorul binar && (și logic) - execută a doua comandă doar dacă precedenta s-a executat cu succes. Exemplul anterior devine:

student@uso:~$ mkdir operators/demo && cd operators/demo
mkdir: cannot create directory ‘operators/demo’: No such file or directory

Observăm că din moment ce comanda mkdir a eșuat, comanda cd nu a mai fost executată.

Operatorul binar || (sau logic) - execută a doua comandă doar dacă prima s-a terminat cu eșec. Urmărim exemplul de mai jos:

student@uso:~$ (ls -d operators || mkdir operators) && ls -d operators
ls: cannot access 'operators': No such file or directory
operators
student@uso:~$ (ls -d operators || mkdir operators) && ls -d operators
operators
operators

În exemplul de mai sus, prima comandă ls a eșuat, așa că a fost executată comanda mkdir și apoi a fost executată ultima comandă ls. La cea de-a doua rulare, a fost executată cu succes prima comandă ls, așa că comanda mkdir nu a mai fost executată, și apoi a fost executată ultima comandă ls.

Pentru a rezolva scenariul de la care am plecat inițial, putem rula:

sudo apt update && sudo apt install -y cowsay && cowsay "Howdy"

Comanda de mai sus va actualiza indexul pachetelor sursă, va instala pachetul cowsay și va rula comanda cowsay pentru a valida instalarea. O astfel de înlănțuire de comenzi este numită oneliner.

Exerciții
  1. Scrieți un oneliner cu ajutorul căruia creați directorul ~/uso-lab/labs/05-cli/support/make-folder și apoi copiați conținutul directorului ~/uso-lab/labs/05-cli/support/redir în el.

Înlănțuirea comenzilor folosind operatorul | (pipe)

Așa cum am descoperit în secțiunile și capitolele anterioare, în mediul Linux avem multe utilitare care rezolvă o nevoie specifică: ls afișează informații despre fișiere, ps despre procese, grep filtrează, etc. Toate acestea au la bază filozofia mediului Linux: “do one thing and do it well”. Ca întodeauna, frumusețea stă în simplitate: avem o suită de unelte la dispoziție, fiecare capabilă să rezolve rapid o sarcină dată; pentru a rezolva o problemă mai complexă trebuie doar să îmbinăm uneltele.

Operatorul | (pipe) ne ajută să facem acest lucru. Atunci când folosim operatorul | preluăm rezultatul comenzii din stânga operatorului și îl oferim ca intrare comenzii aflate în dreapta operatorului.

Am folosit de mai multe ori operatorul | până acum:

  • Am afișat informații despre procesele din sistem și am filtrat după numele unui proces:
    student@uso:~$ ps -e | grep firefox
    14912 pts/0    00:00:19 firefox
  • Am extras primele zece procese care consumă cel mai mare procent de memorie:
    student@uso:~$ ps -e -ouser,uid,pid,%mem,%cpu,rss,cmd --sort=-%mem | head -11
    USER       UID   PID %MEM %CPU   RSS CMD
    student   1000  7938 18.0  0.1 367952 /usr/bin/gnome-shell
    student   1000  8437  8.4  0.0 171916 /usr/bin/gnome-software --gapplication-service
    student   1000  7782  3.9  0.0 81312 /usr/lib/xorg/Xorg vt1 -displayfd 3 -auth /run/user/1000/gdm/Xauthority -background none -noreset -keeptty -verbose 3
    root         0  1338  3.8  0.0 78880 /usr/bin/dockerd -H fd:// --containerd=/run/containerd/containerd.sock
    student   1000  8307  3.1  0.0 64628 /usr/lib/evolution/evolution-calendar-factory
    student   1000  8338  3.0  0.0 61860 /usr/lib/evolution/evolution-calendar-factory-subprocess --factory all --bus-name org.gnome.evolution.dataserver.Subprocess.Backend.Calendarx8307x2 --own-path /org/gnome/evolution/dataserver/Subprocess/Backend/Calendar/8307/2
    root         0   336  2.6  0.0 53612 /lib/systemd/systemd-journald
    student   1000  8274  2.3  0.0 48296 nautilus-desktop
    root         0  1074  2.2  0.0 45460 /usr/bin/containerd
    student   1000 12966  1.8  0.0 38216 /usr/lib/gnome-terminal/gnome-terminal-server

Redirectări

Majoritatea utilitarelor pe care le folosim afișează rezultatele operațiilor pe care le aplică la ieșirea standard, adică pe ecran. În continuare vom aprofunda ceea ce am discutat despre redirectări în capitolul Lucrul cu Fișiere. Anterior am mai menționat și termenul de intrare standard; în această secțiune ne vom clarifica ce înseamnă, ce rol îndeplinesc și cum ne folosim de aceste cunoștințe.

Orice proces folosește implicit trei fluxuri (streams) de date:

  • STDIN - fluxul de intrare standard, referit și ca “citit de la tastatură”. Spunem că un program care citește date de intrare din linie de comandă, deci așteaptă de la utilizator, citește de la intrarea standard; de aici și denumirea “citit de la tastatură”. Complementul citirii de la tastatură este citirea datelor dintr-un fișier.
  • STDOUT - fluxul de ieșire standard, referit și ca “afișare pe ecran”. Spunem că un program afișează datele de ieșire pe ecran, adică scrie rezultatele procesărilor efectuate la ieșirea standard. Complementul afișării pe ecran este scrierea rezultatelor într-un fișier.
  • STDERR - fluxul de ieșire standard al erorilor. Un program corect scris o să scrie erorile în fluxul de ieșire al erorilor. Acest lucru permite filtrarea erorilor.

În linie de comandă, atât STDOUT cât și STDERR vor apărea pe ecran. Datorită faptului că informațiile sunt scrise în două fluxuri distincte, utilizatorul are posibilitatea de a separa rezultatele de erori. Utilizatorul face aceasta folosind redirectări.

Redirectarea ieșirilor standard

Cum spuneam mai sus, majoritatea programelor pe care le folosim vor afișa rezultatele pe ecran. Acest comportament este bun atunci când ne scriem onelinerul care ne extrage informațiile căutate, dar cel mai probabil o să vrem să salvăm rezultatul procesării într-un fișier.

Folosim operatorul > pentru a redirecta STDOUT sau STDERR într-un fișier. Pentru fiecare flux de date avem un număr, numit descriptor de fișier, asociat:

  • STDIN are asociat descriptorul de fișier 0
  • STDOUT are asociat descriptorul de fișier 1
  • STDERR are asociat descriptorul de fișier 2

Pentru a redirecta ieșirea standard folosim sintaxa cmd 1> nume-fișier. Pentru a redirecta ieșirea standard a erorilor folosim sintaxa cmd 2> nume-fișier.

Atenție! În cazul în care fișierul destinație nu există, operatorul > îl va crea. Dacă fișierul destinație există, operatorul > va șterge conținutul acestuia.

Urmăm exemplul de mai jos:

student@uso:~$ ps -e -ouser,uid,pid,%mem,%cpu,rss,cmd --sort=-%mem | head -11
USER       UID   PID %MEM %CPU   RSS CMD
student   1000  7938 18.0  0.1 367952 /usr/bin/gnome-shell
student   1000  8437  8.4  0.0 171916 /usr/bin/gnome-software --gapplication-service
student   1000  7782  3.9  0.0 81312 /usr/lib/xorg/Xorg vt1 -displayfd 3 -auth /run/user/1000/gdm/Xauthority -background none -noreset -keeptty -verbose 3
root         0  1338  3.8  0.0 78880 /usr/bin/dockerd -H fd:// --containerd=/run/containerd/containerd.sock
student   1000  8307  3.1  0.0 64628 /usr/lib/evolution/evolution-calendar-factory
student   1000  8338  3.0  0.0 61860 /usr/lib/evolution/evolution-calendar-factory-subprocess --factory all --bus-name org.gnome.evolution.dataserver.Subprocess.Backend.Calendarx8307x2 --own-path /org/gnome/evolution/dataserver/Subprocess/Backend/Calendar/8307/2
root         0   336  2.6  0.0 53612 /lib/systemd/systemd-journald
student   1000  8274  2.3  0.0 48296 nautilus-desktop
root         0  1074  2.2  0.0 45460 /usr/bin/containerd
student   1000 12966  1.8  0.0 38216 /usr/lib/gnome-terminal/gnome-terminal-server
student@uso:~$ ps -e -ouser,uid,pid,%mem,%cpu,rss,cmd --sort=-%mem | head -11 1> top10-consumers
student@uso:~$ less top10-consumers

Am scris, prin încercări succesive, onelinerul care ne afișează primele zece procese care consumă cea mai multă memorie. Apoi am folosit sintaxa 1> top10-consumers pentru a redirecta rezultatul în fișierul top10-consumers.

Urmăm exemplul de mai jos pentru a redirecta erorile:

student@uso:~$ ls D* F* > out 2> errs
student@uso:~$ cat out
Desktop:
todos.txt
 
Documents:
snippets.git
uni
uso.tar
 
Downloads:
courses.tar
uso.tar
student@uso:~$ cat errs
ls: cannot access 'F*': No such file or directory

Observăm că am folosit sintaxa 2> errs pentru a redirecta erorile în fișierul errs. Observăm că pentru a redirecta ieșirea standard putem omite descriptorul de fișier, așa cum am făcut cu > out.

Atunci când rulăm o comandă, redirectăm erorile într-un fișier pentru că vrem să verificăm că totul s-a executat cu succes. De cele mai multe ori suntem în rumătorul scenariu:

  1. Urmează să executăm o comandă care durează mai mult timp și pentru care nu putem să ținem pasul, cu ochiul liber, cu fluxul de afișare a datelor pe ecran. Un exemplu este compilarea unui proiect mai mare.
  2. O să pornim procesul și o să redirectăm STDOUT și STDERR în două fișiere, de ex. out și err.
  3. În timpul cât rulează noi putem să facem altceva: ne ocupăm de altă sarcină, ne facem o cafea, etc.
  4. La finalul execuției inspectăm fișierele out și err pentru a vedea dacă au existat erori și le rezolvăm.

Acum înțelegem cum funcționează operatorul | (pipe). Acesta conectează fluxul de ieșire (STDOUT) al comenzii din stânga sa cu fluxul de intrare (STDIN) al comenzii din dreapta.

Redirectarea în mod append

Implicit, operatoru > șterge (trunchează) conținutul fișierului destinație. Dacă vrem să păstrăm conținutul fișierului și să adăugăm rezultatul redirectării în continuarea acestuia, folosim operatorul >>.

Rulați din nou exemplele de mai sus folosind operatorul >> în locul operatorului >. Folosiți less pentru a inspecta fișierele de ieșire și de erori.

Fișiere speciale

Pe sistemele Linux găsim un număr de fișiere speciale pe care le putem folosim în diferite scopuri:

Fișierul /dev/null este un fișier care ignoră orice este scris în el. Este echivalentul unei găuri negre în sistemul nostru. Cu ajutorul său, putem rescrie exemplul de mai sus în modul următor:

student@uso:~$ firefox &> /dev/null &
[1] 10349
student@uso:~$ firefox > /dev/null 2>&1 &
[2] 10595

Acum orice va genera firefox va fi scris în /dev/null, care va consuma textul primit fără a ocupa spațiu pe disc.

Fișierul /dev/zero este un generator de octeți. Acesta generează atâția octeți cu valoarea zero (0)4) cât îi sunt ceruți. Rulând comanda cat /dev/zero putem observa că nicio valoare nu este afișată în terminal. Pentru a opri citirea va trebui sa folosim combinația de taste Ctrl+C.

Fișierul /dev/urandom este un alt generator de octeți. Acesta generează atâția octeți cu valoare random cât îi sunt ceruți.

Exercițiu: Rulați comenzile din exemplul anterior, dar acum citiți din /dev/urandom.

Generatoarele de octeți sunt utile pentru a testa aplicațiile pe care le dezvoltăm. Majoritatea aplicațiilor pe care le vom scrie, ca și cele pe care le utilizăm, citesc și prelucrează informații. Testăm o aplicație pentru că vrem să verificăm că nu avem buguri. Pentru aceasta putem să folosim seturi de date de intrare cât mai variate și mai aleatoare, adică inputuri random. Folosim utilitarul dd pentru a genera un fișier de 100 MB cu octeți random, ca în exemplul de mai jos:

student@uso:~$ dd if=/dev/urandom of=rand-100mb count=100 bs=1M
100+0 records in
100+0 records out
104857600 bytes (105 MB, 100 MiB) copied, 1,11416 s, 94,1 MB/s
student@uso:~$ ls -lh rand-100mb
-rw-rw-r-- 1 student student 100M nov  8 17:49 rand-100mb

Am folosit următoarele opțiuni ale utilitarului dd:

  • if - input file - calea către fișierul de unde citim
  • of - output file - calea către fișierul unde scriem
  • bs - block size - dimensiunea unui block citit din if
  • count - block count - numărul de block-uri citite

Exercițiu: Creați un fișier numit rand-250mb folosind utilitarul dd.

Un caz uzual de utilizare a dd este suprascrierea unui disc cu informații aleatoare. Această metodă este utilizată ca o formă de securitate atunci când vrem să ștergem informații de pe un disc. Astfel suprascriem datele șterse pentru a preveni posibilitatea recuperării datelor de pe disc. Mai multe informații găsiți aici.

Exerciții
  1. Afișați primele zece procese sortate în funcție de memoria ocupată (Hint: RSS). Nu uitați să includeți antetul. Redirectați rezultatul în fișierul top10-rss-consumers. Modificați comanda astfel încât rezultatul redirectării să nu șteargă conținutul existent.
  2. Afișați ultimele zece procese sortate în funcție de utilizarea procesorului (Hint: CPU). Nu uitați să includeți antetul. Redirectați rezultatul în fișierul top10-cpu-consumers. Modificați comanda astfel încât rezultatul redirectării să nu șteargă conținutul existent.

Note de subsol

Sumar: Îmbunătățirea lucrului în linia de comandă

Sumar: Scurtături în terminal

  • Funcția de auto-complete este extrem de utilă și îmbunătățește în mod dramatic viteza cu care realizăm acțiuni în terminal.

    • Funcția de auto-complete nu ne face doar mai rapizi, dar putem folosi tasta Tab și pt a confirma că comanda este validă.

  • Consultăm istoricul comenzilor folosind comanda history.

    • Navigăm prin istoricul comenzilor folosind Arrow Keys, Ctrl+r, expandarea comenzilor anterioare sau chiar expandarea argumentelor comenzii anterioare.

    • Navigăm în interiorul unei comenzi (Ctrl+a, Ctrl+e, Alt+f, Alt+b), putem efectua modificări (Ctrl+k, Ctrl+u, Alt+d) și putem insera textul șters (Ctrl+y).

Sumar: Inspectarea sistemului de fișiere

Inspectarea paginilor de manual

  • Navigarea prin paginile manualului:
    • Ctrl+n/Ctrl+p sau j/k pentru a naviga, cu câte o linie, în jos, respectiv în sus; recomandăm utlizarea tastelor j/k pentru a fi mai eficienți
    • Search (/, ?, n, N)
    • Go up (g), go down (G)
    • Help (h) pentru a afla mai multe despre cum putem folosi mai bine sesiunea interactivă
    • Quit (q) pentru a ieși din sesiunea interactivă
  • Prezentarea secțiunilor din manual: man printf vs man 3 printf.
  • Prezentarea pachetului tldr - poate fi util pentru cazurile uzuale, dar nu trebuie să ne fie frică să căutăm în man pentru detalii

Selectarea multiplor fișiere folosind globbing

Folosim globbing pentru a selecta mai multe fișiere al căror nume corespunde unui tipar:

  • Caracterul * poate fi înlocuit cu orice caracter de oricâte ori, sau poate lipsi cu totul.
  • Caracterul ? înlocuiește exact un caracter, oricare ar fi acela.
  • Folosim sintaxa [] pentru a defini o listă de caractere care pot fi folosite în înlocuire.
  • Folosim sintaxa {} pentru a defini o listă de cuvinte (grupuri de caractere) care pot fi folosite în înlocuire.
  • Scăpăm de semnificația specială a unei expresii încadrând-o între " (ghilimele).

Căutarea unui fișier în sistem

Utilitarul locate

Folosim utilitarul locate pentru a căuta un fișier în întreg sistemul de fișiere.

Are avantajul că este foarte rapid, deoarece folosește o bază de date pentru a indexa fișierele.

Are două dezavantaje:

  1. Baza de date trebuie reconstruită periodic. Dacă vrem să reconstruim manual baza de date, avem nevoie de drepturi privilegiate pentru a rula comanda updatedb.

  2. Utilitarul caută în tot sistemul de fișiere: nu putem să specificăm un punct de start pentru căutare. Este necesar să filtrăm rezultatul căutării cu punctul de start dorit, așa cum am făcut în exemplul de mai sus: | grep workspace/C.

Utilitarul find

Folosim find pentru a căuta după criterii mai complexe decât numele fișierului, cum ar fi tipul fișierului, data ultimei modificări, etc.

De cele mai multe ori vom folosi find în conjuncție cu opțiunea -exec pentru a rula o comandă asupra fișierelor găsite.

Utilitarul find este mai lent decât locate, dar nu necesită o bază de date care trebuie actualizată periodic. locate este probabil suficient pentru majoritatea cazurilor când suntem interesați de căutarea unui fișier. j

Sumar: Inspectarea fișierelor

Inspectarea rapida a conținutului fișierelor

Pentru a vedea rapid conținutul unui fișier folosim utlitarul less. În cadrul unei sesiuni less putem folosi aceeleași taste ca în cadrul sesiunii interactive man pentru navigarea în pagină:

  • Ctrl+n/Ctrl+p sau j/k pentru a naviga, cu câte o linie, în jos, respectiv în sus; recomandăm utlizarea tastelor j/k pentru a fi mai eficienți
  • Ctrl+f/Ctrl+b pentru a naviga, cu câte o pagină de terminal, în jos, respectiv în sus
  • Search (/, ?, n, N)
  • Go up (g), go down (G)
  • Help (h) pentru a afla mai multe despre cum putem folosi mai bine sesiunea interactivă
  • Quit (q) pentru a ieși din sesiunea interactivă

Pentru a afișa pe ecran conținutul unui fișier folosim utlitarul cat.

Pentru a afișa parțial conținutul unui fișier sau a extrage rezultatul unei comenzi folosim utilitarele head și tail.

Căutarea în fișiere

Folosim comanda grep pentru a căuta un pattern într-un fișier sau în rezultatul unei comenzi (cum ar fi cat). Modul de folosire este grep PATTERN cale/către/fișier sau cmd | grep PATTERN.

Opțiuni uzuale ale grep

Folosim opțiunea -n pentru a afișa și numărul liniei care conține patternul căutat.

Implicit, grep caută în mod case-sensitive patternul. Folosim opțiunea -i pentru a căuta patternul în mod case-insensitive.

Pentru a afișa toate liniile, mai puțin pe cele care conțin pattern, folosim opțiunea -v.

Pentru a efectua o căutare recursivă folosim opțiunea -r.

De cele mai multe ori vom folosi opțiunile -n, -i și -r în aceelași timp. Astfel avem o căutare cât mai cuprinzătoare și putem folosi funcția de căutare în sesiunea interactivă less pentru a găsi linia și fișierul care ne interesează.

Extra: Dacă dorim să căutăm cuvântul search folosim opțiunea -w (word) pentru a trata patternul ca un cuvânt, ca în exemplul următor: grep -nri -w "search" workspace/C/ | less.

Compararea fișierelor

Comparăm două fișiere, octet cu octet, folosind utilitarul cmp.

Comparăm textual două fișiere folosind utilitarul diff.

Sumar: O înțelegere mai bună a shellului

Configurarea shellului bash

Fișierul de configurare al shellului BASH este ~/.bashrc. Atunci când un utilizator pornește un shell bash, conținutul fișierului ~/.bashrc este citit și sunt aplicate configurările specifice utilizatorului.

Valorile variabilelor HISTSIZE și HISTFILESIZE limitează numărul maxim de comenzi, respectiv linii, din fișierul ~/.bash_history.

Un alias este un nume (placeholder) care înlocuiește un șir de caractere. Pentru o organizare mai bună, este recomandat ca utilizatorul să-și definească aliasurile în fișierul ~/.bash_aliases.

Execuția comenzilor

Înlănțuirea comenzilor

Atunci când își încheie execuția, orice proces întoarce un cod de eroare, care este un număr: valoarea 0 semnifică că acesta și-a încheiat execuția cu succes, iar orice ală valoare indică o eroare.

Pentru a înlănțui comenzi în terminalul bash avem trei operatori disponibili:

  • Operatorul ; - este folosit pentru separarea comenzilor, indiferent de cum s-au executat acestea.
  • Operatorul binar && (și logic) - execută a doua comandă doar dacă precedenta s-a executat cu succes.
  • Operatorul binar || (sau logic) - execută a doua comandă doar dacă prima s-a terminat cu eșec.

Atunci când folosim operatorul | preluăm rezultatul comenzii din stânga operatorului și îl oferim ca intrare comenzii aflate în dreapta operatorului. Operatorul | ne permite să prelucrăm datele de interes, trecându-le prin mai multe utilitare, fiecare cu un scop bine definit.

Redirectări

Folosim operatorul > pentru a redirecta STDOUT sau STDERR într-un fișier. Pentru a redirecta ieșirea standard folosim sintaxa cmd > nume-fișier. Pentru a redirecta ieșirea standard a erorilor folosim sintaxa cmd 2> nume-fișier.

Implicit, operatoru > șterge (trunchează) conținutul fișierului destinație. Dacă vrem să păstrăm conținutul fișierului și să adăugăm rezultatul redirectării în continuarea acestuia, folosim operatorul >>.

Folosim sintaxa &> cale/către/nume-fișier pentru a redirecta atât STDERR, cât și STDOUT, în fișierul primit ca argument.

Filtre de text

Înainte de laborator

Comandă Descriere scurtă
head comandă folosită să afișăm primele linii dintr-un output
tail comandă folosită să afișăm ultimele linii dintr-un output
find comandă cu care putem găsi un fișier într-o ierarhie de directoare
tr filtru de text, mai multe detalii aici
cut comandă utilă pentru a separa secțiuni ale unui output, pentru detalii aici
sort sortează un output
grep caută apariția unui cuvânt/expresii regulate într-un text
uniq elimină duplicatele unui output
wc utilitar care numără liniile, caracterele, cuvintele
touch creează un fișier
file inspectează tipul unui fișier

Fișiere speciale

  • Fișierul /dev/null este un fișier care ignoră orice este scris în el.
  • Fișierul /dev/zero este un generator de octeți. Acesta generează atâția octeți cu valoarea zero (0) cât îi sunt ceruți.
  • Fișierul /dev/urandom este un alt generator de octeți. Acesta generează atâția octeți cu valoare random cât îi sunt ceruți.

Cuprins

1) Putem să ne găsim în situația în care ecranul terminalului nostru este plin cu rezultatele comenzilor rulate anterior sau cu opțiuni afișate de către auto-complete. Putem să curățăm ecranul folosind comanda clear. O alternativă mai rapidă este să folosim combinația de taste Ctrl+l. Aceasta va produce același rezultat (va curăța ecranul) și are avantajul că poate fi folosită în timp ce scriem deja o comandă.
2) Căutarea este case-sensitive. Putem să schimbăm acest comportament prin introducerea opțiunii -I în sesiunea interactivă, înainte de a porni căutarea. Dacă doriți să aflați mai multe despre opțiunile pe care le putem introduce apăsați tasta h într-o sesiune interactivă și căutați textul “OPTIONS”.
3) Putem folosi tasta ? pentru a porni o căutare de la poziția curentă către începutul paginii. Alternativ, putem naviga la începutul paginii prin apăsarea unei singure taste (g) și apoi pornim căutarea / de acolo.
4) Valoarea 0 nu înseamnă cifra 0. Valoarea 0 înseamnă caracterul (null) din tabelul ASCII. Caracterul 0 are valoarea 48 în tabelul ASCII.
uso/laboratoare/ac/laborator-05.txt · Last modified: 2020/11/17 11:14 by ioana_maria.culic
CC Attribution-Share Alike 3.0 Unported
www.chimeric.de Valid CSS Driven by DokuWiki do yourself a favour and use a real browser - get firefox!! Recent changes RSS feed Valid XHTML 1.0