Vim és a fülek (tabs)

Néhány hasznos tapasztalat a Vim fül kezelésével kapcsolatban! Minimum 7-es Vim szükséges.

Fülek létrehozása és bezárása

• :tabnew [fájlneve] – Ez létrehoz egy új fület a paraméterben megadott fájlévvel, ha a paraméter elmarad akkor ezt No Name felirattal jelzi is.
• :tabedit fájlnév – megadott fájlnév szerkesztése.
• :tabclose – aktuális fül bezárása.
• :tabonly – csak az aktuális fület hagyja nyitva, a többit bezárja.
• :tab split – az aktuális fület lemásolja egy új fülre.

Navigálás parancs módban:

• :tabp – Az előző fülre ugrik.
• :tabn – a következő fülre ugrik
• :tabfirst – az első fülre ugrik
• :tablast – az utolsó fülre ugrik
• :tabm 0 – az aktuális fület az első helyre teszi
• :tabm i – az i+1. fülre ugrik.

Normál módban is navigálhatunk

• gt – követkző fülre ufrik
• gT – előző fülre ugrik

A vim indításakor is létrehozhatjuk a kívánt tabokat.

vim -p elso.txt masodik.txt harmadik.txt

 

Git szerver létrehozása

Ebben a bejegyzésben egy Git szervert fogok létrehozni, ami egy Docker konténeren futó Debian Linuxon fog futni. A Git szervert ssh-n keresztül éri el, ezért kell egy ssh szerver, ami jelen esetben az openssh-server lesz. Telepítsük fel a szükséges csomagokat.

apt install openssh-server openssh-client openssh-known-hosts git

Ha sudo-zott rendszert használunk, akkor a sudo szükséges az elejére. Az openssh-server a telepítéskor létrehozza a szerveren az SSH privár és publikus kulcsokait, de generáljunk újakat.

rm -v /etc/ssh/ssh_host_*
dpkg-reconfigure openssh-server

Ezt követően indítsuk el az SSH szerverünket. Mivel ezen a konténeren nincs systemd, ezért a jól bevált init.d szkriptel teszem meg.

/etc/init.d/ssh start
[ ok ] Starting OpenBSD Secure Shell server: sshd.

Ellenőrizzük is a kliensen:

nmap 172.17.0.2 -p 22

PORT STATE SERVICE
22/tcp open ssh

Úgy tűnik működik. Most hozzunk létre a szerveren egy git nevű felhasználót:

useradd git
passwd git
Enter new UNIX password:
Retype new UNIX password:
passwd: password updated successfully
mkdir /home/git
chown git.git -R /home/git/

És kész! Próbáljuk is ki működik-e az ssh elérés a git felhasználóval a kliensről:

ssh git@172.17.0.2
git@172.17.0.2's password:
$

Igen! Ha ezzel megvagyunk másoljuk fel a kliens gép publikus SSH kulcsát a ssh szerverre, így jelszó nélkül tudunk belépni és a git szervernek parancsokat kiadni a kliensről. Ez többféle módon megtehető, én most ezt választottam:

scp ~/.ssh/id_rsa.pub git@172.17.0.2:/home/git/uploaded_key.pub
ssh git@172.17.0.2 "mkdir -p ~/.ssh && cat ~/uploaded_key.pub >> ~/.ssh/authorized_keys && rm uploaded_key.pub"

Majd a ha ezzel megvagyunk konfiguráljuk be az SSH szervert, hogy csak publikus kulccsal rendelkező felhasználókat engedjen be. Szerkesszük a /etc/ssh/ssh_config fájlt a szerveren.

PasswordAuthentication no
ChallengeResponseAuthentication no

Ezt követően indítsuk újra az ssh szervert.

/etc/init.d/ssh restart
[ ok ] Restarting OpenBSD Secure Shell server: sshd.

Ezek után már kulccsal fog beengedni. Térjünk vissza eredeti témánkhoz, a Git szerverhez. Ahhoz, hogy a Git szerver repóban parancsokat tudjunk végrehajtani léteznie kell  a szerveren az adott könyvtárnak és ott egy inicializált Git adatbázisnak. hozzunk létre a szerveren egy proba repót.

mkdir -p ~/git-repos/proba
git init --bare ~/git-repos/proba
ls -la ~/git-repos/proba
total 40
drwxr-xr-x 7 git git 4096 Jan 25 13:01 .
drwxr-xr-x 3 git git 4096 Jan 25 13:00 ..
-rw-r--r-- 1 git git 23 Jan 25 13:01 HEAD
drwxr-xr-x 2 git git 4096 Jan 25 13:01 branches
-rw-r--r-- 1 git git 66 Jan 25 13:01 config
-rw-r--r-- 1 git git 73 Jan 25 13:01 description
drwxr-xr-x 2 git git 4096 Jan 25 13:01 hooks
drwxr-xr-x 2 git git 4096 Jan 25 13:01 info
drwxr-xr-x 4 git git 4096 Jan 25 13:01 objects
drwxr-xr-x 4 git git 4096 Jan 25 13:01 refs

