/
git-ftp
executable file
·1847 lines (1658 loc) · 49.1 KB
/
git-ftp
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
#!/usr/bin/env bash
#
# Copyright 2010-2015 René Moser
# http://github.com/git-ftp/git-ftp
#
# Git-ftp is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# Git-ftp is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Git-ftp. If not, see <http://www.gnu.org/licenses/>.
# ------------------------------------------------------------
# Setup Environment
# ------------------------------------------------------------
# General config
readonly DEFAULT_PROTOCOL="ftp"
readonly REMOTE_LCK_FILE="$(basename "$0").lck"
readonly SYSTEM="$(uname)"
readonly VERSION='1.6.0'
# ------------------------------------------------------------
# Defaults
# ------------------------------------------------------------
URL=""
REMOTE_PROTOCOL=""
REMOTE_HOST=""
REMOTE_USER=""
REMOTE_PASSWD=""
REMOTE_BASE_URL=""
REMOTE_BASE_URL_DISPLAY=""
REMOTE_ROOT=""
REMOTE_PATH=""
REMOTE_CACERT=""
REMOTE_DELETE_CMD="-*DELE "
REMOTE_CMD_OPTIONS=("-s")
LFTP_OPTIONS=""
ACTION=""
LOG_CACHE=""
ERROR_LOG=""
BRANCH=""
CURRENT_BRANCH=""
SCOPE=""
KEYCHAIN_USER=""
KEYCHAIN_HOST=""
DEPLOYED_SHA1_FILE=".git-ftp.log"
DEPLOYED_SHA1=""
PREV_DEPLOYED_SHA1=""
LOCAL_SHA1=""
SYNCROOT=""
SNAPSHOT_DIR=""
CURL_PROTOCOL=""
CURL_PUBLIC_KEY=""
CURL_PRIVATE_KEY=""
CURL_PROXY=""
LFTP_PROTOCOL=""
LFTP_COMMAND_SETTINGS=""
TMP_DIR=""
TMP_CURL_UPLOAD_FILE=""
TMP_CURL_DELETE_FILE=""
TMP_GITFTP_UPLOAD=""
TMP_GITFTP_DELETE=""
TMP_GITFTP_INCLUDE=""
declare -a CURL_ARGS
declare -a GIT_SUBMODULES
declare -i VERBOSE=0
declare -i IGNORE_DEPLOYED=0
declare -i DOWNLOAD_CHANGED_ONLY=0
declare -i DRY_RUN=0
declare -i FORCE=0
declare -i ENABLE_REMOTE_LCK=0
declare -i ACTIVE_MODE=0
declare -i USE_KEYCHAIN=0
declare -i EXECUTE_HOOKS=1
declare -i ENABLE_POST_HOOK_ERRORS=0
declare -i AUTO_INIT=0
declare -i INSECURE=0
declare -i CURL_DISABLE_EPSV=0
declare -i NO_COMMIT=0
# ------------------------------------------------------------
# Constant Exit Error Codes
# ------------------------------------------------------------
readonly ERROR_USAGE=2
readonly ERROR_MISSING_ARGUMENTS=3
readonly ERROR_UPLOAD=4
readonly ERROR_DOWNLOAD=5
readonly ERROR_UNKNOWN_PROTOCOL=6
readonly ERROR_REMOTE_LOCKED=7
readonly ERROR_GIT=8
readonly ERROR_HOOK=9
readonly ERROR_FILESYSTEM=10
# ------------------------------------------------------------
# Functions
# ------------------------------------------------------------
usage_long()
{
local pager=$(git config --get core.pager)
${GIT_PAGER:-${pager:-${PAGER:-less -FRSX}}} << EOF
USAGE
git-ftp <action> [<options>] [<url>]
DESCRIPTION
git-ftp does FTP the Git way.
It uses Git to determine which local files have changed since the last
deployment to the remote server and saves you time and bandwidth by
uploading only those files.
It keeps track of the deployed state by uploading the SHA1 of the last
deployed commit in a log file.
ACTIONS
. init
Does an initial upload of the latest version of all non-ignored
git-tracked files to the remote server and creates .git-ftp.log
file containing the SHA1 of the latest commit.
. catchup
Updates the commit id stored on the server.
. push
Uploads git-tracked files which have changed since last upload.
. download (EXPERIMENTAL)
Downloads changes from the remote host into your working tree.
WARNING: It can delete local untracked files that are not
listed in your .git-ftp-ignore file.
. pull (EXPERIMENTAL)
Downloads changes from the remote server into a separate commit
and merges them into your current branch.
. snapshot (EXPERIMENTAL)
Downloads files into a new Git repository. Takes an additional
optional argument as local destination directory. Example:
\`git-ftp snapshot ftp://example.com/public_html projects/example\`
. show
Downloads last uploaded SHA1 from log and hooks \`git show\`.
. log
Downloads last uploaded SHA1 from log and hooks \`git log\`.
. add-scope
Add a scope (e.g. dev, production, testing).
. remove-scope
Completely remove a scope.
. help
Shows this help screen.
URL
. FTP (default) host.example.com[:<port>][/<remote path>]
. FTP ftp://host.example.com[:<port>][/<remote path>]
. SFTP sftp://host.example.com[:<port>][/<remote path>]
. FTPS ftps://host.example.com[:<port>][/<remote path>]
. FTPES ftpes://host.example.com[:<port>][/<remote path>]
OPTIONS
-h, --help Shows this help screen.
-u, --user FTP login name.
-p, --passwd FTP password.
-P, --ask-passwd Ask for FTP password interactively.
-k, --keychain FTP password from KeyChain (Mac OS X only).
-b, --branch Git branch to push
-s, --scope Using a scope (e.g. dev, production, testing).
-D, --dry-run Dry run: Does not upload anything.
-a, --all Uploads all files, ignores deployed SHA1 hash.
-c, --commit Sets SHA1 hash of last deployed commit by option.
-A, --active Use FTP active mode.
-l, --lock Enable/Disable remote locking.
-f, --force Force, does not ask questions.
-n, --silent Silent mode.
-v, --verbose Verbose mode.
-vv Very verbose or debug mode.
--remote-root Specifies remote root directory
--syncroot Specifies a local directory to sync from as if it were the git project root path.
--key SSH private key file name for SFTP.
--pubkey SSH public key file name. Used with --key option.
--insecure Don't verify server's certificate.
--cacert Specify a <file> as CA certificate store. Useful when a server has got a self-signed certificate.
--no-commit Perform the merge at the and of pull but do not autocommit, to have the chance to inspect and further tweak the merge result before committing.
--changed-only Download or pull only files changed since the deployed commit while ignoring all other files.
--no-verify Bypass the pre-ftp-push hook.
--enable-post-errors Fails if post-ftp-push hook raises an error
--disable-epsv Tell curl to disable the use of the EPSV command when doing passive FTP transfers. Curl will normally always first attempt to use EPSV before PASV, but with this option, it will not try using EPSV.
--auto-init Automatically run init action when running push action
--version Prints version.
-x, --proxy Use the specified proxy.
EXAMPLES
. git-ftp push -u john ftp://ftp.example.com:4445/public_ftp -p -v
. git-ftp push -p -u john -v ftp.example.com:4445:/public_ftp
. git-ftp push -p -u john ftp.example.com --branch prod
. git-ftp add-scope production ftp://user:[email protected]:4445/public_ftp
. git-ftp push --scope production
. git-ftp remove-scope production
SET DEFAULTS
. git config git-ftp.user john
. git config git-ftp.url ftp.example.com
. git config git-ftp.password secr3t
. git config git-ftp.remote-root "~/www/"
. git config git-ftp.branch prod
. git config git-ftp.syncroot path/dir
. git config git-ftp.cacert path/cacert
. git config git-ftp.deployedsha1file mySHA1File
. git config git-ftp.insecure 1
. git config git-ftp.keychain [email protected]
SET SCOPE DEFAULTS
e.g. your scope is 'testing'
. git config git-ftp.testing.url ftp.example.local
VERSION
$VERSION
EOF
exit 0
}
usage() {
echo "git-ftp <action> [<options>] [<url>]"
exit "$ERROR_USAGE"
}
cache_git_submodules() {
GIT_SUBMODULES="$(git submodule status -- "$SYNCROOT" 2>/dev/null | grep -v '^-' | awk '{print $2}')"
}
is_submodule() {
echo "${GIT_SUBMODULES[@]}" | grep -Fxq -- "$1"
}
boolean() {
case "$1" in
"true")
echo "1"
;;
"false")
echo "0"
;;
*)
echo $1
;;
esac
}
ask_for_passwd() {
echo -n "Password: "
stty -echo > /dev/null 2>&1
read REMOTE_PASSWD
stty echo > /dev/null 2>&1
echo ""
}
get_keychain_password () {
if [ "$SYSTEM" = "Darwin" ]; then
# Split user and host if necessary
if echo "$KEYCHAIN_USER" | grep -q '@'; then
KEYCHAIN_HOST=$(echo "$KEYCHAIN_USER" | cut -d '@' -f2)
KEYCHAIN_USER=$(echo "$KEYCHAIN_USER" | cut -d '@' -f1)
else
[ -z "$KEYCHAIN_USER" ] && KEYCHAIN_USER="$REMOTE_USER"
[ -z "$KEYCHAIN_HOST" ] && KEYCHAIN_HOST="$REMOTE_HOST"
fi
[ -z "$KEYCHAIN_USER" ] && print_error_and_die "Missing keychain account." "$ERROR_MISSING_ARGUMENTS"
local KEYCHAIN_ARGS=(-a "$KEYCHAIN_USER")
[ -n "$KEYCHAIN_HOST" ] && KEYCHAIN_ARGS+=(-s "$KEYCHAIN_HOST")
write_log "Read password from keychain."
local pass
if pass="$(security find-internet-password "${KEYCHAIN_ARGS[@]}" -g 2>&1 > /dev/null)"; then
without_prefix="${pass#password: \"}"
REMOTE_PASSWD="${without_prefix%\"}"
else
print_error_and_die "Password not found in keychain for account '$KEYCHAIN_USER @ $KEYCHAIN_HOST'." "$ERROR_MISSING_ARGUMENTS"
fi
else
write_log "Ignoring -k on non-Darwin systems."
fi
}
# Checks if last command was successful
#
# $1 - error message
# $2 - error code to produce
#
check_exit_status() {
check_exit_status_not_equals $? 0 "$1" "$2"
}
# Checks if exit status equals a given value. If false sends exit command.
#
# $1 - status code to check
# $2 - code to test against
# $3 - error message
# $4 - error code to produce
#
check_exit_status_equals() {
if [ $1 -eq $2 ]; then
print_error_and_die "$3, exiting..." "$4"
fi
}
# Checks if exit status not equals a given value
#
# $1 - status code to check
# $2 - code to test against
# $3 - error message
# $4 - error code to produce
#
check_exit_status_not_equals() {
if [ $1 -ne $2 ]; then
print_error_and_die "$3, exiting..." "$4"
fi
}
# Checks if a given curl exit code was successful and if not exits with a nice error message (in some cases)
#
# $1 - exit code to check
# $2 - message: a custom message that is put in front of the error message
# $3 - error code: code to exit with if $1 is bad
#
check_curl_exit_status() {
case $1 in
0) ;;
9) print_error_and_die "$2 Access to resource denied. This usually means that the file or directory does not exist. Wrong path? exiting..." "$3" ;;
67) print_error_and_die "$2 Can't access remote '$REMOTE_BASE_URL_DISPLAY'. Failed to log in. Correct user and password? exiting..." "$3" ;;
78) print_error_and_die "$2 The resource does not exist. exiting..." "$3" ;;
*) print_error_and_die "$2 Can't access remote '$REMOTE_BASE_URL_DISPLAY'. Network down? Wrong URL? exiting..." "$3" ;;
esac
}
get_config() {
# try .git-ftp-config
[ -n "$SCOPE" ] && [ -f '.git-ftp-config' ] && OUT="$(git config -f '.git-ftp-config' --get "git-ftp.$SCOPE.$1")"
if [ $? -eq 0 ];
then
echo "$OUT"
return 0
fi
[ -f '.git-ftp-config' ] && OUT="$(git config -f '.git-ftp-config' --get "git-ftp.$1")"
if [ $? -eq 0 ];
then
echo "$OUT"
return 0
fi
[ -n "$SCOPE" ] && OUT="$(git config --get "git-ftp.$SCOPE.$1")"
if [ $? -eq 0 ];
then
echo "$OUT"
return 0
fi
OUT="$(git config --get "git-ftp.$1")"
if [ $? -eq 0 ];
then
echo "$OUT"
return 0
fi
[ -n "$2" ] && OUT="$2"
echo "$OUT"
}
set_deployed_sha1_file() {
DEPLOYED_SHA1_FILE="$(get_config deployedsha1file "$DEPLOYED_SHA1_FILE")"
}
# Simple log func
write_log() {
if [ $VERBOSE -eq 1 ]; then
echo "$(date): $1"
else
if [ -n "$LOG_CACHE" ]; then
LOG_CACHE="$LOG_CACHE\n$(date): $1"
else
LOG_CACHE="$(date): $1"
fi
fi
}
write_error_log() {
write_log "$1"
if [ -n "$ERROR_LOG" ]; then
ERROR_LOG="$ERROR_LOG\n: $1"
else
ERROR_LOG="$1"
fi
}
print_error_log() {
if [ -n "$ERROR_LOG" ]; then
echo "Error log:"
echo "$ERROR_LOG"
fi
}
# Simple error printer
print_error_and_die() {
if [ $VERBOSE -eq 0 ]; then
echo "fatal: $1" >&2
else
write_log "fatal: $1"
fi
cleanup
exit "$2"
}
# Simple info printer
print_info() {
if [ $VERBOSE -eq 0 ]; then
echo "$1"
else
write_log "$1"
fi
}
cleanup() {
rm -rf "$TMP_DIR"
}
set_default_curl_options() {
OIFS="$IFS"
IFS=" "
CURL_ARGS=("${REMOTE_CMD_OPTIONS[@]}")
IFS="$OIFS"
CURL_ARGS+=(--globoff)
if [ -n "$CURL_PROXY" ]; then
CURL_ARGS+=(--proxy "$CURL_PROXY")
fi
if [ -z "$REMOTE_USER" ]; then
CURL_ARGS+=(--netrc)
fi
CURL_ARGS+=(-#)
if [ $ACTIVE_MODE -eq 1 ]; then
CURL_ARGS+=(-P "-")
else
if [ $CURL_DISABLE_EPSV -eq 1 ]; then
CURL_ARGS+=(--disable-epsv)
fi
fi
}
upload_file() {
local SRC_FILE="$1"
local DEST_FILE="$2"
if [ -z "$DEST_FILE" ]; then
DEST_FILE="${SRC_FILE#$SYNCROOT}"
fi
set_default_curl_options
CURL_ARGS+=(-T "$SRC_FILE")
CURL_ARGS+=(--ftp-create-dirs)
CURL_ARGS+=("$REMOTE_BASE_URL/${REMOTE_PATH}${DEST_FILE}")
curl "${CURL_ARGS[@]}"
}
upload_file_buffered() {
local SRC_FILE="$1"
local DEST_FILE="${SRC_FILE#$SYNCROOT}"
local ENC_DEST_FILE="${DEST_FILE//#/%23}"
local ENC_DEST_FILE="${ENC_DEST_FILE// /%20}"
echo "-T \"./$SRC_FILE\"
url = \"$REMOTE_BASE_URL/${REMOTE_PATH}${ENC_DEST_FILE}\"" >> "$TMP_CURL_UPLOAD_FILE"
}
fire_upload_buffer() {
if [ ! -f "$TMP_CURL_UPLOAD_FILE" ]; then
return 0
fi
print_info "Uploading ..."
set_default_curl_options
CURL_ARGS+=(--ftp-create-dirs)
CURL_ARGS+=(-K "$TMP_CURL_UPLOAD_FILE")
curl "${CURL_ARGS[@]}"
check_exit_status "Could not upload files." "$ERROR_UPLOAD"
}
delete_file() {
local FILENAME="$1"
set_default_curl_options
CURL_ARGS+=(-Q "${REMOTE_DELETE_CMD}${REMOTE_PATH}${FILENAME}")
CURL_ARGS+=("$REMOTE_BASE_URL")
if [ "${REMOTE_CMD_OPTIONS[0]}" = "-v" ]; then
curl "${CURL_ARGS[@]}"
else
curl "${CURL_ARGS[@]}" > /dev/null 2>&1
fi
if [ $? -ne 0 ]; then
write_log "WARNING: Could not delete ${REMOTE_PATH}${FILENAME}, continuing..."
fi
}
delete_file_buffered() {
echo "-Q \"${REMOTE_DELETE_CMD}${REMOTE_PATH}${1}\"" >> "$TMP_CURL_DELETE_FILE"
}
fire_delete_buffer() {
if [ ! -f "$TMP_CURL_DELETE_FILE" ]; then
return 0
fi
print_info "Deleting ..."
echo "url = $REMOTE_BASE_URL" >> "$TMP_CURL_DELETE_FILE"
set_default_curl_options
CURL_ARGS+=(-K "$TMP_CURL_DELETE_FILE")
if [ "${REMOTE_CMD_OPTIONS[0]}" = "-v" ]; then
curl "${CURL_ARGS[@]}"
else
curl "${CURL_ARGS[@]}" > /dev/null 2>&1
fi
if [ $? -ne 0 ]; then
write_log "WARNING: Some files and/or directories could not be deleted."
fi
}
get_file_content() {
local SRC_FILE="$1"
set_default_curl_options
CURL_ARGS+=("$REMOTE_BASE_URL/${REMOTE_PATH}${SRC_FILE}")
curl "${CURL_ARGS[@]}"
}
set_local_sha1() {
LOCAL_SHA1=$(git log -n 1 --pretty=format:%H)
}
upload_local_sha1() {
write_log "Uploading commit log to $REMOTE_BASE_URL_DISPLAY/${REMOTE_PATH}$DEPLOYED_SHA1_FILE."
if [ $DRY_RUN -ne 1 ]; then
echo "$LOCAL_SHA1" | upload_file - "$DEPLOYED_SHA1_FILE"
check_curl_exit_status $? "Could not upload." "$ERROR_UPLOAD"
fi
print_info "Last deployment changed from $DEPLOYED_SHA1 to $LOCAL_SHA1.";
PREV_DEPLOYED_SHA1="$DEPLOYED_SHA1"
DEPLOYED_SHA1="$LOCAL_SHA1"
}
pre_push_hook() {
local hooks_dir="$(git config core.hooksPath)"
if [ -z "$hooks_dir" ];then
hooks_dir=".git/hooks"
fi
local hook="$hooks_dir/pre-ftp-push"
if [ "$EXECUTE_HOOKS" -eq 1 -a -e "$hook" ]; then
local scope="${SCOPE:-$REMOTE_HOST}"
local url="$REMOTE_BASE_URL_DISPLAY/$REMOTE_PATH"
write_log "Trigger pre-ftp-push hook with: $scope, $url, $LOCAL_SHA1, $DEPLOYED_SHA1"
print_status | $hook "$scope" "$url" "$LOCAL_SHA1" "$DEPLOYED_SHA1" || exit "$ERROR_HOOK"
fi
}
post_push_hook() {
local hooks_dir="$(git config core.hooksPath)"
if [ -z "$hooks_dir" ];then
hooks_dir=".git/hooks"
fi
local hook="$hooks_dir/post-ftp-push"
if [ -e "$hook" ]; then
local scope="${SCOPE:-$REMOTE_HOST}"
local url="$REMOTE_BASE_URL_DISPLAY/$REMOTE_PATH"
write_log "Trigger post-ftp-push hook with: $scope, $url, $LOCAL_SHA1, $PREV_DEPLOYED_SHA1"
$hook "$scope" "$url" "$LOCAL_SHA1" "$PREV_DEPLOYED_SHA1" || [ "$ENABLE_POST_HOOK_ERRORS" -eq 0 ] || exit "$ERROR_HOOK"
fi
}
print_status() {
while IFS= read -r -d '' FILE_NAME; do
printf 'A %s\0' "$FILE_NAME"
done < "$TMP_GITFTP_UPLOAD"
while IFS= read -r -d '' FILE_NAME; do
printf 'D %s\0' "$FILE_NAME"
done < "$TMP_GITFTP_DELETE"
}
remote_lock() {
[ $ENABLE_REMOTE_LCK -ne 1 ] && return
[ $FORCE -ne 1 ] && check_remote_lock
local LCK_MESSAGE="${USER}@$(hostname --fqdn) on $(date --utc --rfc-2822)"
write_log "Remote locking $LCK_MESSAGE."
if [ $DRY_RUN -ne 1 ]; then
echo "${LOCAL_SHA1}\n${LCK_MESSAGE}" | upload_file - "$REMOTE_LCK_FILE"
check_exit_status "Could not upload remote lock file." "$ERROR_UPLOAD"
fi
}
release_remote_lock() {
[ $ENABLE_REMOTE_LCK -ne 1 ] && return;
write_log "Releasing remote lock."
delete_file "$REMOTE_LCK_FILE"
}
set_remote_host() {
[ -z "$URL" ] && URL="$(get_config url)"
REMOTE_HOST=$(expr "$URL" : ".*://\([[:alpha:]0-9\.:-]*\).*")
[ -z "$REMOTE_HOST" ] && REMOTE_HOST=$(expr "$URL" : "\([[:alpha:]0-9\.:-]*\).*")
[ -z "$REMOTE_HOST" ] && print_error_and_die "Remote host not set." "$ERROR_MISSING_ARGUMENTS"
}
set_remote_protocol() {
# Split protocol from url
REMOTE_PROTOCOL="$(get_protocol_of_url "$URL")"
CURL_PROTOCOL="$REMOTE_PROTOCOL"
# Protocol found?
if [ ! -z "$REMOTE_PROTOCOL" ]; then
REMOTE_PATH=$(echo "$URL" | cut -d '/' -f 4-)
handle_remote_protocol_options
return
fi
# Check if a unknown protocol is set, handle it or use default protocol
local UNKNOWN_PROTOCOL=$(expr "$URL" : "\(.*:[/]*\).*")
if [ -z "$UNKNOWN_PROTOCOL" ]; then
write_log "Protocol not set, using default protocol $DEFAULT_PROTOCOL://."
REMOTE_PROTOCOL="$DEFAULT_PROTOCOL"
CURL_PROTOCOL="$REMOTE_PROTOCOL"
echo "$URL" | egrep -q "/" && REMOTE_PATH=$(echo "$URL" | cut -d '/' -f 2-)
handle_remote_protocol_options
return
fi
print_error_and_die "Protocol unknown '$UNKNOWN_PROTOCOL'." "$ERROR_UNKNOWN_PROTOCOL"
}
set_remote_path() {
# Check remote root directory
[ -z "$REMOTE_ROOT" ] && REMOTE_ROOT="$(get_config remote-root)"
if [ ! -z "$REMOTE_ROOT" ]; then
! echo "$REMOTE_ROOT" | egrep -q "/$" && REMOTE_ROOT="$REMOTE_ROOT/"
REMOTE_PATH="$REMOTE_ROOT$REMOTE_PATH"
fi
# Add trailing slash if missing
if [ ! -z "$REMOTE_PATH" ] && ! echo "$REMOTE_PATH" | egrep -q "/$"; then
write_log "Added missing trailing / in path."
REMOTE_PATH="$REMOTE_PATH/"
fi
}
set_deployed_sha1_failable() {
# Return if commit is set by user interaction using --commit
if [ -n "$DEPLOYED_SHA1" ]; then
return
fi
# Get the last commit (SHA) we deployed if not ignored or not found
write_log "Retrieving last commit from $REMOTE_BASE_URL_DISPLAY/$REMOTE_PATH."
DEPLOYED_SHA1="$(get_file_content "$DEPLOYED_SHA1_FILE")"
}
set_deployed_sha1() {
set_deployed_sha1_failable
check_curl_exit_status $? "Could not get last commit. Use 'git ftp init' for the initial push." "$ERROR_DOWNLOAD"
write_log "Last deployed SHA1 for $REMOTE_HOST/$REMOTE_PATH is $DEPLOYED_SHA1."
}
set_deployed_sha1_for_push() {
if [ "$AUTO_INIT" = 1 ]; then
set_deployed_sha1_failable
if [ "$DEPLOYED_SHA1" = "" ]; then
check_remote_access
write_log "Uploading all files since no commit was found at $REMOTE_BASE_URL_DISPLAY/$REMOTE_PATH."
IGNORE_DEPLOYED=1
fi
else
set_deployed_sha1
fi
}
set_changed_files() {
set_tmp
# Get raw list of files
if [ $IGNORE_DEPLOYED -ne 0 ]; then
write_log "Taking all files.";
list_all_files
else
list_changed_files
fi
add_include_files
filter_ignore_files "$TMP_GITFTP_UPLOAD" "$TMP_GITFTP_DELETE"
if [ -s "$TMP_GITFTP_UPLOAD" ] || [ -s "$TMP_GITFTP_DELETE" ]; then
write_log "Having files to sync.";
else
write_log "No files to sync. All changed files ignored.";
fi
}
list_all_files() {
git ls-files -z -- "${SYNCROOT:-.}" > "$TMP_GITFTP_UPLOAD"
touch "$TMP_GITFTP_DELETE"
}
list_changed_files() {
git diff --name-only --no-renames --diff-filter=AM -z "$DEPLOYED_SHA1" -- "$SYNCROOT" 2>/dev/null > "$TMP_GITFTP_UPLOAD"
git diff --name-only --no-renames --diff-filter=D -z "$DEPLOYED_SHA1" -- "$SYNCROOT" 2>/dev/null > "$TMP_GITFTP_DELETE"
local git_diff_status=$?
if [ "$git_diff_status" -ne 0 ]; then
if [ $FORCE -eq 1 ]; then
print_info "Unknown SHA1 object, could not determine changed files, taking all files."
list_all_files
return
fi
print_info "Unknown SHA1 object, make sure you are deploying the right branch and it is up-to-date."
echo -n "Do you want to ignore and upload all files again? [y/N]: "
read ANSWER_STATE
if [ "$ANSWER_STATE" != "y" ] && [ "$ANSWER_STATE" != "Y" ]; then
print_info "Aborting..."
cleanup
test "$ANSWER_STATE" == "" && exit "$ERROR_USAGE"
exit 0
fi
write_log "Taking all files.";
list_all_files
elif [ "$LOCAL_SHA1" == "$DEPLOYED_SHA1" ]; then
print_info "No changed files for $REMOTE_HOST/$REMOTE_PATH. Everything up-to-date."
cleanup
unset_branch
exit 0
elif [ ! -s "$TMP_GITFTP_UPLOAD" -a ! -s "$TMP_GITFTP_DELETE" ]; then
write_log "No changed files, but different commit ID. Changed files ignored or commit amended.";
fi
}
add_include_files() {
[ -f '.git-ftp-include' ] || return
local tmp_include_sources="$TMP_DIR/include_sources_tmp"
grep -v '^#.*$\|^\s*$' '.git-ftp-include' | tr -d '\r' > "$TMP_GITFTP_INCLUDE"
grep '^!' "$TMP_GITFTP_INCLUDE" | sed 's/^!//' | while read TARGET; do
add_include_file "$TARGET"
done
local AGAINST="${DEPLOYED_SHA1:-"$(git hash-object -t tree /dev/null)"}"
grep ':' "$TMP_GITFTP_INCLUDE" | while read LINE; do
local TARGET="${LINE%%:*}"
local SOURCE="${LINE#*:}"
if echo "$SOURCE" | grep -q '^/'; then
SOURCE="${SOURCE#/}"
elif [ -n "$SYNCROOT" ]; then
SOURCE="$SYNCROOT/$SOURCE"
fi
if ! git diff --quiet "$AGAINST" -- "$SOURCE"; then
add_include_file "$TARGET"
fi
done
rm -f "$tmp_include_sources"
rm -f "$TMP_GITFTP_INCLUDE"
}
add_include_file() {
local TARGET="${1}"
if [ -e "$TARGET" ]; then
if [ -d "$TARGET" ]; then
write_log "Including all files in $TARGET for upload."
find "$TARGET" -type f -print0 >> "$TMP_GITFTP_UPLOAD"
elif [ -f "$TARGET" ]; then
write_log "Including $TARGET for upload."
printf '%s\0' "$TARGET" >> "$TMP_GITFTP_UPLOAD"
fi
else
if echo "$TARGET" | grep -v '/$'; then
write_log "Including $TARGET for deletion."
printf '%s\0' "$TARGET" >> "$TMP_GITFTP_DELETE"
else
write_log "Deletion of directory $TARGET is not supported."
fi
fi
}
filter_ignore_files() {
[ -f '.git-ftp-ignore' ] || return
local patterns="$TMP_DIR/ignore_tmp"
grep -v '^#.*$\|^\s*$' '.git-ftp-ignore' | tr -d '\r' > "$patterns"
filter_file "$patterns" "$1"
filter_file "$patterns" "$2"
rm -f "$patterns"
}
filter_file() {
glob_filter "$1" < "$2" > "$TMP_DIR/filtered_tmp"
mv "$TMP_DIR/filtered_tmp" "$2"
}
# Original implementation http://stackoverflow.com/a/27718468/3377535
glob_filter() {
local patterns="$1"
while IFS= read -r -d '' filename; do
local hasmatch=0
while IFS= read -r pattern; do
case $filename in ($pattern) hasmatch=1; break ;; esac
done < "$patterns"
test $hasmatch = 1 || printf '%s\0' "$filename"
done
}
handle_file_sync() {
if [ ! -s "$TMP_GITFTP_UPLOAD" ] && [ ! -s "$TMP_GITFTP_DELETE" ]; then
print_info "There are no files to sync."
return
fi
sort -z -u -o "$TMP_GITFTP_UPLOAD" "$TMP_GITFTP_UPLOAD"
sort -z -u -o "$TMP_GITFTP_DELETE" "$TMP_GITFTP_DELETE"
# Calculate total file count
local DONE_ITEMS=0
local TOTAL_ITEMS=$(cat "$TMP_GITFTP_UPLOAD" "$TMP_GITFTP_DELETE" | tr -d -c '\0' | wc -c)
TOTAL_ITEMS=$((TOTAL_ITEMS+0)) # trims whitespaces produced by wc
print_info "$TOTAL_ITEMS file$([ $TOTAL_ITEMS -ne 1 ] && echo 's') to sync:"
while IFS= read -r -d '' FILE_NAME; do
(( DONE_ITEMS++ ))
print_info "[$DONE_ITEMS of $TOTAL_ITEMS] Buffered for upload '$FILE_NAME'."
if is_submodule "$FILE_NAME"; then
handle_submodule_sync "${FILE_NAME#$SYNCROOT}"
elif [ $DRY_RUN -ne 1 ]; then
upload_file_buffered "$FILE_NAME"
fi
done < "$TMP_GITFTP_UPLOAD"
fire_upload_buffer
while IFS= read -r -d '' FILE_NAME; do
(( DONE_ITEMS++ ))
print_info "[$DONE_ITEMS of $TOTAL_ITEMS] Buffered for delete '$FILE_NAME'."
if [ $DRY_RUN -ne 1 ]; then
local file="${FILE_NAME#$SYNCROOT}"
delete_file_buffered "$file"
fi
done < "$TMP_GITFTP_DELETE"
fire_delete_buffer
}
handle_submodule_sync() {
print_info "Handling submodule sync for $1."
set_submodule_args
(
cd "${SYNCROOT}$1" && "$0" "$ACTION" "${args[@]}" "$REMOTE_PROTOCOL://$REMOTE_HOST/${REMOTE_PATH}$1"
)
local EXIT_CODE=$?
# Pushing failed. Submodule may not be initialized
if [ "$EXIT_CODE" -eq "$ERROR_DOWNLOAD" ] && [ "$ACTION" == "push" ]; then
print_info "Could not push $1, trying to init..."
(
cd "${SYNCROOT}$1" && "$0" init "${args[@]}" "$REMOTE_PROTOCOL://$REMOTE_HOST/${REMOTE_PATH}$1"
)
check_exit_status "Failed to sync submodules." "$ERROR_UPLOAD"
elif [ $EXIT_CODE -ne 0 ]; then
print_error_and_die "Failed to sync submodules." "$ERROR_UPLOAD"
fi
}
submodule_catchup() {
[ -z "$GIT_SUBMODULES" ] && return
set_submodule_args
url="$(git config git-ftp.url)"
print_info "Submodules are $GIT_SUBMODULES"
for submodule in "${GIT_SUBMODULES[@]}"
do
print_info "Catching up submodule $submodule."
cd "${SYNCROOT}$submodule" && "$0" "$ACTION" "${args[@]}" "$REMOTE_PROTOCOL://$REMOTE_HOST/${REMOTE_PATH}$submodule"
done
}
set_submodule_args() {
args=(--user "$REMOTE_USER")
[ -n "$REMOTE_PASSWD" ] && args+=(--passwd "$REMOTE_PASSWD")
[ -n "$CURL_PRIVATE_KEY" ] && args+=(--key "$CURL_PRIVATE_KEY")
[ -n "$CURL_PUBLIC_KEY" ] && args+=(--pubkey "$CURL_PUBLIC_KEY")
# Do not ask any questions for submodules
args+=(--force)
if [ $ACTIVE_MODE -eq 1 ]; then
args+=(--active)
else
if [ $CURL_DISABLE_EPSV -eq 1 ]; then
args+=(--disable-epsv)
fi
fi
[ $INSECURE -eq 1 ] && args+=(--insecure)
[ $IGNORE_DEPLOYED -eq 1 ] && args+=(--all)
if [ $VERBOSE -eq 1 ]; then
args+=(--verbose)
elif [ $VERBOSE -eq -1 ]; then
args+=(--silent)
fi
[ $DRY_RUN -eq 1 ] && args+=(--dry-run)
}
handle_remote_protocol_options() {
if [ "$REMOTE_PROTOCOL" = "sftp" ]; then
set_sftp_config
if [ -n "$CURL_PRIVATE_KEY" ]; then
write_log "Using ssh private key file $CURL_PRIVATE_KEY"
REMOTE_CMD_OPTIONS+=("--key" "$CURL_PRIVATE_KEY")
fi
if [ -n "$CURL_PUBLIC_KEY" ]; then
write_log "Using ssh public key file $CURL_PUBLIC_KEY"
REMOTE_CMD_OPTIONS+=("--pubkey" "$CURL_PUBLIC_KEY")
elif [ -f "${CURL_PRIVATE_KEY}.pub" -a -r "${CURL_PRIVATE_KEY}.pub" ]; then
write_log "Automatically using ssh public key file ${CURL_PRIVATE_KEY}.pub"
REMOTE_CMD_OPTIONS+=("--pubkey" "${CURL_PRIVATE_KEY}.pub")
fi
# SFTP uses a different remove command and uses absolute paths
REMOTE_DELETE_CMD="rm /"
fi
# Check for using cacert
if [ "$REMOTE_PROTOCOL" = "ftpes" -o "$REMOTE_PROTOCOL" = "ftps" ] && \
[ -n "$REMOTE_CACERT" -a -r "$REMOTE_CACERT" ]; then
REMOTE_CMD_OPTIONS+=("--cacert" "$REMOTE_CACERT")
fi
# Options for curl if using FTPES
if [ "$REMOTE_PROTOCOL" = "ftpes" ]; then
CURL_PROTOCOL="ftp"
REMOTE_CMD_OPTIONS+=("--ssl")
fi
# Require users' explicit consent for insecure connections
[ $INSECURE -eq 1 ] && REMOTE_CMD_OPTIONS+=("-k")
}
handle_lftp_settings() {
LFTP_PROTOCOL="$REMOTE_PROTOCOL"
# Options for lftp if using FTPES
if [ "$REMOTE_PROTOCOL" = "ftpes" ]; then
LFTP_PROTOCOL="ftp"
LFTP_COMMAND_SETTINGS+="set ftp:ssl-force true && "
LFTP_COMMAND_SETTINGS+="set ftp:ssl-protect-data true && "
LFTP_COMMAND_SETTINGS+="set ftp:ssl-protect-list true && "
fi
[ $INSECURE -eq 1 ] && LFTP_COMMAND_SETTINGS+="set ssl:verify-certificate no && "
LFTP_COMMAND_SETTINGS+="set ftp:list-options -a &&"
}
init_new_repository() {
[ -z "$URL" ] && print_error_and_die "Error: give a URL to snapshot." "$ERROR_USAGE"
# Use the last part of the URL as destination directory by default
[ -z "$SNAPSHOT_DIR" ] && SNAPSHOT_DIR="$(basename "$URL")"
DEPLOYED_SHA1="$(get_file_content "$DEPLOYED_SHA1_FILE")"
if [ "$DEPLOYED_SHA1" != "" ]; then
print_error_and_die "Commit found at $URL/$DEPLOYED_SHA1_FILE.
The remote directory is managed by another Git repository already. If you want
to start using a new repository, then delete $DEPLOYED_SHA1_FILE first. The old
repository will not be able to deploy to this remote any more. Aborting." "$ERROR_USAGE"
fi
# Make sure the destination directory exists
mkdir -p "$SNAPSHOT_DIR" || print_error_and_die "Error creating directory '$SNAPSHOT_DIR'. Aborting." "$ERROR_FILESYSTEM"
if [ "$(ls -A "$SNAPSHOT_DIR")" ]; then
print_error_and_die "Error: The destination directory '$SNAPSHOT_DIR' is not empty. Aborting." "$ERROR_FILESYSTEM"
fi
cd "$SNAPSHOT_DIR" || print_error_and_die "Error entering '$SNAPSHOT_DIR'. Aborting." "$ERROR_FILESYSTEM"
info="$(git init)" || print_error_and_die "Error initialising Git repository." "$ERROR_GIT"
print_info "$info"
}
commit_snapshot() {
git add . > /dev/null || print_error_and_die "Git: error adding changed files" "$ERROR_GIT"
git commit -m "Download $URL with git-ftp" -q > /dev/null || print_error_and_die "Git: error committing the changes" "$ERROR_GIT"
}
handle_action() {
case "$ACTION" in
init)
action_init
;;
push)