Fájl feltöltése Github tárolóba

Egy átlagos napon, egy átlagos feladaton dolgoztam, amikor egy teljesen átlagos, mondhatni triviális dolgot kellett megoldanom. Konkrétan: le kellett tárolni egy állományt egy megadott git tárolóba. Mi sem egyszerűbb, gondoltam naivan, de nem eszik olyan forrón a kását! Nem mennék bele túl mélyen a részletekbe, talán annyi is elég, hogy rendszeresen szoktunk sütni kép-fájlokat különböző felhőkbe. Természetesen az egész sütési folyamat automatizálva van, az eredmény pedig egy katalógusba kerül, ahol a kedves felhasználó ízlése szerint válogathat közülük. Kezdjük hát az egy pont nullával:

git add metadata ; git commit -m"New image available" ; git push

Két probléma is adódott:

• Egyfelől nagyon ronda, persze működik, és a Jenkins-nek is megvan a joga írni a tárolót, de én valami kifinomultabb megoldásra vágytam.
• Másfelől pedig maga a sütés egy másik git tárolóból indul ki, szóval vagy valami ideiglenes könyvtárba dolgozok (/tmp, ram disk), aminek az életciklusát kezelni kell, vagy a git tárolóban a git tároló problémájával küzdök, és kényesen ügyelek rá, hogy mindkét tárolóba csak az oda illő dolgok kerüljenek be.

Elvetettem a git parancsok használatát, úgyis Github-on tartjuk a forrást, van annak saját API-ja, megoldom elegánsan a kérdést. A dokumentációt olvasva elég hamar megtaláltam, hogy a v1-es API-ban elérhető direkt fájl feltöltést kompletten kihajították, így a legfrissebb API verzióban nincs ilyenre lehetőség. Persze tudunk fájt feltölteni, viszont ki kell hozzá nyitni a motorháztetőt, azaz a .git könyvtárban kell műveleteket végezni az API segítségével. Lássunk is neki:

	#!/bin/bash -e
	: ${1?=File name is required}
	file_name=$1
	GITHUB_ORG=mhmxs
	GITHUB_REPO=test-metadata
	GITHUB_USER=mhmxs
	GITHUB_API_KEY=0ea72b*****************
	GITHUB_REPO_URL=https://github.com/$GITHUB_ORG/$GITHUB_REPO

view raw file-upload-part-1.sh hosted with ❤ by GitHub

