zookeeper c api主备切换例子

最新推荐文章于 2024-01-08 15:46:40 发布
最新推荐文章于 2024-01-08 15:46:40 发布
阅读量457 收藏
点赞数
分类专栏： 网络 文章标签： zookeeper c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fulianzhou/article/details/120458626
版权

步骤：
1.准备3台主机并同步好时间。
2.在主机1启动zookeeper服务,创建节点/services
3.在主机2运行应用程序，连接主机1的zookeeper
4.主机2往zookeeper的/services节点注册临时节点,节点名=IP:端口 节点数据=注册时间us
5.主机2监听/services节点
6.分别在主机1，主机3启动运行应用程序；分别向zookeeper注册临时节点。并监听/services节点。
7.以先启动的应用程序为主机，及节点数据小的为主机。
8.三台主机运行起来后，只有一台为主机，其余为备机。
概图

zkCli.h

#ifndef _ZKCLIENT_H_
#define _ZKCLIENT_H_

#ifdef _WIN32
    #include "zk\include\zookeeper.h"
    #include "zk\include\zookeeper.jute.h"
    #include "zk\include\zookeeper_log.h"
    #include "zk\include\zookeeper_version.h"
#else
    #include <zookeeper/zookeeper.h>
    #include <sys/types.h>
    #include <ifaddrs.h>
    #include <arpa/inet.h>
    #include <sys/socket.h>
    #include <netdb.h>
    #include <stdlib.h>
    #include <unistd.h>
    #include <net/if.h>
    #include <errno.h>
    #include <string.h>
    #include <pthread.h>
#endif

#define INFO(fmt, args...) printf("[%s:%d %s][INFO]");printf(fmt, ##args);

typedef void(*FUN)(const char*, const char*);

class ZkCli
{
private:
    zhandle_t *m_ZkHandle;
    pthread_mutex_t m_mutex;
    pthread_cond_t m_cond;
    bool m_Connected;
    char m_servAddr[64];
    char m_zkAddr[64];
    char m_path[64];
    FUN m_func;
public:
    ZkCli();
    ~ZkCli();

    bool zkInit(const char* zkaddr, const char* path);
    int Create(const char* path);
    int Set(const char* path, const char* data, int size);
    void Register(const char* listenIp, const unsigned short listenPort, FUN func);
    void getLocalIp(char *localIp, int len);

private:
    int64_t getTimeStampUs();
    void setConnected(bool stat);
    void ServiceWatch(const char* path);

private:
    /*typedef void (*watcher_fn)(zhandle_t *zh, int type, int state, const char *path, void *watcherCtx);*/
    static void init_watcher(zhandle_t *zh, int type, int stat, const char* path, void* watcherCtx);
    static void require_wachter(zhandle_t *zh, int type, int stat, const char* path, void* watcherCtx);
};

#endif

zkCli.cpp

#include "zkCli.h"
#include <sys/time.h>
#include <unordered_map>

ZkCli::ZkCli()
: m_ZkHandle(NULL),
m_Connected(false)
{
    pthread_mutex_init(&m_mutex, NULL);
    pthread_cond_init(&m_cond, NULL);
}

ZkCli::~ZkCli()
{
    pthread_mutex_destroy(&m_mutex);
    pthread_cond_destroy(&m_cond);

    zookeeper_close(m_ZkHandle);
}

int64_t ZkCli::getTimeStampUs()
{
    struct timeval stamp;

    gettimeofday(&stamp, NULL);

    return (int64_t)(stamp.tv_sec * 1000000 + stamp.tv_usec);
}

void ZkCli::setConnected(bool stat)
{
    if (stat)
    {
        pthread_cond_signal(&m_cond);
    }
    m_Connected = stat;
}

void ZkCli::init_watcher(zhandle_t *zh, int type, int stat, const char* path, void* watcherCtx)
{
    ZkCli* pCli = (ZkCli*)watcherCtx;

    if (type == ZOO_SESSION_EVENT)
    {
        if (stat == ZOO_CONNECTING_STATE)
        {
            pCli->setConnected(false);
        }
        else if (stat == ZOO_CONNECTED_STATE)
        {
            pCli->setConnected(true);
        }
        else if (stat == ZOO_NOTCONNECTED_STATE)
        {
            pCli->setConnected(false);
        }
    }
}

void ZkCli::require_wachter(zhandle_t* zh, int type, int stat, const char* path, void* watherCtx)
{
    printf("require_wachter() : type=%d, stat=%d, path=%s\n", type, stat, path);

    ZkCli* pZkCli = (ZkCli*)watherCtx;
    pZkCli->ServiceWatch(path);
}

