So erstellen Sie schnell einen Redis-Cluster mit Python

　Redis-Kommunikationsprotokoll

　Listen Sie die wichtigsten Punkte auf, um das Verständnis des folgenden Programms zu erleichtern.

　 Redis überwacht eingehende Verbindungen auf TCP-Port 6379 (Standardport, der in der Konfiguration geändert werden kann). Jeder Redis-Befehl oder jede zwischen dem Client und dem Server übertragene Daten endet mit rn.

　Reply (ein Protokoll, das der Server vom Client wiederherstellen kann)

　Redis antwortet auf Befehle mit unterschiedlichen Antworttypen. Es kann den Antworttyp ab dem ersten vom Server gesendeten Byte überprüfen:

　 * Bei einer einzeiligen Antwort (Statusantwort) ist das erste Byte der Antwort „+“

　 * Fehlermeldung der Antwort Das erste Byte ist „-“. )

　 Massenantworten werden vom Server verwendet, um eine einzelne binäre sichere Zeichenfolge zurückzugeben.

　 C: GET mykey

　 S: $6rnfoobarrn

　 Der Server sendet die erste Antwortzeile, die mit „$“ beginnt, gefolgt von der tatsächlichen Anzahl der zu sendenden Bytes, gefolgt von CRLF, und sendet dann die tatsächlichen Daten. und dann gibt es 2 Bytes zusätzliche Daten für das endgültige CRLF. Die genaue vom Server gesendete Sequenz lautet wie folgt:

　　"$6rnfoobarrn"

　 Wenn der angeforderte Wert nicht existiert, verwendet die Batch-Antwort den Sonderwert -1 als Datenlänge, zum Beispiel:

　 C: GET nonexistingkey

　 S: $- 1

　Wenn das angeforderte Objekt nicht existiert, gibt die Clientbibliothek-API keine leere Zeichenfolge, sondern ein leeres Objekt zurück. Beispiel: Die Ruby-Bibliothek gibt „nil“ zurück, während die C-Bibliothek NULL zurückgibt (oder das angegebene Flag im Antwortobjekt setzt) ​​usw.

　Binär

　Um es einfach auszudrücken: Binär bedeutet, dass es enthalten wird. Wenn also die C-Sprache verarbeitet wird, können Sie keine Str-Funktionen wie strlen, strcpy usw. verwenden, da diese zur Bestimmung des Endes der Zeichenfolge verwendet werden.

　 Redis-Cluster

Super einfach, einen Redis-Cluster zu erstellen

Auf der offiziellen Website wird auch beschrieben, wie man einen Redis-Cluster erstellt. Dies ist möglicherweise schwieriger auszuprobieren, da Centos6.5 verwendet wird besser.

　 Daten-Sharding des Redis-Clusters

　 Der Redis-Cluster verwendet kein konsistentes Hashing, sondern führt das Konzept des Hash-Slots ein.

　 Der Redis-Cluster verfügt über 16384 Hash-Slots, und jeder Schlüssel wird nach dem Bestehen von CRC16 überprüft Slot zum Platzieren. Jeder Knoten im Cluster ist für einen Teil des Hash-Slots verantwortlich. Wenn der aktuelle Cluster beispielsweise 3 Knoten hat, dann:

　 * Knoten A enthält Hash-Slots 0 bis 5500.

　 * Knoten B enthält Hash-Slots 5501 bis 11000.

　 * Knoten C enthält Hash-Slots 11001 bis 16384.

Diese Struktur erleichtert das Hinzufügen oder Löschen von Knoten. Wenn ich beispielsweise einen neuen Knoten D hinzufügen möchte, muss ich bei Knoten beginnen A, einige Slots in B und C werden nach D verschoben. Wenn ich Knoten A entfernen möchte, muss ich die Slots in A zu den Knoten B und C verschieben und dann den A-Knoten ohne Slots aus dem Cluster entfernen Ein Hash-Slot von einem Knoten zu einem anderen stoppt den Dienst nicht. Das Hinzufügen, Löschen oder Ändern der Anzahl von Hash-Slots eines Knotens führt nicht dazu, dass der Cluster nicht mehr verfügbar ist.

　Im Redis-Clusterprotokoll Client- und Serverseite

