Web alkalmazás Hibernate + Vaadin segítségével

Diplomamunkám témája a Jáva objektumok perzisztens kezelése volt, mely kapcsán a Hibernate keretrendszert tanulmányoztam és alkalmaztam.
Röviden a perzisztenciáról annyit mondanék, hogy egy Java program futása közben létrejövő objektumokat a perzisztencia kezelő keretrendszer segítségével nagyon egyszerűen tárolhatók, kezelhetők adatbázisokban. Ezzel gyakorlatilag leveszi a programozó válláról azt a terhet hogy az adatbáziskezelés aprólékos feladatával foglalkozzon. Így sokkal inkább a probléma megoldásra koncentrálhatunk. XML fájlok segítségével vagy @nnotációk használatával konfigurálható hogy az objektumok adatmezői melyik adatbázis, melyik táblájában tárolódjanak.
Több keretrendszer létezik erre a feladatra, melyeket objektum-relációs leképező (Object Relation Mapping, ORM) rendszereknek nevezünk. Az egyik ilyen rendszer a Hibernate, melyet széles körben használnak.
Magáról a Hibernate-ről most részletesen nem szándékoztam írni, talán majd egy későbbi alkalommal indítok egy ilyen cikksorozatot.

A jelen jegyzet oka csupán annyi hogy hogyan hoztam létre az első Vaadin - Hibernate háromrétegű alkalmazást.

Természetesen a Hibernate is JAR fájlok formájában érhető el. Ezeket a JAR-okat kell a projektünkhöz kapcsolni és már használhatjuk is a rendszert. Ezt a WAR fájlok definíciója szerinti helyre kell tenni. Ha EE projektben dolgozunk akkor a WEB-INF/Lib alá kell importálni a Hibernate JAR-okat, hogy az alkalmazásszerver (AS, mint pl a Tomcat) használni tudja.
Ezt két módon tehetjük meg. Az első módszer szerint a projekt WEB-INF/Lib mappájába importáljuk a fájlrendszerből a szükséges JAR fájlokat. Ez a Hibernate lib könyvtárában lévő JAR-ok és a használt adatbáziskezelő JDBC elérését biztosító JAR.

A másik módszer szerint a projekt Properties-t indítva a Deployment Assembly opción belül az Add.. gombbal tudjuk a megfelelő helyről betölteni.

Én a példámban létrehoztam egy Vaadin projektet, majd a kis demó programot átírtam úgy hogy a gomb kattintásra generál egy egyedi azonosítót (osztályváltozóba), majd egy üzleti logikának felfogható másik osztályból példányosít egy objektumot ami felépíti a Hibernate kapcsolatot, illetve ennek az addNewRecord nevű metódusa letárolja a generált azonosítóval az objektumot.

Vaadin framework és Apache Tomcat 8 telepítése Eclipse Luna alá

Az utóbbi kommentekben a Java EE futtató és fejlesztői környezet kialakításával foglalkoztam. Gyakorlatilag van egy működő Apache Tomcat kiszolgáló ami alá már lehet telepíteni Java EE alkalmazásokat. Ez mellett van egy Eclipse IDE for Java EE developers fejlesztői környezet telepítve, amivel professzionális keretek között lehet Java programokat készíteni.

Az IDE azonban még nincs teljesen felkészítve. Ahhoz hogy igazán hatékonyan tudjunk dolgozni, szerencsés ha magában az IDE-ben is van egy működő webkonténer (pl. Apache Tomcat). Most ugyanis tesztelni úgy tudunk, ha a projektünket kiexportáljuk WAR fájlba, majd a telepített Tomcat adminisztrációs felületén deployoljuk (telepítjük) a projektünket. Ez így döcögős módszer lenne.
Ezért most első lépésben telepítjük a Tomcat-et az Eclipse alá.
(Eclipse Luna és Apache Tomcat 8.0.9 verziókkal, Ubuntu 14.04 Desktop rendszeren dolgozom)

1. Töltsük le és csomagoljuk ki valahová a Tomcat-et.
2. Indítsuk el az Eclipse-t.
3. Telepítsük a Luna update site-ról (http://download.eclipse.org/releases/luna) a JST Server Adapters és JST Server Adapters Extensions modulokat
   Nyissuk meg a Help/Install new softwares... menüt.
   A megjelenő ablakban válasszuk ki az alábbi képen látható módon a telepítendő modulokat
   
   

   

   JST Server Adapter telepítése

   Next, Next, Finish után települnek a modulok.
   
4. Ez után a Help/Preferences menüre kattintva az alábbi képek alapján rendeljük hozzá az Eclipse-hez az első pontban kicsomagolt Apache Tomcat-et.
   
   

   

   Server/Runtime Environment kiválasztása, majd Add... gomb

   
   

   

   Apache Tomcat v8.0 kiválasztása, majd Next

   
   

   

   A Browse... gombbal válasszuk ki azt a könyvtárat
   ahová a Tomcat-et kitömörítettük, majd Finish

Ezzel készen van az Eclipse a Server használatára úgy hogy az IDE-n belül tudjuk tesztelni, indítani az EE alkalmazásainkat.

Természetesen a Servers fülön még létre kell hozni egy példányt hogy hivatkozni lehessen rá.

A Servers munkaterületen jobb egérgomb, majd New/Server

Válaszuk ki a Tomcat 8.0 Server-t, majd Finish

Most már tényleg kész a szerverpéldány a futtatásra. El is indíthatjuk a servers fülön ha kijelöljük és megnyomjuk a zöld háromszög (Start server) ikont.

Az igazán hatékony EE fejlesztéshez valamilyen framework használata ajánlott. A neten olvasgattam ezekről és nekem a Vaadin framework tetszett meg a leginkább. Segítségével gyorsan lehet AJAX komponenseket felhasználva tetszetős felhazsnálói felületeket létrehozni. Sok leírás, könyv, tutorial lehető fel az interneten, így könnyen tanulható. A profik azt mondják hogy nem igazán szerencsés, mert gyakorlatilag egy olyan bonyolult oldalakat generál, amit nehéz módosítgatni. Na én most nem szeretném módosítgatni és első frameworknek szerintem nagyon jó. 

Szóval most a Vaadin telepítése következik.

Ez sem túl bonyolult, csupán a már ismert Help/Install new software... menüt választva a Vaadin update site-ot beállítjuk (http://vaadin.com/eclipse) és ott kijelöljük a Vaadin plugin-t. Ezután a végtelenségig bonyolult Next, Next, Finish nyomogatás következik és települ a plugin. A végén az  Eclipse kéri hogy had induljon újra. Hagyjuk jóvá.

Ezek után a File/New/Project.../Vaadin csoportból ki tudjuk választani a nekünk tetsző verziót, ezzel elindítva a egy új Vaadin projektet.

Ha egy üres projektet hozunk létre, akkor Run/Run as.../Run on Server menüvel a létrehozott Tomcat kiszolgálón tudjuk futtatni.

Most már komplett környezetünk van. Semmi nem akadályoz meg bennünket hogy komoly vállalati Java EE alkalmazásokat készítsünk!

Apache Tomcat 8 telepítése Ubuntu 14.04 alá lépésről-lépésre

Az előzőekben általánosságban írtam a Tomcat telepítéséről. Most a pontos rendszer struktúrába illeszkedő telepítést írom le, a teljes szolgáltatás indítással, és leállítással együtt.

Jelenleg a legfrissebb Tomcat verzió a 8.0.9. Ezzel fogom bemutatni a telepítést.
Természetesen rendelkeznünk kell működő Java-val. Nálam az Oracle Java 8 van telepítve.
(java -version parancs kiadásával ellenőrizhető)

1. Terminálban dolgozunk, indítsuk el.
2. Töltsük le a Tomcat-et a /tmp könyvtárba, majd csomagoljuk ki
   sudo cd /tmp
   sudo wget http://archive.apache.org/dist/tomcat/tomcat-8/v8.0.9/bin/apache-tomcat-8.0.9.tar.gzsudo tar -xvf apache-tomcat-8.0.9.tar.gz
3. Mozgassuk a teljes kicsomagolt könyvtárstruktúrát a /usr/local/ könyvtárba
   sudo mv apache-tomcat-8.0.9 /usr/local
4. Állítsuk be a Tomcat adminisztrátor felhasználót. Ezt a /usr/local/apache-tomcat-8.0.9/conf/tomcat-user.xml fájlban tehetjük meg. Adjuk hozzá a következő sorokat a fájlhoz, valahol a ... blokkon belül. Az itt megadott felhasználónév/jelszó párossal tudunk majd belépni a webes konfiguráló felületre.
   
   
   
5. Hozzuk létre a /usr/local/apache-tomcat-8.0.9/bin/setenv.sh parancsfájl. Ebben tudjuk beállítani a szükséges környezeti változókat. A JRE_HOME szükséges és a Java könyvtárára kell hogy mutasson. A CATALINA_PID és a CATALINA_OPTS ahhoz kell hogy távoli debugolást tudjunk végezni a szerver által futtatott komponenseken. Az alábbi legyen a fájl tartalma:
   #!/bin/bash
   JRE_HOME=/usr/lib/jvm/java-8-oracle
   CATALINA_PID="$CATALINA_BASE/tomcat.pid"
   CATALINA_OPTS="-agentlib:jdwp=transport=dt_socket,address=8081,server=y,suspend=n"
6. Állítsuk be a script attributumait
   sudo chmod 755 /usr/local/apache-tomcat-8.0.9/bin/setenv.sh
7. Hozzuk létre az indító/leállító/újraindító scriptet. Ehhez a /etc/init.d/tomcat809 fájlt hozzuk létre és a tartalma legyen az alábbi:
   
   #!/bin/bash
   
   export CATALINA_HOME=/usr/local/apache-tomcat-8.0.9
   PATH=/sbin:/bin:/usr/sbin:/usr/bin
   
   start() {
       sh $CATALINA_HOME/bin/startup.sh
   }
   
   stop() {
       sh $CATALINA_HOME/bin/shutdown.sh
   }
   
   case $1 in
       start|stop) $1;;
       restart) stop; start;;
       *) echo "Run as $0 "; exit 1;;
   esac