void ZkCli::getLocalIp(char* localIp, int len)
{
    struct ifaddrs *ifaddr;

    if (getifaddrs(&ifaddr) == -1)
    {
        printf("getifaddr failed, errno=%d, errmsg=%s\n", errno, strerror(errno));
        exit(EXIT_FAILURE);
    }

    char host[NI_MAXHOST];
    for (struct ifaddrs *ifa = ifaddr; ifa != NULL; ifa = ifa->ifa_next) {
        if (ifa->ifa_addr == NULL)
            continue;
        int family = ifa->ifa_addr->sa_family;

        if (!ifa->ifa_flags & IFF_BROADCAST)
        {
            continue;
        }

        if (family == AF_INET || family == AF_INET6)
        {
            int s = getnameinfo(ifa->ifa_addr, (family == AF_INET) ? sizeof(struct sockaddr_in) : sizeof(struct sockaddr_in6), host, NI_MAXHOST, NULL, 0, NI_NUMERICHOST);
            if (s != 0)
            {
                printf("getnameinfo() failed: %s\n", gai_strerror(s));
                break;
            }

            if (strcmp(host, "127.0.0.1"))
            {
                strncpy(localIp, host, len);
                break;
            }
        }
    }

    freeifaddrs(ifaddr);
}

bool ZkCli::zkInit(const char* zkAddr, const char* path)
{
    zoo_set_debug_level(ZOO_LOG_LEVEL_WARN);
    m_ZkHandle = zookeeper_init(zkAddr, init_watcher, 3000, NULL, this, 0);
    if (!m_ZkHandle)
    {
        INFO("zookeeper_init failed, zkAddr:%s, errno=%d, errmsg=%s\n", zkAddr, errno, strerror(errno));
        return false;
    }
    strncpy(m_zkAddr, zkAddr, sizeof(m_zkAddr));

    struct timeval now;
    gettimeofday(&now, NULL);

    pthread_mutex_lock(&m_mutex);

    struct timespec waitTime;
    waitTime.tv_sec = now.tv_sec + 5;
    waitTime.tv_nsec = now.tv_usec * 1000;

    pthread_cond_timedwait(&m_cond, &m_mutex, &waitTime);

    pthread_mutex_unlock(&m_mutex);

    strncpy(m_path, path, sizeof(m_path));

    int ret = Create(path);
    if (ret != ZOK && ret != ZNODEEXISTS)
    {
        printf("create root path failed, path=%s\n", path);
        return false;
    }

    ServiceWatch(path);

    return true;
}

int ZkCli::Create(const char* path)
{
    char path_buffer[256] = { 0 };
    int ret = zoo_create(m_ZkHandle, path, "", -1, &ZOO_OPEN_ACL_UNSAFE, 0, path_buffer, sizeof(path_buffer)-1);
    if (ret == ZOK)
    {
        printf("create node %s succeed!\n", path);
    }
    else
    {
        printf("create node %s, ret=%d\n", path, ret);
    }

    return ret;
}

int ZkCli::Set(const char* path, const char* data, int size)
{
    char path_buffer[256] = { 0 };
    int ret = zoo_create(m_ZkHandle, path, data, size, &ZOO_OPEN_ACL_UNSAFE, ZOO_EPHEMERAL, path_buffer, sizeof(path_buffer)-1);
    if (ret == ZOK)
    {
        printf("set [%s]=[%s] succeed!\n", path_buffer, data);
    }
    else
    {
        printf("set [%s]=[%s] failed, ret=%d\n", path, data, ret);
    }
    return ret;
}

