1004-05，使用workflow对象创建http任务，redis任务

于 2024-10-06 20:27:01 发布
阅读量242 收藏 4
点赞数 7
分类专栏： 我爱学习 文章标签： http redis 网络协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51583806/article/details/142718255
版权

目录

01_wait_group.cc

02_http_wait.cc

03_httptask_callback.cc

04_http_task_request.cc

05_redis_task_callback.cc

06_redistask_read.cc

07_series.cc

08_series_dynamic.cc

09_context.cc

10_parallel_work.cc

作业：

01 存在下列的redis键值映射关系，使用workflow的redis任务和序列，假如只知道"x1"，如何找到最终的"100"？"x1" --> "x2""x2" --> "x3""x3" --> "x4""x4" --> "100"

02 读取某个网站的内容，并且存入redis服务端当中（比如先访问淘宝，再set www.taobao.com 淘宝的html内容）

03 阅读下面的代码并尝试添加注释

01_wait_group.cc

#include <workflow/WFFacilities.h>
#include <workflow/WFTaskFactory.h>

#include <signal.h>
#include <iostream>

using std::cout;
using std::cerr;

static WFFacilities::WaitGroup WaitGroup(1);

void handler(int signum){
    cout<<"done\n";
    WaitGroup.done();
}

int main(void)
{
    signal(SIGINT,handler);

    //创建任务
    WFHttpTask * httpTask=WFTaskFactory::create_http_task(
            /* "http://www.baidu.com", */
"http://localhost/en/index.html",
            10,
            10,
            nullptr
    );
    //交给框架执行
    httpTask->start();

    WaitGroup.wait();
    cout<<"finish\n";

    return 0;
}


	/* static WFHttpTask *create_http_task(const std::string& url, */
	/* 									int redirect_max,//最大重定向次数 */
	/* 									int retry_max, //最大重试次数*/
	/* 									http_callback_t callback//回调函数); */

02_http_wait.cc

// wait_group 实现有条件的等待
#include <workflow/WFFacilities.h>
#include <workflow/WFTaskFactory.h>
#include <iostream>
#include <signal.h>
using std::cout;
using std::cerr;
static WFFacilities::WaitGroup waitGroup(1);
void handler(int signum){
    cout << "done\n";
    waitGroup.done();
}
int main(){
    signal(SIGINT,handler);
    // 用户代码 1 创建任务
    WFHttpTask * httpTask =  WFTaskFactory::create_http_task(
        //"http://www.baidu.com",
        "http://localhost/en/index.html",
        10,
        10,
        nullptr
    );
    // 用户代码 2 把任务交给框架
    httpTask->start();

    waitGroup.wait();
    cout << "finish!\n";
}

03_httptask_callback.cc

#include <workflow/WFFacilities.h>
#include <workflow/WFTaskFactory.h>
#include <workflow/HttpUtil.h>

#include <signal.h>
#include <iostream>

using std::cout;
using std::cerr;

//------------------------------------//
static WFFacilities::WaitGroup waitGroup(1);

void sighandler(int signum){
    waitGroup.done();//waitGroup(--num);
    cout<<"done\n";
}

//------------------------------------//
//  httpCallback()
//------------------------------------//
void httpCallback(WFHttpTask* httpTask){
    cout<<"callback is called\n";

    protocol::HttpRequest* req=httpTask->get_req();
    protocol::HttpResponse* resq=httpTask->get_resp();
    int state=httpTask->get_state();
    int error=httpTask->get_error();//错误原因

    //状态处理
    switch(state) {
        case WFT_STATE_SYS_ERROR: // 系统错误
            cerr <<"system error: " << strerror(error) << "\n"; 
            break;
        case WFT_STATE_DNS_ERROR: // DNS错误
            cerr <<"DNS error: " << gai_strerror(error) << "\n"; 
            break;
        case WFT_STATE_SSL_ERROR: // SSL错误
            cerr <<"SSL error: " << error << "\n"; 
            break;
        case WFT_STATE_TASK_ERROR: // 任务错误
            cerr <<"Task error: "<< error << "\n"; 
            break;
        case WFT_STATE_SUCCESS: // 请求成功
            break; 
    }

    //错误处理
    if (state != WFT_STATE_SUCCESS) {
        cerr <<"Failed. Press Ctrl-C to exit.\n";
        return;
    }


    //------------------------------------//
    //请求报文-起始行-首部字段
    cerr<<"method="<<req->get_method()<<"\n";
    cerr<<"version="<<req->get_http_version()<<"\n";
    cerr<<"path& query="<<req->get_request_uri()<<"\n";

    std::string name;
    std::string value;
    protocol::HttpHeaderCursor req_cursor(req);//类似迭代器，初始化
    while(req_cursor.next(name,value)){
        cerr<<"name ="<<name<<"  value ="<<value<<"\n";
    }
    cerr<<"\n";

    //------------------------------------//
    //响应报文-起始行-首部字段-报文体
    cerr<<"version="<<resq->get_http_version()<<"\n";
    cerr<<"state code="<<resq->get_status_code()<<"\n";
    cerr<<"reason phrea="<<resq->get_reason_phrase()<<"\n";

    protocol::HttpHeaderCursor resp_cursor(resq);//类似迭代器，初始化
    while(resp_cursor.next(name,value)){
        cerr<<"name ="<<name<<"  value ="<<value<<"\n";
    }

    const void * body;
    size_t body_len;
    resq->get_parsed_body(&body,&body_len);
    cerr<<static_cast<const char*>(body)<<"\n";
    

}



//------------------------------------//
//  main()
//------------------------------------//
int main(void)
{
    signal(SIGINT,sighandler);

    WFHttpTask* httpTask=WFTaskFactory::create_http_task(
        "http://www.taobao.com",10,10,httpCallback);

    httpTask->start();
    waitGroup.wait();

    cerr<<"\nfinish\n";
    return 0;
}

04_http_task_request.cc

#include <workflow/WFFacilities.h>
#include <workflow/WFTaskFactory.h>
#include <workflow/HttpMessage.h>
#include <workflow/HttpUtil.h>

#include <signal.h>
#include <iostream>

using std::cout;
using std::cerr;

//------------------------------------//
static WFFacilities::WaitGroup waitGroup(1);