In In einem Redis-Cluster sind Knoten für die Speicherung von Daten und die Aufzeichnung des Status des Clusters verantwortlich (einschließlich der Zuordnung von Schlüsselwerten zu den richtigen Knoten). Cluster-Knoten können auch automatisch andere Knoten erkennen, Knoten erkennen, die nicht ordnungsgemäß funktionieren, und bei Bedarf Master-Knoten aus Slave-Knoten auswählen.

　Um diese Aufgaben auszuführen, kommunizieren alle Clusterknoten über eine TCP-Verbindung (TCP-Bus?) und ein Binärprotokoll (Cluster-Verbindung, Cluster-Bus). Jeder Knoten ist über einen Clusterbus mit jedem anderen Knoten im Cluster verbunden. Knoten verwenden ein Gossip-Protokoll, um Cluster-Informationen zu verbreiten, die: neue Knoten entdecken, Ping-Pakete senden (um sicherzustellen, dass alle Knoten ordnungsgemäß funktionieren) und Cluster-Nachrichten senden, wenn bestimmte Situationen auftreten. Clusterverbindungen werden auch zum Veröffentlichen oder Abonnieren von Nachrichten im Cluster verwendet.

Da die Cluster-Knoten Anfragen nicht weiterleiten können, leitet der Client den Befehl an andere Knoten um, wenn er die Umleitungsfehler -MOVED und -ASK erhält. Theoretisch steht es dem Client frei, Anfragen an alle Knoten im Cluster zu senden und Anfragen bei Bedarf an andere Knoten umzuleiten, sodass der Client den Clusterstatus nicht speichern muss. Der Client kann jedoch die Zuordnungsbeziehung zwischen Schlüsselwerten und Knoten zwischenspeichern, was die Effizienz der Befehlsausführung erheblich verbessern kann.

　 -MOVED

　 Einfach ausgedrückt: Wenn -MOVED zurückgegeben wird, dh wenn der Client eine Verbindung zu Knoten A herstellt und die Verarbeitung des Schlüssels anfordert, sich der Schlüssel jedoch tatsächlich auf Knoten B befindet, wird -MOVED zurückgegeben lautet wie folgt: -MOVED 3999 127.0.0.1:6381

Keine Notwendigkeit, die Situation von -ASK zu berücksichtigen.

　　Redis-Client in C-Sprache implementiert

　Der Code lautet wie folgt:

#include <string.h>#include <sys/socket.h>#include <arpa/inet.h>#include <errno.h>#include <fcntl.h>#include <netdb.h>#include <sys/poll.h>#include <unistd.h>#include <sys/types.h>#include <stdlib.h>#include <stdio.h>ssize_t sock_write_loop( int fd, const void *vptr, size_t n )
{
    size_t nleft = 0;
    ssize_t nwritten = 0;const char *ptr;

    ptr = (char *) vptr;
    nleft = n;while( nleft > 0 )
    {if( (nwritten = write(fd, ptr, nleft) ) <= 0 )
        {if( errno == EINTR )
            {
                nwritten = 0;  //再次调用write            }else{return -5;
            }
        }
        nleft = nleft - nwritten;
        ptr = ptr + nwritten;
    }return(n);
}int sock_read_wait( int fd, int timeout )
{struct pollfd pfd;

    pfd.fd = fd;
    pfd.events = POLLIN;
    pfd.revents = 0;

    timeout *= 1000;for (;;) 
    {switch( poll(&pfd, 1, timeout) ) 
        {case -1:if( errno != EINTR ) 
                {return (-2);
                }continue;case 0:
                errno = ETIMEDOUT;return (-1);default:if( pfd.revents & POLLIN )return (0);elsereturn (-3);
        }
    }

}