void ZkCli::ServiceWatch(const char* path)
{
/*ZOOAPI int zoo_wget_children(zhandle_t *zh, const char *path,watcher_fn watcher,void* watcherCtx,struct String_vector *strings);*/
    String_vector strvect;
    int rc = zoo_wget_children(m_ZkHandle, path, require_wachter, this, &strvect);
    if (rc != ZOK)
    {
        printf("zoo_wget_children faield, path:%s, rc=%d\n", path, rc);
        return;
    }
    
    std::string master_server;
    uint64_t min_starttimeus = 0;
    for (int i = 0; i < strvect.count; i++)
    {
        printf("str[%d]:%s\n", i, strvect.data[i]);

        char nodepath[64] = { 0 };
        snprintf(nodepath, sizeof(nodepath)-1, "%s/%s", path, strvect.data[i]);

        char buffer[256] = { 0 };
        int buffer_len = sizeof(buffer);
        
        if (ZOK == zoo_get(m_ZkHandle, nodepath, 0, buffer, &buffer_len, NULL))
        {
            uint64_t startTimeus = atoll(buffer);
            if (min_starttimeus == 0)
            {
                min_starttimeus = startTimeus;
                master_server = strvect.data[i];
            }
            else if (min_starttimeus > startTimeus)
            {
                min_starttimeus = startTimeus;
                master_server = strvect.data[i];
            }

            printf("%s=%ld\n", nodepath, startTimeus);
        }
    }

    printf("master server=%s, timeus=%ld\n", master_server.c_str(), min_starttimeus);
    if (strcmp(m_servAddr, master_server.c_str()) == 0)
    {
        printf("should switch to master!\n");
        if (m_func)
        {
            m_func("","");
        }
    }
    else
    {
        printf("should switch to slave!\n");
    }
}

void ZkCli::Register(const char* listenIp, const unsigned short listenPort, FUN func)
{
    snprintf(m_servAddr, sizeof(m_servAddr)-1, "%s:%d", listenIp, listenPort);
    m_func = func;

    int64_t TimeStampUs = getTimeStampUs();
    char TimeStampStr[32] = { 0 };
    snprintf(TimeStampStr, sizeof(TimeStampStr)-1, "%ld", TimeStampUs);

    char ServicePath[128] = { 0 };
    snprintf(ServicePath, sizeof(ServicePath)-1, "%s/%s", m_path, m_servAddr);

    Set(ServicePath, TimeStampStr, strlen(TimeStampStr));
}

Makefile

CC=g++ -g
SRC=$(wildcard *.cpp)
OBJ=${SRC:%.cpp=%.o}

FLAG=-DTHREADED
LIB=-lpthread -lzookeeper_mt

TARGET=zk_client

all:${TARGET}

${TARGET}:${OBJ}
	${CC} -o ${TARGET} ${OBJ} ${LIB}

%.o:%.cpp
	${CC} ${FLAG} -c $? -o $@

运行结果：
62：

[root@localhost zk_client]# ./zk_client
create node /services, ret=-110
master server=, timeus=0
should switch to slave!
zookeeper connected!
require_wachter() : type=4, stat=3, path=/services
set [/services/192.168.1.62:9044]=[1632473624547276] succeed!
str[0]:192.168.1.62:9044
/services/192.168.1.62:9044=1632473624547276
master server=192.168.1.62:9044, timeus=1632473624547276
should switch to master!
enter switch func
require_wachter() : type=4, stat=3, path=/services
str[0]:192.168.1.86:9044
/services/192.168.1.86:9044=1632473592590648
str[1]:192.168.1.62:9044
/services/192.168.1.62:9044=1632473624547276
master server=192.168.1.86:9044, timeus=1632473592590648
should switch to slave!
require_wachter() : type=4, stat=3, path=/services
str[0]:192.168.1.86:9044
/services/192.168.1.86:9044=1632473592590648
str[1]:192.168.1.85:9044
/services/192.168.1.85:9044=1632473596504658
str[2]:192.168.1.62:9044
/services/192.168.1.62:9044=1632473624547276
master server=192.168.1.86:9044, timeus=1632473592590648
should switch to slave!

86：

[root@localhost zk_client]# ./zk_client
create node /services, ret=-110
str[0]:192.168.1.62:9044
/services/192.168.1.62:9044=1632473624547276
master server=192.168.1.62:9044, timeus=1632473624547276
should switch to slave!
zookeeper connected!
require_wachter() : type=4, stat=3, path=/services
set [/services/192.168.1.86:9044]=[1632473592590648] succeed!
str[0]:192.168.1.86:9044
/services/192.168.1.86:9044=1632473592590648
str[1]:192.168.1.62:9044
/services/192.168.1.62:9044=1632473624547276
master server=192.168.1.86:9044, timeus=1632473592590648
should switch to master!
enter switch func
require_wachter() : type=4, stat=3, path=/services
str[0]:192.168.1.86:9044
/services/192.168.1.86:9044=1632473592590648
str[1]:192.168.1.85:9044
/services/192.168.1.85:9044=1632473596504658
str[2]:192.168.1.62:9044
/services/192.168.1.62:9044=1632473624547276
master server=192.168.1.86:9044, timeus=1632473592590648
should switch to master!
enter switch func

85：