void sighandler(int signum){
    waitGroup.done();//waitGroup(--num);
    cout<<"done\n";
}

//------------------------------------//
//  httpCallback()
//------------------------------------//
void httpCallback(WFHttpTask* httpTask){
    cout<<"callback is called\n";

    protocol::HttpRequest* req=httpTask->get_req();
    protocol::HttpResponse* resq=httpTask->get_resp();
    int state=httpTask->get_state();
    int error=httpTask->get_error();//错误原因

    //状态处理
    switch(state) {
        case WFT_STATE_SYS_ERROR: // 系统错误
            cerr <<"system error: " << strerror(error) << "\n"; 
            break;
        case WFT_STATE_DNS_ERROR: // DNS错误
            cerr <<"DNS error: " << gai_strerror(error) << "\n"; 
            break;
        case WFT_STATE_SSL_ERROR: // SSL错误
            cerr <<"SSL error: " << error << "\n"; 
            break;
        case WFT_STATE_TASK_ERROR: // 任务错误
            cerr <<"Task error: "<< error << "\n"; 
            break;
        case WFT_STATE_SUCCESS: // 请求成功
            break; 
    }

    //错误处理
    if (state != WFT_STATE_SUCCESS) {
        cerr <<"Failed. Press Ctrl-C to exit.\n";
        return;
    }


    //------------------------------------//
    //请求报文-起始行-首部字段
    cerr<<"method="<<req->get_method()<<"\n";
    cerr<<"version="<<req->get_http_version()<<"\n";
    cerr<<"path& query="<<req->get_request_uri()<<"\n";

    std::string name;
    std::string value;
    protocol::HttpHeaderCursor req_cursor(req);//类似迭代器，初始化
    while(req_cursor.next(name,value)){
        cerr<<"name ="<<name<<"  value ="<<value<<"\n";
    }
    cerr<<"\n";

    //------------------------------------//
    //响应报文-起始行-首部字段-报文体
    cerr<<"version="<<resq->get_http_version()<<"\n";
    cerr<<"state code="<<resq->get_status_code()<<"\n";
    cerr<<"reason phrea="<<resq->get_reason_phrase()<<"\n";

    protocol::HttpHeaderCursor resp_cursor(resq);//类似迭代器，初始化
    while(resp_cursor.next(name,value)){
        cerr<<"name ="<<name<<"  value ="<<value<<"\n";
    }

    /* const void * body; */
    /* size_t body_len; */
    /* resq->get_parsed_body(&body,&body_len); */
    /* cerr<<static_cast<const char*>(body)<<"\n"; */

/* GET: 通常用于请求数据，不会对服务器的状态产生副作用。 */
/* POST: 用于提交数据，通常会导致服务器状态改变或者创建新的资源。 */
/* 百度的接口: */

/* 百度的搜索接口一般是通过 GET 请求来获取搜索结果。因此，即使您将方法设置为 POST，如果服务器只支持 GET，请求仍然会被处理为 GET。 */

}



//------------------------------------//
//  main()
//------------------------------------//
int main(void)
{
    signal(SIGINT,sighandler);

    WFHttpTask* httpTask=WFTaskFactory::create_http_task(
        "http://www.taobao.com",10,10,httpCallback);

    
    //找到请求并设置残数
    protocol::HttpRequest* req=httpTask->get_req();
    req->set_method("POST");
    req->set_request_uri("/s?wd=123");//百度查询接口
    req->add_header_pair("myname","workflow");
    cerr<<"method="<<req->get_method()<<"\n";
    cerr<<"version="<<req->get_http_version()<<"\n";
    cerr<<"path& query="<<req->get_request_uri()<<"\n";
    cerr<<"\n";
    cerr<<"\n";

    httpTask->start();
    waitGroup.wait();

    cerr<<"\nfinish\n";
    return 0;
}

05_redis_task_callback.cc

#include <workflow/WFFacilities.h>
#include <workflow/WFTaskFactory.h>

#include <signal.h>
#include <iostream>

using std::cout;
using std::cerr;

//------------------------------------//
static WFFacilities::WaitGroup waitGroup(1);

void sighandler(int signum){
    waitGroup.done();//waitGroup(--num);
    cout<<"done\n";
}

//------------------------------------//
//  redisCallback()
//------------------------------------//
void redisCallback(WFRedisTask* redistask){
    cout<<"callback is called\n";


    protocol::RedisRequest *req=redistask->get_req();
    protocol::RedisResponse* resp=redistask->get_resp();
    int state=redistask->get_state();
    int error=redistask->get_error();

    //状态处理
    switch(state) {
        case WFT_STATE_SYS_ERROR: // 系统错误
            cerr <<"system error: " << strerror(error) << "\n"; 
            break;
        case WFT_STATE_DNS_ERROR: // DNS错误
            cerr <<"DNS error: " << gai_strerror(error) << "\n"; 
            break;
        case WFT_STATE_SSL_ERROR: // SSL错误
            cerr <<"SSL error: " << error << "\n"; 
            break;
        case WFT_STATE_TASK_ERROR: // 任务错误
            cerr <<"Task error: "<< error << "\n"; 
            break;
        case WFT_STATE_SUCCESS: // 请求成功
            break; 
    }

    //错误处理
    if (state != WFT_STATE_SUCCESS) {
        cerr <<"Failed. Press Ctrl-C to exit.\n";
        return;
    }


    cout<<"callback is end\n";
}



//------------------------------------//
//  main()
//------------------------------------//
int main(void)
{
    signal(SIGINT,sighandler);

    WFRedisTask* redistask=WFTaskFactory::create_redis_task(
        "redis://127.0.0.1:6379",10,redisCallback);
    cerr<<"\n";

    //找到修改请求
    protocol::RedisRequest *req=redistask->get_req();
    req->set_request("SET",{"huasheng","lovexixi"});

    redistask->start();
    waitGroup.wait();

    cerr<<"\nfinish\n";
    return 0;
}

06_redistask_read.cc

#include <workflow/WFFacilities.h>
#include <workflow/WFTaskFactory.h>

#include <signal.h>
#include <iostream>

using std::cout;
using std::cerr;

//------------------------------------//
static WFFacilities::WaitGroup waitGroup(1);

void sighandler(int signum){
    waitGroup.done();//waitGroup(--num);
    cout<<"done\n";
}