A jogosultságoknak és a tulajdonságoknak mindenképpen a git felhasználóhoz kell, hogy rendelve legyenek. Na, OK! Klónozzuk a távoli repót.

git clone ssh://git@172.17.0.2/home/git/git-repos/proba
Cloning into 'proba'...
warning: You appear to have cloned an empty repository.

Figyelem! Mindig a teljes elérési úttal adjuk meg a repó elérését! Ezt követően nézzük meg a kliensen a repó távoli beállítását.

cd proba
git remote -v
origin	ssh://git@172.17.0.2/home/git/git-repos/proba (fetch)
origin	ssh://git@172.17.0.2/home/git/git-repos/proba (push)

És akkor próbáljuk is ki a kliensről.

[anon117@anon117box proba]$ echo alma >> alma txt
[anon117@anon117box proba]$ git add .
[anon117@anon117box proba]$ git commit -m "commit üzenet"
[master (root-commit) 1b4e9da] commit üzenet
 1 file changed, 1 insertion(+)
 create mode 100644 alma
[anon117@anon117box proba]$ git push origin master
Counting objects: 3, done.
Writing objects: 100% (3/3), 217 bytes | 108.00 KiB/s, done.
Total 3 (delta 0), reused 0 (delta 0)
To ssh://172.17.0.2/home/git/git-repos/proba
 * [new branch]      master -> master

Úgy tűnik működik. A különböző rendszereken lehetnek eltérések, de az alap gondolat ugyanaz.

SimpleSSHD for Android

A SimpleSSHD androidos alkalmazást vizsgáljuk meg. Nem egy nagy kaland. Az ssh szerverre kulccsal tudunk belépni, ezt az sdcard0/ssh mappa alatt tárolja a jól ismert authorized_keys fájlban szereplő publikus kulcs segítségével. Szóval annyi a dolgunk hogy a PC-n lévő publikus kulcsunkat felmásoljuk a telefonra. Ehhez ad segítséget egy egyszer használatos jelszóval. Szóval:

~/.ssh $ scp -P 2222 id_rsa.pub user@192.168.1.212:authorized_keys

Aztán már mehet is a vigadalom:

ssh user@192.168.1.212 -p 2222

Ha már létezik authorized_keys létező kulcsokkal a szerveren, akkor a szerveren kell hozzáfűzni a publikus kulcsunkat az authorized_keys-hez.

~/.ssh $ scp -P 2222 id_rsa.pub user@192.168.1.212:myPubKey
cat myPubKey >> authorized_keys

Ehhez újból be kell majd lépj a telefon SSH szerverére, ezért a RESET KEYS menüpontban kérhetsz újabb egyszer használatos kulcsot. Lényeg, hogy létezzen a kulcsod az authorized_keys fájlban.

NodeJS – Telepítés Linuxon a nodejs.org oldalról

Ubuntu/Linux Mint alatt elég régi verzió van csomagban, ezért opcionálisan feltelepíthetjük a nodejs.org oldalról. Van aktuális (current) és hosszú karbantartású (LTS). Én most az LTS verziót használtam.

wget https://nodejs.org/dist/v8.9.3/node-v8.9.3-linux-x64.tar.xz

Ezt kitömöríted…

sudo tar -C /usr/local --strip-components 1 -xJf node-v8.9.3-linux-x64.tar.xz

Majd csinálsz néhány szimlinket a /usr alá:

sudo ln -s /usr/local/bin/node /usr/bin/node
sudo ln -s /usr/local/bin/node /usr/bin/node

node --version
v8.9.3

KDE 5 Plasma vs. old Nvidia VGA

 

Van egy ősrégi integrált nvidia VGA-s gép és szerettem volna már régen KDE 5 Plasma felületet rajta. Igazság szerint elég reménytelen volt eddig, mert még elindulni se nagyon akart. Viszont most neki kezdtem, hátha lesz valami. Lett is. Címszavakban elmesélem mi a helyzet.