A script első felében a szükséges változókat definiáltam. A GITHUB_API_KEY-nek egy Personal Access Token-t generáltam a Github felületén. Következő lépésben kiderítettem az utolsó commit azonosítóját, és helyét. A JSON válaszok értelmezésére a Jq nevű parancs-soros eszközt választottam.

	head=$(curl -sf -u $GITHUB_USER:$GITHUB_API_KEY https://api.github.com/repos/$GITHUB_ORG/$GITHUB_REPO/git/refs/heads/master)
	commitSha=$(echo $head | jq -r .object.sha)
	commitUrl=$(echo $head | jq -r .object.url)

view raw file-upload-part-2.sh hosted with ❤ by GitHub

A git fa szerkezetben tárolja kódunk különböző állapotait, ezért egyel tovább kell mennünk, és meg kell tudnunk, hogy a commit melyik fához tartozik.

treeSha=$(echo $commit | jq -r .tree.sha)

view raw file-upload-part-3.sh hosted with ❤ by GitHub

Most, hogy tudjuk az azonosítóját a fának, feltölthetjük az új fájlt, vagyis a blob-ot.

	blob=$(curl -sf -u $GITHUB_USER:$GITHUB_API_KEY -X POST https://api.github.com/repos/$GITHUB_ORG/$GITHUB_REPO/git/blobs -d "{\"content\":\"$(base64 $file_name)\",\"encoding\":\"base64\"}")
	blobSha=$(echo $blob | jq -r .sha)

view raw file-upload-part-4.sh hosted with ❤ by GitHub

Kezd izgalmassá válni a dolog. Ahogy említettem a .git könyvtárban kézi-munkázunk, ami azt jelenti, hogy az imént feltöltött állomány pillanatnyilag sehová sem tartozik, ahhoz ugyanis egy fához kell csatolni azt.

	newTree=$(curl -sf -u $GITHUB_USER:$GITHUB_API_KEY -X POST https://api.github.com/repos/$GITHUB_ORG/$GITHUB_REPO/git/trees -d \
	"{\"base_tree\":\"$treeSha\",\"tree\":[{\"path\":\"$file_name\",\"mode\":\"100644\",\"type\":\"blob\",\"sha\":\"$blobSha\"}]}")
	newTreeSha=$(echo $newTree | jq -r .sha)

view raw file-upload-part-5.sh hosted with ❤ by GitHub

Majd készítünk egy új commit-ot, amit összekapcsolunk az utolsó commit-tal, és az imént kreált fára irányítjuk.

	newCommit=$(curl -sf -u $GITHUB_USER:$GITHUB_API_KEY -X POST https://api.github.com/repos/$GITHUB_ORG/$GITHUB_REPO/git/commits -d \
	"{\"message\":\"Upload $file_name\",\"parents\":[\"$commitSha\"],\"tree\":\"$newTreeSha\"}")
	newCommitSha=$(echo $newCommit | jq -r .sha)

view raw file-upload-part-6.sh hosted with ❤ by GitHub

Egy utolsó lépés maradt hátra, a master ágon a HEAD címkét át kell helyezni az újdonsült elkészült commit-ra.

	curl -s -u $GITHUB_USER:$GITHUB_API_KEY -X PATCH https://api.github.com/repos/$GITHUB_ORG/$GITHUB_REPO/git/refs/heads/master -d "{\"sha\":\"$newCommitSha\",\"force\":true}"
	exit 0

view raw file-upload-part-7.sh hosted with ❤ by GitHub

Nem állítom, hogy pilóta vizsga kell egy egyszerű fájl feltöltéséhez, de azért nem árt ismerni, hogy miként is működik a git, hogyan tárolja és azonosítja az objektumokat, és nem utolsó sorban miként kezeli a címkéket. A teljes script elérhető itt.

JavaScript EE, JSON válaszol

Előző bejegyzésben bemutattam miként lehet Java környezetünket rávenni JavaScript futtatására. Folytatásban egy servlet-en keresztül rávesszük a web-konténert, hogy JSON válaszokat adjon a kérésekre.

Legelső lépésként egy hagyományos servletet kell létrehoznunk, majd a doGet metódusában megvalósítani a JavaScript futtatását.

Java kód:

Compilable scriptEngine = (Compilable) new ScriptEngineManager().getEngineByName("JavaScript");

ScriptContext scriptContext = new SimpleScriptContext();
scriptContext.setWriter(response.getWriter());
scriptContext.setAttribute("config", getServletConfig(), ScriptContext.ENGINE_SCOPE);
scriptContext.setAttribute("response", response, ScriptContext.ENGINE_SCOPE);
scriptContext.setReader(new InputStreamReader(JSONServlet.class.getResourceAsStream("json.js")));

try {
 CompiledScript script = scriptEngine.compile(scriptContext.getReader());
 script.eval(scriptContext);
} catch (ScriptException e) {}

Látható különbség, hogy ScriptEngine helyett Compilable osztályt használunk. A Compilable interfészt megvalósító értelmező annyival nyújt több szolgáltatást, hogy a lefordított JavaScripteket újra fel lehet használni újrafordítás nélkül, így segítségével gyorsító-tárazni lehet a scipteket csökkentve a szerver terhelését. Következő lépésként, mivel most nem a JavaScript visszatérési értékére van szükségünk (és azt sem szeretnénk, hogy az alapértelmezett kimenetre írjon), hanem azt szeretnénk, hogy a JavaScript közvetlenül a servlet kimenetre írjon, példányosítanunk kell egy ScriptContext objektumot, és referenciát adnunk a ServletResponse-ra. Természetesen van lehetőségünk Java objektumok átadására a JavaScriptnek, de ebben az esetben a ScriptContext osztálynak közvetlenül adhatjuk át a paramétereket a setAttribute metódus meghívásával. Ezután nincs más dolgunk, mint megadni a JavaScript fájlunkat, és futtatni a scriptet.

JavaScript kód:

response.setHeader("Cache-Control", "no-cache");
response.setContentType("application/json");

var json = {
response: {
  status: response.getStatus(),
  content_type: String(response.getContentType())
},
config: {
  servlet: String(config.getServletName())
}
};

println(json.toSource());

A scriptben jól látható miként használjuk a Java objektumokat, és végül miként írjunk a kimenetre.

A böngészőben az alábbi válasz jelenik meg:

({response:{status:200, content_type:"text/plain;charset=ISO-8859-1"}, config:{servlet:"JSONServlet"}})

Folyt köv...