//------------------------------------//
//  redisCallback()
//------------------------------------//
void redisCallback(WFRedisTask* redistask){
    cout<<"callback is called\n";


    protocol::RedisRequest *req=redistask->get_req();
    protocol::RedisResponse* resp=redistask->get_resp();
    int state=redistask->get_state();
    int error=redistask->get_error();
    protocol::RedisValue val;

    //状态处理
    switch(state) {
        case WFT_STATE_SYS_ERROR: // 系统错误
            cerr <<"system error: " << strerror(error) << "\n"; 
            break;
        case WFT_STATE_DNS_ERROR: // DNS错误
            cerr <<"DNS error: " << gai_strerror(error) << "\n"; 
            break;
        case WFT_STATE_SSL_ERROR: // SSL错误
            cerr <<"SSL error: " << error << "\n"; 
            break;
        case WFT_STATE_TASK_ERROR: // 任务错误
            cerr <<"Task error: "<< error << "\n"; 
            break;
        case WFT_STATE_SUCCESS: // 请求成功
            resp->get_result(val);
            if(val.is_error()){
                cerr<<"error reply,need a password? \n";
                state=WFT_STATE_TASK_ERROR;
            }
            break; 
    }

    //错误处理
    if (state != WFT_STATE_SUCCESS) {
        cerr <<"Failed. Press Ctrl-C to exit.\n";
        return;
    }

    //------------------------------------//
    //查看redis执行的结果
    /* protocol::RedisValue val; */
    /* resp->get_result(val); */
    if(val.is_string()){
        cerr<<"value is string:  "<<val.string_value()<<"\n";
    }
    if(val.is_array()){
        cerr<<"value is array: \n ";
        for(size_t i=0;i<val.arr_size();++i){
            cerr<<i<<"  value:"<<val.arr_at(i).string_value()<<"\n";
        }
    }



    cout<<"callback is end\n";
}



//------------------------------------//
//  main()
//------------------------------------//
int main(void)
{
    signal(SIGINT,sighandler);

    WFRedisTask* redistask=WFTaskFactory::create_redis_task(
        "redis://127.0.0.1:6379",10,redisCallback);
    cerr<<"\n";

    //找到修改请求
    protocol::RedisRequest *req=redistask->get_req();
    /* req->set_request("SET",{"huasheng","lovexixi"}); */
    req->set_request("HGETALL",{"aa"});

    redistask->start();
    waitGroup.wait();

    cerr<<"\nfinish\n";
    return 0;
}

07_series.cc

#include <workflow/WFFacilities.h>
#include <workflow/WFTaskFactory.h>
#include <workflow/Workflow.h>

#include <signal.h>
#include <unistd.h>
#include <iostream>

using std::cout;
using std::cerr;

//------------------------------------//
static WFFacilities::WaitGroup waitGroup(1);

void sighandler(int signum){
    waitGroup.done();//waitGroup(--num);
    cout<<"done\n";
}

//------------------------------------//
//  redisCallback()
//------------------------------------//
void redisCallback(WFRedisTask* redistask){
    cout<<"callback is called\n";


    protocol::RedisRequest *req=redistask->get_req();
    protocol::RedisResponse* resp=redistask->get_resp();
    int state=redistask->get_state();
    int error=redistask->get_error();
    protocol::RedisValue val;

    //状态处理
    switch(state) {
        case WFT_STATE_SYS_ERROR: // 系统错误
            cerr <<"system error: " << strerror(error) << "\n"; 
            break;
        case WFT_STATE_DNS_ERROR: // DNS错误
            cerr <<"DNS error: " << gai_strerror(error) << "\n"; 
            break;
        case WFT_STATE_SSL_ERROR: // SSL错误
            cerr <<"SSL error: " << error << "\n"; 
            break;
        case WFT_STATE_TASK_ERROR: // 任务错误
            cerr <<"Task error: "<< error << "\n"; 
            break;
        case WFT_STATE_SUCCESS: // 请求成功
            resp->get_result(val);
            if(val.is_error()){
                cerr<<"error reply,need a password? \n";
                state=WFT_STATE_TASK_ERROR;
            }
            break; 
    }

    //错误处理
    if (state != WFT_STATE_SUCCESS) {
        cerr <<"Failed. Press Ctrl-C to exit.\n";
        return;
    }

    //------------------------------------//
    //查看redis执行的结果
    /* protocol::RedisValue val; */
    /* resp->get_result(val); */
    if(val.is_string()){
        cerr<<"value is string:  "<<val.string_value()<<"\n";
    }
    if(val.is_array()){
        cerr<<"value is array: \n ";
        for(size_t i=0;i<val.arr_size();++i){
            cerr<<i<<"  value:"<<val.arr_at(i).string_value()<<"\n";
        }
    }


    /* sleep(2); */
    cout<<"callback is end\n";
}



//------------------------------------//
//  main()
//------------------------------------//
int main(void)
{
    signal(SIGINT,sighandler);

    WFRedisTask* redistask=WFTaskFactory::create_redis_task(
        "redis://127.0.0.1:6379",10,redisCallback);
    protocol::RedisRequest *req=redistask->get_req();
    req->set_request("SET",{"07dada","07lovexixi"});


    WFRedisTask* redistask1=WFTaskFactory::create_redis_task(
        "redis://127.0.0.1:6379",10,redisCallback);
    protocol::RedisRequest *req1=redistask1->get_req();
    req1->set_request("GET",{"07dada"});

    /* redistask->start(); */
    /* redistask1->start(); */
    //没有固定先后顺序

    SeriesWork* series=Workflow::create_series_work(redistask,nullptr);
    series->push_back(redistask1);
    series->start();

    waitGroup.wait();

    cerr<<"\nfinish\n";
    return 0;
}

08_series_dynamic.cc

#include <workflow/WFFacilities.h>
#include <workflow/WFTaskFactory.h>
#include <workflow/Workflow.h>

#include <signal.h>
#include <unistd.h>
#include <iostream>

using std::cout;
using std::cerr;

//------------------------------------//
static WFFacilities::WaitGroup waitGroup(1);

void sighandler(int signum){
    waitGroup.done();//waitGroup(--num);
    cout<<"done\n";
}

