1
=== removed file '.pc/applied-patches'
2
--- .pc/applied-patches	2013-01-18 22:04:32 +0000
3
+++ .pc/applied-patches	1970-01-01 00:00:00 +0000
4
@@ -1,8 +0,0 @@
5
1
force-reload.patch
6
2
couchdb_own_rundir.patch
7
3
logrotate_as_couchdb.patch
8
4
couchdb_sighup.patch
9
5
wait_for_couchdb_stop.patch
10
6
improve_parsing_of_mochiweb_relative_paths.patch
11
7
improve_script_url_validation.patch
12
8
include_a_comment_before_jsonp_output.patch
13
9
0
14
=== removed directory '.pc/couchdb_own_rundir.patch'
15
=== removed directory '.pc/couchdb_own_rundir.patch/etc'
16
=== removed directory '.pc/couchdb_own_rundir.patch/etc/init'
17
=== removed file '.pc/couchdb_own_rundir.patch/etc/init/couchdb.tpl.in'
18
--- .pc/couchdb_own_rundir.patch/etc/init/couchdb.tpl.in	2012-07-19 20:13:25 +0000
19
+++ .pc/couchdb_own_rundir.patch/etc/init/couchdb.tpl.in	1970-01-01 00:00:00 +0000
20
@@ -1,156 +0,0 @@
21
1
#!/bin/sh -e
22
2
23
3
# Licensed under the Apache License, Version 2.0 (the "License"); you may not
24
4
# use this file except in compliance with the License. You may obtain a copy of
25
5
# the License at
26
6
#
27
7
#   http://www.apache.org/licenses/LICENSE-2.0
28
8
#
29
9
# Unless required by applicable law or agreed to in writing, software
30
10
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
31
11
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
32
12
# License for the specific language governing permissions and limitations under
33
13
# the License.
34
14
35
15
### BEGIN INIT INFO
36
16
# Provides:          couchdb
37
17
# Required-Start:    $local_fs $remote_fs
38
18
# Required-Stop:     $local_fs $remote_fs
39
19
# Default-Start:     2 3 4 5
40
20
# Default-Stop:      0 1 6
41
21
# Short-Description: Apache CouchDB init script
42
22
# Description:       Apache CouchDB init script for the database server.
43
23
### END INIT INFO
44
24
45
25
SCRIPT_OK=0
46
26
SCRIPT_ERROR=1
47
27
48
28
DESCRIPTION="database server"
49
29
NAME=couchdb
50
30
SCRIPT_NAME=`basename $0`
51
31
COUCHDB=%bindir%/%couchdb_command_name%
52
32
CONFIGURATION_FILE=%sysconfdir%/default/couchdb
53
33
RUN_DIR=%localstaterundir%
54
34
LSB_LIBRARY=/lib/lsb/init-functions
55
35
56
36
if test ! -x $COUCHDB; then
57
37
    exit $SCRIPT_ERROR
58
38
fi
59
39
60
40
if test -r $CONFIGURATION_FILE; then
61
41
    . $CONFIGURATION_FILE
62
42
fi
63
43
64
44
log_daemon_msg () {
65
45
    # Dummy function to be replaced by LSB library.
66
46
67
47
    echo $@
68
48
}
69
49
70
50
log_end_msg () {
71
51
    # Dummy function to be replaced by LSB library.
72
52
73
53
    if test "$1" != "0"; then
74
54
      echo "Error with $DESCRIPTION: $NAME"
75
55
    fi
76
56
    return $1
77
57
}
78
58
79
59
if test -r $LSB_LIBRARY; then
80
60
    . $LSB_LIBRARY
81
61
fi
82
62
83
63
run_command () {
84
64
    command="$1"
85
65
    if test -n "$COUCHDB_OPTIONS"; then
86
66
        command="$command $COUCHDB_OPTIONS"
87
67
    fi
88
68
    if test -n "$COUCHDB_USER"; then
89
69
        if su $COUCHDB_USER -c "$command"; then
90
70
            return $SCRIPT_OK
91
71
        else
92
72
            return $SCRIPT_ERROR
93
73
        fi
94
74
    else
95
75
        if $command; then
96
76
            return $SCRIPT_OK
97
77
        else
98
78
            return $SCRIPT_ERROR
99
79
        fi
100
80
    fi
101
81
}
102
82
103
83
start_couchdb () {
104
84
    # Start Apache CouchDB as a background process.
105
85
106
86
    mkdir -p "$RUN_DIR"
107
87
    command="$COUCHDB -b"
108
88
    if test -n "$COUCHDB_STDOUT_FILE"; then
109
89
        command="$command -o $COUCHDB_STDOUT_FILE"
110
90
    fi
111
91
    if test -n "$COUCHDB_STDERR_FILE"; then
112
92
        command="$command -e $COUCHDB_STDERR_FILE"
113
93
    fi
114
94
    if test -n "$COUCHDB_RESPAWN_TIMEOUT"; then
115
95
        command="$command -r $COUCHDB_RESPAWN_TIMEOUT"
116
96
    fi
117
97
    run_command "$command" > /dev/null
118
98
}
119
99
120
100
stop_couchdb () {
121
101
    # Stop the running Apache CouchDB process.
122
102
123
103
    run_command "$COUCHDB -d" > /dev/null
124
104
}
125
105
126
106
display_status () {
127
107
    # Display the status of the running Apache CouchDB process.
128
108
129
109
    run_command "$COUCHDB -s"
130
110
}
131
111
132
112
parse_script_option_list () {
133
113
    # Parse arguments passed to the script and take appropriate action.
134
114
135
115
    case "$1" in
136
116
        start)
137
117
            log_daemon_msg "Starting $DESCRIPTION" $NAME
138
118
            if start_couchdb; then
139
119
                log_end_msg $SCRIPT_OK
140
120
            else
141
121
                log_end_msg $SCRIPT_ERROR
142
122
            fi
143
123
            ;;
144
124
        stop)
145
125
            log_daemon_msg "Stopping $DESCRIPTION" $NAME
146
126
            if stop_couchdb; then
147
127
                log_end_msg $SCRIPT_OK
148
128
            else
149
129
                log_end_msg $SCRIPT_ERROR
150
130
            fi
151
131
            ;;
152
132
        restart|force-reload)
153
133
            log_daemon_msg "Restarting $DESCRIPTION" $NAME
154
134
            if stop_couchdb; then
155
135
                if start_couchdb; then
156
136
                    log_end_msg $SCRIPT_OK
157
137
                else
158
138
                    log_end_msg $SCRIPT_ERROR
159
139
                fi
160
140
            else
161
141
                log_end_msg $SCRIPT_ERROR
162
142
            fi
163
143
            ;;
164
144
        status)
165
145
            display_status
166
146
            ;;
167
147
        *)
168
148
            cat << EOF >&2
169
149
Usage: $SCRIPT_NAME {start|stop|restart|force-reload|status}
170
150
EOF
171
151
            exit $SCRIPT_ERROR
172
152
            ;;
173
153
    esac
174
154
}
175
155
176
156
parse_script_option_list $@
177
157
0
178
=== removed directory '.pc/couchdb_sighup.patch'
179
=== removed directory '.pc/couchdb_sighup.patch/bin'
180
=== removed file '.pc/couchdb_sighup.patch/bin/couchdb.tpl.in'
181
--- .pc/couchdb_sighup.patch/bin/couchdb.tpl.in	2012-11-18 12:24:24 +0000
182
+++ .pc/couchdb_sighup.patch/bin/couchdb.tpl.in	1970-01-01 00:00:00 +0000
183
@@ -1,335 +0,0 @@
184
1
#! /bin/sh -e
185
2
186
3
# Licensed under the Apache License, Version 2.0 (the "License"); you may not
187
4
# use this file except in compliance with the License. You may obtain a copy of
188
5
# the License at
189
6
#
190
7
#   http://www.apache.org/licenses/LICENSE-2.0
191
8
#
192
9
# Unless required by applicable law or agreed to in writing, software
193
10
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
194
11
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
195
12
# License for the specific language governing permissions and limitations under
196
13
# the License.
197
14
198
15
BACKGROUND=false
199
16
DEFAULT_CONFIG_DIR=%localconfdir%/default.d
200
17
DEFAULT_CONFIG_FILE=%localconfdir%/%defaultini%
201
18
ERL_OS_MON_OPTIONS="-os_mon \
202
19
    start_memsup false \
203
20
    start_cpu_sup false \
204
21
    disk_space_check_interval 1 \
205
22
    disk_almost_full_threshold 1"
