void SCIpcClient::readIDEData() {
mIpcData.append(mSocket->readAll());
// After we have put the data in the buffer, process it
int avail = mIpcData.length();
do {
if (mReadSize == 0 && avail > 4){
mReadSize = ArrayToInt(mIpcData.left(4));
mIpcData.remove(0, 4);
avail -= 4;
}
if (mReadSize > 0 && avail >= mReadSize){
QByteArray baReceived(mIpcData.left(mReadSize));
mIpcData.remove(0, mReadSize);
mReadSize = 0;
avail -= mReadSize;
QDataStream in(baReceived);
in.setVersion(QDataStream::Qt_4_6);
QString selector;
QVariantList argList;
in >> selector;
if (in.status() != QDataStream::Ok)
return;
in >> argList;
if (in.status() != QDataStream::Ok)
return;
onResponse(selector, argList);
}
} while ((mReadSize == 0 && avail > 4) || (mReadSize > 0 && avail > mReadSize));
}
void Session::establish(int credentialsId)
{
m_identity = SignOn::Identity::existingIdentity(credentialsId, this);
// TODO:
if (!m_identity) {
SignOn::IdentityInfo info;
info.setCaption("Evernote");
info.setMethod("evernote", QStringList() << "AuthLogin");
m_identity = SignOn::Identity::newIdentity(info, this);
}
m_session = m_identity->createSession("evernote");
qDebug() << Q_FUNC_INFO << m_identity << credentialsId << m_session;
connect(m_session, SIGNAL(error(SignOn::Error)),
this, SLOT(onError(SignOn::Error)));
connect(m_session, SIGNAL(response(SignOn::SessionData)),
this, SLOT(onResponse(SignOn::SessionData)));
connect(m_session, SIGNAL(stateChanged(AuthSession::AuthSessionState,QString)),
this, SLOT(onStateChanged(AuthSession::AuthSessionState,QString)));
m_session->process(SignOn::SessionData(), "AuthLogin");
}
TEST(GTestDns, TestHttpGet) {
GTestOnEnd::clear();
GTestHttpClientOnResponse::clear();
String::CPtr url = String::create("http://nodejs.org");
JsObject::Ptr headers = JsObject::create();
#ifdef USE_PROXY
String::CPtr host = String::create("nodejs.org");
String::CPtr proxyHost = String::create("proxy");
String::CPtr proxyPort = String::create("8080");
JsObject::Ptr options = JsObject::create();
options->put(http::OPTION_HEADERS, headers);
options->put(http::OPTION_PATH, url);
options->put(http::OPTION_HOST, proxyHost);
options->put(http::OPTION_PORT, proxyPort);
headers->put(http::HEADER_HOST, host);
#else
JsObject::Ptr options = url::parse(url);
#endif
headers->put(http::HEADER_CONNECTION, String::create("close"));
GTestHttpClientOnResponse::Ptr onResponse(new GTestHttpClientOnResponse());
http::get(options, onResponse);
node::run();
JsArray::CPtr msgs = GTestOnEnd::messages();
JsArray::CPtr codes = GTestHttpClientOnResponse::statusCodes();
ASSERT_EQ(1, msgs->length());
ASSERT_EQ(1, codes->length());
ASSERT_TRUE(msgs->getCPtr<String>(0));
ASSERT_TRUE(codes->get(0).equals(200));
// console::log(msgs->get(0));
}
void ScProcess::onIpcData()
{
mIpcData.append(mIpcSocket->readAll());
while (mIpcData.size()) {
QBuffer receivedData ( &mIpcData );
receivedData.open ( QIODevice::ReadOnly );
QDataStream in ( &receivedData );
in.setVersion ( QDataStream::Qt_4_6 );
QString selector, message;
in >> selector;
if ( in.status() != QDataStream::Ok )
return;
in >> message;
if ( in.status() != QDataStream::Ok )
return;
mIpcData.remove ( 0, receivedData.pos() );
onResponse(selector, message);
emit response(selector, message);
}
}
void FinderActor::onNewAnswer(Peer::SPtr peer, Packet::SPtr pkt) {
if (pkt->method == M_FOUND && pkt->status == 0 && pkt->count > 0) {
auto peers = pkt->foundPeers;
for(auto peerToAdd = peers->begin(); peerToAdd != peers->end(); peerToAdd ++) {
addToShortList(*peerToAdd);
addToFoundPeers(*peerToAdd);
}
}
//Acknowledge that we received a query
onResponse();
}
TEST(GTestHttpEcho, TestConnectionClose) {
GTestOnEnd::clear();
GTestOnClose::clear();
GTestHttpServerOnEnd::clear();
GTestHttpClientOnResponse::clear();
String::CPtr msg = String::create("xyz");
http::Server::Ptr srv = http::Server::create();
GTestHttpServerOnRequest::Ptr onRequest(
new GTestHttpServerOnRequest(srv, NUM_REQS));
srv->on(http::Server::EVENT_REQUEST, onRequest);
srv->listen(10000);
String::CPtr url = String::create("http://127.0.0.1:10000/abc");
JsObject::Ptr options = url::parse(url);
JsObject::Ptr headers = JsObject::create();
headers->put(
http::HEADER_CONNECTION,
String::create("close"));
headers->put(
http::HEADER_CONTENT_LENGTH,
String::valueOf(Buffer::byteLength(msg)));
options->put(http::OPTION_HEADERS, headers);
GTestHttpClientOnResponse::Ptr onResponse(new GTestHttpClientOnResponse());
for (Size i = 0; i < NUM_REQS; i++) {
http::ClientRequest::Ptr req = http::request(options, onResponse);
req->write(msg);
req->end();
}
node::run();
ASSERT_EQ(0, GTestOnClose::count());
JsArray::CPtr messages = GTestOnEnd::messages();
JsArray::CPtr statusCodes = GTestHttpClientOnResponse::statusCodes();
Size numMsgs = messages->length();
Size numCodes = statusCodes->length();
ASSERT_EQ(NUM_REQS, numMsgs);
ASSERT_EQ(NUM_REQS, numCodes);
for (Size i = 0; i < numMsgs; i++) {
ASSERT_TRUE(messages->get(i).equals(msg));
ASSERT_TRUE(statusCodes->get(i).equals(200));
console::printf(console::INFO, ".");
}
console::printf(console::INFO, "\n");
}
void WARequest::getRequest()
{
QNetworkAccessManager *nam = Client::nam;
if (nam) {
QUrl reqUrl(QUrl(URL_REGISTRATION_V2 + _method));
reqUrl.setQuery(urlQuery);
QNetworkRequest request(reqUrl);
request.setRawHeader("User-Agent", Client::wauseragent.toLatin1());
request.setRawHeader("Connection", "closed");
qDebug() << "User-Agent" << Client::wauseragent;
qDebug() << "WARequest" << _method << "request:" << request.url().toString();
reply = nam->get(request);
QObject::connect(reply, SIGNAL(finished()), this, SLOT(onResponse()));
QObject::connect(reply, SIGNAL(error(QNetworkReply::NetworkError)), this, SLOT(error(QNetworkReply::NetworkError)));
QObject::connect(reply, SIGNAL(sslErrors(const QList<QSslError>&)), this, SLOT(sslErrors(const QList<QSslError>)));
}
}
/**
* ブラウザとのソケットと本来のホストとのソケットを接続するトンネルを作成
*/
void YASWebProxy::openTunnel()
{
QTcpSocket* socket = qobject_cast<QTcpSocket*>(sender());
QByteArray data = socket->readAll();
HttpParser* parser = socket->findChild<HttpParser*>("requestParser");
parser->input(data);
QTcpSocket* proxySocket = socket->findChild<QTcpSocket*>("tunnel");
if (!proxySocket) {
// 本来のホストへのソケットを作成
proxySocket = new QTcpSocket(socket);
proxySocket->setObjectName("tunnel");
proxySocket->connectToHost(parser->url.host(), parser->url.port(80));
connect(proxySocket, SIGNAL(disconnected()), this, SLOT(closeProxySocket()));
connect(proxySocket, SIGNAL(error(QAbstractSocket::SocketError)), this, SLOT(closeProxySocket()));
connect(proxySocket, SIGNAL(readyRead()), this, SLOT(forwardResponse()));
if (parser->method == "CONNECT") {
disconnect(socket, SIGNAL(readyRead()), this, SLOT(openTunnel()));
connect(socket, SIGNAL(readyRead()), this, SLOT(forwardRequest()));
} else {
HttpParser* resParser = new HttpParser(HttpParser::RESPONSE, proxySocket);
resParser->setObjectName("responseParser");
resParser->setProperty("url", parser->url.toString());
connect(resParser, SIGNAL(completeMessage(QByteArray)), this, SLOT(onResponse(QByteArray)));
}
}
if (proxySocket->waitForConnected()) {
if (parser->method == "CONNECT") {
socket->write("HTTP/1.0 200 Connection established\r\n\r\n");
} else {
proxySocket->write(parser->dequeueData());
}
} else {
proxySocket->disconnect();
}
}
void ServiceServerLink::onResponseOkAndLength(const ConnectionPtr& conn, const boost::shared_array<uint8_t>& buffer, uint32_t size, bool success)
{
ROS_ASSERT(conn == connection_);
ROS_ASSERT(size == 5);
if (!success)
return;
uint8_t ok = buffer[0];
uint32_t len = *((uint32_t*)(buffer.get() + 1));
if (len > 1000000000)
{
ROS_ERROR("a message of over a gigabyte was " \
"predicted in tcpros. that seems highly " \
"unlikely, so I'll assume protocol " \
"synchronization is lost.");
conn->drop(Connection::Destructing);
return;
}
{
boost::mutex::scoped_lock lock(call_queue_mutex_);
if ( ok != 0 ) {
current_call_->success_ = true;
} else {
current_call_->success_ = false;
}
}
if (len > 0)
{
connection_->read(len, boost::bind(&ServiceServerLink::onResponse, this, _1, _2, _3, _4));
}
else
{
onResponse(conn, boost::shared_array<uint8_t>(), 0, true);
}
}
void message::gate::itest::ITest_signup_Response::__onResponse(gamit::CSerializer & __is)
{
message::gate::gatemsg::SLoginReturn loginReturn;
loginReturn.__read(__is);
onResponse(loginReturn);
}
void message::gate::itest::ITest_getFloatList_Response::__onResponse(gamit::CSerializer & __is)
{
message::common::publicdef::SeqFloat floatList;
message::common::publicdef::__read(__is, floatList, message::common::publicdef::__SeqFloat_U__());
onResponse(floatList);
}
void message::gate::itest::ITest_getDictIntString_Response::__onResponse(gamit::CSerializer & __is)
{
message::common::publicdef::DictIntString intStrMap;
message::common::publicdef::__read(__is, intStrMap, message::common::publicdef::__DictIntString_U__());
onResponse(intStrMap);
}
void FinderActor::onAnswerTimeout(long id) {
//Acknowledge that we received a query
onResponse();
}
void Broadcast::handleResponse(const BinaryBuffer& buffer) {
onResponse(buffer);
}