//------------------------------------//
//  redisCallback()
//------------------------------------//
void redisCallback1(WFRedisTask* redistask){
    cout<<"callback111\n";
}

void redisCallback(WFRedisTask* redistask){
    cout<<"callback is called\n";


    protocol::RedisRequest *req=redistask->get_req();
    protocol::RedisResponse* resp=redistask->get_resp();
    int state=redistask->get_state();
    int error=redistask->get_error();
    protocol::RedisValue val;

    //状态处理
    switch(state) {
    case WFT_STATE_SYS_ERROR: // 系统错误
        cerr <<"system error: " << strerror(error) << "\n"; 
        break;
    case WFT_STATE_DNS_ERROR: // DNS错误
        cerr <<"DNS error: " << gai_strerror(error) << "\n"; 
        break;
    case WFT_STATE_SSL_ERROR: // SSL错误
        cerr <<"SSL error: " << error << "\n"; 
        break;
    case WFT_STATE_TASK_ERROR: // 任务错误
        cerr <<"Task error: "<< error << "\n"; 
        break;
    case WFT_STATE_SUCCESS: // 请求成功
        resp->get_result(val);
        if(val.is_error()){
            cerr<<"error reply,need a password? \n";
            state=WFT_STATE_TASK_ERROR;
        }
        break; 
    }

    //错误处理
    if (state != WFT_STATE_SUCCESS) {
        cerr <<"Failed. Press Ctrl-C to exit.\n";
        return;
    }

    //------------------------------------//
    if(val.is_string()){
        cerr<<"value is string:  "<<val.string_value()<<"\n";
        //在正在执行的任务队列中添加任务
        WFRedisTask* redistask1=WFTaskFactory::create_redis_task(
              /* "redis://127.0.0.1:6379",10,redisCallback); */
              "redis://127.0.0.1:6379",10,redisCallback1);
        //递归调用
        redistask1->get_req()->set_request("SET",{"07dada","07lovexixi"});
        series_of(redistask)->push_back(redistask1);
    }
    if(val.is_array()){
        cerr<<"value is array: \n ";
        for(size_t i=0;i<val.arr_size();++i){
            cerr<<i<<"  value:"<<val.arr_at(i).string_value()<<"\n";
        }
    }


    /* sleep(2); */
    cout<<"callback is end\n";
}



//------------------------------------//
//  main()
//------------------------------------//
int main(void)
{
    signal(SIGINT,sighandler);



    WFRedisTask* redistask1=WFTaskFactory::create_redis_task(
                                                             "redis://127.0.0.1:6379",10,redisCallback);
    protocol::RedisRequest *req1=redistask1->get_req();
    req1->set_request("GET",{"07dada"});

    /* redistask->start(); */
    redistask1->start();
    //没有固定先后顺序

    /* SeriesWork* series=Workflow::create_series_work(redistask,nullptr); */
    /* series->push_back(redistask1); */
    /* series->start(); */

    waitGroup.wait();

    cerr<<"\nfinish\n";
    return 0;
}

09_context.cc

#include <workflow/WFFacilities.h>
#include <workflow/WFTaskFactory.h>
#include <workflow/Workflow.h>

#include <signal.h>
#include <unistd.h>
#include <iostream>

using std::cout;
using std::cerr;
using std::string;
using std::vector;

//------------------------------------//
struct SeriesContext{
    int id;
    std::string name;
};
static WFFacilities::WaitGroup waitGroup(1);

void sighandler(int signum){
    waitGroup.done();//waitGroup(--num);
    cout<<"done\n";
}

//------------------------------------//
//  redisCallback()
//------------------------------------//
void redisCallback1(WFRedisTask *redisTask){
	cerr << "xixi 1 begin\n";
	SeriesContext * context = static_cast<SeriesContext *>(series_of(redisTask)->get_context());
	cerr << "before id = " << context->id << " name = " << context->name << "\n";
	context->id = 1001;
	context->name = "task1";
	cerr << "after id = " << context->id << " name = " << context->name << "\n";
	cerr << "xixi 1 end!\n";
}
void redisCallback2(WFRedisTask *redisTask){
	cerr << "xixi 2 begin\n";
	SeriesContext * context = static_cast<SeriesContext *>(series_of(redisTask)->get_context());
	cerr << "before id = " << context->id << " name = " << context->name << "\n";
	context->id = 1002;
	context->name = "task2";
	cerr << "after id = " << context->id << " name = " << context->name << "\n";
	cerr << "xixi 2 end!\n";
}
void redisCallback3(WFRedisTask *redisTask){
	cerr << "xixi 3 begin\n";
	SeriesContext * context = static_cast<SeriesContext *>(series_of(redisTask)->get_context());
	cerr << "before id = " << context->id << " name = " << context->name << "\n";
	cerr << "xixi 3 end!\n";
}


void Callback(const SeriesWork* series){
    SeriesContext* context=static_cast<SeriesContext*>(series->get_context());
    cerr<<"callback id ="<<context->id<<"  name="<<context->name<<"\n";
    delete context;
}



//------------------------------------//
//  main()
//------------------------------------//
int main(void)
{
    signal(SIGINT,sighandler);


    WFRedisTask * redisTask1 =  WFTaskFactory::create_redis_task("redis://127.0.0.1:6379",10,redisCallback1);
    redisTask1->get_req()->set_request("SET",{"key","123"});

    WFRedisTask * redisTask2 =  WFTaskFactory::create_redis_task("redis://127.0.0.1:6379",10,redisCallback2);
    redisTask2->get_req()->set_request("SET",{"key","123"});

    WFRedisTask * redisTask3 =  WFTaskFactory::create_redis_task("redis://127.0.0.1:6379",10,redisCallback3);
    redisTask3->get_req()->set_request("SET",{"key","123"});


    SeriesWork* series=Workflow::create_series_work(redisTask1,nullptr);
    series->push_back(redisTask2);
    /* series->push_back(redisTask3); */

    SeriesContext* context=new SeriesContext({1000,"mian"});
    series->set_context(context);
    
    series->set_callback([context](const SeriesWork*series){
        cerr<<"callback id ="<<context->id<<"  name="<<context->name<<"\n";
        delete context;
                         });

    series->start();

    waitGroup.wait();

    cerr<<"\nfinish\n";
    return 0;
}

10_parallel_work.cc

