Přidat otázku mezi oblíbenéZasílat nové odpovědi e-mailem Pársování příkazové řádky a práce s adresáři pohodlně, přehledně - jaký jazyk vybrat?

Na linuxu máme takový rozsáhlejší projekt a jeho součístí je i pár skriptů, které na základě argumentů zakládají/klonují/ověřují gitové repozitáře. Poslední dobou těch skriptpů přibývá a požadavky se stávají komplexnějšími, tak přemýšlím nad redesignem celé této oblasti.
Ty skripty se skládají ze dvou částí
1) první poskládá z aktuálního adresáře a parametrů výsledné parametry (hlavní adresář, "uživatele" - subprojekt, zbytek cesty, server, nějaké názvy a další parametry) a pokud nastane chyba, tak ji nahlásí a celé to končí. Zatím je to v bashi, ale začíná být docela opruz to udržovat a rozčiřovat.
2) pokud vše proběhne dobře, druhá část dělá vlastní práci (nižší desítky volání programů, kopírování adresářů, zápisy, pipeliny s různými filtry a tak) - na ní není moc co vylepšovat a bash jí sedí.

Zatím vše fungovalo, ale jak se to rozrůstá, je ta první část několika násobně větší, než ta druhá, výkonná a navíc by se dala u těch skriptů sdílet, protože dělá v podstatě to samé, jen se to místy trochu liší (hlavně v helpu), ale to se dá snadno parametrizovat. A teď je tu řada požadavků, jak to rozhraní vylepšit (a různě se překrývají a duplikují, ale stroj se má přizpůsobit člověku, nikoli naopak).

Například jedna z "jednodušších" variant, kde se se podle různých priorit a heuristik doplňují jednotlivé části z aktuální cesty a parametrů má jako jeden z výstupů takovouto cestu k adresáři

~/{GIT|$ROOT}/{git/$user}/{$dir|`pwd`|PORTAGE}/category.projekt

("kupodivu" je výsledek přehledný a snadno používatelný, ale těch "uses-case" jak to zadávat a proč se za těch víc než 10 let co projekt žije nahromadilo spousta a každá má dobrý důvod)

Dále nutno říct, že ty samé skripty jsou volány i různých dalších programů v dávkovém režimu, takže musí být schopny běžet neinteraktivně - často u toho nebude ani člověk, ani klávesnice ani monitor. Změna API se dá do většiny těch programů nějak propasírovat, nebo častěji je naopak podmnožinou nového API, tam je to dobré.

Ale týmy se se teď dohadují, co všechno ještě by se hodilo a pokud to brzo nějak nerozetnu s tím, že tady je nový nástroj, umí to a to a používá se tak a tak a komu se to nelíbí, ať si založí oficiální ticket na změnu, tak zanedlouho vymyslí takový kolos, že do něj budu muset narvat i základní 3 Asimovovy zákony, jinak to špatně dopadne.

Takže řeším, jak udělat program/funkci/skript, který by si přehledně poradil se spoustou parametrů a dobře se v něm pracovalo se stringy a s adresářovou strukturou - a když už se to má psát vlastně od začátku, přeorganizovat a výrazně rozšířit, tak už stojí za to se zamyslet nad tím, v jakém jazyku to napsat. Různých jazyků jsem už používal spoustu, takže se nemusíte v návrzích omezovat (klidně od ASM po třeba lisp)

Jaký jazyk byste použili/doporučili pro tu první část vy a proč?

Předmět Autor Datum
Za mna python, ale niekto iny ti poradi nieco ine (kupodivu :D ). bolo by mozne sem hodit trosku via…
Michal2 09.09.2021 21:35
Michal2
Tady je jeden náhodný, lehce anonymizovaný, používá ještě staré konvence #! /bin/bash #############… poslední
gilhad 10.09.2021 00:14
gilhad

Tady je jeden náhodný, lehce anonymizovaný, používá ještě staré konvence

#! /bin/bash
######################################################
# verze='1.0.2-r3' # @@@verze@@@
# datum='11.04.2021 13:25:54' # @@@datum@@@
# branch='master' # @@@branch@@@
######################################################

## CAST 1)

user="git"	# defaultni user
GIT="~/GIT/PORTAGE"	# tady jsou vsechny projekty
server="http://AAA.BBB.CCC"
if [ "$1" == "-u" ]; then
	shift
	user=$1
	GIT="~/GIT-${user}/PORTAGE"
	server="http://${user}.AAA.BBB.CCC"
	shift
	echo "User: ${user}"