8. Fájl attributumokat állítsuk be 
   sudo chmod 755 /etc/init.d/tomcat809
9. Ezek után már indíthatjuk/leállíthatjuk/újraindíthatjuk a tomcat-et, a start, stop, restart paraméterekkel meghívva az indító scriptet. Most indítsuk el 
   sudo /etc/init.d/tomcat809 start
10. Ha azt szeretnénk hogy rendszerindításkor automatikusan induljon akkor frissítsük az rc.d-tsudo update-rc.d tomcat809 defaults
11. Ezek után a localhost:8080 URL-el bejön a gépünkön futó Tomcat induló oldala. A menedzselő gombok megnyomásakor a tomcat-users.xml-ben megadott felhasználónév/jelszó adatokkal tudunk belépni.

Java EE fejlesztői környezet kialakítása

A Java Enterprise Edition (EE) nem más mint a komoly nagyvállalati szoftverek készítésére szánt fejlesztői környezet.
Mivel a nagyvállalati szoftverek jellemzően valamilyen kliens-szerver architektúrát valósítanak meg, ezért szükségesek olyan komponensek a fejlesztői környezethez, amivel a nagyvállalati architektúrára készített alkalmazásokat futtatni lehet.
A JAVA desktop alkalmazásokhoz nem kell más, mint egy JRE (Java Runtime Environment) ami végülis maga a Java virtuális gép (Java Virtual Machine, JVM). Ez mindenképp szükséges ahhoz hogy a helyi gépen java programok futtassunk.

Példaként említhető talán a mindenki által ismert adóbevallás készítéséhez használt AbevJava nyomtatványkitöltő alkalmazás. Ha ezt futtatni akarjuk ahhoz szükséges a Java telepítése.

Az operációs rendszerünkhöz illeszkedő JRE telepítőt a Java oldaláról tudjuk letölteni, majd telepíteni.
Miután telepítettük a futtatási környezetet akkor rendszerünkben a java -version parancs kiadásával ellenőrizhetjük hogy működőképes-e a rendszerünk, tudunk-e Java programokat futtatni. A parancs kiírja az elérhető Java futtatási környezet verzióját. Amennyiben nincs elérhető java környezet, akkor értelmetlen parancsnak tekinti a rendszer az utasítást.

java -version parancs hatására megtudhatjuk hogy milyen verziójú futtatókörnyezet érhető el a számítógépen

Mint látható az én gépemen a Java SE 1.8 van telepítve. Ez azt jelenti hogy a számítógépemen tudok futtatni java programokat (pl remekül tudok adóbevallást készíteni az AbevJavával :) )

Az első lépés megvan. Igen ám, de mi nemcsak futtatni szeretnénk Java programokat, hanem készíteni is. Általánosságban elmondható hogy, ahhoz hogy egy adott nyelven megírt programot a számítógép számára futtathatóvá tegyünk, szükséges egy úgynevezett fordítóprogram (compiler), amivel a forráskódot át tudjuk alakítani olyan gépi kódú utasításokká, hogy azt a célszámítógép képes legyen végrehajtani.
Esetünkben szükséges egy Java fordító, ami a Java forráskódú programunkat átalakítja olyan kódsorozattá amit a célszámítógép, azaz a Java virtuális gép (JVM, ami a futtatási környezet része) végre tud hajtani. Ez a javac nevű program, ami a Java Development Kit (JDK, Java fejlesztői készlet) része. A JDK-t le lehet tölteni a Java honlapjáról, szintén az operációs rendszerünknek megfelelőt válasszuk.

Miután telepítettük a javac parancs kiadásával ellenőrizhetjük.

javac - version parancs kiadásával a java fordító verziószámát ellenőrizhetjük

Ezek után már tudunk java programot írni, azt le tudjuk fordítani és tudjuk futtatni is.
Próbáljuk is ki ezt a méltán híres "Hello world!" példaprogrammal.
A kedvenc szövegszerkesztőnkkel (ne a Word-el!!!) hozzuk létre a java forrásprogramot.

Én az alábbi példában a példa rövidsége miatt közvetlenül parancssorból fogom begépelni a kódot egy Linux terminálból. Windows alatt az első cat >HelloWorld.java parancs helyett a copy con HelloWorld.java parancsot kell kiadni. Nyilván nagy projekteknél nem ezt a módszert kell alkalmazni.

A híres Hello, Wolrd! program megírása, fordítása és futtatása

A programkészítés menetét is szépen bemutatja a fenti képernyőrészlet:

• Szerkesztés (edit): először a program forráskódját készítjük el. Ekkor standard ASCII szövegfájlt kell készítenünk, tehát erre a célra nem a Microsoft Word a legjobb megoldás. A példában egy egyszerű terminálparanccsal billentyűzetről közvetlenül a fájlba küldtük a begépelt karaktereket, majd a kód beírása után a CTRL-Z billentyűkombinációval tudjuk a fájl vége karaktert beírni és a szerkesztést befejezni. Ekkor előáll a forráskód, amit a fordítóval lehet tovább kezelni.
• Fordítás (compile): a fordítási művelet a forráskódot átalakítja a célgép számára értelmezhető utasítássorozattá. Java esetében az úgynevezett bájtkódot kell előállítani, amit a Java virtuális gép (ez a célgép) végre tud hajtani. A fordítást az előzőekben a JDK telepítése után a rendszerünkben elérhetővé vált javac paranccsal tudjuk végrehajtani. Paraméterül a HelloWorld.java fájlt adjuk meg természetesen. A kiadandó parancs: javac HelloWorld.java
  A fordítás eredményeként létrejön a HelloWolrd.class fájl, amit már a JVM végre tud hajtani.
• Futtatás (run): a fordító által létrehozott programot már tudjuk futtatni mégpedig a JRE telepítése kapcsán rendszerünkben elérhetővé vált java parancs segítségével. Paraméterül kiterjesztés nélkül kell megadni a .class fájlt. Esetünkben a parancs: java HelloWorld
  Eredményül a program kiírja a Hello, World! szöveget, majd kilép.

A cikk címe szerint Enterprise fejlesztői környezet kialakításáról kellene szólni és eddig csak egy desktop parancssori alkalmazást készítettünk. Valójában már most kész a rendszerünk és tudunk Java EE programot készíteni, hiszen a Java futtató és fejlesztői környezet képes erre. Azonban a szerver oldalon picit másképp történik a java szerver oldali programok futtatása. Valójában nem közvetlenül a JVM vezérli a program végrehajtását, hanem egy úgynevezett alkalmazás szerver (AS, Application Server). Ez egy olyan konténer, melyben a szerver oldali java alkalmazások betölthetők, majd a hálózaton keresztül érkező kérésekre reagál. Jellemzően HTTP kérések érkeznek a kliensek felől, amit az AS fogad, majd átad az általunk megírt szerver oldali komponensnek. Ez a komponens elvégzi a kért műveletet, majd egy HTTP üzenetként visszaküldi a kliensnek az eredményt. A kliens fogad és a kliens oldali komponens megjeleníti az eredményt.

Nagyjából ezek a lépések. Ahhoz hogy mindezt fejlesztőként meg tudjuk csinálni szükségünk van egy alkalmazás szerverre (AS) is. Csinálhatnánk úgy is hogy a szerver oldali részt lefordítjuk, majd feltöltjük egy távoli AS-re és a kliensünkkel rácsatlakozunk. Ennél sokkal jobb megoldás, hogy a saját gépre telepítünk egy AS-t és azon futtatjuk a komponensünket. Na ez az ami hiányzik a valódi Java EE fejlesztői környezethez.

Többféle AS létezik ami ki tud szolgálni Java komponenseket. Kettőt említek meg és abból egyet fogunk bekonfigurálni. Az egyik a GlassFish nevű, valóban nagy teljesítményű és professzionális alkalmazás szerver. Az Oracle fejleszti és ez a Java referencia szerver. 

Ennél egyszerűbb, de továbbra is nagy teljesítményű eszköz az Apache webszerver fejlesztőitől az Apache Tomcat nevű alkalmazásszerver. Konfigurálása, futtatása egyszerű, ezt fogom bemutatni a következőkben.

A Tomcat telepítése nagyon egyszerű. Le kell tölteni a szükséges verziót az Apache honlapról és ki kell csomagolni.

Ezután a Tomcat könyvtár alatt lévő bin könyvtárba létre kell hozni egy setenv.sh (windows alatt setenv.bat) parancsfájlt, amibe csupán ki kell adni néhány környezeti változó beállítására szolgáló parancsot. Linux esetében ezt tartalmazza a fájl:

#!/bin/sh

CATALINA_HOME=/tomcat-elérési-utja/bin

JRE_HOME=/var/lib/jre/java-8-oracle

Ezek után a tomcat könyvtárán belül a bin könyvtárban ki kell adni a ./startup.sh parancsot. Ez elindítja a Tomcat-et:

Apache Tomcat indítása

Ezek után a Tomcat figyeli a 8080-as porton érkező HTTP kéréseket. Ezt ellenőrizhetjük ha a böngészőnkbe behozzuk a http://localhost:8080 URL-t.

Fut a Tomcat és válaszol a 8080-as porton

Amennyiben ezt elértük, akkor készen vagyunk az Enterprise alkalmazások futtatására. Nyilván ha adatbázissal dolgozunk akkor kell valamilyen SQL szerver (MySQL, Postgress) is, de az már alkalmazás specifikus dolog.

Ami még a professzionális fejlesztéshez kell, az egy professzionális integrált fejlesztői környezet (IDE). Erre a célra az Eclipse-t javaslom.
Ennek telepítése sem bonyolult. Le kell tölteni az Eclipse honlapjáról a Java EE developer IDE-t és ki kell csomagolni. Ennyi.

A végén meg kell említenem a http://appdev.bedok.hu/cikk/ECLIPSE_JAVA cikket, ahol rengeteg jó ötletet és gondolatot találtam az EE fejlesztéssel kapcsolatban. Egy részét az ott leírtaknak felhasználtam a cikkben. 

Android mentés adb-vel, root nélkül

Az Android 4.x egyik újdonsága, hogy lehetőséget ad a teljes rendszer, vagy annak egyes elemeinek mentésére, úgy hogy nem kell a készüléken root jogosultság.
Az alkalmazások mentésével eddig sem volt probléma. Fájlkezelők is képesek voltak a telepített alkalmazások mentésére és visszaállítására, de ezek a mentések csak a programfájlokról csináltak másolatot, amit egyszerűen vissza lehetett állítani.

A most bemutatásra kerülő módszer az alkalmazásokat és azok adatait is menti. Így pl ha lementünk egy jegyzetelő alkalmazást, akkor a jegyzetekkel együtt menti, visszaállításkor pedig természetesen minden rendelkezésre fog állni, a program maga és az adatok is.

Ehhez a művelethez azonban (egyelőre) nincs grafikus felület, legalábbis nem ismerek. Ez lehet hogy zavaró, vagy elriaszt egyeseket, de igazán egyszerű a dolog és szerintem könnyen elvégezhető.

Amire szükségünk van:

• Az Android 4.x vagy magasabb rendszerrel rendelkező készülék
• Működő USB kapcsolat egy számítógép és a készülék között. (Linux-ot javaslok ott nincs probléma)
• Működő ADB

Nézzük mik is ezek a fentebb felsorolt dolgok.

Működő kapcsolat a számítógép és a készülék között azért szükséges, mert a mentést a számítógépről indítjuk és maga a backup fájl is ott fog keletkezni. A visszatöltés is ugyan így történik majd.

