Exemplo n.º 1
0
QByteArray RpcTask::process(QByteArray req_msg) {
    const void *req_data = req_msg.constData();
    Q_ASSERT(req_data);
    int req_size = req_msg.length();
    Q_ASSERT(req_size);
    bool req_parsed = m_req.ParseFromArray(req_data, req_size);
    Q_ASSERT(req_parsed);

    if (m_req.name() == ".Reflector.Service.ack") {
        bool ack_parsed = m_ack_req.ParseFromString(m_req.data());
        Q_ASSERT(ack_parsed);

        m_ack_res.set_timestamp(m_ack_req.timestamp());
        m_res.set_data(m_ack_res.SerializeAsString());
    } else if (m_req.name() == ".Calculator.Service.add") {
        bool add_parsed = m_add_req.ParseFromString(m_req.data());
        Q_ASSERT(add_parsed);

        m_add_res.set_value(m_add_req.lhs() + m_add_req.rhs());
        m_res.set_data(m_add_res.SerializeAsString());
    } else if (m_req.name() == ".Calculator.Service.sub") {
        bool sub_parsed = m_sub_req.ParseFromString(m_req.data());
        Q_ASSERT(sub_parsed);

        m_sub_res.set_value(m_sub_req.lhs() - m_sub_req.rhs());
        m_res.set_data(m_sub_res.SerializeAsString());
    } else if (m_req.name() == ".Calculator.Service.mul") {
        bool mul_parsed = m_mul_req.ParseFromString(m_req.data());
        Q_ASSERT(mul_parsed);

        m_mul_res.set_value(m_mul_req.lhs() * m_mul_req.rhs());
        m_res.set_data(m_mul_res.SerializeAsString());
    } else if (m_req.name() == ".Calculator.Service.div") {
        bool mul_parsed = m_div_req.ParseFromString(m_req.data());
        Q_ASSERT(mul_parsed);

        m_div_res.set_value(m_div_req.lhs() / m_div_req.rhs());
        m_res.set_data(m_div_res.SerializeAsString());
    } else {
        throw RpcException(QString(m_req.name().c_str()).append(": not supported"));
    }

    m_res.set_id(m_req.id());
    Q_ASSERT(m_res.id() > 0);
    int res_size = m_res.ByteSize();
    Q_ASSERT(res_size);
    QByteArray res_msg(res_size, 0);
    Q_ASSERT(res_msg.capacity() == res_size);
    m_res.SerializeToArray(res_msg.data(), res_size);
    Q_ASSERT(res_msg.size() == res_size);

    return res_msg;
}
Exemplo n.º 2
0
void ProcessSubmitJob(Socket& socket, const std::string job_id, const std::string& exe_path, const std::vector<std::string>& recv_files){
  std::cout << "ProcessSubmitJob: " << job_id << std::endl;
  Message res_msg(Header(MT_COMMAND, g_kdesk_port, 0, 0, CMD_JOB_STATE), NULL);
  Header err_hdr(MT_COMMAND, g_kdesk_port, 0, 0, CMD_ACK_ERR);

  // Pre-processing command
  std::string pre_file = job_id + "_pre.sh";
  std::cout << "Pre-processing commands: " << pre_file <<std::endl;
  RunExtendSh(job_id, pre_file);
  

  // Run submit job command
  std::cout << "run pjsub.\n";
  std::string pjm_jid = RunPjsub(job_id, exe_path);
  if(pjm_jid.size() <= 0){
    std::cout << "run pjsub fail\n";
    res_msg.SetHeader(err_hdr);
    if(socket.Send(res_msg)){
      std::cout << "send error response success.\n";
    } else {
      std::cout << "send error response fail.\n";
    }
    return;
  }

  // RunPjwait command
  if(RunPjwait(socket, job_id, pjm_jid)){
    std::cout << "run pjwait success.\n";
  } else {
    std::cout << "run pjwait fail.\n";
  }
  
  // Post-processing command
  std::string post_file = job_id + "_post.sh";
  std::cout << "Post-processing commands:" << post_file << std::endl; 
  RunExtendSh(job_id, post_file);

  // Send file to slavedaemon
  std::string job_path = g_home_job_dir + job_id;
  std::vector<std::string> new_files = GetNewFiles(job_path, recv_files);
  std::cout << "num of new file: " << new_files.size() << "files\n";

  Message notify_msg = Message(Header(MT_COMMAND, g_kdesk_port, 0, 0, CMD_JOB_STATE), NULL),
      err_msg = Message(Header(MT_COMMAND, g_kdesk_port, 0, 0, CMD_ACK_ERR), NULL);

  if(socket.SendListFile(new_files, job_path + PATH_SEPARATOR)){
    std::cout << "send file to slavedaemon success.\n";
    std::string status, start_date, eslapse_time;
    RunPjstat(pjm_jid, status, start_date, eslapse_time);
    notify_msg.AddArgv(job_id);
    notify_msg.AddArgv(pjm_jid);
    notify_msg.AddArgv(status);
    notify_msg.AddArgv(start_date);
    notify_msg.AddArgv(eslapse_time);

    //status = RunPjstat(pjm_jid);
    //res_msg.AddArgv(pjm_jid);
    //res_msg.AddArgv(status);
    if(socket.Send(notify_msg)){
      std::cout << "notify job finished success.\n";
    } else {
      std::cout << "notify job finished false.\n";
    }
    return;
  } else {
    std::cout << "send file to slavedaemon fail.\n";
  }
  if(socket.Send(err_msg)){
    std::cout << "send error message success.\n";
    return;
  } else {
    std::cout << "send error message fail.\n";
  }
}