1. lépésként kapcsold ki az összes Asztal effektust. Rendszerbeállítások – Asztal működés: Aszal effektusok. Így már kevésbé omlott össze a kép.
2. Aztán próbálkozhatsz a kompozítor állítgatásával. Rendszerbeállítások – Kijelző és monitor: Összeállító. Itt kipróbálhatod a Szakadás megelőzése (VSinc): Soha beállítást. Aztán ha még nem az igazi kikapcsolhatod a Kompozítor bekapcsolása induláskor pipát.
3. Aztán ugye jó lenne nvidia driver is, mert a nouveau ugyan eldöcögött, de jó lenne egy kis sebesség. Először megnéztem milyen legacy driverek vannak a 304-hez.

   sudo apt show -a nvidia-304 | grep Version
   Version: 304.135-0ubuntu0.16.04.1
   Version: 304.131-0ubuntu3

   Először a 131.el próbálkoztam:

   sudo apt install nvidia-304=304.131-0ubuntu3

   Ez nem ment, csak fekete képernyő volt meg kurzor. Nézzük a másikat:

   sudo apt install nvidia-304=304.135-0ubuntu0.16.04.1

   Ez már ment. Siker!

   Ha neked nem működne, akkor rakd vissza a nouveau drivert:

   sudo apt remove --purge nvidia-304=304.135-0ubuntu0.16.04.1

4. Igazából a feliratoknál is volt gond, sok helyen fura fekete foltok jelentek meg a tálcán. Ezen úgy segítettem, hogy a Noto betűtípust lecseréltem Dejavu Sans-ra, ezt már valamivel jobban rendereli.

Egy próbát megér.

Környezet: nvidia 7050, Linux Mint 18.2 (KDE 5)

Javascript: Barangolás a tömbök világában

Néhány alap utasítás, essünk túl rajtuk:

var arr = ["alma", "körte", "dinnye", "cseresznye", "barack"];

console.log("elemek száma: " + arr.length);
arr.push("banán"); // Hozzáad a végéhez egy elemet
arr.pop(); // elvesz egy elemet a végéről.
arr.unshift("narancs"); // az elejéhez ad hozzá eg elemet
arr.shift(); // az elejéből vesz el egy elemet

A tömb másolása:

var arr2 = arr // referencia másolás

Ez a művelet „csak” a tömb referenciáját másolja, vagyis mindkét változó címe ugyanarra a tömbre mutat. A valódi másolat készítéséhez a slice() metódust használjuk.

var arrcopy = arr.slice();

Így az egész tömb másolódik, viszont paraméterben megadhatjuk a másolás kezdetét és végét. var arrcopy2 = arr.slice(1,3);.

Na, de nézzünk érdekesebb dolgokat. a tömbünket bejárhatjuk egy forEach() metódus segítségével. A forEach végiglépked az elemeken és hogy mit csináljunk vele egy callback függvénnyel dönthetjük el.

arr.forEach(function(elem, index){
  console.log("index: " + index + ", elem: " + elem);
})

// index: 0, elem: körte
// index: 1, elem: dinnye
// index: 2, elem: cseresznye
// index: 3, elem: barack

A filter() metódus, amely visszaad egy olyan tömböt, amelynek az elemei átmentek a callback függvény által megadott teszten.

var cbFilter = function(value, key) {
  if (key > 2)
    return true;
}

console.log(arr.filter(cbFilter));

a find metódus azon első értékét adja vissza, amire a callback függvény teszten átmegy, hasonlóan működik a findIndex, ami a megtalált elem indexét adja vissza.

var cbFindValue = function(elem) {
  if (elem === "cseresznye")
    return true;
};

console.log(arr.find(cbFindValue));

var cbFindIndex = function(value) {
  if (value === "cseresznye")
    return true;
}

console.log(arr.findIndex(cbFindIndex));

A map metódus segítségével „átmappolhatjuk” a tömbünket, vagyis a tömb összes elemén végiglépked, és az értéken végrehajtja a callback függvényt, majd visszaadja az új tömböt.

var szamok = [1, 2, 3, 4, 5];

var cbMapNegyzet = function(value) {
  return value * value;
};

var negyzet = szamok.map(cbMapNegyzet);

negyzet.forEach(function(e){
  console.log(e);
})

Az entries metódus egy iterátort ad vissza. Az iterátor segítségével végiglépkedhetünk a tömb elemein.

var szamok = [1, 2, 3, 4, 5];

var iterator = szamok.entries();

for (var e of iterator) {
  console.log(e);
}

Az every metódus szintén végiglépked a tömb elemein, majd mindegyiken végrehajt egy callback függvényt, egy tesztet. Ha az összes elem átment a teszten, akkor true-val, ha nem, akkor false-zal tér vissza.

var szamok = [1, 2, 3, 4, 5];

cbEvery = function(e) {
	// return e < 2 && 4 > e // false
	return e > 0 // true
};

console.log(szamok.every(cbEvery));

 

Javascript: .call()

A hivatalos dokumentációhoz néhány példakód:

Szintaxis: fun.call(thisArg[, arg1[, arg2[, ...]]])