fi
if [ $# != 2 -a $# != 3 ] ; then
	echo "$0 [-u user] category projekt [popis]"
	echo "zalozi novy projekt pro emerge"
	echo "volitelne pod jinym, existujicim userem"
	exit
fi
category=$1
projekt=$2
popis=$3
echo "=== $category/$projekt ==="
if [ -z "$category" -o -z "$projekt" ] ; then
	echo "set category/projekt"
	exit;
fi
tmpdir=`mktemp -d`		# sem to exportuju - pozor, maze se
src='src'		# tady je zdrojak
portagedir='portage'
portage='portage/ebuild'	# tady je ebuild
pwd=`pwd`
cd
home=`pwd`
cd "$pwd"


## CAST 2) - priprava souboru a adresaru podle ucelu a skriptu 

cd $tmpdir
mkdir -p "$category.$projekt/src"
mkdir -p "$category.$projekt/src/libs"
touch "$category.$projekt/src/libs/__init__.py"
mkdir -p "$category.$projekt/$portagedir"
cat >"$category.$projekt/$portage" <<EOF
BLA BLA BLA
DESCRIPTION="$category/$projekt $popis"
HOMEPAGE="${server}"
SRC_URI="${server}/distfiles/\${PF}.tar.gz"
BLA BLA BLA
EOF
cat >"$category.$projekt/$src/Makefile" <<"EOF"
BLA BLA BLA
EOF

cat >"$category.$projekt/git-export.sh" <<EOF
#! /bin/bash
export category="$category"
export projekt="$projekt"		# tak se jmenuje projekt a jmena taru se z nej odvozuji
export user="${user}"
export export_to="${user}-ZZZZZ@AAA.BBB.CCC"
export portage_dst="${user}/portage"
export distfiles_dst="${user}/distfiles"
#########################################
BLA BLA BLA
EOF
chmod 744 "$category.$projekt/git-export.sh"
#================ gitignore
cat >"$category.$projekt/.gitignore" <<EOF
BLA BLA BLA
EOF
#================ README
cat >"$category.$projekt/$src/README" <<EOF
$category/$projekt $popis
BLA BLA BLA
EOF

(
	cd "$category.$projekt"
	if ! [ -f gtouch.sh ]; then
		if  [ -f /usr/bin/gtouch.sh.example ]; then
			cp /usr/bin/gtouch.sh.example gtouch.sh
		fi
		if ! [ -f gtouch.sh.example ]; then
			if  [ -f /usr/bin/gtouch.sh.example ]; then
				if ! ( grep gtouch.sh.example .gitignore -q ); then
					echo "./gtouch.sh.example" >>.gitignore
				fi
				cp /usr/bin/gtouch.sh.example .
			fi
		fi
	fi
)
chmod 744 "$category.$projekt/gtouch.sh"
#################



## CAST 2)



cd "$category.$projekt"
git init
git add -A
git ci -am "uvodni commit"
git tag -a -m "0.0.1" 0.0.1
cd "$tmpdir"
git clone --bare  "$category.$projekt"  "$category.$projekt.git"
scp -PXXXX -r "$category.$projekt.git" ${user}@DDD:
cd "$pwd"
echo "deleting tempdir $tmpdir"
rm -rf "$tmpdir"
trueGIT="${GIT/\~/$home}"
mkdir -p $trueGIT
cd "$trueGIT"
git clone ssh://${user}@DDD:XXXX/~/"$category.$projekt.git"
echo "$GIT/$category.$projekt" >> ~/.dirs-${user}
echo "cd $GIT/$category.$projekt"

CAST 2) (a její příprava, ta se dost liší, ale možná na ní časem udělám nějaký hook, který to vygeneruje z templatů) zůstane prakticky beze změn, jen se tam dodají další cesty a sjednotí se názvy
CAST 1) by nově měla:
- řešit, zda je volána z nějakého stromu a pokud ano, tak si rozpársovat odkud a brát parametry relativně k tomu místu (pokud nějaký nebude absolutní)
-- (strom se pozná tak, že existuje adresář ${ROOT}/${user}/list/.git přičemž skript je volán z ${ROOT}/${user}/[mozna/nejake/cesty/a/tak] a to i v případě, že
--- pwd vrací

/home/jmeno/shortcuts/02

--- ale

realpath /home/jmeno/shortcuts/02 = /SHARED/GIT/demo/REPOS/FORTH/FORTHs.jonesforth

--- a tudíž list/.git není ve zpáteční cestě, ale úplně jinde (/SHARED/GIT/demo/list/.git )
--- a tedy všechno převádět na realpath
-- pokud není volána ze stromu, vzít jako výchozí defaultní hodnotu (hlavní strom, nejčastější user)
- umožnit zadat jiného ROOT, user, cesty, kategorie projektu, komentare, serveru, portu na něm ...
-- umožnit i relativní cesty jako ../../neco/neco nebo cosi/cosi (parametr +d)
-- umožnít "ROOT-relativní" cesty (parametr -d) teda na cesta/cesta to vygeneruje /SHARED/GIT/demo/cesta/cesta
-- umožnit plné cesty (=d ZAKLAD/user2/nejaka/jina/cesta) a z ní vypársovat nový ROOT(ZAKLAD) a user(user2)
-- pokud výsledná cesta neexistuje a poslední prvek je aaa.bbb tak z toho brát category(aaa) a projekt(bbb)
-- pokud cesta existuje (nebo je to zadáno mezi parametry), tak to z té cesty nebrat
-- pokud něco není zadáno, nebo je to "nějak divné", tak to brát jako chybu a vypsat co nesedí ("nějak divné" zahrnuje řadu věcí, jako že port musí být číslo, user musí syntakticky odpovídat na user pod linuxem a být lowercase, některé kombinace a hodnoty jsou zakázány, výhledově i ověřit, že existuje SSH klíč pro export na cílový stroj (podle jména a nějakých seznamů) a spoustu dalších podezřelostí))
....
Tenhle seznam pokračuje dál a dál, měl by tam být help, který to aspoň nějak naznačí a mělo by to testovat co nejvíc možných chyb, než to projde do části 2)
A ne, že by to v bashi nešlo taky nějak udělat, ale co je moc, to je moc a zrovna teď je šance s tím hnout. (Zatím se diskutuje o dalších a dalších detailech, ale ať ty diskuze dopadnou jakkoliv, tak základ bude dost podobný - žonglování s s parametry a cestama a pokud to projde, tak už docele přímočaré zpracování)