ssize_t sock_read_tmo( int fd, void *vptr, size_t len, int timeout )
{   if( timeout > 0 && sock_read_wait(fd, timeout) < 0 )return (-1);elsereturn (read(fd, vptr, len));

}int sock_connect_nore(const char *IPaddr , int port , int timeout)
{   // char temp[4096];int sock_fd = 0, n = 0, errcode = 0;struct sockaddr_in servaddr;if( IPaddr == NULL )
    {return -1;
    }if( (sock_fd = socket(AF_INET, SOCK_STREAM, 0) ) < 0 )
    {return -1;
    }

    memset(&servaddr, 0, sizeof(servaddr));
    servaddr.sin_family = AF_INET;
    servaddr.sin_port   = htons(port);//changed by navy 2003.3.3 for support domain addr//if( (servaddr.sin_addr.s_addr = inet_addr(IPaddr) ) == -1 )if( (errcode = inet_pton(AF_INET, IPaddr, &servaddr.sin_addr) ) <= 0 )
    {//added by navy 2003.3.31 for support domain addrstruct hostent* pHost = NULL, host;char sBuf[2048], sHostIp[17];int h_errnop = 0;

        memset(&host, 0, sizeof(host));
        memset(sBuf, 0, sizeof(sBuf));
        memset(sHostIp, 0 , sizeof(sHostIp));
        pHost = &host;

#ifdef _SOLARIS_PLAT//solarisif( (gethostbyname_r(IPaddr, pHost, sBuf, sizeof(sBuf), &h_errnop) == NULL) || 
#else//linuxif( (gethostbyname_r(IPaddr, pHost, sBuf, sizeof(sBuf), &pHost, &h_errnop) != 0) || 
#endif(pHost == NULL) ) 
                {
                close(sock_fd);return -1;
                }if( pHost->h_addrtype != AF_INET && pHost->h_addrtype != AF_INET6 )
                {
                close(sock_fd);return -1;
                }//目前仅取第一个IP地址if( (inet_ntop(pHost->h_addrtype, *(pHost->h_addr_list), sHostIp, sizeof(sHostIp)) ) == NULL )
                {
                    close(sock_fd);return -1;
                }                if( (errcode = inet_pton(AF_INET, sHostIp, &servaddr.sin_addr) ) <= 0 )
                {
                    close(sock_fd);                    return -1;
                }//end added by navy 2003.3.31    }if( (errcode = sock_timed_connect(sock_fd, (struct sockaddr *)&servaddr, sizeof(servaddr), timeout) ) < 0 )
    {
        close(sock_fd);        return -1;
    }return sock_fd;
}int sock_connect(const char *IPaddr , int port , int timeout)
{char temp[4096];int sock_fd = 0, n = 0, errcode = 0;struct sockaddr_in servaddr;if( IPaddr == NULL )
    {return -1;
    }if( (sock_fd = socket(AF_INET, SOCK_STREAM, 0) ) < 0 )
    {return -1;
    }

    memset(&servaddr, 0, sizeof(servaddr));
    servaddr.sin_family = AF_INET;
    servaddr.sin_port   = htons(port);//changed by navy 2003.3.3 for support domain addr//if( (servaddr.sin_addr.s_addr = inet_addr(IPaddr) ) == -1 )if( (errcode = inet_pton(AF_INET, IPaddr, &servaddr.sin_addr) ) <= 0 )
    {//added by navy 2003.3.31 for support domain addrstruct hostent* pHost = NULL, host;char sBuf[2048], sHostIp[17];int h_errnop = 0;

        memset(&host, 0, sizeof(host));
        memset(sBuf, 0, sizeof(sBuf));
        memset(sHostIp, 0 , sizeof(sHostIp));
        pHost = &host;

#ifdef _SOLARIS_PLAT//solarisif( (gethostbyname_r(IPaddr, pHost, sBuf, sizeof(sBuf), &h_errnop) == NULL) || 
#else//linuxif( (gethostbyname_r(IPaddr, pHost, sBuf, sizeof(sBuf), &pHost, &h_errnop) != 0) || 
#endif(pHost == NULL) ) 
                {
                close(sock_fd);return -1;
                }if( pHost->h_addrtype != AF_INET && pHost->h_addrtype != AF_INET6 )
                {
                close(sock_fd);return -1;
                }//目前仅取第一个IP地址if( (inet_ntop(pHost->h_addrtype, *(pHost->h_addr_list), sHostIp, sizeof(sHostIp)) ) == NULL )
                {
                    close(sock_fd);return -1;
                }                if( (errcode = inet_pton(AF_INET, sHostIp, &servaddr.sin_addr) ) <= 0 )
                {
                    close(sock_fd);                    return -1;
                }//end added by navy 2003.3.31    }if( (errcode = sock_timed_connect(sock_fd, (struct sockaddr *)&servaddr, sizeof(servaddr), timeout) ) < 0 )
    {
        close(sock_fd);        return -1;
    }

    n = sock_read_tmo(sock_fd, temp, 4096, timeout);//一般错误if( n <= 0 ) 
    {
        close(sock_fd);
        
        sock_fd = -1;
    }return sock_fd;
}int sock_non_blocking(int fd, int on)
{int     flags;if ((flags = fcntl(fd, F_GETFL, 0)) < 0){return -10;
    }if (fcntl(fd, F_SETFL, on ? flags | O_NONBLOCK : flags & ~O_NONBLOCK) < 0){return -10;
    }return 0;
}int sock_write_wait(int fd, int timeout)
{struct pollfd pfd;

    pfd.fd = fd;
    pfd.events = POLLOUT;
    pfd.revents = 0;

    timeout *= 1000;for (;;) 
    {switch( poll(&pfd, 1, timeout) ) 
        {case -1:if( errno != EINTR ) 
            {return (-2);
            }continue;case 0:
            errno = ETIMEDOUT;return (-1);default:if( pfd.revents & POLLOUT )return (0);elsereturn (-3);
        }
    }

}int sock_timed_connect(int sock, struct sockaddr * sa, int len, int timeout)
{int error = 0;
    socklen_t error_len;

    sock_non_blocking(sock, 1);if( connect(sock, sa, len) == 0 )
    {
        sock_non_blocking(sock, 0);return (0);
    }if( errno != EINPROGRESS )
    {
        sock_non_blocking(sock, 0);return (-1);
    }/* * A connection is in progress. Wait for a limited amount of time for
     * something to happen. If nothing happens, report an error.     */if( sock_write_wait(sock, timeout) != 0)
    {
        sock_non_blocking(sock, 0);return (-2);
    }/* * Something happened. Some Solaris 2 versions have getsockopt() itself
     * return the error, instead of returning it via the parameter list.     */error = 0;
    error_len = sizeof(error);if( getsockopt(sock, SOL_SOCKET, SO_ERROR, (char *) &error, &error_len) != 0 )
    {
        sock_non_blocking(sock, 0);return (-3);
    }if( error ) 
    {
        errno = error;
        sock_non_blocking(sock, 0);return (-4);
    }

    sock_non_blocking(sock, 0);/* * No problems.     */return (0);

}static int check_ip_in_list(const char *ip, char *iplist)
{        char *token = NULL;char *saveptr = NULL;
    token = strtok_r(iplist, ",", &saveptr);while(token != NULL)
    {        char *ptmp = NULL;                        char *ip_mask = strtok_r(token, "/", &ptmp);if(!ip_mask)                    return -1;                     char *ip_bit = strtok_r(NULL, "/", &ptmp);        if(ip_bit)
        {int mask_bit = atoi(ip_bit);if(mask_bit < 0 || mask_bit >32)continue;

            unsigned long addr[4] = { 0 };
            sscanf( ip_mask, "%lu.%lu.%lu.%lu", addr, addr + 1, addr + 2, addr + 3 );
            unsigned long vl1 = addr[0] << 24 | addr[1] << 16 | addr[2] << 8 | addr[3];

            sscanf( ip, "%lu.%lu.%lu.%lu", addr, addr + 1, addr + 2, addr + 3 );
            unsigned long vl2 = addr[0] << 24 | addr[1] << 16 | addr[2] << 8 | addr[3];

            vl1 = ( vl1 >> ( 32 - mask_bit ) );
            vl2 = ( vl2 >> ( 32 - mask_bit ) );if( vl1 == vl2 )                        return 1;                          
        }else{if(strcmp(ip,ip_mask) == 0)            return 1;                            
        }                    

        token = strtok_r(NULL, ",", &saveptr);                
    }        return 0;
}static int check_ip_in_redis(const char *redis_host, const char *ip,const char *rq_pro)
{char buf[128];int loops = 0;    

    strcpy(buf, redis_host);    do{
        loops ++;char *ptmp = NULL;char *host = strtok_r(buf, ":", &ptmp);if(!host) return -1;char *s_port = strtok_r(NULL, ":", &ptmp);if(!s_port) return -1;int port = atoi(s_port);char respone[40] = {0};int sock_fd = -1;if((sock_fd = sock_connect_nore(host, port, 5))<0)return -1;if(sock_write_loop(sock_fd, rq_pro, strlen(rq_pro)) != strlen(rq_pro))
        {
            close(sock_fd);return -1;
        }if(sock_read_tmo(sock_fd, respone, sizeof(respone)-1, 5)<=0)
        {
            close(sock_fd);return -1;
        }        if(strncmp(":0", respone, 2) == 0)
        {
            close(sock_fd);return 0;
        }            else if(strncmp(":1", respone, 2) == 0)
        {
            close(sock_fd);return 1;
        }            else if(strncmp("$", respone, 1) == 0)
        {                                    int data_size = 0;   int ret = 0;char *data_line = strstr(respone,"rn");if(!data_line)
            {
                close(sock_fd);return -1;
            }
            data_line = data_line+2;

            data_size = atoi(respone+1);if(data_size == -1)
            {
                close(sock_fd);return 0;
            }if(strlen(data_line) == data_size+2)
            {
                printf("line = %d, data_line = %sn",__LINE__,data_line);
                ret=check_ip_in_list(ip, data_line);
                close(sock_fd);return ret;
            }char *data = calloc(data_size+3,1);if(!data)
            {
                close(sock_fd);return -1;
            }
            strcpy(data,data_line);int read_size = strlen(data);int left_size = data_size + 2 - read_size;while(left_size > 0)
            {int nread = sock_read_tmo(sock_fd, data+read_size, left_size, 5);if(nread<=0)
                {free(data);
                    close(sock_fd);            return -1;
                }
                read_size += nread;
                left_size -= nread;
            }
            close(sock_fd);
            printf("line = %d, data = %sn",__LINE__,data);
            ret=check_ip_in_list(ip, data);free(data);return ret;
        }            else if(strncmp("-MOVED", respone, 6) == 0)
        {
            close(sock_fd);char *p = strchr(respone, &#39; &#39;);if(p == NULL)return -1;

            p = strchr(p+1, &#39; &#39;);if(p == NULL)return -1;

            strcpy(buf, p+1);
        }else{
            close(sock_fd);return -1;
        }            
        
    }while(loops < 2);return -1;
}int main(int argc,char *argv[])
{if(argc != 2)
    {
        printf("please input ipn");return -1;
    }     const char *redis_ip = "127.0.0.1:7002";const char *domain = "test.com";char exist_pro[128] = {0};char get_pro[128] = {0};    
    snprintf(exist_pro,sizeof(exist_pro),"EXISTS test|%s|%srn",domain,"127.0.0.1");        
    snprintf(get_pro,sizeof(get_pro),"GET test_%srn",domain);int loops = 0;int ret = 0;do{
        loops ++;
        ret = check_ip_in_redis(redis_ip, argv[1],exist_pro);if(ret == 0)
            ret = check_ip_in_redis(redis_ip, argv[1],get_pro);
    }while(loops < 3 && ret < 0);

    printf("line = %d, ret = %dn",__LINE__,ret);return ret;
}

c_redis_cli.c

　Die Hauptsache ist die Funktion check_ip_in_redis, die anderen sind einige Socket-Kapselungen.

　Python implementiert den Redis-Client

#!/usr/bin/pythonimport sys  
import socketdef main(argv):if(len(argv) != 3):print "please input domain ip!"returnhost = "192.168.188.47"   
    port = 7002while 1:
        s = socket.socket()                
        s.connect((host, port))
        
        cmd = 'set %s_white_ip %srn' % (argv[1],argv[2])        
        s.send(cmd)
        res = s.recv(32)
        s.close()        
    if res[0] == "+":print "set domain white  ip suc!"return    elif res[0:6] == "-MOVED":
            list = res.split(" ")
            ip_list = list[2].split(":")            
            host = ip_list[0]    
            port = int(ip_list[1])                            else:print "set domain white  ip error!"return                               if __name__ == "__main__":
    main(sys.argv)

Das obige ist der detaillierte Inhalt vonSo erstellen Sie schnell einen Redis-Cluster mit Python. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!