# pingwinowanie $\int_{0}^{2} x^2 \,dx \cdot 3$

## zad 2
screen to SUPER narzędzie. więcej infromacji znajdziesz screen(1)
A tak na serio screen to narzędzie, które pozwala zarządzać emulatorami terminali.

Odpalamy je poleceniem **UWAGA** `screen` i naciskamy enter
Żeby nazwać robimy `screen -S <nazwa>`
Mamy tak jakby ~~świerzy~~ **świeży** :frog: terminal.
Żeby wyjść - `Ctrl+a, d`
żeby znowu wejść:
`screen -r`
Jeśli będziemy mięli więcej niż jeden screen to nam powie że **nwm o co ci chodzi debilu, masz kilka opcji**

screen -r
There are several suitable screens on:
        3961.pts-1.manjaro-linux        (Detached)
        3840.pts-1.manjaro-linux        (Detached)
Type "screen [-d] -r [pid.]tty.host" to resume one of them.

i logujemy się przez `screen -r 3961.pts-1.manjaro-linux`

żeby wyjść i zamknąć `Ctrl+d` (tak jakbyśmy wyłączali terminal), ewentualnie `Ctrl+a, :quit`
**Kopiowanie**
Wchodzenie w copy mode: `Ctrl+a, [`
potem tak jak w vimie możemy chodzić po terminalu, żeby zacząć zaznaczac musimy kliknąć spację i wchodzimy tak jakby w visual mode w vimie
żeby skopiować zaznaczone naciskamy enter

**Między tabami**
żeby stworzyć nowy terminal w screenie `Ctrl+a, c`
żeby się przełączać:

Ctrl+a, n  # następne
Ctrl+a, p  # poprzednie
Ctrl+a, <id:int>  # o danym numerze
Ctrl+a, "  # wyświetl wszystkie

I wtedy w każdej karcie mamy współdzielony schowek, także fajrant

## zad 3
Suprise, suprise -> to multiplexer terminali, w skrócie jak screen

### Basic commands
* tmux new -s \<name\> -> tworzy nowy terminal o nazwie \<name\>
* tmux ls -> wylistuj aktywne sesje
* tmux attach -t \<id\> -> połącz się do sesji o id
W tmuxie:
* ctrl+B, D -> detach
* ctrl+D -> detach i wyjdź
* ctrl+B, C -> nowa karta
* ctrl+B, P/N -> prev/next karta
* ctrl+B, & -> usuń kartę (trzeba dać AC y/n)

### Czerwony kapelusz poleca

Co do kopiowania itd to mi działa normalnie, zaznaczamy jak normalnie czyli myszka/strzałki idk jak się zaznacza w edytorze i jak w terminalu -> ctrl+shift+c/v

Potencjalnie trzeba odblokować myszkę w tmux.conf, ale ja akurat nie mam tego pliku i śmiga dimyślnie

## zad 6

autor: cez

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <getopt.h>
#include <pthread.h>
#include <unistd.h>

static int readInterval = 1;
static int writeToLogInterval = 60;
char logfilePath[200] = "/var/log/mystat.log";

pthread_mutex_t lock;

float minUsg=100, maxUsg=0, avgUsg;
int clearStatsFlag;

void logger(void *args){
	
	// clear logfile
	FILE *filePtr = fopen(logfilePath, "w");

	if(!filePtr){
		printf("Failed to launch logger. Couldn't create %s\n", filePtr);
		exit(EXIT_FAILURE);
	}

	fclose(filePtr);

	while(1){	
		sleep(writeToLogInterval);	

		pthread_mutex_lock(&lock);
		
		filePtr = fopen(logfilePath, "a");

		if(!filePtr){
			printf("Failed to launch logger. Couldn't open %s\n", filePtr);
			exit(EXIT_FAILURE);
		}
		
		char text[100];
		time_t now = time(NULL);
		struct tm *t = localtime(&now);

		// printf("Writing to log...\n");
		strftime(text, sizeof(text)-1, "%d/%m/%Y-%H:%M:%S", t);
		fprintf(filePtr, "[%s] %f %f %f \n", text, minUsg, avgUsg, maxUsg);

		clearStatsFlag = 1;
		
		fclose(filePtr);
		pthread_mutex_unlock(&lock);	
	}
}