Windows alatt tudom hogy folyton problémák vannak azzal hogy megfelelő driver van-e telepítve, látja-e a számítógép a készüléket. Korábban én is Windows-t használtam és a Galaxy S készülékkel valóban előfordultak kapcsolódási problémák, hogy most mi a helyzet azt nem tudom, ugyanis jópár éve Linux-ot használok. Linux-al sokkal tisztább ez a dolog, ugyanis nincs szükség semmiféle driverre!

Akár windows akár Linux rendszert használunk, szükség lesz még az úgynevezett ADB eszközre. Ez nem más mint egy segédeszköz az Android készülékek számítógépről történő direkt vezérlésére. Teljes nevén Android Debug Bridge.

Az ADB egy parancssori alkalmazás, amit jól beparaméterezve különféle csoda dolgokat lehet elérni az Android készüléken.

Ubuntu Linux alatt az ADB-t telepíthetjük az android-tools csomag telepítésével, vagy az AndroidSDK telepítésével is megkapjuk. Ehhez adjuk ki a következő parancsot:

apt-get install android-tools*

Ezzel települ minden ami szükséges.

A működőképességet és a kapcsolat meglétét ellenőrizhetjük, ha USB kábellel csatlakoztatjuk a készüléket a számítógéphez és kiadjuk a következő parancsot:

adb devices 

A parancs kilistázza a csatlakoztatott készülékeket. Ahhoz hogy kapcsolódni tudjon az adb szükséges, hogy be legyen kapcsolva az USB hibakeresés opció a készüléken (Fejlesztői lehetőségek menüben)

Ha nincs még bekapcsolva az USB hibakeresés az készüléken akkor nem listáz készüléket. Ha bekapcsoljuk az opciót, akkor listázza a készüléket, ahogy a következő képen látható:

Az első parancs kiadásakor nem volt bekapcsolva az USB hibakeresés, majd bekapcsoltam és újból futtattam a parancsot. Ekkor már listázta a készüléket.

Ezek után készen áll minden a mentésre.

Az ADB rengeteg funkcióval bír. A teljes leírás itt található. Most az adb backup és adb restore funkciók bemutatása következik.

Mentésre szolgáló parancs és lehetséges paraméterei:

adb backup [-f ] [-apk|-noapk] [-shared|-noshared] [-all] [-system|nosystem] []

-f : így adjuk meg a mentés fájlnevét. A fájl nevének ab kiterjesztésűnek kell lennie.

-apk vagy -noapk: ezzel szabályozhatjuk hogy mentse-e a telepítő fájlokat vagy sem. Alapértelmezésben nem menti.

-shared vagy -noshared : ezzel állítható hogy a külső memóriatár mentére kerüljön-e. Alapértelmezésben nem kerülmentésre.

-all : ezzel az opcióval minden lehetséges dolog mentésre kerül.

-system vagy -nosystem : a rendszer alkalmazások mentését szabályozhatjuk. Alapértelmezésben menti ezeket. Ezt érdemes lehet kikapcsolni, hiszen ha pl másik ROM-ra váltunk akkor összeakadhatnak a rendszer alkalmazások a mentés visszaállításakor.

listában megadhatjuk hogy mik azok a csomagok (alkalmazások) amikről mentést szeretnénk csinálni. Így konkrétan tudjuk paraméterezni hogy mely programok szerepeljenek a mentésben.

Egy jó általánosan használható paraméterezés lehet:

adb backup -noapk -nosystem -all -f ~/adbmentesek/backup.ab

A parancs kiadásakor meg kell erősíteni a mentést a készüléken:

Ezután rövid időn belül megtörténik a mentés és a megadott helyen megtalálható a backup fájl.

A visszaállítás a következő paranccsal történik:

adb restore

ahol a helyére a backupfájlt kell megadni. Én teljes elérési utat adok meg mindig.

adb restore ~/adbmentesek/backup.ab

Szintén megerősítést kér a készülék, majd visszaállítja a mentett adatokat.

Fantasy gyüjtögetős kártyajátékok

1995-ben Győrben nyílt egy fantasy és szerepjáték bolt, amit meg is látogattam. Megláttam egy érdekes kis dobozt amiben kártyák voltak. Azt mondta az eladó hogy ez egy újfajta stratégiai játék. Minden csomag más lapokat tartalmaz és a lapoknak vannak ritkasági jellemzője is. Lehet gyűjtögetni és cserélgetni másokkal és a lényeg hogy nagyon jókat lehet vele játszani. Eddig csak angolul volt ilyen játék, de most megjelent két magyar is. A Hatalom Kártyái (HKK) és a Mítosz. Nekem valamiért a Mítosz tetszett meg és vettem belőle két paklit.

Ezt nézegettem aztán az egyik barátommal játszottunk vele jókat. Később mikor megint a boltban jártam, megkérdeztem hogy hol találok játékpartnereket. Mondták az ott lévők, hogy a győri szerepjáték klubban játszanak néhányan, de a HKK-t többen játsszák. Akik ott voltak meséltek a HKK-ról, meg egy példajátékot is lenyomtak. Meg kell mondanom hogy sokkal pörgősebb és szórakoztatóbb volt a HKK-t látni mint a Mítosszal játszani. Egyből vettem két csomag HKK-t is.

Az ottani srácokkal jót dumáltunk és megkérdeztem hogy ők hol szoktak játszani. Mondták hogy mosonmagyaróváriak, csak bejöttek megnézni az új boltot. Ennek nagyon megörültem, hisz én is odavalósi voltam. A lényeg hogy ezután sok évig együtt HKK-ztunk. Versenyekre jártunk, versenyeket szerveztünk.
Aztán megismerkedtem a világ első kártyajátékával a Magic the gathering-el. Ez volt az első fantasy gyüjtögetős kártyajáték, minden hasonló alapja és őse. Meg kell mondanom így utólag is, hogy máig nem találkoztam jobb játékrendszerrel. Végtelenségig egyszerű, gyorsan tanulható és nagyon szórakoztató a Magic.

 

A Magic máig a kedvencem. Mivel igen hamar megjelent számítógépes játékként is így sokat játszottam vele. Aztán megjelentek az online játszható virtuális játékterek is. Ebből is a Magic kiemelkedően jól sikerült. Manapság pl Androidos telefonon is igen színvonalas játék érhető el.

És elérkeztem odáig ami miatt az egész fantasy témát két cikken keresztül elővettem itt a blogban. Ugyanis a napokban találtam rá a Hearthstone nevű játékra.

Ez egy kártyajáték mint a fent említettek, de csak számítógépes megvalósítása létezik. A játék kiadója a Blizzard ami eleve már egyfajta biztosíték a minőségre. A másik az hogy a Word of Warcraft világához kapcsolódó, de attól teljesen független játék. Nem kell ismerni a WOW-ot hogy játszani lehessen vele és ami még fontos hoyg az alapjáték ingyenes és az alapjáték eléggé szórakoztató, szinte teljesértékű, csupán vannak olyan küldetések, játékfajták, amik némi pénzzért (1-2 euróért) érhetők el.
Szóval belekóstoltam és nagyon megragadott. A Magichez hasonlóan pörgős a játékmenet, de picit eltérőek a szabályok.
Van magyar nyelvű honlap, ahol sokmindent leírnak és fórumozni is lehet, versenyeket szerveznek.
Aki érdeklődik a hasonló témák iránt annak ajánlom kipróbálásra. Nem kell hozzá "izomgép" és Linuxon is megy.

