void Application::executeRequest(boost::function<void (HttpRequest*&, HttpResponse*&, void*)> convertData, void* data, boost::function<void (HttpRequest*, HttpResponse*)> requestFinish) {
//Create request
HttpRequest* request = NULL;
HttpResponse* response = NULL;
HttpSession* session = NULL;
convertData(request, response, data);
if(request==NULL||response==NULL) {
requestFinish(request, response);
return;
}
setContextToRequest(request);
if(mSessionManager) {
session = mSessionManager->startSession(*request, *response);
if(session) {
setSession(request, session);
}
}
IUrlHandler* urlHandler = getBeanFactory()->getBean<IUrlHandler>("urlHandler");
if(!urlHandler) {
if(mSessionManager && session) {
mSessionManager->endSession(session, *request, *response);
}
std::cout << "No URL Handler found set error page: 500" << std::endl;
requestFinish(request, response);
return;
}
if(!urlHandler->dispatchUrl(*request, *response)) {
if(mSessionManager && session) {
mSessionManager->endSession(session, *request, *response);
}
std::cout << "URL handle error set error page: 500" << std::endl;
requestFinish(request, response);
return;
}
if(mSessionManager && session) {
mSessionManager->endSession(session, *request, *response);
}
response->flush();
requestFinish(request, response);
}
TEST_F(HttpClientTest, Post)
{
HttpClient client;
HttpResponse response;
HttpClient::Options options;
HttpClient::ErrorCode error;
std::string data = "Post Content";
EXPECT_FALSE(client.Post(m_server_address + "/aaa/bbb",
data,
options,
&response,
&error));
EXPECT_NE(error, HttpClient::SUCCESS);
EXPECT_EQ(HttpResponse::Status_NotFound, response.Status());
}
void onLcd(HttpRequest &request, HttpResponse &response)
{
int y = request.getQueryParameter("y").toInt();
String text = request.getQueryParameter("text");
setLcd(y, text);
JsonObjectStream* stream = new JsonObjectStream();
JsonObject& json = stream->getRoot();
json["status"] = (bool)true;
response.setAllowCrossDomainOrigin("*");
response.setHeader("Access-Control-Allow-Methods", "GET,POST,PUT,DELETE,OPTIONS");
response.setHeader("Access-Control-Allow-Headers", "Content-Type, Access-Control-Allow-Headers, Authorization, X-Request, X-Request, X-Requested-With");
response.sendJsonObject(stream);
}
void onTune(HttpRequest &request, HttpResponse &response)
{
setFrequency(request.getQueryParameter("freq").toFloat());
JsonObjectStream* stream = new JsonObjectStream();
JsonObject& json = stream->getRoot();
json["status"] = (bool)true;
response.setAllowCrossDomainOrigin("*");
response.setHeader("Access-Control-Allow-Methods", "GET,POST,PUT,DELETE,OPTIONS");
response.setHeader("Access-Control-Allow-Headers", "Content-Type, Access-Control-Allow-Headers, Authorization, X-Request, X-Request, X-Requested-With");
response.sendJsonObject(stream);
}
void web_cb_scan_status(HttpRequest &request, HttpResponse &response) {
JsonObjectStream* stream = new JsonObjectStream();
JsonObject& json = stream->getRoot();
JsonArray& netlist = json.createNestedArray("available");
for (int i = 0; i < networks.count(); i++) {
JsonObject &item = netlist.createNestedObject();
item.add("id", (int)networks[i].getHashId());
item.add("title", networks[i].ssid.c_str());
item.add("signal", networks[i].rssi);
item.add("encryption", networks[i].getAuthorizationMethodName());
}
response.setAllowCrossDomainOrigin("*");
response.sendJsonObject(stream);
}
static void runHttpClientGetTest(TestRunner& tr)
{
tr.test("Http Client GET");
// create client
HttpClient client;
// connect
Url url("http://www.bitmunk.com");
if(client.connect(&url))
{
printf("Connected to: %s\n", url.toString().c_str());
InternetAddress address(url.getHost().c_str(), url.getPort());
printf("%s\n", address.toString().c_str());
// do get
DynamicObject headers;
headers["Test-Header"] = "bacon";
HttpResponse* response = client.get(&url, &headers);
if(response != NULL)
{
printf("Response=\n%s\n", response->getHeader()->toString().c_str());
if(response->getHeader()->getStatusCode() == 200)
{
// receive content
HttpTrailer trailer;
File file("/tmp/index.html");
FileOutputStream fos(file);
if(client.receiveContent(&fos, &trailer))
{
printf("Content downloaded to '%s'\n",
file->getAbsolutePath());
printf("HTTP trailers=\n%s\n", trailer.toString().c_str());
}
assertNoExceptionSet();
}
}
else
{
printf("There was no response!\n");
}
client.disconnect();
}
tr.passIfNoException();
}
//----------------------------------------------------------------------------
//
//----------------------------------------------------------------------------
void mqttOnHttpConfig(HttpRequest &request, HttpResponse &response)
{
AppSettings.load();
if (!g_http.isHttpClientAllowed(request, response))
return;
if (request.getRequestMethod() == RequestMethod::POST) {
AppSettings.mqttUser = request.getPostParameter("user");
AppSettings.mqttPass = request.getPostParameter("password");
AppSettings.mqttServer = request.getPostParameter("server");
AppSettings.mqttPort = atoi(request.getPostParameter("port").c_str());
AppSettings.mqttClientId = request.getPostParameter("clientId");
AppSettings.save();
if (WifiStation.isConnected())
mqttStartClient();
} // if
TemplateFileStream *tmpl = new TemplateFileStream("mqtt.html");
auto &vars = tmpl->variables();
vars["appAlias"] = szAPP_ALIAS;
vars["user"] = AppSettings.mqttUser;
vars["password"] = AppSettings.mqttPass;
vars["server"] = AppSettings.mqttServer;
vars["port"] = AppSettings.mqttPort;
vars["clientId"] = AppSettings.mqttClientId;
response.sendTemplate(tmpl); // will be automatically deleted
} // mqttOnHttpConfig
TEST_F(HttpClientTest, Put)
{
HttpClient client;
HttpResponse response;
HttpClient::Options options;
HttpClient::ErrorCode error;
std::string data = "Put Content";
EXPECT_TRUE(client.Put(m_server_address + "/Put",
data,
options,
&response,
&error));
EXPECT_EQ(HttpClient::SUCCESS, error);
// www.qq.com always return 200.
EXPECT_EQ(HttpResponse::Status_OK, response.Status());
}
bool HttpServer::initWebSocket(HttpServerConnection& connection, HttpRequest& request, HttpResponse& response)
{
if (!wsEnabled)
return false;
WebSocket *sock = new WebSocket(&connection);
if (!sock->initialize(request, response))
return false;
connection.setTimeOut(USHRT_MAX); //Disable disconnection on connection idle (no rx/tx)
connection.setDisconnectionHandler(HttpServerConnectionDelegate(&HttpServer::onCloseWebSocket, this)); // auto remove on close
response.sendHeader(connection); // Will push header before user data
wsocks.addElement(sock);
if (wsConnect) wsConnect(*sock);
if (wsCommandEnabled && (request.getQueryParameter(wsCommandRequestParam) == "true"))
{
#if ENABLE_CMD_EXECUTOR
debugf("WebSocket Commandprocessor started");
#else
debugf("WebSocket Commandprocessor support DISABLED via ENABLE_CMD_EXECUTOR");
#endif
sock->enableCommand();
}
}
/**
* just for testing
*/
void ICACHE_FLASH_ATTR onTest(HttpRequest &request, HttpResponse &response)
{
response.sendString("Hello, World!<br/>");
response.sendString("files:");
Vector<String> files=fileList();
for(int i=0;i<files.size();i++){
response.sendString(files[i]);
response.sendString("\r\n");
//ebugf("file %d=%s",i,files[i]);
}
}
void HttpThread::OnTransactionCompleted(HttpSession & /*httpSession*/,
HttpTransaction & httpTransaction)
{
HttpResponse * pResponse = httpTransaction.GetResponse();
if (pResponse->GetHttpStatusCode() == HTTP_STATUS_OK
|| pResponse->GetHttpStatusCode() == HTTP_STATUS_PARTIAL_CONTENT)
{
m_callback.OnFinish(200, m_begRange, m_endRange);
}
else
{
LOG(LWARNING, ("Download has finished with status code:", pResponse->GetHttpStatusCode(),
" and text:", FromTizenString(pResponse->GetStatusText() )));
m_callback.OnFinish(-100, m_begRange, m_endRange);
}
}
bool ConsoleHandler::AutocompleteScriptHelper(HttpRequest& request, HttpResponse& response,
const String& command, const String& session, bool sandboxed)
{
Log(LogInformation, "Console")
<< "Auto-completing expression: " << command;
ApiScriptFrame& lsf = l_ApiScriptFrames[session];
lsf.Seen = Utility::GetTime();
if (!lsf.Locals)
lsf.Locals = new Dictionary();
Array::Ptr results = new Array();
Dictionary::Ptr resultInfo = new Dictionary();
ScriptFrame frame;
frame.Locals = lsf.Locals;
frame.Self = lsf.Locals;
frame.Sandboxed = sandboxed;
resultInfo->Set("code", 200);
resultInfo->Set("status", "Auto-completed successfully.");
resultInfo->Set("suggestions", Array::FromVector(GetAutocompletionSuggestions(command, frame)));
results->Add(resultInfo);
Dictionary::Ptr result = new Dictionary();
result->Set("results", results);
response.SetStatus(200, "OK");
HttpUtility::SendJsonBody(response, result);
return true;
}
void onIndex(HttpRequest &request, HttpResponse &response)
{
TemplateFileStream *tmpl = new TemplateFileStream("index.html");
auto &vars = tmpl->variables();
//vars["counter"] = String(counter);
response.sendTemplate(tmpl); // this template object will be deleted automatically
}
void onAjaxInput(HttpRequest &request, HttpResponse &response)
{
JsonObjectStream* stream = new JsonObjectStream();
JsonObject& json = stream->getRoot();
json["status"] = (bool)true;
String stringKey = "StringKey";
String stringValue = "StringValue";
json[stringKey] = stringValue;
for( int i = 0; i < 11; i++)
{
char buff[3];
itoa(i, buff, 10);
String desiredString = "sensor_";
desiredString += buff;
json[desiredString] = desiredString;
}
JsonObject& gpio = json.createNestedObject("gpio");
for (int i = 0; i < countInputs; i++)
gpio[namesInput[i].c_str()] = digitalRead(inputs[i]);
response.sendJsonObject(stream);
}
HttpSession HttpSessionStore::getSession(HttpRequest& request, HttpResponse& response, bool allowCreate) {
QByteArray sessionId=getSessionId(request,response);
mutex.lock();
if (!sessionId.isEmpty()) {
HttpSession session=sessions.value(sessionId);
if (!session.isNull()) {
mutex.unlock();
session.setLastAccess();
return session;
}
}
// Need to create a new session
if (allowCreate) {
QByteArray cookieName=settings->value("cookieName","sessionid").toByteArray();
QByteArray cookiePath=settings->value("cookiePath","/").toByteArray();
QByteArray cookieComment=settings->value("cookieComment").toByteArray();
QByteArray cookieDomain=settings->value("cookieDomain").toByteArray();
HttpSession session(true);
qDebug("HttpSessionStore: create new session with ID %s",session.getId().data());
sessions.insert(session.getId(),session);
response.setCookie(HttpCookie(cookieName,session.getId(),expirationTime/1000,cookiePath,cookieComment,cookieDomain));
mutex.unlock();
return session;
}
// Return a null session
mutex.unlock();
return HttpSession();
}
void onMute(HttpRequest &request, HttpResponse &response)
{
setMmute(!mute);
JsonObjectStream* stream = new JsonObjectStream();
JsonObject& json = stream->getRoot();
json["status"] = (bool)true;
json["state"] = (bool)mute;
response.setAllowCrossDomainOrigin("*");
response.setHeader("Access-Control-Allow-Methods", "GET,POST,PUT,DELETE,OPTIONS");
response.setHeader("Access-Control-Allow-Headers", "Content-Type, Access-Control-Allow-Headers, Authorization, X-Request, X-Request, X-Requested-With");
response.sendJsonObject(stream);
}
void
UserProfileForm::OnTransactionHeaderCompleted(HttpSession& httpSession, HttpTransaction& httpTransaction, int headerLen, bool rs)
{
HttpResponse* pHttpResponse = httpTransaction.GetResponse();
if(pHttpResponse == null)
return;
HttpHeader* pHttpHeader = pHttpResponse->GetHeader();
if(pHttpHeader != null)
{
String* tempHeaderString = pHttpHeader->GetRawHeaderN();
AppLog("HeaderString=%ls\n",tempHeaderString->GetPointer());
}
AppLog("OnTransactionHeaderCompleted\n");
}
bool HttpServer::processRequest(HttpServerConnection &connection, HttpRequest &request, HttpResponse &response)
{
if (request.isWebSocket())
{
bool res = initWebSocket(connection, request, response);
if (!res) response.badRequest();
}
String path = request.getPath();
if (path.length() > 1 && path.endsWith("/"))
path = path.substring(0, path.length() - 1);
if (paths.contains(path))
{
paths[path](request, response);
return true;
}
if (defaultHandler)
{
debugf("Default server handler for: '%s'", path.c_str());
defaultHandler(request, response);
return true;
}
debugf("ERROR at server 404: '%s' not found", path.c_str());
return false;
}
void onIpConfig(HttpRequest &request, HttpResponse &response)
{
if (request.getRequestMethod() == RequestMethod::POST)
{
AppSettings.dhcp = request.getPostParameter("dhcp") == "1";
AppSettings.ip = request.getPostParameter("ip");
AppSettings.netmask = request.getPostParameter("netmask");
AppSettings.gateway = request.getPostParameter("gateway");
debugf("Updating IP settings: %d", AppSettings.ip.isNull());
AppSettings.save();
}
TemplateFileStream *tmpl = new TemplateFileStream("settings.html");
auto &vars = tmpl->variables();
bool dhcp = WifiStation.isEnabledDHCP();
vars["dhcpon"] = dhcp ? "checked='checked'" : "";
vars["dhcpoff"] = !dhcp ? "checked='checked'" : "";
if (!WifiStation.getIP().isNull())
{
vars["ip"] = WifiStation.getIP().toString();
vars["netmask"] = WifiStation.getNetworkMask().toString();
vars["gateway"] = WifiStation.getNetworkGateway().toString();
}
else
{
vars["ip"] = "192.168.1.77";
vars["netmask"] = "255.255.255.0";
vars["gateway"] = "192.168.1.1";
}
response.sendTemplate(tmpl); // will be automatically deleted
}
void onMqttConfig(HttpRequest &request, HttpResponse &response)
{
if (request.getRequestMethod() == RequestMethod::POST)
{
AppSettings.mqtt_password = request.getPostParameter("password");
AppSettings.mqtt_user = request.getPostParameter("user");
AppSettings.mqtt_server = request.getPostParameter("adr");
AppSettings.mqtt_period = request.getPostParameter("period").toInt();
AppSettings.mqtt_port = request.getPostParameter("port").toInt();
AppSettings.mqtt_nodeName = request.getPostParameter("nodeName");
//debugf("Updating MQTT settings: %d", AppSettings.ip.isNull());
AppSettings.save();
}
TemplateFileStream *tmpl = new TemplateFileStream("mqttsettings.html");
auto &vars = tmpl->variables();
vars["user"] = AppSettings.mqtt_user;
vars["password"] = AppSettings.mqtt_password;
vars["period"] = AppSettings.mqtt_period;
vars["port"] = AppSettings.mqtt_port;
vars["adr"] = AppSettings.mqtt_server;
vars["nodeName"] = AppSettings.mqtt_nodeName;
response.sendTemplate(tmpl); // will be automatically deleted
}
/*****************************************************************************
* Function - doGetCGI
* DESCRIPTION: HTTP GET with URL /get.cgi
****************************************************************************/
void WebIfHandler::doGetCGI(HttpRequest& req, HttpResponse& res)
{
if (req.HasParam("io_status"))
{
res.StartHTMLContent();
if (req.GetParam("io_status", "").compare("iob") == 0)
{
res << "<h2>IOB</h2><i>Status not implemented!</i>";
}
else if (req.GetParam("io_status", "").compare("io351iomodules") == 0)
{
for (int i = 0; i < sizeof(m_pIO351IOModules) / sizeof(m_pIO351IOModules[0]); i++)
{
if (i)
{
res << "<br/>";
}
res << "<h2>IO351 IO Module #" << (i + 1) << " Status</h2>";
if (m_pIO351IOModules[i])
m_pIO351IOModules[i]->webifMakeStatusHtml(res);
else
res << "<i>Pointer to IO351 IO Module not set!</i>";
}
}
else
{
res << "<b>Unhandled io_status=" << req.GetParam("io_status", "") << "</b>";
}
}
// firmware_update.html
if (req.HasParam("firmware_update"))
{
res.StartHTMLContent();
if (req.GetParam("firmware_update", "").compare("status") == 0)
{
FirmwareUpdateCtrl::GetInstance()->webifMakeStatus(res);
}
else
{
res << "<b>Unhandled firmware_update=" << req.GetParam("firmware_update", "") << "</b>";
}
}
}
void HttpServer::readCb(bufferevent *bev, void *ctx) {
size_t length = evbuffer_get_length(bufferevent_get_input(bev));
char *data = (char *) malloc(sizeof(char) * length);
evbuffer_remove(bufferevent_get_input(bev), data, length);
HttpRequestParser requestParser;
HttpRequest request;
HttpResponse response;
requestParser.reset();
requestParser.parse(request, data, length);
HttpRequestHandler requestHandler(rootDir_);
requestHandler.handleRequest(&request, &response);
evbuffer_add(bufferevent_get_output(bev), response.toString().c_str(), response.toString().length());
free(data);
}
void RpcServer::processRequest(const HttpRequest& request, HttpResponse& response) {
auto url = request.getUrl();
auto it = s_handlers.find(url);
if (it == s_handlers.end()) {
response.setStatus(HttpResponse::STATUS_404);
return;
}
if (url != "/json_rpc" && !checkCoreReady()) {
response.setStatus(HttpResponse::STATUS_500);
response.setBody("Core is busy");
return;
}
it->second(this, request, response);
}
void onVolume(HttpRequest &request, HttpResponse &response)
{
int channel = request.getQueryParameter("channel").toInt();
int value = request.getQueryParameter("value").toInt();
setVolume(channel, value);
JsonObjectStream* stream = new JsonObjectStream();
JsonObject& json = stream->getRoot();
json["status"] = (bool)true;
response.setAllowCrossDomainOrigin("*");
response.setHeader("Access-Control-Allow-Methods", "GET,POST,PUT,DELETE,OPTIONS");
response.setHeader("Access-Control-Allow-Headers", "Content-Type, Access-Control-Allow-Headers, Authorization, X-Request, X-Request, X-Requested-With");
response.sendJsonObject(stream);
}
bool RpcServer::processJsonRpcRequest(const HttpRequest& request, HttpResponse& response) {
using namespace JsonRpc;
response.addHeader("Content-Type", "application/json");
JsonRpcRequest jsonRequest;
JsonRpcResponse jsonResponse;
try {
logger(TRACE) << "JSON-RPC request: " << request.getBody();
jsonRequest.parseRequest(request.getBody());
jsonResponse.setId(jsonRequest.getId()); // copy id
static std::unordered_map<std::string, JsonMemberMethod> jsonRpcHandlers = {
{ "getblockcount", makeMemberMethod(&RpcServer::on_getblockcount) },
{ "on_getblockhash", makeMemberMethod(&RpcServer::on_getblockhash) },
{ "getblocktemplate", makeMemberMethod(&RpcServer::on_getblocktemplate) },
{ "getcurrencyid", makeMemberMethod(&RpcServer::on_get_currency_id) },
{ "submitblock", makeMemberMethod(&RpcServer::on_submitblock) },
{ "getlastblockheader", makeMemberMethod(&RpcServer::on_get_last_block_header) },
{ "getblockheaderbyhash", makeMemberMethod(&RpcServer::on_get_block_header_by_hash) },
{ "getblockheaderbyheight", makeMemberMethod(&RpcServer::on_get_block_header_by_height) }
};
auto it = jsonRpcHandlers.find(jsonRequest.getMethod());
if (it == jsonRpcHandlers.end()) {
throw JsonRpcError(JsonRpc::errMethodNotFound);
}
if (jsonRequest.getMethod() != "getcurrencyid" && !checkCoreReady()) {
throw JsonRpcError(CORE_RPC_ERROR_CODE_CORE_BUSY, "Core is busy");
}
it->second(this, jsonRequest, jsonResponse);
} catch (const JsonRpcError& err) {
jsonResponse.setError(err);
} catch (const std::exception& e) {
jsonResponse.setError(JsonRpcError(JsonRpc::errInternalError, e.what()));
}
response.setBody(jsonResponse.getBody());
logger(TRACE) << "JSON-RPC response: " << jsonResponse.getBody();
return true;
}
TEST(Packager, List)
{
QVariant var;
HttpResponse resp;
JsonPackager pack;
QList<QVariant> list;
list.append(QVariant("A"));
list.append(QVariant("B"));
list.append(QVariant("C"));
var.setValue(list);
ASSERT_TRUE(pack.Package(var, resp));
QString data = resp.GetBody();
ASSERT_EQ(QString("[ \"A\", \"B\", \"C\" ]\n"), resp.GetBody());
}
void RequestHandler::service(HttpRequest& request, HttpResponse& response) {
QByteArray path=request.getPath();
qDebug("Conroller: path=%s",path.data());
// Set a response header
response.setHeader("Content-Type", "text/html; charset=ISO-8859-1");
// Return a simple HTML document
response.write("<html><body>Hello World</body></html>",true);
qDebug("RequestHandler: finished request");
// Clear the log buffer
if (logger) {
logger->clear();
}
}
HttpResponse* listToResponse(HttpRequest* pRequest,
const Rcpp::List& response) {
using namespace Rcpp;
if (response.isNULL() || response.size() == 0)
return NULL;
CharacterVector names = response.names();
int status = Rcpp::as<int>(response["status"]);
std::string statusDesc = getStatusDescription(status);
List responseHeaders = response["headers"];
// Self-frees when response is written
DataSource* pDataSource = NULL;
// The response can either contain:
// - bodyFile: String value that names the file that should be streamed
// - body: Character vector (which is charToRaw-ed) or raw vector, or NULL
if (std::find(names.begin(), names.end(), "bodyFile") != names.end()) {
FileDataSource* pFDS = new FileDataSource();
pFDS->initialize(Rcpp::as<std::string>(response["bodyFile"]),
Rcpp::as<bool>(response["bodyFileOwned"]));
pDataSource = pFDS;
}
else if (Rf_isString(response["body"])) {
RawVector responseBytes = Function("charToRaw")(response["body"]);
pDataSource = new RawVectorDataSource(responseBytes);
}
else {
RawVector responseBytes = response["body"];
pDataSource = new RawVectorDataSource(responseBytes);
}
HttpResponse* pResp = new HttpResponse(pRequest, status, statusDesc,
pDataSource);
CharacterVector headerNames = responseHeaders.names();
for (R_len_t i = 0; i < responseHeaders.size(); i++) {
pResp->addHeader(
std::string((char*)headerNames[i], headerNames[i].size()),
Rcpp::as<std::string>(responseHeaders[i]));
}
return pResp;
}
void brain_stroke_web::service(HttpRequest &request, HttpResponse &response){
QLOG_ERROR() << "debug thread" << QThread::currentThread();
QByteArray path = request.getPath();
if(path =="/getallversion"){
get_version_controller_ins.service(request,response);
return;
}
else if (path == "/getfile") {
download_version_controller_ins.service(request,response);
return;
}
else if (path == "/rename"){
//POST
if(request.getMethod() != "POST"){
netutil::write(response, 401, "wrong method");
return;
}
rename_version_controller_ins.service(request,response);
return;
}
else if(path == "/delete"){
//POST
if(request.getMethod() != "POST"){
netutil::write(response, 401, "wrong method");
return;
}
delete_version_controller_ins.service(request,response);
return;
}
else if(path.startsWith("/data")){
QString key = request.getParameter("key");
if(key != QString(inner_data_trans_key)){
response.setStatus(401,"key error");
response.write("key error");
}
else{
StaticFileController_ins->service(request,response);
return;
}
}
else{
response.setStatus(401,"no matched request");
response.write("no matched request", false);
}
}
void download_version_controller::service(HttpRequest &request, HttpResponse &response){
QString version_name = request.getParameter("version_name");
QString pid = request.getParameter("pid");
if(pid == "" || version_name == ""){
QLOG_ERROR() << "input para wrong pid, version" << "download_version_controller";
response.setStatus(401,"para error");
response.write("para error");
return;
}
QDir result_dir = Config::single() -> mp["pdata_dir"] + "/" + pid + "/result/" + version_name;
if(!result_dir.exists()){
response.setStatus(401,"data not exists");
response.write("data not exists");
return;
}
QProcess process;
process.setWorkingDirectory(Config::single() -> mp["pdata_dir"] + "/" + pid + "/result");
process.start("zip -r " + version_name + ".zip " + version_name);
bool ret_code = process.waitForFinished();
if(!ret_code){
response.setStatus(401,"zip error");
response.write("zip error");
}
response.redirect(("/data/"+ pid + "/result/" + version_name + ".zip?key=" + QString(inner_data_trans_key)).toUtf8()) ;
}
