staging.inyokaproject.org

Hallo,

ich schreibe gerade ein bash-script (eher ein miniprogramm) das zwei JSON-datei^1 einliest und auswertet mit jq (see: https://wiki.ubuntuusers.de/jq/) .

ich benutze JSON weil die dateien sowohl mit js als auch php und natürlich bash gelesen/geschrieben (eher php und js hier) werden.

meine JSON sehen etwa so aus:

1
2
3
4
5
6
7
8

{
 "comment":"kommentar",
 "backends":
 {
  "back1":"/path/to/data.d/back1.backend",
  "back2":"/path/to/data.d/back2.backend"
 }
}

1
2
3
4
5
6
7
8

{
 "comment":"kommentar",
 "frontends":
 {
  "sub1":["/path/to/data.d/front1.frontend"],
  "sub2":["/path/to/data.d/front2.frontend" "/path/to/data.d/front3.frontend"]
 }
}

ich habe es schon geschafft die beiden JSONs in array zu speichern (dynamisch - unten hier um zu zeigen wie statisch aussieht:)

1
2
3
4
5

myvar_backend_name=("back1" "back2")
myvar_backend_path=("/path/to/data.d/back1.backend" "/path/to/data.d/back2.backend")
myvar_frontends=("myvar_frontend_sub1" "myvar_frontend_sub2")
myvar_frontend_sub1=("/path/to/data.d/front1.frontend")
myvar_frontend_sub2=("/path/to/data.d/front2.frontend" "/path/to/data.d/front3.frontend")

das schwierige ist jetzt das jenachdem was ich als parameter ($1.. = "-f=sub2" & "-s=1") angebe, die bash-miniapp in das array $myvar_frontend_(was ist bei -f) gehen soll und bei index:(was ist bei -s) den string holen muss.

wie mache ich das ? komme hier nicht weiter.

FG PatrickJRed

PS habe auch schon sachen wie

tmp_front="sub2" # von $... mit split
tmp_sub=1 # index:1 von sub2 -> "/path/to/data.d/front3.frontend"
tmp="myvar_frontend_${tmp_front}"
echo ${!tmp[$tmp_sub]}

probiert, nicht geklappt. - es gibt wenn überhaupt nur für index:0 aus

vielen dank für die hilfe

PatrickJRed schrieb:

das schwierige ist jetzt das jenachdem was ich als parameter ($1.. = "-f=sub2" & "-s=1") angebe, die bash-miniapp in das array $myvar_frontend_(was ist bei -f) gehen soll und bei index:(was ist bei -s) den string holen muss.

Ich verstehe nur Bahnhof. Wo gibst Du etwas als Parameter an? Was ist die bash-miniapp? Was bedeutet "was ist bei -f"? Was bedeuten die Texte mit den runden Klammern?

Unabhängig davon sieht dein Problem kompliziert genug aus, dass ich eher Python oder Ruby nehmen und das JSON dort verarbeiten würde. Das geht wahscheinlich deutlich besser als mit einem Shell-Skript - erst recht, wenn Du noch Kommandozeilenoptionen verarbeiten musst.

rklm schrieb:

PatrickJRed schrieb:

das schwierige ist jetzt das jenachdem was ich als parameter ($1.. = "-f=sub2" & "-s=1") angebe, die bash-miniapp in das array $myvar_frontend_(was ist bei -f) gehen soll und bei index:(was ist bei -s) den string holen muss.

Ich verstehe nur Bahnhof. Wo gibst Du etwas als Parameter an? Was ist die bash-miniapp? Was bedeutet "was ist bei -f"? Was bedeuten die Texte mit den runden Klammern?

na ich rufe das script z.b. so auf

/path/to/script.sh -f sub2 -s 1

anhand von "-f sub2" ist gegeben, dass ich $myvar_frontend_sub2 benötige - konkret: mit "-s 1" ist dann das zu holen :

 ${myvar_frontend_sub2[1]} 

und nichts anderes wie z.b.

 ${myvar_frontend_sub1[1]} 

oder

 ${myvar_frontend_sub2[0]} 

Unabhängig davon sieht dein Problem kompliziert genug aus, dass ich eher Python oder Ruby nehmen und das JSON dort verarbeiten würde.

JSON kann ich schon erfolgreich in bash mit jq verarbeiten

Das geht wahscheinlich deutlich besser als mit einem Shell-Skript - erst recht, wenn Du noch Kommandozeilenoptionen verarbeiten musst.

. ich habe auf meinem server kein python oder ruby, und auch kein perl oder so, höchstents php - aber auch nicht immer, aber was immer vorhanden ist bash/shell

PatrickJRed schrieb:

rklm schrieb:

Unabhängig davon sieht dein Problem kompliziert genug aus, dass ich eher Python oder Ruby nehmen und das JSON dort verarbeiten würde. Das geht wahscheinlich deutlich besser als mit einem Shell-Skript - erst recht, wenn Du noch Kommandozeilenoptionen verarbeiten musst.

. ich habe auf meinem server kein python oder ruby, und auch kein perl oder so, höchstents php - aber auch nicht immer, aber was immer vorhanden ist bash/shell

Das ist natürlich blöd.

jq hat ja schon eine Sprache, um Werte aus einem Dokument zu selektieren und zu verarbeiten. Da bräuchtest Du eigentlich keine neue in Form von Kommandozeilenparametern zu definieren. Das ist auch viel flexibler, weil Du nicht für jeden neuen Verarbeitungsfall Dein Skript anpassen müsstest.

jq kann auch zwei Dokumente zusammenfügen - etwas, das Du gerade im Shell-Skript machst.

Unklar ist auch noch, wie Du die Daten weiter verarbeiten willst.

backends bei sind keine eigenständigen programme der (ba)sh oder manchmal php es sind im grunde anweisungs kataloge wie

execbin=("youtube-dl" "youtube-dl")
execbin_opt=("-F $url" "-f $format $url")

was ein wrapper um youtube-dl (https://github.com/ytdl-org/youtube-dl/) ist oder eigene wie

execbin=("bash" "md5sum")
execbin_opt=("$myfile $url $myfile_downloaded" "$myfile_downloaded")

wobei $myfile ein script in /path/to/data.d/scripts/ ist

und die frontends enthalten weiter parameter wie $format für youtube-dl oder meine eigenen wie $base_path_of_download und $myfile_downloaded für meine backends

backend : welche binaries und options in general

frontend: jede platform hat eine eigene gruppe an frontends (-f) (wie youtube.cm,cdimage.ubuntu.com,und viele andere streamsites/live-cd-iso hoster und co)

ein frontendgruppe enthält min. 1 subprogramm dass das jeweilige backend sourced (mit source /path/to/data.d/..backend → pfad von myvar_backend_*)

ein subprogramm (z.b. /path/to/data.d/front2.frontend aus sub2) definiert für youtube z.b. die format-angabe und das namens-schema für die herunterzuladende datei / ziel verzeichnis / .......

FG PatrickJRed

wäre es vielleicht einfacher die json dateien mit jq abzufragen für den komkreten backend/frontend/subprogramm wenn ich den parameter bekomme?

das problem ist ja dass die variablenamen dynamisch (zur laufzeit anhand der json-key) sind und nicht statisch und ich irgendwie mit dem hangeln von array zu array nicht klarkomme - aber ohne array und direkter abfrage kann ich das wahrscheinlich umgehen.

ich probier mal, aber wahrscheinlich leichter zu implementieren als das mit den vielen arrays.

okay,

das mit den arrays habe ich ausgetauscht durch eigene shell-funktionen die jq aufrufen.

funktioniert also jetzt.

fg P.

allerdings tut sich jetzt ein anderes problem auf.

ich baue meinen dynamisch generierten befehl so auf :

#BACKEND.backend
backend_bin=("youtube-dl" "CMD2")
backend_options=("--proxy ..." "MAIN_OPT2")

#PROFILE.profile
profile_option=("-F $tmp_url" "PROFILE_OPT2")

#app.sh
# indexed for-loop over "backend_bin"
${backend_bin[$tmp_exec_index]} ${backend_options[$tmp_exec_index]} ${profile_option[$tmp_exec_index]}

das funktioniert soweit gut, bis auf wenn $tmp_url ein/mehrere "?" (ohne ") enthält, dann folgendes

#final :
youtube-dl --proxy ... -F

anstatt von

#final :
youtube-dl --proxy ... -F https://www.youtube.com/watch?v=abc...

wieso passiert das, wenn kein "?" ist immer url dabei

#final :
youtube-dl --proxy ... -F https://www.exampledomain.com/video/abc-video

meine kurz-test :

echo "${backend_bin[$tmp_exec_index]} ${backend_options[$tmp_exec_index]} ${profile_option[$tmp_exec_index]}"
# youtube-dl --proxy ... -F https://www.youtube.com/watch?v=abc...
echo ${backend_bin[$tmp_exec_index]} ${backend_options[$tmp_exec_index]} ${profile_option[$tmp_exec_index]}
# youtube-dl --proxy ... -F

kann jemand mir helfen das zu verstehen

danke im voraus