//External Includes
#include <catch.hpp>
//System Namespaces
using std::string;
using std::multimap;
//Project Namespaces
using restbed::Response;
//External Namespaces
TEST_CASE( "validate default instance values", "[response]" )
{
const Response response;
REQUIRE( response.get_version( ) == 1.1 );
REQUIRE( response.get_status_code( ) == 200 );
REQUIRE( response.get_protocol( ) == "HTTP" );
REQUIRE( response.get_headers( ).empty( ) );
REQUIRE( response.get_status_message( ).empty( ) );
REQUIRE( response.get_request( ) == nullptr );
}
TEST_CASE( "confirm default destructor throws no exceptions", "[response]" )
{
auto response = new Response;
REQUIRE_NOTHROW( delete response );
}
int main(int argc, char* argv[])
{
int ret = 1;
try {
memPool.reserve(1 << 20);
unique_ptr<Journ> journ;
unique_ptr<Model> model;
if (argc > 1) {
Conf conf;
conf.set("sqlite_journ", argv[1]);
conf.set("sqlite_model", argv[1]);
journ = swirly::makeJourn(conf);
model = swirly::makeModel(conf);
} else {
journ = make_unique<TestJourn>();
model = make_unique<TestModel>();
}
const BusinessDay busDay{RollHour, NewYork};
const auto now = UnixClock::now();
Serv serv{*journ, 1 << 10, 1 << 4};
serv.load(*model, now);
model = nullptr;
auto& market = createMarket(serv, "EURUSD"_sv, busDay(now), 0, now);
auto& eddayl = serv.accnt("EDDAYL"_sv);
auto& gosayl = serv.accnt("GOSAYL"_sv);
auto& marayl = serv.accnt("MARAYL"_sv);
auto& pipayl = serv.accnt("PIPAYL"_sv);
Profile maker{"maker"_sv};
Profile taker{"taker"_sv};
Archiver arch{serv};
Response resp;
for (int i = 0; i < 25100; ++i) {
// Reset profiles after warmup period.
if (i == 100) {
maker.clear();
taker.clear();
}
// Maker sell-side.
{
TimeRecorder tr{maker};
resp.clear();
serv.createOrder(gosayl, market, ""_sv, Side::Sell, 10_lts, 12348_tks, 1_lts, now, resp);
}
{
TimeRecorder tr{maker};
resp.clear();
serv.createOrder(marayl, market, ""_sv, Side::Sell, 10_lts, 12348_tks, 1_lts, now, resp);
}
{
TimeRecorder tr{maker};
resp.clear();
serv.createOrder(gosayl, market, ""_sv, Side::Sell, 10_lts, 12347_tks, 1_lts, now, resp);
}
{
TimeRecorder tr{maker};
resp.clear();
serv.createOrder(marayl, market, ""_sv, Side::Sell, 5_lts, 12347_tks, 1_lts, now, resp);
}
{
TimeRecorder tr{maker};
resp.clear();
serv.createOrder(gosayl, market, ""_sv, Side::Sell, 5_lts, 12346_tks, 1_lts, now, resp);
}
// Maker buy-side.
{
TimeRecorder tr{maker};
resp.clear();
serv.createOrder(marayl, market, ""_sv, Side::Buy, 5_lts, 12344_tks, 1_lts, now, resp);
}
{
TimeRecorder tr{maker};
resp.clear();
serv.createOrder(gosayl, market, ""_sv, Side::Buy, 5_lts, 12343_tks, 1_lts, now, resp);
}
{
TimeRecorder tr{maker};
resp.clear();
serv.createOrder(marayl, market, ""_sv, Side::Buy, 10_lts, 12343_tks, 1_lts, now, resp);
}
{
TimeRecorder tr{maker};
resp.clear();
serv.createOrder(gosayl, market, ""_sv, Side::Buy, 10_lts, 12342_tks, 1_lts, now, resp);
}
{
TimeRecorder tr{maker};
resp.clear();
serv.createOrder(marayl, market, ""_sv, Side::Buy, 10_lts, 12342_tks, 1_lts, now, resp);
}
// Taker sell-side.
{
TimeRecorder tr{taker};
resp.clear();
serv.createOrder(eddayl, market, ""_sv, Side::Sell, 40_lts, 12342_tks, 1_lts, now, resp);
}
// Taker buy-side.
{
TimeRecorder tr{taker};
resp.clear();
serv.createOrder(pipayl, market, ""_sv, Side::Buy, 40_lts, 12348_tks, 1_lts, now, resp);
}
arch(eddayl, market.id(), now);
arch(gosayl, market.id(), now);
arch(marayl, market.id(), now);
arch(pipayl, market.id(), now);
}
ret = 0;
} catch (const exception& e) {
SWIRLY_ERROR(logMsg() << "exception: " << e.what());
}
return ret;
}
Response kConnection::receive_response() {
Response r;
auto s = readmessage();
r.ParseFromString(s);
return r;
}
void TabMessage::messageSent(const Response &response)
{
if (response.response_code() == Response::RespInIgnoreList)
chatView->appendMessage(tr("This user is ignoring you."));
}
bool LayoutEditor::setCSSPropertyValueInCurrentRule(const String& value) {
Response response = m_cssAgent->setLayoutEditorValue(
m_element.get(), m_matchedStyles.at(m_currentRuleIndex),
m_changingProperty, value, false);
return response.isSuccess();
}
void
grandet_fetch_task_wait(grandet_fetch_task_t task) {
task->lock.lock();
if (task->finished == 0 && task->canceled == 0) {
INFO("grandet_fetch_task processing\n");
Request req;
req.set_type(Request::GET);
req.set_key(task->key);
Request::Requirements *reqm = req.mutable_requirements();
reqm->set_latency_required(_latency_requirement);
reqm->set_bandwidth_required(_bandwidth_requirement);
tcp::iostream *conn;
conn_get(conn);
if (!_write_message(*conn, req)) {
DEBUG("grandet_fetch_task failed to write\n");
task->canceled = 1;
task->finished = 1;
conn_put(conn);
task->lock.unlock();
return;
}
Response reply;
if (!_read_message(*conn, reply)) {
DEBUG("grandet_fetch_task failed to read response\n");
task->canceled = 1;
task->finished = 1;
conn_put(conn);
task->lock.unlock();
return;
}
conn_put(conn);
if (reply.status() != Response::OK) {
DEBUG("grandet_fetch_task failed\n");
task->canceled = 1;
} else {
ostringstream o;
o << task->data_path << "_XXXXXX";
char *tmp_path = strdup(o.str().c_str());
int tmp_fh = mkstemp(tmp_path);
const Value &val = reply.value();
if (val.has_data()) {
const string &data = val.data();
INFO("grandet_fetch_task fetch data length %d\n", data.length());
const char *buf = data.c_str();
int length = data.length();
if (length > task->size) length = task->size;
while (length > 0) {
int w = write(tmp_fh, buf, length);
if (w < 0) {
DEBUG("grandet_fetch_task write failed\n");
task->canceled = 1;
break;
}
length -= w;
buf += w;
}
ftruncate(tmp_fh, task->size);
}
close(tmp_fh);
if (!task->canceled) {
int r = rename(tmp_path, task->data_path);
INFO("rename %s to %s ret %d\n", task->tmp_path, task->data_path, r == -1 ? errno : r);
} else {
unlink(tmp_path);
}
}
task->finished = 1;
}
task->lock.unlock();
}
int main(int argc, char **argv)
{
if (argc < 2) {
fprintf(stderr, "Usage: %s ADDRESS...\n", argv[0]);
return 2;
}
const char *progname = strrchr(argv[0], '/');
if (progname)
progname++;
else
progname = argv[0];
openlog(progname, LOG_CONS | LOG_NDELAY | LOG_PID, LOG_USER);
magic_cookie = magic_open(MAGIC_MIME_TYPE);
if (magic_load(magic_cookie, nullptr) < 0) {
syslog(LOG_CRIT, "magic: %s", strerror(errno));
return 1;
}
Magick::InitializeMagick(argv[0]);
zmq::context_t context(1);
zmq::socket_t socket(context, ZMQ_REP);
try {
for (int i = 1; i < argc; i++)
socket.bind(argv[i]);
while (true) {
IO io(socket);
if (!io.receive()) {
syslog(LOG_ERR, "request message was too short");
continue;
}
Request request;
Response response;
if (!decode_request(io.request.first, request)) {
syslog(LOG_ERR, "could not decode request header");
continue;
}
const char *mimetype = magic_buffer(magic_cookie, io.request.second.data(), io.request.second.size());
response.set_source_type(mimetype);
if (mimetype && (strcmp(mimetype, "image/bmp") == 0 ||
strcmp(mimetype, "image/gif") == 0 ||
strcmp(mimetype, "image/jpeg") == 0 ||
strcmp(mimetype, "image/png") == 0)) {
try {
Magick::Blob blob(io.request.second.data(), io.request.second.size());
Magick::Image image(blob);
convert_image(image, request.scale(), request.crop());
response.set_nail_width(image.size().width());
response.set_nail_height(image.size().height());
write_jpeg(image, io.response.second);
} catch (const Magick::Exception &e) {
syslog(LOG_ERR, "magick: %s", e.what());
continue;
}
}
encode_response(response, io.response.first);
io.handled = true;
}
} catch (const zmq::error_t &e) {
syslog(LOG_CRIT, "zmq: %s", e.what());
}
return 1;
}
bool FTPClient::processRequest(char* input)
{
Request r;
int ret_val = r.parseTerminalCommand(input);
if (ret_val == 2)
return false;
if(r.getCommand () == PWD)
{
controlSocket.send (r.getRequestString ());
string recv_str = controlSocket.recv (RECV_SIZE);
Response res = Response::parseResponse (recv_str);
cout << recv_str;
}
else if (r.getCommand () == CWD)
{
controlSocket.send (r.getRequestString ());
string recv_str = controlSocket.recv (RECV_SIZE);
Response res = Response::parseResponse (recv_str);
cout << recv_str;
}
else if (r.getCommand () == LIST)
{
Socket datSock;
if (!establishPORT (datSock))
{
cerr << "ERROR: Data connection failed." << endl;
return false;
}
controlSocket.send (r.getRequestString ());
string recv_str = controlSocket.recv (RECV_SIZE);
cout << recv_str << "\n";
while ((recv_str = datSock.recv (RECV_SIZE)).length () > 0)
{
cout << recv_str;
}
datSock.close ();
recv_str = controlSocket.recv (RECV_SIZE);
cout << "\n" << recv_str;
}
else if (r.getCommand () == RETR)
{
Socket datSock;
if (!establishPORT (datSock))
{
cerr << "ERROR: Data connection failed." << endl;
return false;
}
controlSocket.send (r.getRequestString ());
string recv_str = controlSocket.recv (RECV_SIZE);
Response res = Response::parseResponse (recv_str);
if (res.getReturnCode () == FILE_NOT_FOUND)
{
cout << recv_str;
datSock.close ();
return false;
}
cout << recv_str;
ofstream out_file;
out_file.open (r.getArg ().c_str (), ios::out);
if (!out_file.is_open ())
{
cerr << "ERROR! Could not open file." << endl;
datSock.close ();
return false;
}
char recv_str_data[RECV_SIZE];
int recv_len;
while ((recv_len = datSock.recv (recv_str_data, RECV_SIZE)) > 0)
{
out_file.write (recv_str_data, recv_len);
}
datSock.close ();
out_file.close ();
recv_str = controlSocket.recv (RECV_SIZE);
cout << recv_str;
}
else if (r.getCommand () == STOR)
{
Socket datSock;
if (!establishPORT (datSock))
{
cerr << "ERROR! Data connection failed." << endl;
return false;
}
controlSocket.send (r.getRequestString ());
string recv_str = controlSocket.recv (RECV_SIZE);
Response res = Response::parseResponse (recv_str);
if (res.getReturnCode () == FILE_NOT_FOUND)
{
cout << recv_str;
datSock.close ();
return false;
}
cout << recv_str;
ifstream in_file;
string args = r.getArg ();
in_file.open (args.c_str (), ios::in | ios::ate);
if (!in_file.is_open ())
{
cerr << "ERROR! Could not open file." << endl;
datSock.close ();
return false;
}
int file_len = (int)in_file.tellg ();
in_file.seekg (0, ios::beg);
char* file_data = new char[file_len] ();
in_file.read (file_data, file_len);
datSock.send (file_data, file_len);
datSock.close ();
in_file.close ();
recv_str = controlSocket.recv (RECV_SIZE);
cout << recv_str;
delete[] file_data;
}
else if (r.getCommand () == QUIT)
{
controlSocket.send (r.getRequestString ());
string recv_str = controlSocket.recv (RECV_SIZE);
cout << recv_str;
return true;
}
return false;
}
// check if limit state surface has been reached
int
ShearCurve::checkElementState(double springForce)
{
DummyStream dummy;
// find associated beam-column elementon first visit
if (theElement == 0)
{
theElement = theDomain->getElement(eleTag);
if (theElement == 0) {
// g3ErrorHandler->fatal("WARNING ShearCurve - no element with tag %i exists in Domain",eleTag);
}
// find length between nodes if drift is desired
if (defType == 2)
{
Node *nodeI = theDomain->getNode(ndI);
Node *nodeJ = theDomain->getNode(ndJ);
const Vector &crdI = nodeI->getCrds();
const Vector &crdJ = nodeJ->getCrds();
if (crdI(perpDirn) == crdJ(perpDirn)) {
// g3ErrorHandler->warning("%s -- Nodal projection has zero component along chosen direction",
// "AxialCurve::AxialCurve");
oneOverL = 0.0;
}
else
oneOverL = 1.0/fabs(crdJ(perpDirn) - crdI(perpDirn));
}
}
double deform; // value of deformation parameter from element
double force; // value of force parameter from element
int result; //junk variable
// Based on "defType" and "forType" calculate
// the desired response parameters "deform" and "force"
if (defType == 1) // maximum chord rotations
{
Response *theRotations =0; // integer element returns in setResponse
const char *r[1] = {"basicDeformations"}; // must be implemented in element
Vector *rotVec; //vector of chord rotations at beam-column ends
// set type of beam-column element response desired
theRotations = theElement->setResponse(r, 1, dummy);
// put element response in the vector of "myInfo"
result = theRotations->getResponse();
// access the myInfo vector containing the response (new for Version 1.2)
Information &theInfo = theRotations->getInformation();
rotVec = (theInfo.theVector);
deform = (fabs((*rotVec)(1)) > fabs((*rotVec)(2))) ?
fabs((*rotVec)(1)) : fabs((*rotVec)(2)); //use larger of two end rotations
}
else if (defType == 2) // interstory drift
{
// find associated nodes
Node *nodeI = theDomain->getNode(ndI);
Node *nodeJ = theDomain->getNode(ndJ);
// get displacements
const Vector &dispI = nodeI->getTrialDisp();
const Vector &dispJ = nodeJ->getTrialDisp();
//opserr << "Drift ndI: " << dispI(dof) << endln;
//opserr << "Drift ndJ: " << dispJ(dof) << endln;
// calc drift
double dx = fabs(dispJ(dof)-dispI(dof));
deform = dx*oneOverL;
}
else {
// g3ErrorHandler->fatal("WARNING ShearCurve - deformation type flag %i not implemented",defType);
}
Response *theForces =0;
const char *f[1] = {"localForce"}; // does not include influence of P-delta
// for P-delta use forType = 0
Vector *forceVec; //vector of basic forces from beam column
// set type of beam-column element response desired
theForces = theElement->setResponse(f, 1, dummy);
// put element response in the vector of "myInfo"
result += theForces->getResponse();
// access the myInfo vector containing the response (new for Version 1.2)
Information &theInfo = theForces->getInformation();
forceVec = (theInfo.theVector);
// Local forces (assuming no element loads)
if (forType == 0)
force = fabs(springForce); // force in associated LimitState material
else if (forType == 1)
force = fabs((*forceVec)(1)); // shear
else if (forType == 2)
force = fabs((*forceVec)(0)); // axial
else {
// g3ErrorHandler->fatal("WARNING ShearCurve - force type flag %i not implemented",forType);
}
P = fabs((*forceVec)(0));
// Determine if (deform,force) is outside limit state surface.
//
// Use absolute value of deform and force
double forceSurface = findLimit(deform); // force on surface at deform
// double deformSurface = findLimit(force); // deform on surface at force SDK
//opserr << "The shear force in the element is: " << force << endln;
//opserr << "State flag............................:" << stateFlag << endln;
//opserr << "Shear force in the column.........: " << force << endln;
//opserr << "forceSurface: " << forceSurface << endln;
if (stateFlag == 0) //prior to failure
{
if (force >= forceSurface) // on/outside failure surface
// if (deform >= deformSurface) // on/outside failure surface SDK
{
stateFlag = 1;
setDegSlope(force, deform);
// g3ErrorHandler->warning("ShearCurve - failure detected at deform = %f (Kdeg = %f) ", deform, Kdeg);
//opserr << "*********************" << endln;
opserr << "ShearCurve - failure detected....."<< endln;//SDK
// opserr << "deformSurface: " << deformSurface << endln; //SDK
//opserr << "Capacity: " << forceSurface << endln;
//opserr << "*********************" << endln;
}
else // inside failure surface
{
stateFlag = 0;
}
}
else //after failure
{
if (force >= forceSurface) // on/outside failure surface
// if (deform >= deformSurface) // on/outside failure surface SDK
{
stateFlag = 2;
}
else // inside failure surface
{
stateFlag = 3;
}
}
return stateFlag;
}
//---------------------------------------------------------------------
void DefaultWorkQueueBase::processRequestResponse(Request* r, bool synchronous)
{
Response* response = processRequest(r);
OGRE_LOCK_MUTEX(mProcessMutex);
RequestQueue::iterator it;
for( it = mProcessQueue.begin(); it != mProcessQueue.end(); ++it )
{
if( (*it) == r )
{
mProcessQueue.erase( it );
break;
}
}
if( mIdleProcessed == r )
{
mIdleProcessed = 0;
}
if (response)
{
if (!response->succeeded())
{
// Failed, should we retry?
const Request* req = response->getRequest();
if (req->getRetryCount())
{
addRequestWithRID(req->getID(), req->getChannel(), req->getType(), req->getData(),
req->getRetryCount() - 1);
// discard response (this also deletes request)
OGRE_DELETE response;
return;
}
}
if (synchronous)
{
processResponse(response);
OGRE_DELETE response;
}
else
{
if( response->getRequest()->getAborted() )
{
// destroy response user data
response->abortRequest();
}
// Queue response
OGRE_LOCK_MUTEX(mResponseMutex);
mResponseQueue.push_back(response);
// no need to wake thread, this is processed by the main thread
}
}
else
{
if (!r->getAborted())
{
// no response, delete request
LogManager::getSingleton().stream() <<
"DefaultWorkQueueBase('" << mName << "') warning: no handler processed request "
<< r->getID() << ", channel " << r->getChannel()
<< ", type " << r->getType();
}
OGRE_DELETE r;
}
}
void execute(const Request&, Response& response) {
response.set_frame_size(1520);
response.set_link_technology("Ethernet");
response.set_speed_gbps(1);
response.set_autosense(true);
response.set_mac_address("AA:BB:CC:DD:EE:FF");
response.set_ipv4_address({"10.0.2.2",
"255.255.255.0",
"DHCP",
"10.0.2.1"});
response.set_ipv6_address({"fe80::1ec1:deff:fe6f:1c37",
16,
"DHCP",
"Perferred"});
response.set_neighbor_info({"123e4567-e89b-12d3-a456-426655440000",
"19"});
response.set_vlan_enable(true);
response.set_vlan_count(1);
response.set_status({"Enabled", "OK"});
}
#include <corvusoft/restbed/byte.hpp>
#include <corvusoft/restbed/response.hpp>
//External Includes
#include <catch.hpp>
//System Namespaces
//Project Namespaces
using restbed::Bytes;
using restbed::Response;
//External Namespaces
TEST_CASE( "validate default instance values", "[response]" )
{
const Response response;
REQUIRE( response.get_body( ).empty( ) );
}
TEST_CASE( "validate setters modify default values", "[response]" )
{
Bytes expectation = { 'a', 'b' };
Response response;
response.set_body( expectation );
const auto body = response.get_body( );
REQUIRE( body == expectation );
}