---

V principu jde o vytváření, synchronizaci atd gitových repozitářů mezi programátorem a serverem, kde programátor to dělá u sebe a na server se to pak umístí samo tím skriptem (pokud to projde přez práva).

Tohle například přidá nově vytvořený projekt do jiného repozitáře (list, ale přez symlink - taky to raději fixnout) a samozřejmě jsou skripty, které na základě toto repozitáře například postahují chybějící projekty, projdou co je a co není commitováno či pushnuto atd atd ..

echo "$GIT/$category.$projekt" >> ~/.dirs-${user}

Redirekce přez /tmp, vyexportování a následné naklonování taky už kolikrát pomohla - už byly problémy, že se někde něco nějak nepodařilo, někdo to u sebe nějak jako vyřešil a na serveru to nějak nebylo, nebo nebylo správně a pak se hledalo, co se vlastně stalo, a proč se něco rozbilo někomu úplně jinému.

Přičemž programátorů i serverů je stále víc a prakticky každý programátor má přístup na víc serverů (často ne na všechny), jeden projekt je následně sdílen více programátory a ty počty rostou. Když to začínalo, šlo o jeden server, plochou strukturu a pár lidí, kteří se dohodli "kdo to udělá a jak", no a pak se to začalo rozrůstat, některé věci se dokonce dějou automaticky přez tickety a tak a zatím nikdy "nebyl čas si hrát s takovýma věcma, zákazník che tohle a tamto co nejdřív", tak se to vždycky nějak přiohnulo a jelo se dál.

---

Takovýchle a podobných skriptů je tam víc a přibývají, nejstarší jsou v podstatě 10 let staré a chceme přejít na poněkud jinou strukturu adresářů (chceme už pár let, ale teď s tím vzniknul problém i u zákazníka, kterého si "tam" někdo všimnul dřív a i když o nic nešlo, tak to zařal řešit přez oficiální místa a ředitelství zareagovalo - a to se holt musí využít, než si to rozmyslí a budeme to "nějak" lepit dalších 10 let)

Takže technologický dluh se výrazně hlásí a je s tím potřeba udělat něco razantního. (Ten python mě taky napadnul, ale víc hlav víc ví a možná někdo přijde s něčím ještě lepším)

Zpět do poradny Odpovědět na původní otázku Nahoru