///********* redis/src/server.h  ****************

struct redisServer {

.....

    char *repl_backlog;             /* Replication backlog for partial syncs */

    long long repl_backlog_size;    /* Backlog circular buffer size */

    long long repl_backlog_histlen; /* Backlog actual data length */

    long long repl_backlog_idx;     /* Backlog circular buffer current offset,

                                       that is the next byte will'll write to.*/

    long long repl_backlog_off;     /* Replication "master offset" of first

                                       byte in the replication backlog buffer.*/

.....

}

 

///********* redis/src/replication.c  ****************

void feedReplicationBacklog(void *ptr, size_t len) {

    unsigned char *p = ptr;

 

    server.master_repl_offset += len;

 

    /* This is a circular buffer, so write as much data we can at every

     * iteration and rewind the "idx" index if we reach the limit. */

    while(len) {

        size_t thislen = server.repl_backlog_size - server.repl_backlog_idx;

        if (thislen > len) thislen = len;

        memcpy(server.repl_backlog+server.repl_backlog_idx,p,thislen);

        server.repl_backlog_idx += thislen;

        if (server.repl_backlog_idx == server.repl_backlog_size)

            server.repl_backlog_idx = 0;

        len -= thislen;

        p += thislen;

        server.repl_backlog_histlen += thislen;

    }

    if (server.repl_backlog_histlen > server.repl_backlog_size)

        server.repl_backlog_histlen = server.repl_backlog_size;

    /* Set the offset of the first byte we have in the backlog. */

    server.repl_backlog_off = server.master_repl_offset -

                              server.repl_backlog_histlen + 1;

}

///********* redis/src/replication.c  ****************

 

void replicationFeedSlaves(list *slaves, int dictid, robj **argv, int argc) {

     .....

 /* Write the command to the replication backlog if any. */

    if (server.repl_backlog) {

        char aux[LONG_STR_SIZE+3];

 

        /* Add the multi bulk reply length. */

        aux[0] = '*';

        len = ll2string(aux+1,sizeof(aux)-1,argc);

        aux[len+1] = '\r';

        aux[len+2] = '\n';

        feedReplicationBacklog(aux,len+3);

 

        for (j = 0; j < argc; j++) {

            long objlen = stringObjectLen(argv[j]);

 

            /* We need to feed the buffer with the object as a bulk reply

             * not just as a plain string, so create the $..CRLF payload len

             * and add the final CRLF */

            aux[0] = '$';

            len = ll2string(aux+1,sizeof(aux)-1,objlen);

            aux[len+1] = '\r';

            aux[len+2] = '\n';

            feedReplicationBacklog(aux,len+3);

            feedReplicationBacklogWithObject(argv[j]);

            feedReplicationBacklog(aux+len+1,2);

        }

    }

     /* Write the command to every slave. */

    listRewind(slaves,&li);

    while((ln = listNext(&li))) {

        client *slave = ln->value;

 

        /* Don't feed slaves that are still waiting for BGSAVE to start */

        if (slave->replstate == SLAVE_STATE_WAIT_BGSAVE_START) continue;

 

        /* Feed slaves that are waiting for the initial SYNC (so these commands

         * are queued in the output buffer until the initial SYNC completes),

         * or are already in sync with the master. */

 

        /* Add the multi bulk length. */

        addReplyMultiBulkLen(slave,argc);

 

        /* Finally any additional argument that was not stored inside the

         * static buffer if any (from j to argc). */

        for (j = 0; j < argc; j++)

            addReplyBulk(slave,argv[j]);

    }

}

char master_replid[CONFIG_RUN_ID_SIZE+1];  /* Master PSYNC runid. */

long long master_initial_offset;           /* Master PSYNC offset. */

///********* redis/src/replication.c  ****************  

 

int masterTryPartialResynchronization(client *c) {

......

if (strcasecmp(master_replid, server.replid) &&

        (strcasecmp(master_replid, server.replid2) ||

         psync_offset > server.second_replid_offset))

    {

        /* Run id "?" is used by slaves that want to force a full resync. */

        if (master_replid[0] != '?') {

            if (strcasecmp(master_replid, server.replid) &&

                strcasecmp(master_replid, server.replid2))

            {

                serverLog(LL_NOTICE,"Partial resynchronization not accepted: "

                    "Replication ID mismatch (Slave asked for '%s', my "

                    "replication IDs are '%s' and '%s')",

                    master_replid, server.replid, server.replid2);

            } else {

                serverLog(LL_NOTICE,"Partial resynchronization not accepted: "

                    "Requested offset for second ID was %lld, but I can reply "

                    "up to %lld", psync_offset, server.second_replid_offset);

            }

        } else {

            serverLog(LL_NOTICE,"Full resync requested by slave %s",

                replicationGetSlaveName(c));

        }

        goto need_full_resync;

    }

 

    /* We still have the data our slave is asking for? */

    if (!server.repl_backlog ||

        psync_offset < server.repl_backlog_off ||

        psync_offset > (server.repl_backlog_off + server.repl_backlog_histlen))

    {

        serverLog(LL_NOTICE,

            "Unable to partial resync with slave %s for lack of backlog (Slave request was: %lld).", replicationGetSlaveName(c), psync_offset);

        if (psync_offset > server.master_repl_offset) {

            serverLog(LL_WARNING,

                "Warning: slave %s tried to PSYNC with an offset that is greater than the master replication offset.", replicationGetSlaveName(c));

        }

        goto need_full_resync;

    }

    ........

     //进行部分同步

}