1. 01 Apr, 2015 1 commit
    • antirez's avatar
      Net: improve prepareClientToWrite() error handling and comments. · 6c60526d
      antirez authored
      When we fail to setup the write handler it does not make sense to take
      the client around, it is missing writes: whatever is a client or a slave
      anyway the connection should terminated ASAP.
      
      Moreover what the function does exactly with its return value, and in
      which case the write handler is installed on the socket, was not clear,
      so the functions comment are improved to make the goals of the function
      more obvious.
      
      Also related to #2485.
      6c60526d
  2. 31 Mar, 2015 1 commit
    • Oran Agra's avatar
      fixes to diskless replication. · 159875b5
      Oran Agra authored
      master was closing the connection if the RDB transfer took long time.
      and also sent PINGs to the slave before it got the initial ACK, in which case the slave wouldn't be able to find the EOF marker.
      159875b5
  3. 30 Mar, 2015 1 commit
  4. 21 Mar, 2015 2 commits
    • antirez's avatar
      Net: processUnblockedClients() and clientsArePaused() minor changes. · 2b278a33
      antirez authored
      1. No need to set btype in processUnblockedClients(), since clients
         flagged REDIS_UNBLOCKED should have it already cleared.
      2. When putting clients in the unblocked clients list, clientsArePaused()
         should flag them with REDIS_UNBLOCKED. Not strictly needed with the
         current code but is more coherent.
      2b278a33
    • antirez's avatar
      Net: clientsArePaused() should not touch blocked clients. · 5fe4a231
      antirez authored
      When the list of unblocked clients were processed, btype was set to
      blocking type none, but the client remained flagged with REDIS_BLOCKED.
      When timeout is reached (or when the client disconnects), unblocking it
      will trigger an assertion.
      
      There is no need to process pending requests from blocked clients, so
      now clientsArePaused() just avoid touching blocked clients.
      
      Close #2467.
      5fe4a231
  5. 11 Mar, 2015 1 commit
  6. 27 Feb, 2015 1 commit
  7. 25 Feb, 2015 1 commit
  8. 19 Jan, 2015 1 commit
    • Matt Stancliff's avatar
      Improve networking type correctness · 53c082ec
      Matt Stancliff authored
      read() and write() return ssize_t (signed long), not int.
      
      For other offsets, we can use the unsigned size_t type instead
      of a signed offset (since our replication offsets and buffer
      positions are never negative).
      53c082ec
  9. 23 Dec, 2014 1 commit
  10. 11 Dec, 2014 2 commits
    • antirez's avatar
      sdsformatip() removed. · bbf0736c
      antirez authored
      Specialized single-use function. Not the best match for sds.c btw.
      Also genClientPeerId() is no longer static: we need symbols.
      bbf0736c
    • Matt Stancliff's avatar
      Cleanup all IP formatting code · 491881e1
      Matt Stancliff authored
      Instead of manually checking for strchr(n,':') everywhere,
      we can use our new centralized IP formatting functions.
      491881e1
  11. 03 Dec, 2014 1 commit
    • antirez's avatar
      Network bandwidth tracking + refactoring. · 1b732c09
      antirez authored
      Track bandwidth used by clients and replication (but diskless
      replication is not tracked since the actual transfer happens in the
      child process).
      
      This includes a refactoring that makes tracking new instantaneous
      metrics simpler.
      1b732c09
  12. 25 Nov, 2014 1 commit
    • antirez's avatar
      Avoid valgrind memory leak false positive in processInlineBuffer(). · a8f9a989
      antirez authored
      zmalloc(0) cauesd to actually trigger a non-zero allocation since with
      standard libc malloc we have our own zmalloc header for memory tracking,
      but at the same time the returned pointer is at the end of the block and
      not in the middle. This triggers a false positive when testing with
      valgrind.
      
      When the inline protocol args count is 0, we now avoid reallocating
      c->argv, preventing the issue to happen.
      a8f9a989
  13. 11 Nov, 2014 1 commit
    • antirez's avatar
      Diskless SYNC: fix RDB EOF detection. · bb7fea0d
      antirez authored
      RDB EOF detection was relying on the final part of the RDB transfer to
      be a magic 40 bytes EOF marker. However as the slave is put online
      immediately, and because of sockets timeouts, the replication stream is
      actually contiguous with the RDB file.
      
      This means that to detect the EOF correctly we should either:
      
      1) Scan all the stream searching for the mark. Sucks CPU-wise.
      2) Start to send the replication stream only after an acknowledge.
      3) Implement a proper chunked encoding.
      
      For now solution "2" was picked, so the master does not start to send
      ASAP the stream of commands in the case of diskless replication. We wait
      for the first REPLCONF ACK command from the slave, that certifies us
      that the slave correctly loaded the RDB file and is ready to get more
      data.
      bb7fea0d
  14. 27 Oct, 2014 1 commit
  15. 29 Sep, 2014 1 commit
  16. 13 Aug, 2014 1 commit
  17. 16 Jul, 2014 1 commit
    • antirez's avatar
      PubSub clients refactoring and new PUBSUB flag. · 59cf0824
      antirez authored
      The code tested many times if a client had active Pub/Sub subscriptions
      by checking the length of a list and dictionary where the patterns and
      channels are stored. This was substituted with a client flag called
      REDIS_PUBSUB that is simpler to test for. Moreover in order to manage
      this flag some code was refactored.
      
      This commit is believed to have no effects in the behavior of the
      server.
      59cf0824
  18. 26 Jun, 2014 2 commits
  19. 24 Jun, 2014 1 commit
  20. 16 Jun, 2014 5 commits
    • antirez's avatar
      CLIENT KILL API modified. · bb2011d9
      antirez authored
      Added a new SKIPME option that is true by default, that prevents the
      client sending the command to be killed, unless SKIPME NO is sent.
      bb2011d9
    • antirez's avatar
      e06b3819
    • antirez's avatar
      New features for CLIENT KILL. · e7affd26
      antirez authored
      e7affd26
    • 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
  21. 28 Apr, 2014 2 commits
  22. 24 Apr, 2014 3 commits
    • antirez's avatar
      Process events with processEventsWhileBlocked() when blocked. · e29d3307
      antirez authored
      When we are blocked and a few events a processed from time to time, it
      is smarter to call the event handler a few times in order to handle the
      accept, read, write, close cycle of a client in a single pass, otherwise
      there is too much latency added for clients to receive a reply while the
      server is busy in some way (for example during the DB loading).
      e29d3307
    • 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
    • antirez's avatar
      AE_ERR -> ANET_ERR in acceptUnixHandler(). · cac4bae1
      antirez authored
      No actual changes since the value is the same.
      cac4bae1
  23. 23 Apr, 2014 1 commit
  24. 06 Mar, 2014 1 commit
  25. 04 Feb, 2014 1 commit
    • antirez's avatar
      CLIENT PAUSE and related API implemented. · 4919a13f
      antirez authored
      The API is one of the bulding blocks of CLUSTER FAILOVER command that
      executes a manual failover in Redis Cluster. However exposed as a
      command that the user can call directly, it makes much simpler to
      upgrade a standalone Redis instance using a slave in a safer way.
      
      The commands works like that:
      
          CLIENT PAUSE <milliesconds>
      
      All the clients that are not slaves and not in MONITOR state are paused
      for the specified number of milliesconds. This means that slaves are
      normally served in the meantime.
      
      At the end of the specified amount of time all the clients are unblocked
      and will continue operations normally. This command has no effects on
      the population of the slow log, since clients are not blocked in the
      middle of operations but only when there is to process new data.
      
      Note that while the clients are unblocked, still new commands are
      accepted and queued in the client buffer, so clients will likely not
      block while writing to the server while the pause is active.
      4919a13f
  26. 25 Jan, 2014 1 commit
  27. 14 Jan, 2014 1 commit
    • antirez's avatar
      Cluster: support to read from slave nodes. · 28273394
      antirez authored
      A client can enter a special cluster read-only mode using the READONLY
      command: if the client read from a slave instance after this command,
      for slots that are actually served by the instance's master, the queries
      will be processed without redirection, allowing clients to read from
      slaves (but without any kind fo read-after-write guarantee).
      
      The READWRITE command can be used in order to exit the readonly state.
      28273394
  28. 25 Dec, 2013 1 commit
  29. 22 Dec, 2013 1 commit
  30. 20 Dec, 2013 1 commit