pygments.rb 2.0.0.rc2 → 2.0.0.rc3

Sign up to get free protection for your applications and to get access to all the features.
checksums.yaml CHANGED
@@ -1,7 +1,7 @@
1
1
  ---
2
2
  SHA256:
3
- metadata.gz: 535b90f92dff585921fc5ed203ec921d8581312776ec3193ef3d48506f9466f7
4
- data.tar.gz: 35b79346665936bc1534bd9023eba2124afff346e560347a3f0d4c97e16e0019
3
+ metadata.gz: cb7e6901e07778261de7c0a6283696d5c1593ade93565caf32b2870e11477d39
4
+ data.tar.gz: 36d123e7aa363b8f50dfcd884e4d1f0721e6e75c83966c18d83f505e7bbf0b85
5
5
  SHA512:
6
- metadata.gz: cd051147c3cb8ff1d00c215d75534efafcc4b3e4fdfd88085d27a8d95efc6f733125b5f74e8877b0c0502b86e06c97340eb5ec80776e1e7ed6e60d73468f7ec5
7
- data.tar.gz: 130bf6fe7e708c252b192141ab3e99ca7702e7260f6f3b6c0af3b5c35ede677dbc6bf8d2051ffac7fc5bdc05a43f22f504c59d1cc79a8303f94bc1d38a003e17
6
+ metadata.gz: 6ad9b6ac8dce86c289939ffbe3ee8c71268dd04ed3755798f08c75905cac90bf602236ae10448a44162809483ca5f88252985db7537d01818c5dcd348d60fe78
7
+ data.tar.gz: 728ca37e69f29ee9c74d2804e7583fdaf2284f330b9f3096612a88c2cc58833f49ad9a642eadd63e883a36cb7ea171b7f7892a205da709be67937e698a1d49f2
@@ -5,6 +5,10 @@
5
5
  This document provides a high-level view of the changes to the {project-name} by release.
6
6
  For a detailed view of what has changed, refer to the {uri-repo}/commits/master[commit history] on GitHub.
7
7
 