A fent említett játékokhoz kapcsolódó linkek:
Mitosz emlékoldal
Hatalom kártyái
Hatalom Kártyái Online játék
Magic the gathering hivatalos oldala
Hearthstone hivatalos oldal, program letöltése

Hogyan kerültem kapcsolatba a fantasy szerepjátékokkal

Szóval a honlap mottójában írtam, hogy fantasy és sci-fi is a blog témák között szerepel. Ez idáig még nem írtam ezen témákban. Most ez következik.
Elsőként néhány szót ejtek arról, hogy mi módon találkoztam a fantasy-vel...
Természetesen nekem is alapokat a Star Wars adta. Gyermekkorom meghatározó kultuszfilmje volt és mindenki Jedi lovag akart lenni, Jedi erőt akart magának. Aztán sok-sok évig nem történt semmi különös ezen a vonalon.
1990-ben már nem is tudom milyen indíttatásból elkezdtem olvasni J.R.R Tolkien-nek a Gyűrűk ura trilógiáját, ami azóta már a óriási karriert futott be a mozifilm kapcsán. Bár a könyveket akkor nem olvastam végig, de elkápráztatott az hogy létezik ilyen világ mint Középfölde. Tele különös lényekkel, akik a saját maguk törvényei szerint élnek, ellenségeik és szövetségeseik között. Izgalmas volt ahogy kiderült egy-egy apró részlet a világ történelméből ahogy az ezeréves tündék elmondták meséiket. A sejtelmes mágusok vívódásai, akik a világ sorsának alakításáért felelnek és látszólag a legnagyobb hatalommal bírnak, mégsem olyan könnyű élni azzal a hatalommal és irányítgatni Középfölde népeinek történelmét. Szóval ez volt az első fantasy kapcsolatom, de ekkor még azt sem tudtam hogy létezik efféle irodalom stb...
Aztán bevonultam katonának és ott ráértem olvasni. Egyszer valamelyik vasútállomáson egy könyvárusnál találtam néhány könyvet amik felkeltették az érdeklődésemet. Az egyik a Varázsló-átok a másik a Világok háza címet viselte. Beleolvasgattam és valami megragadott. Felidézték bennem ugyan azt a csodálatot mint amit a Gyűrűk urát olvasva tapasztaltam. De mégis más volt, hisz nem Középföldén történtek a dolgok és nem a hobbitok meg a törpök voltak a főszereplők. A két könyv mindegyike valamilyen másik dimenzióban játszódik ami kapcsolatban van a földi dimenzióval, csakhogy az itteni tudás az a másik dimenzióban varázserőt jelent, szóval izgalmas volt (főként úgy hogy a Varázsló-átokban a varázserőt a C programozás és a UNIX jelentette :) ) Valaki azt mondta a könyvről, olyan mintha a Gyűrűk urából, egy UNIX manuálból és egy matematika könyvből gyúrták volna össze a történetet,,, Valóban irodalmilag nem egy nagy eresztés, silány a fordítás, de engem nem is ez izgatott, hanem maga az ötlet hogy "huhúúúúúú varázsojjuuuuunk" Megvettem a könyveket és izgatottam olvastam a történeteket.
A Világok háza már sokkal jobban fordított és színvonalasabb mű volt. Volt benne egy részlet, ami arról szólt, hogy egy egyetemista társaság Kalandok és sárkányokat játszik. A játékmenetből pár mondat le is volt írva, hogy különös oldalszámú dobókockákkal döntik el a csatákat, vagy hogy ki tudják-e nyitni a 20-as védelmű zárat a 3-as szintű zárnyitás szakértelemmel. Persze a zár védve volt valami csapdával ami ellen a mentőt nem tudta megdobni, mert kicsi volt a csapdaészlelés szakértelme és ezért kisült a csapda és agyonsebezte a fél csapatot... Ez a rész még inkább megragadott, bár nem tudtam hová tenni. Úgy tűnt hogy a könyvben a szerző valamiféle társasjátékról ír, csakhogy itt nem egyszerűen lépkedni kell körbe körbe a játékmezőn primitív szabályok alapján, hanem annál sokkal komplexebb és valamiféle modell alapján történik a különféle események kiértékelése... Na még egy löketet kaptam. Elkezdtem saját játékot gyártani és a barátnőm öccsével játszottunk sakkot a saját magunk által kitalált szabályokkal. A bábuk nem a megszokott módon működtek. Voltak tulajdonságaik, tudtak sebezni, meg volt pajzs értékük és így csatázgattunk. Rohadt büszke voltam, hogy milyen tuti új szabályt alkottam a sakkhoz... :)

Aztán jött a nagy megvilágosodás. 1993-ban már a katonaság után a kedvenc újságárusom bódéját kerülgetve láttam meg egy fura újságot, fura grafikával és még furább címekkel.
A Bíborhold magazin második száma volt ez és az volt ráírva hogy "fantasy és szerepjáték magazin".
A borítón egy sárkány van, amin valami nagyon gonosznak kinéző lovagféleség ül és lengeti a kardját, a másik kezében meg egy pajzsot tart. Vele szemben egy űrsiklóféleségben  maga Luke Skywalker ül és egy lézerpisztollyal támadja a sötét nagyurat... Egyből eszembe jutottak a katonaság alatt olvasott dimenzióvándoros regények. Meg is vettem az újságot.
Aztán beleolvastam és először nem igazán értettem hogy mi az a AD&D. AT&T-ről hallottam már, de itt biztosan elírták. Aztán elkezdett gyanús lenni néhány dolog. Tulajdonságokról, próba dobásokról, meg mindenféle szabályokról írtak a cikkekben....
Döbbenet volt amikor rájöttem hogy az általam kitalált sakk szabálymódosításokkal én nem találtam fel semmi újat, hiszen ez az újság éppen ilyen játékokról szól. A "mély letargiából" úgy tudtam kigyógyulni hogy azzal "vigasztaltam" magamat hogy legalább nem kell marketingkampányokat szervezni arra hogy másokat is ráébresszek milyen jók az ilyen játékok. :) Szóval rádöbbentem, hogy sok ember lehet ebben a földi dimenzióban is aki fogékony ugyan arra a dologra amire én is. Az újság rendszeres vásárlója lettem, és hamarosan vásárolni kezdtem a Beholder Bt által forgalmazott fantasy könyveket.
Első szerepjáték szabályrendszer ami a kezem közé került, az a Középfölde és a M.A.G.U.S szerepjátékok voltak. Kiolvastam szinte az összes MAGUS regényt (akkor havonta jelentek meg újabb regények, regényciklusok). Őrület volt és szerettem a kalandozásokat.
Később az újságban olvasott levelezési rovatból kiderült hogy van egy helyi szerepjáték klub, ahová el is látogattam és jópár évre ott is ragadtam...
[A történetet folyatom egy másik cikkben később, mert látom hogy hosszabb lesz mint képzeltem...]

Levelezés Linuxon 0. rész - Alapok

Levelezésről általában