int main(int argc, char **argv) {

	int c;
	
	while(1){
		static struct option long_options[] = {
			{ "period", 	required_argument, 0, 'p' },
			{ "interval", 	required_argument, 0, 'i' },
		        { "logfile",	required_argument, 0, 'f' },
			{ 0, 0, 0, 0 }	
		};
	
		int option_index = 0;

		c = getopt_long(argc, argv, "p:i:f:", long_options, &option_index);

		if(c == -1)
			break;

		switch(c){
			case 'p':
				writeToLogInterval = atoi(optarg);
		       		break;
			case 'i':
		 		readInterval = atoi(optarg);
	       			break;
			case 'f':
				strcpy(logfilePath, optarg);			
				break;
			default:
				abort();
		}
	}	

	printf("Options set: %d %d %s\n", writeToLogInterval, readInterval, logfilePath);

	char buffer[100];
	char *seperators = " ,";

	float lastSum=-1, lastIdle=-1;

	float usageSum = 0;
	int counter = 0;


	// launch logger

	pthread_t loggerThread;

	if (pthread_mutex_init(&lock, NULL) != 0) {
        	printf("\n mutex init has failed\n");
        	return 1;
    	}	

	int error = pthread_create(&loggerThread,
                               NULL,
                               &logger, NULL);
        if (error != 0)
            printf("\nThread can't be created :[%s]",
                   strerror(error));


	for(;;){	
	
		pthread_mutex_lock(&lock);

		FILE *file = fopen("/proc/stat", "r");

		int n = fgets(buffer, 100, file);
		
		char *schowek = strtok(buffer, seperators);
		schowek = strtok(NULL, seperators);
			
		int cnt = 1;

		float sum = 0;
		float idle = 0;

		while (schowek != NULL){	
			float val = (float)atoi(schowek);

			if(cnt == 4)
				idle = val;
			else
				sum += val;
					
			if(cnt >= 7)
				break;
			schowek = strtok(NULL, seperators);
			cnt++;
		}

		float usage =  100.0f - (100.0f*(idle - lastIdle) / (sum + idle - lastSum - lastIdle));

		if(lastSum != -1){
			printf("CPU usage: %f%\n", usage);
		}
		
		if(minUsg > usage)
			minUsg = usage;
		if(maxUsg < usage)
			maxUsg = usage;
		usageSum += usage;
		counter++;

		avgUsg = usageSum / (float)counter;

		if(clearStatsFlag){
			minUsg = usage;
			maxUsg = usage;
			avgUsg = usage;
			counter = 0;
			usageSum = 0;
			clearStatsFlag = 0;
		}

		lastSum = sum;
		lastIdle = idle;
		fclose(file);

		pthread_mutex_unlock(&lock);

		sleep(readInterval);
		
	}

	pthread_join(loggerThread, NULL);
	pthread_mutex_destroy(&lock);

}

## zad 11

mkdir ~/.bashrc.d
nano aliases 
nano base
nano colors

# skopiujmy coś do tych plików 
# i dopiszmy do bashrc