// wait_group 实现有条件的等待
#include <workflow/WFFacilities.h>
#include <workflow/WFTaskFactory.h>
#include <workflow/Workflow.h>
#include <iostream>
#include <signal.h>
using std::cout;
using std::cerr;
using std::vector;
using std::string;
struct SeriesContext{
    string url;
    size_t body_len;
};
static WFFacilities::WaitGroup waitGroup(1);
void handler(int signum){
    cout << "done\n";
    waitGroup.done();
}

void httpCallback(WFHttpTask *httpTask){
	protocol::HttpResponse *resp = httpTask->get_resp(); // 获取响应
	int state = httpTask->get_state(); // 获取状态
	int error = httpTask->get_error(); // 获取错误原因
	switch (state){
	case WFT_STATE_SYS_ERROR:
		cerr <<"system error: " << strerror(error) << "\n";
		break;
	case WFT_STATE_DNS_ERROR:
		cerr <<"DNS error: "  << gai_strerror(error) << "\n";
		break;
	case WFT_STATE_SSL_ERROR:
		cerr <<"SSL error\n";
		break;
	case WFT_STATE_TASK_ERROR:
		cerr <<"Task error\n";
		break;
	case WFT_STATE_SUCCESS:
		break;
	}
	if (state != WFT_STATE_SUCCESS){
		cerr <<"Failed. Press Ctrl-C to exit.\n";
		return;
	}

	const void *body;
	size_t body_len;
	resp->get_parsed_body(&body, &body_len); // get_parsed_body找到响应报文的报文体
    SeriesContext * context = static_cast<SeriesContext *>(series_of(httpTask)->get_context());
    context->body_len = body_len;
    cerr << "url = " << context->url << ", len = " << context->body_len << "\n";
}
void parallelCallback(const ParallelWork * parallelWork){
    cerr << "parallel callback\n";
    string name;
    size_t body_len = 0;
    for(int i = 0; i < 3; ++i){
        // 找到内部的（已经执行完成不可修改的）序列
        const SeriesWork * series = parallelWork->series_at(i);
        SeriesContext * context = static_cast<SeriesContext *>(series->get_context());
        cerr << "i = " << i << "url = " << context->url << ", len = " << context->body_len << "\n";
        if(body_len < context->body_len){
            body_len = context->body_len;
            name = context->url;
        }
        delete context;
    }
    cerr << "longest body_len  url = " << name << " body_len = " << body_len <<"\n";

    WFRedisTask * redisTask = WFTaskFactory::create_redis_task(
        "redis://127.0.0.1:6379",10,nullptr
    );
    redisTask->get_req()->set_request("SET",{name,std::to_string(body_len)});
    series_of(parallelWork)->push_back(redisTask);
}
int main(){
    signal(SIGINT,handler);
    // 创建一个空的并行任务
    ParallelWork * parallelWork = Workflow::create_parallel_work(parallelCallback);
    // 创建多个小序列
    vector<string> urls = {
        "http://www.taobao.com",
        "http://www.jd.com",
        "http://www.baidu.com"
    };
    for(int i = 0; i < 3; ++i){
        // 创建一个http任务
        WFHttpTask * httpTask = WFTaskFactory::create_http_task(urls[i],10,10,httpCallback);
        // 根据http任务创建小序列
        SeriesWork * series =  Workflow::create_series_work(httpTask,nullptr);
        // 往序列中加一个context
        SeriesContext *context = new SeriesContext;
        context->url = urls[i];
        series->set_context(context);
        // 把小序列加入并行任务
        parallelWork->add_series(series);
    }

    parallelWork->start();
    waitGroup.wait();
    cout << "finish!\n";
}

作业：

01 存在下列的redis键值映射关系，使用workflow的redis任务和序列，假如只知道"x1"，如何找到最终的"100"？"x1" --> "x2""x2" --> "x3""x3" --> "x4""x4" --> "100"

// wait_group 实现有条件的等待
#include <workflow/WFFacilities.h>
#include <workflow/WFTaskFactory.h>

#include <iostream>
#include <signal.h>
using std::cout;
using std::cerr;
static WFFacilities::WaitGroup waitGroup(1);
void handler(int signum){
    cout << "done\n";
    waitGroup.done();
}
void redisCallback(WFRedisTask *redisTask)
{
	protocol::RedisRequest *req = redisTask->get_req();
	protocol::RedisResponse *resp = redisTask->get_resp();

	int state = redisTask->get_state();
	int error = redisTask->get_error();
    // val用来保存redis执行的结果
	protocol::RedisValue val;
    switch (state){
	case WFT_STATE_SYS_ERROR:
		cerr <<"system error: " << strerror(error) << "\n";
		break;
	case WFT_STATE_DNS_ERROR:
		cerr <<"DNS error: "  << gai_strerror(error) << "\n";
		break;
	case WFT_STATE_SSL_ERROR:
		cerr <<"SSL error\n";
		break;
	case WFT_STATE_TASK_ERROR:
		cerr <<"Task error\n";
		break;
	case WFT_STATE_SUCCESS:
    	resp->get_result(val);// 将redis的执行结果保存起来
		if (val.is_error()){
		   cerr <<  "Error reply. Need a password?\n";
		   state = WFT_STATE_TASK_ERROR;
		}
		break;
	}
	if (state != WFT_STATE_SUCCESS){
		cerr <<  "Failed. Press Ctrl-C to exit.\n";
		return;
	}

    if(val.is_string()&& val.string_value()!="100"){
        cerr<<"100 is not found"<<val.string_value()<<"\n";
        WFRedisTask* newtask=WFTaskFactory::create_redis_task("redis://127.0.0.1:6379",10,redisCallback);
        newtask->get_req()->set_request("GET",{val.string_value()});
        series_of(redisTask)->push_back(newtask);
    }else{
        cerr<<"100 is found\n";
    }

}

int main(){
    signal(SIGINT,handler);
    // 创建任务
    WFRedisTask * redisTask =  WFTaskFactory::create_redis_task(
        "redis://127.0.0.1:6379",
        10,
        redisCallback
    );
    // 找到请求
    protocol::RedisRequest * req =  redisTask->get_req();
    req->set_request("GET", {"x1"});
    // 将任务交给框架
    redisTask->start();
    waitGroup.wait();
    cout << "finish!\n";
}

