Example #1
0
    bool feedback(float fProgress, DWORD_PTR pUser1, DWORD_PTR pUser2)
    {
        auto surfaceWork = reinterpret_cast<ImporterSurfaceWork*>(pUser1);

        float progress = fProgress / 100.0f;

        if (progress != surfaceWork->lastProgress)
        {
            surfaceWork->lastProgress = progress;
            ProcessorTaskMessageType type;
            type.set_type(ProcessorTaskMessageType::TaskProgress);
            vector<char> type_message(type.ByteSizeLong());
            if (type_message.size() > 0)
                type.SerializeToArray(&type_message[0], type_message.size());

            ProcessorTaskProgress prog;
            prog.set_taskid(surfaceWork->request->taskid());
            prog.set_progress(progress);
            vector<char> progData(prog.ByteSizeLong());
            if (progData.size() > 0)
                prog.SerializeToArray(&progData[0], progData.size());

            MqMessage msg;
            msg.emplace_back(surfaceWork->hostId);
            msg.emplace_back("");
            msg.emplace_back(std::move(type_message));
            msg.emplace_back(std::move(progData));
            msg.send(*surfaceWork->socket);
        }
        return false;
    }
Example #2
0
    int ResourceTask::join()
    {
        while (true)
        {
            poll(m_polls, 20);

            if (m_polls[0].revents & ZMQ_POLLIN)
            {
                m_state = TaskState::PerformingTask;

                MqMessage msg(m_socket);
                string id = string(msg.parts()[0].begin(), msg.parts()[0].end());

                ProcessorTaskMessageType type;
                type.ParseFromArray(msg.parts()[1].data(), msg.parts()[1].size());

                switch (type.type())
                {
                    case ProcessorTaskMessageType::TaskRequest:
                    {
                        ProcessorTaskRequest requesttype;
                        requesttype.ParseFromArray(msg.parts()[2].data(), msg.parts()[2].size());

                        vector<char> responseData;

                        switch (requesttype.type())
                        {
                            case ProcessorTaskRequest::Image:
                            {
                                ProcessorTaskImageRequest imageReq;
                                imageReq.ParseFromArray(msg.parts()[3].data(), msg.parts()[3].size());
                                LOG("Task was asked to perform Image encoding: %s", imageReq.taskid().c_str());
                                auto response = m_imageTask.process(imageReq, m_hostid, &m_socket);
                                responseData.resize(response.ByteSizeLong());
                                if(responseData.size() > 0)
                                    response.SerializeToArray(&responseData[0], responseData.size());
                                break;
                            }
                            case ProcessorTaskRequest::Model:
                            {
                                ProcessorTaskModelRequest modelReq;
                                modelReq.ParseFromArray(msg.parts()[3].data(), msg.parts()[3].size());
                                LOG("Task was asked to perform Model encoding: %i", modelReq.taskid().c_str());
                                auto response = m_modelTask.process(modelReq, m_hostid, &m_socket);

                                responseData.resize(response.ByteSizeLong());
                                if (responseData.size() > 0)
                                    response.SerializeToArray(&responseData[0], responseData.size());
                                break;
                            }
                        }

                        ProcessorTaskMessageType resulttype;
                        resulttype.set_type(ProcessorTaskMessageType::TaskResponse);
                        vector<char> type_message(resulttype.ByteSizeLong());
                        if (type_message.size() > 0)
                            resulttype.SerializeToArray(&type_message[0], type_message.size());

                        MqMessage responseMsg;
                        responseMsg.emplace_back(id);
                        responseMsg.emplace_back("");
                        responseMsg.emplace_back(std::move(type_message));
                        responseMsg.emplace_back(std::move(msg.parts()[2]));
                        responseMsg.emplace_back(std::move(responseData));
                        responseMsg.send(m_socket);

                        break;
                    }
                    case ProcessorTaskMessageType::DoneRequest:
                    {
                        ProcessorTaskMessageType resulttype;
                        resulttype.set_type(ProcessorTaskMessageType::DoneResponse);
                        vector<char> type_message(resulttype.ByteSizeLong());
                        if (type_message.size() > 0)
                            resulttype.SerializeToArray(&type_message[0], type_message.size());

                        MqMessage responseMsg;
                        responseMsg.emplace_back(id);
                        responseMsg.emplace_back("");
                        responseMsg.emplace_back(std::move(type_message));
                        responseMsg.send(m_socket);
                        return 0;
                    }
                }
                //EncodeTaskHeloAnswer
            }

            if (m_state == TaskState::WaitingForHelo)
            {
                auto now = std::chrono::high_resolution_clock::now();
                auto durationMs = static_cast<double>(std::chrono::duration_cast<std::chrono::nanoseconds>(now - m_lastCheck).count()) / 1000000.0;

                if (durationMs > 300)
                {
                    m_lastCheck = now;
                    ProcessorTaskMessageType type;
                    type.set_type(ProcessorTaskMessageType::Helo);
                    vector<char> type_message(type.ByteSizeLong());
                    if (type_message.size() > 0)
                        type.SerializeToArray(&type_message[0], type_message.size());

                    MqMessage msg;
                    msg.emplace_back(m_hostid);
                    msg.emplace_back("");
                    msg.emplace_back(move(type_message));
                    msg.send(m_socket);

                    LOG("Sent TASK helo to ID: %s", m_hostid.c_str());
                }
            }
        }
        LOG("Task exiting");
        return 0;
    }