1. 27 Jun, 2014 1 commit
    • Matt Stancliff's avatar
      Cluster: Add COMMANDS command · 183458f7
      Matt Stancliff authored
      COMMANDS returns a nested multibulk reply for each
      command in the command table.  The reply for each
      command contains:
        - command name
        - arity
        - array of command flags
        - start key position
        - end key position
        - key offset step
        - optional: if the keys are not deterministic and
          Redis uses an internal key evaluation function,
          the 6th field appears and is defined as a status
          reply of: REQUIRES ARGUMENT PARSING
      
      Cluster clients need to know where the keys are in each
      command to implement proper routing to cluster nodes.
      
      Redis commands can have multiple keys, keys at offset steps, or other
      issues where you can't always assume the first element after
      the command name is the cluster routing key.
      
      Using the information exposed by COMMANDS, client implementations
      can have live, accurate key extraction details for all commands.
      
      Also implements COMMANDS INFO [commands...] to return only a
      specific set of commands instead of all 160+ commands live in Redis.
      183458f7
  2. 26 Jun, 2014 1 commit
  3. 23 Jun, 2014 1 commit
  4. 21 Jun, 2014 2 commits
  5. 16 Jun, 2014 2 commits
    • antirez's avatar
      Assign an unique non-repeating ID to each new client. · f26f79ea
      antirez authored
      This will be used by CLIENT KILL and is also a good way to ensure a
      given client is still the same across CLIENT LIST calls.
      
      The output of CLIENT LIST was modified to include the new ID, but this
      change is considered to be backward compatible as the API does not imply
      you can do positional parsing, since each filed as a different name.
      f26f79ea
    • antirez's avatar
      Client types generalized. · 56d26c23
      antirez authored
      Because of output buffer limits Redis internals had this idea of type of
      clients: normal, pubsub, slave. It is possible to set different output
      buffer limits for the three kinds of clients.
      
      However all the macros and API were named after output buffer limit
      classes, while the idea of a client type is a generic one that can be
      reused.
      
      This commit does two things:
      
      1) Rename the API and defines with more general names.
      2) Change the class of clients executing the MONITOR command from "slave"
         to "normal".
      
      "2" is a good idea because you want to have very special settings for
      slaves, that are not a good idea for MONITOR clients that are instead
      normal clients even if they are conceptually slave-alike (since it is a
      push protocol).
      
      The backward-compatibility breakage resulting from "2" is considered to
      be minimal to care, since MONITOR is a debugging command, and because
      anyway this change is not going to break the format or the behavior, but
      just when a connection is closed on big output buffer issues.
      56d26c23
  6. 07 Jun, 2014 1 commit
    • antirez's avatar
      ROLE command added. · d34c2fa3
      antirez authored
      The new ROLE command is designed in order to provide a client with
      informations about the replication in a fast and easy to use way
      compared to the INFO command where the same information is also
      available.
      d34c2fa3
  7. 05 Jun, 2014 1 commit
  8. 22 May, 2014 3 commits
  9. 12 May, 2014 1 commit
  10. 24 Apr, 2014 1 commit
    • antirez's avatar
      Accept multiple clients per iteration. · 3a3458ee
      antirez authored
      When the listening sockets readable event is fired, we have the chance
      to accept multiple clients instead of accepting a single one. This makes
      Redis more responsive when there is a mass-connect event (for example
      after the server startup), and in workloads where a connect-disconnect
      pattern is used often, so that multiple clients are waiting to be
      accepted continuously.
      
      As a side effect, this commit makes the LOADING, BUSY, and similar
      errors much faster to deliver to the client, making Redis more
      responsive when there is to return errors to inform the clients that the
      server is blocked in an not interruptible operation.
      3a3458ee
  11. 17 Apr, 2014 2 commits
  12. 16 Apr, 2014 1 commit
  13. 15 Apr, 2014 1 commit
  14. 14 Apr, 2014 1 commit
  15. 13 Apr, 2014 1 commit
  16. 07 Apr, 2014 1 commit
    • antirez's avatar
      Add casting to match printf format. · 67bb2c46
      antirez authored
      adjustOpenFilesLimit() and clusterUpdateSlotsWithConfig() that were
      assuming uint64_t is the same as unsigned long long, which is true
      probably for all the systems out there that we target, but still GCC
      emitted a warning since technically they are two different types.
      67bb2c46
  17. 05 Apr, 2014 1 commit
  18. 03 Apr, 2014 1 commit
    • antirez's avatar
      PFGETREG added for testing purposes. · aaaed66c
      antirez authored
      The new command allows to get a dump of the registers stored
      into an HyperLogLog data structure for testing / debugging purposes.
      aaaed66c
  19. 31 Mar, 2014 3 commits
  20. 28 Mar, 2014 3 commits
  21. 25 Mar, 2014 2 commits
    • antirez's avatar
      Fix off by one bug in freeMemoryIfNeeded() eviction pool. · 6540e9ee
      antirez authored
      Bug found by the continuous integration test running the Redis
      with valgrind:
      
      ==6245== Invalid read of size 8
      ==6245==    at 0x4C2DEEF: memcpy@GLIBC_2.2.5 (mc_replace_strmem.c:876)
      ==6245==    by 0x41F9E6: freeMemoryIfNeeded (redis.c:3010)
      ==6245==    by 0x41D2CC: processCommand (redis.c:2069)
      
      memmove() size argument was accounting for an extra element, going
      outside the bounds of the array.
      6540e9ee
    • antirez's avatar
      adjustOpenFilesLimit() refactoring. · 6e33c908
      antirez authored
      In this commit:
      * Decrement steps are semantically differentiated from the reserved FDs.
        Previously both values were 32 but the meaning was different.
      * Make it clear that we save setrlimit errno.
      * Don't explicitly handle wrapping of 'f', but prevent it from
        happening.
      * Add comments to make the function flow more readable.
      
      This integrates PR #1630
      6e33c908
  22. 24 Mar, 2014 7 commits
    • Matt Stancliff's avatar
      Fix potentially incorrect errno usage · 386a4694
      Matt Stancliff authored
      errno may be reset by the previous call to redisLog, so capture
      the original value for proper error reporting.
      386a4694
    • Matt Stancliff's avatar
      Add REDIS_MIN_RESERVED_FDS define for open fds · 3b54ee6e
      Matt Stancliff authored
      Also update the original REDIS_EVENTLOOP_FDSET_INCR to
      include REDIS_MIN_RESERVED_FDS. REDIS_EVENTLOOP_FDSET_INCR
      exists to make sure more than (maxclients+RESERVED) entries
      are allocated, but we can only guarantee that if we include
      the current value of REDIS_MIN_RESERVED_FDS as a minimum
      for the INCR size.
      3b54ee6e
    • Matt Stancliff's avatar
      Fix infinite loop on startup if ulimit too low · 90b84421
      Matt Stancliff authored
      Fun fact: rlim_t is an unsigned long long on all platforms.
      
      Continually subtracting from a rlim_t makes it get smaller
      and smaller until it wraps, then you're up to 2^64-1.
      
      This was causing an infinite loop on Redis startup if
      your ulimit was extremely (almost comically) low.
      
      The case of (f > oldlimit) would never be met in a case like:
      
          f = 150
          while (f > 20) f -= 128
      
      Since f is unsigned, it can't go negative and would
      take on values of:
      
          Iteration 1: 150 - 128 => 22
          Iteration 2:  22 - 128 => 18446744073709551510
          Iterations 3-∞: ...
      
      To catch the wraparound, we use the previous value of f
      stored in limit.rlimit_cur.  If we subtract from f and
      get a larger number than the value it had previously,
      we print an error and exit since we don't have enough
      file descriptors to help the user at this point.
      
      Thanks to @bs3g for the inspiration to fix this problem.
      Patches existed from @bs3g at antirez#1227, but I needed to repair a few other
      parts of Redis simultaneously, so I didn't get a chance to use them.
      90b84421
    • Matt Stancliff's avatar
      Improve error handling around setting ulimits · 4a25983f
      Matt Stancliff authored
      The log messages about open file limits have always
      been slightly opaque and confusing.  Here's an attempt to
      fix their wording, detail, and meaning.  Users will have a
      better understanding of how to fix very common problems
      with these reworded messages.
      
      Also, we handle a new error case when maxclients becomes less
      than one, essentially rendering the server unusable.  We
      now exit on startup instead of leaving the user with a server
      unable to handle any connections.
      
      This fixes antirez#356 as well.
      4a25983f
    • Matt Stancliff's avatar
      Replace magic 32 with REDIS_EVENTLOOP_FDSET_INCR · 491532a7
      Matt Stancliff authored
      32 was the additional number of file descriptors Redis
      would reserve when managing a too-low ulimit.  The
      number 32 was in too many places statically, so now
      we use a macro instead that looks more appropriate.
      
      When Redis sets up the server event loop, it uses:
          server.maxclients+REDIS_EVENTLOOP_FDSET_INCR
      
      So, when reserving file descriptors, it makes sense to
      reserve at least REDIS_EVENTLOOP_FDSET_INCR FDs instead
      of only 32.  Currently, REDIS_EVENTLOOP_FDSET_INCR is
      set to 128 in redis.h.
      
      Also, I replaced the static 128 in the while f < old loop
      with REDIS_EVENTLOOP_FDSET_INCR as well, which results
      in no change since it was already 128.
      
      Impact: Users now need at least maxclients+128 as
      their open file limit instead of maxclients+32 to obtain
      actual "maxclients" number of clients.  Redis will carve
      the extra REDIS_EVENTLOOP_FDSET_INCR file descriptors it
      needs out of the "maxclients" range instead of failing
      to start (unless the local ulimit -n is too low to accomidate
      the request).
      491532a7
    • antirez's avatar
      Sample and cache RSS in serverCron(). · 93253c27
      antirez authored
      Obtaining the RSS (Resident Set Size) info is slow in Linux and OSX.
      This slowed down the generation of the INFO 'memory' section.
      
      Since the RSS does not require to be a real-time measurement, we
      now sample it with server.hz frequency (10 times per second by default)
      and use this value both to show the INFO rss field and to compute the
      fragmentation ratio.
      
      Practically this does not make any difference for memory profiling of
      Redis but speeds up the INFO call significantly.
      93253c27
    • antirez's avatar
      Cache uname() output across INFO calls. · d3efe04c
      antirez authored
      Uname was profiled to be a slow syscall. It produces always the same
      output in the context of a single execution of Redis, so calling it at
      every INFO output generation does not make too much sense.
      
      The uname utsname structure was modified as a static variable. At the
      same time a static integer was added to check if we need to call uname
      the first time.
      d3efe04c
  23. 20 Mar, 2014 2 commits