-
Notifications
You must be signed in to change notification settings - Fork 0
/
dcm
executable file
·1766 lines (1597 loc) · 52.7 KB
/
dcm
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
#!/bin/bash
# Version 3.0.0
usage() {
echo ""
echo "Das Script führt Anweisungen für die Verwaltung des kvwmap-Servers aus. Es muss als Nutzer root ausgeführt werden wenn der Nutzer nicht zur Gruppe docker gehört.";
echo "Dazu gehören Befehle zum Starten und Stoppen der Container aber auch solche zum Anzeigen von Stati und Laden von Konfigurationen und sonstige häufiger für die Administration benötigten Komandos."
echo "Kontakt: [email protected]"
echo ""
echo "Aufruf:";
echo "dcm command service|all [network|ohne]";
echo ""
echo "Varianten von command, service und network:"
echo "command gibt an was mit den Services gemacht werden soll."
echo "service gibt den Namen des Services an für den der Befehl ausgeführt werden soll. all führt den Befehl auf alle Services aus, die im docker-compose.yaml konfiguriert sind und die Cargo-Container."
echo "network gibt an welches Netzwerk gemeint ist. Wird kein Netzwerk angegeben wird der Befehl auf die Container im Netzwerk kvwmap_prod ausgeführt. Wird ohne angegeben werden die Befehle auf die Container angewendet, die noch nicht in einem Netzwerk sind. (Alte Variante der container)."
echo ""
echo "build gdal Erzeugt ein neues Image pkorduan/gdal-ssh:${GDAL_IMAGE_VERSION} an Hand des lokalen Dockerfiles."
echo "build kvwmap Erzeugt ein neues Image pkorduan/kvwmap-server:${KVWMAP_IMAGE_VERSION} an Hand des lokalen Dockerfiles."
echo "clean Löscht alle beendeten Container und nicht getaggete images."
echo "console mysql Öffnet eine Console im Mysql Container."
echo "console pgsql Öffnet eine Console im PostgreSQL Container."
echo "console web Öffnet eine Console im Web Container"
echo "console proxy Öffnet eine Console im Proxy Container"
echo "create network Erzeugt ein Netzwerk je nach Namen im 3. Parameter network"
echo "install - Installiert auf dem Hostrechner den Docker-Server und Utilities zum Betrieb der Container,"
echo " - Richtet ggf. benötigte Verzeichnisse und lokale Dateien für den Betrieb der Container ein."
echo "install all Installiert die Voraussetzungen zum Betrieb aller Container."
echo "install kvwmap Installiert die Voraussetzungen zum Betrieb des web Containers."
echo "install network Installiert die erforderlichen Ressourcen zum Betrieb des Netzwerkes mit dem Namen kvwmap_<network>. z.B. install network prod"
echo "install pydio Installiert pydio Image."
echo "mysql client Öffnet eine Komandozeile im mysql Client."
echo "mysql start Startet nur den Container mit der MySQL-Datenbank (mysql-server)"
echo "mysql status Zeigt den Status des MySQL Containers an."
echo "mysql stop Stoppt den MySQL Container und zeigt alle vorhandenen an."
echo "mysql remove Löscht den MySQL Container und zeigt die verbleibenden an. Der Container muss vorher gestoppt worden sein."
echo "mysql run Erzeugt und startet den MySQL Container mit dem Namen mysql-server."
echo "pgsql client Öffnet eine Komandozeile im psql Client."
echo "pgsql start Startet nur den Container mit der PostgreSQL-Datenbank (pgsql-server)."
echo "pgsql status Zeigt den Status des PostgreSQL-Datenbank Containers an."
echo "pgsql stop Stoppt den PostgreSQL Container und zeigt alle vorhandenen an."
echo "pgsql remove Löscht den PostgreSQL Container und zeigt die verbleibenden an. Der Container muss vorher gestoppt worden sein."
echo "pgsql run Erzeugt und startet den PostgreSQL Container mit dem Namen pgsql-server."
echo "pgsql allowip < IP> Führt das Script allowip im postgres data Verzeichnis aus, welches die IP in die pg_hba.conf einträgt für einen externen Zugriff."
echo "rebuild Stoppt und löscht Container, löscht images, die neu gebildet werden sollen, bildet diese neu und erzeugt und startet danach Container neu."
echo "rebuild all Stoppt, löscht und restartet zum rebuild des Web Containers alle Container."
echo "rebuild gdal Stoppt und löscht den gdal Container, löscht und rebuild das image pkorduan/gdal-ssh:${GDAL_IMAGE_VERSION} neu und run gdal Container neu."
echo "rebuild web Macht ein Rebuild vom image kvwmap-server:#{KVWMAP_IMAGE_VERSION}."
echo "reload Das selbe wie bei rebuild, nur dass nicht das image lokal neu gebuildet wird, sondern das latest von Dockerhub geladen wird."
echo "reload all Läd alle Container neu."
echo "relaod pgsql Lad die Konfiguration vom Postmaster im postgres-Container als Nutzer postgres neu mit dem Befehl pg_ctl reload."
echo "reload web Läd nur den Web Container neu."
echo "reload proxy Läd die Konfiguration vom Proxy-Container neu, z.B. nach Änderungen im Verzeichnis config/conf.d"
echo "rm Löscht Container."
echo "rm all Löscht alle Container."
echo "rm mysql Löscht nur den Container mysql-server."
echo "rm pgsql Löscht nur den Container pgsql-server."
echo "rm web Löscht nur den Container web."
echo "rm network Löscht das Netzwerk mit dem Namen aus dem 3. Parameter network"
echo "rerun Stoppt und löscht alle oder die angegebenen Container und erzeugt und startet sie danach wieder."
echo "rerun all Rerun für alle Container."
echo "rerun gdal Stopped und löscht nur den gdal Container und erzeugt und startet ihn anschließend neu."
echo "rerun web Stopped und löscht nur den web Container und erzeugt und startet ihn anschließend neu."
echo "restart Stoppt und löscht Container und erzeugt und startet sie neu wie beim Parameter run."
echo "restart all Führt es für alle Container aus."
echo "restart web Führt es nur für den web Container aus."
echo "run Erzeugt und startet alle oder den angegebenen Container."
echo "run all Erzeugt und startet alle Container."
echo "run proxy Erzeugt und startet nur den Container proxy."
echo "run gdal Erzeugt und startet nur den Container gdal."
echo "run mysql Erzeugt und startet nur den Container mysql-server."
echo "run pgsql Erzeugt und startet nur den Container pgsql-server."
echo "run web Erzeugt und startet nur den Container web."
echo "show_ip Zeigt die IP Adressen der Container an. Der Containername als zusätzlicher Parameter zeigt nur die IP dieses Containers an."
echo "start Startet alle oder den angegebenen Container."
echo "start all Startet alle Container."
echo "start proxy Startet den Proxy Container."
echo "start mysql Startet nur den Container mysql-server."
echo "start pgsql Startet nur den Container pgsql-server."
echo "start pydio Startet nur den Container pydio."
echo "start web Startet nur den Container web."
echo "status Listet Status der angegebenen Container auf."
echo "status all Listet den Status aller Container auf."
echo "status mysql Listet den Status des Containers mysql-server."
echo "status pgsql Listet den Status des Containers pgsql-server."
echo "status web Listet den Status des Containers web"
echo "stop Stoppt alle oder einen der angegebenen Container."
echo "stop all Stoppt alle Container."
echo "stop mysql Stoppt nur den Container mysql-server."
echo "stop pgsql Stoppt nur den Container pgsql-server."
echo "stop web Stoppt nur den Container web."
echo "uninstall Vorsicht, Stoppt und löscht Container, löscht Images und deinstalliert eingerichtete Verzeichnisse auf dem Host-Rechner."
echo "uninstall all Deinstalliert alle images."
echo "uninsall gdal Deinstalliert das gdal image pkorduan/gdal-ssh:${GDAL_IMAGE_VERSION} und die dazugehörigen lokalen Ressourcen auf dem Hostrechner."
echo "uninstall kvwmap Deinstalliert kvwmap-server."
echo " Dazu gehören die Verzeichnisse networks, proxy und kvwmap-server"
echo " unter dem Installationsverzeichnis z.B. unter /home/gisadmin"
echo " Damit werden auch alle Daten und Datenbankinhalte gelöscht."
echo "update cron Aktualisiert umgehend die cronjobs des Nutzers gisadmin im Web Container durch die Eintragungen,"
echo " die mit kvwmap in die Datei /var/www/cron/crontab_gisadmin geschrieben wurden."
echo ""
echo "Als Netzwerknamen können alle in kvwmap-server/config/config definierten Cases verwendet werden. Defaultmäßig sind die kvwmap_prod, kvwmap_dev und kvwmap_test verfügbar."
echo "Ohne Angabe des Netzwerknames wird kvwmap_prod verwendet!"
echo "Beispiele:"
echo "$0 start"
echo "$0 stop"
echo "$0 pgsql status"
echo "$0 rerun web kvwmap_dev"
echo ""
echo "Je nach dem welche Erweiterungen in cargo-enabeld eingestellt sind gibt es weitere Befehle. Folgende sind derzeit aktiviert:"
usage_cargos
}
usage_cargos() {
#echo "Show usage of cargos."
for cargo in "${CARGOS[@]}"
do
#echo "usage_$cargo"
usage_$cargo
done
}
debug() {
if $DEBUG ; then
echo $1
fi
}
build_kvwmap_server() {
TAG=$1
if [ -z "$TAG" ] ; then
TAG=$KVWMAP_IMAGE_VERSION
fi
cd $USER_DIR/kvwmap-server/docker
docker build -t pkorduan/kvwmap-server:${TAG} .
}
build_gdal_image() {
TAG=$1
if [ -z "$TAG" ] ; then
TAG="latest"
fi
echo "Build the image pkorduan/gdal-sshd:$TAG"
cd $USER_DIR/gdal-sshd
docker build -t pkorduan/gdal-sshd:$TAG .
}
call_cargo_cases() {
#debug "Call cargo cases with Arguments '$1' and '$2' and '$3'"
#echo "Call cargo cases with Arguments '$1' and '$2' and '$3'"
any_case_found=false
for cargo in "${CARGOS[@]}"
do :
#debug "Search for case $1 $2 in cargo $cargo"
#echo " Search for case $1 $2 in cargo $cargo cases_$cargo"
cases_$cargo $1 $2 $3
if $case_found ; then
#echo "Found case in cargo $cargo $1 $2"
any_case_found=true
fi
done
debug "Any case found after call all cargo cases: $any_case_found"
if ! $any_case_found ; then
echo "$any_case_found nicht gefunden"
echo "Gib nach $1 die Parameter $core_sub_cases"
if [ "${#CARGOS[@]}" -gt "0" ] ; then
printf "oder %s " "${CARGOS[@]}"
fi
echo "an."
fi
}
# Bricht ab, wenn nutzer nicht root ist und nicht in docker gruppe
fail_unless_root() {
dcm_user=$(id -nu)
dcm_user_group=$(id -nG)
# Wenn ausführender Nutzer nicht root ist
if [ "${dcm_user}" != "root" ]; then
# Prüfe ob ausführende Nutzer in Gruppe docker ist
if [[ "$dcm_user_group" != *"docker"* ]] ; then
echo "Nutzer ${dcm_user} ist nicht berechtigt das Script dcm auszuführen."
echo "Führen Sie das Script als root aus oder fügen Sie den Nutzer ${dcm_user} mit dem Befehhl"
echo "/usr/sbin/usermod -a -G docker ${dcm_user}"
echo "zur Gruppe von docker hinzu."
exit 1
# else
#echo "${dcm_user} in gruppe ${dcm_user_group}"
fi
fi
}
load_cargo() {
#echo "Load cargo source code."
#echo "Load Container Configurations in $CARGOPATH."
#echo "Consider that they will loaded in the alphanumeric order of the symbolic links in $CARGOPATH."
dcmfiles=($(find -L $CARGOPATH -name dcm))
dcmfiles=($(echo "${dcmfiles[@]}" | sed 's/ /\n/g' | sort))
for dcmfile in ${dcmfiles[@]}
do
echo "Load dcmfile: ${dcmfile}"
source $dcmfile
done
#echo "CARGOS: "
#printf '%s\n' "${CARGOS[@]}"
#echo ""
}
install_cargos() {
for cargo in "${CARGOS[@]}"
do :
install_$cargo
done
}
install_docker() {
echo "Install docker auf dem Hostrechner ..."
# Update debian repo
apt-get update && apt-get install -y \
apt-utils \
curl \
jq \
sendemail \
unzip \
wget
# install docker demon and client on host system if not exists already
case `docker --version` in
*Docker*)
echo 'Docker schon installiert!'
;;
*)
echo 'Installiere docker ....'
curl -sSL https://get.docker.com/ | sh
mkdir $USER_DIR/docker/lib
systemctl stop docker
mv /var/lib/docker $USER_DIR/docker/lib
ln -s $USER_DIR/docker/lib/docker /var/lib/docker
systemctl start docker
;;
esac
# enable memory and swap accounting. This prevent from
# WARNING: Your kernel does not support cgroup swap limit. and
# WARNING: Your kernel does not support swap limit capabilities. Limitation discarded.
# This setting affects only after rebooting the system
sed -i \
-e "s|GRUB_CMDLINE_LINUX=\"\"|GRUB_CMDLINE_LINUX=\"cgroup_enable=memory swapaccount=1\"|g" \
/etc/default/grub
update-grub
}
install_docker-compose() {
echo "Installiere docker-compose"
curl -L "https://github.com/docker/compose/releases/download/1.29.2/docker-compose-$(uname -s)-$(uname -m)" -o /usr/bin/docker-compose
chmod +x /usr/bin/docker-compose
}
install_kvwmap_network() {
fail_unless_root
echo "Installiere Voraussetzungen für den Betrieb des Netzwerkes $network_name"
if [ -d "$NETWORK_DIR" ]; then
read -p "Netzwerk $network_name existiert bereits. Soll es gelöscht und neu angelegt werden (j/n)? " answer
case ${answer:0:1} in
j|Y )
if [ ! "$(whoami)" == "root" ] ; then
echo "Die Funktion kann nur als root ausgeführt werden. Abbruch!"
return
fi
rm -R "$NETWORK_DIR"
;;
* )
echo "OK, nix passiert!"
return
;;
esac
fi
mkdir -p "$USER_DIR/networks"
cp -R -p "$USER_DIR/kvwmap-server/networks/kvwmap_prod" "$USER_DIR/networks/$network_name"
rm $USER_DIR/networks/${network_name}/pgsql/data/*
chown -R 999.gisadmin $USER_DIR/networks/${network_name}/mysql
chown -R 999.gisadmin $USER_DIR/networks/${network_name}/pgsql
chmod -R g+w $USER_DIR/networks/${network_name}/pgsql/logs
chown root.root $USER_DIR/networks/${network_name}/web/www/cron/crontab_root
chown gisadmin.gisadmin $USER_DIR/networks/${network_name}/web/www/cron/crontab_gisadmin
chmod 600 $USER_DIR/networks/${network_name}/web/www/cron/crontab_root $USER_DIR/networks/${network_name}/web/www/cron/crontab_gisadmin
chown root.root $USER_DIR/networks/${network_name}/pgsql/.pgpass
chown gisadmin.gisadmin $USER_DIR/networks/${network_name}/pgsql/.pgpass_gisadmin
chmod 600 $USER_DIR/networks/${network_name}/pgsql/.pgpass $USER_DIR/networks/${network_name}/pgsql/.pgpass_gisadmin
compose_file="$USER_DIR/networks/${network_name}/docker-compose.yaml"
echo "Verzeichnis $NETWORK_DIR neu angelgt."
# kvwmap_prod durch neuen Netzwerknamen austauschen
sed -i \
-e "s|kvwmap_prod|${network_name}|g" \
$compose_file
# Fragt den ip-range von docker-compose.yaml ab und addiert 10 zum C-Netz dazu
ip_range="\
$(yq e '.networks.'${network_name}'.ipam.config[0].subnet' ${compose_file} | awk -F. '{print $1}').\
$(yq e '.networks.'${network_name}'.ipam.config[0].subnet' ${compose_file} | awk -F. '{print $2}').\
$(expr $(yq e '.networks.'${network_name}'.ipam.config[0].subnet' ${compose_file} | awk -F. '{print $3}') + 10).\
$(yq e '.networks.'${network_name}'.ipam.config[0].subnet' ${compose_file} | awk -F. '{print $4}')\
"
sed -i \
-e "s|$(yq e '.networks.'${network_name}'.ipam.config[0].subnet' ${compose_file})|${ip_range}|g" \
$compose_file
echo "IP-Range vom Netzwerk ${network_name} eingestellt auf: ${ip_range}. Bitte ggf. anpassen!"
# Zählt Port von pgsql um einen hoch
pgsql_port=$(yq e '.services.pgsql.ports[0]' $compose_file | awk -F: '{print $1}')
sed -i \
-e "s|${pgsql_port}:5432|$(expr ${pgsql_port} + 1):5432|g" \
$compose_file
echo "Port von pgsql Container nach außen auf $pgsql_port gesetzt. Bitte ggf. anpassen!"
if [ -d "$USER_DIR/proxy" ]; then
read -p "Das proxy Verzeichnis existiert bereits. Soll es gelöscht und neu angelegt werden? (j/n)? " answer
case ${answer:0:1} in
j|Y )
rm -R "$USER_DIR/proxy"
echo "Das proxy Verzeichnis wird angelegt."
cp -R -p "$USER_DIR/kvwmap-server/proxy" "$USER_DIR/proxy"
;;
* )
echo "OK, wir lassen das bestehende so wie es ist!"
;;
esac
else
cp -R -p "$USER_DIR/kvwmap-server/proxy" "$USER_DIR/proxy"
fi
echo "fertig
"
echo "Die Container im Netzwerk ${network_name} können jetzt gestartet werden mit dcm run all $3"
}
copy_directories() {
dcm rm all ohne
rm -R $USER_DIR/networks/$network_name/web/www
mv $USER_DIR/docker/www $USER_DIR/networks/$network_name/web/www
ln -s $USER_DIR/networks/$network_name/web/www $USER_DIR/docker/www
mv $USER_DIR/db/mysql/* $USER_DIR/networks/$network_name/mysql/data
mv $USER_DIR/etc/mysql/my.cnf $USER_DIR/networks/$network_name/mysql/etc/my.cnf
mv $USER_DIR/etc/mysql/conf.d/* $USER_DIR/networks/$network_name/mysql/etc/conf.d/
mv $USER_DIR/www/logs/mysql/* $USER_DIR/networks/$network_name/mysql/logs
chown -R 999.gisadmin $USER_DIR/networks/$network_name/mysql
ln -s $USER_DIR/networks/$network_name/mysql/etc/my.cnf $USER_DIR/etc/mysql/my.cnf
rm -d $USER_DIR/db/mysql/
ln -s $USER_DIR/networks/$network_name/mysql/data $USER_DIR/db/mysql
rm -R $USER_DIR/networks/$network_name/pgsql
mv $USER_DIR/db/postgresql/data $USER_DIR/networks/$network_name/pgsql
mv $USER_DIR/etc/postgresql/.pgpass $USER_DIR/networks/$network_name/pgsql/.pgpass
mv $USER_DIR/etc/postgresql/.pgpass_gisadmin $USER_DIR/networks/$network_name/pgsql/.pgpass_gisadmin
mv $USER_DIR/networks/$network_name/web/www/logs/pgsql/* $USER_DIR/networks/$network_name/pgsql/logs
rm -d $USER_DIR/networks/$network_name/web/www/logs/pgsql
rm -d $USER_DIR/db/postgresql
ln -s $USER_DIR/networks/kvwmap_prod/pgsql $USER_DIR/db/postgresql
rm -R $USER_DIR/proxy/letsencrypt/live
mv $USER_DIR/etc/apache2/letsencrypt/live $USER_DIR/proxy/letsencrypt
mv $USER_DIR/etc/apache2/letsencrypt/csr $USER_DIR/proxy/letsencrypt
mv $USER_DIR/etc/apache2/letsencrypt/keys $USER_DIR/proxy/letsencrypt
mv $USER_DIR/etc/apache2/letsencrypt/archive $USER_DIR/proxy/letsencrypt
cp -Rp $USER_DIR/proxy/letsencrypt/live $USER_DIR/etc/apache2/letsencrypt/live
cp -Rp $USER_DIR/proxy/letsencrypt/keys/ $USER_DIR/etc/apache2/letsencrypt/keys
cp -Rp $USER_DIR/proxy/letsencrypt/csr/ $USER_DIR/etc/apache2/letsencrypt/csr
cp -Rp $USER_DIR/proxy/letsencrypt/archive/ $USER_DIR/etc/apache2/letsencrypt/archive
dcm run all ohne
}
install_kvwmap_images() {
echo "Installiere Voraussetzungen für den Betrieb von kvwmap ..."
if [ ! "$(whoami)" == "root" ] ; then
echo "Die Funktion kann nur als root ausgeführt werden. Abbruch!"
return
fi
/usr/sbin/usermod -a -G docker $OS_USER
echo "
Setze bash Einstellungen für user: ${OS_USER} ..."
# set bash settings for web gis user
cp /etc/skel/.bashrc $USER_DIR/.bashrc
echo "
export PATH=\$PATH:${USER_DIR}/kvwmap-server" >> $USER_DIR/.bashrc
sed -i \
-e "s|#alias ll=|alias ll=|g" \
-e "s|alias rm=|#alias rm=|g" \
$USER_DIR/.bashrc
echo "alias l='ls -alh --color=yes'" >> $USER_DIR/.bashrc
echo "export PS1=\"\[\e[0m\]\[\e[01;31m\]\u\[\e[0m\]\[\e[00;37m\]@\[\e[0m\]\[\e[01;34m\]\h\[\e[0m\]\[\e[00;37m\]:\[\e[0m\]\[\e[01;37m\]\w\[\e[0m\]\[\e[00;37m\] \\$ \[\e[0m\]\"" >> $USER_DIR/.bashrc
echo "set nocompatible" >> $USER_DIR/.vimrc
cp $USER_DIR/.bashrc ~/.bashrc
cp $USER_DIR/.vimrc ~/.vimrc
source ~/.bashrc
install_kvwmap_network
echo "
Erzeuge restliche Verzeichnisstruktur für die Datenbank und Web-Anwendungen von kvwmap ..."
ln -s "$NETWORK_DIR/web/www" "$USER_DIR/www"
mkdir -p "$USER_DIR/db"
ln -s "$NETWORK_DIR/mysql/data" "$USER_DIR/db/mysql"
ln -s "$NETWORK_DIR/pgsql/data" "$USER_DIR/db/postgresql"
echo "
Erzeuge Unterverzeichnis sites-enabled im Apache Konfigurationsverzeichnis..."
mkdir -p "$NETWORK_DIR/web/apache2/sites-enabled"
echo "
Clone kvwmap von github ins Web-Verzeichnis ..."
if [ ! -d "${USER_DIR}/networks/$network_name/web/www/apps/kvwmap" ]; then
# clone kvwmap repository into apps
git clone https://github.com/srahn/kvwmap.git "$NETWORK_DIR/web/www/apps/kvwmap"
cd "$NETWORK_DIR/web/www/apps/kvwmap"
git checkout develop
fi
echo "
Erzeuge kvwmap custom Verzeichnisse für Fonts, Grafik, Symbole und Layouts ..."
mkdir -p $NETWORK_DIR/web/www/apps/kvwmap/custom/fonts \
$NETWORK_DIR/web/www/apps/kvwmap/custom/graphics \
$NETWORK_DIR/web/www/apps/kvwmap/custom/wappen \
$NETWORK_DIR/web/www/apps/kvwmap/custom/layouts \
$NETWORK_DIR/web/www/apps/kvwmap/custom/layouts/snippets \
$NETWORK_DIR/web/www/apps/kvwmap/custom/symbols
touch $NETWORK_DIR/web/www/apps/kvwmap/custom/layouts/custom.css
wget -O $NETWORK_DIR/web/www/apps/kvwmap/custom/wappen/Logo_GDI-Service_200x47.png https://gdi-service.de/public/kvwmap_resources/Logo_GDI-Service_200x47.png
echo "#geo_name_search_field {
width: 100%;
}
#search_div {
display: none;
}" >> $NETWORK_DIR/web/www/apps/kvwmap/custom/layouts/custom.css
cd $NETWORK_DIR/web/www/apps
echo "
Setze Rechte auf kvwmap Datenverzeichnisse ..."
chown -R $OS_USER.$OS_USER $USER_DIR $NETWORK_DIR/web/www
chmod -R g+w $NETWORK_DIR/web/www
echo "
Setze Rechte auf Datenbankverzeichnisse ..."
chown -R 999.$OS_USER $NETWORK_DIR/mysql $NETWORK_DIR/pgsql
chmod 700 $NETWORK_DIR/pgsql
echo "
Setze Rechte auf logs Verzeichnisse ..."
chmod g+rw $NETWORK_DIR/pgsql/logs; chmod g+r $NETWORK_DIR/mysql/logs $NETWORK_DIR/web/www/logs
echo "
Setze Rechte 600 auf .pgpass ..."
chown root.root $NETWORK_DIR/pgsql/.pgpass
chmod 600 $NETWORK_DIR/pgsql/.pgpass
chown $OS_USER.$OS_USER $NETWORK_DIR/pgsql/.pgpass_gisadmin
chmod 600 $NETWORK_DIR/pgsql/.pgpass_gisadmin
echo "Initialisiere das Postgres Datenbank-Cluster"
run_pgsql_container
stop_pgsql_container
remove_pgsql_container
cp $USER_DIR/kvwmap-server/pgsql/pg_hba.conf $NETWORK_DIR/pgsql/data/
chown 999.docker $NETWORK_DIR/pgsql/data/pg_hba.conf
cp $USER_DIR/kvwmap-server/pgsql/allowip $NETWORK_DIR/pgsql/data/
chown 999.docker $NETWORK_DIR/pgsql/data/allowip
sed -i -e "s|#log_destination = 'stderr'|log_destination = 'csvlog'|g" $NETWORK_DIR/pgsql/data/postgresql.conf
sed -i -e "s|#logging_collector = off|logging_collector = on|g" $NETWORK_DIR/pgsql/data/postgresql.conf
sed -i -e "s|#log_directory = 'pg_log'|log_directory = '/var/log/postgresql'|g" $NETWORK_DIR/pgsql/data/postgresql.conf
sed -i -e "s|#log_filename = 'postgresql-%Y-%m-%d_%H%M%S.log'|log_filename = 'pgsql-%Y-%m-%d.log'|g" $NETWORK_DIR/pgsql/data/postgresql.conf
sed -i -e "s|#log_file_mode = 0600|log_file_mode = 0640|g" $NETWORK_DIR/pgsql/data/postgresql.conf
sed -i -e "s|#log_truncate_on_rotation = off|log_truncate_on_rotation = on|g" $NETWORK_DIR/pgsql/data/postgresql.conf
sed -i -e "s|#log_rotation_age = 1d|log_rotation_age = 1d|g" $NETWORK_DIR/pgsql/data/postgresql.conf
sed -i -e "s|#log_rotation_size = 10MB|log_rotation_size = 0|g" $NETWORK_DIR/pgsql/data/postgresql.conf
sed -i -e "s|#log_line_prefix = ''|log_line_prefix = '%t:%r:%u@%d:[%p]: '|g" $NETWORK_DIR/pgsql/data/postgresql.conf
sed -i -e "s|#log_statement = 'none'|log_statement = 'mod'|g" $NETWORK_DIR/pgsql/data/postgresql.conf
chown 999.docker $NETWORK_DIR/pgsql/data/postgresql.conf
read -p "Add IP to allow external access with pgAdmin Client: " PGADMIN_IP
echo "host all kvwmap ${PGADMIN_IP}/32 md5 # externe IP for external pgAdmin access" >> $NETWORK_DIR/pgsql/data/pg_hba.conf
echo "host kvwmapsp kvwmap 217.160.173.232/32 md5 # GDI-Service Server" >> $NETWORK_DIR/pgsql/data/pg_hba.conf
echo "host kvwmapsp kvwmap 90.187.125.49/32 md5 # GDI-Service Buero" >> $NETWORK_DIR/pgsql/data/pg_hba.conf
echo "
Installation abgeschlossen. Die Container können gestartet werden mit dcm run all"
}
is_stopped() {
if [ "$(docker ps -a -q -f name=$1 -f status=exited)" ] ; then
echo 'true'
else
echo 'false'
fi;
}
is_running() {
if [ "$(docker inspect --format="{{ .State.Running }}" $1 2> /dev/null)" == "true" ] ; then
echo 'true';
else
echo 'false';
fi;
}
migrate_to_mariadb() {
echo "Migrate MySQL image to MariaDB..."
# backup mysql-Databases
stop_all_container
remove_all_container
# backup env_and_volume
# overwrite env_and_volume from kvwmap-server
run_all_container
# restore mysql-Databases
}
ps_container() {
if [ -z $1 ] ; then
echo "Liste alle Container"
docker ps -a
else
echo "Liste nur Container im Netzwerk $1"
docker ps -a --filter network=$1 | sort -k 2
fi
}
remove_all_container() {
echo "Lösche alle Container ..."
remove_web_container
remove_mysql_container
remove_pgsql_container
remove_gdal_container
echo "Alle Container gelöscht."
}
remove_networks() {
echo "Remove all unused networks"
docker network prune -f
}
remove_network() {
echo "Remove network ${network_name}"
cmd="docker network rm ${network_name}"
echo $cmd
$cmd
}
remove_proxy_container() {
echo "Entferne proxy Container"
cmd="docker-compose -f ${USER_DIR}/proxy/docker-compose.yaml rm nginx"
echo $cmd
$cmd
}
remove_gdal_container() {
remove_container gdal
}
remove_mysql_container() {
if [ "${network_name}" == "kvwmap_ohne" ]; then
remove_container mysql-server
else
remove_container mysql
fi
}
remove_pgsql_container() {
if [ "${network_name}" == "kvwmap_ohne" ]; then
remove_container pgsql-server
else
remove_container pgsql
fi
}
remove_web_container() {
remove_container web
}
remove_container() {
if [ "${network_name}" == "kvwmap_ohne" ]; then
echo "Entferne Container $1"
cmd="docker rm $1"
else
echo "Entferne Container $1 in Netzwerk ${network_name}"
cmd="docker-compose -f /home/gisadmin/networks/${network_name}/docker-compose.yaml rm -s $1"
fi
echo $cmd
$cmd
}
remove_all_images() {
echo "Lösche alle Images ..."
docker rmi $(docker images | awk "{print $3}")
echo "Alle Images gelöscht."
}
run_all_container() {
echo "Erzeuge und Starte alle Container ..."
run_mysql_container
if type -t run_oracle_container | grep -q "^function$" ; then
run_oracle_container
fi
run_pgsql_container
run_gdal_container
if type -t run_geoserver_container | grep -q "^function$" ; then
run_geoserver_container
fi
if type -t run_tomcat_container | grep -q "^function$" ; then
run_tomcat_container
fi
if type -t run_pydio_container | grep -q "^function$" ; then
run_pydio_container
fi
if type -t run_owncloud_container | grep -q "^function$" ; then
run_owncloud_container
fi
if type -t run_owncloud_10.0.10_container | grep -q "^function$" ; then
run_owncloud_10.0.10_container
fi
if type -t run_deegree_container | grep -q "^function$" ; then
run_deegree_container
fi
if type -t run_osm2po_container | grep -q "^function$" ; then
run_osm2po_container
fi
if type -t run_bucardo_container | grep -q "^function$" ; then
run_bucardo_container
fi
if type -t run_ftpserver_container | grep -q "^function$" ; then
run_ftpserver_container
fi
run_web_container
if [ "${network_name}" != "kvwmap_ohne" ]; then
if [ $( docker ps -a | grep proxy_nginx_1 | wc -l ) -gt 0 ]; then
echo "Proxy Container existiert bereits."
else
echo "Proxy Container existiert noch nicht."
run_proxy_container
fi
fi
}
run_cargo_containers() {
for cargo in "${CARGOS[@]}"
do
run_${cargo}_container
done
}
run_gdal_container() {
if [ "${network_name}" == "kvwmap_ohne" ]; then
echo "Erzeuge und Starte container gdal"
source $USER_DIR/etc/gdal/env_and_volumes
echo ${SERVER_NAME}-gdal-container
cmd="docker run --name gdal \
-h ${SERVER_NAME}-gdal-container \
--link pgsql-server:pgsql \
$gdal_env_vars \
$gdal_volumes \
$gdal_ports \
--restart=always \
-d ${GDAL_IMAGE}:${GDAL_IMAGE_VERSION}"
else
echo "Erzeuge und Starte container gdal im Netzwerk ${network_name}"
cmd="docker-compose -f /home/gisadmin/networks/${network_name}/docker-compose.yaml up -d gdal"
fi
echo $cmd
$cmd
}
run_mysql_container() {
if [ "${network_name}" == "kvwmap_ohne" ]; then
source $USER_DIR/etc/mysql/env_and_volumes
if [ -z "${START_MYSQL_WITH_DCM}" ] ; then
START_MYSQL_WITH_DCM="true"
fi
if [ "${START_MYSQL_WITH_DCM}" = "true" ] ; then
echo "Erzeuge und Starte container mysql"
cmd="docker run --name mysql-server \
-h ${SERVER_NAME}-mysql-container \
$mysql_env_vars \
$mysql_volumes \
$mysql_ports \
--restart=always \
-d ${MYSQL_IMAGE}:${MYSQL_IMAGE_VERSION}"
else
echo "Starten von mysql container wird ausgelassen weil START_MYSQL_WITH_DCM auf false steht."
fi
else
echo "Erzeuge und Starte container mysql im Netzwerk ${network_name}"
if [ ! -d "${USER_DIR}/networks/${network_name}/mysql/data/mysql" ] ; then
read -sp "Vergebe ein Passwort für MySQL-Nutzer root: " MYSQL_ROOT_PASSWORD
export MYSQL_ROOT_PASSWORD=$MYSQL_ROOT_PASSWORD
fi
cmd="docker-compose -f /home/gisadmin/networks/${network_name}/docker-compose.yaml up -d mysql"
fi
echo $cmd
$cmd
}
run_pgsql_container() {
if [ "${network_name}" == "kvwmap_ohne" ]; then
source $USER_DIR/etc/postgresql/env_and_volumes
if [ "${START_WITH_DCM}" = "true" ] ; then
echo "Erzeuge und Starte container pgsql"
if [ -z "$pgsql_ports" ] ; then
pgsql_ports="-p 5432:5432"
fi
if [ -z "${PGSQL_CONTAINER_NAME}" ] ; then
PGSQL_CONTAINER_NAME="pgsql-server"
fi
if [ -z "$pgsql_config" ] ; then
pgsql_config=""
fi
set_cargo_pgsql_links
cmd="docker run --name ${PGSQL_CONTAINER_NAME} \
-h ${SERVER_NAME}-${PGSQL_CONTAINER_NAME} \
$CARGO_PGSQL_LINKS \
$pgsql_env_vars \
$pgsql_volumes \
$pgsql_ports \
--restart=always \
-d ${PGSQL_IMAGE}:${PGSQL_IMAGE_VERSION} \
$pgsql_config"
else
echo "Starten von pgsql container wird ausgelassen weil START_WITH_DCM auf false steht."
fi
else
if [ ! -d "${USER_DIR}/networks/${network_name}/pgsql/data/base" ] ; then
read -sp "Vergebe ein Passwort für Postgres-Nutzer postgres: " POSTGRES_PASSWORD
export POSTGRES_PASSWORD=$POSTGRES_PASSWORD
fi
echo "Starte container postgres im Netzwerk: ${network_name}"
cmd="docker-compose -f /home/gisadmin/networks/${network_name}/docker-compose.yaml up -d pgsql"
fi
echo $cmd
$cmd
}
run_web_container() {
if [ "${network_name}" == "kvwmap_ohne" ]; then
source $USER_DIR/etc/web/env_and_volumes
if [ -z "${web_hosts}" ]; then
web_hosts="--add-host=$DOMAIN_NAME:${IP_EXTERN} \
--add-host=$SERVER_NAME:${IP_EXTERN}"
fi
if [ -z "${web_ports}" ]; then
web_ports="-p 80:80 \
-p 443:443"
fi
set_cargo_web_links
cmd="docker run --name web \
-h ${SERVER_NAME}-web-container \
--link mysql-server:mysql \
--link pgsql-server:pgsql \
--link gdal:gdal \
$CARGO_WEB_LINKS \
$web_env_vars \
$web_volumes \
$web_hosts \
$web_ports \
--restart=always \
-d ${KVWMAP_IMAGE}:${KVWMAP_IMAGE_VERSION} \
"
echo "Starte web Container:"
else
create_bridge_network
echo "Starte container web im Netzwerk: ${network_name}"
cmd="docker-compose -f /home/gisadmin/networks/${network_name}/docker-compose.yaml up -d web"
fi
echo $cmd
$cmd
}
run_proxy_container() {
echo "Starte proxy Container"
docker-compose -f $USER_DIR/proxy/docker-compose.yaml up -d nginx
}
reload_pgsql_container() {
cmd="docker exec --user postgres kvwmap_prod_pgsql_1 /usr/lib/postgresql/13/bin/pg_ctl reload"
echo "Reload PostgreSQL-Konfiguration im pgsql-Container:"
echo $cmd
$cmd
}
reload_proxy_container() {
cmd="docker exec proxy_nginx_1 nginx -s reload"
echo "Reload Konfiguration des proxy Containers:"
echo $cmd
$cmd
}
test_proxy_container() {
cmd="docker exec proxy nginx -t"
echo "Teste proxy Container:"
echo $cmd
$cmd
}
set_cargo_web_links() {
for cargo in "${CARGOS[@]}"
do :
set_${cargo}_web_link
done
}
set_cargo_pgsql_links() {
for cargo in "${CARGOS[@]}"
do :
if type -t set_${cargo}_pgsql_link | grep -q "^function$" ; then
set_${cargo}_pgsql_link
fi
done
}
show_all_container_ips() {
docker inspect -f="Container {{.Name}} IP: {{ .NetworkSettings.Networks.${network_name}.IPAddress }}" $(docker ps -aq)
}
show_container_ip() {
docker inspect -f="Container {{.Name}} IP: {{ .NetworkSettings.Networks.${network_name}.IPAddress }}" $1
}
show_container_status() {
CONTAINER=$1
echo "Status des Containers $CONTAINER:"
RUNNING=$(docker inspect --format="{{ .State.Running }}" $CONTAINER 2> /dev/null)
if [ $? -eq 1 ]; then
echo "UNKNOWN - Container $CONTAINER does not exist."
return 3
fi
if [ "$RUNNING" == "false" ]; then
echo "CRITICAL - $CONTAINER is not running."
return 2
fi
STARTED=$(docker inspect --format="{{ .State.StartedAt }}" $CONTAINER)
NETWORK=$(docker inspect --format="{{ .NetworkSettings.IPAddress }}" $CONTAINER)
echo "OK - $CONTAINER is running. IP: $NETWORK, StartedAt: $STARTED"
}
start_all_container() {
echo "Startet alle existierenden Container."
start_mysql_container
start_pgsql_container
# start_cargo_container
start_gdal_container
start_web_container
docker ps
}
start_container() {
if [ "${network_name}" == "kvwmap_ohne" ]; then
echo "Starte container $1"
container=$1
if [ ! -z $container ] ; then
if [ "$(is_running $container)" == "true" ]; then
echo "Container $container läuft schon.";
else
if [ "$(is_stopped $container)" == "false" ]; then
run_${container}_container
else
echo "Starte Container ${container} ..."
cmd="docker start $1"
fi
fi
fi
else
echo "Starte container $1 in Network: ${network_name}"
cmd="docker-compose -f /home/gisadmin/networks/${network_name}/docker-compose.yaml start $1"
fi
echo $cmd
$cmd
}
start_gdal_container() {
echo "Starte gdal Container."
docker start gdal
}
start_mysql_container() {
if [ "${network_name}" == "kvwmap_ohne" ]; then
start_container mysql-server
else
start_container mysql
fi
}
start_pgsql_container() {
if [ "${network_name}" == "kvwmap_ohne" ]; then
start_container pgsql-server
else
start_container pgsql
fi
}
start_web_container() {
echo "Starte web Container."
docker start web
}
stop_all_container() {
echo "Stoppe alle Container. Bitte warten ..."
stop_web_container
stop_mysql_container
stop_pgsql_container
stop_gdal_container
# docker-compose -f /home/gisadmin/networks/${network_name}/docker-compose.yaml rm -s
echo "Alle Container gestopped."
}
stop_container() {
if [ "${network_name}" == "kvwmap_ohne" ]; then
echo "Stoppe container $1"
cmd="docker stop $1"
else
echo "Stoppe container $1 in Network: ${network_name}"
cmd="docker-compose -f /home/gisadmin/networks/${network_name}/docker-compose.yaml stop $1"
fi
echo $cmd
$cmd
}
stop_proxy_container() {
if [[ -n $(docker ps -a -f status=running -f name=proxy_nginx_1 -q) ]] ; then
echo "Stoppe proxy Container. Bitte warten ..."
cmd="docker-compose -f ${USER_DIR}/proxy/docker-compose.yaml stop nginx"
echo $cmd
$cmd
fi
}
stop_gdal_container() {
# if [ "$(docker ps -a -q -f name=gdal -f status=running)" ] ; then
stop_container gdal
# else
# echo "Container gdal kann nicht gestoppt werden, weil er nicht läuft."
# fi
}
stop_mysql_container() {
if [ "${network_name}" == "kvwmap_ohne" ]; then
stop_container mysql-server
else
stop_container mysql
fi
}
stop_pgsql_container() {
if [ "${network_name}" == "kvwmap_ohne" ]; then
stop_container pgsql-server
else
stop_container pgsql
fi
}
stop_web_container() {
stop_container web
}
uninstall_cargos() {
for cargo in "${CARGOS[@]}"