-
Notifications
You must be signed in to change notification settings - Fork 190
/
git-ftp
1279 lines (1131 loc) · 31.5 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-2014 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.0.0-rc.1'
# ------------------------------------------------------------
# Defaults
# ------------------------------------------------------------
URL=""
REMOTE_PROTOCOL=""
REMOTE_HOST=""
REMOTE_USER=""
REMOTE_PASSWD=""
REMOTE_PATH=""
REMOTE_CACERT=""
REMOTE_DELETE_CMD="-*DELE "
REMOTE_CMD_OPTIONS="-s"
ACTION=""
LOG_CACHE=""
ERROR_LOG=""
SCOPE=""
KEYCHAIN_USER=""
KEYCHAIN_HOST=""
DEPLOYED_SHA1=""
LOCAL_SHA1=""
SYNCROOT=""
CURL_INSECURE=""
CURL_PUBLIC_KEY=""
CURL_PRIVATE_KEY=""
CURL_UPLOADS=()
CURL_DELETE=()
CURL_DISABLE_EPSV=0
declare -a CURL_ARGS
declare -i VERBOSE=0
declare -i IGNORE_DEPLOYED=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 ARG_MAX=4096
declare -a GIT_SUBMODULES
# ------------------------------------------------------------
# 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
# ------------------------------------------------------------
# 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.
. push
Uploads git-tracked files which have changed since last upload.
. show
Downloads last uploaded SHA1 from log and hooks \`git show\`.
. log
Downloads last uploaded SHA1 from log and hooks \`git log\`.
. catchup
Uploads current SHA1 to log, does not upload any files.
This is useful if you used another FTP client to upload the
files and now want to remember the SHA1.
. 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.
-k, --keychain FTP password from KeyChain (Mac OS X only).
-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.
--syncroot Specifies a directory to sync from as if it were the git project root path.
--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.
--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.
--version Prints version.
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 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.syncroot path/dir
. git config git-ftp.cacert path/cacert
. git config git-ftp.deployedsha1file mySHA1File
. git config git-ftp.insecure 1
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
}
escape() {
echo "$1" | sed 's/\([\.\+\$]\)/\\\1/g'
}
has() {
local item=$1; shift
echo " $@ " | grep -q " $(escape $item) "
}
cache_git_submodules() {
GIT_SUBMODULES=$(git submodule | awk '{print $2}')
}
is_submodule() {
has $1 ${GIT_SUBMODULES[@]}
}
is_arg_max_reached() {
local ARGS_TO_ADD=$1
local ARGS_STRING=$2
CURRENT_LENGTH=$(( ${#ARGS_STRING} + ${#ARGS_TO_ADD} ))
if [ $CURRENT_LENGTH -lt $ARG_MAX ]; then
return 1
fi
return 0
}
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 '@') ]; 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
CURL_ARGS=(-a "$KEYCHAIN_USER")
[ -n "$KEYCHAIN_HOST" ] && CURL_ARGS+=(-s "$KEYCHAIN_HOST")
local pass
if pass="$(security find-internet-password ${CURL_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 "Ingoring -k on non-Darwin systems."
fi
}
# Checks if last comand was successful
check_exit_status() {
if [ $? -ne 0 ]; then
print_error_and_die "$1, exiting..." $2
fi
}
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
}
readonly DEPLOYED_SHA1_FILE="$(get_config deployedsha1file .git-ftp.log)"
# 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
exit $2
}
# Simple info printer
print_info() {
if [ $VERBOSE -eq 0 ]; then
echo "$1"
else
write_log "$1"
fi
}
set_default_curl_options() {
OIFS="$IFS"
IFS=" "
CURL_ARGS=(${REMOTE_CMD_OPTIONS[@]})
IFS="$OIFS"
CURL_ARGS+=(--globoff)
if [ ! -z $REMOTE_USER ]; then
CURL_ARGS+=(--user "$REMOTE_USER":"$REMOTE_PASSWD")
else
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
fi
if [ -n "$SYNCROOT" ]; then
DEST_FILE=${DEST_FILE/$SYNCROOT/$REPLACE}
fi
set_default_curl_options
CURL_ARGS+=(-T "$SRC_FILE")
CURL_ARGS+=(--ftp-create-dirs)
CURL_ARGS+=("$REMOTE_PROTOCOL://$REMOTE_HOST/${REMOTE_PATH}${DEST_FILE}")
curl "${CURL_ARGS[@]}"
check_exit_status "Could not upload file: '${REMOTE_PATH}$DEST_FILE'." $ERROR_UPLOAD
}
upload_file_buffered() {
local SRC_FILE="$1"
local DEST_FILE="$2"
if [ -z $DEST_FILE ]; then
DEST_FILE=$SRC_FILE
fi
if [ -n "$SYNCROOT" ]; then
DEST_FILE=${DEST_FILE/$SYNCROOT/$REPLACE}
fi
CURL_UPLOADS+=(-T "./$SRC_FILE")
CURL_UPLOADS+=("$REMOTE_PROTOCOL://$REMOTE_HOST/${REMOTE_PATH}${DEST_FILE}")
}
fire_upload_buffer() {
if [ -z "$CURL_UPLOADS" ]; then
return 0
fi
print_info "Uploading ..."
set_default_curl_options
CURL_ARGS+=(--ftp-create-dirs)
CURL_ARGS+=("${CURL_UPLOADS[@]}")
curl "${CURL_ARGS[@]}"
check_exit_status "Could not upload files." $ERROR_UPLOAD
CURL_UPLOADS=()
}
delete_file() {
local FILENAME="$1"
set_default_curl_options
CURL_ARGS+=(-Q "${REMOTE_DELETE_CMD}${REMOTE_PATH}${FILENAME}")
CURL_ARGS+=("$REMOTE_PROTOCOL://$REMOTE_HOST")
if [ "${REMOTE_CMD_OPTIONS:0:2}" = "-v" ]; then
curl "${CURL_ARGS[@]}"
else
curl "${CURL_ARGS[@]}" > /dev/null 2>&1
fi
if [ $? -ne 0 ]; then
write_error_log "Could not delete ${REMOTE_PATH}${FILENAME}, continuing..."
fi
}
delete_file_buffered() {
local FILENAME="$1"
CURL_DELETE+=(-Q "${REMOTE_DELETE_CMD}${REMOTE_PATH}${FILENAME}")
}
fire_delete_buffer() {
if [ -z "$CURL_DELETE" ]; then
return 0
fi
print_info "Deleting ..."
set_default_curl_options
CURL_ARGS+=("${CURL_DELETE[@]}")
CURL_ARGS+=("$REMOTE_PROTOCOL://$REMOTE_HOST")
if [ "${REMOTE_CMD_OPTIONS:0:2}" = "-v" ]; then
curl "${CURL_ARGS[@]}"
else
curl "${CURL_ARGS[@]}" > /dev/null 2>&1
fi
if [ $? -ne 0 ]; then
write_error_log "Some files and/or folders could not be deleted."
fi
CURL_DELETE=()
}
delete_dir() {
ORIGIN_REMOTE_DELETE_CMD=$REMOTE_DELETE_CMD
REMOTE_DELETE_CMD="-*RMD "
delete_file_buffered $1
REMOTE_DELETE_CMD=$ORIGIN_REMOTE_DELETE_CMD
}
get_file_content() {
local SRC_FILE="$1"
set_default_curl_options
CURL_ARGS+=("$REMOTE_PROTOCOL://$REMOTE_HOST/${REMOTE_PATH}${SRC_FILE}")
curl "${CURL_ARGS[@]}"
}
set_local_sha1() {
LOCAL_SHA1=$(git log -n 1 --pretty=format:%H)
}
upload_local_sha1() {
DEPLOYED_SHA1=$LOCAL_SHA1
write_log "Uploading commit log to $REMOTE_PROTOCOL://$REMOTE_HOST/${REMOTE_PATH}$DEPLOYED_SHA1_FILE."
if [ $DRY_RUN -ne 1 ]; then
echo "$DEPLOYED_SHA1" | upload_file - $DEPLOYED_SHA1_FILE
check_exit_status "Could not upload." $ERROR_UPLOAD
fi
print_info "Last deployment changed to $DEPLOYED_SHA1.";
}
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 != 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")
# 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
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_deployed_sha1() {
# 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_PROTOCOL://$REMOTE_HOST/$REMOTE_PATH."
DEPLOYED_SHA1="$(get_file_content $DEPLOYED_SHA1_FILE)"
check_exit_status "Could not get last commit. Network down? Wrong URL? Use 'git ftp init' for the inital push." $ERROR_DOWNLOAD
write_log "Last deployed SHA1 for $REMOTE_HOST/$REMOTE_PATH is $DEPLOYED_SHA1."
}
set_changed_files() {
# Get raw list of files
if [ $IGNORE_DEPLOYED -ne 0 ]; then
git ls-files -t $SYNCROOT > '.git-ftp-tmp'
else
git diff --name-status --no-renames $DEPLOYED_SHA1 $SYNCROOT 2>/dev/null > '.git-ftp-tmp'
fi
# Add files from include file
if [ -f '.git-ftp-include' ]; then
grep -v '^#.*$\|^\s*$' '.git-ftp-include' | tr -d '\r' > '.git-ftp-include-tmp'
for LINE in $(grep '^!' '.git-ftp-include-tmp')
do
FILE_STATUS='M'
FILE_PAIR=$(echo "$LINE" | sed 's/^!//')
echo "$FILE_STATUS $FILE_PAIR" >> '.git-ftp-tmp'
done
for LINE in $(grep ':' '.git-ftp-include-tmp')
do
OIFS="$IFS"
IFS=":"
FILE_PAIR=($LINE)
IFS="$OIFS"
if [[ $(grep -F "${FILE_PAIR[1]}" '.git-ftp-tmp') && ! $(grep -F "${FILE_PAIR[0]}" '.git-ftp-tmp') ]]; then
DELETE_COUNT=0
MODIFY_COUNT=0
for SUB_LINE in $(grep -F "${FILE_PAIR[0]}" '.git-ftp-include-tmp')
do
OIFS="$IFS"
IFS=":"
SUB_FILE_PAIR=($SUB_LINE)
IFS="$OIFS"
if [ $IGNORE_DEPLOYED -eq 0 ] && [[ $(git diff --name-status --no-renames $DEPLOYED_SHA1 $SYNCROOT -- "${SUB_FILE_PAIR[1]}" | grep '^D') ]]; then
let DELETE_COUNT++
else
let MODIFY_COUNT++
fi
done
if [ -f "${FILE_PAIR[0]}" ]; then
if [ "$DELETE_COUNT" -gt 0 ] && [ "$MODIFY_COUNT" -eq 0 ]; then
FILE_STATUS='D'
else
FILE_STATUS='M'
fi
echo "$FILE_STATUS ${FILE_PAIR[0]}" >> '.git-ftp-tmp'
fi
fi
done
fi
# Filter against ignore file
if [ -f '.git-ftp-ignore' ]; then
grep -v '^#.*$\|^\s*$' '.git-ftp-ignore' | tr -d '\r' > '.git-ftp-ignore-tmp'
FILES_CHANGED=$(grep --invert-match -f '.git-ftp-ignore-tmp' '.git-ftp-tmp' | tr '\t' ' ')
else
FILES_CHANGED=$(cat '.git-ftp-tmp' | tr '\t' ' ')
fi
rm -f '.git-ftp-tmp'
rm -f '.git-ftp-include-tmp'
rm -f '.git-ftp-ignore-tmp'
if [ $IGNORE_DEPLOYED -ne 0 ]; then
write_log "Sync all files."
return
fi
if [ $? -ne 0 ]; then
if [ $FORCE -ne 1 ]; then
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..."
exit 0
else
write_log "Taking all files.";
FILES_CHANGED="$(git ls-files -t $SYNCROOT)"
fi
else
print_info "Unknown SHA1 object, could not determine changed filed, taking all files."
FILES_CHANGED="$(git ls-files -t $SYNCROOT)"
fi
elif [ -n "$FILES_CHANGED" ]; then
write_log "Having changed files.";
elif [ "$LOCAL_SHA1" != "$DEPLOYED_SHA1" ]; then
write_log "No changed files, but different commit ID. Probably amended.";
else
print_info "No changed files for $REMOTE_HOST/$REMOTE_PATH. Everything up-to-date."
exit 0
fi
}
handle_file_sync() {
# Calculate total file count
local DONE_ITEMS=0
local TOTAL_ITEMS=$(echo "$FILES_CHANGED" | wc -l)
TOTAL_ITEMS=$((TOTAL_ITEMS+0)) # trims whitespaces produced by wc
print_info "There are $TOTAL_ITEMS files to sync:"
# Changing internal field separator, file names could have spaces
OIFS="$IFS"
NIFS=$'\n'
IFS="$NIFS"
for FILE_ITERATOR in $FILES_CHANGED; do
(( DONE_ITEMS++ ))
FILE_MODE="$(echo "$FILE_ITERATOR" | cut -f1 -d ' ')"
FILE_NAME="$(printf "$FILE_ITERATOR" | cut -f2- -d ' ')"
FILE_NAME="${FILE_NAME/#\"/}"
FILE_NAME="${FILE_NAME/%\"/}"
if [ "$FILE_MODE" != "D" ]; then
print_info "[$DONE_ITEMS of $TOTAL_ITEMS] Buffered for upload '$FILE_NAME'."
if is_submodule "$FILE_NAME"; then
handle_submodule_sync "${FILE_NAME#$SYNCROOT}"
else if [ $DRY_RUN -ne 1 ]; then
if is_arg_max_reached "$FILE_NAME" "${CURL_UPLOADS[@]}"; then
IFS="$OIFS"
fire_upload_buffer
IFS="$NIFS"
fi
upload_file_buffered "$FILE_NAME"
fi
fi
# Removing file
else
print_info "[$DONE_ITEMS of $TOTAL_ITEMS] Buffered for delete '$FILE_NAME'."
if [ $DRY_RUN -ne 1 ]; then
if is_arg_max_reached "$FILE_NAME" "${CURL_DELETE[@]}"; then
IFS="$OIFS"
fire_delete_buffer
IFS="$NIFS"
fi
delete_file_buffered "${FILE_NAME#$SYNCROOT}" && delete_dir $(dirname "${FILE_NAME#$SYNCROOT}")
fi
fi
done
IFS="$OIFS"
fire_upload_buffer
fire_delete_buffer
}
handle_submodule_sync() {
print_info "Handling submodule sync for $1."
# Duplicate the current required parameters
args=(--user "$REMOTE_USER" --passwd "$REMOTE_PASSWD")
# 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
[ $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)
(
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
}
handle_remote_protocol_options() {
if [ "$REMOTE_PROTOCOL" = "sftp" ]; then
set_sftp_config
if [ ! -z "$CURL_PRIVATE_KEY" ]; then
write_log "Using ssh private key file $CURL_PRIVATE_KEY"
if [ -z "$CURL_PUBLIC_KEY" ]; then
# If public key is not specified, use private key with .pub extension
CURL_PUBLIC_KEY="$CURL_PRIVATE_KEY.pub"
fi
write_log "Using ssh public key file $CURL_PUBLIC_KEY"
REMOTE_CMD_OPTIONS="$REMOTE_CMD_OPTIONS --key $CURL_PRIVATE_KEY --pubkey $CURL_PUBLIC_KEY"
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="$REMOTE_CMD_OPTIONS --cacert $REMOTE_CACERT"
fi
# Options for curl if using FTPES
if [ "$REMOTE_PROTOCOL" = "ftpes" ]; then
REMOTE_PROTOCOL="ftp"
REMOTE_CMD_OPTIONS="$REMOTE_CMD_OPTIONS --ssl"
fi
# Require users' explicit consent for insecure connections
[ "$CURL_INSECURE" != "0" ] && REMOTE_CMD_OPTIONS="$REMOTE_CMD_OPTIONS -k"
}
handle_action() {
case "$ACTION" in
init)
action_init
;;
push)
action_push
;;
catchup)
action_catchup
;;
show)
action_show
;;
log)
action_log
;;
add-scope)
action_add_scope
;;
remove-scope)
action_remove_scope
;;
*)
print_error_and_die "Action unknown." $ERROR_MISSING_ARGUMENTS
;;
esac
}
set_remote_user() {
[ -z $REMOTE_USER ] && REMOTE_USER="$(get_config user)"
}
set_remote_cacert() {
[ -z $REMOTE_CACERT ] && REMOTE_CACERT="$(get_config cacert)"
}
set_remote_password() {
[ -z "$REMOTE_PASSWD" ] && [ $USE_KEYCHAIN -eq 1 ] && get_keychain_password "$KEYCHAIN_USER"
[ -z "$REMOTE_PASSWD" ] && REMOTE_PASSWD="$(get_config password)"
}
set_syncroot() {
[ -z "$SYNCROOT" ] && SYNCROOT="$(get_config syncroot)"
if [ "$SYNCROOT" ]; then
[ -d "$SYNCROOT" ] || print_error_and_die "'$SYNCROOT' is not a directory! Exiting..." $ERROR_GIT
SYNCROOT=$(echo $SYNCROOT | sed 's#/*$##')/
fi
}
set_sftp_config() {
[ -z "$CURL_PRIVATE_KEY" ] && CURL_PRIVATE_KEY="$(get_config key)"
[ -z "$CURL_PUBLIC_KEY" ] && CURL_PUBLIC_KEY="$(get_config pubkey)"
}
set_remotes() {
set_remote_host
write_log "Host is '$REMOTE_HOST'."
set_remote_user
write_log "User is '$REMOTE_USER'."
set_remote_password
if [ -z "$REMOTE_PASSWD" ]; then
write_log "No password is set."
else
write_log "Password is set."
fi
set_remote_protocol
# 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
write_log "Path is '$REMOTE_PATH'."
set_syncroot
write_log "Syncroot is '$SYNCROOT'."
set_remote_cacert
write_log "CACert is '$REMOTE_CACERT'."
set_curl_insecure
write_log "Insecure is '$CURL_INSECURE'."
}
set_curl_insecure() {
[ -z "$CURL_INSECURE" ] && CURL_INSECURE="$(get_config insecure)"
}
get_protocol_of_url() {
echo "$1" | tr '[:upper:]' '[:lower:]' | egrep '^(ftp|sftp|ftps|ftpes)://' | cut -d ':' -f 1
}
set_scope() {
[ -z $SCOPE ] && print_error_and_die "Missing scope argument." $ERROR_MISSING_ARGUMENTS
[ -z $URL ] && print_error_and_die "Missing URL." $ERROR_MISSING_ARGUMENTS
# URI without credentials
if ! echo "$URL" | grep -q '@'; then
$(git config git-ftp.$SCOPE.url $URL)
return
fi
# set url
local protocol=$(get_protocol_of_url "$URL")
local path=${URL##*@}
$(git config git-ftp.$SCOPE.url ${protocol}${path})
# strip protocol
local credentials=${URL#${protocol}}
# cut at last '@' occurence
local credentials=${credentials%${URL##*@}}
# strip trailing '@'
local credentials=${credentials%?}
local colons=${credentials//[^:]/}
case ${#colons} in
0)
# assume only username
$(git config git-ftp.$SCOPE.user ${credentials})
;;
1)
# credentials have both username and password
$(git config git-ftp.$SCOPE.user ${credentials%:*})
$(git config git-ftp.$SCOPE.password ${credentials#*:})
;;
*)
# we can't know where to cut with multiple ':'
print_info "Warning, multiple ':' characters detected, only URL was set in scope."
print_info "Use --user and --passwd options to set login and password respectively."
esac
}
remove_scope() {
[ -z $SCOPE ] && print_error_and_die "Missing scope argument." $ERROR_MISSING_ARGUMENTS
$(git config --remove-section git-ftp.$SCOPE &>/dev/null)
[ $? -ne 0 ] && print_error_and_die "Cannot fine scope $SCOPE." $ERROR_GIT
print_info "Successfully removed scope $SCOPE."
}
# ------------------------------------------------------------
# Actions
# ------------------------------------------------------------
action_init() {
check_git_version
check_is_git_project
check_is_dirty_repository
set_remotes
check_deployed_sha1
set_local_sha1
set_changed_files
remote_lock
handle_file_sync
upload_local_sha1
release_remote_lock
}
action_push() {
check_git_version
check_is_git_project
check_is_dirty_repository
set_remotes
set_deployed_sha1
set_local_sha1
set_changed_files
remote_lock
handle_file_sync
upload_local_sha1
release_remote_lock
}
action_catchup() {
check_is_git_project
check_is_dirty_repository
set_remotes
set_local_sha1
upload_local_sha1
}
action_show() {
set_remotes
DEPLOYED_SHA1="$(get_file_content $DEPLOYED_SHA1_FILE)"
check_exit_status "Could not get uploaded log file" $ERROR_DOWNLOAD
git show "$DEPLOYED_SHA1"
}
action_log() {
set_remotes
DEPLOYED_SHA1="$(get_file_content $DEPLOYED_SHA1_FILE)"
check_exit_status "Could not get uploaded log file" $ERROR_DOWNLOAD
git log "$DEPLOYED_SHA1"
}
action_add_scope() {
check_is_git_project
set_scope
}
action_remove_scope() {
check_is_git_project
remove_scope
}
# ------------------------------------------------------------
# Checks
# ------------------------------------------------------------
check_deployed_sha1() {
write_log "Check if $REMOTE_PROTOCOL://$REMOTE_HOST/$REMOTE_PATH is clean."
DEPLOYED_SHA1="$(get_file_content $DEPLOYED_SHA1_FILE)"
if [ "$DEPLOYED_SHA1" != "" ]; then
print_error_and_die "Commit found, use 'git ftp push' to sync. Exiting..." $ERROR_USAGE
fi
# Make sure if sync all files if no sha1 was found
IGNORE_DEPLOYED=1
}
check_git_version() {
local GIT_VERSION=$(git --version | cut -d ' ' -f 3)
local MAJOR=$(echo $GIT_VERSION | cut -d '.' -f 1)
local MINOR=$(echo $GIT_VERSION | cut -d '.' -f 2)
if [ $MAJOR -lt 2 ] && [ $MINOR -lt 7 ]; then
print_error_and_die "Git is too old, 1.7.0 or higher suported only." $ERROR_GIT
fi
}