02 读取某个网站的内容，并且存入redis服务端当中（比如先访问淘宝，再set www.taobao.com 淘宝的html内容）

// wait_group 实现有条件的等待
#include <workflow/WFFacilities.h>
#include <workflow/WFTaskFactory.h>
#include <workflow/Workflow.h>
#include <iostream>
#include <signal.h>
using std::cout;
using std::cerr;
using std::vector;
using std::string;
struct SeriesContext{
    string url;
    size_t body_len;
};
static WFFacilities::WaitGroup waitGroup(1);
void handler(int signum){
    cout << "done\n";
    waitGroup.done();
}

void httpCallback(WFHttpTask *httpTask){
    protocol::HttpResponse *resp = httpTask->get_resp(); // 获取响应
    int state = httpTask->get_state(); // 获取状态
    int error = httpTask->get_error(); // 获取错误原因
    switch (state){
    case WFT_STATE_SYS_ERROR:
        cerr <<"system error: " << strerror(error) << "\n";
        break;
    case WFT_STATE_DNS_ERROR:
        cerr <<"DNS error: "  << gai_strerror(error) << "\n";
        break;
    case WFT_STATE_SSL_ERROR:
        cerr <<"SSL error\n";
        break;
    case WFT_STATE_TASK_ERROR:
        cerr <<"Task error\n";
        break;
    case WFT_STATE_SUCCESS:
        break;
    }
    if (state != WFT_STATE_SUCCESS){
        cerr <<"Failed. Press Ctrl-C to exit.\n";
        return;
    }

    const void *body;
    size_t body_len;
    resp->get_parsed_body(&body, &body_len); // get_parsed_body找到响应报文的报文体
    
    //创建一个redis任务
    WFRedisTask* redistask=WFTaskFactory::create_redis_task("redis://127.0.0.1:6379",10,nullptr);
    redistask->get_req()->set_request("SET",{"http://www.baidu.com",static_cast<const char*>(body)});
    series_of(httpTask)->push_back(redistask);
}

int main(){
    signal(SIGINT,handler);
    WFHttpTask * httpTask = WFTaskFactory::create_http_task("http://www.baidu.com",10,10,httpCallback);
    /* SeriesWork * series =  Workflow::create_series_work(httpTask,nullptr); */


    httpTask->start();
    waitGroup.wait();
    cout << "finish!\n";
}

03 阅读下面的代码并尝试添加注释

#include <workflow/WFFacilities.h>
#include <workflow/MySQLUtil.h>
#include <workflow/MySQLResult.h>
#include <iostream>
#include <signal.h>
using std::string;
using std::cerr;
static WFFacilities::WaitGroup waitGroup(1);
void sighandler(int signum){
    std::cout << "signum = " << signum << "\n";
    waitGroup.done();
}
void mysqlCallback(WFMySQLTask * mysqlTask){
    if(mysqlTask->get_state() != WFT_STATE_SUCCESS){
        // 在系统层面报错，权限or密码
        cerr << "error_msg =  " << WFGlobal::get_error_string(mysqlTask->get_state(), mysqlTask->get_error()) << "\n";
        return;
    }
    protocol::MySQLResponse * resp = mysqlTask->get_resp();
    if(resp->get_packet_type() == MYSQL_PACKET_ERROR){
        // 在SQL语句报错
        cerr << "error_code = " << resp->get_error_code() << " error_msg = " << resp->get_error_msg() << "\n";
        return;
    }
    protocol::MySQLResultCursor cursor(resp);
    do{
        if(cursor.get_cursor_status() == MYSQL_STATUS_OK){
            // 写类型的SQL语句
            cerr << "write \n";
            cerr << cursor.get_affected_rows() << " rows affected\n";
        }
        else if(cursor.get_cursor_status() == MYSQL_STATUS_GET_RESULT){
            // 读类型的SQL语句
            cerr << "read \n";
            // 读表头 列的信息 field
            const protocol::MySQLField * const * fieldArr;
            fieldArr = cursor.fetch_fields();
            for(int i = 0; i < cursor.get_field_count(); ++i){
                cerr << "db = " << fieldArr[i]->get_db()
                     << " table = " << fieldArr[i]->get_table()
                     << " name = " << fieldArr[i]->get_name()
                     << " type = " << datatype2str(fieldArr[i]->get_data_type()) << "\n";
            }
            // 读表的内容 每一行每一列
            // bool fetch_all(std::vector<std::vector<MySQLCell>>& rows);
            std::vector<std::vector<protocol::MySQLCell>> rows;
            cursor.fetch_all(rows);
            for(auto &row:rows){
                for(auto &cell:row){
                    if(cell.is_int()){
                        cerr << cell.as_int();
                    }
                    else if(cell.is_string()){
                        cerr << cell.as_string();
                    }
                    else if(cell.is_datetime()){
                        cerr << cell.as_datetime();
                    }
                    cerr << "\t";
                }
                cerr << "\n";
            } 
        }
    }while(cursor.next_result_set()); //mysql 任务支持一个任务处理多个SQL语句
}
int main(){
    signal(SIGINT,sighandler);
    WFMySQLTask * mysqlTask =  WFTaskFactory::create_mysql_task("mysql://root:123@localhost",1,mysqlCallback);
    string sql = "insert into mycloud.tbl_user_token (user_name,user_token) values ('Caixukun','singdancerap');";
    //string sql;
    sql += "select * from mycloud.tbl_user_token;";
    mysqlTask->get_req()->set_query(sql);
    mysqlTask->start();
    waitGroup.wait();
    return 0;
}
#include <workflow/WFFacilities.h> // 包含 WFFacilities 库
#include <workflow/MySQLUtil.h>    // 包含 MySQL 相关工具库
#include <workflow/MySQLResult.h>  // 包含 MySQL 结果处理库
#include <iostream>                // 包含输入输出流库
#include <signal.h>                // 包含信号处理库

using std::string; // 使用 string 类型
using std::cerr;   // 使用 cerr 输出错误信息

// 创建一个 WaitGroup 对象，用于同步
static WFFacilities::WaitGroup waitGroup(1);

// 定义信号处理函数，用于处理 SIGINT 信号
void sighandler(int signum){
    std::cout << "signum = " << signum << "\n"; // 输出接收到的信号编号
    waitGroup.done(); // 完成 WaitGroup 的工作，结束程序
}

