curl
#include <app/fusion/curl_post.hpp>
#include <terrace/thirdparty/spdlog/spdlog.h>
using namespace std;
Curl::Curl()
{
curl _global_init(CURL_GLOBAL_ALL) ;
curl_ = curl_easy_init();
}
Curl::~Curl()
{
curl _global_cleanup();
}
bool Curl::post(string &addr, string &json_str, vector<string> &image jpeg, string &encoded_video_data)
{
CURLcode res;
struct curl_httppost *formpost = NULL;
struct curl_httppost *lastptr = NULL;
struct curl_slist *headerlist = NULL;
static const char buf[] = "Expect:";
if (NULL != curl_) {
curl_formadd(&formpost, &lastptr, CURLFORM_COPYNAME, "json_info",CURLFORM_COPYCONTENTS,json_str.c_str(),CURLFORM_END);
if (image_jpeg.size() == 1) {
curl_formadd(&formpost, &lastptr,
CURLFORM_COPYNAME, "image",
CURLFORM_BUFFER, "image.jpg",
CURLFORM_BUFFERPTR, image_jpeg[0].c_str(),
CURLFORM_BUFFERLENGTH, image_jpeg[0].size(),
CURLFORM_END);
} else {
for (int i = 0; i < image jpeg.size(); i++) {
string image_name = "image" + to_string(i);
string image_buffer = "image" + to_string(i) + ".jpg";
curl_formadd(&formpost, &lastptr,
CURLFORM_COPYNAME, image_name.c_str(),
CURLFORM_BUFFER, image_buffer.c_str(),
CURLFORM_BUFFERPTR, image _jpeg[i].c_str(),
CURLFORM_BUFFERLENGTH, image jpeg[i].size(),
CURLFORM_END);
}
}
if (!encoded_video_data.empty())
{
curl_formadd(&formpost, &lastptr,
CURLFORM_COPYNAME, "video",
CURLFORM_BUFFER, "video.mp4",
CURLFORM_BUFFERPTR, encoded_video _data.c_str(),
CURLFORM_BUFFERLENGTH, encoded_video_data.size(),
CURLFORM_END) ;
}
headerlist = curl_slist_append(headerlist, buf);
curl_easy_setopt(curl_, CURLOPT_URL, addr.c_str());
curl_easy_setopt(curl_, CURLOPT_NOSIGNAL, 1L);
curl_easy_setopt(curl_, CURLOPT_TIMEOUT, 10L);
curl_easy_setopt(curl_, CURLOPT_CONNECTTIMEOUT, 5L);
curl_easy_setopt(curl_, CURLOPT_HTTPHEADER, headerlist);
curl_easy_setopt(curl_, CURLOPT_HTTPPOST, formpost);
auto time = chrono: :high_resolution_clock: :now();
res = curl _easy_perform(curl_);
auto time_elapsed = chrono: :duration_cast<chrono: :microseconds>(chrono: :high_resolution_clock::now() - time) .count();
float time_seconds = time_elapsed / 1000000.f;
spdlog:: debug("post time: {}", time_seconds);
if (res != 0)
{
spdlog::error("post back failed: {}", curl_easy strerror(res));
}
curl_formfree(formpost) ;
curl_slist_free_all(headerlist) ;
}
return true;
}
int Curl::post(const string &addr, const string &info, const string *resp) {
CURLcode res;
struct curl_httppost *formpost = NULL;
struct curl_httppost *lastptr = NULL;
struct curl_slist *headerlist = NULL;
static const char buf[] = "Expect:";
if (NULL != curl_) {
curl_formadd(&formpost, &lastptr, CURLFORM_COPYNAME, "info", CURLFORM_COPYCONTENTS, info.c_str(), CURLFORM_END);
headerlist = curl_slist_append(headerlist, buf);
curl_easy_setopt(curl_, CURLOPT_SSL_VERIFYPEER, false);
curl_easy_setopt(curl_, CURLOPT_SSL_VERIFYHOST, false);
curl_easy_setopt(curl_, CURLOPT_URL, (char *)addr.c_str());
curl_easy_setopt(curl_, CURLOPT_TIMEOUT, 5);
curl_easy_setopt(curl_, CURLOPT_CONNECTTIMEOUT_MS, 5000);
curl_easy_setopt(curl_, CURLOPT_NOSIGNAL, 1);
curl_easy_setopt(curl_, CURLOPT_HTTPHEADER, headerlist);
curl_easy_setopt(curl_, CURLOPT_HTTPPOST, formpost) ;
curl_easy_setopt(curl_, CURLOPT_WRITEFUNCTION, write_data_json) ;
curl_easy_setopt(curl_, CURLOPT_WRITEDATA, (void *)resp);
auto time = chrono: :high resolution_clock: :now();
res = curl_easy_perform(curl_);
auto time_elapsed = chrono: :duration_cast<chrono: :microseconds>(chrono: :high_resolution_clock: :now({) - time) .count();
float time_seconds = time_elapsed / 1000000.f;
if (res != CURLE_OK) {
spdlog::error("post back failed: {}, post time {}s", curl_easy_strerror(res), time_seconds);
return false;
}
curl_formfree(formpost) ;
curl slist_free_all(headerlist);
}
return true;
}
size_t write_data_json(void *ptr, size_t size, size_t nmemb, void *stream)
{
string *str = (string *)stream;
(*str).append((char *)ptr, size * nmemb);
return size * nmemb;
}
#include <unistd.h>
#include <set>
#include <string.h>
#include <time.h>
#include <curl/curl.h>
#include <string>
#include <stdio.h>
#include <vector>
#include <iostream>
#include <fstream>
#include <sstream>
#include <chrono>
class Curl
{
public:
Curl();
~Curl();
bool post(std::string &addr, std::string &json_str, std::vector<std::string> &image_jpeg, std::string &encoded_video_data);
int post(const std::string &addr, const std::string &info, const std::string *resp);
int device_id_;
CURL *curl ;
};
size_t write_data_json(void *ptr, size_t size, size_t nmemb, void *stream);
python
import os
import json
from traceback import srint_tk
import requests
import base64
import multiprocessing
import shutil
import pandas as pd
import numpy as rp
from tqdm import tqdm
testimgs_addr = "http://127.0.@.1:8810/api/iqa_image_process"
my_task={}
path="/data2/iqa/baitian"
def post_images(pic_Lists):
global path
for pic in tqdm(pic_Lists):
pic_path=os.path. join(path, pic)
img=open(pic_path, "rb").read()
my_files = {'image_content' : ('image.jpg',img )}
my_task["device_id"] ="135456"
r = requests.post(testimgs_addr,files=my_files,data= my_task)
res_join = json.loads(r.text)
mpic_Lists=os. listdir(path)
img_len=int(len(mpic_Lists)/5)
test_parm=[mpic_Lists[:img_len],mpic_Lists[img_len:2*img_len],mpic_Lists[2*img_len:3*img_len],mpic_Lists[3*img_len:4*img_len],mpic_Lists[4*img_len:]]
pool=multiprocessing.Pool(5)
pool ,map(post_images, test_parm)
pool.close()
pool. join()
from email.mime import image
import tornado.ioloop
import tornado.web
import json
import cv2
import numpy as np
import time
import os,uwuid
import hashlib
a= 0
def mkdir(path):
if not (os.path.exists(path)):
os.makedirs(path)
def get_img(pic, image_name):
if len(pic) > 2000:
tmp = np.asarray(bytearray(pic), dtype="uint8")
img = cv2.imdecode(tmp, cv2.IMREAD_COLOR)
cv2.imwrite(image_name, img)
else:
print("pic error")
class MainHandler (tornado. web. RequestHandler):
def get(self):
self.write("Hello, world")
def post(self):
global a
body = self.request.body
print("len{body): ", len(body))
print("len(files): ", len(self.request.files))
json_info = self.get_body_arguments("json_info")[0]
j = json. loads(json_info)
localtime = time. localtime(time.time())
dir_ = str(localtime. tm_mday)+"_"+str(localtime.tm_hour)
save_path = os.path.join(dir_, j["device_id"])
if not os.path.exists(save_path):
mkdir (save_path)
if "video_quality" in j and j["video_quality"]== -1:
randomByteArray = bytearray(os.urandom( 126680) )
flatNumpyArray = np.array(randomByteArray)
bgrImage = flatNumpyArray.reshape(100,400, 3)
image_name=str(a)+"_-1. jpg"
cv2.imwrite(os.path.join(save_path, image_name),bgrImage)
else:
if "image_quality" in j:
for k, v in self.request.files.items():
if "image" in k:
image = v[0]["body"]
image_name=str(a)+"_"+str(j["image_quality"])+"_"+str(round(j["classification_prob"],3))+".jpg"
get_img(image, os.path.join(save_path, image name) )
a =a+1
elif "video" in k:
video = v[0]["body"]
if j["save_video"]:
if len(video) > 2000:
with open(save_path + "/video.mp4","wb") as f:
f.write(video)
else:
print("save_video error: ", video)
def make_app():
return tornado.web.Application([
(r"/", MainHandler),
])
if __name__ == "main ":
app = make_app()
app. listen(8090)
tornado.ioloop.IOLoop.current().start()