A Linuxot használtam eddig desktop környezetként, mostanában ismerkedem a különféle szerver szolgáltatásokkal. Az egyik fontos szolgáltatás a Linux világban a levelezés. Az itt leírtak desktop környezetben is használhatók, de igazából a nagy előnye a szerverek világában van.
Mint mindig most is magamnak írom a postot, a saját tapasztalataim lejegyzetelésére. Kérem, hogy így kezelje mindenki aki olvassa.
Az első dolog amit látni kell az a levelezés infrastruktúrája, felépítése, működése. Én magam még nem teljesen értem, jónéhány paradigmától kellett megszabadulnom.
Először is látni kell hogy ha levelező szervert készítünk, akkor mindent amit átlag felhasználóként tapasztaltam a levelezésről teljesen más. Talán bonyolultabb, de ez igazából a rugalmasság elérése miatt tűnhet bonyolultnak.

Levélküldés (MUA, MTA, SMTP)

Nézzük először az elveket, amik bizony már 40 évesek. Az akkori technikai rendszerekhez igazodtak és aszerint lettek kialakítva. Manapság az elv ugyan az csupán a különféle elemek kerültek át a központi gépekből a felhasználói desktopokra, majd vissza a szerverekre.
Abban az időben a felhasználóknak buta termináljaik voltak, amikkel egy központi gépre kapcsolódtak és ott futtatták más felhasználókkal együtt, párhuzamosan a programjaikat. Tehát minden program egy központi gépen futott, még a levelező kliens is (Mail User Agent, MUA), ami egyszerű parancssori alkalmazás volt, gyakorlatilag felhasználói felület nélkül, egyszerűen a terminálra kiírta a szöveges információt.
Az egyik legismertebb MUA a mailx volt a Unix világban. Segítségével pl így lehetett levelet írni:

mailx -s "Elso level" user@pelda.hu

A parancs hatására elindítottunk egy levél megírását. A levél tárgya "Elso level" és a címzett user@pelda.hu volt. A feladó természetesen az a felhasználó, aki bejelentkezés után kiadta a parancsot.
A parancs jóváhagyása után beadhattuk a levél törzsét amit egy CTRL-D billentyűvel lezárhattunk. A levél pedig elküldésre került.
Ugyan ezen a központi gépen futott egy úgynevezett levelező szerver is. Ennek a dolga az hogy más levelező szerverek által nekünk továbbított üzeneteket a saját (helyi) felhasználóink postafiókjába tegye. A másik feladata a saját felhasználóink által megírt levelek továbbítása a célfelhasználó levelező szerverének, ami majd beteszi a címzett postaládájába a levelünket. Mint látható ez a szerver leveleket továbbít, innen is ered a neve Mail Transfer Agent (röviden MTA). Természetesen többféle MTA megvalósítás létezik (postfix, sendmail), ezek bemutatása, konfigurálása egy későbbi cikkben történik. Ez is mint a hálózaton történő kommunikációk mindegyike egyfajta alkalmazás szintű protokollt használ aminek segítségével az üzenetek elküldésre kerülnek. A protokoll neve a Send Mail Transfer Protocol (SMTP). A protokol alapértelmezésben a 25-ös TCP porton kommunikál, ezért nevezik ezt a portot smtp portnak.
Régen az MTA-k nem voltak authentikálva, tehát gyakorlatilag ha valaki ismert egy működő MTA-t akkor igen könnyen tudott levelet küldeni. Manapság az MTA-k mind authentikációval érhetők el és korlátozva is vannak általában a saját hálózatra.
A 90-es és a 2000-es években megnőtt a felhasználói munkaállomások teljesítménye és a levelező kliensek jellemzően a felhasználók saját gépein futottak, távol a levelező szervertől. Ezek a kliensek már grafikus programok voltak, rengeteg kényelmi funkcióval felszerelve. Aztán a kliensek átkerültek a 2000-es évek végére a web-re. A webtechnológiák és a hálózati kommunikációs sebesség drasztikus növekedése már lehetővé tette hogy webes alkalmazásként jelenjenek meg a különféle asztali alkalmazások, többek között az email kliensek is.
A lényeg azonban változatlan maradt. A felhasználó valamilyen levélszerkesztővel megírja az emailt, amit a 25-ös smtp porton továbbít valamilyen MTA-nak. Ezután MTA-MTA közti kommunikáció folyik, végül a címzett postafiókjában tárolódik a levél.

Példának nézzük meg mi történik ha a tatooine nevű gép laci felhasználója levelet ír a naboo gép tomi felhasználójának.
A tatooine gépre bejelentkezik laci felhasználó és elindítja az email szerkesztő alkalmazását, márha nem terminálba akarja közvetlenül az SMTP protokoll nyelvén megadni a szükséges adatmezőket. (ez is lehetséges, érdekes jó kis tapasztalat). Az email megírása után elküldi az üzenetet (pontosabban az alkalmazást utasítja arra, hogy az SMTP szabályoknak megfelelően a tatooin 25-ös portjára csatlakozzon és küldje el az üzenetet). A kommunikációs csatornán fogadja a tatooine MTA-ja a levelet. A protokol szabályok alapján kiszedi belőle a címzettet és megszólítja a címzett naboo gépet a 25-ös portján. Átküldi a levelet a naboo MTA-ja tárolja a levelet tomi felhasználó postafiókjában.

Ott tartunk tehát hogy egy levelező klienssel megírt és elküldött levél megérkezik a címzett postafiókjába. De mi történik ezután?

Levelek olvasása (MUA, POP3, IMAP)

A levelek olvasására jellemzően ugyan azt a programot használjuk mint az írásra. Tehát ez is egy Mail User Agent, azaz egy MUA.
Régen a buta terminálok idejében, amikor a felhasználó bejelentkezett a terminálon akkor mindenféle okos scriptek futottak le és különféle beállításokat végeztek illetve információkat adtak. Az ősidők óta az egyik ilyen információ az volt hogy olvasatlan levele van a postafiókjában. Itt értesülhetett a felhasználó levél érkezéséről. Ezután valamilyen parancssori programmal lekérdezhettük a postafiókunkat. Találtam a neten egy képet erről a folyamatról:

Látszik hogy a James felhasználó miután bejelentkezett a Metroid-4 nevű szerverre, értesül hogy levele érkezett (You have new mail.).
Ezután kiadja a mail parancsot. A program kiírja a verziószámát, meg egy rövid help szöveget, végül pedig azt is hogy 1 üzenet van a postaládában ami még nincs olvasva (1 message 1 new), majd a levelek listája jön (itt egyetlen sor). A sor elején az N betű jelzi hogy új  levél (New), még olvasatlan, majd a levél sorszáma, címzettje dátum és a tárgy.
Utána a ? a mail program promptja. Ez jelzi hogy érvényes parancsra vár. A felhasználó beírta a print parancsot, melynek hatására megjeleníti az összes olvasatlan levelet teljes egészében. Látható a levél, majd ismét a ? prompt.
Ugye kényelmes így levelezni? :)