[root@localhost zk_client]# ./zk_client
create node /services, ret=-110
str[0]:192.168.1.86:9044
/services/192.168.1.86:9044=1632473592590648
str[1]:192.168.1.62:9044
/services/192.168.1.62:9044=1632473624547276
master server=192.168.1.86:9044, timeus=1632473592590648
should switch to slave!
zookeeper connected!
require_wachter() : type=4, stat=3, path=/services
set [/services/192.168.1.85:9044]=[1632473596504658] succeed!
str[0]:192.168.1.86:9044
/services/192.168.1.86:9044=1632473592590648
str[1]:192.168.1.85:9044
/services/192.168.1.85:9044=1632473596504658
str[2]:192.168.1.62:9044
/services/192.168.1.62:9044=1632473624547276
master server=192.168.1.86:9044, timeus=1632473592590648
should switch to slave!

86为主机。

关闭62后：

85切换为主机

require_wachter() : type=4, stat=3, path=/services
str[0]:192.168.1.85:9044
/services/192.168.1.85:9044=1632473768385849
str[1]:192.168.1.62:9044
/services/192.168.1.62:9044=1632473810040201
master server=192.168.1.85:9044, timeus=1632473768385849
should switch to master!
enter switch func
fulianzhou
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
zookeeper C API实例
lpshoucsd1的专栏
05-28 1万+
之前一直用zookeeper的java API，最近要用C开发，所以看了C的API及实现 使用zookeeper C API 的步骤： （1）安装zookeeper，直接下载，解压，配置文件即可 （2）安装C API 进入./zookeeper/src/c目录 ./configure make make install （3）编写调用函数，可以参考下面的例子 （4）编译的时候注意
Zookeeper HA集群搭建，主备切换测试验证
weixin_40524659的博客
03-13 814
Zookeeper集群中只要有过半的节点是正常的情况下，那么整个集群对外就是可用的。 正是基于这个特性，要将ZK集群的节点数量要为奇数（2n+1：如3、5、7个节点）较为合适。 zookeeper服务集群工作图： zookeeper HA集群搭建： 设备信息： 设备：192.168.136.136 设备：192.168.136.137 设备：192.168.136.138 1，首先在三台设备上分别安装单机zookeeper，方法已经在上篇blog介绍过， 2, 接下...
基于zookeeper实现服务节点HA主备自动切换
HarryChenj的专栏
01-08 1825
zookeeper实现服务节点HA主备自动切换 1主多从模式 ZooKeeper实现高可用 主备模式自动切换 基于SpringBoot2.5.6、SpringFrameWork5.3.12、JDK8
zookeeper主从服务切换
diaoliwei2的专栏
10-24 2334
 zookeeper使用CuratorFramework实现主从服务切换demo，下面github上的demo可以直接运行。 demo使用springboot、jdk1.8、zookeeper 3.4.12 demo主要实现了，当前服务部署在多台服务器上时，需要其中一台来跑定时任务时，优先抢到leader的那台机器来处理定时任务。 当leader机器故障或运行代码超时时。将另外一台服务器切换...