8
+ == 2.0.0.rc3 (2021-01-08) - @slonopotamus
9
+
10
+ * fix watchdog race condition leading to `ThreadError(<killed thread>)` on JRuby ({uri-repo}/pull/215[#215])
11
+
8
12
  == 2.0.0.rc2 (2021-01-07) - @slonopotamus
9
13
 
10
14
  * Fix release workflow
data/Rakefile CHANGED
@@ -49,6 +49,7 @@ task(:build).enhance([:lexers])
49
49
  namespace :vendor do
50
50
  file 'vendor/pygments-main' do |f|
51
51
  sh "pip install --target=#{f.name} pygments"
52
+ sh "git add -- #{f.name}"
52
53
  end
53
54
 
54
55
  task :clobber do
@@ -227,15 +227,17 @@ module Pygments
227
227
  def with_watchdog(timeout_time, error_message)
228
228
  state_mutex = Mutex.new
229
229
  state = :alive
230
+ wd_cleanup = ConditionVariable.new
230
231
 
231
232
  watchdog = timeout_time > 0 ? Thread.new do
232
233
  state_mutex.synchronize do
233
- state_mutex.sleep(timeout_time) if state != :finished
234
+ wd_cleanup.wait(state_mutex, timeout_time) if state != :finished
234
235
  if state != :finished
235
236
  @log.error error_message
236
237
  stop error_message
237
238
  state = :timeout
238
239
  end
240
+
239
241
  end
240
242
  end : nil
241
243
  begin
@@ -244,7 +246,8 @@ module Pygments
244
246
  if watchdog
245
247
  state_mutex.synchronize do
246
248
  state = :finished if state == :alive
247
- watchdog.wakeup if watchdog.alive?
249
+ # wake up watchdog thread
250
+ wd_cleanup.signal
248
251
  end
249
252
  watchdog.join
250
253
  end
@@ -1,5 +1,5 @@
1
1
  # frozen_string_literal: true
2
2
 
3
3
  module Pygments
4
- VERSION = '2.0.0.rc2'
4
+ VERSION = '2.0.0.rc3'
5
5
  end
@@ -10,7 +10,7 @@ PE = Pygments.engine
10
10
  class PygmentsHighlightTest < Test::Unit::TestCase
11
11
  RUBY_CODE = "#!/usr/bin/ruby\nputs 'foo'"
12
12
  RUBY_CODE_TRAILING_NEWLINE = "#!/usr/bin/ruby\nputs 'foo'\n"
13
- REDIS_CODE = File.read(File.join(File.dirname(__FILE__), '..', '/test/test_data.c'))
13
+ TEST_CODE = File.read(File.join(File.dirname(__FILE__), '..', 'lib', 'pygments', 'mentos.py'))
14
14
 
15
15
  def test_highlight_defaults_to_html
16
16
  code = P.highlight(RUBY_CODE)
@@ -31,14 +31,14 @@ class PygmentsHighlightTest < Test::Unit::TestCase
31
31
  end
32
32
 
33
33
  def test_highlight_works_with_larger_files
34
- code = P.highlight(REDIS_CODE)
35
- assert_match 'used_memory_peak_human', code
34
+ code = P.highlight(TEST_CODE)
35
+ assert_match 'Main loop, waiting for inputs on stdin', code
36
36
  end
37
37
 
38
38
  def test_raises_exception_on_timeout
39
39
  assert_raise MentosError.new('Timeout on a mentos highlight call') do
40
40
  # Assume highlighting a large file will take more than 1 millisecond
41
- P.highlight(REDIS_CODE, timeout: 0.001)
41
+ P.highlight(TEST_CODE * 10, timeout: 0.001)
42
42
  end
43
43
  end
44
44
 
metadata CHANGED
@@ -1,7 +1,7 @@
1
1
  --- !ruby/object:Gem::Specification
2
2
  name: pygments.rb
3
3
  version: !ruby/object:Gem::Version
4
- version: 2.0.0.rc2
4
+ version: 2.0.0.rc3
5
5
  platform: ruby
6
6
  authors:
7
7
  - Aman Gupta
@@ -79,7 +79,6 @@ files:
79
79
  - lib/pygments/popen.rb
80
80
  - lib/pygments/version.rb
81
81
  - pygments.rb.gemspec
82
- - test/test_data.c
83
82
  - test/test_pygments.rb
84
83
  - vendor/pygments-main/Pygments-2.7.3.dist-info/AUTHORS
85
84
  - vendor/pygments-main/Pygments-2.7.3.dist-info/INSTALLER
@@ -1,2581 +0,0 @@
1
- /*
2
- * Copyright (c) 2009-2010, Salvatore Sanfilippo <antirez at gmail dot com>
3
- * All rights reserved.
4
- *
5
- * Redistribution and use in source and binary forms, with or without
6
- * modification, are permitted provided that the following conditions are met:
7
- *
8
- * * Redistributions of source code must retain the above copyright notice,
9
- * this list of conditions and the following disclaimer.
10
- * * Redistributions in binary form must reproduce the above copyright
11
- * notice, this list of conditions and the following disclaimer in the
12
- * documentation and/or other materials provided with the distribution.
13
- * * Neither the name of Redis nor the names of its contributors may be used
14
- * to endorse or promote products derived from this software without
15
- * specific prior written permission.
16
- *
17
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
18
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
21
- * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
22
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
23
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
24
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
25
- * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
26
- * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
27
- * POSSIBILITY OF SUCH DAMAGE.
28
- */
29
-
30
- #include "redis.h"
31
- #include "slowlog.h"
32
- #include "bio.h"
33
-
34
- #include <time.h>
35
- #include <signal.h>
36
- #include <sys/wait.h>
37
- #include <errno.h>
38
- #include <assert.h>
39
- #include <ctype.h>
40
- #include <stdarg.h>
41
- #include <arpa/inet.h>
42
- #include <sys/stat.h>
43
- #include <fcntl.h>
44
- #include <sys/time.h>
45
- #include <sys/resource.h>
46
- #include <sys/uio.h>
47
- #include <limits.h>
48
- #include <float.h>
49
- #include <math.h>
50
- #include <sys/resource.h>
51
- #include <sys/utsname.h>
52
-
53
- /* Our shared "common" objects */
54
-
55
- struct sharedObjectsStruct shared;
56
-
57
- /* Global vars that are actually used as constants. The following double
58
- * values are used for double on-disk serialization, and are initialized
59
- * at runtime to avoid strange compiler optimizations. */
60
-
61
- double R_Zero, R_PosInf, R_NegInf, R_Nan;
62
-
63
- /*================================= Globals ================================= */
64
-
65
- /* Global vars */
66
- struct redisServer server; /* server global state */
67
- struct redisCommand *commandTable;
68
-
69
- /* Our command table.
70
- *
71
- * Every entry is composed of the following fields:
72
- *
73
- * name: a string representing the command name.
74
- * function: pointer to the C function implementing the command.
75
- * arity: number of arguments, it is possible to use -N to say >= N
76
- * sflags: command flags as string. See below for a table of flags.
77
- * flags: flags as bitmask. Computed by Redis using the 'sflags' field.
78
- * get_keys_proc: an optional function to get key arguments from a command.
79
- * This is only used when the following three fields are not
80
- * enough to specify what arguments are keys.
81
- * first_key_index: first argument that is a key
82
- * last_key_index: last argument that is a key
83
- * key_step: step to get all the keys from first to last argument. For instance
84
- * in MSET the step is two since arguments are key,val,key,val,...
85
- * microseconds: microseconds of total execution time for this command.
86
- * calls: total number of calls of this command.
87
- *
88
- * The flags, microseconds and calls fields are computed by Redis and should
89
- * always be set to zero.
90
- *
91
- * Command flags are expressed using strings where every character represents
92
- * a flag. Later the populateCommandTable() function will take care of
93
- * populating the real 'flags' field using this characters.
94
- *
95
- * This is the meaning of the flags:
96
- *
97
- * w: write command (may modify the key space).
98
- * r: read command (will never modify the key space).
99
- * m: may increase memory usage once called. Don't allow if out of memory.
100
- * a: admin command, like SAVE or SHUTDOWN.
101
- * p: Pub/Sub related command.
102
- * f: force replication of this command, regarless of server.dirty.
103
- * s: command not allowed in scripts.
104
- * R: random command. Command is not deterministic, that is, the same command
105
- * with the same arguments, with the same key space, may have different
106
- * results. For instance SPOP and RANDOMKEY are two random commands.
107
- * S: Sort command output array if called from script, so that the output
108
- * is deterministic.
109
- */
110
- struct redisCommand redisCommandTable[] = {
111
- {"get",getCommand,2,"r",0,NULL,1,1,1,0,0},
112
- {"set",setCommand,3,"wm",0,noPreloadGetKeys,1,1,1,0,0},
113
- {"setnx",setnxCommand,3,"wm",0,noPreloadGetKeys,1,1,1,0,0},
114
- {"setex",setexCommand,4,"wm",0,noPreloadGetKeys,1,1,1,0,0},
115
- {"psetex",psetexCommand,4,"wm",0,noPreloadGetKeys,1,1,1,0,0},
116
- {"append",appendCommand,3,"wm",0,NULL,1,1,1,0,0},
117
- {"strlen",strlenCommand,2,"r",0,NULL,1,1,1,0,0},
118
- {"del",delCommand,-2,"w",0,noPreloadGetKeys,1,-1,1,0,0},
119
- {"exists",existsCommand,2,"r",0,NULL,1,1,1,0,0},
120
- {"setbit",setbitCommand,4,"wm",0,NULL,1,1,1,0,0},
121
- {"getbit",getbitCommand,3,"r",0,NULL,1,1,1,0,0},
122
- {"setrange",setrangeCommand,4,"wm",0,NULL,1,1,1,0,0},
123
- {"getrange",getrangeCommand,4,"r",0,NULL,1,1,1,0,0},
124
- {"substr",getrangeCommand,4,"r",0,NULL,1,1,1,0,0},
125
- {"incr",incrCommand,2,"wm",0,NULL,1,1,1,0,0},
126
- {"decr",decrCommand,2,"wm",0,NULL,1,1,1,0,0},
127
- {"mget",mgetCommand,-2,"r",0,NULL,1,-1,1,0,0},
128
- {"rpush",rpushCommand,-3,"wm",0,NULL,1,1,1,0,0},
129
- {"lpush",lpushCommand,-3,"wm",0,NULL,1,1,1,0,0},
130
- {"rpushx",rpushxCommand,3,"wm",0,NULL,1,1,1,0,0},
131
- {"lpushx",lpushxCommand,3,"wm",0,NULL,1,1,1,0,0},
132
- {"linsert",linsertCommand,5,"wm",0,NULL,1,1,1,0,0},
133
- {"rpop",rpopCommand,2,"w",0,NULL,1,1,1,0,0},
134
- {"lpop",lpopCommand,2,"w",0,NULL,1,1,1,0,0},
135
- {"brpop",brpopCommand,-3,"ws",0,NULL,1,1,1,0,0},
136
- {"brpoplpush",brpoplpushCommand,4,"wms",0,NULL,1,2,1,0,0},
137
- {"blpop",blpopCommand,-3,"ws",0,NULL,1,-2,1,0,0},
138
- {"llen",llenCommand,2,"r",0,NULL,1,1,1,0,0},
139
- {"lindex",lindexCommand,3,"r",0,NULL,1,1,1,0,0},
140
- {"lset",lsetCommand,4,"wm",0,NULL,1,1,1,0,0},
141
- {"lrange",lrangeCommand,4,"r",0,NULL,1,1,1,0,0},
142
- {"ltrim",ltrimCommand,4,"w",0,NULL,1,1,1,0,0},
143
- {"lrem",lremCommand,4,"w",0,NULL,1,1,1,0,0},
144
- {"rpoplpush",rpoplpushCommand,3,"wm",0,NULL,1,2,1,0,0},
145
- {"sadd",saddCommand,-3,"wm",0,NULL,1,1,1,0,0},
146
- {"srem",sremCommand,-3,"w",0,NULL,1,1,1,0,0},
147
- {"smove",smoveCommand,4,"w",0,NULL,1,2,1,0,0},
148
- {"sismember",sismemberCommand,3,"r",0,NULL,1,1,1,0,0},
149
- {"scard",scardCommand,2,"r",0,NULL,1,1,1,0,0},
150
- {"spop",spopCommand,2,"wRs",0,NULL,1,1,1,0,0},
151
- {"srandmember",srandmemberCommand,2,"rR",0,NULL,1,1,1,0,0},
152
- {"sinter",sinterCommand,-2,"rS",0,NULL,1,-1,1,0,0},
153
- {"sinterstore",sinterstoreCommand,-3,"wm",0,NULL,1,-1,1,0,0},
154
- {"sunion",sunionCommand,-2,"rS",0,NULL,1,-1,1,0,0},
155
- {"sunionstore",sunionstoreCommand,-3,"wm",0,NULL,1,-1,1,0,0},
156
- {"sdiff",sdiffCommand,-2,"rS",0,NULL,1,-1,1,0,0},
157
- {"sdiffstore",sdiffstoreCommand,-3,"wm",0,NULL,1,-1,1,0,0},
158
- {"smembers",sinterCommand,2,"rS",0,NULL,1,1,1,0,0},
159
- {"zadd",zaddCommand,-4,"wm",0,NULL,1,1,1,0,0},
160
- {"zincrby",zincrbyCommand,4,"wm",0,NULL,1,1,1,0,0},
161
- {"zrem",zremCommand,-3,"w",0,NULL,1,1,1,0,0},
162
- {"zremrangebyscore",zremrangebyscoreCommand,4,"w",0,NULL,1,1,1,0,0},
163
- {"zremrangebyrank",zremrangebyrankCommand,4,"w",0,NULL,1,1,1,0,0},
164
- {"zunionstore",zunionstoreCommand,-4,"wm",0,zunionInterGetKeys,0,0,0,0,0},
165
- {"zinterstore",zinterstoreCommand,-4,"wm",0,zunionInterGetKeys,0,0,0,0,0},
166
- {"zrange",zrangeCommand,-4,"r",0,NULL,1,1,1,0,0},
167
- {"zrangebyscore",zrangebyscoreCommand,-4,"r",0,NULL,1,1,1,0,0},
168
- {"zrevrangebyscore",zrevrangebyscoreCommand,-4,"r",0,NULL,1,1,1,0,0},
169
- {"zcount",zcountCommand,4,"r",0,NULL,1,1,1,0,0},
170
- {"zrevrange",zrevrangeCommand,-4,"r",0,NULL,1,1,1,0,0},
171
- {"zcard",zcardCommand,2,"r",0,NULL,1,1,1,0,0},
172
- {"zscore",zscoreCommand,3,"r",0,NULL,1,1,1,0,0},
173
- {"zrank",zrankCommand,3,"r",0,NULL,1,1,1,0,0},
174
- {"zrevrank",zrevrankCommand,3,"r",0,NULL,1,1,1,0,0},
175
- {"hset",hsetCommand,4,"wm",0,NULL,1,1,1,0,0},
176
- {"hsetnx",hsetnxCommand,4,"wm",0,NULL,1,1,1,0,0},
177
- {"hget",hgetCommand,3,"r",0,NULL,1,1,1,0,0},
178
- {"hmset",hmsetCommand,-4,"wm",0,NULL,1,1,1,0,0},
179
- {"hmget",hmgetCommand,-3,"r",0,NULL,1,1,1,0,0},
180
- {"hincrby",hincrbyCommand,4,"wm",0,NULL,1,1,1,0,0},
181
- {"hincrbyfloat",hincrbyfloatCommand,4,"wm",0,NULL,1,1,1,0,0},
182
- {"hdel",hdelCommand,-3,"w",0,NULL,1,1,1,0,0},
183
- {"hlen",hlenCommand,2,"r",0,NULL,1,1,1,0,0},
184
- {"hkeys",hkeysCommand,2,"rS",0,NULL,1,1,1,0,0},
185
- {"hvals",hvalsCommand,2,"rS",0,NULL,1,1,1,0,0},
186
- {"hgetall",hgetallCommand,2,"r",0,NULL,1,1,1,0,0},
187
- {"hexists",hexistsCommand,3,"r",0,NULL,1,1,1,0,0},
188
- {"incrby",incrbyCommand,3,"wm",0,NULL,1,1,1,0,0},
189
- {"decrby",decrbyCommand,3,"wm",0,NULL,1,1,1,0,0},
190
- {"incrbyfloat",incrbyfloatCommand,3,"wm",0,NULL,1,1,1,0,0},
191
- {"getset",getsetCommand,3,"wm",0,NULL,1,1,1,0,0},
192
- {"mset",msetCommand,-3,"wm",0,NULL,1,-1,2,0,0},
193
- {"msetnx",msetnxCommand,-3,"wm",0,NULL,1,-1,2,0,0},
194
- {"randomkey",randomkeyCommand,1,"rR",0,NULL,0,0,0,0,0},
195
- {"select",selectCommand,2,"r",0,NULL,0,0,0,0,0},
196
- {"move",moveCommand,3,"w",0,NULL,1,1,1,0,0},
197
- {"rename",renameCommand,3,"w",0,renameGetKeys,1,2,1,0,0},
198
- {"renamenx",renamenxCommand,3,"w",0,renameGetKeys,1,2,1,0,0},
199
- {"expire",expireCommand,3,"w",0,NULL,1,1,1,0,0},
200
- {"expireat",expireatCommand,3,"w",0,NULL,1,1,1,0,0},
201
- {"pexpire",pexpireCommand,3,"w",0,NULL,1,1,1,0,0},
202
- {"pexpireat",pexpireatCommand,3,"w",0,NULL,1,1,1,0,0},
203
- {"keys",keysCommand,2,"rS",0,NULL,0,0,0,0,0},
204
- {"dbsize",dbsizeCommand,1,"r",0,NULL,0,0,0,0,0},
205
- {"auth",authCommand,2,"rs",0,NULL,0,0,0,0,0},
206
- {"ping",pingCommand,1,"r",0,NULL,0,0,0,0,0},
207
- {"echo",echoCommand,2,"r",0,NULL,0,0,0,0,0},
208
- {"save",saveCommand,1,"ars",0,NULL,0,0,0,0,0},
209
- {"bgsave",bgsaveCommand,1,"ar",0,NULL,0,0,0,0,0},
210
- {"bgrewriteaof",bgrewriteaofCommand,1,"ar",0,NULL,0,0,0,0,0},
211
- {"shutdown",shutdownCommand,-1,"ar",0,NULL,0,0,0,0,0},
212
- {"lastsave",lastsaveCommand,1,"r",0,NULL,0,0,0,0,0},
213
- {"type",typeCommand,2,"r",0,NULL,1,1,1,0,0},
214
- {"multi",multiCommand,1,"rs",0,NULL,0,0,0,0,0},
215
- {"exec",execCommand,1,"s",0,NULL,0,0,0,0,0},
216
- {"discard",discardCommand,1,"rs",0,NULL,0,0,0,0,0},
217
- {"sync",syncCommand,1,"ars",0,NULL,0,0,0,0,0},
218
- {"replconf",replconfCommand,-1,"ars",0,NULL,0,0,0,0,0},
219
- {"flushdb",flushdbCommand,1,"w",0,NULL,0,0,0,0,0},
220
- {"flushall",flushallCommand,1,"w",0,NULL,0,0,0,0,0},
221
- {"sort",sortCommand,-2,"wmS",0,NULL,1,1,1,0,0},
222
- {"info",infoCommand,-1,"r",0,NULL,0,0,0,0,0},
223
- {"monitor",monitorCommand,1,"ars",0,NULL,0,0,0,0,0},
224
- {"ttl",ttlCommand,2,"r",0,NULL,1,1,1,0,0},
225
- {"pttl",pttlCommand,2,"r",0,NULL,1,1,1,0,0},
226
- {"persist",persistCommand,2,"w",0,NULL,1,1,1,0,0},
227
- {"slaveof",slaveofCommand,3,"as",0,NULL,0,0,0,0,0},
228
- {"debug",debugCommand,-2,"as",0,NULL,0,0,0,0,0},
229
- {"config",configCommand,-2,"ar",0,NULL,0,0,0,0,0},
230
- {"subscribe",subscribeCommand,-2,"rps",0,NULL,0,0,0,0,0},
231
- {"unsubscribe",unsubscribeCommand,-1,"rps",0,NULL,0,0,0,0,0},
232
- {"psubscribe",psubscribeCommand,-2,"rps",0,NULL,0,0,0,0,0},
233
- {"punsubscribe",punsubscribeCommand,-1,"rps",0,NULL,0,0,0,0,0},
234
- {"publish",publishCommand,3,"pf",0,NULL,0,0,0,0,0},
235
- {"watch",watchCommand,-2,"rs",0,noPreloadGetKeys,1,-1,1,0,0},
236
- {"unwatch",unwatchCommand,1,"rs",0,NULL,0,0,0,0,0},
237
- {"cluster",clusterCommand,-2,"ar",0,NULL,0,0,0,0,0},
238
- {"restore",restoreCommand,4,"awm",0,NULL,1,1,1,0,0},
239
- {"migrate",migrateCommand,6,"aw",0,NULL,0,0,0,0,0},
240
- {"asking",askingCommand,1,"r",0,NULL,0,0,0,0,0},
241
- {"dump",dumpCommand,2,"ar",0,NULL,1,1,1,0,0},
242
- {"object",objectCommand,-2,"r",0,NULL,2,2,2,0,0},
243
- {"client",clientCommand,-2,"ar",0,NULL,0,0,0,0,0},
244
- {"eval",evalCommand,-3,"s",0,zunionInterGetKeys,0,0,0,0,0},
245
- {"evalsha",evalShaCommand,-3,"s",0,zunionInterGetKeys,0,0,0,0,0},
246
- {"slowlog",slowlogCommand,-2,"r",0,NULL,0,0,0,0,0},
247
- {"script",scriptCommand,-2,"ras",0,NULL,0,0,0,0,0},
248
- {"time",timeCommand,1,"rR",0,NULL,0,0,0,0,0},
249
- {"bitop",bitopCommand,-4,"wm",0,NULL,2,-1,1,0,0},
250
- {"bitcount",bitcountCommand,-2,"r",0,NULL,1,1,1,0,0}
251
- };
252
-
253
- /*============================ Utility functions ============================ */
254
-
255
- /* Low level logging. To use only for very big messages, otherwise
256
- * redisLog() is to prefer. */
257
- void redisLogRaw(int level, const char *msg) {
258
- const int syslogLevelMap[] = { LOG_DEBUG, LOG_INFO, LOG_NOTICE, LOG_WARNING };
259
- const char *c = ".-*#";
260
- FILE *fp;
261
- char buf[64];
262
- int rawmode = (level & REDIS_LOG_RAW);
263
-
264
- level &= 0xff; /* clear flags */
265
- if (level < server.verbosity) return;
266
-
267
- fp = (server.logfile == NULL) ? stdout : fopen(server.logfile,"a");
268
- if (!fp) return;
269
-
270
- if (rawmode) {
271
- fprintf(fp,"%s",msg);
272
- } else {
273
- int off;
274
- struct timeval tv;
275
-
276
- gettimeofday(&tv,NULL);
277
- off = strftime(buf,sizeof(buf),"%d %b %H:%M:%S.",localtime(&tv.tv_sec));
278
- snprintf(buf+off,sizeof(buf)-off,"%03d",(int)tv.tv_usec/1000);
279
- fprintf(fp,"[%d] %s %c %s\n",(int)getpid(),buf,c[level],msg);
280
- }
281
- fflush(fp);
282
-
283
- if (server.logfile) fclose(fp);
284
-
285
- if (server.syslog_enabled) syslog(syslogLevelMap[level], "%s", msg);
286
- }
287
-
288
- /* Like redisLogRaw() but with printf-alike support. This is the funciton that
289
- * is used across the code. The raw version is only used in order to dump
290
- * the INFO output on crash. */
291
- void redisLog(int level, const char *fmt, ...) {
292
- va_list ap;
293
- char msg[REDIS_MAX_LOGMSG_LEN];
294
-
295
- if ((level&0xff) < server.verbosity) return;
296
-
297
- va_start(ap, fmt);
298
- vsnprintf(msg, sizeof(msg), fmt, ap);
299
- va_end(ap);
300
-
301
- redisLogRaw(level,msg);
302
- }
303
-
304
- /* Log a fixed message without printf-alike capabilities, in a way that is
305
- * safe to call from a signal handler.
306
- *
307
- * We actually use this only for signals that are not fatal from the point
308
- * of view of Redis. Signals that are going to kill the server anyway and
309
- * where we need printf-alike features are served by redisLog(). */
310
- void redisLogFromHandler(int level, const char *msg) {
311
- int fd;
312
- char buf[64];
313
-
314
- if ((level&0xff) < server.verbosity ||
315
- (server.logfile == NULL && server.daemonize)) return;
316
- fd = server.logfile ?
317
- open(server.logfile, O_APPEND|O_CREAT|O_WRONLY, 0644) :
318
- STDOUT_FILENO;
319
- if (fd == -1) return;
320
- ll2string(buf,sizeof(buf),getpid());
321
- if (write(fd,"[",1) == -1) goto err;
322
- if (write(fd,buf,strlen(buf)) == -1) goto err;
323
- if (write(fd," | signal handler] (",20) == -1) goto err;
324
- ll2string(buf,sizeof(buf),time(NULL));
325
- if (write(fd,buf,strlen(buf)) == -1) goto err;
326
- if (write(fd,") ",2) == -1) goto err;
327
- if (write(fd,msg,strlen(msg)) == -1) goto err;
328
- if (write(fd,"\n",1) == -1) goto err;
329
- err:
330
- if (server.logfile) close(fd);
331
- }
332
-
333
- /* Redis generally does not try to recover from out of memory conditions
334
- * when allocating objects or strings, it is not clear if it will be possible
335
- * to report this condition to the client since the networking layer itself
336
- * is based on heap allocation for send buffers, so we simply abort.
337
- * At least the code will be simpler to read... */
338
- void oom(const char *msg) {
339
- redisLog(REDIS_WARNING, "%s: Out of memory\n",msg);
340
- sleep(1);
341
- abort();
342
- }
343
-
344
- /* Return the UNIX time in microseconds */
345
- long long ustime(void) {
346
- struct timeval tv;
347
- long long ust;
348
-
349
- gettimeofday(&tv, NULL);
350
- ust = ((long long)tv.tv_sec)*1000000;
351
- ust += tv.tv_usec;
352
- return ust;
353
- }
354
-
355
- /* Return the UNIX time in milliseconds */
356
- long long mstime(void) {
357
- return ustime()/1000;
358
- }
359
-
360
- /* After an RDB dump or AOF rewrite we exit from children using _exit() instead of
361
- * exit(), because the latter may interact with the same file objects used by
362
- * the parent process. However if we are testing the coverage normal exit() is
363
- * used in order to obtain the right coverage information. */
364
- void exitFromChild(int retcode) {
365
- #ifdef COVERAGE_TEST
366
- exit(retcode);
367
- #else
368
- _exit(retcode);
369
- #endif
370
- }
371
-
372
- /*====================== Hash table type implementation ==================== */
373
-
374
- /* This is an hash table type that uses the SDS dynamic strings libary as
375
- * keys and radis objects as values (objects can hold SDS strings,
376
- * lists, sets). */
377
-
378
- void dictVanillaFree(void *privdata, void *val)
379
- {
380
- DICT_NOTUSED(privdata);
381
- zfree(val);
382
- }
383
-
384
- void dictListDestructor(void *privdata, void *val)
385
- {
386
- DICT_NOTUSED(privdata);
387
- listRelease((list*)val);
388
- }
389
-
390
- int dictSdsKeyCompare(void *privdata, const void *key1,
391
- const void *key2)
392
- {
393
- int l1,l2;
394
- DICT_NOTUSED(privdata);
395
-
396
- l1 = sdslen((sds)key1);
397
- l2 = sdslen((sds)key2);
398
- if (l1 != l2) return 0;
399
- return memcmp(key1, key2, l1) == 0;
400
- }
401
-
402
- /* A case insensitive version used for the command lookup table. */
403
- int dictSdsKeyCaseCompare(void *privdata, const void *key1,
404
- const void *key2)
405
- {
406
- DICT_NOTUSED(privdata);
407
-
408
- return strcasecmp(key1, key2) == 0;
409
- }
410
-
411
- void dictRedisObjectDestructor(void *privdata, void *val)
412
- {
413
- DICT_NOTUSED(privdata);
414
-
415
- if (val == NULL) return; /* Values of swapped out keys as set to NULL */
416
- decrRefCount(val);
417
- }
418
-
419
- void dictSdsDestructor(void *privdata, void *val)
420
- {
421
- DICT_NOTUSED(privdata);
422
-
423
- sdsfree(val);
424
- }
425
-
426
- int dictObjKeyCompare(void *privdata, const void *key1,
427
- const void *key2)
428
- {
429
- const robj *o1 = key1, *o2 = key2;
430
- return dictSdsKeyCompare(privdata,o1->ptr,o2->ptr);
431
- }
432
-
433
- unsigned int dictObjHash(const void *key) {
434
- const robj *o = key;
435
- return dictGenHashFunction(o->ptr, sdslen((sds)o->ptr));
436
- }
437
-
438
- unsigned int dictSdsHash(const void *key) {
439
- return dictGenHashFunction((unsigned char*)key, sdslen((char*)key));
440
- }
441
-
442
- unsigned int dictSdsCaseHash(const void *key) {
443
- return dictGenCaseHashFunction((unsigned char*)key, sdslen((char*)key));
444
- }
445
-
446
- int dictEncObjKeyCompare(void *privdata, const void *key1,
447
- const void *key2)
448
- {
449
- robj *o1 = (robj*) key1, *o2 = (robj*) key2;
450
- int cmp;
451
-
452
- if (o1->encoding == REDIS_ENCODING_INT &&
453
- o2->encoding == REDIS_ENCODING_INT)
454
- return o1->ptr == o2->ptr;
455
-
456
- o1 = getDecodedObject(o1);
457
- o2 = getDecodedObject(o2);
458
- cmp = dictSdsKeyCompare(privdata,o1->ptr,o2->ptr);
459
- decrRefCount(o1);
460
- decrRefCount(o2);
461
- return cmp;
462
- }
463
-
464
- unsigned int dictEncObjHash(const void *key) {
465
- robj *o = (robj*) key;
466
-
467
- if (o->encoding == REDIS_ENCODING_RAW) {
468
- return dictGenHashFunction(o->ptr, sdslen((sds)o->ptr));
469
- } else {
470
- if (o->encoding == REDIS_ENCODING_INT) {
471
- char buf[32];
472
- int len;
473
-
474
- len = ll2string(buf,32,(long)o->ptr);
475
- return dictGenHashFunction((unsigned char*)buf, len);
476
- } else {
477
- unsigned int hash;
478
-
479
- o = getDecodedObject(o);
480
- hash = dictGenHashFunction(o->ptr, sdslen((sds)o->ptr));
481
- decrRefCount(o);
482
- return hash;
483
- }
484
- }
485
- }
486
-
487
- /* Sets type hash table */
488
- dictType setDictType = {
489
- dictEncObjHash, /* hash function */
490
- NULL, /* key dup */
491
- NULL, /* val dup */
492
- dictEncObjKeyCompare, /* key compare */
493
- dictRedisObjectDestructor, /* key destructor */
494
- NULL /* val destructor */
495
- };
496
-
497
- /* Sorted sets hash (note: a skiplist is used in addition to the hash table) */
498
- dictType zsetDictType = {
499
- dictEncObjHash, /* hash function */
500
- NULL, /* key dup */
501
- NULL, /* val dup */
502
- dictEncObjKeyCompare, /* key compare */
503
- dictRedisObjectDestructor, /* key destructor */
504
- NULL /* val destructor */
505
- };
506
-
507
- /* Db->dict, keys are sds strings, vals are Redis objects. */
508
- dictType dbDictType = {
509
- dictSdsHash, /* hash function */
510
- NULL, /* key dup */
511
- NULL, /* val dup */
512
- dictSdsKeyCompare, /* key compare */
513
- dictSdsDestructor, /* key destructor */
514
- dictRedisObjectDestructor /* val destructor */
515
- };
516
-
517
- /* Db->expires */
518
- dictType keyptrDictType = {
519
- dictSdsHash, /* hash function */
520
- NULL, /* key dup */
521
- NULL, /* val dup */
522
- dictSdsKeyCompare, /* key compare */
523
- NULL, /* key destructor */
524
- NULL /* val destructor */
525
- };
526
-
527
- /* Command table. sds string -> command struct pointer. */
528
- dictType commandTableDictType = {
529
- dictSdsCaseHash, /* hash function */
530
- NULL, /* key dup */
531
- NULL, /* val dup */
532
- dictSdsKeyCaseCompare, /* key compare */
533
- dictSdsDestructor, /* key destructor */
534
- NULL /* val destructor */
535
- };
536
-
537
- /* Hash type hash table (note that small hashes are represented with zimpaps) */
538
- dictType hashDictType = {
539
- dictEncObjHash, /* hash function */
540
- NULL, /* key dup */
541
- NULL, /* val dup */
542
- dictEncObjKeyCompare, /* key compare */
543
- dictRedisObjectDestructor, /* key destructor */
544
- dictRedisObjectDestructor /* val destructor */
545
- };
546
-
547
- /* Keylist hash table type has unencoded redis objects as keys and
548
- * lists as values. It's used for blocking operations (BLPOP) and to
549
- * map swapped keys to a list of clients waiting for this keys to be loaded. */
550
- dictType keylistDictType = {
551
- dictObjHash, /* hash function */
552
- NULL, /* key dup */
553
- NULL, /* val dup */
554
- dictObjKeyCompare, /* key compare */
555
- dictRedisObjectDestructor, /* key destructor */
556
- dictListDestructor /* val destructor */
557
- };
558
-
559
- /* Cluster nodes hash table, mapping nodes addresses 1.2.3.4:6379 to
560
- * clusterNode structures. */
561
- dictType clusterNodesDictType = {
562
- dictSdsHash, /* hash function */
563
- NULL, /* key dup */
564
- NULL, /* val dup */
565
- dictSdsKeyCompare, /* key compare */
566
- dictSdsDestructor, /* key destructor */
567
- NULL /* val destructor */
568
- };
569
-
570
- int htNeedsResize(dict *dict) {
571
- long long size, used;
572
-
573
- size = dictSlots(dict);
574
- used = dictSize(dict);
575
- return (size && used && size > DICT_HT_INITIAL_SIZE &&
576
- (used*100/size < REDIS_HT_MINFILL));
577
- }
578
-
579
- /* If the percentage of used slots in the HT reaches REDIS_HT_MINFILL
580
- * we resize the hash table to save memory */
581
- void tryResizeHashTables(void) {
582
- int j;
583
-
584
- for (j = 0; j < server.dbnum; j++) {
585
- if (htNeedsResize(server.db[j].dict))
586
- dictResize(server.db[j].dict);
587
- if (htNeedsResize(server.db[j].expires))
588
- dictResize(server.db[j].expires);
589
- }
590
- }
591
-
592
- /* Our hash table implementation performs rehashing incrementally while
593
- * we write/read from the hash table. Still if the server is idle, the hash
594
- * table will use two tables for a long time. So we try to use 1 millisecond
595
- * of CPU time at every serverCron() loop in order to rehash some key. */
596
- void incrementallyRehash(void) {
597
- int j;
598
-
599
- for (j = 0; j < server.dbnum; j++) {
600
- /* Keys dictionary */
601
- if (dictIsRehashing(server.db[j].dict)) {
602
- dictRehashMilliseconds(server.db[j].dict,1);
603
- break; /* already used our millisecond for this loop... */
604
- }
605
- /* Expires */
606
- if (dictIsRehashing(server.db[j].expires)) {
607
- dictRehashMilliseconds(server.db[j].expires,1);
608
- break; /* already used our millisecond for this loop... */
609
- }
610
- }
611
- }
612
-
613
- /* This function is called once a background process of some kind terminates,
614
- * as we want to avoid resizing the hash tables when there is a child in order
615
- * to play well with copy-on-write (otherwise when a resize happens lots of
616
- * memory pages are copied). The goal of this function is to update the ability
617
- * for dict.c to resize the hash tables accordingly to the fact we have o not
618
- * running childs. */
619
- void updateDictResizePolicy(void) {
620
- if (server.rdb_child_pid == -1 && server.aof_child_pid == -1)
621
- dictEnableResize();
622
- else
623
- dictDisableResize();
624
- }
625
-
626
- /* ======================= Cron: called every 100 ms ======================== */
627
-
628
- /* Try to expire a few timed out keys. The algorithm used is adaptive and
629
- * will use few CPU cycles if there are few expiring keys, otherwise
630
- * it will get more aggressive to avoid that too much memory is used by
631
- * keys that can be removed from the keyspace. */
632
- void activeExpireCycle(void) {
633
- int j, iteration = 0;
634
- long long start = ustime(), timelimit;
635
-
636
- /* We can use at max REDIS_EXPIRELOOKUPS_TIME_PERC percentage of CPU time
637
- * per iteration. Since this function gets called with a frequency of
638
- * REDIS_HZ times per second, the following is the max amount of
639
- * microseconds we can spend in this function. */
640
- timelimit = 1000000*REDIS_EXPIRELOOKUPS_TIME_PERC/REDIS_HZ/100;
641
- if (timelimit <= 0) timelimit = 1;
642
-
643
- for (j = 0; j < server.dbnum; j++) {
644
- int expired;
645
- redisDb *db = server.db+j;
646
-
647
- /* Continue to expire if at the end of the cycle more than 25%
648
- * of the keys were expired. */
649
- do {
650
- unsigned long num = dictSize(db->expires);
651
- unsigned long slots = dictSlots(db->expires);
652
- long long now = mstime();
653
-
654
- /* When there are less than 1% filled slots getting random
655
- * keys is expensive, so stop here waiting for better times...
656
- * The dictionary will be resized asap. */
657
- if (num && slots > DICT_HT_INITIAL_SIZE &&
658
- (num*100/slots < 1)) break;
659
-
660
- /* The main collection cycle. Sample random keys among keys
661
- * with an expire set, checking for expired ones. */
662
- expired = 0;
663
- if (num > REDIS_EXPIRELOOKUPS_PER_CRON)
664
- num = REDIS_EXPIRELOOKUPS_PER_CRON;
665
- while (num--) {
666
- dictEntry *de;
667
- long long t;
668
-
669
- if ((de = dictGetRandomKey(db->expires)) == NULL) break;
670
- t = dictGetSignedIntegerVal(de);
671
- if (now > t) {
672
- sds key = dictGetKey(de);
673
- robj *keyobj = createStringObject(key,sdslen(key));
674
-
675
- propagateExpire(db,keyobj);
676
- dbDelete(db,keyobj);
677
- decrRefCount(keyobj);
678
- expired++;
679
- server.stat_expiredkeys++;
680
- }
681
- }
682
- /* We can't block forever here even if there are many keys to
683
- * expire. So after a given amount of milliseconds return to the
684
- * caller waiting for the other active expire cycle. */
685
- iteration++;
686
- if ((iteration & 0xf) == 0 && /* check once every 16 cycles. */
687
- (ustime()-start) > timelimit) return;
688
- } while (expired > REDIS_EXPIRELOOKUPS_PER_CRON/4);
689
- }
690
- }
691
-
692
- void updateLRUClock(void) {
693
- server.lruclock = (server.unixtime/REDIS_LRU_CLOCK_RESOLUTION) &
694
- REDIS_LRU_CLOCK_MAX;
695
- }
696
-
697
-
698
- /* Add a sample to the operations per second array of samples. */
699
- void trackOperationsPerSecond(void) {
700
- long long t = mstime() - server.ops_sec_last_sample_time;
701
- long long ops = server.stat_numcommands - server.ops_sec_last_sample_ops;
702
- long long ops_sec;
703
-
704
- ops_sec = t > 0 ? (ops*1000/t) : 0;
705
-
706
- server.ops_sec_samples[server.ops_sec_idx] = ops_sec;
707
- server.ops_sec_idx = (server.ops_sec_idx+1) % REDIS_OPS_SEC_SAMPLES;
708
- server.ops_sec_last_sample_time = mstime();
709
- server.ops_sec_last_sample_ops = server.stat_numcommands;
710
- }
711
-
712
- /* Return the mean of all the samples. */
713
- long long getOperationsPerSecond(void) {
714
- int j;
715
- long long sum = 0;
716
-
717
- for (j = 0; j < REDIS_OPS_SEC_SAMPLES; j++)
718
- sum += server.ops_sec_samples[j];
719
- return sum / REDIS_OPS_SEC_SAMPLES;
720
- }
721
-
722
- /* Check for timeouts. Returns non-zero if the client was terminated */
723
- int clientsCronHandleTimeout(redisClient *c) {
724
- time_t now = server.unixtime;
725
-
726
- if (server.maxidletime &&
727
- !(c->flags & REDIS_SLAVE) && /* no timeout for slaves */
728
- !(c->flags & REDIS_MASTER) && /* no timeout for masters */
729
- !(c->flags & REDIS_BLOCKED) && /* no timeout for BLPOP */
730
- dictSize(c->pubsub_channels) == 0 && /* no timeout for pubsub */
731
- listLength(c->pubsub_patterns) == 0 &&
732
- (now - c->lastinteraction > server.maxidletime))
733
- {
734
- redisLog(REDIS_VERBOSE,"Closing idle client");
735
- freeClient(c);
736
- return 1;
737
- } else if (c->flags & REDIS_BLOCKED) {
738
- if (c->bpop.timeout != 0 && c->bpop.timeout < now) {
739
- addReply(c,shared.nullmultibulk);
740
- unblockClientWaitingData(c);
741
- }
742
- }
743
- return 0;
744
- }
745
-
746
- /* The client query buffer is an sds.c string that can end with a lot of
747
- * free space not used, this function reclaims space if needed.
748
- *
749
- * The funciton always returns 0 as it never terminates the client. */
750
- int clientsCronResizeQueryBuffer(redisClient *c) {
751
- size_t querybuf_size = sdsAllocSize(c->querybuf);
752
- time_t idletime = server.unixtime - c->lastinteraction;
753
-
754
- /* There are two conditions to resize the query buffer:
755
- * 1) Query buffer is > BIG_ARG and too big for latest peak.
756
- * 2) Client is inactive and the buffer is bigger than 1k. */
757
- if (((querybuf_size > REDIS_MBULK_BIG_ARG) &&
758
- (querybuf_size/(c->querybuf_peak+1)) > 2) ||
759
- (querybuf_size > 1024 && idletime > 2))
760
- {
761
- /* Only resize the query buffer if it is actually wasting space. */
762
- if (sdsavail(c->querybuf) > 1024) {
763
- c->querybuf = sdsRemoveFreeSpace(c->querybuf);
764
- }
765
- }
766
- /* Reset the peak again to capture the peak memory usage in the next
767
- * cycle. */
768
- c->querybuf_peak = 0;
769
- return 0;
770
- }
771
-
772
- void clientsCron(void) {
773
- /* Make sure to process at least 1/(REDIS_HZ*10) of clients per call.
774
- * Since this function is called REDIS_HZ times per second we are sure that
775
- * in the worst case we process all the clients in 10 seconds.
776
- * In normal conditions (a reasonable number of clients) we process
777
- * all the clients in a shorter time. */
778
- int numclients = listLength(server.clients);
779
- int iterations = numclients/(REDIS_HZ*10);
780
-
781
- if (iterations < 50)
782
- iterations = (numclients < 50) ? numclients : 50;
783
- while(listLength(server.clients) && iterations--) {
784
- redisClient *c;
785
- listNode *head;
786
-
787
- /* Rotate the list, take the current head, process.
788
- * This way if the client must be removed from the list it's the
789
- * first element and we don't incur into O(N) computation. */
790
- listRotate(server.clients);
791
- head = listFirst(server.clients);
792
- c = listNodeValue(head);
793
- /* The following functions do different service checks on the client.
794
- * The protocol is that they return non-zero if the client was
795
- * terminated. */
796
- if (clientsCronHandleTimeout(c)) continue;
797
- if (clientsCronResizeQueryBuffer(c)) continue;
798
- }
799
- }
800
-
801
- /* This is our timer interrupt, called REDIS_HZ times per second.
802
- * Here is where we do a number of things that need to be done asynchronously.
803
- * For instance:
804
- *
805
- * - Active expired keys collection (it is also performed in a lazy way on
806
- * lookup).
807
- * - Software watchdong.
808
- * - Update some statistic.
809
- * - Incremental rehashing of the DBs hash tables.
810
- * - Triggering BGSAVE / AOF rewrite, and handling of terminated children.
811
- * - Clients timeout of differnet kinds.
812
- * - Replication reconnection.
813
- * - Many more...
814
- *
815
- * Everything directly called here will be called REDIS_HZ times per second,
816
- * so in order to throttle execution of things we want to do less frequently
817
- * a macro is used: run_with_period(milliseconds) { .... }
818
- */
819
-
820
- /* Using the following macro you can run code inside serverCron() with the
821
- * specified period, specified in milliseconds.
822
- * The actual resolution depends on REDIS_HZ. */
823
- #define run_with_period(_ms_) if (!(loops % ((_ms_)/(1000/REDIS_HZ))))
824
-
825
- int serverCron(struct aeEventLoop *eventLoop, long long id, void *clientData) {
826
- int j, loops = server.cronloops;
827
- REDIS_NOTUSED(eventLoop);
828
- REDIS_NOTUSED(id);
829
- REDIS_NOTUSED(clientData);
830
-
831
- /* Software watchdog: deliver the SIGALRM that will reach the signal
832
- * handler if we don't return here fast enough. */
833
- if (server.watchdog_period) watchdogScheduleSignal(server.watchdog_period);
834
-
835
- /* We take a cached value of the unix time in the global state because
836
- * with virtual memory and aging there is to store the current time
837
- * in objects at every object access, and accuracy is not needed.
838
- * To access a global var is faster than calling time(NULL) */
839
- server.unixtime = time(NULL);
840
-
841
- run_with_period(100) trackOperationsPerSecond();
842
-
843
- /* We have just 22 bits per object for LRU information.
844
- * So we use an (eventually wrapping) LRU clock with 10 seconds resolution.
845
- * 2^22 bits with 10 seconds resoluton is more or less 1.5 years.
846
- *
847
- * Note that even if this will wrap after 1.5 years it's not a problem,
848
- * everything will still work but just some object will appear younger
849
- * to Redis. But for this to happen a given object should never be touched
850
- * for 1.5 years.
851
- *
852
- * Note that you can change the resolution altering the
853
- * REDIS_LRU_CLOCK_RESOLUTION define.
854
- */
855
- updateLRUClock();
856
-
857
- /* Record the max memory used since the server was started. */
858
- if (zmalloc_used_memory() > server.stat_peak_memory)
859
- server.stat_peak_memory = zmalloc_used_memory();
860
-
861
- /* We received a SIGTERM, shutting down here in a safe way, as it is
862
- * not ok doing so inside the signal handler. */
863
- if (server.shutdown_asap) {
864
- if (prepareForShutdown(0) == REDIS_OK) exit(0);
865
- redisLog(REDIS_WARNING,"SIGTERM received but errors trying to shut down the server, check the logs for more information");
866
- }
867
-
868
- /* Show some info about non-empty databases */
869
- run_with_period(5000) {
870
- for (j = 0; j < server.dbnum; j++) {
871
- long long size, used, vkeys;
872
-
873
- size = dictSlots(server.db[j].dict);
874
- used = dictSize(server.db[j].dict);
875
- vkeys = dictSize(server.db[j].expires);
876
- if (used || vkeys) {
877
- redisLog(REDIS_VERBOSE,"DB %d: %lld keys (%lld volatile) in %lld slots HT.",j,used,vkeys,size);
878
- /* dictPrintStats(server.dict); */
879
- }
880
- }
881
- }
882
-
883
- /* We don't want to resize the hash tables while a bacground saving
884
- * is in progress: the saving child is created using fork() that is
885
- * implemented with a copy-on-write semantic in most modern systems, so
886
- * if we resize the HT while there is the saving child at work actually
887
- * a lot of memory movements in the parent will cause a lot of pages
888
- * copied. */
889
- if (server.rdb_child_pid == -1 && server.aof_child_pid == -1) {
890
- tryResizeHashTables();
891
- if (server.activerehashing) incrementallyRehash();
892
- }
893
-
894
- /* Show information about connected clients */
895
- run_with_period(5000) {
896
- redisLog(REDIS_VERBOSE,"%d clients connected (%d slaves), %zu bytes in use",
897
- listLength(server.clients)-listLength(server.slaves),
898
- listLength(server.slaves),
899
- zmalloc_used_memory());
900
- }
901
-
902
- /* We need to do a few operations on clients asynchronously. */
903
- clientsCron();
904
-
905
- /* Start a scheduled AOF rewrite if this was requested by the user while
906
- * a BGSAVE was in progress. */
907
- if (server.rdb_child_pid == -1 && server.aof_child_pid == -1 &&
908
- server.aof_rewrite_scheduled)
909
- {
910
- rewriteAppendOnlyFileBackground();
911
- }
912
-
913
- /* Check if a background saving or AOF rewrite in progress terminated. */
914
- if (server.rdb_child_pid != -1 || server.aof_child_pid != -1) {
915
- int statloc;
916
- pid_t pid;
917
-
918
- if ((pid = wait3(&statloc,WNOHANG,NULL)) != 0) {
919
- int exitcode = WEXITSTATUS(statloc);
920
- int bysignal = 0;
921
-
922
- if (WIFSIGNALED(statloc)) bysignal = WTERMSIG(statloc);
923
-
924
- if (pid == server.rdb_child_pid) {
925
- backgroundSaveDoneHandler(exitcode,bysignal);
926
- } else {
927
- backgroundRewriteDoneHandler(exitcode,bysignal);
928
- }
929
- updateDictResizePolicy();
930
- }
931
- } else {
932
- /* If there is not a background saving/rewrite in progress check if
933
- * we have to save/rewrite now */
934
- for (j = 0; j < server.saveparamslen; j++) {
935
- struct saveparam *sp = server.saveparams+j;
936
-
937
- if (server.dirty >= sp->changes &&
938
- server.unixtime-server.lastsave > sp->seconds) {
939
- redisLog(REDIS_NOTICE,"%d changes in %d seconds. Saving...",
940
- sp->changes, sp->seconds);
941
- rdbSaveBackground(server.rdb_filename);
942
- break;
943
- }
944
- }
945
-
946
- /* Trigger an AOF rewrite if needed */
947
- if (server.rdb_child_pid == -1 &&
948
- server.aof_child_pid == -1 &&
949
- server.aof_rewrite_perc &&
950
- server.aof_current_size > server.aof_rewrite_min_size)
951
- {
952
- long long base = server.aof_rewrite_base_size ?
953
- server.aof_rewrite_base_size : 1;
954
- long long growth = (server.aof_current_size*100/base) - 100;
955
- if (growth >= server.aof_rewrite_perc) {
956
- redisLog(REDIS_NOTICE,"Starting automatic rewriting of AOF on %lld%% growth",growth);
957
- rewriteAppendOnlyFileBackground();
958
- }
959
- }
960
- }
961
-
962
-
963
- /* If we postponed an AOF buffer flush, let's try to do it every time the
964
- * cron function is called. */
965
- if (server.aof_flush_postponed_start) flushAppendOnlyFile(0);
966
-
967
- /* Expire a few keys per cycle, only if this is a master.
968
- * On slaves we wait for DEL operations synthesized by the master
969
- * in order to guarantee a strict consistency. */
970
- if (server.masterhost == NULL) activeExpireCycle();
971
-
972
- /* Close clients that need to be closed asynchronous */
973
- freeClientsInAsyncFreeQueue();
974
-
975
- /* Replication cron function -- used to reconnect to master and
976
- * to detect transfer failures. */
977
- run_with_period(1000) replicationCron();
978
-
979
- /* Run other sub-systems specific cron jobs */
980
- run_with_period(1000) {
981
- if (server.cluster_enabled) clusterCron();
982
- }
983
-
984
- server.cronloops++;
985
- return 1000/REDIS_HZ;
986
- }
987
-
988
- /* This function gets called every time Redis is entering the
989
- * main loop of the event driven library, that is, before to sleep
990
- * for ready file descriptors. */
991
- void beforeSleep(struct aeEventLoop *eventLoop) {
992
- REDIS_NOTUSED(eventLoop);
993
- listNode *ln;
994
- redisClient *c;
995
-
996
- /* Try to process pending commands for clients that were just unblocked. */
997
- while (listLength(server.unblocked_clients)) {
998
- ln = listFirst(server.unblocked_clients);
999
- redisAssert(ln != NULL);
1000
- c = ln->value;
1001
- listDelNode(server.unblocked_clients,ln);
1002
- c->flags &= ~REDIS_UNBLOCKED;
1003
-
1004
- /* Process remaining data in the input buffer. */
1005
- if (c->querybuf && sdslen(c->querybuf) > 0) {
1006
- server.current_client = c;
1007
- processInputBuffer(c);
1008
- server.current_client = NULL;
1009
- }
1010
- }
1011
-
1012
- /* Write the AOF buffer on disk */
1013
- flushAppendOnlyFile(0);
1014
- }
1015
-
1016
- /* =========================== Server initialization ======================== */
1017
-
1018
- void createSharedObjects(void) {
1019
- int j;
1020
-
1021
- shared.crlf = createObject(REDIS_STRING,sdsnew("\r\n"));
1022
- shared.ok = createObject(REDIS_STRING,sdsnew("+OK\r\n"));
1023
- shared.err = createObject(REDIS_STRING,sdsnew("-ERR\r\n"));
1024
- shared.emptybulk = createObject(REDIS_STRING,sdsnew("$0\r\n\r\n"));
1025
- shared.czero = createObject(REDIS_STRING,sdsnew(":0\r\n"));
1026
- shared.cone = createObject(REDIS_STRING,sdsnew(":1\r\n"));
1027
- shared.cnegone = createObject(REDIS_STRING,sdsnew(":-1\r\n"));
1028
- shared.nullbulk = createObject(REDIS_STRING,sdsnew("$-1\r\n"));
1029
- shared.nullmultibulk = createObject(REDIS_STRING,sdsnew("*-1\r\n"));
1030
- shared.emptymultibulk = createObject(REDIS_STRING,sdsnew("*0\r\n"));
1031
- shared.pong = createObject(REDIS_STRING,sdsnew("+PONG\r\n"));
1032
- shared.queued = createObject(REDIS_STRING,sdsnew("+QUEUED\r\n"));
1033
- shared.wrongtypeerr = createObject(REDIS_STRING,sdsnew(
1034
- "-ERR Operation against a key holding the wrong kind of value\r\n"));
1035
- shared.nokeyerr = createObject(REDIS_STRING,sdsnew(
1036
- "-ERR no such key\r\n"));
1037
- shared.syntaxerr = createObject(REDIS_STRING,sdsnew(
1038
- "-ERR syntax error\r\n"));
1039
- shared.sameobjecterr = createObject(REDIS_STRING,sdsnew(
1040
- "-ERR source and destination objects are the same\r\n"));
1041
- shared.outofrangeerr = createObject(REDIS_STRING,sdsnew(
1042
- "-ERR index out of range\r\n"));
1043
- shared.noscripterr = createObject(REDIS_STRING,sdsnew(
1044
- "-NOSCRIPT No matching script. Please use EVAL.\r\n"));
1045
- shared.loadingerr = createObject(REDIS_STRING,sdsnew(
1046
- "-LOADING Redis is loading the dataset in memory\r\n"));
1047
- shared.slowscripterr = createObject(REDIS_STRING,sdsnew(
1048
- "-BUSY Redis is busy running a script. You can only call SCRIPT KILL or SHUTDOWN NOSAVE.\r\n"));
1049
- shared.masterdownerr = createObject(REDIS_STRING,sdsnew(
1050
- "-MASTERDOWN Link with MASTER is down and slave-serve-stale-data is set to 'no'.\r\n"));
1051
- shared.bgsaveerr = createObject(REDIS_STRING,sdsnew(
1052
- "-MISCONF Redis is configured to save RDB snapshots, but is currently not able to persist on disk. Commands that may modify the data set are disabled. Please check Redis logs for details about the error.\r\n"));
1053
- shared.roslaveerr = createObject(REDIS_STRING,sdsnew(
1054
- "-READONLY You can't write against a read only slave.\r\n"));
1055
- shared.oomerr = createObject(REDIS_STRING,sdsnew(
1056
- "-OOM command not allowed when used memory > 'maxmemory'.\r\n"));
1057
- shared.space = createObject(REDIS_STRING,sdsnew(" "));
1058
- shared.colon = createObject(REDIS_STRING,sdsnew(":"));
1059
- shared.plus = createObject(REDIS_STRING,sdsnew("+"));
1060
-
1061
- for (j = 0; j < REDIS_SHARED_SELECT_CMDS; j++) {
1062
- shared.select[j] = createObject(REDIS_STRING,
1063
- sdscatprintf(sdsempty(),"select %d\r\n", j));
1064
- }
1065
- shared.messagebulk = createStringObject("$7\r\nmessage\r\n",13);
1066
- shared.pmessagebulk = createStringObject("$8\r\npmessage\r\n",14);
1067
- shared.subscribebulk = createStringObject("$9\r\nsubscribe\r\n",15);
1068
- shared.unsubscribebulk = createStringObject("$11\r\nunsubscribe\r\n",18);
1069
- shared.psubscribebulk = createStringObject("$10\r\npsubscribe\r\n",17);
1070
- shared.punsubscribebulk = createStringObject("$12\r\npunsubscribe\r\n",19);
1071
- shared.del = createStringObject("DEL",3);
1072
- shared.rpop = createStringObject("RPOP",4);
1073
- shared.lpop = createStringObject("LPOP",4);
1074
- for (j = 0; j < REDIS_SHARED_INTEGERS; j++) {
1075
- shared.integers[j] = createObject(REDIS_STRING,(void*)(long)j);
1076
- shared.integers[j]->encoding = REDIS_ENCODING_INT;
1077
- }
1078
- for (j = 0; j < REDIS_SHARED_BULKHDR_LEN; j++) {
1079
- shared.mbulkhdr[j] = createObject(REDIS_STRING,
1080
- sdscatprintf(sdsempty(),"*%d\r\n",j));
1081
- shared.bulkhdr[j] = createObject(REDIS_STRING,
1082
- sdscatprintf(sdsempty(),"$%d\r\n",j));
1083
- }
1084
- }
1085
-
1086
- void initServerConfig() {
1087
- getRandomHexChars(server.runid,REDIS_RUN_ID_SIZE);
1088
- server.runid[REDIS_RUN_ID_SIZE] = '\0';
1089
- server.arch_bits = (sizeof(long) == 8) ? 64 : 32;
1090
- server.port = REDIS_SERVERPORT;
1091
- server.bindaddr = NULL;
1092
- server.unixsocket = NULL;
1093
- server.unixsocketperm = 0;
1094
- server.ipfd = -1;
1095
- server.sofd = -1;
1096
- server.dbnum = REDIS_DEFAULT_DBNUM;
1097
- server.verbosity = REDIS_NOTICE;
1098
- server.maxidletime = REDIS_MAXIDLETIME;
1099
- server.client_max_querybuf_len = REDIS_MAX_QUERYBUF_LEN;
1100
- server.saveparams = NULL;
1101
- server.loading = 0;
1102
- server.logfile = NULL; /* NULL = log on standard output */
1103
- server.syslog_enabled = 0;
1104
- server.syslog_ident = zstrdup("redis");
1105
- server.syslog_facility = LOG_LOCAL0;
1106
- server.daemonize = 0;
1107
- server.aof_state = REDIS_AOF_OFF;
1108
- server.aof_fsync = AOF_FSYNC_EVERYSEC;
1109
- server.aof_no_fsync_on_rewrite = 0;
1110
- server.aof_rewrite_perc = REDIS_AOF_REWRITE_PERC;
1111
- server.aof_rewrite_min_size = REDIS_AOF_REWRITE_MIN_SIZE;
1112
- server.aof_rewrite_base_size = 0;
1113
- server.aof_rewrite_scheduled = 0;
1114
- server.aof_last_fsync = time(NULL);
1115
- server.aof_rewrite_time_last = -1;
1116
- server.aof_rewrite_time_start = -1;
1117
- server.aof_delayed_fsync = 0;
1118
- server.aof_fd = -1;
1119
- server.aof_selected_db = -1; /* Make sure the first time will not match */
1120
- server.aof_flush_postponed_start = 0;
1121
- server.pidfile = zstrdup("/var/run/redis.pid");
1122
- server.rdb_filename = zstrdup("dump.rdb");
1123
- server.aof_filename = zstrdup("appendonly.aof");
1124
- server.requirepass = NULL;
1125
- server.rdb_compression = 1;
1126
- server.rdb_checksum = 1;
1127
- server.activerehashing = 1;
1128
- server.maxclients = REDIS_MAX_CLIENTS;
1129
- server.bpop_blocked_clients = 0;
1130
- server.maxmemory = 0;
1131
- server.maxmemory_policy = REDIS_MAXMEMORY_VOLATILE_LRU;
1132
- server.maxmemory_samples = 3;
1133
- server.hash_max_ziplist_entries = REDIS_HASH_MAX_ZIPLIST_ENTRIES;
1134
- server.hash_max_ziplist_value = REDIS_HASH_MAX_ZIPLIST_VALUE;
1135
- server.list_max_ziplist_entries = REDIS_LIST_MAX_ZIPLIST_ENTRIES;
1136
- server.list_max_ziplist_value = REDIS_LIST_MAX_ZIPLIST_VALUE;
1137
- server.set_max_intset_entries = REDIS_SET_MAX_INTSET_ENTRIES;
1138
- server.zset_max_ziplist_entries = REDIS_ZSET_MAX_ZIPLIST_ENTRIES;
1139
- server.zset_max_ziplist_value = REDIS_ZSET_MAX_ZIPLIST_VALUE;
1140
- server.shutdown_asap = 0;
1141
- server.repl_ping_slave_period = REDIS_REPL_PING_SLAVE_PERIOD;
1142
- server.repl_timeout = REDIS_REPL_TIMEOUT;
1143
- server.cluster_enabled = 0;
1144
- server.cluster.configfile = zstrdup("nodes.conf");
1145
- server.lua_caller = NULL;
1146
- server.lua_time_limit = REDIS_LUA_TIME_LIMIT;
1147
- server.lua_client = NULL;
1148
- server.lua_timedout = 0;
1149
-
1150
- updateLRUClock();
1151
- resetServerSaveParams();
1152
-
1153
- appendServerSaveParams(60*60,1); /* save after 1 hour and 1 change */
1154
- appendServerSaveParams(300,100); /* save after 5 minutes and 100 changes */
1155
- appendServerSaveParams(60,10000); /* save after 1 minute and 10000 changes */
1156
- /* Replication related */
1157
- server.masterauth = NULL;
1158
- server.masterhost = NULL;
1159
- server.masterport = 6379;
1160
- server.master = NULL;
1161
- server.repl_state = REDIS_REPL_NONE;
1162
- server.repl_syncio_timeout = REDIS_REPL_SYNCIO_TIMEOUT;
1163
- server.repl_serve_stale_data = 1;
1164
- server.repl_slave_ro = 1;
1165
- server.repl_down_since = time(NULL);
1166
-
1167
- /* Client output buffer limits */
1168
- server.client_obuf_limits[REDIS_CLIENT_LIMIT_CLASS_NORMAL].hard_limit_bytes = 0;
1169
- server.client_obuf_limits[REDIS_CLIENT_LIMIT_CLASS_NORMAL].soft_limit_bytes = 0;
1170
- server.client_obuf_limits[REDIS_CLIENT_LIMIT_CLASS_NORMAL].soft_limit_seconds = 0;
1171
- server.client_obuf_limits[REDIS_CLIENT_LIMIT_CLASS_SLAVE].hard_limit_bytes = 1024*1024*256;
1172
- server.client_obuf_limits[REDIS_CLIENT_LIMIT_CLASS_SLAVE].soft_limit_bytes = 1024*1024*64;
1173
- server.client_obuf_limits[REDIS_CLIENT_LIMIT_CLASS_SLAVE].soft_limit_seconds = 60;
1174
- server.client_obuf_limits[REDIS_CLIENT_LIMIT_CLASS_PUBSUB].hard_limit_bytes = 1024*1024*32;
1175
- server.client_obuf_limits[REDIS_CLIENT_LIMIT_CLASS_PUBSUB].soft_limit_bytes = 1024*1024*8;
1176
- server.client_obuf_limits[REDIS_CLIENT_LIMIT_CLASS_PUBSUB].soft_limit_seconds = 60;
1177
-
1178
- /* Double constants initialization */
1179
- R_Zero = 0.0;
1180
- R_PosInf = 1.0/R_Zero;
1181
- R_NegInf = -1.0/R_Zero;
1182
- R_Nan = R_Zero/R_Zero;
1183
-
1184
- /* Command table -- we intiialize it here as it is part of the
1185
- * initial configuration, since command names may be changed via
1186
- * redis.conf using the rename-command directive. */
1187
- server.commands = dictCreate(&commandTableDictType,NULL);
1188
- populateCommandTable();
1189
- server.delCommand = lookupCommandByCString("del");
1190
- server.multiCommand = lookupCommandByCString("multi");
1191
- server.lpushCommand = lookupCommandByCString("lpush");
1192
-
1193
- /* Slow log */
1194
- server.slowlog_log_slower_than = REDIS_SLOWLOG_LOG_SLOWER_THAN;
1195
- server.slowlog_max_len = REDIS_SLOWLOG_MAX_LEN;
1196
-
1197
- /* Debugging */
1198
- server.assert_failed = "<no assertion failed>";
1199
- server.assert_file = "<no file>";
1200
- server.assert_line = 0;
1201
- server.bug_report_start = 0;
1202
- server.watchdog_period = 0;
1203
- }
1204
-
1205
- /* This function will try to raise the max number of open files accordingly to
1206
- * the configured max number of clients. It will also account for 32 additional
1207
- * file descriptors as we need a few more for persistence, listening
1208
- * sockets, log files and so forth.
1209
- *
1210
- * If it will not be possible to set the limit accordingly to the configured
1211
- * max number of clients, the function will do the reverse setting
1212
- * server.maxclients to the value that we can actually handle. */
1213
- void adjustOpenFilesLimit(void) {
1214
- rlim_t maxfiles = server.maxclients+32;
1215
- struct rlimit limit;
1216
-
1217
- if (getrlimit(RLIMIT_NOFILE,&limit) == -1) {
1218
- redisLog(REDIS_WARNING,"Unable to obtain the current NOFILE limit (%s), assuming 1024 and setting the max clients configuration accordingly.",
1219
- strerror(errno));
1220
- server.maxclients = 1024-32;
1221
- } else {
1222
- rlim_t oldlimit = limit.rlim_cur;
1223
-
1224
- /* Set the max number of files if the current limit is not enough
1225
- * for our needs. */
1226
- if (oldlimit < maxfiles) {
1227
- rlim_t f;
1228
-
1229
- f = maxfiles;
1230
- while(f > oldlimit) {
1231
- limit.rlim_cur = f;
1232
- limit.rlim_max = f;
1233
- if (setrlimit(RLIMIT_NOFILE,&limit) != -1) break;
1234
- f -= 128;
1235
- }
1236
- if (f < oldlimit) f = oldlimit;
1237
- if (f != maxfiles) {
1238
- server.maxclients = f-32;
1239
- redisLog(REDIS_WARNING,"Unable to set the max number of files limit to %d (%s), setting the max clients configuration to %d.",
1240
- (int) maxfiles, strerror(errno), (int) server.maxclients);
1241
- } else {
1242
- redisLog(REDIS_NOTICE,"Max number of open files set to %d",
1243
- (int) maxfiles);
1244
- }
1245
- }
1246
- }
1247
- }
1248
-
1249
- void initServer() {
1250
- int j;
1251
-
1252
- signal(SIGHUP, SIG_IGN);
1253
- signal(SIGPIPE, SIG_IGN);
1254
- setupSignalHandlers();
1255
-
1256
- if (server.syslog_enabled) {
1257
- openlog(server.syslog_ident, LOG_PID | LOG_NDELAY | LOG_NOWAIT,
1258
- server.syslog_facility);
1259
- }
1260
-
1261
- server.current_client = NULL;
1262
- server.clients = listCreate();
1263
- server.clients_to_close = listCreate();
1264
- server.slaves = listCreate();
1265
- server.monitors = listCreate();
1266
- server.unblocked_clients = listCreate();
1267
-
1268
- createSharedObjects();
1269
- adjustOpenFilesLimit();
1270
- server.el = aeCreateEventLoop(server.maxclients+1024);
1271
- server.db = zmalloc(sizeof(redisDb)*server.dbnum);
1272
-
1273
- if (server.port != 0) {
1274
- server.ipfd = anetTcpServer(server.neterr,server.port,server.bindaddr);
1275
- if (server.ipfd == ANET_ERR) {
1276
- redisLog(REDIS_WARNING, "Opening port %d: %s",
1277
- server.port, server.neterr);
1278
- exit(1);
1279
- }
1280
- }
1281
- if (server.unixsocket != NULL) {
1282
- unlink(server.unixsocket); /* don't care if this fails */
1283
- server.sofd = anetUnixServer(server.neterr,server.unixsocket,server.unixsocketperm);
1284
- if (server.sofd == ANET_ERR) {
1285
- redisLog(REDIS_WARNING, "Opening socket: %s", server.neterr);
1286
- exit(1);
1287
- }
1288
- }
1289
- if (server.ipfd < 0 && server.sofd < 0) {
1290
- redisLog(REDIS_WARNING, "Configured to not listen anywhere, exiting.");
1291
- exit(1);
1292
- }
1293
- for (j = 0; j < server.dbnum; j++) {
1294
- server.db[j].dict = dictCreate(&dbDictType,NULL);
1295
- server.db[j].expires = dictCreate(&keyptrDictType,NULL);
1296
- server.db[j].blocking_keys = dictCreate(&keylistDictType,NULL);
1297
- server.db[j].watched_keys = dictCreate(&keylistDictType,NULL);
1298
- server.db[j].id = j;
1299
- }
1300
- server.pubsub_channels = dictCreate(&keylistDictType,NULL);
1301
- server.pubsub_patterns = listCreate();
1302
- listSetFreeMethod(server.pubsub_patterns,freePubsubPattern);
1303
- listSetMatchMethod(server.pubsub_patterns,listMatchPubsubPattern);
1304
- server.cronloops = 0;
1305
- server.rdb_child_pid = -1;
1306
- server.aof_child_pid = -1;
1307
- aofRewriteBufferReset();
1308
- server.aof_buf = sdsempty();
1309
- server.lastsave = time(NULL);
1310
- server.rdb_save_time_last = -1;
1311
- server.rdb_save_time_start = -1;
1312
- server.dirty = 0;
1313
- server.stat_numcommands = 0;
1314
- server.stat_numconnections = 0;
1315
- server.stat_expiredkeys = 0;
1316
- server.stat_evictedkeys = 0;
1317
- server.stat_starttime = time(NULL);
1318
- server.stat_keyspace_misses = 0;
1319
- server.stat_keyspace_hits = 0;
1320
- server.stat_peak_memory = 0;
1321
- server.stat_fork_time = 0;
1322
- server.stat_rejected_conn = 0;
1323
- memset(server.ops_sec_samples,0,sizeof(server.ops_sec_samples));
1324
- server.ops_sec_idx = 0;
1325
- server.ops_sec_last_sample_time = mstime();
1326
- server.ops_sec_last_sample_ops = 0;
1327
- server.unixtime = time(NULL);
1328
- server.lastbgsave_status = REDIS_OK;
1329
- server.stop_writes_on_bgsave_err = 1;
1330
- aeCreateTimeEvent(server.el, 1, serverCron, NULL, NULL);
1331
- if (server.ipfd > 0 && aeCreateFileEvent(server.el,server.ipfd,AE_READABLE,
1332
- acceptTcpHandler,NULL) == AE_ERR) oom("creating file event");
1333
- if (server.sofd > 0 && aeCreateFileEvent(server.el,server.sofd,AE_READABLE,
1334
- acceptUnixHandler,NULL) == AE_ERR) oom("creating file event");
1335
-
1336
- if (server.aof_state == REDIS_AOF_ON) {
1337
- server.aof_fd = open(server.aof_filename,
1338
- O_WRONLY|O_APPEND|O_CREAT,0644);
1339
- if (server.aof_fd == -1) {
1340
- redisLog(REDIS_WARNING, "Can't open the append-only file: %s",
1341
- strerror(errno));
1342
- exit(1);
1343
- }
1344
- }
1345
-
1346
- /* 32 bit instances are limited to 4GB of address space, so if there is
1347
- * no explicit limit in the user provided configuration we set a limit
1348
- * at 3.5GB using maxmemory with 'noeviction' policy'. This saves
1349
- * useless crashes of the Redis instance. */
1350
- if (server.arch_bits == 32 && server.maxmemory == 0) {
1351
- redisLog(REDIS_WARNING,"Warning: 32 bit instance detected but no memory limit set. Setting 3.5 GB maxmemory limit with 'noeviction' policy now.");
1352
- server.maxmemory = 3584LL*(1024*1024); /* 3584 MB = 3.5 GB */
1353
- server.maxmemory_policy = REDIS_MAXMEMORY_NO_EVICTION;
1354
- }
1355
-
1356
- if (server.cluster_enabled) clusterInit();
1357
- scriptingInit();
1358
- slowlogInit();
1359
- bioInit();
1360
- }
1361
-
1362
- /* Populates the Redis Command Table starting from the hard coded list
1363
- * we have on top of redis.c file. */
1364
- void populateCommandTable(void) {
1365
- int j;
1366
- int numcommands = sizeof(redisCommandTable)/sizeof(struct redisCommand);
1367
-
1368
- for (j = 0; j < numcommands; j++) {
1369
- struct redisCommand *c = redisCommandTable+j;
1370
- char *f = c->sflags;
1371
- int retval;
1372
-
1373
- while(*f != '\0') {
1374
- switch(*f) {
1375
- case 'w': c->flags |= REDIS_CMD_WRITE; break;
1376
- case 'r': c->flags |= REDIS_CMD_READONLY; break;
1377
- case 'm': c->flags |= REDIS_CMD_DENYOOM; break;
1378
- case 'a': c->flags |= REDIS_CMD_ADMIN; break;
1379
- case 'p': c->flags |= REDIS_CMD_PUBSUB; break;
1380
- case 'f': c->flags |= REDIS_CMD_FORCE_REPLICATION; break;
1381
- case 's': c->flags |= REDIS_CMD_NOSCRIPT; break;
1382
- case 'R': c->flags |= REDIS_CMD_RANDOM; break;
1383
- case 'S': c->flags |= REDIS_CMD_SORT_FOR_SCRIPT; break;
1384
- default: redisPanic("Unsupported command flag"); break;
1385
- }
1386
- f++;
1387
- }
1388
-
1389
- retval = dictAdd(server.commands, sdsnew(c->name), c);
1390
- assert(retval == DICT_OK);
1391
- }
1392
- }
1393
-
1394
- void resetCommandTableStats(void) {
1395
- int numcommands = sizeof(redisCommandTable)/sizeof(struct redisCommand);
1396
- int j;
1397
-
1398
- for (j = 0; j < numcommands; j++) {
1399
- struct redisCommand *c = redisCommandTable+j;
1400
-
1401
- c->microseconds = 0;
1402
- c->calls = 0;
1403
- }
1404
- }
1405
-
1406
- /* ========================== Redis OP Array API ============================ */
1407
-
1408
- void redisOpArrayInit(redisOpArray *oa) {
1409
- oa->ops = NULL;
1410
- oa->numops = 0;
1411
- }
1412
-
1413
- int redisOpArrayAppend(redisOpArray *oa, struct redisCommand *cmd, int dbid,
1414
- robj **argv, int argc, int target)
1415
- {
1416
- redisOp *op;
1417
-
1418
- oa->ops = zrealloc(oa->ops,sizeof(redisOp)*(oa->numops+1));
1419
- op = oa->ops+oa->numops;
1420
- op->cmd = cmd;
1421
- op->dbid = dbid;
1422
- op->argv = argv;
1423
- op->argc = argc;
1424
- op->target = target;
1425
- oa->numops++;
1426
- return oa->numops;
1427
- }
1428
-
1429
- void redisOpArrayFree(redisOpArray *oa) {
1430
- while(oa->numops) {
1431
- int j;
1432
- redisOp *op;
1433
-
1434
- oa->numops--;
1435
- op = oa->ops+oa->numops;
1436
- for (j = 0; j < op->argc; j++)
1437
- decrRefCount(op->argv[j]);
1438
- zfree(op->argv);
1439
- }
1440
- zfree(oa->ops);
1441
- }
1442
-
1443
- /* ====================== Commands lookup and execution ===================== */
1444
-
1445
- struct redisCommand *lookupCommand(sds name) {
1446
- return dictFetchValue(server.commands, name);
1447
- }
1448
-
1449
- struct redisCommand *lookupCommandByCString(char *s) {
1450
- struct redisCommand *cmd;
1451
- sds name = sdsnew(s);
1452
-
1453
- cmd = dictFetchValue(server.commands, name);
1454
- sdsfree(name);
1455
- return cmd;
1456
- }
1457
-
1458
- /* Propagate the specified command (in the context of the specified database id)
1459
- * to AOF, Slaves and Monitors.
1460
- *
1461
- * flags are an xor between:
1462
- * + REDIS_PROPAGATE_NONE (no propagation of command at all)
1463
- * + REDIS_PROPAGATE_AOF (propagate into the AOF file if is enabled)
1464
- * + REDIS_PROPAGATE_REPL (propagate into the replication link)
1465
- */
1466
- void propagate(struct redisCommand *cmd, int dbid, robj **argv, int argc,
1467
- int flags)
1468
- {
1469
- if (server.aof_state != REDIS_AOF_OFF && flags & REDIS_PROPAGATE_AOF)
1470
- feedAppendOnlyFile(cmd,dbid,argv,argc);
1471
- if (flags & REDIS_PROPAGATE_REPL && listLength(server.slaves))
1472
- replicationFeedSlaves(server.slaves,dbid,argv,argc);
1473
- }
1474
-
1475
- /* Used inside commands to schedule the propagation of additional commands
1476
- * after the current command is propagated to AOF / Replication. */
1477
- void alsoPropagate(struct redisCommand *cmd, int dbid, robj **argv, int argc,
1478
- int target)
1479
- {
1480
- redisOpArrayAppend(&server.also_propagate,cmd,dbid,argv,argc,target);
1481
- }
1482
-
1483
- /* Call() is the core of Redis execution of a command */
1484
- void call(redisClient *c, int flags) {
1485
- long long dirty, start = ustime(), duration;
1486
-
1487
- /* Sent the command to clients in MONITOR mode, only if the commands are
1488
- * not geneated from reading an AOF. */
1489
- if (listLength(server.monitors) && !server.loading)
1490
- replicationFeedMonitors(c,server.monitors,c->db->id,c->argv,c->argc);
1491
-
1492
- /* Call the command. */
1493
- redisOpArrayInit(&server.also_propagate);
1494
- dirty = server.dirty;
1495
- c->cmd->proc(c);
1496
- dirty = server.dirty-dirty;
1497
- duration = ustime()-start;
1498
-
1499
- /* When EVAL is called loading the AOF we don't want commands called
1500
- * from Lua to go into the slowlog or to populate statistics. */
1501
- if (server.loading && c->flags & REDIS_LUA_CLIENT)
1502
- flags &= ~(REDIS_CALL_SLOWLOG | REDIS_CALL_STATS);
1503
-
1504
- /* Log the command into the Slow log if needed, and populate the
1505
- * per-command statistics that we show in INFO commandstats. */
1506
- if (flags & REDIS_CALL_SLOWLOG)
1507
- slowlogPushEntryIfNeeded(c->argv,c->argc,duration);
1508
- if (flags & REDIS_CALL_STATS) {
1509
- c->cmd->microseconds += duration;
1510
- c->cmd->calls++;
1511
- }
1512
-
1513
- /* Propagate the command into the AOF and replication link */
1514
- if (flags & REDIS_CALL_PROPAGATE) {
1515
- int flags = REDIS_PROPAGATE_NONE;
1516
-
1517
- if (c->cmd->flags & REDIS_CMD_FORCE_REPLICATION)
1518
- flags |= REDIS_PROPAGATE_REPL;
1519
- if (dirty)
1520
- flags |= (REDIS_PROPAGATE_REPL | REDIS_PROPAGATE_AOF);
1521
- if (flags != REDIS_PROPAGATE_NONE)
1522
- propagate(c->cmd,c->db->id,c->argv,c->argc,flags);
1523
- }
1524
- /* Commands such as LPUSH or BRPOPLPUSH may propagate an additional
1525
- * PUSH command. */
1526
- if (server.also_propagate.numops) {
1527
- int j;
1528
- redisOp *rop;
1529
-
1530
- for (j = 0; j < server.also_propagate.numops; j++) {
1531
- rop = &server.also_propagate.ops[j];
1532
- propagate(rop->cmd, rop->dbid, rop->argv, rop->argc, rop->target);
1533
- }
1534
- redisOpArrayFree(&server.also_propagate);
1535
- }
1536
- server.stat_numcommands++;
1537
- }
1538
-
1539
- /* If this function gets called we already read a whole
1540
- * command, argments are in the client argv/argc fields.
1541
- * processCommand() execute the command or prepare the
1542
- * server for a bulk read from the client.
1543
- *
1544
- * If 1 is returned the client is still alive and valid and
1545
- * and other operations can be performed by the caller. Otherwise
1546
- * if 0 is returned the client was destroied (i.e. after QUIT). */
1547
- int processCommand(redisClient *c) {
1548
- /* The QUIT command is handled separately. Normal command procs will
1549
- * go through checking for replication and QUIT will cause trouble
1550
- * when FORCE_REPLICATION is enabled and would be implemented in
1551
- * a regular command proc. */
1552
- if (!strcasecmp(c->argv[0]->ptr,"quit")) {
1553
- addReply(c,shared.ok);
1554
- c->flags |= REDIS_CLOSE_AFTER_REPLY;
1555
- return REDIS_ERR;
1556
- }
1557
-
1558
- /* Now lookup the command and check ASAP about trivial error conditions
1559
- * such as wrong arity, bad command name and so forth. */
1560
- c->cmd = c->lastcmd = lookupCommand(c->argv[0]->ptr);
1561
- if (!c->cmd) {
1562
- addReplyErrorFormat(c,"unknown command '%s'",
1563
- (char*)c->argv[0]->ptr);
1564
- return REDIS_OK;
1565
- } else if ((c->cmd->arity > 0 && c->cmd->arity != c->argc) ||
1566
- (c->argc < -c->cmd->arity)) {
1567
- addReplyErrorFormat(c,"wrong number of arguments for '%s' command",
1568
- c->cmd->name);
1569
- return REDIS_OK;
1570
- }
1571
-
1572
- /* Check if the user is authenticated */
1573
- if (server.requirepass && !c->authenticated && c->cmd->proc != authCommand)
1574
- {
1575
- addReplyError(c,"operation not permitted");
1576
- return REDIS_OK;
1577
- }
1578
-
1579
- /* If cluster is enabled, redirect here */
1580
- if (server.cluster_enabled &&
1581
- !(c->cmd->getkeys_proc == NULL && c->cmd->firstkey == 0)) {
1582
- int hashslot;
1583
-
1584
- if (server.cluster.state != REDIS_CLUSTER_OK) {
1585
- addReplyError(c,"The cluster is down. Check with CLUSTER INFO for more information");
1586
- return REDIS_OK;
1587
- } else {
1588
- int ask;
1589
- clusterNode *n = getNodeByQuery(c,c->cmd,c->argv,c->argc,&hashslot,&ask);
1590
- if (n == NULL) {
1591
- addReplyError(c,"Multi keys request invalid in cluster");
1592
- return REDIS_OK;
1593
- } else if (n != server.cluster.myself) {
1594
- addReplySds(c,sdscatprintf(sdsempty(),
1595
- "-%s %d %s:%d\r\n", ask ? "ASK" : "MOVED",
1596
- hashslot,n->ip,n->port));
1597
- return REDIS_OK;
1598
- }
1599
- }
1600
- }
1601
-
1602
- /* Handle the maxmemory directive.
1603
- *
1604
- * First we try to free some memory if possible (if there are volatile
1605
- * keys in the dataset). If there are not the only thing we can do
1606
- * is returning an error. */
1607
- if (server.maxmemory) {
1608
- int retval = freeMemoryIfNeeded();
1609
- if ((c->cmd->flags & REDIS_CMD_DENYOOM) && retval == REDIS_ERR) {
1610
- addReply(c, shared.oomerr);
1611
- return REDIS_OK;
1612
- }
1613
- }
1614
-
1615
- /* Don't accept write commands if there are problems persisting on disk. */
1616
- if (server.stop_writes_on_bgsave_err &&
1617
- server.saveparamslen > 0
1618
- && server.lastbgsave_status == REDIS_ERR &&
1619
- c->cmd->flags & REDIS_CMD_WRITE)
1620
- {
1621
- addReply(c, shared.bgsaveerr);
1622
- return REDIS_OK;
1623
- }
1624
-
1625
- /* Don't accept wirte commands if this is a read only slave. But
1626
- * accept write commands if this is our master. */
1627
- if (server.masterhost && server.repl_slave_ro &&
1628
- !(c->flags & REDIS_MASTER) &&
1629
- c->cmd->flags & REDIS_CMD_WRITE)
1630
- {
1631
- addReply(c, shared.roslaveerr);
1632
- return REDIS_OK;
1633
- }
1634
-
1635
- /* Only allow SUBSCRIBE and UNSUBSCRIBE in the context of Pub/Sub */
1636
- if ((dictSize(c->pubsub_channels) > 0 || listLength(c->pubsub_patterns) > 0)
1637
- &&
1638
- c->cmd->proc != subscribeCommand &&
1639
- c->cmd->proc != unsubscribeCommand &&
1640
- c->cmd->proc != psubscribeCommand &&
1641
- c->cmd->proc != punsubscribeCommand) {
1642
- addReplyError(c,"only (P)SUBSCRIBE / (P)UNSUBSCRIBE / QUIT allowed in this context");
1643
- return REDIS_OK;
1644
- }
1645
-
1646
- /* Only allow INFO and SLAVEOF when slave-serve-stale-data is no and
1647
- * we are a slave with a broken link with master. */
1648
- if (server.masterhost && server.repl_state != REDIS_REPL_CONNECTED &&
1649
- server.repl_serve_stale_data == 0 &&
1650
- c->cmd->proc != infoCommand && c->cmd->proc != slaveofCommand)
1651
- {
1652
- addReply(c, shared.masterdownerr);
1653
- return REDIS_OK;
1654
- }
1655
-
1656
- /* Loading DB? Return an error if the command is not INFO */
1657
- if (server.loading && c->cmd->proc != infoCommand) {
1658
- addReply(c, shared.loadingerr);
1659
- return REDIS_OK;
1660
- }
1661
-
1662
- /* Lua script too slow? Only allow SHUTDOWN NOSAVE and SCRIPT KILL. */
1663
- if (server.lua_timedout &&
1664
- !(c->cmd->proc == shutdownCommand &&
1665
- c->argc == 2 &&
1666
- tolower(((char*)c->argv[1]->ptr)[0]) == 'n') &&
1667
- !(c->cmd->proc == scriptCommand &&
1668
- c->argc == 2 &&
1669
- tolower(((char*)c->argv[1]->ptr)[0]) == 'k'))
1670
- {
1671
- addReply(c, shared.slowscripterr);
1672
- return REDIS_OK;
1673
- }
1674
-
1675
- /* Exec the command */
1676
- if (c->flags & REDIS_MULTI &&
1677
- c->cmd->proc != execCommand && c->cmd->proc != discardCommand &&
1678
- c->cmd->proc != multiCommand && c->cmd->proc != watchCommand)
1679
- {
1680
- queueMultiCommand(c);
1681
- addReply(c,shared.queued);
1682
- } else {
1683
- call(c,REDIS_CALL_FULL);
1684
- }
1685
- return REDIS_OK;
1686
- }
1687
-
1688
- /*================================== Shutdown =============================== */
1689
-
1690
- int prepareForShutdown(int flags) {
1691
- int save = flags & REDIS_SHUTDOWN_SAVE;
1692
- int nosave = flags & REDIS_SHUTDOWN_NOSAVE;
1693
-
1694
- redisLog(REDIS_WARNING,"User requested shutdown...");
1695
- /* Kill the saving child if there is a background saving in progress.
1696
- We want to avoid race conditions, for instance our saving child may
1697
- overwrite the synchronous saving did by SHUTDOWN. */
1698
- if (server.rdb_child_pid != -1) {
1699
- redisLog(REDIS_WARNING,"There is a child saving an .rdb. Killing it!");
1700
- kill(server.rdb_child_pid,SIGKILL);
1701
- rdbRemoveTempFile(server.rdb_child_pid);
1702
- }
1703
- if (server.aof_state != REDIS_AOF_OFF) {
1704
- /* Kill the AOF saving child as the AOF we already have may be longer
1705
- * but contains the full dataset anyway. */
1706
- if (server.aof_child_pid != -1) {
1707
- redisLog(REDIS_WARNING,
1708
- "There is a child rewriting the AOF. Killing it!");
1709
- kill(server.aof_child_pid,SIGKILL);
1710
- }
1711
- /* Append only file: fsync() the AOF and exit */
1712
- redisLog(REDIS_NOTICE,"Calling fsync() on the AOF file.");
1713
- aof_fsync(server.aof_fd);
1714
- }
1715
- if ((server.saveparamslen > 0 && !nosave) || save) {
1716
- redisLog(REDIS_NOTICE,"Saving the final RDB snapshot before exiting.");
1717
- /* Snapshotting. Perform a SYNC SAVE and exit */
1718
- if (rdbSave(server.rdb_filename) != REDIS_OK) {
1719
- /* Ooops.. error saving! The best we can do is to continue
1720
- * operating. Note that if there was a background saving process,
1721
- * in the next cron() Redis will be notified that the background
1722
- * saving aborted, handling special stuff like slaves pending for
1723
- * synchronization... */
1724
- redisLog(REDIS_WARNING,"Error trying to save the DB, can't exit.");
1725
- return REDIS_ERR;
1726
- }
1727
- }
1728
- if (server.daemonize) {
1729
- redisLog(REDIS_NOTICE,"Removing the pid file.");
1730
- unlink(server.pidfile);
1731
- }
1732
- /* Close the listening sockets. Apparently this allows faster restarts. */
1733
- if (server.ipfd != -1) close(server.ipfd);
1734
- if (server.sofd != -1) close(server.sofd);
1735
- if (server.unixsocket) {
1736
- redisLog(REDIS_NOTICE,"Removing the unix socket file.");
1737
- unlink(server.unixsocket); /* don't care if this fails */
1738
- }
1739
-
1740
- redisLog(REDIS_WARNING,"Redis is now ready to exit, bye bye...");
1741
- return REDIS_OK;
1742
- }
1743
-
1744
- /*================================== Commands =============================== */
1745
-
1746
- /* Return zero if strings are the same, non-zero if they are not.
1747
- * The comparison is performed in a way that prevents an attacker to obtain
1748
- * information about the nature of the strings just monitoring the execution
1749
- * time of the function.
1750
- *
1751
- * Note that limiting the comparison length to strings up to 512 bytes we
1752
- * can avoid leaking any information about the password length and any
1753
- * possible branch misprediction related leak.
1754
- */
1755
- int time_independent_strcmp(char *a, char *b) {
1756
- char bufa[REDIS_AUTHPASS_MAX_LEN], bufb[REDIS_AUTHPASS_MAX_LEN];
1757
- /* The above two strlen perform len(a) + len(b) operations where either
1758
- * a or b are fixed (our password) length, and the difference is only
1759
- * relative to the length of the user provided string, so no information
1760
- * leak is possible in the following two lines of code. */
1761
- int alen = strlen(a);
1762
- int blen = strlen(b);
1763
- int j;
1764
- int diff = 0;
1765
-
1766
- /* We can't compare strings longer than our static buffers.
1767
- * Note that this will never pass the first test in practical circumstances
1768
- * so there is no info leak. */
1769
- if (alen > sizeof(bufa) || blen > sizeof(bufb)) return 1;
1770
-
1771
- memset(bufa,0,sizeof(bufa)); /* Constant time. */
1772
- memset(bufb,0,sizeof(bufb)); /* Constant time. */
1773
- /* Again the time of the following two copies is proportional to
1774
- * len(a) + len(b) so no info is leaked. */
1775
- memcpy(bufa,a,alen);
1776
- memcpy(bufb,b,blen);
1777
-
1778
- /* Always compare all the chars in the two buffers without
1779
- * conditional expressions. */
1780
- for (j = 0; j < sizeof(bufa); j++) {
1781
- diff |= (bufa[j] ^ bufb[j]);
1782
- }
1783
- /* Length must be equal as well. */
1784
- diff |= alen ^ blen;
1785
- return diff; /* If zero strings are the same. */
1786
- }
1787
-
1788
- void authCommand(redisClient *c) {
1789
- if (!server.requirepass) {
1790
- addReplyError(c,"Client sent AUTH, but no password is set");
1791
- } else if (!time_independent_strcmp(c->argv[1]->ptr, server.requirepass)) {
1792
- c->authenticated = 1;
1793
- addReply(c,shared.ok);
1794
- } else {
1795
- c->authenticated = 0;
1796
- addReplyError(c,"invalid password");
1797
- }
1798
- }
1799
-
1800
- void pingCommand(redisClient *c) {
1801
- addReply(c,shared.pong);
1802
- }
1803
-
1804
- void echoCommand(redisClient *c) {
1805
- addReplyBulk(c,c->argv[1]);
1806
- }
1807
-
1808
- void timeCommand(redisClient *c) {
1809
- struct timeval tv;
1810
-
1811
- /* gettimeofday() can only fail if &tv is a bad addresss so we
1812
- * don't check for errors. */
1813
- gettimeofday(&tv,NULL);
1814
- addReplyMultiBulkLen(c,2);
1815
- addReplyBulkLongLong(c,tv.tv_sec);
1816
- addReplyBulkLongLong(c,tv.tv_usec);
1817
- }
1818
-
1819
- /* Convert an amount of bytes into a human readable string in the form
1820
- * of 100B, 2G, 100M, 4K, and so forth. */
1821
- void bytesToHuman(char *s, unsigned long long n) {
1822
- double d;
1823
-
1824
- if (n < 1024) {
1825
- /* Bytes */
1826
- sprintf(s,"%lluB",n);
1827
- return;
1828
- } else if (n < (1024*1024)) {
1829
- d = (double)n/(1024);
1830
- sprintf(s,"%.2fK",d);
1831
- } else if (n < (1024LL*1024*1024)) {
1832
- d = (double)n/(1024*1024);
1833
- sprintf(s,"%.2fM",d);
1834
- } else if (n < (1024LL*1024*1024*1024)) {
1835
- d = (double)n/(1024LL*1024*1024);
1836
- sprintf(s,"%.2fG",d);
1837
- }
1838
- }
1839
-
1840
- /* Create the string returned by the INFO command. This is decoupled
1841
- * by the INFO command itself as we need to report the same information
1842
- * on memory corruption problems. */
1843
- sds genRedisInfoString(char *section) {
1844
- sds info = sdsempty();
1845
- time_t uptime = server.unixtime-server.stat_starttime;
1846
- int j, numcommands;
1847
- struct rusage self_ru, c_ru;
1848
- unsigned long lol, bib;
1849
- int allsections = 0, defsections = 0;
1850
- int sections = 0;
1851
-
1852
- if (section) {
1853
- allsections = strcasecmp(section,"all") == 0;
1854
- defsections = strcasecmp(section,"default") == 0;
1855
- }
1856
-
1857
- getrusage(RUSAGE_SELF, &self_ru);
1858
- getrusage(RUSAGE_CHILDREN, &c_ru);
1859
- getClientsMaxBuffers(&lol,&bib);
1860
-
1861
- /* Server */
1862
- if (allsections || defsections || !strcasecmp(section,"server")) {
1863
- struct utsname name;
1864
-
1865
- if (sections++) info = sdscat(info,"\r\n");
1866
- uname(&name);
1867
- info = sdscatprintf(info,
1868
- "# Server\r\n"
1869
- "redis_version:%s\r\n"
1870
- "redis_git_sha1:%s\r\n"
1871
- "redis_git_dirty:%d\r\n"
1872
- "os:%s %s %s\r\n"
1873
- "arch_bits:%d\r\n"
1874
- "multiplexing_api:%s\r\n"
1875
- "gcc_version:%d.%d.%d\r\n"
1876
- "process_id:%ld\r\n"
1877
- "run_id:%s\r\n"
1878
- "tcp_port:%d\r\n"
1879
- "uptime_in_seconds:%ld\r\n"
1880
- "uptime_in_days:%ld\r\n"
1881
- "lru_clock:%ld\r\n",
1882
- REDIS_VERSION,
1883
- redisGitSHA1(),
1884
- strtol(redisGitDirty(),NULL,10) > 0,
1885
- name.sysname, name.release, name.machine,
1886
- server.arch_bits,
1887
- aeGetApiName(),
1888
- #ifdef __GNUC__
1889
- __GNUC__,__GNUC_MINOR__,__GNUC_PATCHLEVEL__,
1890
- #else
1891
- 0,0,0,
1892
- #endif
1893
- (long) getpid(),
1894
- server.runid,
1895
- server.port,
1896
- uptime,
1897
- uptime/(3600*24),
1898
- (unsigned long) server.lruclock);
1899
- }
1900
-
1901
- /* Clients */
1902
- if (allsections || defsections || !strcasecmp(section,"clients")) {
1903
- if (sections++) info = sdscat(info,"\r\n");
1904
- info = sdscatprintf(info,
1905
- "# Clients\r\n"
1906
- "connected_clients:%lu\r\n"
1907
- "client_longest_output_list:%lu\r\n"
1908
- "client_biggest_input_buf:%lu\r\n"
1909
- "blocked_clients:%d\r\n",
1910
- listLength(server.clients)-listLength(server.slaves),
1911
- lol, bib,
1912
- server.bpop_blocked_clients);
1913
- }
1914
-
1915
- /* Memory */
1916
- if (allsections || defsections || !strcasecmp(section,"memory")) {
1917
- char hmem[64];
1918
- char peak_hmem[64];
1919
-
1920
- bytesToHuman(hmem,zmalloc_used_memory());
1921
- bytesToHuman(peak_hmem,server.stat_peak_memory);
1922
- if (sections++) info = sdscat(info,"\r\n");
1923
- info = sdscatprintf(info,
1924
- "# Memory\r\n"
1925
- "used_memory:%zu\r\n"
1926
- "used_memory_human:%s\r\n"
1927
- "used_memory_rss:%zu\r\n"
1928
- "used_memory_peak:%zu\r\n"
1929
- "used_memory_peak_human:%s\r\n"
1930
- "used_memory_lua:%lld\r\n"
1931
- "mem_fragmentation_ratio:%.2f\r\n"
1932
- "mem_allocator:%s\r\n",
1933
- zmalloc_used_memory(),
1934
- hmem,
1935
- zmalloc_get_rss(),
1936
- server.stat_peak_memory,
1937
- peak_hmem,
1938
- ((long long)lua_gc(server.lua,LUA_GCCOUNT,0))*1024LL,
1939
- zmalloc_get_fragmentation_ratio(),
1940
- ZMALLOC_LIB
1941
- );
1942
- }
1943
-
1944
- /* Persistence */
1945
- if (allsections || defsections || !strcasecmp(section,"persistence")) {
1946
- if (sections++) info = sdscat(info,"\r\n");
1947
- info = sdscatprintf(info,
1948
- "# Persistence\r\n"
1949
- "loading:%d\r\n"
1950
- "rdb_changes_since_last_save:%lld\r\n"
1951
- "rdb_bgsave_in_progress:%d\r\n"
1952
- "rdb_last_save_time:%ld\r\n"
1953
- "rdb_last_bgsave_status:%s\r\n"
1954
- "rdb_last_bgsave_time_sec:%ld\r\n"
1955
- "rdb_current_bgsave_time_sec:%ld\r\n"
1956
- "aof_enabled:%d\r\n"
1957
- "aof_rewrite_in_progress:%d\r\n"
1958
- "aof_rewrite_scheduled:%d\r\n"
1959
- "aof_last_rewrite_time_sec:%ld\r\n"
1960
- "aof_current_rewrite_time_sec:%ld\r\n",
1961
- server.loading,
1962
- server.dirty,
1963
- server.rdb_child_pid != -1,
1964
- server.lastsave,
1965
- server.lastbgsave_status == REDIS_OK ? "ok" : "err",
1966
- server.rdb_save_time_last,
1967
- (server.rdb_child_pid == -1) ?
1968
- -1 : time(NULL)-server.rdb_save_time_start,
1969
- server.aof_state != REDIS_AOF_OFF,
1970
- server.aof_child_pid != -1,
1971
- server.aof_rewrite_scheduled,
1972
- server.aof_rewrite_time_last,
1973
- (server.aof_child_pid == -1) ?
1974
- -1 : time(NULL)-server.aof_rewrite_time_start);
1975
-
1976
- if (server.aof_state != REDIS_AOF_OFF) {
1977
- info = sdscatprintf(info,
1978
- "aof_current_size:%lld\r\n"
1979
- "aof_base_size:%lld\r\n"
1980
- "aof_pending_rewrite:%d\r\n"
1981
- "aof_buffer_length:%zu\r\n"
1982
- "aof_rewrite_buffer_length:%zu\r\n"
1983
- "aof_pending_bio_fsync:%llu\r\n"
1984
- "aof_delayed_fsync:%lu\r\n",
1985
- (long long) server.aof_current_size,
1986
- (long long) server.aof_rewrite_base_size,
1987
- server.aof_rewrite_scheduled,
1988
- sdslen(server.aof_buf),
1989
- aofRewriteBufferSize(),
1990
- bioPendingJobsOfType(REDIS_BIO_AOF_FSYNC),
1991
- server.aof_delayed_fsync);
1992
- }
1993
-
1994
- if (server.loading) {
1995
- double perc;
1996
- time_t eta, elapsed;
1997
- off_t remaining_bytes = server.loading_total_bytes-
1998
- server.loading_loaded_bytes;
1999
-
2000
- perc = ((double)server.loading_loaded_bytes /
2001
- server.loading_total_bytes) * 100;
2002
-
2003
- elapsed = server.unixtime-server.loading_start_time;
2004
- if (elapsed == 0) {
2005
- eta = 1; /* A fake 1 second figure if we don't have
2006
- enough info */
2007
- } else {
2008
- eta = (elapsed*remaining_bytes)/server.loading_loaded_bytes;
2009
- }
2010
-
2011
- info = sdscatprintf(info,
2012
- "loading_start_time:%ld\r\n"
2013
- "loading_total_bytes:%llu\r\n"
2014
- "loading_loaded_bytes:%llu\r\n"
2015
- "loading_loaded_perc:%.2f\r\n"
2016
- "loading_eta_seconds:%ld\r\n"
2017
- ,(unsigned long) server.loading_start_time,
2018
- (unsigned long long) server.loading_total_bytes,
2019
- (unsigned long long) server.loading_loaded_bytes,
2020
- perc,
2021
- eta
2022
- );
2023
- }
2024
- }
2025
-
2026
- /* Stats */
2027
- if (allsections || defsections || !strcasecmp(section,"stats")) {
2028
- if (sections++) info = sdscat(info,"\r\n");
2029
- info = sdscatprintf(info,
2030
- "# Stats\r\n"
2031
- "total_connections_received:%lld\r\n"
2032
- "total_commands_processed:%lld\r\n"
2033
- "instantaneous_ops_per_sec:%lld\r\n"
2034
- "rejected_connections:%lld\r\n"
2035
- "expired_keys:%lld\r\n"
2036
- "evicted_keys:%lld\r\n"
2037
- "keyspace_hits:%lld\r\n"
2038
- "keyspace_misses:%lld\r\n"
2039
- "pubsub_channels:%ld\r\n"
2040
- "pubsub_patterns:%lu\r\n"
2041
- "latest_fork_usec:%lld\r\n",
2042
- server.stat_numconnections,
2043
- server.stat_numcommands,
2044
- getOperationsPerSecond(),
2045
- server.stat_rejected_conn,
2046
- server.stat_expiredkeys,
2047
- server.stat_evictedkeys,
2048
- server.stat_keyspace_hits,
2049
- server.stat_keyspace_misses,
2050
- dictSize(server.pubsub_channels),
2051
- listLength(server.pubsub_patterns),
2052
- server.stat_fork_time);
2053
- }
2054
-
2055
- /* Replication */
2056
- if (allsections || defsections || !strcasecmp(section,"replication")) {
2057
- if (sections++) info = sdscat(info,"\r\n");
2058
- info = sdscatprintf(info,
2059
- "# Replication\r\n"
2060
- "role:%s\r\n",
2061
- server.masterhost == NULL ? "master" : "slave");
2062
- if (server.masterhost) {
2063
- info = sdscatprintf(info,
2064
- "master_host:%s\r\n"
2065
- "master_port:%d\r\n"
2066
- "master_link_status:%s\r\n"
2067
- "master_last_io_seconds_ago:%d\r\n"
2068
- "master_sync_in_progress:%d\r\n"
2069
- ,server.masterhost,
2070
- server.masterport,
2071
- (server.repl_state == REDIS_REPL_CONNECTED) ?
2072
- "up" : "down",
2073
- server.master ?
2074
- ((int)(server.unixtime-server.master->lastinteraction)) : -1,
2075
- server.repl_state == REDIS_REPL_TRANSFER
2076
- );
2077
-
2078
- if (server.repl_state == REDIS_REPL_TRANSFER) {
2079
- info = sdscatprintf(info,
2080
- "master_sync_left_bytes:%ld\r\n"
2081
- "master_sync_last_io_seconds_ago:%d\r\n"
2082
- ,(long)server.repl_transfer_left,
2083
- (int)(server.unixtime-server.repl_transfer_lastio)
2084
- );
2085
- }
2086
-
2087
- if (server.repl_state != REDIS_REPL_CONNECTED) {
2088
- info = sdscatprintf(info,
2089
- "master_link_down_since_seconds:%ld\r\n",
2090
- (long)server.unixtime-server.repl_down_since);
2091
- }
2092
- }
2093
- info = sdscatprintf(info,
2094
- "connected_slaves:%lu\r\n",
2095
- listLength(server.slaves));
2096
- if (listLength(server.slaves)) {
2097
- int slaveid = 0;
2098
- listNode *ln;
2099
- listIter li;
2100
-
2101
- listRewind(server.slaves,&li);
2102
- while((ln = listNext(&li))) {
2103
- redisClient *slave = listNodeValue(ln);
2104
- char *state = NULL;
2105
- char ip[32];
2106
- int port;
2107
-
2108
- if (anetPeerToString(slave->fd,ip,&port) == -1) continue;
2109
- switch(slave->replstate) {
2110
- case REDIS_REPL_WAIT_BGSAVE_START:
2111
- case REDIS_REPL_WAIT_BGSAVE_END:
2112
- state = "wait_bgsave";
2113
- break;
2114
- case REDIS_REPL_SEND_BULK:
2115
- state = "send_bulk";
2116
- break;
2117
- case REDIS_REPL_ONLINE:
2118
- state = "online";
2119
- break;
2120
- }
2121
- if (state == NULL) continue;
2122
- info = sdscatprintf(info,"slave%d:%s,%d,%s\r\n",
2123
- slaveid,ip,slave->slave_listening_port,state);
2124
- slaveid++;
2125
- }
2126
- }
2127
- }
2128
-
2129
- /* CPU */
2130
- if (allsections || defsections || !strcasecmp(section,"cpu")) {
2131
- if (sections++) info = sdscat(info,"\r\n");
2132
- info = sdscatprintf(info,
2133
- "# CPU\r\n"
2134
- "used_cpu_sys:%.2f\r\n"
2135
- "used_cpu_user:%.2f\r\n"
2136
- "used_cpu_sys_children:%.2f\r\n"
2137
- "used_cpu_user_children:%.2f\r\n",
2138
- (float)self_ru.ru_stime.tv_sec+(float)self_ru.ru_stime.tv_usec/1000000,
2139
- (float)self_ru.ru_utime.tv_sec+(float)self_ru.ru_utime.tv_usec/1000000,
2140
- (float)c_ru.ru_stime.tv_sec+(float)c_ru.ru_stime.tv_usec/1000000,
2141
- (float)c_ru.ru_utime.tv_sec+(float)c_ru.ru_utime.tv_usec/1000000);
2142
- }
2143
-
2144
- /* cmdtime */
2145
- if (allsections || !strcasecmp(section,"commandstats")) {
2146
- if (sections++) info = sdscat(info,"\r\n");
2147
- info = sdscatprintf(info, "# Commandstats\r\n");
2148
- numcommands = sizeof(redisCommandTable)/sizeof(struct redisCommand);
2149
- for (j = 0; j < numcommands; j++) {
2150
- struct redisCommand *c = redisCommandTable+j;
2151
-
2152
- if (!c->calls) continue;
2153
- info = sdscatprintf(info,
2154
- "cmdstat_%s:calls=%lld,usec=%lld,usec_per_call=%.2f\r\n",
2155
- c->name, c->calls, c->microseconds,
2156
- (c->calls == 0) ? 0 : ((float)c->microseconds/c->calls));
2157
- }
2158
- }
2159
-
2160
- /* Cluster */
2161
- if (allsections || defsections || !strcasecmp(section,"cluster")) {
2162
- if (sections++) info = sdscat(info,"\r\n");
2163
- info = sdscatprintf(info,
2164
- "# Cluster\r\n"
2165
- "cluster_enabled:%d\r\n",
2166
- server.cluster_enabled);
2167
- }
2168
-
2169
- /* Key space */
2170
- if (allsections || defsections || !strcasecmp(section,"keyspace")) {
2171
- if (sections++) info = sdscat(info,"\r\n");
2172
- info = sdscatprintf(info, "# Keyspace\r\n");
2173
- for (j = 0; j < server.dbnum; j++) {
2174
- long long keys, vkeys;
2175
-
2176
- keys = dictSize(server.db[j].dict);
2177
- vkeys = dictSize(server.db[j].expires);
2178
- if (keys || vkeys) {
2179
- info = sdscatprintf(info, "db%d:keys=%lld,expires=%lld\r\n",
2180
- j, keys, vkeys);
2181
- }
2182
- }
2183
- }
2184
- return info;
2185
- }
2186
-
2187
- void infoCommand(redisClient *c) {
2188
- char *section = c->argc == 2 ? c->argv[1]->ptr : "default";
2189
-
2190
- if (c->argc > 2) {
2191
- addReply(c,shared.syntaxerr);
2192
- return;
2193
- }
2194
- sds info = genRedisInfoString(section);
2195
- addReplySds(c,sdscatprintf(sdsempty(),"$%lu\r\n",
2196
- (unsigned long)sdslen(info)));
2197
- addReplySds(c,info);
2198
- addReply(c,shared.crlf);
2199
- }
2200
-
2201
- void monitorCommand(redisClient *c) {
2202
- /* ignore MONITOR if aleady slave or in monitor mode */
2203
- if (c->flags & REDIS_SLAVE) return;
2204
-
2205
- c->flags |= (REDIS_SLAVE|REDIS_MONITOR);
2206
- c->slaveseldb = 0;
2207
- listAddNodeTail(server.monitors,c);
2208
- addReply(c,shared.ok);
2209
- }
2210
-
2211
- /* ============================ Maxmemory directive ======================== */
2212
-
2213
- /* This function gets called when 'maxmemory' is set on the config file to limit
2214
- * the max memory used by the server, before processing a command.
2215
- *
2216
- * The goal of the function is to free enough memory to keep Redis under the
2217
- * configured memory limit.
2218
- *
2219
- * The function starts calculating how many bytes should be freed to keep
2220
- * Redis under the limit, and enters a loop selecting the best keys to
2221
- * evict accordingly to the configured policy.
2222
- *
2223
- * If all the bytes needed to return back under the limit were freed the
2224
- * function returns REDIS_OK, otherwise REDIS_ERR is returned, and the caller
2225
- * should block the execution of commands that will result in more memory
2226
- * used by the server.
2227
- */
2228
- int freeMemoryIfNeeded(void) {
2229
- size_t mem_used, mem_tofree, mem_freed;
2230
- int slaves = listLength(server.slaves);
2231
-
2232
- /* Remove the size of slaves output buffers and AOF buffer from the
2233
- * count of used memory. */
2234
- mem_used = zmalloc_used_memory();
2235
- if (slaves) {
2236
- listIter li;
2237
- listNode *ln;
2238
-
2239
- listRewind(server.slaves,&li);
2240
- while((ln = listNext(&li))) {
2241
- redisClient *slave = listNodeValue(ln);
2242
- unsigned long obuf_bytes = getClientOutputBufferMemoryUsage(slave);
2243
- if (obuf_bytes > mem_used)
2244
- mem_used = 0;
2245
- else
2246
- mem_used -= obuf_bytes;
2247
- }
2248
- }
2249
- if (server.aof_state != REDIS_AOF_OFF) {
2250
- mem_used -= sdslen(server.aof_buf);
2251
- mem_used -= aofRewriteBufferSize();
2252
- }
2253
-
2254
- /* Check if we are over the memory limit. */
2255
- if (mem_used <= server.maxmemory) return REDIS_OK;
2256
-
2257
- if (server.maxmemory_policy == REDIS_MAXMEMORY_NO_EVICTION)
2258
- return REDIS_ERR; /* We need to free memory, but policy forbids. */
2259
-
2260
- /* Compute how much memory we need to free. */
2261
- mem_tofree = mem_used - server.maxmemory;
2262
- mem_freed = 0;
2263
- while (mem_freed < mem_tofree) {
2264
- int j, k, keys_freed = 0;
2265
-
2266
- for (j = 0; j < server.dbnum; j++) {
2267
- long bestval = 0; /* just to prevent warning */
2268
- sds bestkey = NULL;
2269
- struct dictEntry *de;
2270
- redisDb *db = server.db+j;
2271
- dict *dict;
2272
-
2273
- if (server.maxmemory_policy == REDIS_MAXMEMORY_ALLKEYS_LRU ||
2274
- server.maxmemory_policy == REDIS_MAXMEMORY_ALLKEYS_RANDOM)
2275
- {
2276
- dict = server.db[j].dict;
2277
- } else {
2278
- dict = server.db[j].expires;
2279
- }
2280
- if (dictSize(dict) == 0) continue;
2281
-
2282
- /* volatile-random and allkeys-random policy */
2283
- if (server.maxmemory_policy == REDIS_MAXMEMORY_ALLKEYS_RANDOM ||
2284
- server.maxmemory_policy == REDIS_MAXMEMORY_VOLATILE_RANDOM)
2285
- {
2286
- de = dictGetRandomKey(dict);
2287
- bestkey = dictGetKey(de);
2288
- }
2289
-
2290
- /* volatile-lru and allkeys-lru policy */
2291
- else if (server.maxmemory_policy == REDIS_MAXMEMORY_ALLKEYS_LRU ||
2292
- server.maxmemory_policy == REDIS_MAXMEMORY_VOLATILE_LRU)
2293
- {
2294
- for (k = 0; k < server.maxmemory_samples; k++) {
2295
- sds thiskey;
2296
- long thisval;
2297
- robj *o;
2298
-
2299
- de = dictGetRandomKey(dict);
2300
- thiskey = dictGetKey(de);
2301
- /* When policy is volatile-lru we need an additonal lookup
2302
- * to locate the real key, as dict is set to db->expires. */
2303
- if (server.maxmemory_policy == REDIS_MAXMEMORY_VOLATILE_LRU)
2304
- de = dictFind(db->dict, thiskey);
2305
- o = dictGetVal(de);
2306
- thisval = estimateObjectIdleTime(o);
2307
-
2308
- /* Higher idle time is better candidate for deletion */
2309
- if (bestkey == NULL || thisval > bestval) {
2310
- bestkey = thiskey;
2311
- bestval = thisval;
2312
- }
2313
- }
2314
- }
2315
-
2316
- /* volatile-ttl */
2317
- else if (server.maxmemory_policy == REDIS_MAXMEMORY_VOLATILE_TTL) {
2318
- for (k = 0; k < server.maxmemory_samples; k++) {
2319
- sds thiskey;
2320
- long thisval;
2321
-
2322
- de = dictGetRandomKey(dict);
2323
- thiskey = dictGetKey(de);
2324
- thisval = (long) dictGetVal(de);
2325
-
2326
- /* Expire sooner (minor expire unix timestamp) is better
2327
- * candidate for deletion */
2328
- if (bestkey == NULL || thisval < bestval) {
2329
- bestkey = thiskey;
2330
- bestval = thisval;
2331
- }
2332
- }
2333
- }
2334
-
2335
- /* Finally remove the selected key. */
2336
- if (bestkey) {
2337
- long long delta;
2338
-
2339
- robj *keyobj = createStringObject(bestkey,sdslen(bestkey));
2340
- propagateExpire(db,keyobj);
2341
- /* We compute the amount of memory freed by dbDelete() alone.
2342
- * It is possible that actually the memory needed to propagate
2343
- * the DEL in AOF and replication link is greater than the one
2344
- * we are freeing removing the key, but we can't account for
2345
- * that otherwise we would never exit the loop.
2346
- *
2347
- * AOF and Output buffer memory will be freed eventually so
2348
- * we only care about memory used by the key space. */
2349
- delta = (long long) zmalloc_used_memory();
2350
- dbDelete(db,keyobj);
2351
- delta -= (long long) zmalloc_used_memory();
2352
- mem_freed += delta;
2353
- server.stat_evictedkeys++;
2354
- decrRefCount(keyobj);
2355
- keys_freed++;
2356
-
2357
- /* When the memory to free starts to be big enough, we may
2358
- * start spending so much time here that is impossible to
2359
- * deliver data to the slaves fast enough, so we force the
2360
- * transmission here inside the loop. */
2361
- if (slaves) flushSlavesOutputBuffers();
2362
- }
2363
- }
2364
- if (!keys_freed) return REDIS_ERR; /* nothing to free... */
2365
- }
2366
- return REDIS_OK;
2367
- }
2368
-
2369
- /* =================================== Main! ================================ */
2370
-
2371
- #ifdef __linux__
2372
- int linuxOvercommitMemoryValue(void) {
2373
- FILE *fp = fopen("/proc/sys/vm/overcommit_memory","r");
2374
- char buf[64];
2375
-
2376
- if (!fp) return -1;
2377
- if (fgets(buf,64,fp) == NULL) {
2378
- fclose(fp);
2379
- return -1;
2380
- }
2381
- fclose(fp);
2382
-
2383
- return atoi(buf);
2384
- }
2385
-
2386
- void linuxOvercommitMemoryWarning(void) {
2387
- if (linuxOvercommitMemoryValue() == 0) {
2388
- redisLog(REDIS_WARNING,"WARNING overcommit_memory is set to 0! Background save may fail under low memory condition. To fix this issue add 'vm.overcommit_memory = 1' to /etc/sysctl.conf and then reboot or run the command 'sysctl vm.overcommit_memory=1' for this to take effect.");
2389
- }
2390
- }
2391
- #endif /* __linux__ */
2392
-
2393
- void createPidFile(void) {
2394
- /* Try to write the pid file in a best-effort way. */
2395
- FILE *fp = fopen(server.pidfile,"w");
2396
- if (fp) {
2397
- fprintf(fp,"%d\n",(int)getpid());
2398
- fclose(fp);
2399
- }
2400
- }
2401
-
2402
- void daemonize(void) {
2403
- int fd;
2404
-
2405
- if (fork() != 0) exit(0); /* parent exits */
2406
- setsid(); /* create a new session */
2407
-
2408
- /* Every output goes to /dev/null. If Redis is daemonized but
2409
- * the 'logfile' is set to 'stdout' in the configuration file
2410
- * it will not log at all. */
2411
- if ((fd = open("/dev/null", O_RDWR, 0)) != -1) {
2412
- dup2(fd, STDIN_FILENO);
2413
- dup2(fd, STDOUT_FILENO);
2414
- dup2(fd, STDERR_FILENO);
2415
- if (fd > STDERR_FILENO) close(fd);
2416
- }
2417
- }
2418
-
2419
- void version() {
2420
- printf("Redis server v=%s sha=%s:%d malloc=%s bits=%d\n",
2421
- REDIS_VERSION,
2422
- redisGitSHA1(),
2423
- atoi(redisGitDirty()) > 0,
2424
- ZMALLOC_LIB,
2425
- sizeof(long) == 4 ? 32 : 64);
2426
- exit(0);
2427
- }
2428
-
2429
- void usage() {
2430
- fprintf(stderr,"Usage: ./redis-server [/path/to/redis.conf] [options]\n");
2431
- fprintf(stderr," ./redis-server - (read config from stdin)\n");
2432
- fprintf(stderr," ./redis-server -v or --version\n");
2433
- fprintf(stderr," ./redis-server -h or --help\n");
2434
- fprintf(stderr," ./redis-server --test-memory <megabytes>\n\n");
2435
- fprintf(stderr,"Examples:\n");
2436
- fprintf(stderr," ./redis-server (run the server with default conf)\n");
2437
- fprintf(stderr," ./redis-server /etc/redis/6379.conf\n");
2438
- fprintf(stderr," ./redis-server --port 7777\n");
2439
- fprintf(stderr," ./redis-server --port 7777 --slaveof 127.0.0.1 8888\n");
2440
- fprintf(stderr," ./redis-server /etc/myredis.conf --loglevel verbose\n");
2441
- exit(1);
2442
- }
2443
-
2444
- void redisAsciiArt(void) {
2445
- #include "asciilogo.h"
2446
- char *buf = zmalloc(1024*16);
2447
-
2448
- snprintf(buf,1024*16,ascii_logo,
2449
- REDIS_VERSION,
2450
- redisGitSHA1(),
2451
- strtol(redisGitDirty(),NULL,10) > 0,
2452
- (sizeof(long) == 8) ? "64" : "32",
2453
- server.cluster_enabled ? "cluster" : "stand alone",
2454
- server.port,
2455
- (long) getpid()
2456
- );
2457
- redisLogRaw(REDIS_NOTICE|REDIS_LOG_RAW,buf);
2458
- zfree(buf);
2459
- }
2460
-
2461
- static void sigtermHandler(int sig) {
2462
- REDIS_NOTUSED(sig);
2463
-
2464
- redisLogFromHandler(REDIS_WARNING,"Received SIGTERM, scheduling shutdown...");
2465
- server.shutdown_asap = 1;
2466
- }
2467
-
2468
- void setupSignalHandlers(void) {
2469
- struct sigaction act;
2470
-
2471
- /* When the SA_SIGINFO flag is set in sa_flags then sa_sigaction is used.
2472
- * Otherwise, sa_handler is used. */
2473
- sigemptyset(&act.sa_mask);
2474
- act.sa_flags = 0;
2475
- act.sa_handler = sigtermHandler;
2476
- sigaction(SIGTERM, &act, NULL);
2477
-
2478
- #ifdef HAVE_BACKTRACE
2479
- sigemptyset(&act.sa_mask);
2480
- act.sa_flags = SA_NODEFER | SA_RESETHAND | SA_SIGINFO;
2481
- act.sa_sigaction = sigsegvHandler;
2482
- sigaction(SIGSEGV, &act, NULL);
2483
- sigaction(SIGBUS, &act, NULL);
2484
- sigaction(SIGFPE, &act, NULL);
2485
- sigaction(SIGILL, &act, NULL);
2486
- #endif
2487
- return;
2488
- }
2489
-
2490
- void memtest(size_t megabytes, int passes);
2491
-
2492
- int main(int argc, char **argv) {
2493
- long long start;
2494
- struct timeval tv;
2495
-
2496
- /* We need to initialize our libraries, and the server configuration. */
2497
- zmalloc_enable_thread_safeness();
2498
- srand(time(NULL)^getpid());
2499
- gettimeofday(&tv,NULL);
2500
- dictSetHashFunctionSeed(tv.tv_sec^tv.tv_usec^getpid());
2501
- initServerConfig();
2502
-
2503
- if (argc >= 2) {
2504
- int j = 1; /* First option to parse in argv[] */
2505
- sds options = sdsempty();
2506
- char *configfile = NULL;
2507
-
2508
- /* Handle special options --help and --version */
2509
- if (strcmp(argv[1], "-v") == 0 ||
2510
- strcmp(argv[1], "--version") == 0) version();
2511
- if (strcmp(argv[1], "--help") == 0 ||
2512
- strcmp(argv[1], "-h") == 0) usage();
2513
- if (strcmp(argv[1], "--test-memory") == 0) {
2514
- if (argc == 3) {
2515
- memtest(atoi(argv[2]),50);
2516
- exit(0);
2517
- } else {
2518
- fprintf(stderr,"Please specify the amount of memory to test in megabytes.\n");
2519
- fprintf(stderr,"Example: ./redis-server --test-memory 4096\n\n");
2520
- exit(1);
2521
- }
2522
- }
2523
-
2524
- /* First argument is the config file name? */
2525
- if (argv[j][0] != '-' || argv[j][1] != '-')
2526
- configfile = argv[j++];
2527
- /* All the other options are parsed and conceptually appended to the
2528
- * configuration file. For instance --port 6380 will generate the
2529
- * string "port 6380\n" to be parsed after the actual file name
2530
- * is parsed, if any. */
2531
- while(j != argc) {
2532
- if (argv[j][0] == '-' && argv[j][1] == '-') {
2533
- /* Option name */
2534
- if (sdslen(options)) options = sdscat(options,"\n");
2535
- options = sdscat(options,argv[j]+2);
2536
- options = sdscat(options," ");
2537
- } else {
2538
- /* Option argument */
2539
- options = sdscatrepr(options,argv[j],strlen(argv[j]));
2540
- options = sdscat(options," ");
2541
- }
2542
- j++;
2543
- }
2544
- resetServerSaveParams();
2545
- loadServerConfig(configfile,options);
2546
- sdsfree(options);
2547
- } else {
2548
- redisLog(REDIS_WARNING,"Warning: no config file specified, using the default config. In order to specify a config file use 'redis-server /path/to/redis.conf'");
2549
- }
2550
- if (server.daemonize) daemonize();
2551
- initServer();
2552
- if (server.daemonize) createPidFile();
2553
- redisAsciiArt();
2554
- redisLog(REDIS_WARNING,"Server started, Redis version " REDIS_VERSION);
2555
- #ifdef __linux__
2556
- linuxOvercommitMemoryWarning();
2557
- #endif
2558
- start = ustime();
2559
- if (server.aof_state == REDIS_AOF_ON) {
2560
- if (loadAppendOnlyFile(server.aof_filename) == REDIS_OK)
2561
- redisLog(REDIS_NOTICE,"DB loaded from append only file: %.3f seconds",(float)(ustime()-start)/1000000);
2562
- } else {
2563
- if (rdbLoad(server.rdb_filename) == REDIS_OK) {
2564
- redisLog(REDIS_NOTICE,"DB loaded from disk: %.3f seconds",
2565
- (float)(ustime()-start)/1000000);
2566
- } else if (errno != ENOENT) {
2567
- redisLog(REDIS_WARNING,"Fatal error loading the DB. Exiting.");
2568
- exit(1);
2569
- }
2570
- }
2571
- if (server.ipfd > 0)
2572
- redisLog(REDIS_NOTICE,"The server is now ready to accept connections on port %d", server.port);
2573
- if (server.sofd > 0)
2574
- redisLog(REDIS_NOTICE,"The server is now ready to accept connections at %s", server.unixsocket);
2575
- aeSetBeforeSleepProc(server.el,beforeSleep);
2576
- aeMain(server.el);
2577
- aeDeleteEventLoop(server.el);
2578
- return 0;
2579
- }
2580
-
2581
- /* The End */