A lényeg a fentiekből, hogy valamiféle UNIX postaládába érkezett levelet a UNIX terminálba lekérdeztük és elolvastuk. Igen ám, de mi nem itt akarjuk ezt megtenni, hanem távol a saját okos számítógépünkön.
Két lehetőségünk van. Az egyik az, hogy letöltjük a leveleinket a saját gépünkre, a másik pedig az hogy a távoli gép postafiókját jelenítjük meg és kezeljük.
Erre két protokoll van segítségünkre. A POP3 protokoll a 110-es porton és az IMAP protokoll a 143-as porton.
POP3 segítségével letölthetjük a leveleinket a saját gépünkre. A protokoll akkor élte virágkorát, amikor nem volt állandó kapcsolat, hanem betárcsázós módon (dial-up) kapcsolódtak a kliensek a világhálóra. Ilyenkor letöltötték a leveleket, majd bontották a vonalat. Offline módon olvasták és kezelték a leveleket a saját gépükön.
Az IMAP protokoll a modernebb technológia. Segítségével levélkezelés valósul meg, de a szerver oldalon, így kisebb adatforgalom keletkezik, ugyanis a levél nem töltődik le a kliensre. A levelek keresése, kezelése a szerveren történik, de ugyanakkor kényelmes kliens alkalmazás segítségével.

Ezen protokollokat is egy szerver oldali folyamat kezeli. Ilyen alkalmazás például a Dovecot vagy a Courier, melyek mind a POP3 mind az IMAP protokollokat támogatják.

Összefoglalás

Ezzel gyakorlatilag áttekintettük a levelezés legfontosabb folyamatait:

• levél megírása (MUA)
• levél továbbítása, fogadása és tárolása (MTA, SMTP protokoll)
• postafiók lekérdezése, levelek olvasása (MUA, POP3/IMAP protokollok)

Amit még levelezés kapcsán meg lehet (és meg is kell) tenni, de ez már egy további szint:

• levélküldési biztonság (SMTP authentikáció)
• levélszűrés (tartalomra, csatolmányokra)
• vírusellenőrzés

Hálózatos fájlmegosztás Linuxon (NFS)

NFS - Hálózatos fájlrendszer 

Hálózatos fájlmegosztás az egyik leggyakoribb szolgáltatás a hálózatokon. Ennek is több formája létezik. A most bemutatásra kerülő módszer a hálózatba kötött Linux gépek közti megosztást és elérést teszi lehetővé. Ezzel a módszerrel egy másik Linux gépen lévő könyvtárat hasonló módon lehet elérni mintha a helyi gépen lenne.
A Linuxon egyetlen fájlrendszer létezik, amibe befűzhetünk (mount) különböző akár távoli fájlrendszereket. Ehhez el kell indítani a távoli gépen az úgynevezett NFS szolgáltatást, illetve a helyi gépen telepíteni kell az NFS kezeléséhez szükséges programcsomagot. A távoli gépen egy egyszerű konfigurációs fájlban megadjuk az exportálandó fájlrendszer részeket, végül a helyi gépen a mount paranccsal befűzzük a távoli exportált fájlrendszer részt a sajátunkba.

A kiszolgáló telepítése

Első lépésként telepítsük a távoli gépre a kiszolgáló (server) programot.

sudo apt-get install nfs-kernel-server

Miután települtek a szükséges programcsomagok a /etc/exports fájlban megadhatjuk hogy milyen fájlrendszer részeket, kiknek és milyen opciókkal akarunk kiajánlani.

sudo nano /etc/exports

Példaként a /srv/share és a /srv/backup könyvtárak kiajánlását láthatjuk:

/srv/share     *(rw,sync,no_root_squash)
/srv/backup    192.168.1.200(rw,sync,no_root_squash)

A fenti exportálás esetében a /srv/share könyvtárat (aminek léteznie kell) minden IP címről elérhetővé teszi. A /srv/backup könyvtárat csak a 192.168.1.200 IP címről teszi elérhetővé (pl. egy levelezőszerverről a mentések ide készülnek)
Figyeljünk hogy az IP cím (illetve a *) után közvetlenül, szóköz nélkül kezdődjön az opciókat tartalmazó nyitó zárójel!
A példában használt opciók jelentése a következő:

• rw - 
• sync -
• no_root_squash - 
• no_subtree_check - 

Természetesen ennél több opció áll rendelkezésre. Ehhez lásd a manual oldalakat:

man exports

Miután megadtuk a konfigurációt, indítsuk el a szolgáltatást:

sudo service nfs-kernel-server start

Ezzel a kiszolgáló oldalon készen vagyunk, az NFS szerver működik mégpedig a 2049 porton.

Teendők a kliens oldalon

A kliens oldalon első teendőnk a nfs-common csomag telepítése.

apt-get install nfs-common

Ezek után hozzuk létre a csatolási pontok helyét (azaz a könyvtárat ahová csatolni szeretnénk a távoli megosztott könyvtárat):

mkdir -i /mnt/nfs/share

mkdir -i /mnt/nfs/backup

ezután csatolhatjuk a távoli könyvtárat:

sudo mount 192.168.1.100:/srv/backup /mnt/nfs/backup

A csatolást ellenőrizhetjük:

df -h

A manuális csatolás helyett használhatjuk /etc/fstab fájlt is az automatikus csatoláshoz. Ehhez írjuk bele a következő sort:

192.168.1.100:/srv/backup /mnt/nfs/backup nfs rsize=8192,wsize=8192,timeo=14,intr

A /etc/fstab fájlban megadható NFS csatolási opciókról részletesen a manualban lehet olvasni:

man nfs

Az NFS csatolás tesztelése

A csatolt fájlrendszert ezek után használhatjuk, mintha a helyi fájlrendszer része lenne.

Ellenőrzésként hozzunk létre egy proba nevű fájlt:

sudo touch /mnt/nfs/backup/proba

ellenőrizzük hogy létre jött-e a fájl:

ls -l /mnt/nfs/backup

A fájllistában ott kell lennie a proba nevű fájlnak.

Jogosultságok

Ahhoz, hogy az NFS csatolási pontokra legyen írási jogunk a kliens oldalon, szükséges hogy a szerver oldalon a felhasználók létezzenek és megfelelő jogokkal rendelkezzenek a megosztott könyvtárhoz. Tehát fel kell venni a szerveren a felhasználókat (adduser) és a könyvtár jogosultságokat be kell állítani (chmod).

Záradék

Megjegyzések:

• A fenti példákban a 192.168.1.200 IP címen egy Backup szerver, a 192.168.1.100 címen pedig egy Samba kiszolgáló működik. A Backup szerveren telepítettem az NFS kiszolgálót, a Samba szerveren pedig a klienst, majd csatoltam a Samba szerver fájlrendszerébe a Backup tárhelyét. Ezután egy egyszerű tar paranccsal már meg is oldható a Samba szerveren lévő windowsos megosztások tartalma.
• A csatolási művelet nálam elég lassan (5-10 mp) történt, bár hozzá kell tennem hogy egy nagyon minimalista kis teljesítményű servert helyeztem üzembe.

Használt források: 

http://sugo.ubuntu.hu/10.10/html/serverguide/hu/network-file-system.html

https://www.digitalocean.com/community/articles/how-to-set-up-an-nfs-mount-on-ubuntu-12-04

Ubuntu fix IP beállítás

Ubuntu Server telepítését ha gyorsan csináltad és nem vacakoltál a finombeállítással telepítés közben, akkor után szükséges lehet (szerintem mindenképpen kell) hogy DHCP címkiosztásról átállítsuk a rendszert fix IP címre.
A Linux az IP konfigurációt a /etc/network/interfaces fájlban tárolja. Pontosabban itt kell megadni az elérhető hálózati csatolók IP hálózati paramétereit.

sudo vi /etc/network/interfaces

A következők alapján módosítsuk a csatoló paramétereit:

