summaryrefslogtreecommitdiff
path: root/git.liw.fi.sh
blob: 6f202663fa26a34b97c9e373eb00dcd839751498 (plain)
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
# Shell library for running git.liw.fi ACL tests.


# We create ssh keys in the test suite. The temporary directory,
# $DATADIR, must be made inaccessible to others before that happens.
# We do it here, so it gets done before any of the code from an
# IMPLEMENTS actually runs.
chmod 0700 "$DATADIR"


# This is handy for giving an error message and aborting.

die()
{
    echo "$@" 1>&2
    exit 1
}


# Attempt to run something, which may fail. Store the stdout,
# stderr, and exit code in $DATADIR.

attempt()
{
    if "$@" > "$DATADIR/attempt.stdout" 2> "$DATADIR/attempt.stderr"
    then
        echo 0 > "$DATADIR/attempt.exit"
    else
        echo $? > "$DATADIR/attempt.exit"
    fi
}


# Run gitano on the server using a desired ssh key. The key is
# either the admin key (i.e., they key of whoever invoked the
# test suite), or a test key we've created in $DATADIR.

run_gitano_as()
{
    local keyname="$1"
    shift
    if [ "$keyname" = "admin" ]
    then
	ssh "$GITANO@$GITHOST" "$@"
    else
	SSH_AUTH_SOCK= ssh -F "ssh.conf" -i "$DATADIR/$keyname.key" \
	    "$GITANO@$GITHOST" "$@"
    fi
}


# Does a user exist on the server?

user_exists()
{
    ssh "$GITANO@$GITHOST" user | grep "^$1:"
}


# Create a user, including setting their ssh key.

user_add()
{
    run_gitano_as "$1" user add "$2" name foo@example.com
    run_gitano_as "$1" as "$2" sshkey add somekey < "$DATADIR/$2.key.pub"
}


# A helper function to do a two-step destruction on gitano. With the
# first step, gitano outputs a token, which is the last word on the
# last line of the output. The second step has the same command line
# as the first step, but with the token appended.

two_step()
{
    if "$@" 2> "$DATADIR/temp"
    then
	secret=$(awk '{ s = $2 } END { print s }' "$DATADIR/temp")
	"$@" "$secret"
    else
	cat "$DATADIR/temp" 1>&2
	return 1
    fi
}


# Remove a user from the server. This is a two-step process.

user_del()
{
    two_step run_gitano_as "$1" user del "$2"
}


# Does a repository exist?

repo_exists()
{
    run_gitano_as "$1" ls | awk -v "r=$2" '$NF == r' | grep .
}


# Clone repo over ssh.

clone_with_ssh()
{
    localdir="$DATADIR/$1/$2"
    rm -rf "$localdir"
    mkdir -p "$localdir"
    url="ssh://$GITANO@$GITHOST/$2"
    if [ "$1" = admin ]
    then
	git clone "$url" "$localdir"
    else
	KEYFILE="$DATADIR/$1.key" \
	    PATH="$SRCDIR:$PATH" git clone "$url" "$localdir"
    fi
}


# Remove a repository from the server. This is a two-step process.

destroy_repo()
{
    two_step run_gitano_as "$1" destroy "$2"
}


# Does cgit show a repository?

cgit_shows()
{
    local tempfile="$(mktemp)"
    wget -q -O- "http://$GITHOST/cgi-bin/cgit/cgit.cgi/$1/" \
	> "$tempfile" 2>&1
    if grep 'Repository seems to be empty' "$tempfile"
    then
	ret=0
    elif grep 'Commit message' "$tempfile"
    then
	ret=0
    else
	ret=1
    fi
    rm -f "$tempfile"
    return $ret
}