for file in ~/.bashrc.d/*; do
    source "$file"
done

## zad 12
### run-parts
To taki (nie)mądry skrypcik, który odpala wszystkie skrypty/programy w podanym katalogu (skipuje wszystkie inne pliki)
Skrypty są wykonywane w kolejności alfabetycznej (jesli nie odpalimy z flagą, aby tak nie robił)

Przyjmuje katalog jako argument

ma jakieś losowe opcje w stylu:
* -v -> wypisz nazwę skryptu zanim go wykonasz
* --test -> taki dry-run, wypisz nazwę, jakbyś wykonywał, ale nie wykonuj
* --list -> wylistuj wszystkie skrypty, ale ich nie wykonuj (nie może być użyte z --test, ale nie rozumiem różnicy)
* --report -> prawie jak -v, ale wypisuje nazwy tylko tych, które wypisują output
* --reverse -> odpala alfabetycznie DESC, a nie ASC
* --regex umożliwia wyszukiwanie/odpalanie tylko skryptów z jakimś regexem

### dlaczego słaby w poprzednim?
Chyba chodzi o to, że on odpala te skrypty. Kiedy odpalamy nowe skrypty to one odpalają nowy shell. Ale my chcemy konfigurować shell, więc chyba tutaj są problemy. A kiedy robimy source to dodajemy obecnego shella, więc w sumie git

### Sprawdzenie jakie wykonywane raz na dobę

run-parts --list /etc/cron.daily
# u mnie akurat nie ma nic w daily, 
# ale mam coś w hourly
run-parts --list /etc/cron.hourly

## zad 13

Nwm ale samo zrobienie Zombie i zobaczenie, że rzeczywiście tak jest

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>

int main() {
    pid_t child_pid;

    child_pid = fork();

    if (child_pid == -1) {
        perror("Failed fork");
        exit(EXIT_FAILURE);
    }

    if (child_pid == 0) {
        printf("Child: PID = %d\n", getpid());
        
        sleep(5);
        
        exit(EXIT_SUCCESS);
    } else {
        printf("Parent: PID = %d\n", getpid());
        sleep(100);
    }

    return 0;
}

I teraz bierzemy PID dziecka

ps -q <PID_DZIECKA> -o state=   

Jeśli wypisuje się Z to zombie i fajrancik

## zad 14

top wyświetla procesy :smiley_cat:

To może jakiś szybcior :eyes:
### Header
Mamy jakieś statystyki i co one kolejno onzaczają
* system time
* uptime
* #users
* Avg load (różne strony podają jakieś różne definicje) przez 1,5,15 min
* Jakieś info ile tasków i ile w jakim stanie
* Zużycie CPU
* us -> user
* sy -> kernel
* Nice? https://en.wikipedia.org/wiki/Nice_%28Unix%29 jak długo zajmował się procesami które mają manualnie ustawione Nice (to chyba po prostu priorytet)
* id -> idle
* wa -> waiting time
* hi -> hardware interrupt
* si -> software interrupt
* st -> czas dla maszyn wirtualnych (steal)
* Pamięć chyba jasna czym jest free, used itd
### Reszta
Co my tu mamy
* PR -> priority
* NI -> ten współczynnik Nice
* VIRT -> pamięć którą zajmuje proces
* RES -> zajęta pamięć, ale tylko w RAM
* SHR -> shared memory
* S -> state
* %[CPU|MEM] -> zużycie % względem całości
* TIME+ -> ile czasu CPU zużył proces
* COMMAND -> jaka apka wywołała

Dobra jak już wiemy co widzimy to może jakaś
### Nawigacja
* Zaskakująco poruszamy się strzałkami :shocked_face_with_exploding_head:
* shift+p -> sort by %CPU
* shift+m -> sort by %MEM
* shift+t -> sort by time
* shift+n -> sort by ID
* shitf+r -> sort in ASC (domyślnie jest DESC)
* shift+v -> tworzy 'drzewko' rodzic->dziecko
* g -> zmiana widoku (mamy 4 do wyboru)
* h -> otwórz help menu
* u -> filter by user
* t -> zmienia wygląd CPU w headerze
* m -> zmienia wygląd MEM w headerze
* k -> prosi o ID i zabija gnojka, domyślnie SIGTERM, może że forcujemy to wtedy SIGKILL
* q -> exit

### Jakaś personalizacja
1. shift+A -> wejdź w edycję
2. shift+Z -> wybór kolorków
3. Wybieramy zgodnie z instrukcją (Literami ustalamy co, cyferkami jaki kolor)
4. Commit enterem i cieszymy się super kolorkami
5. Potencjalnie możemy kolorować jeszcze inne widoki klikając a/w i jak w 3

Żeby zapisać do pliku to lecimy shift+W i fajranick chyba
Jeśli chcemy coś ponad kolory tylko np dodajmy jeszcze to, że zawsze chcemy posortowane po pidzie to lecimy shift+n i shift+w żeby zapisać

Osobno persolanizuje się każdy widok G[1-4]!

Docelowo mamy np. coś takiego, że czerwony napis w headerach, wartości białe, nazwy kolumn niebieskie i zielone wartości

## zad 15

ps wyświetla obecnie działajace procesy, a pstree stara się robić to samo ale w formie łądniejszego drzewka

### Jakieś flagi dla ps
* -e -> wyświetla wszystkie procesy
* -u \<username\> -> procesy użytkownika
* -F -> daj wszystkie kolumny jakie są
* f/--forest -> zrób coś na kształt drzewka
* aux -> pełne info o procesach (w formacie BSD)

### Jakieś flagi dla pstree
* -a -> pokaż argumenty z cmd
* -p -> dodaj PID procesu
* -c -> wyłącz kompaktowanie podprocesów (domyślnie są kompaktowane gdzie się da)
* -n -> sort po PID
* -T -> pokazuj tylko procesy, ukryj wątki