A lenti példában szerepel egy objektum, vagyis kettő (obj1, obj2). Ezek tartalmaznak egy-egy property-t. Jelen esetben műveletet akarunk végrehajtani az objektum tartalmával. Ezt legtöbb esetben úgy tennénk, hogy az objektum prototípusába beleraknánk egy metódust.

Viszont megoldhatjuk call metódus meghívásával. A metódusnak átadjuk paraméterben az objektumunkat, ezzel egy új környezetet (Context) alakítunk ki a függvény számára. Ha ezt nem tennénk meg (null), akkor az alapértelmezett this értéket kapja meg.

A lenti példában 3 különböző hívással mutatom be ezt a alkalmazási módot.

this.z = 100; 

function add(arg1, arg2) {
  console.log("Context: " + this)
  
  this.x = arg1;
  this.y = arg2;
  console.log("Z:" + this.z);
  this.z = 200;
  
  console.log("arg1:" + this.x);
  console.log("arg2:" + this.y);
  console.log("Z:" + this.z);
  
  return this.x + this.y + this.num;
}

var obj1 = {num:10}; var obj2 = {num:11};

console.log("Result: " + add(5, 6));
console.log("Result: " + add.call(null, 5, 6));
console.log("Result: " + add.call(obj1, 5, 6));
console.log("Result: " + add.call(obj2, 5, 6));

Kimenet:

Context: [object Window]
Z:100
arg1:5
arg2:6
Z:200
Result: NaN

Context: [object Window] // null
Z:200 // Itt 100 lenne, ha nem hívtam volna meg előtte a függvényt.
arg1:5
arg2:6
Z:200
Result: NaN // Itt nincs this.num, ezért ne értékelődik ki a kifejezés.

Context: [object Object] // obj1
Z:undefined // Az obj1 környezetben még nem szerepel a Z változó ekkor.
arg1:5
arg2:6
Z:200
Result: 21 // Itt már elérhető a this.num az új környezet miatt.

Context: [object Object] // obj2
Z:undefined
arg1:5
arg2:6
Z:200
Result: 22

A következő példánál egy úgynevezett  self-execution vagy self-invoking anonymous függvényt használok. Ha még nem hallottál volna róla, akkor röviden bemutatom.

Tehát ez egy önmagától lefutó függvény, vagyis a weboldal betöltése után automatikusan lefut. Szintaktikája hasonlít a sima függvénymeghívásához. Lényeges, hogy kerek „()” zárójelek között kell lennie.

(function() {
  // code
}())

Legyen egy példa is:

var i = "Piros";

(function(i) {
	console.log(i + " Alma");
}(i)) // Piros Alma

Látható, hogy a self-invoking függvény paraméterként megkapja az i változót, és a függvénytörzsben lévő anonymous függvény pedig „felhasználja”. Érdekes lehetőségek vannak benne, de most menjünk tovább.

var emberek =  [
  {nev: "Emese", kedvencSzin: "piros", haziKedvenc: "kutya"},
  {nev: "Béla", kedvencSzin: "zöld", haziKedvenc:  "macska"},
  {nev: "Erika", kedvencSzin: "lila", haziKedvenc: "teknős"}
];

for (var i = 0; i < emberek.length; i++) {
  (function(i){
    console.log("Név: " + this.nev + ", kedven szín: " + this.kedvencSzin + ", kedvenc állat: " + this.haziKedvenc);
  }).call(emberek[i])
}

function.call() Talán a fentiek elolvasása után nem kell magyarázat. A függvényen belül a lokális környezet (this) az emberek[i] property-kből érkezik.

Egy példa a prototype metódus hívására.

var obj1 = {num:10};
var stringBemenet = "alma";

function Person() {}

Person.prototype.printSomething = function(strBemenet) {
  return strBemenet + " --- " + this.num;
};

console.log(Person.prototype.printSomething.call(obj1, stringBemenet)); // alma --- 10

 

Blender: Aktuális MESH objektum – vertex és poligon lista

Ez a script az aktív objektum vertex és poligon adatait írja ki. A Blendert terminálból indítsd.

import bpy

obj = bpy.context.scene.objects.active

mesh = obj.data

feluletek = []
vertexek = []

for vert in mesh.vertices:
  vertexek.append((vert.co.x, vert.co.y, vert.co.z))

for face in mesh.polygons:
  faces = []
  for vert in face.vertices:
    faces.append(vert)
  feluletek.append(faces) 

print ('vertices = %s' % vertexek) 
print ('polygons = %s' % feluletek)

Blender: fokok, radiánsok

90° = 1.5708 radiáns
180° = 3.14159 radiáns
270° = 4.71239 radiáns
360° = 6.28316 radiáns
1° = 0.0174533 radiáns

Blender és Python

Első komolyabb bpy próbálkozás, kétváltozós függvény ábrázolása:

Python kód