iface eth0 inet static
       address 192.168.1.100 #a csatoló IP címe
       netmask 255.255.255.0
       network 192.168.1.0
       broadcast 192.168.1.255
       gateway 192.168.1.1
       dns-nameservers 192.168.1.100 8.8.8.8 #DNS szerverek
       dns-search sajat.halozat #hálózat neve amiben keresni fog



Írjuk át a /etc/hosts fájlban a következő sort:

127.0.1.1 myserver.mynetwork.lan

erre:

192.168.1.100 mysqrver.mynetwork.lan myserver

Indítsuk újra a hálózatot:

sudo /etc/init.d/networking restart

QT 5 telepítése Ubuntu-ra

Az ubuntu.hu oldalon nemrégiben megjelent egy cikk, mely néhány magyar nyelvű ingyenes rendszergazdáknak szóló elektronikus szakkönyv megjelenését és letölthetőségét közölte.
Az engem érdeklő linux rendszergazdai könyvek között volt még néhány másik is. Többek között egy "QT strandkönyv" címre hallgató is. A könyv igen könnyed olvasmányt ígér a QT programozásról. Gondoltam megismerkedem ezzel a környezettel/nyelvvel is.
Ubuntu Linuxot használok desktop környezetnek, így ez alá akartam telepíteni a legújabb QT 5.2-t. Mivel az Ubuntu tárolókban QT 5.0.2 szerepel ezért gondoltam hogy inkább letöltöm és nem a tárolókból telepítem.
Találtam egy leírást a QT projekt oldalán, mely az Ubuntu telepítést írja le. Ez alapján a következő műveleteket csináltam végig:

1. Letöltöttem a projekt oldaláról a 32 bites telepítőkészletet (a leírásban az offline készlet letöltése szerepel, én az online-t találtam csak meg, így azt szedtem le)
2. Futtatási jogot adtam a letöltött csomagnak, majd elindítottam:
   
   chmod +x qt-opensource-linux-x86-1.6.0-online.run
   ./qt-opensource-linux-x86-1.6.0-online.run
3. A g++ telepítéséhez a következő csomagot kell telepíteni:
   
   sudo apt-get install build-essential
4. Ezután már csak az OpenGL könyvtár telepítése szükséges:
   
   sudo apt-get install mesa-common-dev

Ezek után elindítottam a QT Creatort, csináltam egy alap üres GUI alkalmazást, próbáltam futtatni, de hibaüzenet fogadott:

cannot find lGL

Egy csomó google-zás után találtam rá a megoldásra. Telepíteni kell még egy OpenGL könyvtárat:

sudo apt-get install libgl1-mesa-dev

Ezek után már gond nélkül fordulnak a QT alkalmazások.

Tenyérgépeim története V. - Google Nexus 5

Gondolkodtam azon, hogy a cikksorozat címével kezdek valamit mert a tenyérgépnek már régen nem nevezik ezeket a készülékeket. De mi legyen az új cím? "Telefonjaim története" Szintén nem jó, hiszen az okostelefon számomra egy olyan számítógépet jelent amivel mellesleg telefonálni is lehet. Ergó nem telefon az okostelefon hanem számítógép. De ha meg azt írnám, hogy "Számítógépeim története" akkor abszolút félreérthető lenne az egész, mert mindenki az asztali PC-re gondol, ha számítógépről beszélek...
Ez az agymenés az én mániám, de akkor is igazam van :)
Szóval maradok az eredeti címnél, mellétéve az éppen aktuális modell nevét, így talán egyértelműbb lesz a dolog...
Az előző részben az LG L szériájának első generációs csúcskészülékéről az L9-ről írtam, az akkori telefonomról /vagy számítógépemről? :) / Akkor 5 napos volt a készülékem és az első tapasztalatom keserédes volt, hiszen bár gyors, szép, modern készülékről volt szó de az akkumulátora akkor 12-14 órát bírt, ami valljuk be édes kevés. Nos ez azóta sem változott. Jöttek a frissítések, majd sikerült boot loadert nyitni és jöhettek a custom romok, de egyik sem segített. A készülék reggel 7-től töltés nélkül este 7-ig bírta jó esetben, ezért mindenhol körülvettem magam mikroUSB-s töltőkkel. Autó, munkahelyi iroda, nappali, éjjelszikerény, utazótáska. Így éreztem magam biztonságba, de kényelmetlen volt nagyon. Aztán a másik problémám az volt, hogy sehogy sem akart együttműködni normálisan a teljesen új Ford Focus hangrendszerével a FordSync-el. Végülis ez volt a fő oka, hogy az egy éves készüléket leváltottam. Soha nem volt még ilyen rövid életű nálam egy telefon.
Azt hogy mi legyen a következő készülék nem tartott soká eldönteni. A Galaxy S számomra szimpatikus volt, de mióta belekezdett a Samsung az adjunk-ki-évente-egy-csúcskészüléket sztoriba, azóta már inkább taszító számomra. Az S2 még rendben lett volna, de az ára nagyon nem tetszett, akárcsak az S3 vagy az S4.
Azt tudtam hogy LG-t nem akarok újra, mert azért szeretek mókolni a kütyükkel, ROM-okat kipróbálni, meg hát programozni is szoktam és az Android izgalmas platform.

Ekkor jött az ötlet hogy nézzem meg a Nexust. Á gondoltam az biztos nagyon drága. Aztán jött a meglepetés. Gyakorlatilag a legújabb Nexust a KitKat hivatalos tesztkészülékét gyakorlatilag 100-120000 Ft környéki áron be lehet szerezni Ausztriából. A fórumok olvasgatása közben jöttem rá hogy gyakorlatilag mindegy, hogy hová kell vinnem garanciáztatni a készüléket ha baj lenne, hiszen az osztrák főváros 60 km-re van tőlem. Épp ezen morfondíroztam, amikor jött a hír az egyik fórumon hogy egy napig akciózzák a Nexus 5-öt Ausztriában. 390 euro helyett 350-ért adják. Nosza, hazaértem a munkából, beültem az autóba és elmentem Bécsbe venni egy Nexus 5-öt.
Az ismerkedés percei, az első indítás nagy izgalmakkal telt. A készülék sebessége észvesztő, a kamera csodálatos képeket csinál gyengébb fényben is, a KitKat remek oprendszer. És hát igen a Nexus az a referencia készülék, amolyan fejlesztői készülék. Lehet vele mókolni, lehet buherálni teljesen szabadon (ez az L9-en szinte lehetetlen volt). A másik amit Nexus-érzésnek neveznek az maga az Android élmény amit a Google kiadott. Nincs össze vissza díszítve gyártóspecifikus launcherekkel, keretrendszerekkel, hanem a teljes valójában a szűz Android van hozzá. És ez egy teljesen más élményt nyújt mint amit eddig az Android-on értettem. Eddig az LG vagy a Samsung testreszabott, átformált Androidját használtam és az nem ugyan az.
Szóval a lényeg hogy egy aktuális csúcskészülék boldog tulajdonosa vagyok. Úgy érzem hogy az N5 nem egy évig fog szolgálni. Az akkuideje jelenleg az én felhasználási módommal 40 óra környékén mozog. Egy napot röhögve kibír akkor is ha sokat használom. Működik a FordSync-el és nagyon jó a hangminősége is. LTE az megint egy csoda!

Szóval Nexus hívő lettem!