简单使用 ZooKeeper 实现集群主备切换
【欢迎关注公众号：冬瓜白】
05-05 4561
昨天晚上看了一篇博客，作者实现了一个分布式的调度框架，其中支持两种集群模式，其中一种就是主备模式，是基于 ZooKeeper 实现的，这也是 ZooKeeper 很常见的应用场景，还没来得及看具体细节就去处理了一个线上问题，今天一直找不到那个博客链接。今天就尝试自己实现一下，本文会介绍两种实现方式（总体思想一致，部分细节有所差别）。 这种主备模式首先需要从集群中选出 Master 节点，然后剩余节...
基于zookeeper的主备切换方法
weixin_34082854的博客
03-30 915
继承CZookeeperHelper即可快速实现主备切换：https://github.com/eyjian/mooon/blob/master/mooon/include/mooon/net/zookeeper_helper.h zookeeper的ZOO_EPHEMERAL节点（如果ZOO_EPHEMERAL满足不了需求，可以考虑和ZOO...
zookeeper C API中文文档
12-19
Zookeeper C API 中文文档 Zookeeper C API 是 Zookeeper 的一个 C 语言实现，提供了一个简洁的 API，让开发者可以轻松地使用 Zookeeper 的功能。本文档将详细介绍 Zookeeper C API 的使用方法和相关知识点。 ...
基于zookeeper的多活、主备模式控制
11-15
2. **主备切换**：利用Zookeeper的临时节点和监听机制，可以轻松实现主备切换。当主节点因故障失去连接时，其对应的临时节点会被删除，其他节点通过监听这个事件，发现主节点失效，然后根据顺序节点的顺序选择新的主...
zookeeper实现服务节点HA主备自动切换，1主多从模式、ZooKeeper实现高可用
01-08
《ZooKeeper实现服务节点HA主备自动切换与高可用性》 在分布式系统中，服务的高可用性（High Availability, HA）是至关重要的，它确保即使在单个组件故障的情况下，系统仍能正常运行。ZooKeeper，作为Apache的一个...
ZooKeeper Java API编程实例分析
08-28
ZooKeeper Java API编程实例分析 ZooKeeper Java API编程是 ZooKeeper 的一个重要组件，它提供了 Java 语言的 API 接口，让开发者可以使用 Java 语言编写 ZooKeeper 应用程序。下面我们将详细分析 ZooKeeper Java ...
zookeeper-api基础.docx
最新发布
06-21
以下是对 Zookeeper API 的详细介绍： Zookeeper API 概述 Zookeeper API 提供了一组接口，允许客户端与 Zookeeper 服务进行交互。这些接口包括创建、删除、读取和设置节点数据，以及为节点设置监视器（Watchers）...
基于Zookeeper实现高可用架构
lee_nacl的博客
11-24 1149
基于Zookeeper实现高可用架构
Zookeeper 05 示例代码-主备节点切换
MyDriverC
08-22 398
版权声明：本文为博主原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接和本声明。 本文链接：https://blog.csdn.net/yanliang1/article/details/46548819 收起 主备节点的切换，是分布式应用的基本要求。现在用 Zookeeper 实现主备节点自动切换功能。 基本思路： 1 多个服务启动后，都尝试在 Zookeeper中创建一个EPHEMERAL 类型的节点，Zookeeper本身会保证，只有一个服务会创建成功，其他服...
【大数据Hadoop】HDFS-HA模式下ZKFC(DFSZKFailoverController)高可用主备切换机制
如切如磋，如琢如磨，臻于至善。
03-26 2540
当一个NameNode被成功切换为Active状态时，它会在ZK内部创建一个临时的znode，在znode中将会保留当前Active NameNode的一些信息，比如主机名等等。当Active NameNode出现失败或连接超时的情况下，监控程序会将ZK上对应的临时znode进行删除，znode的删除事件会主动触发到下一次的Active NamNode的选择。根据检测出的不同状态之后，会调用enterState方法，在这个方法内部会触发相应状态的回调事件。这2个方法会在HDFS HA自动切换最后被调用。
getTimeStamp( )
qq_29650553的博客
06-21 4827
#include &lt;windows.h&gt; double getTimeStamp() { LARGE_INTEGER counter = { 0 }; QueryPerformanceCounter(&amp;counter); LARGE_INTEGER freq = { 0 }; QueryPerformanceFrequency(&amp;freq); double...
Zookeeper中主从模式结构场景练习
01-16 5611
下面这个部分，我们将通过zkCli工具来实现简单的主从结构模式，主从模式结构设计到了下面的几个角色。MasterMaster监视着新的worker和tasks，并且分配任务到workers上WorkerWorker注册到系统中，好让master知道他们是可以来执行任务的ClientClient用来创建任务并且等待系统的响应， TheMaster Role由于只能有一个master，所以只能有一个进
zookeeper实现分布式协调服务--主备切换的核心原理
znHD的博客
10-21 952
zookeeper可以用于解决hdfs中NamNode、Yarn中ResourceManager中的单点问题。 以ResourceManager为例，集群中可以存在多个ResourceManager，只有一个处于active状态，其余都是standby状态。 1.刚启动时，所有ResourceManager节点都会去写一个lock临时节点，但是只有一个能写成功。成功写入的节点进入active状...
ZooKeeper在大型分布式系统中的应用
07-14 494
1.Hadoop ZooKeeper在Hadoop中的作用：Yarn中的ZooKeeper 1.1 ResourceManager HA Yarn的HA架构：Active/Standby模式 1.1.1 主备切换 实现原理：使用基于ZooKeeper实现的ActiveStandbyElector组件来确定ResourceManager为active还是standby 1.1.2 Fencin...
zookeeper的主备切换
10-10
在 ZooKeeper 中，主备切换是指当主节点出现故障或不可用时，备节点会自动切换为主节点，以保证服务的可用性。ZooKeeper 使用了一种叫做 ZAB（ZooKeeper Atomic Broadcast）的协议来确保主备切换的可靠性。 当主...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值