// MySQL 任务的回调函数
void mysqlCallback(WFMySQLTask * mysqlTask){
    // 检查任务状态是否成功
    if(mysqlTask->get_state() != WFT_STATE_SUCCESS){
        // 输出系统级错误信息，如权限或密码错误
        cerr << "error_msg =  " << WFGlobal::get_error_string(mysqlTask->get_state(), mysqlTask->get_error()) << "\n";
        return;
    }

    // 获取 MySQL 响应对象
    protocol::MySQLResponse * resp = mysqlTask->get_resp();
    
    // 检查返回的数据包类型是否为错误类型
    if(resp->get_packet_type() == MYSQL_PACKET_ERROR){
        // 输出 SQL 语句执行中的错误码和错误信息
        cerr << "error_code = " << resp->get_error_code() << " error_msg = " << resp->get_error_msg() << "\n";
        return;
    }

    // 创建 MySQL 结果游标对象
    protocol::MySQLResultCursor cursor(resp);
    
    // 循环处理结果集
    do{
        // 检查游标状态
        if(cursor.get_cursor_status() == MYSQL_STATUS_OK){
            // 如果是写操作，输出受影响的行数
            cerr << "write \n";
            cerr << cursor.get_affected_rows() << " rows affected\n";
        }
        else if(cursor.get_cursor_status() == MYSQL_STATUS_GET_RESULT){
            // 如果是读操作
            cerr << "read \n";
            
            // 读取字段信息
            const protocol::MySQLField * const * fieldArr;
            fieldArr = cursor.fetch_fields();
            for(int i = 0; i < cursor.get_field_count(); ++i){
                // 输出数据库、表名、字段名及其数据类型
                cerr << "db = " << fieldArr[i]->get_db()
                     << " table = " << fieldArr[i]->get_table()
                     << " name = " << fieldArr[i]->get_name()
                     << " type = " << datatype2str(fieldArr[i]->get_data_type()) << "\n";
            }

            // 读取表的所有内容
            std::vector<std::vector<protocol::MySQLCell>> rows;
            cursor.fetch_all(rows); // 获取所有行
            
            // 遍历每一行和每一个单元格
            for(auto &row : rows){
                for(auto &cell : row){
                    // 根据单元格的数据类型输出相应的内容
                    if(cell.is_int()){
                        cerr << cell.as_int();
                    }
                    else if(cell.is_string()){
                        cerr << cell.as_string();
                    }
                    else if(cell.is_datetime()){
                        cerr << cell.as_datetime();
                    }
                    cerr << "\t"; // 输出制表符
                }
                cerr << "\n"; // 换行
            } 
        }
    } while(cursor.next_result_set()); // 支持一个任务处理多个 SQL 语句
}

int main(){
    signal(SIGINT, sighandler); // 注册 SIGINT 信号处理函数

    // 创建 MySQL 任务并指定连接字符串和回调函数
    WFMySQLTask * mysqlTask =  WFTaskFactory::create_mysql_task("mysql://root:123@localhost", 1, mysqlCallback);
    
    // 构造 SQL 查询语句
    string sql = "insert into mycloud.tbl_user_token (user_name, user_token) values ('Caixukun', 'singdancerap');";
    sql += "select * from mycloud.tbl_user_token;"; // 在插入后选择用户令牌

    // 设置 MySQL 任务的查询
    mysqlTask->get_req()->set_query(sql);
    
    // 启动 MySQL 任务
    mysqlTask->start();
    
    // 等待 WaitGroup 完成
    waitGroup.wait();
    
    return 0; // 返回 0 表示程序正常结束
}