206
23
ERL_START_OPTIONS="$ERL_OS_MON_OPTIONS -sasl errlog_type error +K true +A 4"
207
24
HEART_BEAT_TIMEOUT=11
208
25
HEART_COMMAND="%bindir%/%couchdb_command_name% -k"
209
26
INTERACTIVE=false
210
27
KILL=false
211
28
LOCAL_CONFIG_DIR=%localconfdir%/local.d
212
29
LOCAL_CONFIG_FILE=%localconfdir%/%localini%
213
30
PID_FILE=%localstatedir%/run/couchdb/couchdb.pid
214
31
RECURSED=false
215
32
RESET_CONFIG=true
216
33
RESPAWN_TIMEOUT=0
217
34
SCRIPT_ERROR=1
218
35
SCRIPT_OK=0
219
36
SHUTDOWN=false
220
37
STDERR_FILE=couchdb.stderr
221
38
STDOUT_FILE=couchdb.stdout
222
39
223
40
print_arguments=""
224
41
start_arguments=""
225
42
background_start_arguments=""
226
43
227
44
basename=`basename $0`
228
45
229
46
display_version () {
230
47
    cat << EOF
231
48
$basename - %package_name% %version%
232
49
233
50
Licensed under the Apache License, Version 2.0 (the "License"); you may not use
234
51
this file except in compliance with the License. You may obtain a copy of the
235
52
License at
236
53
237
54
  http://www.apache.org/licenses/LICENSE-2.0
238
55
239
56
Unless required by applicable law or agreed to in writing, software distributed
240
57
under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
241
58
CONDITIONS OF ANY KIND, either express or implied. See the License for the
242
59
specific language governing permissions and limitations under the License.
243
60
244
61
EOF
245
62
}
246
63
247
64
display_help () {
248
65
    cat << EOF
249
66
Usage: $basename [OPTION]
250
67
251
68
The $basename command runs the %package_name% server.
252
69
253
70
Erlang is called with:
254
71
255
72
    $ERL_START_OPTIONS
256
73
257
74
Erlang inherits the environment of this command.
258
75
259
76
You can override these options using the environment:
260
77
261
78
    ERL_AFLAGS, ERL_FLAGS, ERL_ZFLAGS
262
79
263
80
See erl(1) for more information about the environment variables.
264
81
265
82
The exit status is 0 for success or 1 for failure.
266
83
267
84
Options:
268
85
269
86
  -h          display a short help message and exit
270
87
  -V          display version information and exit
271
88
  -a FILE     add configuration FILE to chain
272
89
  -A DIR      add configuration DIR to chain
273
90
  -n          reset configuration file chain (including system default)
274
91
  -c          print configuration file chain and exit
275
92
  -i          use the interactive Erlang shell
276
93
  -b          spawn as a background process
277
94
  -p FILE     set the background PID FILE (overrides system default)
278
95
  -r SECONDS  respawn background process after SECONDS (defaults to no respawn)
279
96
  -o FILE     redirect background stdout to FILE (defaults to $STDOUT_FILE)
280
97
  -e FILE     redirect background stderr to FILE (defaults to $STDERR_FILE)
281
98
  -s          display the status of the background process
282
99
  -k          kill the background process, will respawn if needed
283
100
  -d          shutdown the background process
284
101
285
102
Report bugs at <%bug_uri%>.
286
103
EOF
287
104
}
288
105
289
106
display_error () {
290
107
    if test -n "$1"; then
291
108
        echo $1 >&2
292
109
    fi
293
110
    echo >&2
294
111
    echo "Try \`"$basename" -h' for more information." >&2
295
112
    false
296
113
}
297
114
298
115
_get_pid () {
299
116
    if test -f $PID_FILE; then
300
117
        PID=`cat $PID_FILE`
301
118
    fi
302
119
    echo $PID
303
120
}
304
121
305
122
_add_config_file () {
306
123
    if test -z "$print_arguments"; then
307
124
        print_arguments="$1"
308
125
    else
309
126
        print_arguments="`cat <<EOF
310
127
$print_arguments
311
128
$1
312
129
EOF
313
130
`"
314
131
    fi
315
132
    start_arguments="$start_arguments $1"
316
133
    background_start_arguments="$background_start_arguments -a $1"
317
134
}
318
135
319
136
_add_config_dir () {
320
137
    for file in "$1"/*.ini; do
321
138
        if [ -r "$file" ]; then
322
139
          _add_config_file "$file"
323
140
        fi
324
141
    done
325
142
}
326
143
327
144
_load_config () {
328
145
    _add_config_file "$DEFAULT_CONFIG_FILE"
329
146
    _add_config_dir "$DEFAULT_CONFIG_DIR"
330
147
    _add_config_file "$LOCAL_CONFIG_FILE"
331
148
    _add_config_dir "$LOCAL_CONFIG_DIR"
332
149
}
333
150
334
151
_reset_config () {
335
152
    print_arguments=""
336
153
    start_arguments=""
337
154
    background_start_arguments="-n"
338
155
}
339
156
340
157
_print_config () {
341
158
    cat <<EOF
342
159
$print_arguments
343
160
EOF
344
161
}
345
162
346
163
check_status () {
347
164
    PID=`_get_pid`
348
165
    if test -n "$PID"; then
349
166
        if kill -0 $PID 2> /dev/null; then
350
167
            echo "Apache CouchDB is running as process $PID, time to relax."
351
168
            return $SCRIPT_OK
352
169
        else
353
170
            echo >&2 << EOF
354
171
Apache CouchDB is not running but a stale PID file exists: $PID_FILE
355
172
EOF
356
173
        fi
357
174
    else
358
175
        echo "Apache CouchDB is not running." >&2
359
176
    fi
360
177
    return $SCRIPT_ERROR
361
178
}
362
179
363
180
check_environment () {
364
181
    if test "$BACKGROUND" != "true"; then
365
182
        return
366
183
    fi
367
184
    touch $PID_FILE 2> /dev/null || true
368
185
    touch $STDOUT_FILE 2> /dev/null || true
369
186
    touch $STDERR_FILE 2> /dev/null || true
370
187
    message_prefix="Apache CouchDB needs write permission on the"
371
188
    if test ! -w $PID_FILE; then
372
189
        echo "$message_prefix PID file: $PID_FILE" >&2
373
190
        false
374
191
    fi
375
192
    if test ! -w $STDOUT_FILE; then
376
193
        echo "$message_prefix STDOUT file: $STDOUT_FILE" >&2
377
194
        false
378
195
    fi
379
196
    if test ! -w $STDERR_FILE; then
380
197
        echo "$message_prefix STDERR file: $STDERR_FILE" >&2
381
198
        false
382
199
    fi
383
200
    message_prefix="Apache CouchDB needs a regular"
384
201
    if test `echo 2> /dev/null >> $PID_FILE; echo $?` -gt 0; then
385
202
        echo "$message_prefix PID file: $PID_FILE" >&2
386
203
        false
387
204
    fi
388
205
    if test `echo 2> /dev/null >> $STDOUT_FILE; echo $?` -gt 0; then
389
206
        echo "$message_prefix STDOUT file: $STDOUT_FILE" >&2
390
207
        false
391
208
    fi
392
209
    if test `echo 2> /dev/null >> $STDERR_FILE; echo $?` -gt 0; then
393
210
        echo "$message_prefix STDERR file: $STDERR_FILE" >&2
394
211
        false
395
212
    fi
396
213
}
397
214
398
215
start_couchdb () {
399
216
    if test ! "$RECURSED" = "true"; then
400
217
        if check_status 2> /dev/null; then
401
218
            exit
402
219
        fi
403
220
        check_environment
404
221
    fi
405
222
    interactive_option="+Bd -noinput"
406
223
    if test "$INTERACTIVE" = "true"; then
407
224
        interactive_option=""
408
225
    fi
409
226
    if test "$BACKGROUND" = "true"; then
410
227
        touch $PID_FILE
411
228
        interactive_option="+Bd -noinput"
412
229
    fi
413
230
    command="%ERL% $interactive_option $ERL_START_OPTIONS \
414
231
        -env ERL_LIBS %localerlanglibdir% -couch_ini $start_arguments -s couch"
415
232
    if test "$BACKGROUND" = "true" -a "$RECURSED" = "false"; then
416
233
        $0 $background_start_arguments -b -r $RESPAWN_TIMEOUT -p $PID_FILE \
417
234
            -o $STDOUT_FILE -e $STDERR_FILE -R &
418
235
        echo "Apache CouchDB has started, time to relax."
419
236
    else
420
237
        if test "$RECURSED" = "true"; then
421
238
            while true; do
422
239
                export HEART_COMMAND
423
240
                export HEART_BEAT_TIMEOUT
424
241
                `eval $command -pidfile $PID_FILE -heart \
425
242
                    >> $STDOUT_FILE 2>> $STDERR_FILE` || true
426
243
                PID=`_get_pid`
427
244
                if test -n "$PID"; then
428
245
                    if kill -0 $PID 2> /dev/null; then
429
246
                        return $SCRIPT_ERROR
430
247
                    fi
431
248
                else
432
249
                    return $SCRIPT_OK
433
250
                fi
434
251
                if test "$RESPAWN_TIMEOUT" = "0"; then
435
252
                    return $SCRIPT_OK
436
253
                fi
437
254
                if test "$RESPAWN_TIMEOUT" != "1"; then
438
255
                    plural_ending="s"
439
256
                fi
440
257
                cat << EOF
441
258
Apache CouchDB crashed, restarting in $RESPAWN_TIMEOUT second$plural_ending.
442
259
EOF
443
260
                sleep $RESPAWN_TIMEOUT
444
261
            done
445
262
        else
446
263
            eval exec $command
447
264
        fi
448
265
    fi
449
266
}
450
267
451
268
stop_couchdb () {
452
269
    PID=`_get_pid`
453
270
    if test -n "$PID"; then
454
271
        if test "$1" = "false"; then
455
272
            echo > $PID_FILE
456
273
        fi
457
274
        if kill -0 $PID 2> /dev/null; then
458
275
            if kill -1 $PID 2> /dev/null; then
459
276
                if test "$1" = "false"; then
460
277
                    echo "Apache CouchDB has been shutdown."
461
278
                else
462
279
                    echo "Apache CouchDB has been killed."
463
280
                fi
464
281
                return $SCRIPT_OK
465
282
            else
466
283
                echo "Apache CouchDB could not be killed." >&2
467
284
                return $SCRIPT_ERROR
468
285
            fi
469
286
            if test "$1" = "false"; then
470
287
                echo "Stale PID file exists but Apache CouchDB is not running."
471
288
            else
472
289
                echo "Stale PID file existed but Apache CouchDB is not running."
473
290
            fi
474
291
        fi
475
292
    else
476
293
        echo "Apache CouchDB is not running."
477
294
    fi
478
295
}
479
296
480
297
parse_script_option_list () {
481
298
    _load_config
482
299
    set +e
483
300
    options=`getopt hVa:A:ncibp:r:Ro:e:skd $@`
484
301
    if test ! $? -eq 0; then
485
302
        display_error
486
303
    fi
487
304
    set -e
488
305
    eval set -- $options
489
306
    while [ $# -gt 0 ]; do
490
307
        case "$1" in
491
308
            -h) shift; display_help; exit;;
492
309
            -V) shift; display_version; exit;;
493
310
            -a) shift; _add_config_file "$1"; shift;;
494
311
            -A) shift; _add_config_dir "$1"; shift;;
495
312
            -n) shift; _reset_config;;
496
313
            -c) shift; _print_config; exit;;
497
314
            -i) shift; INTERACTIVE=true;;
498
315
            -b) shift; BACKGROUND=true;;
499
316
            -r) shift; RESPAWN_TIMEOUT=$1; shift;;
500
317
            -R) shift; RECURSED=true;;
501
318
            -p) shift; PID_FILE=$1; shift;;
502
319
            -o) shift; STDOUT_FILE=$1; shift;;
503
320
            -e) shift; STDERR_FILE=$1; shift;;
504
321
            -s) shift; check_status; exit;;
505
322
            -k) shift; KILL=true;;
506
323
            -d) shift; SHUTDOWN=true;;
507
324
            --) shift; break;;
508
325
            *) display_error "Unknown option: $1" >&2;;
509
326
        esac
510
327
    done
511
328
    if test "$KILL" = "true" -o "$SHUTDOWN" = "true"; then
512
329
        stop_couchdb $KILL
513
330
    else
514
331
        start_couchdb
515
332
    fi
516
333
}
517
334
518
335
parse_script_option_list $@
519
336
0
520
=== removed directory '.pc/force-reload.patch'
521
=== removed directory '.pc/force-reload.patch/etc'
522
=== removed directory '.pc/force-reload.patch/etc/init'
523
=== removed file '.pc/force-reload.patch/etc/init/couchdb.tpl.in'
524
--- .pc/force-reload.patch/etc/init/couchdb.tpl.in	2012-04-10 21:14:05 +0000
525
+++ .pc/force-reload.patch/etc/init/couchdb.tpl.in	1970-01-01 00:00:00 +0000
526
@@ -1,156 +0,0 @@
527
1
#!/bin/sh -e
528
2
529
3
# Licensed under the Apache License, Version 2.0 (the "License"); you may not
530
4
# use this file except in compliance with the License. You may obtain a copy of
531
5
# the License at
532
6
#
533
7
#   http://www.apache.org/licenses/LICENSE-2.0
534
8
#
535
9
# Unless required by applicable law or agreed to in writing, software
536
10
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
537
11
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
538
12
# License for the specific language governing permissions and limitations under
539
13
# the License.
540
14
541
15
### BEGIN INIT INFO
542
16
# Provides:          couchdb
543
17
# Required-Start:    $local_fs $remote_fs
544
18
# Required-Stop:     $local_fs $remote_fs
545
19
# Default-Start:     2 3 4 5
546
20
# Default-Stop:      0 1 6
547
21
# Short-Description: Apache CouchDB init script
548
22
# Description:       Apache CouchDB init script for the database server.
549
23
### END INIT INFO
550
24
551
25
SCRIPT_OK=0
552
26
SCRIPT_ERROR=1
553
27
554
28
DESCRIPTION="database server"
555
29
NAME=couchdb
556
30
SCRIPT_NAME=`basename $0`
557
31
COUCHDB=%bindir%/%couchdb_command_name%
558
32
CONFIGURATION_FILE=%sysconfdir%/default/couchdb
559
33
RUN_DIR=%localstaterundir%
560
34
LSB_LIBRARY=/lib/lsb/init-functions
561
35
562
36
if test ! -x $COUCHDB; then
563
37
    exit $SCRIPT_ERROR
564
38
fi
565
39
566
40
if test -r $CONFIGURATION_FILE; then
567
41
    . $CONFIGURATION_FILE
568
42
fi
569
43
570
44
log_daemon_msg () {
571
45
    # Dummy function to be replaced by LSB library.
572
46
573
47
    echo $@
574
48
}
575
49
576
50
log_end_msg () {
577
51
    # Dummy function to be replaced by LSB library.
578
52
579
53
    if test "$1" != "0"; then
580
54
      echo "Error with $DESCRIPTION: $NAME"
581
55
    fi
582
56
    return $1
583
57
}
584
58
585
59
if test -r $LSB_LIBRARY; then
586
60
    . $LSB_LIBRARY
587
61
fi
588
62
589
63
run_command () {
590
64
    command="$1"
591
65
    if test -n "$COUCHDB_OPTIONS"; then
592
66
        command="$command $COUCHDB_OPTIONS"
593
67
    fi
594
68
    if test -n "$COUCHDB_USER"; then
595
69
        if su $COUCHDB_USER -c "$command"; then
596
70
            return $SCRIPT_OK
597
71
        else
598
72
            return $SCRIPT_ERROR
599
73
        fi
600
74
    else
601
75
        if $command; then
602
76
            return $SCRIPT_OK
603
77
        else
604
78
            return $SCRIPT_ERROR
605
79
        fi
606
80
    fi
607
81
}
608
82
609
83
start_couchdb () {
610
84
    # Start Apache CouchDB as a background process.
611
85
612
86
    mkdir -p "$RUN_DIR"
613
87
    command="$COUCHDB -b"
614
88
    if test -n "$COUCHDB_STDOUT_FILE"; then
615
89
        command="$command -o $COUCHDB_STDOUT_FILE"
616
90
    fi
617
91
    if test -n "$COUCHDB_STDERR_FILE"; then
618
92
        command="$command -e $COUCHDB_STDERR_FILE"
619
93
    fi
620
94
    if test -n "$COUCHDB_RESPAWN_TIMEOUT"; then
621
95
        command="$command -r $COUCHDB_RESPAWN_TIMEOUT"
622
96
    fi
623
97
    run_command "$command" > /dev/null
624
98
}
625
99
626
100
stop_couchdb () {
627
101
    # Stop the running Apache CouchDB process.
628
102
629
103
    run_command "$COUCHDB -d" > /dev/null
630
104
}
631
105
632
106
display_status () {
633
107
    # Display the status of the running Apache CouchDB process.
634
108
635
109
    run_command "$COUCHDB -s"
636
110
}
637
111
638
112
parse_script_option_list () {
639
113
    # Parse arguments passed to the script and take appropriate action.
640
114
641
115
    case "$1" in
642
116
        start)
643
117
            log_daemon_msg "Starting $DESCRIPTION" $NAME
644
118
            if start_couchdb; then
645
119
                log_end_msg $SCRIPT_OK
646
120
            else
647
121
                log_end_msg $SCRIPT_ERROR
648
122
            fi
649
123
            ;;
650
124
        stop)
651
125
            log_daemon_msg "Stopping $DESCRIPTION" $NAME
652
126
            if stop_couchdb; then
653
127
                log_end_msg $SCRIPT_OK
654
128
            else
655
129
                log_end_msg $SCRIPT_ERROR
656
130
            fi
657
131
            ;;
658
132
        restart)
659
133
            log_daemon_msg "Restarting $DESCRIPTION" $NAME
660
134
            if stop_couchdb; then
661
135
                if start_couchdb; then
662
136
                    log_end_msg $SCRIPT_OK
663
137
                else
664
138
                    log_end_msg $SCRIPT_ERROR
665
139
                fi
666
140
            else
667
141
                log_end_msg $SCRIPT_ERROR
668
142
            fi
669
143
            ;;
670
144
        status)
671
145
            display_status
672
146
            ;;
673
147
        *)
674
148
            cat << EOF >&2
675
149
Usage: $SCRIPT_NAME {start|stop|restart|status}
676
150
EOF
677
151
            exit $SCRIPT_ERROR
678
152
            ;;
679
153
    esac
680
154
}
681
155
682
156
parse_script_option_list $@
683
157
0
684
=== removed directory '.pc/improve_parsing_of_mochiweb_relative_paths.patch'
685
=== removed directory '.pc/improve_parsing_of_mochiweb_relative_paths.patch/src'
686
=== removed directory '.pc/improve_parsing_of_mochiweb_relative_paths.patch/src/mochiweb'
687
=== removed file '.pc/improve_parsing_of_mochiweb_relative_paths.patch/src/mochiweb/mochiweb_util.erl'
688
--- .pc/improve_parsing_of_mochiweb_relative_paths.patch/src/mochiweb/mochiweb_util.erl	2013-01-18 22:04:32 +0000
689
+++ .pc/improve_parsing_of_mochiweb_relative_paths.patch/src/mochiweb/mochiweb_util.erl	1970-01-01 00:00:00 +0000
690
@@ -1,973 +0,0 @@
691
1
%% @author Bob Ippolito <bob@mochimedia.com>
692
2
%% @copyright 2007 Mochi Media, Inc.
693
3
694
4
%% @doc Utilities for parsing and quoting.
695
5
696
6
-module(mochiweb_util).
697
7
-author('bob@mochimedia.com').
698
8
-export([join/2, quote_plus/1, urlencode/1, parse_qs/1, unquote/1]).
699
9
-export([path_split/1]).
700
10
-export([urlsplit/1, urlsplit_path/1, urlunsplit/1, urlunsplit_path/1]).
701
11
-export([guess_mime/1, parse_header/1]).
702
12
-export([shell_quote/1, cmd/1, cmd_string/1, cmd_port/2, cmd_status/1]).
703
13
-export([record_to_proplist/2, record_to_proplist/3]).
704
14
-export([safe_relative_path/1, partition/2]).
705
15
-export([parse_qvalues/1, pick_accepted_encodings/3]).
706
16
-export([make_io/1]).
707
17
708
18
-define(PERCENT, 37).  % $\%
709
19
-define(FULLSTOP, 46). % $\.
710
20
-define(IS_HEX(C), ((C >= $0 andalso C =< $9) orelse
711
21
                    (C >= $a andalso C =< $f) orelse
712
22
                    (C >= $A andalso C =< $F))).
713
23
-define(QS_SAFE(C), ((C >= $a andalso C =< $z) orelse
714
24
                     (C >= $A andalso C =< $Z) orelse
715
25
                     (C >= $0 andalso C =< $9) orelse
716
26
                     (C =:= ?FULLSTOP orelse C =:= $- orelse C =:= $~ orelse
717
27
                      C =:= $_))).
718
28
719
29
hexdigit(C) when C < 10 -> $0 + C;
720
30
hexdigit(C) when C < 16 -> $A + (C - 10).
721
31
722
32
unhexdigit(C) when C >= $0, C =< $9 -> C - $0;
723
33
unhexdigit(C) when C >= $a, C =< $f -> C - $a + 10;
724
34
unhexdigit(C) when C >= $A, C =< $F -> C - $A + 10.
725
35
726
36
%% @spec partition(String, Sep) -> {String, [], []} | {Prefix, Sep, Postfix}
727
37
%% @doc Inspired by Python 2.5's str.partition:
728
38
%%      partition("foo/bar", "/") = {"foo", "/", "bar"},
729
39
%%      partition("foo", "/") = {"foo", "", ""}.
730
40
partition(String, Sep) ->
731
41
    case partition(String, Sep, []) of
732
42
        undefined ->
733
43
            {String, "", ""};
734
44
        Result ->
735
45
            Result
736
46
    end.
737
47
738
48
partition("", _Sep, _Acc) ->
739
49
    undefined;
740
50
partition(S, Sep, Acc) ->
741
51
    case partition2(S, Sep) of
742
52
        undefined ->
743
53
            [C | Rest] = S,
744
54
            partition(Rest, Sep, [C | Acc]);
745
55
        Rest ->
746
56
            {lists:reverse(Acc), Sep, Rest}
747
57
    end.
748
58
749
59
partition2(Rest, "") ->
750
60
    Rest;
751
61
partition2([C | R1], [C | R2]) ->
752
62
    partition2(R1, R2);
753
63
partition2(_S, _Sep) ->
754
64
    undefined.
755
65
756
66
757
67
758
68
%% @spec safe_relative_path(string()) -> string() | undefined
759
69
%% @doc Return the reduced version of a relative path or undefined if it
760
70
%%      is not safe. safe relative paths can be joined with an absolute path
761
71
%%      and will result in a subdirectory of the absolute path.
762
72
safe_relative_path("/" ++ _) ->
763
73
    undefined;
764
74
safe_relative_path(P) ->
765
75
    safe_relative_path(P, []).
766
76
767
77
safe_relative_path("", Acc) ->
768
78
    case Acc of
769
79
        [] ->
770
80
            "";
771
81
        _ ->
772
82
            string:join(lists:reverse(Acc), "/")
773
83
    end;
774
84
safe_relative_path(P, Acc) ->
775
85
    case partition(P, "/") of
776
86
        {"", "/", _} ->
777
87
            %% /foo or foo//bar
778
88
            undefined;
779
89
        {"..", _, _} when Acc =:= [] ->
780
90
            undefined;
781
91
        {"..", _, Rest} ->
782
92
            safe_relative_path(Rest, tl(Acc));
783
93
        {Part, "/", ""} ->
784
94
            safe_relative_path("", ["", Part | Acc]);
785
95
        {Part, _, Rest} ->
786
96
            safe_relative_path(Rest, [Part | Acc])
787
97
    end.
788
98
789
99
%% @spec shell_quote(string()) -> string()
790
100
%% @doc Quote a string according to UNIX shell quoting rules, returns a string
791
101
%%      surrounded by double quotes.
792
102
shell_quote(L) ->
793
103
    shell_quote(L, [$\"]).
794
104
795
105
%% @spec cmd_port([string()], Options) -> port()
796
106
%% @doc open_port({spawn, mochiweb_util:cmd_string(Argv)}, Options).
797
107
cmd_port(Argv, Options) ->
798
108
    open_port({spawn, cmd_string(Argv)}, Options).
799
109
800
110
%% @spec cmd([string()]) -> string()
801
111
%% @doc os:cmd(cmd_string(Argv)).
802
112
cmd(Argv) ->
803
113
    os:cmd(cmd_string(Argv)).
804
114
805
115
%% @spec cmd_string([string()]) -> string()
806
116
%% @doc Create a shell quoted command string from a list of arguments.
807
117
cmd_string(Argv) ->
808
118
    string:join([shell_quote(X) || X <- Argv], " ").
809
119
810
120
%% @spec cmd_status([string()]) -> {ExitStatus::integer(), Stdout::binary()}
811
121
%% @doc Accumulate the output and exit status from the given application, will be
812
122
%%      spawned with cmd_port/2.
813
123
cmd_status(Argv) ->
814
124
    Port = cmd_port(Argv, [exit_status, stderr_to_stdout,
815
125
                           use_stdio, binary]),
816
126
    try cmd_loop(Port, [])
817
127
    after catch port_close(Port)
818
128
    end.
819
129
820
130
%% @spec cmd_loop(port(), list()) -> {ExitStatus::integer(), Stdout::binary()}
821
131
%% @doc Accumulate the output and exit status from a port.
822
132
cmd_loop(Port, Acc) ->
823
133
    receive
824
134
        {Port, {exit_status, Status}} ->
825
135
            {Status, iolist_to_binary(lists:reverse(Acc))};
826
136
        {Port, {data, Data}} ->
827
137
            cmd_loop(Port, [Data | Acc])
828
138
    end.
829
139
830
140
%% @spec join([iolist()], iolist()) -> iolist()
831
141
%% @doc Join a list of strings or binaries together with the given separator
832
142
%%      string or char or binary. The output is flattened, but may be an
833
143
%%      iolist() instead of a string() if any of the inputs are binary().
834
144
join([], _Separator) ->
835
145
    [];
836
146
join([S], _Separator) ->
837
147
    lists:flatten(S);
838
148
join(Strings, Separator) ->
839
149
    lists:flatten(revjoin(lists:reverse(Strings), Separator, [])).
840
150
841
151
revjoin([], _Separator, Acc) ->
842
152
    Acc;
843
153
revjoin([S | Rest], Separator, []) ->
844
154
    revjoin(Rest, Separator, [S]);
845
155
revjoin([S | Rest], Separator, Acc) ->
846
156
    revjoin(Rest, Separator, [S, Separator | Acc]).
847
157
848
158
%% @spec quote_plus(atom() | integer() | float() | string() | binary()) -> string()
849
159
%% @doc URL safe encoding of the given term.
850
160
quote_plus(Atom) when is_atom(Atom) ->
851
161
    quote_plus(atom_to_list(Atom));
852
162
quote_plus(Int) when is_integer(Int) ->
853
163
    quote_plus(integer_to_list(Int));
854
164
quote_plus(Binary) when is_binary(Binary) ->
855
165
    quote_plus(binary_to_list(Binary));
856
166
quote_plus(Float) when is_float(Float) ->
857
167
    quote_plus(mochinum:digits(Float));
858
168
quote_plus(String) ->
859
169
    quote_plus(String, []).
860
170
861
171
quote_plus([], Acc) ->
862
172
    lists:reverse(Acc);
863
173
quote_plus([C | Rest], Acc) when ?QS_SAFE(C) ->
864
174
    quote_plus(Rest, [C | Acc]);
865
175
quote_plus([$\s | Rest], Acc) ->
866
176
    quote_plus(Rest, [$+ | Acc]);
867
177
quote_plus([C | Rest], Acc) ->
868
178
    <<Hi:4, Lo:4>> = <<C>>,
869
179
    quote_plus(Rest, [hexdigit(Lo), hexdigit(Hi), ?PERCENT | Acc]).
870
180
871
181
%% @spec urlencode([{Key, Value}]) -> string()
872
182
%% @doc URL encode the property list.
873
183
urlencode(Props) ->
874
184
    Pairs = lists:foldr(
875
185
              fun ({K, V}, Acc) ->
876
186
                      [quote_plus(K) ++ "=" ++ quote_plus(V) | Acc]
877
187
              end, [], Props),
878
188
    string:join(Pairs, "&").
879
189
880
190
%% @spec parse_qs(string() | binary()) -> [{Key, Value}]
881
191
%% @doc Parse a query string or application/x-www-form-urlencoded.
882
192
parse_qs(Binary) when is_binary(Binary) ->
883
193
    parse_qs(binary_to_list(Binary));
884
194
parse_qs(String) ->
885
195
    parse_qs(String, []).
886
196
887
197
parse_qs([], Acc) ->
888
198
    lists:reverse(Acc);
889
199
parse_qs(String, Acc) ->
890
200
    {Key, Rest} = parse_qs_key(String),
891
201
    {Value, Rest1} = parse_qs_value(Rest),
892
202
    parse_qs(Rest1, [{Key, Value} | Acc]).
893
203
894
204
parse_qs_key(String) ->
895
205
    parse_qs_key(String, []).
896
206
897
207
parse_qs_key([], Acc) ->
898
208
    {qs_revdecode(Acc), ""};
899
209
parse_qs_key([$= | Rest], Acc) ->
900
210
    {qs_revdecode(Acc), Rest};
901
211
parse_qs_key(Rest=[$; | _], Acc) ->
902
212
    {qs_revdecode(Acc), Rest};
903
213
parse_qs_key(Rest=[$& | _], Acc) ->
904
214
    {qs_revdecode(Acc), Rest};
905
215
parse_qs_key([C | Rest], Acc) ->
906
216
    parse_qs_key(Rest, [C | Acc]).
907
217
908
218
parse_qs_value(String) ->
909
219
    parse_qs_value(String, []).
910
220
911
221
parse_qs_value([], Acc) ->
912
222
    {qs_revdecode(Acc), ""};
913
223
parse_qs_value([$; | Rest], Acc) ->
914
224
    {qs_revdecode(Acc), Rest};
915
225
parse_qs_value([$& | Rest], Acc) ->
916
226
    {qs_revdecode(Acc), Rest};
917
227
parse_qs_value([C | Rest], Acc) ->
918
228
    parse_qs_value(Rest, [C | Acc]).
919
229
920
230
%% @spec unquote(string() | binary()) -> string()
921
231
%% @doc Unquote a URL encoded string.
922
232
unquote(Binary) when is_binary(Binary) ->
923
233
    unquote(binary_to_list(Binary));
924
234
unquote(String) ->
925
235
    qs_revdecode(lists:reverse(String)).
926
236
927
237
qs_revdecode(S) ->
928
238
    qs_revdecode(S, []).
929
239
930
240
qs_revdecode([], Acc) ->
931
241
    Acc;
932
242
qs_revdecode([$+ | Rest], Acc) ->
933
243
    qs_revdecode(Rest, [$\s | Acc]);
934
244
qs_revdecode([Lo, Hi, ?PERCENT | Rest], Acc) when ?IS_HEX(Lo), ?IS_HEX(Hi) ->
935
245
    qs_revdecode(Rest, [(unhexdigit(Lo) bor (unhexdigit(Hi) bsl 4)) | Acc]);
936
246
qs_revdecode([C | Rest], Acc) ->
937
247
    qs_revdecode(Rest, [C | Acc]).
938
248
939
249
%% @spec urlsplit(Url) -> {Scheme, Netloc, Path, Query, Fragment}
940
250
%% @doc Return a 5-tuple, does not expand % escapes. Only supports HTTP style
941
251
%%      URLs.
942
252
urlsplit(Url) ->
943
253
    {Scheme, Url1} = urlsplit_scheme(Url),
944
254
    {Netloc, Url2} = urlsplit_netloc(Url1),
945
255
    {Path, Query, Fragment} = urlsplit_path(Url2),
946
256
    {Scheme, Netloc, Path, Query, Fragment}.
947
257
948
258
urlsplit_scheme(Url) ->
949
259
    case urlsplit_scheme(Url, []) of
950
260
        no_scheme ->
951
261
            {"", Url};
952
262
        Res ->
953
263
            Res
954
264
    end.
955
265
956
266
urlsplit_scheme([C | Rest], Acc) when ((C >= $a andalso C =< $z) orelse
957
267
                                       (C >= $A andalso C =< $Z) orelse
958
268
                                       (C >= $0 andalso C =< $9) orelse
959
269
                                       C =:= $+ orelse C =:= $- orelse
960
270
                                       C =:= $.) ->
961
271
    urlsplit_scheme(Rest, [C | Acc]);
962
272
urlsplit_scheme([$: | Rest], Acc=[_ | _]) ->
963
273
    {string:to_lower(lists:reverse(Acc)), Rest};
964
274
urlsplit_scheme(_Rest, _Acc) ->
965
275
    no_scheme.
966
276
967
277
urlsplit_netloc("//" ++ Rest) ->
968
278
    urlsplit_netloc(Rest, []);
969
279
urlsplit_netloc(Path) ->
970
280
    {"", Path}.
971
281
972
282
urlsplit_netloc("", Acc) ->
973
283
    {lists:reverse(Acc), ""};
974
284
urlsplit_netloc(Rest=[C | _], Acc) when C =:= $/; C =:= $?; C =:= $# ->
975
285
    {lists:reverse(Acc), Rest};
976
286
urlsplit_netloc([C | Rest], Acc) ->
977
287
    urlsplit_netloc(Rest, [C | Acc]).
978
288
979
289
980
290
%% @spec path_split(string()) -> {Part, Rest}
981
291
%% @doc Split a path starting from the left, as in URL traversal.
982
292
%%      path_split("foo/bar") = {"foo", "bar"},
983
293
%%      path_split("/foo/bar") = {"", "foo/bar"}.
984
294
path_split(S) ->
985
295
    path_split(S, []).
986
296
987
297
path_split("", Acc) ->
988
298
    {lists:reverse(Acc), ""};
989
299
path_split("/" ++ Rest, Acc) ->
990
300
    {lists:reverse(Acc), Rest};
991
301
path_split([C | Rest], Acc) ->
992
302
    path_split(Rest, [C | Acc]).
993
303
994
304
995
305
%% @spec urlunsplit({Scheme, Netloc, Path, Query, Fragment}) -> string()
996
306
%% @doc Assemble a URL from the 5-tuple. Path must be absolute.
997
307
urlunsplit({Scheme, Netloc, Path, Query, Fragment}) ->
998
308
    lists:flatten([case Scheme of "" -> "";  _ -> [Scheme, "://"] end,
999
309
                   Netloc,
1000
310
                   urlunsplit_path({Path, Query, Fragment})]).
1001
311
1002
312
%% @spec urlunsplit_path({Path, Query, Fragment}) -> string()
1003
313
%% @doc Assemble a URL path from the 3-tuple.
1004
314
urlunsplit_path({Path, Query, Fragment}) ->
1005
315
    lists:flatten([Path,
1006
316
                   case Query of "" -> ""; _ -> [$? | Query] end,
1007
317
                   case Fragment of "" -> ""; _ -> [$# | Fragment] end]).
1008
318
1009
319
%% @spec urlsplit_path(Url) -> {Path, Query, Fragment}
1010
320
%% @doc Return a 3-tuple, does not expand % escapes. Only supports HTTP style
1011
321
%%      paths.
1012
322
urlsplit_path(Path) ->
1013
323
    urlsplit_path(Path, []).
1014
324
1015
325
urlsplit_path("", Acc) ->
1016
326
    {lists:reverse(Acc), "", ""};
1017
327
urlsplit_path("?" ++ Rest, Acc) ->
1018
328
    {Query, Fragment} = urlsplit_query(Rest),
1019
329
    {lists:reverse(Acc), Query, Fragment};
1020
330
urlsplit_path("#" ++ Rest, Acc) ->
1021
331
    {lists:reverse(Acc), "", Rest};
1022
332
urlsplit_path([C | Rest], Acc) ->
1023
333
    urlsplit_path(Rest, [C | Acc]).
1024
334
1025
335
urlsplit_query(Query) ->
1026
336
    urlsplit_query(Query, []).
1027
337
1028
338
urlsplit_query("", Acc) ->
1029
339
    {lists:reverse(Acc), ""};
1030
340
urlsplit_query("#" ++ Rest, Acc) ->
1031
341
    {lists:reverse(Acc), Rest};
1032
342
urlsplit_query([C | Rest], Acc) ->
1033
343
    urlsplit_query(Rest, [C | Acc]).
1034
344
1035
345
%% @spec guess_mime(string()) -> string()
1036
346
%% @doc  Guess the mime type of a file by the extension of its filename.
1037
347
guess_mime(File) ->
1038
348
    case mochiweb_mime:from_extension(filename:extension(File)) of
1039
349
        undefined ->
1040
350
            "text/plain";
1041
351
        Mime ->
1042
352
            Mime
1043
353
    end.
1044
354
1045
355
%% @spec parse_header(string()) -> {Type, [{K, V}]}
1046
356
%% @doc  Parse a Content-Type like header, return the main Content-Type
1047
357
%%       and a property list of options.
1048
358
parse_header(String) ->
1049
359
    %% TODO: This is exactly as broken as Python's cgi module.
1050
360
    %%       Should parse properly like mochiweb_cookies.
1051
361
    [Type | Parts] = [string:strip(S) || S <- string:tokens(String, ";")],
1052
362
    F = fun (S, Acc) ->
1053
363
                case lists:splitwith(fun (C) -> C =/= $= end, S) of
1054
364
                    {"", _} ->
1055
365
                        %% Skip anything with no name
1056
366
                        Acc;
1057
367
                    {_, ""} ->
1058
368
                        %% Skip anything with no value
1059
369
                        Acc;
1060
370
                    {Name, [$\= | Value]} ->
1061
371
                        [{string:to_lower(string:strip(Name)),
1062
372
                          unquote_header(string:strip(Value))} | Acc]
1063
373
                end
1064
374
        end,
1065
375
    {string:to_lower(Type),
1066
376
     lists:foldr(F, [], Parts)}.
1067
377
1068
378
unquote_header("\"" ++ Rest) ->
1069
379
    unquote_header(Rest, []);
1070
380
unquote_header(S) ->
1071
381
    S.
1072
382
1073
383
unquote_header("", Acc) ->
1074
384
    lists:reverse(Acc);
1075
385
unquote_header("\"", Acc) ->
1076
386
    lists:reverse(Acc);
1077
387
unquote_header([$\\, C | Rest], Acc) ->
1078
388
    unquote_header(Rest, [C | Acc]);
1079
389
unquote_header([C | Rest], Acc) ->
1080
390
    unquote_header(Rest, [C | Acc]).
1081
391
1082
392
%% @spec record_to_proplist(Record, Fields) -> proplist()
1083
393
%% @doc calls record_to_proplist/3 with a default TypeKey of '__record'
1084
394
record_to_proplist(Record, Fields) ->
1085
395
    record_to_proplist(Record, Fields, '__record').
1086
396
1087
397
%% @spec record_to_proplist(Record, Fields, TypeKey) -> proplist()
1088
398
%% @doc Return a proplist of the given Record with each field in the
1089
399
%%      Fields list set as a key with the corresponding value in the Record.
1090
400
%%      TypeKey is the key that is used to store the record type
1091
401
%%      Fields should be obtained by calling record_info(fields, record_type)
1092
402
%%      where record_type is the record type of Record
1093
403
record_to_proplist(Record, Fields, TypeKey)
1094
404
  when tuple_size(Record) - 1 =:= length(Fields) ->
1095
405
    lists:zip([TypeKey | Fields], tuple_to_list(Record)).
1096
406
1097
407
1098
408
shell_quote([], Acc) ->
1099
409
    lists:reverse([$\" | Acc]);
1100
410
shell_quote([C | Rest], Acc) when C =:= $\" orelse C =:= $\` orelse
1101
411
                                  C =:= $\\ orelse C =:= $\$ ->
1102
412
    shell_quote(Rest, [C, $\\ | Acc]);
1103
413
shell_quote([C | Rest], Acc) ->
1104
414
    shell_quote(Rest, [C | Acc]).
1105
415
1106
416
%% @spec parse_qvalues(string()) -> [qvalue()] | invalid_qvalue_string
1107
417
%% @type qvalue() = {media_type() | encoding() , float()}.
1108
418
%% @type media_type() = string().
1109
419
%% @type encoding() = string().
1110
420
%%
1111
421
%% @doc Parses a list (given as a string) of elements with Q values associated
1112
422
%%      to them. Elements are separated by commas and each element is separated
1113
423
%%      from its Q value by a semicolon. Q values are optional but when missing
1114
424
%%      the value of an element is considered as 1.0. A Q value is always in the
1115
425
%%      range [0.0, 1.0]. A Q value list is used for example as the value of the
1116
426
%%      HTTP "Accept" and "Accept-Encoding" headers.
1117
427
%%
1118
428
%%      Q values are described in section 2.9 of the RFC 2616 (HTTP 1.1).
1119
429
%%
1120
430
%%      Example:
1121
431
%%
1122
432
%%      parse_qvalues("gzip; q=0.5, deflate, identity;q=0.0") ->
1123
433
%%          [{"gzip", 0.5}, {"deflate", 1.0}, {"identity", 0.0}]
1124
434
%%
1125
435
parse_qvalues(QValuesStr) ->
1126
436
    try
1127
437
        lists:map(
1128
438
            fun(Pair) ->
1129
439
                [Type | Params] = string:tokens(Pair, ";"),
1130
440
                NormParams = normalize_media_params(Params),
1131
441
                {Q, NonQParams} = extract_q(NormParams),
1132
442
                {string:join([string:strip(Type) | NonQParams], ";"), Q}
1133
443
            end,
1134
444
            string:tokens(string:to_lower(QValuesStr), ",")
1135
445
        )
1136
446
    catch
1137
447
        _Type:_Error ->
1138
448
            invalid_qvalue_string
1139
449
    end.
1140
450
1141
451
normalize_media_params(Params) ->
1142
452
    {ok, Re} = re:compile("\\s"),
1143
453
    normalize_media_params(Re, Params, []).
1144
454
1145
455
normalize_media_params(_Re, [], Acc) ->
1146
456
    lists:reverse(Acc);
1147
457
normalize_media_params(Re, [Param | Rest], Acc) ->
1148
458
    NormParam = re:replace(Param, Re, "", [global, {return, list}]),
1149
459
    normalize_media_params(Re, Rest, [NormParam | Acc]).
1150
460
1151
461
extract_q(NormParams) ->
1152
462
    {ok, KVRe} = re:compile("^([^=]+)=([^=]+)$"),
1153
463
    {ok, QRe} = re:compile("^((?:0|1)(?:\\.\\d{1,3})?)$"),
1154
464
    extract_q(KVRe, QRe, NormParams, []).
1155
465
1156
466
extract_q(_KVRe, _QRe, [], Acc) ->
1157
467
    {1.0, lists:reverse(Acc)};
1158
468
extract_q(KVRe, QRe, [Param | Rest], Acc) ->
1159
469
    case re:run(Param, KVRe, [{capture, [1, 2], list}]) of
1160
470
        {match, [Name, Value]} ->
1161
471
            case Name of
1162
472
            "q" ->
1163
473
                {match, [Q]} = re:run(Value, QRe, [{capture, [1], list}]),
1164
474
                QVal = case Q of
1165
475
                    "0" ->
1166
476
                        0.0;
1167
477
                    "1" ->
1168
478
                        1.0;
1169
479
                    Else ->
1170
480
                        list_to_float(Else)
1171
481
                end,
1172
482
                case QVal < 0.0 orelse QVal > 1.0 of
1173
483
                false ->
1174
484
                    {QVal, lists:reverse(Acc) ++ Rest}
1175
485
                end;
1176
486
            _ ->
1177
487
                extract_q(KVRe, QRe, Rest, [Param | Acc])
1178
488
            end
1179
489
    end.
1180
490
1181
491
%% @spec pick_accepted_encodings([qvalue()], [encoding()], encoding()) ->
1182
492
%%    [encoding()]
1183
493
%%
1184
494
%% @doc Determines which encodings specified in the given Q values list are
1185
495
%%      valid according to a list of supported encodings and a default encoding.
1186
496
%%
1187
497
%%      The returned list of encodings is sorted, descendingly, according to the
1188
498
%%      Q values of the given list. The last element of this list is the given
1189
499
%%      default encoding unless this encoding is explicitily or implicitily
1190
500
%%      marked with a Q value of 0.0 in the given Q values list.
1191
501
%%      Note: encodings with the same Q value are kept in the same order as
1192
502
%%            found in the input Q values list.
1193
503
%%
1194
504
%%      This encoding picking process is described in section 14.3 of the
1195
505
%%      RFC 2616 (HTTP 1.1).
1196
506
%%
1197
507
%%      Example:
1198
508
%%
1199
509
%%      pick_accepted_encodings(
1200
510
%%          [{"gzip", 0.5}, {"deflate", 1.0}],
1201
511
%%          ["gzip", "identity"],
1202
512
%%          "identity"
1203
513
%%      ) ->
1204
514
%%          ["gzip", "identity"]
1205
515
%%
1206
516
pick_accepted_encodings(AcceptedEncs, SupportedEncs, DefaultEnc) ->
1207
517
    SortedQList = lists:reverse(
1208
518
        lists:sort(fun({_, Q1}, {_, Q2}) -> Q1 < Q2 end, AcceptedEncs)
1209
519
    ),
1210
520
    {Accepted, Refused} = lists:foldr(
1211
521
        fun({E, Q}, {A, R}) ->
1212
522
            case Q > 0.0 of
1213
523
                true ->
1214
524
                    {[E | A], R};
1215
525
                false ->
1216
526
                    {A, [E | R]}
1217
527
            end
1218
528
        end,
1219
529
        {[], []},
1220
530
        SortedQList
1221
531
    ),
1222
532
    Refused1 = lists:foldr(
1223
533
        fun(Enc, Acc) ->
1224
534
            case Enc of
1225
535
                "*" ->
1226
536
                    lists:subtract(SupportedEncs, Accepted) ++ Acc;
1227
537
                _ ->
1228
538
                    [Enc | Acc]
1229
539
            end
1230
540
        end,
1231
541
        [],
1232
542
        Refused
1233
543
    ),
1234
544
    Accepted1 = lists:foldr(
1235
545
        fun(Enc, Acc) ->
1236
546
            case Enc of
1237
547
                "*" ->
1238
548
                    lists:subtract(SupportedEncs, Accepted ++ Refused1) ++ Acc;
1239
549
                _ ->
1240
550
                    [Enc | Acc]
1241
551
            end
1242
552
        end,
1243
553
        [],
1244
554
        Accepted
1245
555
    ),
1246
556
    Accepted2 = case lists:member(DefaultEnc, Accepted1) of
1247
557
        true ->
1248
558
            Accepted1;
1249
559
        false ->
1250
560
            Accepted1 ++ [DefaultEnc]
1251
561
    end,
1252
562
    [E || E <- Accepted2, lists:member(E, SupportedEncs),
1253
563
        not lists:member(E, Refused1)].
1254
564
1255
565
make_io(Atom) when is_atom(Atom) ->
1256
566
    atom_to_list(Atom);
1257
567
make_io(Integer) when is_integer(Integer) ->
1258
568
    integer_to_list(Integer);
1259
569
make_io(Io) when is_list(Io); is_binary(Io) ->
1260
570
    Io.
1261
571
1262
572
%%
1263
573
%% Tests
1264
574
%%
1265
575
-include_lib("eunit/include/eunit.hrl").
1266
576
-ifdef(TEST).
1267
577
1268
578
make_io_test() ->
1269
579
    ?assertEqual(
1270
580
       <<"atom">>,
1271
581
       iolist_to_binary(make_io(atom))),
1272
582
    ?assertEqual(
1273
583
       <<"20">>,
1274
584
       iolist_to_binary(make_io(20))),
1275
585
    ?assertEqual(
1276
586
       <<"list">>,
1277
587
       iolist_to_binary(make_io("list"))),
1278
588
    ?assertEqual(
1279
589
       <<"binary">>,
1280
590
       iolist_to_binary(make_io(<<"binary">>))),
1281
591
    ok.
1282
592
1283
593
-record(test_record, {field1=f1, field2=f2}).
1284
594
record_to_proplist_test() ->
1285
595
    ?assertEqual(
1286
596
       [{'__record', test_record},
1287
597
        {field1, f1},
1288
598
        {field2, f2}],
1289
599
       record_to_proplist(#test_record{}, record_info(fields, test_record))),
1290
600
    ?assertEqual(
1291
601
       [{'typekey', test_record},
1292
602
        {field1, f1},
1293
603
        {field2, f2}],
1294
604
       record_to_proplist(#test_record{},
1295
605
                          record_info(fields, test_record),
1296
606
                          typekey)),
1297
607
    ok.
1298
608
1299
609
shell_quote_test() ->
1300
610
    ?assertEqual(
1301
611
       "\"foo \\$bar\\\"\\`' baz\"",
1302
612
       shell_quote("foo $bar\"`' baz")),
1303
613
    ok.
1304
614
1305
615
cmd_port_test_spool(Port, Acc) ->
1306
616
    receive
1307
617
        {Port, eof} ->
1308
618
            Acc;
1309
619
        {Port, {data, {eol, Data}}} ->
1310
620
            cmd_port_test_spool(Port, ["\n", Data | Acc]);
1311
621
        {Port, Unknown} ->
1312
622
            throw({unknown, Unknown})
1313
623
    after 1000 ->
1314
624
            throw(timeout)
1315
625
    end.
1316
626
1317
627
cmd_port_test() ->
1318
628
    Port = cmd_port(["echo", "$bling$ `word`!"],
1319
629
                    [eof, stream, {line, 4096}]),
1320
630
    Res = try lists:append(lists:reverse(cmd_port_test_spool(Port, [])))
1321
631
          after catch port_close(Port)
1322
632
          end,
1323
633
    self() ! {Port, wtf},
1324
634
    try cmd_port_test_spool(Port, [])
1325
635
    catch throw:{unknown, wtf} -> ok
1326
636
    end,
1327
637
    try cmd_port_test_spool(Port, [])
1328
638
    catch throw:timeout -> ok
1329
639
    end,
1330
640
    ?assertEqual(
1331
641
       "$bling$ `word`!\n",
1332
642
       Res).
