Oozie - 仅今天小时的协调员

如何解决Oozie - 仅今天小时的协调员

是否可以让 Oozie 协调员只查看今天的时间？例如，如果当前小时是 16 小时，那么每小时运行的作业会返回 00 到 16 吗？

我知道您可以通过以下方式返回前 24 小时：

#include <iostream>
#include <thread>
#include <vector>
#include <atomic>
#include <cstdlib>

#define _WINSOCK_DEPRECATED_NO_WARNINGS
#include <winsock2.h>
#include <Windows.h>
#include <ws2tcpip.h>

#pragma comment(lib,"Ws2_32.lib")

std::atomic<bool> stopRunning = false;

void client(SOCKET client_socket)
{
    int iResult;
    char buffer[1024];
    fd_set rfds;
    timeval timeout;

    std::cout << "New connection" << std::endl;

    while (!stopRunning.load()) {
        iResult = recv(client_socket,buffer,sizeof(buffer),0);
        if (iResult == SOCKET_ERROR) {
            iResult = WSAGetLastError();
            if (iResult != WSAEWOULDBLOCK) {
                std::cerr << "recv Failed: " << iResult << "\n";
                break;
            }

            FD_ZERO(&rfds);
            FD_SET(client_socket,&rfds);

            timeout.tv_sec = 1;
            timeout.tv_usec = 0;

            iResult = select(0,&rfds,NULL,&timeout);
            if (iResult < 0) {
                iResult = WSAGetLastError();
                std::cerr << "select Failed: " << iResult << "\n";
                break;
            }

            if (iResult == 0)
                continue;
        }
        else if (iResult == 0) {
            std::cout << "Closing connection" << std::endl;
            break;
        }
        else {
            std::cout.write(buffer,iResult);
            std::cout << std::endl;
        }
    }

    //clean up
    closesocket(client_socket);
}

void server()
{
    int iResult;

    sockaddr_in listen_address;
    listen_address.sin_family = AF_INET;
    listen_address.sin_port = htons(1000);
    listen_address.sin_addr.S_un.S_addr = INADDR_ANY;

    SOCKET listen_socket = socket(AF_INET,SOCK_STREAM,0);
    if (listen_socket == INVALID_SOCKET) {
        iResult = WSAGetLastError();
        std::cerr << "socket Failed: " << iResult << "\n";
        return;
    }

    u_long mode = 1;
    if (ioctlsocket(listen_socket,FIONBIO,&mode) == SOCKET_ERROR) {
        iResult = WSAGetLastError();
        std::cerr << "ioctlsocket Failed: " << iResult << "\n";
        closesocket(listen_socket);
        return;
    }

    if (bind(listen_socket,(sockaddr*)&listen_address,sizeof(listen_address)) == SOCKET_ERROR) {
        iResult = WSAGetLastError();
        std::cerr << "bind Failed: " << iResult << "\n";
        closesocket(listen_socket);
        return;
    }

    if (listen(listen_socket,SOMAXCONN) == SOCKET_ERROR) {
        iResult = WSAGetLastError();
        std::cerr << "listen Failed: " << iResult << "\n";
        closesocket(listen_socket);
        return;
    }

    std::vector<std::thread> clients;
    sockaddr client_info;
    int addrlen;
    SOCKET client_socket;
    fd_set rfds;
    timeval timeout;

    while (!stopRunning.load()) {
        FD_ZERO(&rfds);
        FD_SET(listen_socket,&rfds);

        timeout.tv_sec = 1;
        timeout.tv_usec = 0;

        iResult = select(0,&timeout);
        if (iResult < 0) {
            iResult = WSAGetLastError();
            std::cerr << "select Failed: " << iResult << "\n";
            break;
        }

        if (iResult > 0) {
            addrlen = sizeof(client_info);
            client_socket = accept(listen_socket,(struct sockaddr*)&client_info,&addrlen);
            if (client_socket == INVALID_SOCKET) {
                iResult = WSAGetLastError();
                std::cerr << "accept Failed: " << iResult << "\n";
                break;
            }

            if (ioctlsocket(client_socket,&mode) == SOCKET_ERROR) {
                iResult = WSAGetLastError();
                std::cerr << "ioctlsocket Failed: " << iResult << "\n";
                closesocket(client_socket);
                continue;
            }

            threads.push_back(std::thread(client,client_socket));
        }
    }

    closesocket(listen_socket);

    stopRunning = true;
    for (auto &t : threads) {
        t.join();
    }    
}

int main() {
    WSADATA data;
    int iResult = WSAStartup(MAKEWORD(2,2),&data);
    if (iResult != 0) {
        std::cerr << "WSAStartup Failed: " << iResult << "\n";
        return 0;
    }

    std::thread server_thread(server);

    std::system("pause");

    stopRunning = true;
    server_thread.join();

    WSACleanup();
    return 0;
}

但是，我对处理昨天的数据不感兴趣...只是今天的