qq_51583806 彩雷王
关注
专栏目录
ArgoWorkflow教程(四)---Workflow & 日志归档
weixin_37023863的博客
09-14 128
合集 - ArgoWorkflow(4)1.ArgoWorkflow教程(二)---快速构建流水线：Workflow & Template 概念08-202.ArgoWorkflow 教程(一)--DevOps 另一选择？云原生 CICD 初体验08-063.ArgoWorkflow教程(三)---使用 Artifacts 实现步骤间文件共享08-294.ArgoWorkflow教程(四)...
C++异步网络库workflow系列教程(2)redis任务
新法的博客
12-14 2498
与http task的get_req()类似，redis task的get_req()返回任务对应的redis request。 RedisRequest提供的功能可以在查看。 其中，set_request接口用于设置redis命令。
适合嵌入式的C++开源项目-Workflow
嵌入式Linux
09-09 2149
在来腾讯之前，我是没有真正用C++开发过一个完整的项目的，然后，赶鸭子上架，鹅厂的人特别喜欢用C++，而且用的特别好。我这次推荐一个开源的C++项目，希望喜欢C++，或者想往C++方向发展...
一个超轻量级工作流引擎：Workflow-Core
dotNET跨平台
07-19 6038
近期工作上有一个工作流的开发需求，自己基于面向对象和职责链模式捣鼓了一套小框架，后来在github上发现一个轻量级的工作流引擎轮子：Workflow-Core，看完其wi...
一个适合于.NET Core的超轻量级工作流引擎：Workflow-Core
Mr_TianSDQ的博客
02-20 2090
一个适合于.NET Core的超轻量级工作流引擎：Workflow-Core
搜狗workflow框架例程分析——03
qq_44011116的博客
12-11 1225
文章目录测试说明测试结果代码分析main函数http_callback函数 测试说明 本次例程在ubuntu上运行，redis服务器安装在本机的windows系统下，运行例程00作为访问对象。 测试结果 没有运行例程03之前在redis的数据库 运行例程03之后 可以看到数据库中已经增加了关于本地端口8888的记录。 代码分析 在例程中，主要关注三个callback函数（series_callback, http_callback, redis_callback）和一个lamda函数 main函数
go-machinery入门教程（异步任务队列教程）
qq_39397165的博客
10-31 4808
主题使用方法：https://github.com/xitu/juejin-markdown-themes theme: juejin highlight: github 前言 哈喽，大家好，我是asong，这次给大家介绍一个go的异步任务框架machinery。使用过python的同学们都知道Celery框架，machinery框架就类似于Celery框架。下面我们就来学习一下machinery的基本使用。 自己翻译一个粗略版的machinery中文文档，有需要的伙伴们公众号自取无水印版：后台回复：m.
开源工作流引擎 Workflow Core 的研究和使用教程
weixin_30795127的博客
08-10 1653
目录 开源工作流引擎 Workflow Core 的研究和使用教程 一，工作流对象和使用前说明 二，IStepBuilder 节点 三，工作流节点的逻辑和操作 容器操作 普通节点 事件 条件体和循环体 节点的...
workFlow c++异步网络库编译教程与简介
新法的博客
12-12 1891
搜狗公司C++服务器引擎，编程范式。支撑搜狗几乎所有后端C++在线服务，包括所有搜索服务，云输入法，在线广告等，每日处理数百亿请求。这是一个设计轻盈优雅的企业级程序引擎，可以满足大多数后端与嵌入式开发需求。 编程范式 结构化并发与任务隐藏回调与内存回收机制
C++(week17): C++提高:(七)workflow
Edward2022的博客
08-19 1020
①HTTP协议复习 ②Nginx的基本使用 ③异步回调框架：workflow、wfrest ④微服务相关技术：阿里云OSS、容器docker、消息队列RabbitMQ ⑤web网盘项目用面向对象方式重写
aws-lambda-swift-sprinter：具有swift-nio 2.0支持的AWS Lambda Swift自定义运行时
02-05
Lambda函数可以响应各种事件，如HTTP请求、S3对象更改或数据库触发器。Lambda运行时是执行代码的环境，通常由AWS预先配置，但也可以自定义。 `aws-lambda-swift-sprinter` 是一个项目，专门用于在AWS Lambda上运行...
Apache Airflow：自动化数据处理管道—— 一个可让您构建和运行DAG工作任务流程的平台
AI天才研究院
07-14 1899
数据处理流程管理是许多公司面临的数据管理和分析难题。传统上企业通常会手工建立数据处理流程，人工操作繁琐且效率低下。而自动化工具则可以大幅提升工作效率，节约人力资源，缩短响应时间，并减少错误发生率。Airflow（Airflow是一种基于Python开发的轻量级开源的DAG (Directed Acyclic Graphs) 任务流管理系统）就是这样一个自动化的数据处理管道管理工具。
python工作流引擎workflow.py_一个适合于.NET Core的超轻量级工作流引擎：Workflow-Core...
weixin_39548805的博客
12-19 1028
一、关于Workflow-Core近期工作上有一个工作流的开发需求，自己基于面向对象和职责链模式捣鼓了一套小框架，后来在github上发现一个轻量级的工作流引擎轮子：Workflow-Core，看完其wiki之后决定放弃之前自己造的轮子，使用这个开源项目来改造，也就有了这一篇博文。Workflow-Core是一个基于.NET Standard的轻量级工作流引擎，其GitHub地址为：https:/...
celery分布式异步任务框架
prodigal11的博客
02-02 286
介绍： Celery是Python开发的分布式异步任务调度模块。Celery 需要一个发送和接受消息的传输者。RabbitMQ 和 Redis 中间人的消息传输支持所有特性，但也提供大量其他实验性方案的支持，包括用 SQLite 进行本地开发。Celery 可以单机运行，也可以在多台机器上运行，甚至可以跨越数据中心运行。 什么是clelery：处理大量消息的分布式系统 celery可以做什么： 异步任务 定时任务 使用场景： 耗时操作（所有的耗时操作都可以） 定时任务（可以设置在一定时间执行一件事，每天定时
WinHttp异步实现GET, POST, 多线程下载文件
FlameCyclone的博客
09-29 582
基于WinHttp封装, 实现异步多线程文件下载, GET请求, POST请求
socket和http区别
最新发布
weixin_37788102的博客
10-03 421
http：http是客户端用http协议进行请求，发送请求的时候需要封装http请求头，并绑定请求的数据，服务器一般有web服务器配合(当然也非绝对)，http的请求方式为客户端主动发起请求，服务器才能给响应，一次请求完毕后则断开连接，以节省资源，服务器不能主动给客户端发起响应，主要使用类是NSURLConnection。其中，主体不同指的是socke是一个调用接口（API），而HTTP是基于TCP/IP协议的应用层协议。http：HTTP是基于TCP/IP协议的应用层协议，定义的是传输数据的内容的规范。
HTTP 和 HTTPS 协议的区别？
智通全网络工作室的博客
09-27 1449
HTTP 是一种无状态的、基于请求/响应模型的应用层协议，旨在用于分布式、协作和超媒体信息系统。最常见的用途是查看网页。HTTP 协议在 TCP/IP 上运行，其标准端口是 80。了解 HTTP 和 HTTPS 之间的区别至关重要。HTTPS 是保护用户信息和提升网站信任度的关键因素。在一个安全意识增强的时代，确保你的网站使用 HTTPS 不仅是一个负责任的做法，也是赢得用户信任的基石。希望这篇博客能帮助你更好地理解这两种协议的区别及其重要性。
java8:hutool：httputil.post读取配置项中的url
hongyuxiongji的博客
09-28 658
不过这种方式有潜在的问题，因为在Spring容器初始化Bean的时候构造函数会被调用，但是如果@Value注入还没完成（例如配置文件加载延迟等情况），可能会导致staticUrl的值为null。如果HttpUtil.post是静态方法，无法直接访问非静态的@Value注入的属性。1. 首先将配置项的值通过@Value注入到类的成员变量，然后在构造函数中将这个值传递给一个静态变量。这种方式更符合Spring的依赖注入原则，而且可以确保在需要使用配置值的时候能够正确获取到。通过一个工具类方法获取配置值。
HTTP 协议的基本格式和 fiddler 的用法
GodK777的博客
10-03 543
一、请求格式1. 请求行- 包含请求方法（如 GET、POST、PUT 等）、请求的资源路径和 HTTP 版本。例如：“GET /index.html HTTP/1.1”。2. 请求头- 由一系列键值对组成，如“Host”表示请求的主机名，“User-Agent”表示发出请求的客户端信息等。- 每个请求头占一行，格式为“头字段名: 值”。3. 空行- 用于分隔请求头和请求体。4. 请求体- 对于某些请求方法（如 POST），会包含要提交的数据。二、响应格式。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值