1333
643
1334
644
cmd_test() ->
1335
645
    ?assertEqual(
1336
646
       "$bling$ `word`!\n",
1337
647
       cmd(["echo", "$bling$ `word`!"])),
1338
648
    ok.
1339
649
1340
650
cmd_string_test() ->
1341
651
    ?assertEqual(
1342
652
       "\"echo\" \"\\$bling\\$ \\`word\\`!\"",
1343
653
       cmd_string(["echo", "$bling$ `word`!"])),
1344
654
    ok.
1345
655
1346
656
cmd_status_test() ->
1347
657
    ?assertEqual(
1348
658
       {0, <<"$bling$ `word`!\n">>},
1349
659
       cmd_status(["echo", "$bling$ `word`!"])),
1350
660
    ok.
1351
661
1352
662
1353
663
parse_header_test() ->
1354
664
    ?assertEqual(
1355
665
       {"multipart/form-data", [{"boundary", "AaB03x"}]},
1356
666
       parse_header("multipart/form-data; boundary=AaB03x")),
1357
667
    %% This tests (currently) intentionally broken behavior
1358
668
    ?assertEqual(
1359
669
       {"multipart/form-data",
1360
670
        [{"b", ""},
1361
671
         {"cgi", "is"},
1362
672
         {"broken", "true\"e"}]},
1363
673
       parse_header("multipart/form-data;b=;cgi=\"i\\s;broken=true\"e;=z;z")),
1364
674
    ok.
1365
675
1366
676
guess_mime_test() ->
1367
677
    "text/plain" = guess_mime(""),
1368
678
    "text/plain" = guess_mime(".text"),
1369
679
    "application/zip" = guess_mime(".zip"),
1370
680
    "application/zip" = guess_mime("x.zip"),
1371
681
    "text/html" = guess_mime("x.html"),
1372
682
    "application/xhtml+xml" = guess_mime("x.xhtml"),
1373
683
    ok.
1374
684
1375
685
path_split_test() ->
1376
686
    {"", "foo/bar"} = path_split("/foo/bar"),
1377
687
    {"foo", "bar"} = path_split("foo/bar"),
1378
688
    {"bar", ""} = path_split("bar"),
1379
689
    ok.
1380
690
1381
691
urlsplit_test() ->
1382
692
    {"", "", "/foo", "", "bar?baz"} = urlsplit("/foo#bar?baz"),
1383
693
    {"http", "host:port", "/foo", "", "bar?baz"} =
1384
694
        urlsplit("http://host:port/foo#bar?baz"),
1385
695
    {"http", "host", "", "", ""} = urlsplit("http://host"),
1386
696
    {"", "", "/wiki/Category:Fruit", "", ""} =
1387
697
        urlsplit("/wiki/Category:Fruit"),
1388
698
    ok.
1389
699
1390
700
urlsplit_path_test() ->
1391
701
    {"/foo/bar", "", ""} = urlsplit_path("/foo/bar"),
1392
702
    {"/foo", "baz", ""} = urlsplit_path("/foo?baz"),
1393
703
    {"/foo", "", "bar?baz"} = urlsplit_path("/foo#bar?baz"),
1394
704
    {"/foo", "", "bar?baz#wibble"} = urlsplit_path("/foo#bar?baz#wibble"),
1395
705
    {"/foo", "bar", "baz"} = urlsplit_path("/foo?bar#baz"),
1396
706
    {"/foo", "bar?baz", "baz"} = urlsplit_path("/foo?bar?baz#baz"),
1397
707
    ok.
1398
708
1399
709
urlunsplit_test() ->
1400
710
    "/foo#bar?baz" = urlunsplit({"", "", "/foo", "", "bar?baz"}),
1401
711
    "http://host:port/foo#bar?baz" =
1402
712
        urlunsplit({"http", "host:port", "/foo", "", "bar?baz"}),
1403
713
    ok.
1404
714
1405
715
urlunsplit_path_test() ->
1406
716
    "/foo/bar" = urlunsplit_path({"/foo/bar", "", ""}),
1407
717
    "/foo?baz" = urlunsplit_path({"/foo", "baz", ""}),
1408
718
    "/foo#bar?baz" = urlunsplit_path({"/foo", "", "bar?baz"}),
1409
719
    "/foo#bar?baz#wibble" = urlunsplit_path({"/foo", "", "bar?baz#wibble"}),
1410
720
    "/foo?bar#baz" = urlunsplit_path({"/foo", "bar", "baz"}),
1411
721
    "/foo?bar?baz#baz" = urlunsplit_path({"/foo", "bar?baz", "baz"}),
1412
722
    ok.
1413
723
1414
724
join_test() ->
1415
725
    ?assertEqual("foo,bar,baz",
1416
726
                  join(["foo", "bar", "baz"], $,)),
1417
727
    ?assertEqual("foo,bar,baz",
1418
728
                  join(["foo", "bar", "baz"], ",")),
1419
729
    ?assertEqual("foo bar",
1420
730
                  join([["foo", " bar"]], ",")),
1421
731
    ?assertEqual("foo bar,baz",
1422
732
                  join([["foo", " bar"], "baz"], ",")),
1423
733
    ?assertEqual("foo",
1424
734
                  join(["foo"], ",")),
1425
735
    ?assertEqual("foobarbaz",
1426
736
                  join(["foo", "bar", "baz"], "")),
1427
737
    ?assertEqual("foo" ++ [<<>>] ++ "bar" ++ [<<>>] ++ "baz",
1428
738
                 join(["foo", "bar", "baz"], <<>>)),
1429
739
    ?assertEqual("foobar" ++ [<<"baz">>],
1430
740
                 join(["foo", "bar", <<"baz">>], "")),
1431
741
    ?assertEqual("",
1432
742
                 join([], "any")),
1433
743
    ok.
1434
744
1435
745
quote_plus_test() ->
1436
746
    "foo" = quote_plus(foo),
1437
747
    "1" = quote_plus(1),
1438
748
    "1.1" = quote_plus(1.1),
1439
749
    "foo" = quote_plus("foo"),
1440
750
    "foo+bar" = quote_plus("foo bar"),
1441
751
    "foo%0A" = quote_plus("foo\n"),
1442
752
    "foo%0A" = quote_plus("foo\n"),
1443
753
    "foo%3B%26%3D" = quote_plus("foo;&="),
1444
754
    "foo%3B%26%3D" = quote_plus(<<"foo;&=">>),
1445
755
    ok.
1446
756
1447
757
unquote_test() ->
1448
758
    ?assertEqual("foo bar",
1449
759
                 unquote("foo+bar")),
1450
760
    ?assertEqual("foo bar",
1451
761
                 unquote("foo%20bar")),
1452
762
    ?assertEqual("foo\r\n",
1453
763
                 unquote("foo%0D%0A")),
1454
764
    ?assertEqual("foo\r\n",
1455
765
                 unquote(<<"foo%0D%0A">>)),
1456
766
    ok.
1457
767
1458
768
urlencode_test() ->
1459
769
    "foo=bar&baz=wibble+%0D%0A&z=1" = urlencode([{foo, "bar"},
1460
770
                                                 {"baz", "wibble \r\n"},
1461
771
                                                 {z, 1}]),
1462
772
    ok.
1463
773
1464
774
parse_qs_test() ->
1465
775
    ?assertEqual(
1466
776
       [{"foo", "bar"}, {"baz", "wibble \r\n"}, {"z", "1"}],
1467
777
       parse_qs("foo=bar&baz=wibble+%0D%0a&z=1")),
1468
778
    ?assertEqual(
1469
779
       [{"", "bar"}, {"baz", "wibble \r\n"}, {"z", ""}],
1470
780
       parse_qs("=bar&baz=wibble+%0D%0a&z=")),
1471
781
    ?assertEqual(
1472
782
       [{"foo", "bar"}, {"baz", "wibble \r\n"}, {"z", "1"}],
1473
783
       parse_qs(<<"foo=bar&baz=wibble+%0D%0a&z=1">>)),
1474
784
    ?assertEqual(
1475
785
       [],
1476
786
       parse_qs("")),
1477
787
    ?assertEqual(
1478
788
       [{"foo", ""}, {"bar", ""}, {"baz", ""}],
1479
789
       parse_qs("foo;bar&baz")),
1480
790
    ok.
1481
791
1482
792
partition_test() ->
1483
793
    {"foo", "", ""} = partition("foo", "/"),
1484
794
    {"foo", "/", "bar"} = partition("foo/bar", "/"),
1485
795
    {"foo", "/", ""} = partition("foo/", "/"),
1486
796
    {"", "/", "bar"} = partition("/bar", "/"),
1487
797
    {"f", "oo/ba", "r"} = partition("foo/bar", "oo/ba"),
1488
798
    ok.
1489
799
1490
800
safe_relative_path_test() ->
1491
801
    "foo" = safe_relative_path("foo"),
1492
802
    "foo/" = safe_relative_path("foo/"),
1493
803
    "foo" = safe_relative_path("foo/bar/.."),
1494
804
    "bar" = safe_relative_path("foo/../bar"),
1495
805
    "bar/" = safe_relative_path("foo/../bar/"),
1496
806
    "" = safe_relative_path("foo/.."),
1497
807
    "" = safe_relative_path("foo/../"),
1498
808
    undefined = safe_relative_path("/foo"),
1499
809
    undefined = safe_relative_path("../foo"),
1500
810
    undefined = safe_relative_path("foo/../.."),
1501
811
    undefined = safe_relative_path("foo//"),
1502
812
    ok.
1503
813
1504
814
parse_qvalues_test() ->
1505
815
    [] = parse_qvalues(""),
1506
816
    [{"identity", 0.0}] = parse_qvalues("identity;q=0"),
1507
817
    [{"identity", 0.0}] = parse_qvalues("identity ;q=0"),
1508
818
    [{"identity", 0.0}] = parse_qvalues(" identity; q =0 "),
1509
819
    [{"identity", 0.0}] = parse_qvalues("identity ; q = 0"),
1510
820
    [{"identity", 0.0}] = parse_qvalues("identity ; q= 0.0"),
1511
821
    [{"gzip", 1.0}, {"deflate", 1.0}, {"identity", 0.0}] = parse_qvalues(
1512
822
        "gzip,deflate,identity;q=0.0"
1513
823
    ),
1514
824
    [{"deflate", 1.0}, {"gzip", 1.0}, {"identity", 0.0}] = parse_qvalues(
1515
825
        "deflate,gzip,identity;q=0.0"
1516
826
    ),
1517
827
    [{"gzip", 1.0}, {"deflate", 1.0}, {"gzip", 1.0}, {"identity", 0.0}] =
1518
828
        parse_qvalues("gzip,deflate,gzip,identity;q=0"),
1519
829
    [{"gzip", 1.0}, {"deflate", 1.0}, {"identity", 0.0}] = parse_qvalues(
1520
830
        "gzip, deflate , identity; q=0.0"
1521
831
    ),
1522
832
    [{"gzip", 1.0}, {"deflate", 1.0}, {"identity", 0.0}] = parse_qvalues(
1523
833
        "gzip; q=1, deflate;q=1.0, identity;q=0.0"
1524
834
    ),
1525
835
    [{"gzip", 0.5}, {"deflate", 1.0}, {"identity", 0.0}] = parse_qvalues(
1526
836
        "gzip; q=0.5, deflate;q=1.0, identity;q=0"
1527
837
    ),
1528
838
    [{"gzip", 0.5}, {"deflate", 1.0}, {"identity", 0.0}] = parse_qvalues(
1529
839
        "gzip; q=0.5, deflate , identity;q=0.0"
1530
840
    ),
1531
841
    [{"gzip", 0.5}, {"deflate", 0.8}, {"identity", 0.0}] = parse_qvalues(
1532
842
        "gzip; q=0.5, deflate;q=0.8, identity;q=0.0"
1533
843
    ),
1534
844
    [{"gzip", 0.5}, {"deflate", 1.0}, {"identity", 1.0}] = parse_qvalues(
1535
845
        "gzip; q=0.5,deflate,identity"
1536
846
    ),
1537
847
    [{"gzip", 0.5}, {"deflate", 1.0}, {"identity", 1.0}, {"identity", 1.0}] =
1538
848
        parse_qvalues("gzip; q=0.5,deflate,identity, identity "),
1539
849
    [{"text/html;level=1", 1.0}, {"text/plain", 0.5}] =
1540
850
        parse_qvalues("text/html;level=1, text/plain;q=0.5"),
1541
851
    [{"text/html;level=1", 0.3}, {"text/plain", 1.0}] =
1542
852
        parse_qvalues("text/html;level=1;q=0.3, text/plain"),
1543
853
    [{"text/html;level=1", 0.3}, {"text/plain", 1.0}] =
1544
854
        parse_qvalues("text/html; level = 1; q = 0.3, text/plain"),
1545
855
    [{"text/html;level=1", 0.3}, {"text/plain", 1.0}] =
1546
856
        parse_qvalues("text/html;q=0.3;level=1, text/plain"),
1547
857
    invalid_qvalue_string = parse_qvalues("gzip; q=1.1, deflate"),
1548
858
    invalid_qvalue_string = parse_qvalues("gzip; q=0.5, deflate;q=2"),
1549
859
    invalid_qvalue_string = parse_qvalues("gzip, deflate;q=AB"),
1550
860
    invalid_qvalue_string = parse_qvalues("gzip; q=2.1, deflate"),
1551
861
    invalid_qvalue_string = parse_qvalues("gzip; q=0.1234, deflate"),
1552
862
    invalid_qvalue_string = parse_qvalues("text/html;level=1;q=0.3, text/html;level"),
1553
863
    ok.
1554
864
1555
865
pick_accepted_encodings_test() ->
1556
866
    ["identity"] = pick_accepted_encodings(
1557
867
        [],
1558
868
        ["gzip", "identity"],
1559
869
        "identity"
1560
870
    ),
1561
871
    ["gzip", "identity"] = pick_accepted_encodings(
1562
872
        [{"gzip", 1.0}],
1563
873
        ["gzip", "identity"],
1564
874
        "identity"
1565
875
    ),
1566
876
    ["identity"] = pick_accepted_encodings(
1567
877
        [{"gzip", 0.0}],
1568
878
        ["gzip", "identity"],
1569
879
        "identity"
1570
880
    ),
1571
881
    ["gzip", "identity"] = pick_accepted_encodings(
1572
882
        [{"gzip", 1.0}, {"deflate", 1.0}],
1573
883
        ["gzip", "identity"],
1574
884
        "identity"
1575
885
    ),
1576
886
    ["gzip", "identity"] = pick_accepted_encodings(
1577
887
        [{"gzip", 0.5}, {"deflate", 1.0}],
1578
888
        ["gzip", "identity"],
1579
889
        "identity"
1580
890
    ),
1581
891
    ["identity"] = pick_accepted_encodings(
1582
892
        [{"gzip", 0.0}, {"deflate", 0.0}],
1583
893
        ["gzip", "identity"],
1584
894
        "identity"
1585
895
    ),
1586
896
    ["gzip"] = pick_accepted_encodings(
1587
897
        [{"gzip", 1.0}, {"deflate", 1.0}, {"identity", 0.0}],
1588
898
        ["gzip", "identity"],
1589
899
        "identity"
1590
900
    ),
1591
901
    ["gzip", "deflate", "identity"] = pick_accepted_encodings(
1592
902
        [{"gzip", 1.0}, {"deflate", 1.0}],
1593
903
        ["gzip", "deflate", "identity"],
1594
904
        "identity"
1595
905
    ),
1596
906
    ["gzip", "deflate"] = pick_accepted_encodings(
1597
907
        [{"gzip", 1.0}, {"deflate", 1.0}, {"identity", 0.0}],
1598
908
        ["gzip", "deflate", "identity"],
1599
909
        "identity"
1600
910
    ),
1601
911
    ["deflate", "gzip", "identity"] = pick_accepted_encodings(
1602
912
        [{"gzip", 0.2}, {"deflate", 1.0}],
1603
913
        ["gzip", "deflate", "identity"],
1604
914
        "identity"
1605
915
    ),
1606
916
    ["deflate", "deflate", "gzip", "identity"] = pick_accepted_encodings(
1607
917
        [{"gzip", 0.2}, {"deflate", 1.0}, {"deflate", 1.0}],
1608
918
        ["gzip", "deflate", "identity"],
1609
919
        "identity"
1610
920
    ),
1611
921
    ["deflate", "gzip", "gzip", "identity"] = pick_accepted_encodings(
1612
922
        [{"gzip", 0.2}, {"deflate", 1.0}, {"gzip", 1.0}],
1613
923
        ["gzip", "deflate", "identity"],
1614
924
        "identity"
1615
925
    ),
1616
926
    ["gzip", "deflate", "gzip", "identity"] = pick_accepted_encodings(
1617
927
        [{"gzip", 0.2}, {"deflate", 0.9}, {"gzip", 1.0}],
1618
928
        ["gzip", "deflate", "identity"],
1619
929
        "identity"
1620
930
    ),
1621
931
    [] = pick_accepted_encodings(
1622
932
        [{"*", 0.0}],
1623
933
        ["gzip", "deflate", "identity"],
1624
934
        "identity"
1625
935
    ),
1626
936
    ["gzip", "deflate", "identity"] = pick_accepted_encodings(
1627
937
        [{"*", 1.0}],
1628
938
        ["gzip", "deflate", "identity"],
1629
939
        "identity"
1630
940
    ),
1631
941
    ["gzip", "deflate", "identity"] = pick_accepted_encodings(
1632
942
        [{"*", 0.6}],
1633
943
        ["gzip", "deflate", "identity"],
1634
944
        "identity"
1635
945
    ),
1636
946
    ["gzip"] = pick_accepted_encodings(
1637
947
        [{"gzip", 1.0}, {"*", 0.0}],
1638
948
        ["gzip", "deflate", "identity"],
1639
949
        "identity"
1640
950
    ),
1641
951
    ["gzip", "deflate"] = pick_accepted_encodings(
1642
952
        [{"gzip", 1.0}, {"deflate", 0.6}, {"*", 0.0}],
1643
953
        ["gzip", "deflate", "identity"],
1644
954
        "identity"
1645
955
    ),
1646
956
    ["deflate", "gzip"] = pick_accepted_encodings(
1647
957
        [{"gzip", 0.5}, {"deflate", 1.0}, {"*", 0.0}],
1648
958
        ["gzip", "deflate", "identity"],
1649
959
        "identity"
1650
960
    ),
1651
961
    ["gzip", "identity"] = pick_accepted_encodings(
1652
962
        [{"deflate", 0.0}, {"*", 1.0}],
1653
963
        ["gzip", "deflate", "identity"],
1654
964
        "identity"
1655
965
    ),
1656
966
    ["gzip", "identity"] = pick_accepted_encodings(
1657
967
        [{"*", 1.0}, {"deflate", 0.0}],
1658
968
        ["gzip", "deflate", "identity"],
1659
969
        "identity"
1660
970
    ),
1661
971
    ok.
1662
972
1663
973
-endif.
1664
974
0
1665
=== removed directory '.pc/improve_script_url_validation.patch'
1666
=== removed directory '.pc/improve_script_url_validation.patch/share'
1667
=== removed directory '.pc/improve_script_url_validation.patch/share/www'
1668
=== removed directory '.pc/improve_script_url_validation.patch/share/www/script'
1669
=== removed file '.pc/improve_script_url_validation.patch/share/www/script/couch_test_runner.js'
1670
--- .pc/improve_script_url_validation.patch/share/www/script/couch_test_runner.js	2013-01-18 22:04:32 +0000
1671
+++ .pc/improve_script_url_validation.patch/share/www/script/couch_test_runner.js	1970-01-01 00:00:00 +0000
1672
@@ -1,472 +0,0 @@
1673
1
// Licensed under the Apache License, Version 2.0 (the "License"); you may not
1674
2
// use this file except in compliance with the License. You may obtain a copy of
1675
3
// the License at
1676
4
//
1677
5
//   http://www.apache.org/licenses/LICENSE-2.0
1678
6
//
1679
7
// Unless required by applicable law or agreed to in writing, software
1680
8
// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
1681
9
// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
1682
10
// License for the specific language governing permissions and limitations under
1683
11
// the License.
1684
12
1685
13
// *********************** Test Framework of Sorts ************************* //
1686
14
1687
15
1688
16
function loadScript(url) {
1689
17
  // disallow loading remote URLs
1690
18
  if((url.substr(0, 7) == "http://")
1691
19
    || (url.substr(0, 2) == "//")
1692
20
    || (url.substr(0, 5) == "data:")
1693
21
    || (url.substr(0, 11) == "javascript:")) {
1694
22
        throw "Not loading remote test scripts";
1695
23
  }
1696
24
  if (typeof document != "undefined") document.write('<script src="'+url+'"></script>');
1697
25
};
1698
26
1699
27
function patchTest(fun) {
1700
28
  var source = fun.toString();
1701
29
  var output = "";
1702
30
  var i = 0;
1703
31
  var testMarker = "T(";
1704
32
  while (i < source.length) {
1705
33
    var testStart = source.indexOf(testMarker, i);
1706
34
    if (testStart == -1) {
1707
35
      output = output + source.substring(i, source.length);
1708
36
      break;
1709
37
    }
1710
38
    var testEnd = source.indexOf(");", testStart);
1711
39
    var testCode = source.substring(testStart + testMarker.length, testEnd);
1712
40
    output += source.substring(i, testStart) + "T(" + testCode + "," + JSON.stringify(testCode);
1713
41
    i = testEnd;
1714
42
  }
1715
43
  try {
1716
44
    return eval("(" + output + ")");
1717
45
  } catch (e) {
1718
46
    return null;
1719
47
  }
1720
48
}
1721
49
1722
50
function runAllTests() {
1723
51
  var rows = $("#tests tbody.content tr");
1724
52
  $("td", rows).text("");
1725
53
  $("td.status", rows).removeClass("error").removeClass("failure").removeClass("success").text("not run");
1726
54
  var offset = 0;
1727
55
  function runNext() {
1728
56
    if (offset < rows.length) {
1729
57
      var row = rows.get(offset);
1730
58
      runTest($("th button", row).get(0), function() {
1731
59
        offset += 1;
1732
60
        setTimeout(runNext, 100);
1733
61
      }, false, true);
1734
62
    } else {
1735
63
      saveTestReport();
1736
64
    }
1737
65
  }
1738
66
  runNext();
1739
67
}
1740
68
1741
69
var numFailures = 0;
1742
70
var currentRow = null;
1743
71
1744
72
function runTest(button, callback, debug, noSave) {
1745
73
1746
74
  // offer to save admins
1747
75
  if (currentRow != null) {
1748
76
    alert("Can not run multiple tests simultaneously.");
1749
77
    return;
1750
78
  }
1751
79
  var row = currentRow = $(button).parents("tr").get(0);
1752
80
  $("td.status", row).removeClass("error").removeClass("failure").removeClass("success");
1753
81
  $("td", row).text("");
1754
82
  $("#toolbar li.current").text("Running: "+row.id);
1755
83
  var testFun = couchTests[row.id];
1756
84
  function run() {
1757
85
    numFailures = 0;
1758
86
    var start = new Date().getTime();
1759
87
    try {
1760
88
      if (debug == undefined || !debug) {
1761
89
        testFun = patchTest(testFun) || testFun;
1762
90
      }
1763
91
      testFun(debug);
1764
92
      var status = numFailures > 0 ? "failure" : "success";
1765
93
    } catch (e) {
1766
94
      var status = "error";
1767
95
      if ($("td.details ol", row).length == 0) {
1768
96
        $("<ol></ol>").appendTo($("td.details", row));
1769
97
      }
1770
98
      $("<li><b>Exception raised:</b> <code class='error'></code></li>")
1771
99
        .find("code").text(JSON.stringify(e)).end()
1772
100
        .appendTo($("td.details ol", row));
1773
101
      if (debug) {
1774
102
        currentRow = null;
1775
103
        throw e;
1776
104
      }
1777
105
    }
1778
106
    if ($("td.details ol", row).length) {
1779
107
      $("<a href='#'>Run with debugger</a>").click(function() {
1780
108
        runTest(this, undefined, true);
1781
109
      }).prependTo($("td.details ol", row));
1782
110
    }
1783
111
    var duration = new Date().getTime() - start;
1784
112
    $("td.status", row).removeClass("running").addClass(status).text(status);
1785
113
    $("td.duration", row).text(duration + "ms");
1786
114
    $("#toolbar li.current").text("Finished: "+row.id);
1787
115
    updateTestsFooter();
1788
116
    currentRow = null;
1789
117
    if (callback) callback();
1790
118
    if (!noSave) saveTestReport();
1791
119
  }
1792
120
  $("td.status", row).addClass("running").text("running…");
1793
121
  setTimeout(run, 100);
1794
122
}
1795
123
1796
124
function showSource(cell) {
1797
125
  var name = $(cell).text();
1798
126
  var win = window.open("", name, "width=700,height=500,resizable=yes,scrollbars=yes");
1799
127
  win.document.location = "script/test/" + name + ".js";
1800
128
}
1801
129
1802
130
var readyToRun;
1803
131
function setupAdminParty(fun) {
1804
132
  if (readyToRun) {
1805
133
    fun();
1806
134
  } else {
1807
135
    function removeAdmins(confs, doneFun) {
1808
136
      // iterate through the config and remove current user last
1809
137
      // current user is at front of list
1810
138
      var remove = confs.pop();
1811
139
      if (remove) {
1812
140
        $.couch.config({
1813
141
          success : function() {
1814
142
            removeAdmins(confs, doneFun);
1815
143
          }
1816
144
        }, "admins", remove[0], null);
1817
145
      } else {
1818
146
        doneFun();
1819
147
      }
1820
148
    };
1821
149
    $.couch.session({
1822
150
      success : function(resp) {
1823
151
        var userCtx = resp.userCtx;
1824
152
        if (userCtx.name && userCtx.roles.indexOf("_admin") != -1) {
1825
153
          // admin but not admin party. dialog offering to make admin party
1826
154
          $.showDialog("dialog/_admin_party.html", {
1827
155
            submit: function(data, callback) {
1828
156
              $.couch.config({
1829
157
                success : function(conf) {
1830
158
                  var meAdmin, adminConfs = [];
1831
159
                  for (var name in conf) {
1832
160
                    if (name == userCtx.name) {
1833
161
                      meAdmin = [name, conf[name]];
1834
162
                    } else {
1835
163
                      adminConfs.push([name, conf[name]]);
1836
164
                    }
1837
165
                  }
1838
166
                  adminConfs.unshift(meAdmin);
1839
167
                  removeAdmins(adminConfs, function() {
1840
168
                    callback();
1841
169
                    $.futon.session.sidebar();
1842
170
                    readyToRun = true;
1843
171
                    setTimeout(fun, 500);
1844
172
                  });
1845
173
                }
1846
174
              }, "admins");
1847
175
            }
1848
176
          });
1849
177
        } else if (userCtx.roles.indexOf("_admin") != -1) {
1850
178
          // admin party!
1851
179
          readyToRun = true;
1852
180
          fun();
1853
181
        } else {
1854
182
          // not an admin
1855
183
          alert("Error: You need to be an admin to run the tests.");
1856
184
        };
1857
185
      }
1858
186
    });
1859
187
  }
1860
188
};
1861
189
1862
190
function updateTestsListing() {
1863
191
  for (var name in couchTests) {
1864
192
    var testFunction = couchTests[name];
1865
193
    var row = $("<tr><th></th><td></td><td></td><td></td></tr>")
1866
194
      .find("th").text(name).attr("title", "Show source").click(function() {
1867
195
        showSource(this);
1868
196
      }).end()
1869
197
      .find("td:nth(0)").addClass("status").text("not run").end()
1870
198
      .find("td:nth(1)").addClass("duration").end()
1871
199
      .find("td:nth(2)").addClass("details").end();
1872
200
    $("<button type='button' class='run' title='Run test'></button>").click(function() {
1873
201
      this.blur();
1874
202
      var self = this;
1875
203
      // check for admin party
1876
204
      setupAdminParty(function() {
1877
205
        runTest(self);
1878
206
      });
1879
207
      return false;
1880
208
    }).prependTo(row.find("th"));
1881
209
    row.attr("id", name).appendTo("#tests tbody.content");
1882
210
  }
1883
211
  $("#tests tr").removeClass("odd").filter(":odd").addClass("odd");
1884
212
  updateTestsFooter();
1885
213
}
1886
214
1887
215
function updateTestsFooter() {
1888
216
  var tests = $("#tests tbody.content tr td.status");
1889
217
  var testsRun = tests.filter(".success, .error, .failure");
1890
218
  var testsFailed = testsRun.not(".success");
1891
219
  var totalDuration = 0;
1892
220
  $("#tests tbody.content tr td.duration:contains('ms')").each(function() {
1893
221
    var text = $(this).text();
1894
222
    totalDuration += parseInt(text.substr(0, text.length - 2), 10);
1895
223
  });
1896
224
  $("#tests tbody.footer td").html("<span>"+testsRun.length + " of " + tests.length +
1897
225
    " test(s) run, " + testsFailed.length + " failures (" +
1898
226
    totalDuration + " ms)</span> ");
1899
227
}
1900
228
1901
229
// make report and save to local db
1902
230
// display how many reports need replicating to the mothership
1903
231
// have button to replicate them
1904
232
1905
233
function saveTestReport(report) {
1906
234
  var report = makeTestReport();
1907
235
  if (report) {
1908
236
    var db = $.couch.db("test_suite_reports");
1909
237
    var saveReport = function(db_info) {
1910
238
      report.db = db_info;
1911
239
      $.couch.info({success : function(node_info) {
1912
240
        report.node = node_info;
1913
241
        db.saveDoc(report);
1914
242
      }});
1915
243
    };
1916
244
    var createDb = function() {
1917
245
      db.create({success: function() {
1918
246
        db.info({success:saveReport});
1919
247
      }});
1920
248
    };
1921
249
    db.info({error: createDb, success:saveReport});
1922
250
  }
1923
251
};
1924
252
1925
253
function makeTestReport() {
1926
254
  var report = {};
1927
255
  report.summary = $("#tests tbody.footer td").text();
1928
256
  report.platform = testPlatform();
1929
257
  var date = new Date();
1930
258
  report.timestamp = date.getTime();
1931
259
  report.timezone = date.getTimezoneOffset();
1932
260
  report.tests = [];
1933
261
  $("#tests tbody.content tr").each(function() {
1934
262
    var status = $("td.status", this).text();
1935
263
    if (status != "not run") {
1936
264
      var test = {};
1937
265
      test.name = this.id;
1938
266
      test.status = status;
1939
267
      test.duration = parseInt($("td.duration", this).text());
1940
268
      test.details = [];
1941
269
      $("td.details li", this).each(function() {
1942
270
        test.details.push($(this).text());
1943
271
      });
1944
272
      if (test.details.length == 0) {
1945
273
        delete test.details;
1946
274
      }
1947
275
      report.tests.push(test);
1948
276
    }
1949
277
  });
1950
278
  if (report.tests.length > 0) return report;
1951
279
};
1952
280
1953
281
function testPlatform() {
1954
282
  var b = $.browser;
1955
283
  var bs = ["mozilla", "msie", "opera", "safari"];
1956
284
  for (var i=0; i < bs.length; i++) {
1957
285
    if (b[bs[i]]) {
1958
286
      return {"browser" : bs[i], "version" : b.version};
1959
287
    }
1960
288
  };
1961
289
  return {"browser" : "undetected"};
1962
290
}
1963
291
1964
292
1965
293
function reportTests() {
1966
294
  // replicate the database to couchdb.couchdb.org
1967
295
}
1968
296
1969
297
// Use T to perform a test that returns false on failure and if the test fails,
1970
298
// display the line that failed.
1971
299
// Example:
1972
300
// T(MyValue==1);
1973
301
function T(arg1, arg2, testName) {
1974
302
  if (!arg1) {
1975
303
    if (currentRow) {
1976
304
      if ($("td.details ol", currentRow).length == 0) {
1977
305
        $("<ol></ol>").appendTo($("td.details", currentRow));
1978
306
      }
1979
307
      var message = (arg2 != null ? arg2 : arg1).toString();
1980
308
      $("<li><b>Assertion " + (testName ? "'" + testName + "'" : "") + " failed:</b> <code class='failure'></code></li>")
1981
309
        .find("code").text(message).end()
1982
310
        .appendTo($("td.details ol", currentRow));
1983
311
    }
1984
312
    numFailures += 1;
1985
313
  }
1986
314
}
1987
315
1988
316
function TIsnull(actual, testName) {
1989
317
  T(actual === null, "expected 'null', got '"
1990
318
    + repr(actual) + "'", testName);
1991
319
}
1992
320
1993
321
function TEquals(expected, actual, testName) {
1994
322
  T(equals(expected, actual), "expected '" + repr(expected) +
1995
323
    "', got '" + repr(actual) + "'", testName);
1996
324
}
1997
325
1998
326
function TEqualsIgnoreCase(expected, actual, testName) {
1999
327
  T(equals(expected.toUpperCase(), actual.toUpperCase()), "expected '" + repr(expected) +
2000
328
    "', got '" + repr(actual) + "'", testName);
2001
329
}
2002
330
2003
331
function equals(a,b) {
2004
332
  if (a === b) return true;
2005
333
  try {
2006
334
    return repr(a) === repr(b);
2007
335
  } catch (e) {
2008
336
    return false;
2009
337
  }
2010
338
}
2011
339
2012
340
function repr(val) {
2013
341
  if (val === undefined) {
2014
342
    return null;
2015
343
  } else if (val === null) {
2016
344
    return "null";
2017
345
  } else {
2018
346
    return JSON.stringify(val);
2019
347
  }
2020
348
}
2021
349
2022
350
function makeDocs(start, end, templateDoc) {
2023
351
  var templateDocSrc = templateDoc ? JSON.stringify(templateDoc) : "{}";
2024
352
  if (end === undefined) {
2025
353
    end = start;
2026
354
    start = 0;
2027
355
  }
2028
356
  var docs = [];
2029
357
  for (var i = start; i < end; i++) {
2030
358
    var newDoc = eval("(" + templateDocSrc + ")");
2031
359
    newDoc._id = (i).toString();
2032
360
    newDoc.integer = i;
2033
361
    newDoc.string = (i).toString();
2034
362
    docs.push(newDoc);
2035
363
  }
2036
364
  return docs;
2037
365
}
2038
366
2039
367
function run_on_modified_server(settings, fun) {
2040
368
  try {
2041
369
    // set the settings
2042
370
    for(var i=0; i < settings.length; i++) {
2043
371
      var s = settings[i];
2044
372
      var xhr = CouchDB.request("PUT", "/_config/" + s.section + "/" + s.key, {
2045
373
        body: JSON.stringify(s.value),
2046
374
        headers: {"X-Couch-Persist": "false"}
2047
375
      });
2048
376
      CouchDB.maybeThrowError(xhr);
2049
377
      s.oldValue = xhr.responseText;
2050
378
    }
2051
379
    // run the thing
2052
380
    fun();
2053
381
  } finally {
2054
382
    // unset the settings
2055
383
    for(var j=0; j < i; j++) {
2056
384
      var s = settings[j];
2057
385
      if(s.oldValue == "\"\"\n") { // unset value
2058
386
        CouchDB.request("DELETE", "/_config/" + s.section + "/" + s.key, {
2059
387
          headers: {"X-Couch-Persist": "false"}
2060
388
        });
2061
389
      } else {
2062
390
        CouchDB.request("PUT", "/_config/" + s.section + "/" + s.key, {
2063
391
          body: s.oldValue,
2064
392
          headers: {"X-Couch-Persist": "false"}
2065
393
        });
2066
394
      }
2067
395
    }
2068
396
  }
2069
397
}
2070
398
2071
399
function stringFun(fun) {
2072
400
  var string = fun.toSource ? fun.toSource() : "(" + fun.toString() + ")";
2073
401
  return string;
2074
402
}
2075
403
2076
404
function waitForSuccess(fun, tag) {
2077
405
  var start = new Date();
2078
406
  while(true) {
2079
407
    if (new Date() - start > 5000) {
2080
408
      throw("timeout: "+tag);
2081
409
    } else {
2082
410
      try {
2083
411
        fun();
2084
412
        break;
2085
413
      } catch (e) {}
2086
414
      // sync http req allow async req to happen
2087
415
      CouchDB.request("GET", "/test_suite_db/?tag="+encodeURIComponent(tag));
2088
416
    }
2089
417
  }
2090
418
}
2091
419
2092
420
function waitForRestart() {
2093
421
  var waiting = true;
2094
422
  // Wait for the server to go down but don't
2095
423
  // wait too long because we might miss the
2096
424
  // the unavailable period.
2097
425
  var count = 25;
2098
426
  while (waiting && count > 0) {
2099
427
    count--;
2100
428
    try {
2101
429
      CouchDB.request("GET", "/");
2102
430
    } catch(e) {
2103
431
      waiting = false;
2104
432
    }
2105
433
  }
2106
434
  // Wait for it to come back up
2107
435
  waiting = true;
2108
436
  while (waiting) {
2109
437
    try {
2110
438
      CouchDB.request("GET", "/");
2111
439
      waiting = false;
2112
440
    } catch(e) {
2113
441
      // the request will fail until restart completes
2114
442
    }
2115
443
  }
2116
444
};
2117
445
2118
446
function restartServer() {
2119
447
  var xhr;
2120
448
  try {
2121
449
    CouchDB.request("POST", "/_restart");
2122
450
  } catch(e) {
2123
451
    // this request may sometimes fail
2124
452
  }
2125
453
  waitForRestart();
2126
454
}
2127
455
2128
456
// legacy functions for CouchDB < 1.2.0
2129
457
// we keep them to make sure we keep BC
2130
458
CouchDB.user_prefix = "org.couchdb.user:";
2131
459
2132
460
CouchDB.prepareUserDoc = function(user_doc, new_password) {
2133
461
  user_doc._id = user_doc._id || CouchDB.user_prefix + user_doc.name;
2134
462
  if (new_password) {
2135
463
    // handle the password crypto
2136
464
    user_doc.salt = CouchDB.newUuids(1)[0];
2137
465
    user_doc.password_sha = hex_sha1(new_password + user_doc.salt);
2138
466
  }
2139
467
  user_doc.type = "user";
2140
468
  if (!user_doc.roles) {
2141
469
    user_doc.roles = [];
2142
470
  }
2143
471
  return user_doc;
2144
472
};
2145
473
0
2146
=== removed directory '.pc/include_a_comment_before_jsonp_output.patch'
2147
=== removed directory '.pc/include_a_comment_before_jsonp_output.patch/src'
2148
=== removed directory '.pc/include_a_comment_before_jsonp_output.patch/src/couchdb'
2149
=== removed file '.pc/include_a_comment_before_jsonp_output.patch/src/couchdb/couch_httpd.erl'
2150
--- .pc/include_a_comment_before_jsonp_output.patch/src/couchdb/couch_httpd.erl	2013-01-18 22:04:32 +0000
2151
+++ .pc/include_a_comment_before_jsonp_output.patch/src/couchdb/couch_httpd.erl	1970-01-01 00:00:00 +0000
2152
@@ -1,1081 +0,0 @@
2153
1
% Licensed under the Apache License, Version 2.0 (the "License"); you may not
2154
2
% use this file except in compliance with the License. You may obtain a copy of
2155
3
% the License at
2156
4
%
2157
5
%   http://www.apache.org/licenses/LICENSE-2.0
2158
6
%
2159
7
% Unless required by applicable law or agreed to in writing, software
2160
8
% distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
2161
9
% WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
2162
10
% License for the specific language governing permissions and limitations under
2163
11
% the License.
2164
12
2165
13
-module(couch_httpd).
2166
14
-include("couch_db.hrl").
2167
15
2168
16
-export([start_link/0, start_link/1, stop/0, config_change/2, 
2169
17
        handle_request/5]).
2170
18
2171
19
-export([header_value/2,header_value/3,qs_value/2,qs_value/3,qs/1,qs_json_value/3]).
2172
20
-export([path/1,absolute_uri/2,body_length/1]).
2173
21
-export([verify_is_server_admin/1,unquote/1,quote/1,recv/2,recv_chunked/4,error_info/1]).
2174
22
-export([make_fun_spec_strs/1]).
2175
23
-export([make_arity_1_fun/1, make_arity_2_fun/1, make_arity_3_fun/1]).
2176
24
-export([parse_form/1,json_body/1,json_body_obj/1,body/1,doc_etag/1, make_etag/1, etag_respond/3]).
2177
25
-export([primary_header_value/2,partition/1,serve_file/3,serve_file/4, server_header/0]).
2178
26
-export([start_chunked_response/3,send_chunk/2,log_request/2]).
2179
27
-export([start_response_length/4, start_response/3, send/2]).
2180
28
-export([start_json_response/2, start_json_response/3, end_json_response/1]).
2181
29
-export([send_response/4,send_method_not_allowed/2,send_error/4, send_redirect/2,send_chunked_error/2]).
2182
30
-export([send_json/2,send_json/3,send_json/4,last_chunk/1,parse_multipart_request/3]).
2183
31
-export([accepted_encodings/1,handle_request_int/5,validate_referer/1,validate_ctype/2]).
2184
32
2185
33
start_link() ->
2186
34
    start_link(http).
2187
35
start_link(http) ->
2188
36
    Port = couch_config:get("httpd", "port", "5984"),
2189
37
    start_link(?MODULE, [{port, Port}]);
2190
38
start_link(https) ->
2191
39
    Port = couch_config:get("ssl", "port", "6984"),
2192
40
    CertFile = couch_config:get("ssl", "cert_file", nil),
2193
41
    KeyFile = couch_config:get("ssl", "key_file", nil),
2194
42
    Options = case CertFile /= nil andalso KeyFile /= nil of
2195
43
        true ->
2196
44
            SslOpts = [{certfile, CertFile}, {keyfile, KeyFile}],
2197
45
2198
46
            %% set password if one is needed for the cert
2199
47
            SslOpts1 = case couch_config:get("ssl", "password", nil) of
2200
48
                nil -> SslOpts;
2201
49
                Password ->
2202
50
                    SslOpts ++ [{password, Password}]
2203
51
            end,
2204
52
            % do we verify certificates ?
2205
53
            FinalSslOpts = case couch_config:get("ssl",
2206
54
                    "verify_ssl_certificates", "false") of
2207
55
                "false" -> SslOpts1;
2208
56
                "true" ->
2209
57
                    case couch_config:get("ssl",
2210
58
                            "cacert_file", nil) of
2211
59
                        nil ->
2212
60
                            io:format("Verify SSL certificate "
2213
61
                                ++"enabled but file containing "
2214
62
                                ++"PEM encoded CA certificates is "
2215
63
                                ++"missing", []),
2216
64
                            throw({error, missing_cacerts});
2217
65
                        CaCertFile ->
2218
66
                            Depth = list_to_integer(couch_config:get("ssl",
2219
67
                                    "ssl_certificate_max_depth",
2220
68
                                    "1")),
2221
69
                            FinalOpts = [
2222
70
                                {cacertfile, CaCertFile},
2223
71
                                {depth, Depth},
2224
72
                                {verify, verify_peer}],
2225
73
                            % allows custom verify fun.
2226
74
                            case couch_config:get("ssl",
2227
75
                                    "verify_fun", nil) of
2228
76
                                nil -> FinalOpts;
2229
77
                                SpecStr ->
2230
78
                                    FinalOpts 
2231
79
                                    ++ [{verify_fun, make_arity_3_fun(SpecStr)}]
2232
80
                            end
2233
81
                    end
2234
82
            end,
2235
83
            
2236
84
            [{port, Port},
2237
85
                {ssl, true},
2238
86
                {ssl_opts, FinalSslOpts}];
2239
87
        false ->
2240
88
            io:format("SSL enabled but PEM certificates are missing.", []),
2241
89
            throw({error, missing_certs})
2242
90
    end,
2243
91
    start_link(https, Options).
2244
92
start_link(Name, Options) ->
2245
93
    % read config and register for configuration changes
2246
94
2247
95
    % just stop if one of the config settings change. couch_server_sup
2248
96
    % will restart us and then we will pick up the new settings.
2249
97
2250
98
    BindAddress = couch_config:get("httpd", "bind_address", any),
2251
99
    DefaultSpec = "{couch_httpd_db, handle_request}",
2252
100
    DefaultFun = make_arity_1_fun(
2253
101
        couch_config:get("httpd", "default_handler", DefaultSpec)
2254
102
    ),
2255
103
2256
104
    UrlHandlersList = lists:map(
2257
105
        fun({UrlKey, SpecStr}) ->
2258
106
            {?l2b(UrlKey), make_arity_1_fun(SpecStr)}
2259
107
        end, couch_config:get("httpd_global_handlers")),
2260
108
2261
109
    DbUrlHandlersList = lists:map(
2262
110
        fun({UrlKey, SpecStr}) ->
2263
111
            {?l2b(UrlKey), make_arity_2_fun(SpecStr)}
2264
112
        end, couch_config:get("httpd_db_handlers")),
2265
113
2266
114
    DesignUrlHandlersList = lists:map(
2267
115
        fun({UrlKey, SpecStr}) ->
2268
116
            {?l2b(UrlKey), make_arity_3_fun(SpecStr)}
2269
117
        end, couch_config:get("httpd_design_handlers")),
2270
118
2271
119
    UrlHandlers = dict:from_list(UrlHandlersList),
2272
120
    DbUrlHandlers = dict:from_list(DbUrlHandlersList),
2273
121
    DesignUrlHandlers = dict:from_list(DesignUrlHandlersList),
2274
122
    {ok, ServerOptions} = couch_util:parse_term(
2275
123
        couch_config:get("httpd", "server_options", "[]")),
2276
124
    {ok, SocketOptions} = couch_util:parse_term(
2277
125
        couch_config:get("httpd", "socket_options", "[]")),
2278
126
2279
127
    set_auth_handlers(),
2280
128
2281
129
    Loop = fun(Req)->
2282
130
        case SocketOptions of
2283
131
        [] ->
2284
132
            ok;
2285
133
        _ ->
2286
134
            ok = mochiweb_socket:setopts(Req:get(socket), SocketOptions)
2287
135
        end,
2288
136
        apply(?MODULE, handle_request, [
2289
137
            Req, DefaultFun, UrlHandlers, DbUrlHandlers, DesignUrlHandlers
2290
138
        ])
2291
139
    end,
2292
140
2293
141
    % set mochiweb options
2294
142
    FinalOptions = lists:append([Options, ServerOptions, [
2295
143
            {loop, Loop},
2296
144
            {name, Name},
2297
145
            {ip, BindAddress}]]),
2298
146
2299
147
    % launch mochiweb
2300
148
    {ok, Pid} = case mochiweb_http:start(FinalOptions) of
2301
149
        {ok, MochiPid} -> 
2302
150
            {ok, MochiPid};
2303
151
        {error, Reason} ->
2304
152
            io:format("Failure to start Mochiweb: ~s~n",[Reason]),
2305
153
            throw({error, Reason})
2306
154
    end,
2307
155
2308
156
    ok = couch_config:register(fun ?MODULE:config_change/2, Pid),
2309
157
    {ok, Pid}.
2310
158
2311
159
2312
160
stop() ->
2313
161
    mochiweb_http:stop(couch_httpd),
2314
162
    mochiweb_http:stop(https).
2315
163
2316
164
config_change("httpd", "bind_address") ->
2317
165
    ?MODULE:stop();
2318
166
config_change("httpd", "port") ->
2319
167
    ?MODULE:stop();
2320
168
config_change("httpd", "default_handler") ->
2321
169
    ?MODULE:stop();
2322
170
config_change("httpd", "server_options") ->
2323
171
    ?MODULE:stop();
2324
172
config_change("httpd", "socket_options") ->
2325
173
    ?MODULE:stop();
2326
174
config_change("httpd", "authentication_handlers") ->
2327
175
    set_auth_handlers();
2328
176
config_change("httpd_global_handlers", _) ->
2329
177
    ?MODULE:stop();
2330
178
config_change("httpd_db_handlers", _) ->
2331
179
    ?MODULE:stop();
2332
180
config_change("ssl", _) ->
2333
181
    ?MODULE:stop().
2334
182
2335
183
set_auth_handlers() ->
2336
184
    AuthenticationSrcs = make_fun_spec_strs(
2337
185
        couch_config:get("httpd", "authentication_handlers", "")),
2338
186
    AuthHandlers = lists:map(
2339
187
        fun(A) -> {make_arity_1_fun(A), ?l2b(A)} end, AuthenticationSrcs),
2340
188
    ok = application:set_env(couch, auth_handlers, AuthHandlers).
2341
189
2342
190
% SpecStr is a string like "{my_module, my_fun}"
2343
191
%  or "{my_module, my_fun, <<"my_arg">>}"
2344
192
make_arity_1_fun(SpecStr) ->
2345
193
    case couch_util:parse_term(SpecStr) of
2346
194
    {ok, {Mod, Fun, SpecArg}} ->
2347
195
        fun(Arg) -> Mod:Fun(Arg, SpecArg) end;
2348
196
    {ok, {Mod, Fun}} ->
2349
197
        fun(Arg) -> Mod:Fun(Arg) end
2350
198
    end.
2351
199
2352
200
make_arity_2_fun(SpecStr) ->
2353
201
    case couch_util:parse_term(SpecStr) of
2354
202
    {ok, {Mod, Fun, SpecArg}} ->
2355
203
        fun(Arg1, Arg2) -> Mod:Fun(Arg1, Arg2, SpecArg) end;
2356
204
    {ok, {Mod, Fun}} ->
2357
205
        fun(Arg1, Arg2) -> Mod:Fun(Arg1, Arg2) end
2358
206
    end.
2359
207
2360
208
make_arity_3_fun(SpecStr) ->
2361
209
    case couch_util:parse_term(SpecStr) of
2362
210
    {ok, {Mod, Fun, SpecArg}} ->
2363
211
        fun(Arg1, Arg2, Arg3) -> Mod:Fun(Arg1, Arg2, Arg3, SpecArg) end;
2364
212
    {ok, {Mod, Fun}} ->
2365
213
        fun(Arg1, Arg2, Arg3) -> Mod:Fun(Arg1, Arg2, Arg3) end
2366
214
    end.
2367
215
2368
216
% SpecStr is "{my_module, my_fun}, {my_module2, my_fun2}"
2369
217
make_fun_spec_strs(SpecStr) ->
2370
218
    re:split(SpecStr, "(?<=})\\s*,\\s*(?={)", [{return, list}]).
2371
219
2372
220
handle_request(MochiReq, DefaultFun, UrlHandlers, DbUrlHandlers, 
2373
221
    DesignUrlHandlers) ->
2374
222
2375
223
    MochiReq1 = couch_httpd_vhost:dispatch_host(MochiReq),
2376
224
    
2377
225
    handle_request_int(MochiReq1, DefaultFun,
2378
226
                UrlHandlers, DbUrlHandlers, DesignUrlHandlers).
2379
227
2380
228
handle_request_int(MochiReq, DefaultFun,
2381
229
            UrlHandlers, DbUrlHandlers, DesignUrlHandlers) ->
2382
230
    Begin = now(),
2383
231
    % for the path, use the raw path with the query string and fragment
2384
232
    % removed, but URL quoting left intact
2385
233
    RawUri = MochiReq:get(raw_path),
2386
234
    {"/" ++ Path, _, _} = mochiweb_util:urlsplit_path(RawUri),
2387
235
2388
236
    Headers = MochiReq:get(headers), 
2389
237
2390
238
    % get requested path
2391
239
    RequestedPath = case MochiReq:get_header_value("x-couchdb-vhost-path") of
2392
240
        undefined ->
2393
241
            case MochiReq:get_header_value("x-couchdb-requested-path") of
2394
242
                undefined -> RawUri;
2395
243
                R -> R
2396
244
            end;
2397
245
        P -> P
2398
246
    end,
2399
247
    
2400
248
    HandlerKey =
2401
249
    case mochiweb_util:partition(Path, "/") of
2402
250
    {"", "", ""} ->
2403
251
        <<"/">>; % Special case the root url handler
2404
252
    {FirstPart, _, _} ->
2405
253
        list_to_binary(FirstPart)
2406
254
    end,
2407
255
    ?LOG_DEBUG("~p ~s ~p from ~p~nHeaders: ~p", [
2408
256
        MochiReq:get(method),
2409
257
        RawUri,
2410
258
        MochiReq:get(version),
2411
259
        MochiReq:get(peer),
2412
260
        mochiweb_headers:to_list(MochiReq:get(headers))
2413
261
    ]),
2414
262
    
2415
263
    Method1 =
2416
264
    case MochiReq:get(method) of
2417
265
        % already an atom
2418
266
        Meth when is_atom(Meth) -> Meth;
2419
267
2420
268
        % Non standard HTTP verbs aren't atoms (COPY, MOVE etc) so convert when
2421
269
        % possible (if any module references the atom, then it's existing).
2422
270
        Meth -> couch_util:to_existing_atom(Meth)
2423
271
    end,
2424
272
    increment_method_stats(Method1),
2425
273
2426
274
    % allow broken HTTP clients to fake a full method vocabulary with an X-HTTP-METHOD-OVERRIDE header
2427
275
    MethodOverride = MochiReq:get_primary_header_value("X-HTTP-Method-Override"),
2428
276
    Method2 = case lists:member(MethodOverride, ["GET", "HEAD", "POST", "PUT", "DELETE", "TRACE", "CONNECT", "COPY"]) of
2429
277
    true -> 
2430
278
        ?LOG_INFO("MethodOverride: ~s (real method was ~s)", [MethodOverride, Method1]),
2431
279
        case Method1 of
2432
280
        'POST' -> couch_util:to_existing_atom(MethodOverride);
2433
281
        _ -> 
2434
282
            % Ignore X-HTTP-Method-Override when the original verb isn't POST.
2435
283
            % I'd like to send a 406 error to the client, but that'd require a nasty refactor.
2436
284
            % throw({not_acceptable, <<"X-HTTP-Method-Override may only be used with POST requests.">>})
2437
285
            Method1
2438
286
        end;
2439
287
    _ -> Method1
2440
288
    end,
2441
289
2442
290
    % alias HEAD to GET as mochiweb takes care of stripping the body
2443
291
    Method = case Method2 of
2444
292
        'HEAD' -> 'GET';
2445
293
        Other -> Other
2446
294
    end,
2447
295
2448
296
    HttpReq = #httpd{
2449
297
        mochi_req = MochiReq,
2450
298
        peer = MochiReq:get(peer),
2451
299
        method = Method,
2452
300
        requested_path_parts =
2453
301
            [?l2b(unquote(Part)) || Part <- string:tokens(RequestedPath, "/")],
2454
302
        path_parts = [?l2b(unquote(Part)) || Part <- string:tokens(Path, "/")],
2455
303
        db_url_handlers = DbUrlHandlers,
2456
304
        design_url_handlers = DesignUrlHandlers,
2457
305
        default_fun = DefaultFun,
2458
306
        url_handlers = UrlHandlers,
2459
307
        user_ctx = erlang:erase(pre_rewrite_user_ctx)
2460
308
    },
2461
309
2462
310
    HandlerFun = couch_util:dict_find(HandlerKey, UrlHandlers, DefaultFun),
2463
311
    {ok, AuthHandlers} = application:get_env(couch, auth_handlers),
2464
312
2465
313
    {ok, Resp} =
2466
314
    try
2467
315
        case authenticate_request(HttpReq, AuthHandlers) of
2468
316
        #httpd{} = Req ->
2469
317
            HandlerFun(Req);
2470
318
        Response ->
2471
319
            Response
2472
320
        end
2473
321
    catch
2474
322
        throw:{http_head_abort, Resp0} ->
2475
323
            {ok, Resp0};
2476
324
        throw:{invalid_json, S} ->
2477
325
            ?LOG_ERROR("attempted upload of invalid JSON (set log_level to debug to log it)", []),
2478
326
            ?LOG_DEBUG("Invalid JSON: ~p",[S]),
2479
327
            send_error(HttpReq, {bad_request, invalid_json});
2480
328
        throw:unacceptable_encoding ->
2481
329
            ?LOG_ERROR("unsupported encoding method for the response", []),
2482
330
            send_error(HttpReq, {not_acceptable, "unsupported encoding"});
2483
331
        throw:bad_accept_encoding_value ->
2484
332
            ?LOG_ERROR("received invalid Accept-Encoding header", []),
2485
333
            send_error(HttpReq, bad_request);
2486
334
        exit:normal ->
2487
335
            exit(normal);
2488
336
        exit:snappy_nif_not_loaded ->
2489
337
            ErrorReason = "To access the database or view index, Apache CouchDB"
2490
338
                " must be built with Erlang OTP R13B04 or higher.",
2491
339
            ?LOG_ERROR("~s", [ErrorReason]),
2492
340
            send_error(HttpReq, {bad_otp_release, ErrorReason});
2493
341
        throw:Error ->
2494
342
            Stack = erlang:get_stacktrace(),
2495
343
            ?LOG_DEBUG("Minor error in HTTP request: ~p",[Error]),
2496
344
            ?LOG_DEBUG("Stacktrace: ~p",[Stack]),
2497
345
            send_error(HttpReq, Error);
2498
346
        error:badarg ->
2499
347
            Stack = erlang:get_stacktrace(),
2500
348
            ?LOG_ERROR("Badarg error in HTTP request",[]),
2501
349
            ?LOG_INFO("Stacktrace: ~p",[Stack]),
2502
350
            send_error(HttpReq, badarg);
2503
351
        error:function_clause ->
2504
352
            Stack = erlang:get_stacktrace(),
2505
353
            ?LOG_ERROR("function_clause error in HTTP request",[]),
2506
354
            ?LOG_INFO("Stacktrace: ~p",[Stack]),
2507
355
            send_error(HttpReq, function_clause);
2508
356
        Tag:Error ->
2509
357
            Stack = erlang:get_stacktrace(),
2510
358
            ?LOG_ERROR("Uncaught error in HTTP request: ~p",[{Tag, Error}]),
2511
359
            ?LOG_INFO("Stacktrace: ~p",[Stack]),
2512
360
            send_error(HttpReq, Error)
2513
361
    end,
2514
362
    RequestTime = round(timer:now_diff(now(), Begin)/1000),
2515
363
    couch_stats_collector:record({couchdb, request_time}, RequestTime),
2516
364
    couch_stats_collector:increment({httpd, requests}),
2517
365
    {ok, Resp}.
2518
366
2519
367
% Try authentication handlers in order until one sets a user_ctx
2520
368
% the auth funs also have the option of returning a response
2521
369
% move this to couch_httpd_auth?
2522
370
authenticate_request(#httpd{user_ctx=#user_ctx{}} = Req, _AuthHandlers) ->
2523
371
    Req;
2524
372
authenticate_request(#httpd{} = Req, []) ->
2525
373
    case couch_config:get("couch_httpd_auth", "require_valid_user", "false") of
2526
374
    "true" ->
2527
375
        throw({unauthorized, <<"Authentication required.">>});
2528
376
    "false" ->
2529
377
        Req#httpd{user_ctx=#user_ctx{}}
2530
378
    end;
2531
379
authenticate_request(#httpd{} = Req, [{AuthFun, AuthSrc} | RestAuthHandlers]) ->
2532
380
    R = case AuthFun(Req) of
2533
381
        #httpd{user_ctx=#user_ctx{}=UserCtx}=Req2 ->
2534
382
            Req2#httpd{user_ctx=UserCtx#user_ctx{handler=AuthSrc}};
2535
383
        Else -> Else
2536
384
    end,
2537
385
    authenticate_request(R, RestAuthHandlers);
2538
386
authenticate_request(Response, _AuthSrcs) ->
2539
387
    Response.
2540
388
2541
389
increment_method_stats(Method) ->
2542
390
    couch_stats_collector:increment({httpd_request_methods, Method}).
2543
391
2544
392
validate_referer(Req) ->
2545
393
    Host = host_for_request(Req),
2546
394
    Referer = header_value(Req, "Referer", fail),
2547
395
    case Referer of
2548
396
    fail ->
2549
397
        throw({bad_request, <<"Referer header required.">>});
2550
398
    Referer ->
2551
399
        {_,RefererHost,_,_,_} = mochiweb_util:urlsplit(Referer),
2552
400
        if
2553
401
            RefererHost =:= Host -> ok;
2554
402
            true -> throw({bad_request, <<"Referer header must match host.">>})
2555
403
        end
2556
404
    end.
2557
405
2558
406
validate_ctype(Req, Ctype) ->
2559
407
    case header_value(Req, "Content-Type") of
2560
408
    undefined ->
2561
409
        throw({bad_ctype, "Content-Type must be "++Ctype});
2562
410
    ReqCtype ->
2563
411
        case string:tokens(ReqCtype, ";") of
2564
412
        [Ctype] -> ok;
2565
413
        [Ctype, _Rest] -> ok;
2566
414
        _Else ->
2567
415
            throw({bad_ctype, "Content-Type must be "++Ctype})
2568
416
        end
2569
417
    end.
2570
418
2571
419
% Utilities
2572
420
2573
421
partition(Path) ->
2574
422
    mochiweb_util:partition(Path, "/").
2575
423
2576
424
header_value(#httpd{mochi_req=MochiReq}, Key) ->
2577
425
    MochiReq:get_header_value(Key).
2578
426
2579
427
header_value(#httpd{mochi_req=MochiReq}, Key, Default) ->
2580
428
    case MochiReq:get_header_value(Key) of
2581
429
    undefined -> Default;
2582
430
    Value -> Value
2583
431
    end.
2584
432
2585
433
primary_header_value(#httpd{mochi_req=MochiReq}, Key) ->
2586
434
    MochiReq:get_primary_header_value(Key).
2587
435
2588
436
accepted_encodings(#httpd{mochi_req=MochiReq}) ->
2589
437
    case MochiReq:accepted_encodings(["gzip", "identity"]) of
2590
438
    bad_accept_encoding_value ->
2591
439
        throw(bad_accept_encoding_value);
2592
440
    [] ->
2593
441
        throw(unacceptable_encoding);
2594
442
    EncList ->
2595
443
        EncList
2596
444
    end.
2597
445
2598
446
serve_file(Req, RelativePath, DocumentRoot) ->
2599
447
    serve_file(Req, RelativePath, DocumentRoot, []).
2600
448
2601
449
serve_file(#httpd{mochi_req=MochiReq}=Req, RelativePath, DocumentRoot, ExtraHeaders) ->
2602
450
    log_request(Req, 200),
2603
451
    {ok, MochiReq:serve_file(RelativePath, DocumentRoot,
2604
452
        server_header() ++ couch_httpd_auth:cookie_auth_header(Req, []) ++ ExtraHeaders)}.
2605
453
2606
454
qs_value(Req, Key) ->
2607
455
    qs_value(Req, Key, undefined).
2608
456
2609
457
qs_value(Req, Key, Default) ->
2610
458
    couch_util:get_value(Key, qs(Req), Default).
2611
459
2612
460
qs_json_value(Req, Key, Default) ->
2613
461
    case qs_value(Req, Key, Default) of
2614
462
    Default ->
2615
463
        Default;
2616
464
    Result ->
2617
465
        ?JSON_DECODE(Result)
2618
466
    end.
2619
467
2620
468
qs(#httpd{mochi_req=MochiReq}) ->
2621
469
    MochiReq:parse_qs().
2622
470
2623
471
path(#httpd{mochi_req=MochiReq}) ->
2624
472
    MochiReq:get(path).
2625
473
2626
474
host_for_request(#httpd{mochi_req=MochiReq}) ->
2627
475
    XHost = couch_config:get("httpd", "x_forwarded_host", "X-Forwarded-Host"),
2628
476
    case MochiReq:get_header_value(XHost) of
2629
477
        undefined ->
2630
478
            case MochiReq:get_header_value("Host") of
2631
479
                undefined ->
2632
480
                    {ok, {Address, Port}} = inet:sockname(MochiReq:get(socket)),
2633
481
                    inet_parse:ntoa(Address) ++ ":" ++ integer_to_list(Port);
2634
482
                Value1 ->
2635
483
                    Value1
2636
484
            end;
2637
485
        Value -> Value
2638
486
    end.
2639
487
2640
488
absolute_uri(#httpd{mochi_req=MochiReq}=Req, Path) ->
2641
489
    Host = host_for_request(Req),
2642
490
    XSsl = couch_config:get("httpd", "x_forwarded_ssl", "X-Forwarded-Ssl"),
2643
491
    Scheme = case MochiReq:get_header_value(XSsl) of
2644
492
                 "on" -> "https";
2645
493
                 _ ->
2646
494
                     XProto = couch_config:get("httpd", "x_forwarded_proto", "X-Forwarded-Proto"),
2647
495
                     case MochiReq:get_header_value(XProto) of
2648
496
                         %% Restrict to "https" and "http" schemes only
2649
497
                         "https" -> "https";
2650
498
                         _ -> case MochiReq:get(scheme) of
2651
499
                                  https -> "https";
2652
500
                                  http -> "http"
2653
501
                              end
2654
502
                     end
2655
503
             end,
2656
504
    Scheme ++ "://" ++ Host ++ Path.
2657
505
2658
506
unquote(UrlEncodedString) ->
2659
507
    mochiweb_util:unquote(UrlEncodedString).
2660
508
2661
509
quote(UrlDecodedString) ->
2662
510
    mochiweb_util:quote_plus(UrlDecodedString).
2663
511
2664
512
parse_form(#httpd{mochi_req=MochiReq}) ->
2665
513
    mochiweb_multipart:parse_form(MochiReq).
2666
514
2667
515
recv(#httpd{mochi_req=MochiReq}, Len) ->
2668
516
    MochiReq:recv(Len).
2669
517
2670
518
recv_chunked(#httpd{mochi_req=MochiReq}, MaxChunkSize, ChunkFun, InitState) ->
2671
519
    % Fun is called once with each chunk
2672
520
    % Fun({Length, Binary}, State)
2673
521
    % called with Length == 0 on the last time.
2674
522
    MochiReq:stream_body(MaxChunkSize, ChunkFun, InitState).
2675
523
    
2676
524
body_length(Req) ->
2677
525
    case header_value(Req, "Transfer-Encoding") of
2678
526
        undefined ->
2679
527
            case header_value(Req, "Content-Length") of
2680
528
                undefined -> undefined;
2681
529
                Length -> list_to_integer(Length)
2682
530
            end;
2683
531
        "chunked" -> chunked;
2684
532
        Unknown -> {unknown_transfer_encoding, Unknown}
2685
533
    end.
2686
534
2687
535
body(#httpd{mochi_req=MochiReq, req_body=undefined} = Req) ->
2688
536
    case body_length(Req) of
2689
537
        undefined ->
2690
538
            MaxSize = list_to_integer(
2691
539
                couch_config:get("couchdb", "max_document_size", "4294967296")),
2692
540
            MochiReq:recv_body(MaxSize);
2693
541
        chunked ->
2694
542
            ChunkFun = fun({0, _Footers}, Acc) ->
2695
543
                lists:reverse(Acc);
2696
544
            ({_Len, Chunk}, Acc) ->
2697
545
                [Chunk | Acc]
2698
546
            end,
2699
547
            recv_chunked(Req, 8192, ChunkFun, []);
2700
548
        Len ->
2701
549
            MochiReq:recv_body(Len)
2702
550
    end;
2703
551
body(#httpd{req_body=ReqBody}) ->
2704
552
    ReqBody.
2705
553
2706
554
json_body(Httpd) ->
2707
555
    ?JSON_DECODE(body(Httpd)).
2708
556
2709
557
json_body_obj(Httpd) ->
2710
558
    case json_body(Httpd) of
2711
559
        {Props} -> {Props};
2712
560
        _Else ->
2713
561
            throw({bad_request, "Request body must be a JSON object"})
2714
562
    end.
2715
563
2716
564
2717
565
2718
566
doc_etag(#doc{revs={Start, [DiskRev|_]}}) ->
2719
567
    "\"" ++ ?b2l(couch_doc:rev_to_str({Start, DiskRev})) ++ "\"".
2720
568
2721
569
make_etag(Term) ->
2722
570
    <<SigInt:128/integer>> = couch_util:md5(term_to_binary(Term)),
2723
571
    iolist_to_binary([$", io_lib:format("~.36B", [SigInt]), $"]).
2724
572
2725
573
etag_match(Req, CurrentEtag) when is_binary(CurrentEtag) ->
2726
574
    etag_match(Req, binary_to_list(CurrentEtag));
2727
575
2728
576
etag_match(Req, CurrentEtag) ->
2729
577
    EtagsToMatch = string:tokens(
2730
578
        header_value(Req, "If-None-Match", ""), ", "),
2731
579
    lists:member(CurrentEtag, EtagsToMatch).
2732
580
2733
581
etag_respond(Req, CurrentEtag, RespFun) ->
2734
582
    case etag_match(Req, CurrentEtag) of
2735
583
    true ->
2736
584
        % the client has this in their cache.
2737
585
        send_response(Req, 304, [{"ETag", CurrentEtag}], <<>>);
2738
586
    false ->
2739
587
        % Run the function.
2740
588
        RespFun()
2741
589
    end.
2742
590
2743
591
verify_is_server_admin(#httpd{user_ctx=UserCtx}) ->
2744
592
    verify_is_server_admin(UserCtx);
2745
593
verify_is_server_admin(#user_ctx{roles=Roles}) ->
2746
594
    case lists:member(<<"_admin">>, Roles) of
2747
595
    true -> ok;
2748
596
    false -> throw({unauthorized, <<"You are not a server admin.">>})
2749
597
    end.
2750
598
2751
599
log_request(#httpd{mochi_req=MochiReq,peer=Peer}, Code) ->
2752
600
    ?LOG_INFO("~s - - ~s ~s ~B", [
2753
601
        Peer,
2754
602
        MochiReq:get(method),
2755
603
        MochiReq:get(raw_path),
2756
604
        Code
2757
605
    ]).
2758
606
2759
607
2760
608
start_response_length(#httpd{mochi_req=MochiReq}=Req, Code, Headers, Length) ->
2761
609
    log_request(Req, Code),
2762
610
    couch_stats_collector:increment({httpd_status_codes, Code}),
2763
611
    Resp = MochiReq:start_response_length({Code, Headers ++ server_header() ++ couch_httpd_auth:cookie_auth_header(Req, Headers), Length}),
2764
612
    case MochiReq:get(method) of
2765
613
    'HEAD' -> throw({http_head_abort, Resp});
2766
614
    _ -> ok
2767
615
    end,
2768
616
    {ok, Resp}.
2769
617
2770
618
start_response(#httpd{mochi_req=MochiReq}=Req, Code, Headers) ->
2771
619
    log_request(Req, Code),
2772
620
    couch_stats_collector:increment({httpd_status_cdes, Code}),
2773
621
    CookieHeader = couch_httpd_auth:cookie_auth_header(Req, Headers),
2774
622
    Headers2 = Headers ++ server_header() ++ CookieHeader,
2775
623
    Resp = MochiReq:start_response({Code, Headers2}),
2776
624
    case MochiReq:get(method) of
2777
625
        'HEAD' -> throw({http_head_abort, Resp});
2778
626
        _ -> ok
2779
627
    end,
2780
628
    {ok, Resp}.
2781
629
2782
630
send(Resp, Data) ->
2783
631
    Resp:send(Data),
2784
632
    {ok, Resp}.
2785
633
2786
634
no_resp_conn_header([]) ->
2787
635
    true;
2788
636
no_resp_conn_header([{Hdr, _}|Rest]) ->
2789
637
    case string:to_lower(Hdr) of
2790
638
        "connection" -> false;
2791
639
        _ -> no_resp_conn_header(Rest)
2792
640
    end.
2793
641
2794
642
http_1_0_keep_alive(Req, Headers) ->
2795
643
    KeepOpen = Req:should_close() == false,
2796
644
    IsHttp10 = Req:get(version) == {1, 0},
2797
645
    NoRespHeader = no_resp_conn_header(Headers),
2798
646
    case KeepOpen andalso IsHttp10 andalso NoRespHeader of
2799
647
        true -> [{"Connection", "Keep-Alive"} | Headers];
2800
648
        false -> Headers
2801
649
    end.
2802
650
2803
651
start_chunked_response(#httpd{mochi_req=MochiReq}=Req, Code, Headers) ->
2804
652
    log_request(Req, Code),
2805
653
    couch_stats_collector:increment({httpd_status_codes, Code}),
2806
654
    Headers2 = http_1_0_keep_alive(MochiReq, Headers),
2807
655
    Resp = MochiReq:respond({Code, Headers2 ++ server_header() ++ couch_httpd_auth:cookie_auth_header(Req, Headers2), chunked}),
2808
656
    case MochiReq:get(method) of
2809
657
    'HEAD' -> throw({http_head_abort, Resp});
2810
658
    _ -> ok
2811
659
    end,
2812
660
    {ok, Resp}.
2813
661
2814
662
send_chunk(Resp, Data) ->
2815
663
    case iolist_size(Data) of
2816
664
    0 -> ok; % do nothing
2817
665
    _ -> Resp:write_chunk(Data)
2818
666
    end,
2819
667
    {ok, Resp}.
2820
668
2821
669
last_chunk(Resp) ->
2822
670
    Resp:write_chunk([]),
2823
671
    {ok, Resp}.
2824
672
2825
673
send_response(#httpd{mochi_req=MochiReq}=Req, Code, Headers, Body) ->
2826
674
    log_request(Req, Code),
2827
675
    couch_stats_collector:increment({httpd_status_codes, Code}),
2828
676
    Headers2 = http_1_0_keep_alive(MochiReq, Headers),
2829
677
    if Code >= 400 ->
2830
678
        ?LOG_DEBUG("httpd ~p error response:~n ~s", [Code, Body]);
2831
679
    true -> ok
2832
680
    end,
2833
681
    {ok, MochiReq:respond({Code, Headers2 ++ server_header() ++ couch_httpd_auth:cookie_auth_header(Req, Headers2), Body})}.
2834
682
2835
683
send_method_not_allowed(Req, Methods) ->
2836
684
    send_error(Req, 405, [{"Allow", Methods}], <<"method_not_allowed">>, ?l2b("Only " ++ Methods ++ " allowed")).
2837
685
2838
686
send_json(Req, Value) ->
2839
687
    send_json(Req, 200, Value).
2840
688
2841
689
send_json(Req, Code, Value) ->
2842
690
    send_json(Req, Code, [], Value).
2843
691
2844
692
send_json(Req, Code, Headers, Value) ->
2845
693
    initialize_jsonp(Req),
2846
694
    DefaultHeaders = [
2847
695
        {"Content-Type", negotiate_content_type(Req)},
2848
696
        {"Cache-Control", "must-revalidate"}
2849
697
    ],
2850
698
    Body = [start_jsonp(), ?JSON_ENCODE(Value), end_jsonp(), $\n],
2851
699
    send_response(Req, Code, DefaultHeaders ++ Headers, Body).
2852
700
2853
701
start_json_response(Req, Code) ->
2854
702
    start_json_response(Req, Code, []).
2855
703
2856
704
start_json_response(Req, Code, Headers) ->
2857
705
    initialize_jsonp(Req),
2858
706
    DefaultHeaders = [
2859
707
        {"Content-Type", negotiate_content_type(Req)},
2860
708
        {"Cache-Control", "must-revalidate"}
2861
709
    ],
2862
710
    {ok, Resp} = start_chunked_response(Req, Code, DefaultHeaders ++ Headers),
2863
711
    case start_jsonp() of
2864
712
        [] -> ok;
2865
713
        Start -> send_chunk(Resp, Start)
2866
714
    end,
2867
715
    {ok, Resp}.
2868
716
2869
717
end_json_response(Resp) ->
2870
718
    send_chunk(Resp, end_jsonp() ++ [$\n]),
2871
719
    last_chunk(Resp).
2872
720
2873
721
initialize_jsonp(Req) ->
2874
722
    case get(jsonp) of
2875
723
        undefined -> put(jsonp, qs_value(Req, "callback", no_jsonp));
2876
724
        _ -> ok
2877
725
    end,
2878
726
    case get(jsonp) of
2879
727
        no_jsonp -> [];
2880
728
        [] -> [];
2881
729
        CallBack ->
2882
730
            try
2883
731
                % make sure jsonp is configured on (default off)
2884
732
                case couch_config:get("httpd", "allow_jsonp", "false") of
2885
733
                "true" ->
2886
734
                    validate_callback(CallBack);
2887
735
                _Else ->
2888
736
                    put(jsonp, no_jsonp)
2889
737
                end
2890
738
            catch
2891
739
                Error ->
2892
740
                    put(jsonp, no_jsonp),
2893
741
                    throw(Error)
2894
742
            end
2895
743
    end.
2896
744
2897
745
start_jsonp() ->
2898
746
    case get(jsonp) of
2899
747
        no_jsonp -> [];
2900
748
        [] -> [];
2901
749
        CallBack -> CallBack ++ "("
2902
750
    end.
2903
751
2904
752
end_jsonp() ->
2905
753
    case erlang:erase(jsonp) of
2906
754
        no_jsonp -> [];
2907
755
        [] -> [];
2908
756
        _ -> ");"
2909
757
    end.
2910
758
2911
759
validate_callback(CallBack) when is_binary(CallBack) ->
2912
760
    validate_callback(binary_to_list(CallBack));
2913
761
validate_callback([]) ->
2914
762
    ok;
2915
763
validate_callback([Char | Rest]) ->
2916
764
    case Char of
2917
765
        _ when Char >= $a andalso Char =< $z -> ok;
2918
766
        _ when Char >= $A andalso Char =< $Z -> ok;
2919
767
        _ when Char >= $0 andalso Char =< $9 -> ok;
2920
768
        _ when Char == $. -> ok;
2921
769
        _ when Char == $_ -> ok;
2922
770
        _ when Char == $[ -> ok;
2923
771
        _ when Char == $] -> ok;
2924
772
        _ ->
2925
773
            throw({bad_request, invalid_callback})
2926
774
    end,
2927
775
    validate_callback(Rest).
2928
776
2929
777
2930
778
error_info({Error, Reason}) when is_list(Reason) ->
2931
779
    error_info({Error, ?l2b(Reason)});
2932
780
error_info(bad_request) ->
2933
781
    {400, <<"bad_request">>, <<>>};
2934
782
error_info({bad_request, Reason}) ->
2935
783
    {400, <<"bad_request">>, Reason};
2936
784
error_info({query_parse_error, Reason}) ->
2937
785
    {400, <<"query_parse_error">>, Reason};
2938
786
% Prior art for md5 mismatch resulting in a 400 is from AWS S3
2939
787
error_info(md5_mismatch) ->
2940
788
    {400, <<"content_md5_mismatch">>, <<"Possible message corruption.">>};
2941
789
error_info(not_found) ->
2942
790
    {404, <<"not_found">>, <<"missing">>};
2943
791
error_info({not_found, Reason}) ->
2944
792
    {404, <<"not_found">>, Reason};
2945
793
error_info({not_acceptable, Reason}) ->
2946
794
    {406, <<"not_acceptable">>, Reason};
2947
795
error_info(conflict) ->
2948
796
    {409, <<"conflict">>, <<"Document update conflict.">>};
2949
797
error_info({forbidden, Msg}) ->
2950
798
    {403, <<"forbidden">>, Msg};
2951
799
error_info({unauthorized, Msg}) ->
2952
800
    {401, <<"unauthorized">>, Msg};
2953
801
error_info(file_exists) ->
2954
802
    {412, <<"file_exists">>, <<"The database could not be "
2955
803
        "created, the file already exists.">>};
2956
804
error_info({bad_ctype, Reason}) ->
2957
805
    {415, <<"bad_content_type">>, Reason};
2958
806
error_info(requested_range_not_satisfiable) ->
2959
807
    {416, <<"requested_range_not_satisfiable">>, <<"Requested range not satisfiable">>};
2960
808
error_info({error, illegal_database_name}) ->
2961
809
    {400, <<"illegal_database_name">>, <<"Only lowercase characters (a-z), "
2962
810
        "digits (0-9), and any of the characters _, $, (, ), +, -, and / "
2963
811
        "are allowed. Must begin with a letter.">>};
2964
812
error_info({missing_stub, Reason}) ->
2965
813
    {412, <<"missing_stub">>, Reason};
2966
814
error_info({Error, Reason}) ->
2967
815
    ?LOG_ERROR("Uncaught server error: ~p", [{Error, Reason}]),
2968
816
    {500, couch_util:to_binary(Error), couch_util:to_binary(Reason)};
2969
817
error_info(Error) ->
2970
818
    ?LOG_ERROR("Uncaught server error: ~p", [Error]),
2971
819
    {500, <<"unknown_error">>, couch_util:to_binary(Error)}.
2972
820
2973
821
error_headers(#httpd{mochi_req=MochiReq}=Req, Code, ErrorStr, ReasonStr) ->
2974
822
    if Code == 401 ->
2975
823
        % this is where the basic auth popup is triggered
2976
824
        case MochiReq:get_header_value("X-CouchDB-WWW-Authenticate") of
2977
825
        undefined ->
2978
826
            case couch_config:get("httpd", "WWW-Authenticate", nil) of
2979
827
            nil ->
2980
828
                % If the client is a browser and the basic auth popup isn't turned on
2981
829
                % redirect to the session page.
2982
830
                case ErrorStr of
2983
831
                <<"unauthorized">> ->
2984
832
                    case couch_config:get("couch_httpd_auth", "authentication_redirect", nil) of
2985
833
                    nil -> {Code, []};
2986
834
                    AuthRedirect ->
2987
835
                        case couch_config:get("couch_httpd_auth", "require_valid_user", "false") of
2988
836
                        "true" ->
2989
837
                            % send the browser popup header no matter what if we are require_valid_user
2990
838
                            {Code, [{"WWW-Authenticate", "Basic realm=\"server\""}]};
2991
839
                        _False ->
2992
840
                            case MochiReq:accepts_content_type("application/json") of
2993
841
                            true ->
2994
842
                                {Code, []};
2995
843
                            false ->
2996
844
                                case MochiReq:accepts_content_type("text/html") of
2997
845
                                true ->
2998
846
                                    % Redirect to the path the user requested, not
2999
847
                                    % the one that is used internally.
3000
848
                                    UrlReturnRaw = case MochiReq:get_header_value("x-couchdb-vhost-path") of
3001
849
                                    undefined ->
3002
850
                                        MochiReq:get(path);
3003
851
                                    VHostPath ->
3004
852
                                        VHostPath
3005
853
                                    end,
3006
854
                                    RedirectLocation = lists:flatten([
3007
855
                                        AuthRedirect,
3008
856
                                        "?return=", couch_util:url_encode(UrlReturnRaw),
3009
857
                                        "&reason=", couch_util:url_encode(ReasonStr)
3010
858
                                    ]),
3011
859
                                    {302, [{"Location", absolute_uri(Req, RedirectLocation)}]};
3012
860
                                false ->
3013
861
                                    {Code, []}
3014
862
                                end
3015
863
                            end
3016
864
                        end
3017
865
                    end;
3018
866
                _Else ->
3019
867
                    {Code, []}
3020
868
                end;
3021
869
            Type ->
3022
870
                {Code, [{"WWW-Authenticate", Type}]}
3023
871
            end;
3024
872
        Type ->
3025
873
           {Code, [{"WWW-Authenticate", Type}]}
3026
874
        end;
3027
875
    true ->
3028
876
        {Code, []}
3029
877
    end.
3030
878
3031
879
send_error(_Req, {already_sent, Resp, _Error}) ->
3032
880
    {ok, Resp};
3033
881
3034
882
send_error(Req, Error) ->
3035
883
    {Code, ErrorStr, ReasonStr} = error_info(Error),
3036
884
    {Code1, Headers} = error_headers(Req, Code, ErrorStr, ReasonStr),
3037
885
    send_error(Req, Code1, Headers, ErrorStr, ReasonStr).
3038
886
3039
887
send_error(Req, Code, ErrorStr, ReasonStr) ->
3040
888
    send_error(Req, Code, [], ErrorStr, ReasonStr).
3041
889
3042
890
send_error(Req, Code, Headers, ErrorStr, ReasonStr) ->
3043
891
    send_json(Req, Code, Headers,
3044
892
        {[{<<"error">>,  ErrorStr},
3045
893
         {<<"reason">>, ReasonStr}]}).
3046
894
3047
895
% give the option for list functions to output html or other raw errors
3048
896
send_chunked_error(Resp, {_Error, {[{<<"body">>, Reason}]}}) ->
3049
897
    send_chunk(Resp, Reason),
3050
898
    last_chunk(Resp);
3051
899
3052
900
send_chunked_error(Resp, Error) ->
3053
901
    {Code, ErrorStr, ReasonStr} = error_info(Error),
3054
902
    JsonError = {[{<<"code">>, Code},
3055
903
        {<<"error">>,  ErrorStr},
3056
904
        {<<"reason">>, ReasonStr}]},
3057
905
    send_chunk(Resp, ?l2b([$\n,?JSON_ENCODE(JsonError),$\n])),
3058
906
    last_chunk(Resp).
3059
907
3060
908
send_redirect(Req, Path) ->
3061
909
     send_response(Req, 301, [{"Location", absolute_uri(Req, Path)}], <<>>).
3062
910
3063
911
negotiate_content_type(Req) ->
3064
912
    case get(jsonp) of
3065
913
        no_jsonp -> negotiate_content_type1(Req);
3066
914
        [] -> negotiate_content_type1(Req);
3067
915
        _Callback -> "text/javascript"
3068
916
    end.
3069
917
3070
918
negotiate_content_type1(#httpd{mochi_req=MochiReq}) ->
3071
919
    %% Determine the appropriate Content-Type header for a JSON response
3072
920
    %% depending on the Accept header in the request. A request that explicitly
3073
921
    %% lists the correct JSON MIME type will get that type, otherwise the
3074
922
    %% response will have the generic MIME type "text/plain"
3075
923
    AcceptedTypes = case MochiReq:get_header_value("Accept") of
3076
924
        undefined       -> [];
3077
925
        AcceptHeader    -> string:tokens(AcceptHeader, ", ")
3078
926
    end,
3079
927
    case lists:member("application/json", AcceptedTypes) of
3080
928
        true  -> "application/json";
3081
929
        false -> "text/plain; charset=utf-8"
3082
930
    end.
3083
931
3084
932
server_header() ->
3085
933
    [{"Server", "CouchDB/" ++ couch_server:get_version() ++
3086
934
                " (Erlang OTP/" ++ erlang:system_info(otp_release) ++ ")"}].
3087
935
3088
936
3089
937
-record(mp, {boundary, buffer, data_fun, callback}).
3090
938
3091
939
3092
940
parse_multipart_request(ContentType, DataFun, Callback) ->
3093
941
    Boundary0 = iolist_to_binary(get_boundary(ContentType)),
3094
942
    Boundary = <<"\r\n--", Boundary0/binary>>,
3095
943
    Mp = #mp{boundary= Boundary,
3096
944
            buffer= <<>>,
3097
945
            data_fun=DataFun,
3098
946
            callback=Callback},
3099
947
    {Mp2, _NilCallback} = read_until(Mp, <<"--", Boundary0/binary>>,
3100
948
        fun nil_callback/1),
3101
949
    #mp{buffer=Buffer, data_fun=DataFun2, callback=Callback2} =
3102
950
            parse_part_header(Mp2),
3103
951
    {Buffer, DataFun2, Callback2}.
3104
952
3105
953
nil_callback(_Data)->
3106
954
    fun nil_callback/1.
3107
955
3108
956
get_boundary({"multipart/" ++ _, Opts}) ->
3109
957
    case couch_util:get_value("boundary", Opts) of
3110
958
        S when is_list(S) ->
3111
959
            S
3112
960
    end;
3113
961
get_boundary(ContentType) ->
3114
962
    {"multipart/" ++ _ , Opts} = mochiweb_util:parse_header(ContentType),
3115
963
    get_boundary({"multipart/", Opts}).
3116
964
    
3117
965
3118
966
3119
967
split_header(<<>>) ->
3120
968
    [];
3121
969
split_header(Line) ->
3122
970
    {Name, [$: | Value]} = lists:splitwith(fun (C) -> C =/= $: end,
3123
971
                                           binary_to_list(Line)),
3124
972
    [{string:to_lower(string:strip(Name)),
3125
973
     mochiweb_util:parse_header(Value)}].
3126
974
3127
975
read_until(#mp{data_fun=DataFun, buffer=Buffer}=Mp, Pattern, Callback) ->
3128
976
    case find_in_binary(Pattern, Buffer) of
3129
977
    not_found ->
3130
978
        Callback2 = Callback(Buffer),
3131
979
        {Buffer2, DataFun2} = DataFun(),
3132
980
        Buffer3 = iolist_to_binary(Buffer2),
3133
981
        read_until(Mp#mp{data_fun=DataFun2,buffer=Buffer3}, Pattern, Callback2);
3134
982
    {partial, 0} ->
3135
983
        {NewData, DataFun2} = DataFun(),
3136
984
        read_until(Mp#mp{data_fun=DataFun2,
3137
985
                buffer= iolist_to_binary([Buffer,NewData])},
3138
986
                Pattern, Callback);
3139
987
    {partial, Skip} ->
3140
988
        <<DataChunk:Skip/binary, Rest/binary>> = Buffer,
3141
989
        Callback2 = Callback(DataChunk),
3142
990
        {NewData, DataFun2} = DataFun(),
3143
991
        read_until(Mp#mp{data_fun=DataFun2,
3144
992
                buffer= iolist_to_binary([Rest | NewData])},
3145
993
                Pattern, Callback2);
3146
994
    {exact, 0} ->
3147
995
        PatternLen = size(Pattern),
3148
996
        <<_:PatternLen/binary, Rest/binary>> = Buffer,
3149
997
        {Mp#mp{buffer= Rest}, Callback};
3150
998
    {exact, Skip} ->
3151
999
        PatternLen = size(Pattern),
3152
1000
        <<DataChunk:Skip/binary, _:PatternLen/binary, Rest/binary>> = Buffer,
3153
1001
        Callback2 = Callback(DataChunk),
3154
1002
        {Mp#mp{buffer= Rest}, Callback2}
3155
1003
    end.
3156
1004
3157
1005
3158
1006
parse_part_header(#mp{callback=UserCallBack}=Mp) ->
3159
1007
    {Mp2, AccCallback} = read_until(Mp, <<"\r\n\r\n">>,
3160
1008
            fun(Next) -> acc_callback(Next, []) end),
3161
1009
    HeaderData = AccCallback(get_data),
3162
1010
    
3163
1011
    Headers =
3164
1012
    lists:foldl(fun(Line, Acc) ->
3165
1013
            split_header(Line) ++ Acc
3166
1014
        end, [], re:split(HeaderData,<<"\r\n">>, [])),
3167
1015
    NextCallback = UserCallBack({headers, Headers}),
3168
1016
    parse_part_body(Mp2#mp{callback=NextCallback}).
3169
1017
3170
1018
parse_part_body(#mp{boundary=Prefix, callback=Callback}=Mp) ->
3171
1019
    {Mp2, WrappedCallback} = read_until(Mp, Prefix,
3172
1020
            fun(Data) -> body_callback_wrapper(Data, Callback) end),
3173
1021
    Callback2 = WrappedCallback(get_callback),
3174
1022
    Callback3 = Callback2(body_end),
3175
1023
    case check_for_last(Mp2#mp{callback=Callback3}) of
3176
1024
    {last, #mp{callback=Callback3}=Mp3} ->
3177
1025
        Mp3#mp{callback=Callback3(eof)};
3178
1026
    {more, Mp3} ->
3179
1027
        parse_part_header(Mp3)
3180
1028
    end.
3181
1029
3182
1030
acc_callback(get_data, Acc)->
3183
1031
    iolist_to_binary(lists:reverse(Acc));
3184
1032
acc_callback(Data, Acc)->
3185
1033
    fun(Next) -> acc_callback(Next, [Data | Acc]) end.
3186
1034
3187
1035
body_callback_wrapper(get_callback, Callback) ->
3188
1036
    Callback;
3189
1037
body_callback_wrapper(Data, Callback) ->
3190
1038
    Callback2 = Callback({body, Data}),
3191
1039
    fun(Next) -> body_callback_wrapper(Next, Callback2) end.
3192
1040
3193
1041
3194
1042
check_for_last(#mp{buffer=Buffer, data_fun=DataFun}=Mp) ->
3195
1043
    case Buffer of
3196
1044
    <<"--",_/binary>> -> {last, Mp};
3197
1045
    <<_, _, _/binary>> -> {more, Mp};
3198
1046
    _ -> % not long enough
3199
1047
        {Data, DataFun2} = DataFun(),
3200
1048
        check_for_last(Mp#mp{buffer= <<Buffer/binary, Data/binary>>,
3201
1049
                data_fun = DataFun2})
3202
1050
    end.
3203
1051
3204
1052
find_in_binary(B, Data) when size(B) > 0 ->
3205
1053
    case size(Data) - size(B) of
3206
1054
        Last when Last < 0 ->
3207
1055
            partial_find(B, Data, 0, size(Data));
3208
1056
        Last ->
3209
1057
            find_in_binary(B, size(B), Data, 0, Last)
3210
1058
    end.
3211
1059
3212
1060
find_in_binary(B, BS, D, N, Last) when N =< Last->
3213
1061
    case D of
3214
1062
        <<_:N/binary, B:BS/binary, _/binary>> ->
3215
1063
            {exact, N};
3216
1064
        _ ->
3217
1065
            find_in_binary(B, BS, D, 1 + N, Last)
3218
1066
    end;
3219
1067
find_in_binary(B, BS, D, N, Last) when N =:= 1 + Last ->
3220
1068
    partial_find(B, D, N, BS - 1).
3221
1069
3222
1070
partial_find(_B, _D, _N, 0) ->
3223
1071
    not_found;
3224
1072
partial_find(B, D, N, K) ->
3225
1073
    <<B1:K/binary, _/binary>> = B,
3226
1074
    case D of
3227
1075
        <<_Skip:N/binary, B1/binary>> ->
3228
1076
            {partial, N};
3229
1077
        _ ->
3230
1078
            partial_find(B, D, 1 + N, K - 1)
3231
1079
    end.
3232
1080
3233
1081
3234
1082
0
3235
=== removed directory '.pc/logrotate_as_couchdb.patch'
3236
=== removed directory '.pc/logrotate_as_couchdb.patch/etc'
3237
=== removed directory '.pc/logrotate_as_couchdb.patch/etc/logrotate.d'
3238
=== removed file '.pc/logrotate_as_couchdb.patch/etc/logrotate.d/couchdb.tpl.in'
3239
--- .pc/logrotate_as_couchdb.patch/etc/logrotate.d/couchdb.tpl.in	2012-11-18 12:24:24 +0000
3240
+++ .pc/logrotate_as_couchdb.patch/etc/logrotate.d/couchdb.tpl.in	1970-01-01 00:00:00 +0000
3241
@@ -1,9 +0,0 @@
3242
1
%localstatelogdir%/*.log {
3243
2
       weekly
3244
3
       rotate 10
3245
4
       copytruncate
3246
5
       delaycompress
3247
6
       compress
3248
7
       notifempty
3249
8
       missingok
3250
9
}
3251
10
0
3252
=== removed directory '.pc/wait_for_couchdb_stop.patch'
3253
=== removed directory '.pc/wait_for_couchdb_stop.patch/etc'
3254
=== removed directory '.pc/wait_for_couchdb_stop.patch/etc/init'
3255
=== removed file '.pc/wait_for_couchdb_stop.patch/etc/init/couchdb.tpl.in'
3256
--- .pc/wait_for_couchdb_stop.patch/etc/init/couchdb.tpl.in	2012-11-18 12:24:24 +0000
3257
+++ .pc/wait_for_couchdb_stop.patch/etc/init/couchdb.tpl.in	1970-01-01 00:00:00 +0000
3258
@@ -1,157 +0,0 @@
3259
1
#!/bin/sh -e
3260
2
3261
3
# Licensed under the Apache License, Version 2.0 (the "License"); you may not
3262
4
# use this file except in compliance with the License. You may obtain a copy of
3263
5
# the License at
3264
6
#
3265
7
#   http://www.apache.org/licenses/LICENSE-2.0
3266
8
#
3267
9
# Unless required by applicable law or agreed to in writing, software
3268
10
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
3269
11
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
3270
12
# License for the specific language governing permissions and limitations under
3271
13
# the License.
3272
14
3273
15
### BEGIN INIT INFO
3274
16
# Provides:          couchdb
3275
17
# Required-Start:    $local_fs $remote_fs
3276
18
# Required-Stop:     $local_fs $remote_fs
3277
19
# Default-Start:     2 3 4 5
3278
20
# Default-Stop:      0 1 6
3279
21
# Short-Description: Apache CouchDB init script
3280
22
# Description:       Apache CouchDB init script for the database server.
3281
23
### END INIT INFO
3282
24
3283
25
SCRIPT_OK=0
3284
26
SCRIPT_ERROR=1
3285
27
3286
28
DESCRIPTION="database server"
3287
29
NAME=couchdb
3288
30
SCRIPT_NAME=`basename $0`
3289
31
COUCHDB=%bindir%/%couchdb_command_name%
3290
32
CONFIGURATION_FILE=%sysconfdir%/default/couchdb
3291
33
RUN_DIR=%localstaterundir%
3292
34
LSB_LIBRARY=/lib/lsb/init-functions
3293
35
3294
36
if test ! -x $COUCHDB; then
3295
37
    exit $SCRIPT_ERROR
3296
38
fi
3297
39
3298
40
if test -r $CONFIGURATION_FILE; then
3299
41
    . $CONFIGURATION_FILE
3300
42
fi
3301
43
3302
44
log_daemon_msg () {
3303
45
    # Dummy function to be replaced by LSB library.
3304
46
3305
47
    echo $@
3306
48
}
3307
49
3308
50
log_end_msg () {
3309
51
    # Dummy function to be replaced by LSB library.
3310
52
3311
53
    if test "$1" != "0"; then
3312
54
      echo "Error with $DESCRIPTION: $NAME"
3313
55
    fi
3314
56
    return $1
3315
57
}
3316
58
3317
59
if test -r $LSB_LIBRARY; then
3318
60
    . $LSB_LIBRARY
3319
61
fi
3320
62
3321
63
run_command () {
3322
64
    command="$1"
3323
65
    if test -n "$COUCHDB_OPTIONS"; then
3324
66
        command="$command $COUCHDB_OPTIONS"
3325
67
    fi
3326
68
    if test -n "$COUCHDB_USER"; then
3327
69
        if su $COUCHDB_USER -c "$command"; then
3328
70
            return $SCRIPT_OK
3329
71
        else
3330
72
            return $SCRIPT_ERROR
3331
73
        fi
3332
74
    else
3333
75
        if $command; then
3334
76
            return $SCRIPT_OK
3335
77
        else
3336
78
            return $SCRIPT_ERROR
3337
79
        fi
3338
80
    fi
3339
81
}
3340
82
3341
83
start_couchdb () {
3342
84
    # Start Apache CouchDB as a background process.
3343
85
3344
86
    test -e "$RUN_DIR" || \
3345
87
        install -m 755 -o "$COUCHDB_USER" -g "$COUCHDB_USER" -d "$RUN_DIR"
3346
88
    command="$COUCHDB -b"
3347
89
    if test -n "$COUCHDB_STDOUT_FILE"; then
3348
90
        command="$command -o $COUCHDB_STDOUT_FILE"
3349
91
    fi
3350
92
    if test -n "$COUCHDB_STDERR_FILE"; then
3351
93
        command="$command -e $COUCHDB_STDERR_FILE"
3352
94
    fi
3353
95
    if test -n "$COUCHDB_RESPAWN_TIMEOUT"; then
3354
96
        command="$command -r $COUCHDB_RESPAWN_TIMEOUT"
3355
97
    fi
3356
98
    run_command "$command" > /dev/null
3357
99
}
3358
100
3359
101
stop_couchdb () {
3360
102
    # Stop the running Apache CouchDB process.
3361
103
3362
104
    run_command "$COUCHDB -d" > /dev/null
3363
105
}
3364
106
3365
107
display_status () {
3366
108
    # Display the status of the running Apache CouchDB process.
3367
109
3368
110
    run_command "$COUCHDB -s"
3369
111
}
3370
112
3371
113
parse_script_option_list () {
3372
114
    # Parse arguments passed to the script and take appropriate action.
3373
115
3374
116
    case "$1" in
3375
117
        start)
3376
118
            log_daemon_msg "Starting $DESCRIPTION" $NAME
3377
119
            if start_couchdb; then
3378
120
                log_end_msg $SCRIPT_OK
3379
121
            else
3380
122
                log_end_msg $SCRIPT_ERROR
3381
123
            fi
3382
124
            ;;
3383
125
        stop)
3384
126
            log_daemon_msg "Stopping $DESCRIPTION" $NAME
3385
127
            if stop_couchdb; then
3386
128
                log_end_msg $SCRIPT_OK
3387
129
            else
3388
130
                log_end_msg $SCRIPT_ERROR
3389
131
            fi
3390
132
            ;;
3391
133
        restart|force-reload)
3392
134
            log_daemon_msg "Restarting $DESCRIPTION" $NAME
3393
135
            if stop_couchdb; then
3394
136
                if start_couchdb; then
3395
137
                    log_end_msg $SCRIPT_OK
3396
138
                else
3397
139
                    log_end_msg $SCRIPT_ERROR
3398
140
                fi
3399
141
            else
3400
142
                log_end_msg $SCRIPT_ERROR
3401
143
            fi
3402
144
            ;;
3403
145
        status)
3404
146
            display_status
3405
147
            ;;
3406
148
        *)
3407
149
            cat << EOF >&2
3408
150
Usage: $SCRIPT_NAME {start|stop|restart|force-reload|status}
3409
151
EOF
3410
152
            exit $SCRIPT_ERROR
3411
153
            ;;
3412
154
    esac
3413
155
}
3414
156
3415
157
parse_script_option_list $@
3416
158
0
3417
=== modified file 'AUTHORS'
3418
--- AUTHORS	2012-07-30 22:49:59 +0000
3419
+++ AUTHORS	2013-08-30 22:06:57 +0000
3420
@@ -20,5 +20,11 @@
3421
20
 * Bob Dionne <bitdiddle@apache.org>
20
 * Bob Dionne <bitdiddle@apache.org>
3422
21
 * Dave Cottlehuber <dch@apache.org>
21
 * Dave Cottlehuber <dch@apache.org>
3423
22
 * Jason Smith <jhs@apache.org>
22
 * Jason Smith <jhs@apache.org>
3424
23
 * Joan Touzet <joant@ieee.org>
3425
24
 * Dale Harvey <dale@apache.org>
3426
25
 * Dirkjan Ochtman <djc@apache.org>
3427
26
 * Alexander Shorin <kxepal@apache.org>
3428
27
 * Garren Smith <garren@apache.org>
3429
28
 * Sue Lockwood <deathbear@apache.org>
3430
23
29
3431
24
For a list of other credits see the `THANKS` file.
30
For a list of other credits see the `THANKS` file.
3432
25
31
3433
=== modified file 'BUGS'
3434
--- BUGS	2009-04-14 16:32:45 +0000
3435
+++ BUGS	2013-08-30 22:06:57 +0000
3436
@@ -1,6 +1,8 @@
3437
1
Apache CouchDB BUGS
1
Apache CouchDB BUGS
3438
2
===================
2
===================
3439
3
3
3443
4
Please see the [documentation][1] on how to report bugs with Apache CouchDB.
4
Visit our issue tracker:
3444
5
5
3445
6
[1] http://couchdb.apache.org/community/issues.html
6
    https://issues.apache.org/jira/browse/CouchDB
3446
7
3447
8
You can use this to report bugs, request features, or suggest enhancements.
3448
7
9
3449
=== removed file 'CHANGES'
3450
--- CHANGES	2012-07-30 22:49:59 +0000
3451
+++ CHANGES	1970-01-01 00:00:00 +0000
3452
@@ -1,874 +0,0 @@
3453
1
Apache CouchDB CHANGES
3454
2
======================
3455
3
3456
4
Version 1.2.0
3457
5
-------------
3458
6
3459
7
Authentication:
3460
8
3461
9
 * Fix use of OAuth with VHosts and URL rewriting.
3462
10
 * OAuth secrets can now be stored in the users system database
3463
11
   as an alternative to key value pairs in the .ini configuration.
3464
12
   By default this is disabled (secrets are stored in the .ini)
3465
13
   but can be enabled via the .ini configuration key `use_users_db`
3466
14
   in the `couch_httpd_oauth` section.
3467
15
 * Documents in the _users database are no longer publicly
3468
16
   readable.
3469
17
 * Confidential information in the _replication database is no
3470
18
   longer publicly readable.
3471
19
 * Password hashes are now calculated by CouchDB. Clients are no
3472
20
   longer required to do this manually.
3473
21
 * Cookies used for authentication can be made persistent by enabling
3474
22
   the .ini configuration key `allow_persistent_cookies' in the
3475
23
   `couch_httpd_auth` section.
3476
24
3477
25
Build System:
3478
26
3479
27
 * cURL is no longer required to build CouchDB as it is only
3480
28
   used by the command line JS test runner. If cURL is available
3481
29
   when building CouchJS you can enable the HTTP bindings by
3482
30
   passing -H on the command line.
3483
31
 * Temporarily made `make check` pass with R15B. A more thorough
3484
32
   fix is in the works (COUCHDB-1424).
3485
33
 * Fixed --with-js-include and --with-js-lib options.
3486
34
 * Added --with-js-lib-name option.
3487
35
3488
36
HTTP Interface:
3489
37
3490
38
 * Added a native JSON parser.
3491
39
 * The _active_tasks API now offers more granular fields. Each
3492
40
   task type is now able to expose different properties.
3493
41
 * Added built-in changes feed filter `_view`.
3494
42
 * Fixes to the `_changes` feed heartbeat option which caused
3495
43
   heartbeats to be missed when used with a filter. This caused
3496
44
   timeouts of continuous pull replications with a filter.
3497
45
 * Properly restart the SSL socket on configuration changes.
3498
46
3499
47
Replicator:
3500
48
3501
49
 * A new replicator implementation. It offers more performance and
3502
50
   configuration options.
3503
51
 * Passing non-string values to query_params is now a 400 bad
3504
52
   request. This is to reduce the surprise that all parameters
3505
53
   are converted to strings internally.
3506
54
 * Added optional field `since_seq` to replication objects/documents.
3507
55
   It allows to bootstrap a replication from a specific source sequence
3508
56
   number.
3509
57
 * Simpler replication cancellation. In addition to the current method,
3510
58
   replications can now be canceled by specifying the replication ID
3511
59
   instead of the original replication object/document.
3512
60
3513
61
Storage System:
3514
62
3515
63
 * Added optional database and view index file compression (using Google's
3516
64
   snappy or zlib's deflate). This feature is enabled by default, but it
3517
65
   can be disabled by adapting local.ini accordingly. The on-disk format
3518
66
   is upgraded on compaction and new DB/view creation to support this.
3519
67
 * Several performance improvements, most notably regarding database writes
3520
68
   and view indexing.
3521
69
 * Computation of the size of the latest MVCC snapshot data and all its
3522
70
   supporting metadata, both for database and view index files. This
3523
71
   information is exposed as the `data_size` attribute in the database and
3524
72
   view group information URIs.
3525
73
 * The size of the buffers used for database and view compaction is now
3526
74
   configurable.
3527
75
 * Added support for automatic database and view compaction. This feature
3528
76
   is disabled by default, but it can be enabled via the .ini configuration.
3529
77
 * Performance improvements for the built-in changes feed filters `_doc_ids`
3530
78
   and `_design'.
3531
79
3532
80
View Server:
3533
81
3534
82
 * Add CoffeeScript (http://coffeescript.org/) as a first class view server
3535
83
   language.
3536
84
 * Fixed old index file descriptor leaks after a view cleanup.
3537
85
 * The requested_path property keeps the pre-rewrite path even when no VHost
3538
86
   configuration is matched.
3539
87
 * Fixed incorrect reduce query results when using pagination parameters.
3540
88
 * Made icu_driver work with Erlang R15B and later.
3541
89
 * Avoid invalidating view indexes when running out of file descriptors.
3542
90
3543
91
OAuth:
3544
92
3545
93
 * Updated bundled erlang_oauth library to the latest version.
3546
94
3547
95
Futon:
3548
96
3549
97
 * The `Status` screen (active tasks) now displays two new task status
3550
98
   fields: `Started on` and `Updated on`.
3551
99
 * Futon remembers view code every time it is saved, allowing to save an
3552
100
   edit that amounts to a revert.
3553
101
3554
102
Log System:
3555
103
3556
104
 * Log correct stacktrace in all cases.
3557
105
 * Improvements to log messages for file-related errors.
3558
106
3559
107
Version 1.1.1
3560
108
-------------
3561
109
3562
110
* Support SpiderMonkey 1.8.5
3563
111
* Add configurable maximum to the number of bytes returned by _log.
3564
112
* Allow CommonJS modules to be an empty string.
3565
113
* Bump minimum Erlang version to R13B02.
3566
114
* Do not run deleted validate_doc_update functions.
3567
115
* ETags for views include current sequence if include_docs=true.
3568
116
* Fix bug where duplicates can appear in _changes feed.
3569
117
* Fix bug where update handlers break after conflict resolution.
3570
118
* Fix bug with _replicator where include "filter" could crash couch.
3571
119
* Fix crashes when compacting large views.
3572
120
* Fix file descriptor leak in _log
3573
121
* Fix missing revisions in _changes?style=all_docs.
3574
122
* Improve handling of compaction at max_dbs_open limit.
3575
123
* JSONP responses now send "text/javascript" for Content-Type.
3576
124
* Link to ICU 4.2 on Windows.
3577
125
* Permit forward slashes in path to update functions.
3578
126
* Reap couchjs processes that hit reduce_overflow error.
3579
127
* Status code can be specified in update handlers.
3580
128
* Support provides() in show functions.
3581
129
* _view_cleanup when ddoc has no views now removes all index files.
3582
130
* max_replication_retry_count now supports "infinity".
3583
131
* Fix replication crash when source database has a document with empty ID.
3584
132
* Fix deadlock when assigning couchjs processes to serve requests.
3585
133
* Fixes to the document multipart PUT API.
3586
134
* Fixes regarding file descriptor leaks for databases with views.
3587
135
3588
136
Version 1.1.0
3589
137
-------------
3590
138
3591
139
All CHANGES for 1.0.2 and 1.0.3 also apply to 1.1.0.
3592
140
3593
141
HTTP Interface:
3594
142
3595
143
 * Native SSL support.
3596
144
 * Added support for HTTP range requests for attachments.
3597
145
 * Added built-in filters for `_changes`: `_doc_ids` and `_design`.
3598
146
 * Added configuration option for TCP_NODELAY aka "Nagle".
3599
147
 * Allow POSTing arguments to `_changes`.
3600
148
 * Allow `keys` parameter for GET requests to views.
3601
149
 * Allow wildcards in vhosts definitions.
3602
150
 * More granular ETag support for views.
3603
151
 * More flexible URL rewriter.
3604
152
 * Added support for recognizing "Q values" and media parameters in
3605
153
   HTTP Accept headers.
3606
154
 * Validate doc ids that come from a PUT to a URL.
3607
155
3608
156
Externals:
3609
157
3610
158
 * Added OS Process module to manage daemons outside of CouchDB.
3611
159
 * Added HTTP Proxy handler for more scalable externals.
3612
160
3613
161
Replicator:
3614
162
3615
163
 * Added `_replicator` database to manage replications.
3616
164
 * Fixed issues when an endpoint is a remote database accessible via SSL.
3617
165
 * Added support for continuous by-doc-IDs replication.
3618
166
 * Fix issue where revision info was omitted when replicating attachments.
3619
167
 * Integrity of attachment replication is now verified by MD5.
3620
168
3621
169
Storage System:
3622
170
3623
171
 * Multiple micro-optimizations when reading data.
3624
172
3625
173
View Server:
3626
174
3627
175
 * Added CommonJS support to map functions.
3628
176
 * Added `stale=update_after` query option that triggers a view update after
3629
177
   returning a `stale=ok` response.
3630
178
 * Warn about empty result caused by `startkey` and `endkey` limiting.
3631
179
 * Built-in reduce function `_sum` now accepts lists of integers as input.
3632
180
 * Added view query aliases start_key, end_key, start_key_doc_id and
3633
181
   end_key_doc_id.
3634
182
3635
183
Futon:
3636
184
3637
185
 * Added a "change password"-feature to Futon.
3638
186
3639
187
URL Rewriter & Vhosts:
3640
188
3641
189
 * Fix for variable substituion
3642
190
3643
191
Version 1.0.3
3644
192
-------------
3645
193
3646
194
General:
3647
195
3648
196
 * Fixed compatibility issues with Erlang R14B02.
3649
197
3650
198
HTTP Interface:
3651
199
3652
200
 * Fix bug that allows invalid UTF-8 after valid escapes.
3653
201
 * The query parameter `include_docs` now honors the parameter `conflicts`.
3654
202
   This applies to queries against map views, _all_docs and _changes.
3655
203
 * Added support for inclusive_end with reduce views.
3656
204
3657
205
Storage System:
3658
206
3659
207
 * More performant queries against _changes and _all_docs when using the
3660
208
  `include_docs` parameter.
3661
209
3662
210
Replicator:
3663
211
3664
212
 * Enabled replication over IPv6.
3665
213
 * Fixed for crashes in continuous and filtered changes feeds.
3666
214
 * Fixed error when restarting replications in OTP R14B02.
3667
215
 * Upgrade ibrowse to version 2.2.0.
3668
216
 * Fixed bug when using a filter and a limit of 1.
3669
217
3670
218
Security:
3671
219
3672
220
 * Fixed OAuth signature computation in OTP R14B02.
3673
221
 * Handle passwords with : in them.
3674
222
3675
223
Futon:
3676
224
3677
225
 * Made compatible with jQuery 1.5.x.
3678
226
3679
227
Etap Test Suite:
3680
228
3681
229
 * Etap tests no longer require use of port 5984. They now use a randomly
3682
230
   selected port so they won't clash with a running CouchDB.
3683
231
3684
232
Windows:
3685
233
3686
234
 * Windows builds now require ICU >= 4.4.0 and Erlang >= R14B03. See
3687
235
   COUCHDB-1152, and COUCHDB-963 + OTP-9139 for more information.
3688
236
3689
237
Version 1.0.2
3690
238
-------------
3691
239
3692
240
Futon:
3693
241
3694
242
 * Make test suite work with Safari and Chrome.
3695
243
 * Fixed animated progress spinner.
3696
244
 * Fix raw view document link due to overzealous URI encoding.
3697
245
 * Spell javascript correctly in loadScript(uri).
3698
246
3699
247
Storage System:
3700
248
3701
249
 * Fix leaking file handles after compacting databases and views.
3702
250
 * Fix databases forgetting their validation function after compaction.
3703
251
 * Fix occasional timeout errors after successfully compacting large databases.
3704
252
 * Fix ocassional error when writing to a database that has just been compacted.
3705
253
 * Fix occasional timeout errors on systems with slow or heavily loaded IO.
3706
254
 * Fix for OOME when compactions include documents with many conflicts.
3707
255
 * Fix for missing attachment compression when MIME types included parameters.
3708
256
 * Preserve purge metadata during compaction to avoid spurious view rebuilds.
3709
257
 * Fix spurious conflicts introduced when uploading an attachment after
3710
258
   a doc has been in a conflict. See COUCHDB-902 for details.
3711
259
 * Fix for frequently edited documents in multi-master deployments being
3712
260
   duplicated in _changes and _all_docs.  See COUCHDDB-968 for details on how
3713
261
   to repair.
3714
262
 * Significantly higher read and write throughput against database and
3715
263
   view index files.
3716
264
3717
265
Log System:
3718
266
3719
267
 * Reduce lengthy stack traces.
3720
268
 * Allow logging of native <xml> types.
3721
269
3722
270
HTTP Interface:
3723
271
3724
272
 * Allow reduce=false parameter in map-only views.
3725
273
 * Fix parsing of Accept headers.
3726
274
 * Fix for multipart GET APIs when an attachment was created during a
3727
275
   local-local replication. See COUCHDB-1022 for details.
3728
276
3729
277
Replicator:
3730
278
3731
279
 * Updated ibrowse library to 2.1.2 fixing numerous replication issues.
3732
280
 * Make sure that the replicator respects HTTP settings defined in the config.
3733
281
 * Fix error when the ibrowse connection closes unexpectedly.
3734
282
 * Fix authenticated replication (with HTTP basic auth) of design documents
3735
283
   with attachments.
3736
284
 * Various fixes to make replication more resilient for edge-cases.
3737
285
3738
286
View Server:
3739
287
3740
288
 * Don't trigger view updates when requesting `_design/doc/_info`.
3741
289
 * Fix for circular references in CommonJS requires.
3742
290
 * Made isArray() function available to functions executed in the query server.
3743
291
 * Documents are now sealed before being passed to map functions.
3744
292
 * Force view compaction failure when duplicated document data exists. When
3745
293
   this error is seen in the logs users should rebuild their views from
3746
294
   scratch to fix the issue. See COUCHDB-999 for details.
3747
295
3748
296
Version 1.0.1
3749
297
-------------
3750
298
3751
299
Storage System:
3752
300
3753
301
  * Fix data corruption bug COUCHDB-844. Please see
3754
302
    http://couchdb.apache.org/notice/1.0.1.html for details.
3755
303
3756
304
Replicator:
3757
305
3758
306
  * Added support for replication via an HTTP/HTTPS proxy.
3759
307
  * Fix pull replication of attachments from 0.11 to 1.0.x.
3760
308
  * Make the _changes feed work with non-integer seqnums.
3761
309
3762
310
HTTP Interface:
3763
311
3764
312
  * Expose `committed_update_seq` for monitoring purposes.
3765
313
  * Show fields saved along with _deleted=true. Allows for auditing of deletes.
3766
314
  * More robust Accept-header detection.
3767
315
3768
316
Authentication:
3769
317
3770
318
  * Enable basic-auth popup when required to access the server, to prevent
3771
319
    people from getting locked out.
3772
320
3773
321
Futon:
3774
322
3775
323
  * User interface element for querying stale (cached) views.
3776
324
3777
325
Build and System Integration:
3778
326
3779
327
  * Included additional source files for distribution.
3780
328
3781
329
Version 1.0.0
3782
330
-------------
3783
331
3784
332
Security:
3785
333
3786
334
 * Added authentication caching, to avoid repeated opening and closing of the
3787
335
   users database for each request requiring authentication.
3788
336
3789
337
Storage System:
3790
338
3791
339
 * Small optimization for reordering result lists.
3792
340
 * More efficient header commits.
3793
341
 * Use O_APPEND to save lseeks.
3794
342
 * Faster implementation of pread_iolist(). Further improves performance on
3795
343
   concurrent reads.
3796
344
3797
345
View Server:
3798
346
3799
347
 * Faster default view collation.
3800
348
 * Added option to include update_seq in view responses.
3801
349
3802
350
Version 0.11.2
3803
351
--------------
3804
352
3805
353
Replicator:
3806
354
3807
355
  * Fix bug when pushing design docs by non-admins, which was hanging the
3808
356
    replicator for no good reason.
3809
357
  * Fix bug when pulling design documents from a source that requires
3810
358
    basic-auth.
3811
359
3812
360
HTTP Interface:
3813
361
3814
362
  * Better error messages on invalid URL requests.
3815
363
3816
364
Authentication:
3817
365
3818
366
  * User documents can now be deleted by admins or the user.
3819
367
3820
368
Security:
3821
369
3822
370
  * Avoid potential DOS attack by guarding all creation of atoms.
3823
371
3824
372
Futon:
3825
373
3826
374
  * Add some Futon files that were missing from the Makefile.
3827
375
3828
376
Version 0.11.1
3829
377
--------------
3830
378
3831
379
HTTP Interface:
3832
380
3833
381
 * Mask passwords in active tasks and logging.
3834
382
 * Update mochijson2 to allow output of BigNums not in float form.
3835
383
 * Added support for X-HTTP-METHOD-OVERRIDE.
3836
384
 * Better error message for database names.
3837
385
 * Disable jsonp by default.
3838
386
 * Accept gzip encoded standalone attachments.
3839
387
 * Made max_concurrent_connections configurable.
3840
388
 * Made changes API more robust.
3841
389
 * Send newly generated document rev to callers of an update function.
3842
390
3843
391
Futon:
3844
392
3845
393
 * Use "expando links" for over-long document values in Futon.
3846
394
 * Added continuous replication option.
3847
395
 * Added option to replicating test results anonymously to a community
3848
396
   CouchDB instance.
3849
397
 * Allow creation and deletion of config entries.
3850
398
 * Fixed display issues with doc ids that have escaped characters.
3851
399
 * Fixed various UI issues.
3852
400
3853
401
Build and System Integration:
3854
402
3855
403
 * Output of `couchdb --help` has been improved.
3856
404
 * Fixed compatibility with the Erlang R14 series.
3857
405
 * Fixed warnings on Linux builds.
3858
406
 * Fixed build error when aclocal needs to be called during the build.
3859
407
 * Require ICU 4.3.1.
3860
408
 * Fixed compatibility with Solaris.
3861
409
3862
410
Security:
3863
411
3864
412
 * Added authentication redirect URL to log in clients.
3865
413
 * Fixed query parameter encoding issue in oauth.js.
3866
414
 * Made authentication timeout configurable.
3867
415
 * Temporary views are now admin-only resources.
3868
416
3869
417
Storage System:
3870
418
3871
419
 * Don't require a revpos for attachment stubs.
3872
420
 * Added checking to ensure when a revpos is sent with an attachment stub,
3873
421
   it's correct.
3874
422
 * Make file deletions async to avoid pauses during compaction and db
3875
423
   deletion.
3876
424
 * Fixed for wrong offset when writing headers and converting them to blocks,
3877
425
   only triggered when header is larger than 4k.
3878
426
 * Preserve _revs_limit and instance_start_time after compaction.
3879
427
3880
428
Configuration System:
3881
429
3882
430
 * Fixed timeout with large .ini files.
3883
431
3884
432
JavaScript Clients:
3885
433
3886
434
 * Added tests for couch.js and jquery.couch.js
3887
435
 * Added changes handler to jquery.couch.js.
3888
436
 * Added cache busting to jquery.couch.js if the user agent is msie.
3889
437
 * Added support for multi-document-fetch (via _all_docs) to jquery.couch.js.
3890
438
 * Added attachment versioning to jquery.couch.js.
3891
439
 * Added option to control ensure_full_commit to jquery.couch.js.
3892
440
 * Added list functionality to jquery.couch.js.
3893
441
 * Fixed issues where bulkSave() wasn't sending a POST body.
3894
442
3895
443
View Server:
3896
444
3897
445
 * Provide a UUID to update functions (and all other functions) that they can
3898
446
   use to create new docs.
3899
447
 * Upgrade CommonJS modules support to 1.1.1.
3900
448
 * Fixed erlang filter funs and normalize filter fun API.
3901
449
 * Fixed hang in view shutdown.
3902
450
3903
451
Log System:
3904
452
3905
453
 * Log HEAD requests as HEAD, not GET.
3906
454
 * Keep massive JSON blobs out of the error log.
3907
455
 * Fixed a timeout issue.
3908
456
3909
457
Replication System:
3910
458
3911
459
 * Refactored various internal APIs related to attachment streaming.
3912
460
 * Fixed hanging replication.
3913
461
 * Fixed keepalive issue.
3914
462
3915
463
URL Rewriter & Vhosts:
3916
464
3917
465
 * Allow more complex keys in rewriter.
3918
466
 * Allow global rewrites so system defaults are available in vhosts.
3919
467
 * Allow isolation of databases with vhosts.
3920
468
 * Fix issue with passing variables to query parameters.
3921
469
3922
470
Test Suite:
3923
471
3924
472
 * Made the test suite overall more reliable.
3925
473
3926
474
Version 0.11.0
3927
475
--------------
3928
476
3929
477
Security:
3930
478
3931
479
 * Fixed CVE-2010-0009: Apache CouchDB Timing Attack Vulnerability.
3932
480
 * Added default cookie-authentication and users database.
3933
481
 * Added Futon user interface for user signup and login.
3934
482
 * Added per-database reader access control lists.
3935
483
 * Added per-database security object for configuration data in validation
3936
484
   functions.
3937
485
 * Added proxy authentication handler
3938
486
3939
487
HTTP Interface:
3940
488
3941
489
 * Provide Content-MD5 header support for attachments.
3942
490
 * Added URL Rewriter handler.
3943
491
 * Added virtual host handling.
3944
492
3945
493
View Server:
3946
494
3947
495
 * Added optional 'raw' binary collation for faster view builds where Unicode
3948
496
   collation is not important.
3949
497
 * Improved view index build time by reducing ICU collation callouts.
3950
498
 * Improved view information objects.
3951
499
 * Bug fix for partial updates during view builds.
3952
500
 * Move query server to a design-doc based protocol.
3953
501
 * Use json2.js for JSON serialization for compatiblity with native JSON.
3954
502
 * Major refactoring of couchjs to lay the groundwork for disabling cURL
3955
503
   support. The new HTTP interaction acts like a synchronous XHR. Example usage
3956
504
   of the new system is in the JavaScript CLI test runner.
3957
505
3958
506
Replication:
3959
507
3960
508
 * Added option to implicitly create replication target databases.
3961
509
 * Avoid leaking file descriptors on automatic replication restarts.
3962
510
 * Added option to replicate a list of documents by id.
3963
511
 * Allow continuous replication to be cancelled.
3964
512
3965
513
Storage System:
3966
514
3967
515
 * Adds batching of multiple updating requests, to improve throughput with many
3968
516
   writers. Removed the now redundant couch_batch_save module.
3969
517
 * Adds configurable compression of attachments.
3970
518
3971
519
Runtime Statistics:
3972
520
3973
521
 * Statistics are now calculated for a moving window instead of non-overlapping
3974
522
   timeframes.
3975
523
 * Fixed a problem with statistics timers and system sleep.
3976
524
 * Moved statistic names to a term file in the priv directory.
3977
525
3978
526
Futon:
3979
527
3980
528
 * Added a button for view compaction.
3981
529
 * JSON strings are now displayed as-is in the document view, without the escaping of
3982
530
   new-lines and quotes. That dramatically improves readability of multi-line
3983
531
   strings.
3984
532
 * Same goes for editing of JSON string values. When a change to a field value is
3985
533
   submitted, and the value is not valid JSON it is assumed to be a string. This
3986
534
   improves editing of multi-line strings a lot.
3987
535
 * Hitting tab in textareas no longer moves focus to the next form field, but simply
3988
536
   inserts a tab character at the current caret position.
3989
537
 * Fixed some font declarations.
3990
538
3991
539
Build and System Integration:
3992
540
3993
541
 * Updated and improved source documentation.
3994
542
 * Fixed distribution preparation for building on Mac OS X.
3995
543
 * Added support for building a Windows installer as part of 'make dist'.
3996
544
 * Bug fix for building couch.app's module list.
3997
545
 * ETap tests are now run during make distcheck. This included a number of
3998
546
   updates to the build system to properly support VPATH builds.
3999
547
 * Gavin McDonald setup a build-bot instance. More info can be found at
4000
548
   http://ci.apache.org/buildbot.html
4001
549
4002
550
Version 0.10.1
4003
551
--------------
4004
552
4005
553
Replicator:
4006
554
4007
555
 * Stability enhancements regarding redirects, timeouts, OAuth.
4008
556
4009
557
Query Server:
4010
558
4011
559
 * Avoid process leaks
4012
560
 * Allow list and view to span languages
4013
561
4014
562
Stats:
4015
563
4016
564
 * Eliminate new process flood on system wake
4017
565
4018
566
Build and System Integration:
4019
567
4020
568
 * Test suite now works with the distcheck target.
4021
569
4022
570
Version 0.10.0
4023
571
--------------
4024
572
4025
573
Storage Format:
4026
574
4027
575
 * Add move headers with checksums to the end of database files for extra robust
4028
576
   storage and faster storage.
4029
577
4030
578
View Server:
4031
579
4032
580
 * Added native Erlang views for high-performance applications.
4033
581
4034
582
HTTP Interface:
4035
583
4036
584
 * Added optional cookie-based authentication handler.
4037
585
 * Added optional two-legged OAuth authentication handler.
4038
586
4039
587
Build and System Integration:
4040
588
4041
589
 * Changed `couchdb` script configuration options.
4042
590
 * Added default.d and local.d configuration directories to load sequence.
4043
591
4044
592
4045
593
Version 0.9.2
4046
594
-------------
4047
595
4048
596
Replication:
4049
597
4050
598
 * Fix replication with 0.10 servers initiated by an 0.9 server (COUCHDB-559).
4051
599
4052
600
Build and System Integration:
4053
601
4054
602
 * Remove branch callbacks to allow building couchjs against newer versions of
4055
603
   Spidermonkey.
4056
604
4057
605
Version 0.9.1
4058
606
-------------
4059
607
4060
608
Build and System Integration:
4061
609
4062
610
 * PID file directory is now created by the SysV/BSD daemon scripts.
4063
611
 * Fixed the environment variables shown by the configure script.
4064
612
 * Fixed the build instructions shown by the configure script.
4065
613
 * Updated ownership and permission advice in `README` for better security.
4066
614
4067
615
Configuration and stats system:
4068
616
4069
617
 * Corrected missing configuration file error message.
4070
618
 * Fixed incorrect recording of request time.
4071
619
4072
620
Database Core:
4073
621
4074
622
 * Document validation for underscore prefixed variables.
4075
623
 * Made attachment storage less sparse.
4076
624
 * Fixed problems when a database with delayed commits pending is considered
4077
625
   idle, and subject to losing changes when shutdown. (COUCHDB-334)
4078
626
4079
627
External Handlers:
4080
628
4081
629
 * Fix POST requests.
4082
630
4083
631
Futon:
4084
632
4085
633
 * Redirect when loading a deleted view URI from the cookie.
4086
634
4087
635
HTTP Interface:
4088
636
4089
637
 * Attachment requests respect the "rev" query-string parameter.
4090
638
4091
639
JavaScript View Server:
4092
640
4093
641
 * Useful JavaScript Error messages.
4094
642
4095
643
Replication:
4096
644
4097
645
 * Added support for Unicode characters transmitted as UTF-16 surrogate pairs.
4098
646
 * URL-encode attachment names when necessary.
4099
647
 * Pull specific revisions of an attachment, instead of just the latest one.
4100
648
 * Work around a rare chunk-merging problem in ibrowse.
4101
649
 * Work with documents containing Unicode characters outside the Basic
4102
650
   Multilingual Plane.
4103
651
4104
652
Version 0.9.0
4105
653
-------------
4106
654
4107
655
Futon Utility Client:
4108
656
4109
657
 * Added pagination to the database listing page.
4110
658
 * Implemented attachment uploading from the document page.
4111
659
 * Added page that shows the current configuration, and allows modification of
4112
660
   option values.
4113
661
 * Added a JSON "source view" for document display.
4114
662
 * JSON data in view rows is now syntax highlighted.
4115
663
 * Removed the use of an iframe for better integration with browser history and
4116
664
   bookmarking.
4117
665
 * Full database listing in the sidebar has been replaced by a short list of
4118
666
   recent databases.
4119
667
 * The view editor now allows selection of the view language if there is more
4120
668
   than one configured.
4121
669
 * Added links to go to the raw view or document URI.
4122
670
 * Added status page to display currently running tasks in CouchDB.
4123
671
 * JavaScript test suite split into multiple files.
4124
672
 * Pagination for reduce views.
4125
673
4126
674
Design Document Resource Paths:
4127
675
4128
676
 * Added httpd_design_handlers config section.
4129
677
 * Moved _view to httpd_design_handlers.
4130
678
 * Added ability to render documents as non-JSON content-types with _show and
4131
679
   _list functions, which are also httpd_design_handlers.
4132
680
4133
681
HTTP Interface:
4134
682
4135
683
 * Added client side UUIDs for idempotent document creation
4136
684
 * HTTP COPY for documents
4137
685
 * Streaming of chunked attachment PUTs to disk
4138
686
 * Remove negative count feature
4139
687
 * Add include_docs option for view queries
4140
688
 * Add multi-key view post for views
4141
689
 * Query parameter validation
4142
690
 * Use stale=ok to request potentially cached view index
4143
691
 * External query handler module for full-text or other indexers.
4144
692
 * Etags for attachments, views, shows and lists
4145
693
 * Show and list functions for rendering documents and views as developer
4146
694
   controlled content-types.
4147
695
 * Attachment names may use slashes to allow uploading of nested directories
4148
696
   (useful for static web hosting).
4149
697
 * Option for a view to run over design documents.
4150
698
 * Added newline to JSON responses. Closes bike-shed.
4151
699
4152
700
Replication:
4153
701
4154
702
 * Using ibrowse.
4155
703
 * Checkpoint replications so failures are less expensive.
4156
704
 * Automatically retry of failed replications.
4157
705
 * Stream attachments in pull-replication.
4158
706
4159
707
Database Core:
4160
708
4161
709
 * Faster B-tree implementation.
4162
710
 * Changed internal JSON term format.
4163
711
 * Improvements to Erlang VM interactions under heavy load.
4164
712
 * User context and administrator role.
4165
713
 * Update validations with design document validation functions.
4166
714
 * Document purge functionality.
4167
715
 * Ref-counting for database file handles.
4168
716
4169
717
Build and System Integration:
4170
718
4171
719
 * The `couchdb` script now supports system chainable configuration files.
4172
720
 * The Mac OS X daemon script now redirects STDOUT and STDERR like SysV/BSD.
4173
721
 * The build and system integration have been improved for portability.
4174
722
 * Added COUCHDB_OPTIONS to etc/default/couchdb file.
4175
723
 * Remove COUCHDB_INI_FILE and COUCHDB_PID_FILE from etc/default/couchdb file.
4176
724
 * Updated `configure.ac` to manually link `libm` for portability.
4177
725
 * Updated `configure.ac` to extended default library paths.
4178
726
 * Removed inets configuration files.
4179
727
 * Added command line test runner.
4180
728
 * Created dev target for make.
4181
729
4182
730
Configuration and stats system:
4183
731
4184
732
 * Separate default and local configuration files.
4185
733
 * HTTP interface for configuration changes.
4186
734
 * Statistics framework with HTTP query API.
4187
735
4188
736
Version 0.8.1-incubating
4189
737
------------------------
4190
738
4191
739
Database Core:
4192
740
4193
741
 * Fix for replication problems where the write queues can get backed up if the
4194
742
   writes aren't happening fast enough to keep up with the reads. For a large
4195
743
   replication, this can exhaust memory and crash, or slow down the machine
4196
744
   dramatically. The fix keeps only one document in the write queue at a time.
4197
745
 * Fix for databases sometimes incorrectly reporting that they contain 0
4198
746
   documents after compaction.
4199
747
 * CouchDB now uses ibrowse instead of inets for its internal HTTP client
4200
748
   implementation. This means better replication stability.
4201
749
4202
750
HTTP Interface:
4203
751
4204
752
 * Fix for chunked responses where chunks were always being split into multiple
4205
753
   TCP packets, which caused problems with the test suite under Safari, and in
4206
754
   some other cases.
4207
755
 * Fix for an invalid JSON response body being returned for some kinds of
4208
756
   views. (COUCHDB-84)
4209
757
 * Fix for connections not getting closed after rejecting a chunked request.
4210
758
   (COUCHDB-55)
4211
759
 * CouchDB can now be bound to IPv6 addresses.
4212
760
 * The HTTP `Server` header now contains the versions of CouchDB and Erlang.
4213
761
4214
762
JavaScript View Server:
4215
763
4216
764
 * Sealing of documents has been disabled due to an incompatibility with
4217
765
   SpiderMonkey 1.9.
4218
766
 * Improve error handling for undefined values emitted by map functions.
4219
767
   (COUCHDB-83)
4220
768
4221
769
Build and System Integration:
4222
770
4223
771
 * The `couchdb` script no longer uses `awk` for configuration checks as this
4224
772
   was causing portability problems.
4225
773
 * Updated `sudo` example in `README` to use the `-i` option, this fixes
4226
774
   problems when invoking from a directory the `couchdb` user cannot access.
4227
775
4228
776
Futon:
4229
777
4230
778
 * The view selector dropdown should now work in Opera and Internet Explorer
4231
779
   even when it includes optgroups for design documents. (COUCHDB-81)
4232
780
4233
781
Version 0.8.0-incubating
4234
782
------------------------
4235
783
4236
784
Database Core:
4237
785
4238
786
 * The view engine has been completely decoupled from the storage engine. Index
4239
787
   data is now stored in separate files, and the format of the main database
4240
788
   file has changed.
4241
789
 * Databases can now be compacted to reclaim space used for deleted documents
4242
790
   and old document revisions.
4243
791
 * Support for incremental map/reduce views has been added.
4244
792
 * To support map/reduce, the structure of design documents has changed. View
4245
793
   values are now JSON objects containing at least a `map` member, and
4246
794
   optionally a `reduce` member.
4247
795
 * View servers are now identified by name (for example `javascript`) instead of
4248
796
   by media type.
4249
797
 * Automatically generated document IDs are now based on proper UUID generation
4250
798
   using the crypto module.
4251
799
 * The field `content-type` in the JSON representation of attachments has been
4252
800
   renamed to `content_type` (underscore).
4253
801
4254
802
HTTP Interface:
4255
803
4256
804
 * CouchDB now uses MochiWeb instead of inets for the HTTP server
4257
805
   implementation. Among other things, this means that the extra configuration
4258
806
   files needed for inets (such as `couch_httpd.conf`) are no longer used.
4259
807
 * The HTTP interface now completely supports the `HEAD` method. (COUCHDB-3)
4260
808
 * Improved compliance of `Etag` handling with the HTTP specification.
4261
809
   (COUCHDB-13)
4262
810
 * Etags are no longer included in responses to document `GET` requests that
4263
811
   include query string parameters causing the JSON response to change without
4264
812
   the revision or the URI having changed.
4265
813
 * The bulk document update API has changed slightly on both the request and the
4266
814
   response side. In addition, bulk updates are now atomic.
4267
815
 * CouchDB now uses `TCP_NODELAY` to fix performance problems with persistent
4268
816
   connections on some platforms due to nagling.
4269
817
 * Including a `?descending=false` query string parameter in requests to views
4270
818
   no longer raises an error.
4271
819
 * Requests to unknown top-level reserved URLs (anything with a leading
4272
820
   underscore) now return a `unknown_private_path` error instead of the
4273
821
   confusing `illegal_database_name`.
4274
822
 * The Temporary view handling now expects a JSON request body, where the JSON
4275
823
   is an object with at least a `map` member, and optional `reduce` and
4276
824
   `language` members.
4277
825
 * Temporary views no longer determine the view server based on the Content-Type
4278
826
   header of the `POST` request, but rather by looking for a `language` member
4279
827
   in the JSON body of the request.
4280
828
 * The status code of responses to `DELETE` requests is now 200 to reflect that
4281
829
   that the deletion is performed synchronously.
4282
830
4283
831
JavaScript View Server:
4284
832
4285
833
 * SpiderMonkey is no longer included with CouchDB, but rather treated as a
4286
834
   normal external dependency. A simple C program (`_couchjs`) is provided that
4287
835
   links against an existing SpiderMonkey installation and uses the interpreter
4288
836
   embedding API.
4289
837
 * View functions using the default JavaScript view server can now do logging
4290
838
   using the global `log(message)` function. Log messages are directed into the
4291
839
   CouchDB log at `INFO` level. (COUCHDB-59)
4292
840
 * The global `map(key, value)` function made available to view code has been
4293
841
   renamed to `emit(key, value)`.
4294
842
 * Fixed handling of exceptions raised by view functions.
4295
843
4296
844
Build and System Integration:
4297
845
4298
846
 * CouchDB can automatically respawn following a server crash.
4299
847
 * Database server no longer refuses to start with a stale PID file.
4300
848
 * System logrotate configuration provided.
4301
849
 * Improved handling of ICU shared libraries.
4302
850
 * The `couchdb` script now automatically enables SMP support in Erlang.
4303
851
 * The `couchdb` and `couchjs` scripts have been improved for portability.
4304
852
 * The build and system integration have been improved for portability.
4305
853
4306
854
Futon:
4307
855
4308
856
 * When adding a field to a document, Futon now just adds a field with an
4309
857
   autogenerated name instead of prompting for the name with a dialog. The name
4310
858
   is automatically put into edit mode so that it can be changed immediately.
4311
859
 * Fields are now sorted alphabetically by name when a document is displayed.
4312
860
 * Futon can be used to create and update permanent views.
4313
861
 * The maximum number of rows to display per page on the database page can now
4314
862
   be adjusted.
4315
863
 * Futon now uses the XMLHTTPRequest API asynchronously to communicate with the
4316
864
   CouchDB HTTP server, so that most operations no longer block the browser.
4317
865
 * View results sorting can now be switched between ascending and descending by
4318
866
   clicking on the `Key` column header.
4319
867
 * Fixed a bug where documents that contained a `@` character could not be
4320
868
   viewed. (COUCHDB-12)
4321
869
 * The database page now provides a `Compact` button to trigger database
4322
870
   compaction. (COUCHDB-38)
4323
871
 * Fixed portential double encoding of document IDs and other URI segments in
4324
872
   many instances. (COUCHDB-39)
4325
873
 * Improved display of attachments.
4326
874
 * The JavaScript Shell has been removed due to unresolved licensing issues.
4327
875
0
4328
=== modified file 'DEVELOPERS'
4329
--- DEVELOPERS	2010-07-26 10:24:11 +0000
4330
+++ DEVELOPERS	2013-08-30 22:06:57 +0000
4331
@@ -1,6 +1,10 @@
4332
1
Apache CouchDB DEVELOPERS
1
Apache CouchDB DEVELOPERS
4333
2
=========================
2
=========================
4334
3
3
4335
4
Before you start here, read `INSTALL.Unix` (or `INSTALL.Windows`) and
4336
5
follow the setup instructions including the installation of all the
4337
6
listed dependencies for your system.
4338
7
4339
4
Only follow these instructions if you are building from a source checkout.
8
Only follow these instructions if you are building from a source checkout.
4340
5
9
4341
6
If you're unsure what this means, ignore this document.
10
If you're unsure what this means, ignore this document.
4342
@@ -10,30 +14,109 @@
4343
10
14
4344
11
You will need the following installed:
15
You will need the following installed:
4345
12
16
4346
17
 * GNU Libtool            (http://www.gnu.org/software/libtool/)
4347
13
 * GNU Automake (>=1.6.3) (http://www.gnu.org/software/automake/)
18
 * GNU Automake (>=1.6.3) (http://www.gnu.org/software/automake/)
4350
14
 * GNU Autoconf (>=2.59)  (http://www.gnu.org/software/autoconf/)
19
 * GNU Autoconf (>=2.63)  (http://www.gnu.org/software/autoconf/)
4351
15
 * GNU Libtool            (http://www.gnu.org/software/libtool/)
20
 * GNU Autoconf Archive   (http://www.gnu.org/software/autoconf-archive/)
4352
21
 * pkg-config             (http://www.freedesktop.org/wiki/Software/pkg-config)
4353
22
4354
23
You may also need:
4355
24
4356
25
 * Sphinx                 (http://sphinx.pocoo.org/)
4357
26
 * LaTex                  (http://www.latex-project.org/)
4358
27
 * GNU Texinfo            (http://www.gnu.org/software/texinfo/)
4359
16
 * GNU help2man           (http://www.gnu.org/software/help2man/)
28
 * GNU help2man           (http://www.gnu.org/software/help2man/)
4362
17
29
 * GnuPG                  (http://www.gnupg.org/)
4363
18
The `help2man` tool is optional, but will generate `man` pages for you.
30
 * md5sum                 (http://www.microbrew.org/tools/md5sha1sum/)
4364
31
 * sha1sum                (http://www.microbrew.org/tools/md5sha1sum/)
4365
32
4366
33
The first of these optional dependencies are required for building the
4367
34
documentation. The last three are needed to build releases.
4368
35
4369
36
You will need these optional dependencies installed if:
4370
37
4371
38
 * You are working on the documentation, or
4372
39
 * You are preparing a distribution archive
4373
40
4374
41
However, you do not need them if:
4375
42
4376
43
 * You are building from a distribution archive, or
4377
44
 * You don't care about building the documentation
4378
45
4379
46
4380
47
Here is a list of *optional* dependencies for various operating systems.
4381
48
Installation will be easiest, when you install them all.
4382
19
49
4383
20
Debian-based (inc. Ubuntu) Systems
50
Debian-based (inc. Ubuntu) Systems
4384
21
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
51
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
4385
22
52
4391
23
You can install the dependencies by running:
53
    sudo apt-get install help2man
4392
24
54
    sudo apt-get install python-sphinx
4393
25
    apt-get install automake autoconf libtool help2man
55
    sudo apt-get install texlive-latex-base
4394
26
56
    sudo apt-get install texlive-latex-recommended
4395
27
Be sure to update the version numbers to match your system's available packages.
57
    sudo apt-get install texlive-latex-extra
4396
58
    sudo apt-get install texlive-fonts-recommended
4397
59
    sudo apt-get install texinfo
4398
60
    sudo apt-get install gnupg
4399
61
4400
62
Gentoo-based Systems
4401
63
~~~~~~~~~~~~~~~~~~~~
4402
64
4403
65
    sudo emerge texinfo
4404
66
    sudo emerge gnupg
4405
67
    sudo emerge coreutils
4406
68
    sudo emerge pkgconfig
4407
69
    sudo emerge help2man
4408
70
    sudo USE=latex emerge sphinx
4409
71
4410
72
RedHat-based (Fedora, Centos, RHEL) Systems
4411
73
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
4412
74
4413
75
    sudo yum install help2man
4414
76
    sudo yum install python-sphinx
4415
77
    sudo yum install python-docutils
4416
78
    sudo yum install python-pygments
4417
79
    sudo yum install texlive-latex
4418
80
    sudo yum install texlive-latex-fonts
4419
81
    sudo yum install texinfo
4420
82
    sudo yum install gnupg
4421
28
83
4422
29
Mac OS X
84
Mac OS X
4423
30
~~~~~~~~
85
~~~~~~~~
4424
31
86
4430
32
You can install the dependencies by running:
87
Install Homebrew, if you do not have it already:
4431
33
88
4432
34
    port install automake autoconf libtool help2man
89
    https://github.com/mxcl/homebrew
4433
35
90
4434
36
You will need MacPorts installed to use the `port` command.
91
Unless you want to install the optional dependencies, skip to the next section.
4435
92
4436
93
Install what else we can with Homebrew:
4437
94
4438
95
    brew install help2man
4439
96
    brew install gnupg
4440
97
    brew install md5sha1sum
4441
98
4442
99
If you don't already have pip installed, install it:
4443
100
4444
101
    sudo easy_install pip
4445
102
4446
103
Now, install the required Python packages:
4447
104
4448
105
    sudo pip install sphinx
4449
106
    sudo pip install docutils
4450
107
    sudo pip install pygments
4451
108
4452
109
Download MaxTeX from here:
4453
110
4454
111
    http://www.tug.org/mactex/
4455
112
4456
113
Follow the instructions to get a working LaTeX install on your system.
4457
114
4458
115
Windows
4459
116
~~~~~~~
4460
117
4461
118
Follow the instructions in INSTALL.Windows and build all components from
4462
119
source, using the same Visual C++ compiler and runtime.
4463
37
120
4464
38
Bootstrapping
121
Bootstrapping
4465
39
-------------
122
-------------
4466
@@ -44,6 +127,33 @@
4467
44
127
4468
45
You must repeat this step every time you update your source checkout.
128
You must repeat this step every time you update your source checkout.
4469
46
129
4470
130
Configuring
4471
131
-----------
4472
132
4473
133
Configure the source by running:
4474
134
4475
135
    ./configure
4476
136
4477
137
Note that this will not fail when the optional dependencies are missing.
4478
138
4479
139
To ensure the optional dependencies are installed, run:
4480
140
4481
141
    ./configure --enable-strictness
4482
142
4483
143
If you don't care about docs and want to skip the whole thing, run:
4484
144
4485
145
    ./configure --disable-docs
4486
146
4487
147
If you're working on the build system itself, you can run:
4488
148
4489
149
    ./configure --disable-tests
4490
150
4491
151
This skips the tests allowing quicker `make' cycles.
4492
152
4493
153
If you want to build it into different destination than `/usr/local`.
4494
154
4495
155
    ./configure --prefix=/<your directory path>
4496
156
4497
47
Testing
157
Testing
4498
48
-------
158
-------
4499
49
159
4500
@@ -60,13 +170,13 @@
4501
60
Releasing
170
Releasing
4502
61
---------
171
---------
4503
62
172
4504
173
The release procedure is documented here:
4505
174
4506
175
    https://wiki.apache.org/couchdb/Release_Procedure
4507
176
4508
63
Unix-like Systems
177
Unix-like Systems
4509
64
~~~~~~~~~~~~~~~~~
178
~~~~~~~~~~~~~~~~~
4510
65
179
4511
66
Configure the source by running:
4512
67
4513
68
    ./configure
4514
69
4515
70
Prepare the release artefacts by running:
180
Prepare the release artefacts by running:
4516
71
181
4517
72
    make distcheck
182
    make distcheck
4518
@@ -80,10 +190,6 @@
4519
80
Microsoft Windows
190
Microsoft Windows
4520
81
~~~~~~~~~~~~~~~~~
191
~~~~~~~~~~~~~~~~~
4521
82
192
4522
83
Configure the source by running:
4523
84
4524
85
    ./configure
4525
86
4526
87
Prepare the release artefacts by running:
193
Prepare the release artefacts by running:
4527
88
194
4528
89
    make dist
195
    make dist
4529
90
196
4530
=== modified file 'INSTALL'
4531
--- INSTALL	2012-07-30 22:49:54 +0000
4532
+++ INSTALL	2013-08-30 22:06:57 +0000
4533
@@ -1,19 +1,25 @@
4534
1
Installation Instructions
1
Installation Instructions
4535
2
*************************
2
*************************
4536
3
3
4539
4
Copyright (C) 1994, 1995, 1996, 1999, 2000, 2001, 2002, 2004, 2005,
4
Copyright (C) 1994-1996, 1999-2002, 2004-2011 Free Software Foundation,
4540
5
2006 Free Software Foundation, Inc.
5
Inc.
4541
6
6
4544
7
This file is free documentation; the Free Software Foundation gives
7
   Copying and distribution of this file, with or without modification,
4545
8
unlimited permission to copy, distribute and modify it.
8
are permitted in any medium without royalty provided the copyright
4546
9
notice and this notice are preserved.  This file is offered as-is,
4547
10
without warranty of any kind.
4548
9
11
4549
10
Basic Installation
12
Basic Installation
4550
11
==================
13
==================
4551
12
14
4553
13
Briefly, the shell commands `./configure; make; make install' should
15
   Briefly, the shell commands `./configure; make; make install' should
4554
14
configure, build, and install this package.  The following
16
configure, build, and install this package.  The following
4555
15
more-detailed instructions are generic; see the `README' file for
17
more-detailed instructions are generic; see the `README' file for
4557
16
instructions specific to this package.
18
instructions specific to this package.  Some packages provide this
4558
19
`INSTALL' file but do not implement all of the features documented
4559
20
below.  The lack of an optional feature in a given package is not
4560
21
necessarily a bug.  More recommendations for GNU packages can be found
4561
22
in *note Makefile Conventions: (standards)Makefile Conventions.
4562
17
23
4563
18
   The `configure' shell script attempts to guess correct values for
24
   The `configure' shell script attempts to guess correct values for
4564
19
various system-dependent variables used during compilation.  It uses
25
various system-dependent variables used during compilation.  It uses
4565
@@ -42,7 +48,7 @@
4566
42
you want to change it or regenerate `configure' using a newer version
48
you want to change it or regenerate `configure' using a newer version
4567
43
of `autoconf'.
49
of `autoconf'.
4568
44
50
4570
45
The simplest way to compile this package is:
51
   The simplest way to compile this package is:
4571
46
52
4572
47
  1. `cd' to the directory containing the package's source code and type
53
  1. `cd' to the directory containing the package's source code and type
4573
48
     `./configure' to configure the package for your system.
54
     `./configure' to configure the package for your system.
4574
@@ -53,12 +59,22 @@
4575
53
  2. Type `make' to compile the package.
59
  2. Type `make' to compile the package.
4576
54
60
4577
55
  3. Optionally, type `make check' to run any self-tests that come with
61
  3. Optionally, type `make check' to run any self-tests that come with
4579
56
     the package.
62
     the package, generally using the just-built uninstalled binaries.
4580
57
63
4581
58
  4. Type `make install' to install the programs and any data files and
64
  4. Type `make install' to install the programs and any data files and
4585
59
     documentation.
65
     documentation.  When installing into a prefix owned by root, it is
4586
60
66
     recommended that the package be configured and built as a regular
4587
61
  5. You can remove the program binaries and object files from the
67
     user, and only the `make install' phase executed with root
4588
68
     privileges.
4589
69
4590
70
  5. Optionally, type `make installcheck' to repeat any self-tests, but
4591
71
     this time using the binaries in their final installed location.
4592
72
     This target does not install anything.  Running this target as a
4593
73
     regular user, particularly if the prior `make install' required
4594
74
     root privileges, verifies that the installation completed
4595
75
     correctly.
4596
76
4597
77
  6. You can remove the program binaries and object files from the
4598
62
     source code directory by typing `make clean'.  To also remove the
78
     source code directory by typing `make clean'.  To also remove the
4599
63
     files that `configure' created (so you can compile the package for
79
     files that `configure' created (so you can compile the package for
4600
64
     a different kind of computer), type `make distclean'.  There is
80
     a different kind of computer), type `make distclean'.  There is
4601
@@ -67,12 +83,22 @@
4602
67
     all sorts of other programs in order to regenerate files that came
83
     all sorts of other programs in order to regenerate files that came
4603
68
     with the distribution.
84
     with the distribution.
4604
69
85
4605
86
  7. Often, you can also type `make uninstall' to remove the installed
4606
87
     files again.  In practice, not all packages have tested that
4607
88
     uninstallation works correctly, even though it is required by the
4608
89
     GNU Coding Standards.
4609
90
4610
91
  8. Some packages, particularly those that use Automake, provide `make
4611
92
     distcheck', which can by used by developers to test that all other
4612
93
     targets like `make install' and `make uninstall' work correctly.
4613
94
     This target is generally not run by end users.
4614
95
4615
70
Compilers and Options
96
Compilers and Options
4616
71
=====================
97
=====================
4617
72
98
4621
73
Some systems require unusual options for compilation or linking that the
99
   Some systems require unusual options for compilation or linking that
4622
74
`configure' script does not know about.  Run `./configure --help' for
100
the `configure' script does not know about.  Run `./configure --help'
4623
75
details on some of the pertinent environment variables.
101
for details on some of the pertinent environment variables.
4624
76
102
4625
77
   You can give `configure' initial values for configuration parameters
103
   You can give `configure' initial values for configuration parameters
4626
78
by setting variables in the command line or in the environment.  Here
104
by setting variables in the command line or in the environment.  Here
4627
@@ -85,25 +111,41 @@
4628
85
Compiling For Multiple Architectures
111
Compiling For Multiple Architectures
4629
86
====================================
112
====================================
4630
87
113
4632
88
You can compile the package for more than one kind of computer at the
114
   You can compile the package for more than one kind of computer at the
4633
89
same time, by placing the object files for each architecture in their
115
same time, by placing the object files for each architecture in their
4634
90
own directory.  To do this, you can use GNU `make'.  `cd' to the
116
own directory.  To do this, you can use GNU `make'.  `cd' to the
4635
91
directory where you want the object files and executables to go and run
117
directory where you want the object files and executables to go and run
4636
92
the `configure' script.  `configure' automatically checks for the
118
the `configure' script.  `configure' automatically checks for the
4638
93
source code in the directory that `configure' is in and in `..'.
119
source code in the directory that `configure' is in and in `..'.  This
4639
120
is known as a "VPATH" build.
4640
94
121
4641
95
   With a non-GNU `make', it is safer to compile the package for one
122
   With a non-GNU `make', it is safer to compile the package for one
4642
96
architecture at a time in the source code directory.  After you have
123
architecture at a time in the source code directory.  After you have
4643
97
installed the package for one architecture, use `make distclean' before
124
installed the package for one architecture, use `make distclean' before
4644
98
reconfiguring for another architecture.
125
reconfiguring for another architecture.
4645
99
126
4646
127
   On MacOS X 10.5 and later systems, you can create libraries and
4647
128
executables that work on multiple system types--known as "fat" or
4648
129
"universal" binaries--by specifying multiple `-arch' options to the
4649
130
compiler but only a single `-arch' option to the preprocessor.  Like
4650
131
this:
4651
132
4652
133
     ./configure CC="gcc -arch i386 -arch x86_64 -arch ppc -arch ppc64" \
4653
134
                 CXX="g++ -arch i386 -arch x86_64 -arch ppc -arch ppc64" \
4654
135
                 CPP="gcc -E" CXXCPP="g++ -E"
4655
136
4656
137
   This is not guaranteed to produce working output in all cases, you
4657
138
may have to build one architecture at a time and combine the results
4658
139
using the `lipo' tool if you have problems.
4659
140
4660
100
Installation Names
141
Installation Names
4661
101
==================
142
==================
4662
102
143
4664
103
By default, `make install' installs the package's commands under
144
   By default, `make install' installs the package's commands under
4665
104
`/usr/local/bin', include files under `/usr/local/include', etc.  You
145
`/usr/local/bin', include files under `/usr/local/include', etc.  You
4666
105
can specify an installation prefix other than `/usr/local' by giving
146
can specify an installation prefix other than `/usr/local' by giving
4668
106
`configure' the option `--prefix=PREFIX'.
147
`configure' the option `--prefix=PREFIX', where PREFIX must be an
4669
148
absolute file name.
4670
107
149
4671
108
   You can specify separate installation prefixes for
150
   You can specify separate installation prefixes for
4672
109
architecture-specific files and architecture-independent files.  If you
151
architecture-specific files and architecture-independent files.  If you
4673
@@ -114,16 +156,47 @@
4674
114
   In addition, if you use an unusual directory layout you can give
156
   In addition, if you use an unusual directory layout you can give
4675
115
options like `--bindir=DIR' to specify different values for particular
157
options like `--bindir=DIR' to specify different values for particular
4676
116
kinds of files.  Run `configure --help' for a list of the directories
158
kinds of files.  Run `configure --help' for a list of the directories
4678
117
you can set and what kinds of files go in them.
159
you can set and what kinds of files go in them.  In general, the
4679
160
default for these options is expressed in terms of `${prefix}', so that
4680
161
specifying just `--prefix' will affect all of the other directory
4681
162
specifications that were not explicitly provided.
4682
163
4683
164
   The most portable way to affect installation locations is to pass the
4684
165
correct locations to `configure'; however, many packages provide one or
4685
166
both of the following shortcuts of passing variable assignments to the
4686
167
`make install' command line to change installation locations without
4687
168
having to reconfigure or recompile.
4688
169
4689
170
   The first method involves providing an override variable for each
4690
171
affected directory.  For example, `make install
4691
172
prefix=/alternate/directory' will choose an alternate location for all
4692
173
directory configuration variables that were expressed in terms of
4693
174
`${prefix}'.  Any directories that were specified during `configure',
4694
175
but not in terms of `${prefix}', must each be overridden at install
4695
176
time for the entire installation to be relocated.  The approach of
4696
177
makefile variable overrides for each directory variable is required by
4697
178
the GNU Coding Standards, and ideally causes no recompilation.
4698
179
However, some platforms have known limitations with the semantics of
4699
180
shared libraries that end up requiring recompilation when using this
4700
181
method, particularly noticeable in packages that use GNU Libtool.
4701
182
4702
183
   The second method involves providing the `DESTDIR' variable.  For
4703
184
example, `make install DESTDIR=/alternate/directory' will prepend
4704
185
`/alternate/directory' before all installation names.  The approach of
4705
186
`DESTDIR' overrides is not required by the GNU Coding Standards, and
4706
187
does not work on platforms that have drive letters.  On the other hand,
4707
188
it does better at avoiding recompilation issues, and works well even
4708
189
when some directory options were not specified in terms of `${prefix}'
4709
190
at `configure' time.
4710
191
4711
192
Optional Features
4712
193
=================
4713
118
194
4714
119
   If the package supports it, you can cause programs to be installed
195
   If the package supports it, you can cause programs to be installed
4715
120
with an extra prefix or suffix on their names by giving `configure' the
196
with an extra prefix or suffix on their names by giving `configure' the
4716
121
option `--program-prefix=PREFIX' or `--program-suffix=SUFFIX'.
197
option `--program-prefix=PREFIX' or `--program-suffix=SUFFIX'.
4717
122
198
4722
123
Optional Features
199
   Some packages pay attention to `--enable-FEATURE' options to
4719
124
=================
4720
125
4721
126
Some packages pay attention to `--enable-FEATURE' options to
4723
127
`configure', where FEATURE indicates an optional part of the package.
200
`configure', where FEATURE indicates an optional part of the package.
4724
128
They may also pay attention to `--with-PACKAGE' options, where PACKAGE
201
They may also pay attention to `--with-PACKAGE' options, where PACKAGE
4725
129
is something like `gnu-as' or `x' (for the X Window System).  The
202
is something like `gnu-as' or `x' (for the X Window System).  The
4726
@@ -135,14 +208,58 @@
4727
135
you can use the `configure' options `--x-includes=DIR' and
208
you can use the `configure' options `--x-includes=DIR' and
4728
136
`--x-libraries=DIR' to specify their locations.
209
`--x-libraries=DIR' to specify their locations.
4729
137
210
4730
211
   Some packages offer the ability to configure how verbose the
4731
212
execution of `make' will be.  For these packages, running `./configure
4732
213
--enable-silent-rules' sets the default to minimal output, which can be
4733
214
overridden with `make V=1'; while running `./configure
4734
215
--disable-silent-rules' sets the default to verbose, which can be
4735
216
overridden with `make V=0'.
4736
217
4737
218
Particular systems
4738
219
==================
4739
220
4740
221
   On HP-UX, the default C compiler is not ANSI C compatible.  If GNU
4741
222
CC is not installed, it is recommended to use the following options in
4742
223
order to use an ANSI C compiler:
4743
224
4744
225
     ./configure CC="cc -Ae -D_XOPEN_SOURCE=500"
4745
226
4746
227
and if that doesn't work, install pre-built binaries of GCC for HP-UX.
4747
228
4748
229
   HP-UX `make' updates targets which have the same time stamps as
4749
230
their prerequisites, which makes it generally unusable when shipped
4750
231
generated files such as `configure' are involved.  Use GNU `make'
4751
232
instead.
4752
233
4753
234
   On OSF/1 a.k.a. Tru64, some versions of the default C compiler cannot
4754
235
parse its `<wchar.h>' header file.  The option `-nodtk' can be used as
4755
236
a workaround.  If GNU CC is not installed, it is therefore recommended
4756
237
to try
4757
238
4758
239
     ./configure CC="cc"
4759
240
4760
241
and if that doesn't work, try
4761
242
4762
243
     ./configure CC="cc -nodtk"
4763
244
4764
245
   On Solaris, don't put `/usr/ucb' early in your `PATH'.  This
4765
246
directory contains several dysfunctional programs; working variants of
4766
247
these programs are available in `/usr/bin'.  So, if you need `/usr/ucb'
4767
248
in your `PATH', put it _after_ `/usr/bin'.
4768
249
4769
250
   On Haiku, software installed for all users goes in `/boot/common',
4770
251
not `/usr/local'.  It is recommended to use the following options:
4771
252
4772
253
     ./configure --prefix=/boot/common
4773
254
4774
138
Specifying the System Type
255
Specifying the System Type
4775
139
==========================
256
==========================
4776
140
257
4782
141
There may be some features `configure' cannot figure out automatically,
258
   There may be some features `configure' cannot figure out
4783
142
but needs to determine by the type of machine the package will run on.
259
automatically, but needs to determine by the type of machine the package
4784
143
Usually, assuming the package is built to be run on the _same_
260
will run on.  Usually, assuming the package is built to be run on the
4785
144
architectures, `configure' can figure that out, but if it prints a
261
_same_ architectures, `configure' can figure that out, but if it prints
4786
145
message saying it cannot guess the machine type, give it the
262
a message saying it cannot guess the machine type, give it the
4787
146
`--build=TYPE' option.  TYPE can either be a short name for the system
263
`--build=TYPE' option.  TYPE can either be a short name for the system
4788
147
type, such as `sun4', or a canonical name which has the form:
264
type, such as `sun4', or a canonical name which has the form:
4789
148
265
4790
@@ -150,7 +267,8 @@
4791
150
267
4792
151
where SYSTEM can have one of these forms:
268
where SYSTEM can have one of these forms:
4793
152
269
4795
153
     OS KERNEL-OS
270
     OS
4796
271
     KERNEL-OS
4797
154
272
4798
155
   See the file `config.sub' for the possible values of each field.  If
273
   See the file `config.sub' for the possible values of each field.  If
4799
156
`config.sub' isn't included in this package, then this package doesn't
274
`config.sub' isn't included in this package, then this package doesn't
4800
@@ -168,9 +286,9 @@
4801
168
Sharing Defaults
286
Sharing Defaults
4802
169
================
287
================
4803
170
288
4807
171
If you want to set default values for `configure' scripts to share, you
289
   If you want to set default values for `configure' scripts to share,
4808
172
can create a site shell script called `config.site' that gives default
290
you can create a site shell script called `config.site' that gives
4809
173
values for variables like `CC', `cache_file', and `prefix'.
291
default values for variables like `CC', `cache_file', and `prefix'.
4810
174
`configure' looks for `PREFIX/share/config.site' if it exists, then
292
`configure' looks for `PREFIX/share/config.site' if it exists, then
4811
175
`PREFIX/etc/config.site' if it exists.  Or, you can set the
293
`PREFIX/etc/config.site' if it exists.  Or, you can set the
4812
176
`CONFIG_SITE' environment variable to the location of the site script.
294
`CONFIG_SITE' environment variable to the location of the site script.
4813
@@ -179,7 +297,7 @@
4814
179
Defining Variables
297
Defining Variables
4815
180
==================
298
==================
4816
181
299
4818
182
Variables not defined in a site shell script can be set in the
300
   Variables not defined in a site shell script can be set in the
4819
183
environment passed to `configure'.  However, some packages may run
301
environment passed to `configure'.  However, some packages may run
4820
184
configure again during the build, and the customized values of these
302
configure again during the build, and the customized values of these
4821
185
variables may be lost.  In order to avoid this problem, you should set
303
variables may be lost.  In order to avoid this problem, you should set
4822
@@ -198,11 +316,19 @@
4823
198
`configure' Invocation
316
`configure' Invocation
4824
199
======================
317
======================
4825
200
318
4827
201
`configure' recognizes the following options to control how it operates.
319
   `configure' recognizes the following options to control how it
4828
320
operates.
4829
202
321
4830
203
`--help'
322
`--help'
4831
204
`-h'
323
`-h'
4833
205
     Print a summary of the options to `configure', and exit.
324
     Print a summary of all of the options to `configure', and exit.
4834
325
4835
326
`--help=short'
4836
327
`--help=recursive'
4837
328
     Print a summary of the options unique to this package's
4838
329
     `configure', and exit.  The `short' variant lists options used
4839
330
     only in the top level, while the `recursive' variant lists options
4840
331
     also present in any nested packages.
4841
206
332
4842
207
`--version'
333
`--version'
4843
208
`-V'
334
`-V'
4844
@@ -229,6 +355,16 @@
4845
229
     Look for the package's source code in directory DIR.  Usually
355
     Look for the package's source code in directory DIR.  Usually
4846
230
     `configure' can determine that directory automatically.
356
     `configure' can determine that directory automatically.
4847
231
357
4848
358
`--prefix=DIR'
4849
359
     Use DIR as the installation prefix.  *note Installation Names::
4850
360
     for more details, including other options available for fine-tuning
4851
361
     the installation locations.
4852
362
4853
363
`--no-create'
4854
364
`-n'
4855
365
     Run the configure checks, but stop before creating any output
4856
366
     files.
4857
367
4858
232
`configure' also accepts some other, not widely useful, options.  Run
368
`configure' also accepts some other, not widely useful, options.  Run
4859
233
`configure --help' for more details.
369
`configure --help' for more details.
4860
234
370
4861
235
371
4862
=== modified file 'INSTALL.Unix'
4863
--- INSTALL.Unix	2012-07-30 22:49:59 +0000
4864
+++ INSTALL.Unix	2013-08-30 22:06:57 +0000
4865
@@ -3,6 +3,16 @@
4866
3
3
4867
4
A high-level guide to Unix-like systems, inc. Mac OS X and Ubuntu.
4
A high-level guide to Unix-like systems, inc. Mac OS X and Ubuntu.
4868
5
5
4869
6
Community installation guides are available on the wiki:
4870
7
4871
8
    http://wiki.apache.org/couchdb/Installation
4872
9
    
4873
10
This document is the canonical source of installation information. However, many
4874
11
systems have gotchas that you need to be aware of. In addition, dependencies
4875
12
frequently change as distributions update their archives. If you're running into
4876
13
trouble, be sure to check out the wiki. If you have any tips to share, please
4877
14
also update the wiki so that others can benefit from your experience.
4878
15
4879
6
Troubleshooting
16
Troubleshooting
4880
7
---------------
17
---------------
4881
8
18
4882
@@ -25,69 +35,91 @@
4883
25
35
4884
26
You should have the following installed:
36
You should have the following installed:
4885
27
37
4894
28
 * Erlang OTP (>=R12B5)       (http://erlang.org/)
38
 * Erlang OTP (>=R13B04, <R17)  (http://erlang.org/)
4895
29
 * ICU                        (http://icu.sourceforge.net/)
39
 * ICU                          (http://icu-project.org/)
4896
30
 * OpenSSL                    (http://www.openssl.org/)
40
 * OpenSSL                      (http://www.openssl.org/)
4897
31
 * Mozilla SpiderMonkey (1.7) (http://www.mozilla.org/js/spidermonkey/)
41
 * Mozilla SpiderMonkey (1.7)   (http://www.mozilla.org/js/spidermonkey/)
4898
32
 * GNU Make                   (http://www.gnu.org/software/make/)
42
 * GNU Make                     (http://www.gnu.org/software/make/)
4899
33
 * GNU Compiler Collection    (http://gcc.gnu.org/)
43
 * GNU Compiler Collection      (http://gcc.gnu.org/)
4900
34
 * libcurl                    (http://curl.haxx.se/libcurl/)
44
 * libcurl                      (http://curl.haxx.se/libcurl/)
4901
35
 * help2man                   (http://www.gnu.org/s/help2man/)
45
 * help2man                     (http://www.gnu.org/s/help2man/)
4902
46
 * Python (>=2.7) for docs      (http://python.org/)
4903
47
 * Python Sphinx (>=1.1.3)      (http://pypi.python.org/pypi/Sphinx)
4904
36
48
4906
37
It is recommended that you install Erlang OTP R12B-5 or above where possible.
49
It is recommended that you install Erlang OTP R13B-4 or above where possible.
4907
38
You will only need libcurl if you plan to run the JavaScript test suite. And
50
You will only need libcurl if you plan to run the JavaScript test suite. And
4908
39
help2man is only need if you plan on installing the CouchDB man pages.
51
help2man is only need if you plan on installing the CouchDB man pages.
4918
40
52
Python and Sphinx are only required for building the online documentation.
4910
41
Ubuntu
4911
42
~~~~~~
4912
43
4913
44
For up to date instructions, please see:
4914
45
4915
46
  http://wiki.apache.org/couchdb/Installing_on_Ubuntu
4916
47
4917
48
Unfortunately, it seems that installing dependancies on Ubuntu is troublesome.
4919
49
53
4920
50
Debian-based Systems
54
Debian-based Systems
4921
51
~~~~~~~~~~~~~~~~~~~~
55
~~~~~~~~~~~~~~~~~~~~
4922
52
56
4924
53
You can install the build tools by running:
57
You can install the dependencies by running:
4925
54
58
4926
55
    sudo apt-get install build-essential
59
    sudo apt-get install build-essential
4931
56
60
    sudo apt-get install erlang-base-hipe
4932
57
You can install the other dependencies by running:
61
    sudo apt-get install erlang-dev
4933
58
62
    sudo apt-get install erlang-manpages
4934
59
    sudo apt-get install erlang libicu-dev libmozjs-dev libcurl4-openssl-dev
63
    sudo apt-get install erlang-eunit
4935
64
    sudo apt-get install erlang-nox
4936
65
    sudo apt-get install libicu-dev
4937
66
    sudo apt-get install libmozjs-dev
4938
67
    sudo apt-get install libcurl4-openssl-dev
4939
68
    sudo apt-get install pkg-config
4940
69
4941
70
There are lots of Erlang packages. If there is a problem with your install, try
4942
71
a different mix. There is more information on the wiki. Additionally, you might
4943
72
want to install some of the optional Erlang tools which may also be useful.
4944
60
73
4945
61
Be sure to update the version numbers to match your system's available packages.
74
Be sure to update the version numbers to match your system's available packages.
4946
62
75
4947
76
For up to date instructions, please see:
4948
77
4949
78
  http://wiki.apache.org/couchdb/Installing_on_Debian
4950
79
4951
80
  http://wiki.apache.org/couchdb/Installing_on_Ubuntu
4952
81
4953
82
Unfortunately, it seems that installing dependencies on Ubuntu is troublesome.
4954
83
4955
84
RedHat-based (Fedora, Centos, RHEL) Systems
4956
85
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
4957
86
4958
87
You can install the dependencies by running:
4959
88
4960
89
    sudo yum groupinstall "Development Tools"
4961
90
    sudo yum install autoconf
4962
91
    sudo yum install autoconf-archive
4963
92
    sudo yum install automake
4964
93
    sudo yum install libtool
4965
94
    sudo yum install perl-Test-Harness
4966
95
    sudo yum install erlang-etap
4967
96
    sudo yum install erlang-erts
4968
97
    sudo yum install erlang-os_mon
4969
98
    sudo yum install erlang-eunit
4970
99
    sudo yum install libicu-devel
4971
100
    sudo yum install js-devel
4972
101
    sudo yum install curl-devel
4973
102
    sudo yum install pkg-config
4974
103
4975
104
While CouchDB builds against the default js-devel-1.7.0 included in some
4976
105
distributions, it's recommended to use a more recent js-devel-1.8.5.
4977
106
4978
63
Mac OS X
107
Mac OS X
4979
64
~~~~~~~~
108
~~~~~~~~
4980
65
109
4984
66
You can install the build tools by running:
110
To build CouchDB from source on Mac OS X, you will need to install Xcode.
4982
67
4983
68
    open /Applications/Installers/Xcode\ Tools/XcodeTools.mpkg
4985
69
111
4986
70
You can install the other dependencies by running:
112
You can install the other dependencies by running:
4987
71
113
4988
72
    brew install erlang icu4c spidermonkey curl
4989
73
4990
74
You may want to link ICU so that CouchDB can find the header files automatically:
4991
75
4992
76
    brew link icu4c
4993
77
4994
78
The same is true for recent versions of Erlang:
4995
79
4996
80
    brew link erlang
4997
81
4998
82
If you are upgrading your version of CouchDB and have an older nspr and
4999
83
Spidermonkey installed you may encounter an error during the ./configure step
5000
84
below. This is generally due to nspr being installed without its pkg-config
Reviewer	Date Requested	Status
Andrew Starr-Bochicchio (community)		Approve on 2013-09-17
Chad Miller (community)		Approve on 2013-08-29
Jason Gerard DeRose (community)		Needs Resubmitting on 2013-08-28
Ubuntu branches	2013-08-28	Pending
Review via email: mp+182725@code.launchpad.net