void Button::rect(const Rect& r)
{
View::rect(r);
Rect svr(0,0,r.width, r.height);
imageView->rect(svr);
titleLabel->rect(svr);
}
TEST(Socket, SimpleReadWrite) {
std::thread server([&]() {
fp::TCPSocketServer svr("localhost", "6969");
ASSERT_TRUE(svr.connect());
std::shared_ptr<fp::Socket> connection = svr.acceptPendingConnection();
char buffer[16];
int counter = 0;
ssize_t size = 0;
while(true) {
fp::Socket::ReadResult result = connection->read(buffer, 16, size);
if (result == fp::Socket::MoreData) {
EXPECT_EQ(4, size);
EXPECT_STREQ(buffer, "tom");
break;
} else if (result == fp::Socket::NoData) {
std::this_thread::sleep_for(std::chrono::microseconds(10));
if (counter++ > 1000) {
break;
}
} else if (result == fp::Socket::Closed) {
DEBUG_LOG("Socket closed");
break;
}
}
});
std::this_thread::sleep_for(std::chrono::seconds(1));
fp::TCPSocketClient client("localhost", "6969");
ASSERT_TRUE(client.connect());
EXPECT_TRUE(client.send("tom", 4)); // send 4bytes (including \0)
server.join();
}
void Button::rect(f32 x, f32 y, f32 w, f32 h)
{
View::rect(x,y,w,h);
Rect svr(0,0,w,h);
imageView->rect(svr);
titleLabel->rect(svr);
}
int main(int argc, char **argv)
{
member_list_obj_t mlobj;
friends_obj_t friends;
//msg_list_t msgl_obj;
net::SockInit();
objects_t::Init(&mlobj, &friends);
net::SockConfig conf = { 11111, 0, "", "" };
svr_t svr(1024, conf);
try{
while (true)
svr.Run();
}
catch (std::exception &e){
cout << e.what() << endl;
}
net::SockUninit();
return 0;
}
void ServiceBrowserPrivate::gotNewService(int,int,const QString& name, const QString& type, const QString& domain, uint)
{
m_timer.start(TIMEOUT_LAST_SERVICE);
RemoteService::Ptr svr(new RemoteService(name, type,domain));
if (m_autoResolve) {
connect(svr.data(),SIGNAL(resolved(bool)),this,SLOT(serviceResolved(bool)));
m_duringResolve+=svr;
svr->resolveAsync();
} else {
int main(int argc, char* argv[])
{
try
{
char const* port = argc > 1 ? argv[1] : "10001";
server svr("127.0.0.1", std::atoi(port));
client cln("127.0.0.1", port);
}
catch (std::exception& ex)
{
std::cerr << ex.what() << std::endl;
}
return 0;
}
void PopularUrls::save()
{
KConfigGroup svr(krConfig, "Private");
// prepare the string list containing urls and int list with ranks
QStringList urlList;
QList<int> rankList;
UrlNodeP p = head;
while (p) {
urlList << p->url.toDisplayString();
rankList << p->rank;
p = p->next;
}
svr.writeEntry("PopularUrls", urlList);
svr.writeEntry("PopularUrlsRank", rankList);
}
int main(int argc, char *argv[])
{
if (argc < 2) {
usage(argv[0]);
}
if (0 == strncmp("svr", argv[1], strlen(argv[1])))
svr(argc - 1, &argv[1]);
else if (0 == strncmp("cli", argv[1], strlen(argv[1])))
cli(argc - 1, &argv[1]);
else {
usage(argv[0]);
}
exit(EXIT_SUCCESS);
}
int main()
{
Singleton<ConfigParser>::instance()->parser_file("./svr.conf");
Singleton<ConfigParser>::instance()->scan();
const Section & NetSec = Singleton<ConfigParser>::instance()->get("AppSvr");
Log::init("./run.log");
Log::set_level(1);
Log::NOTICE("LOG INIT SUCCES");
AppReactor svr(NetSec);
svr.init();
svr.run();
return 0;
}
void PopularUrls::load()
{
KConfigGroup svr(krConfig, "Private");
QStringList urlList = svr.readEntry("PopularUrls", QStringList());
QList<int> rankList = svr.readEntry("PopularUrlsRank", QList<int>());
if (urlList.count() != rankList.count()) {
KMessageBox::error(krMainWindow, i18n("The saved 'Popular URLs' are invalid. The list will be cleared."));
return;
}
clearList();
count = 0;
// iterate through both lists and
QStringList::Iterator uit;
QList<int>::Iterator rit;
for (uit = urlList.begin(), rit = rankList.begin(); uit != urlList.end() && rit != rankList.end(); ++uit, ++rit) {
UrlNodeP node = new UrlNode;
node->url = QUrl(*uit);
node->rank = *rit;
appendNode(node);
ranks.insert(*uit, node);
}
}
TEST(Socket, NonBlockingReadWrite) {
bool callbackFired = false;
LOG_LEVEL(tf::logger::info);
fp::Session::initialise();
std::thread server([&]() {
DEBUG_LOG("Started server thread");
fp::TCPSocketServer svr("localhost", "6967");
ASSERT_TRUE(svr.connect());
std::shared_ptr<fp::Socket> connection = svr.acceptPendingConnection();
DEBUG_LOG("Accepted connection");
char buffer[16];
int counter = 0;
ssize_t size = 0;
while(true) {
fp::Socket::ReadResult result = connection->read(buffer, 16, size);
if (result == fp::Socket::MoreData) {
DEBUG_LOG("Server received data");
EXPECT_EQ(6, size);
EXPECT_STREQ(buffer, "hello");
break;
} else if (result == fp::Socket::NoData) {
std::this_thread::sleep_for(std::chrono::microseconds(10));
if (counter++ > 1000) {
break;
}
} else if (result == fp::Socket::Closed) {
DEBUG_LOG("Socket closed");
break;
}
}
DEBUG_LOG("Server sending data");
EXPECT_TRUE(connection->send("goodbye", 8));
std::this_thread::sleep_for(std::chrono::milliseconds(100));
});
std::this_thread::sleep_for(std::chrono::milliseconds(100));
fp::TCPSocketClient client("localhost", "6967");
fp::BusySpinQueue queue;
DEBUG_LOG("Client attempting to connect");
ASSERT_TRUE(client.connect(fp::SocketOptionsDisableSigPipe));
EXPECT_NE(-1, client.getSocket());
DEBUG_LOG("Client connected");
/*fp::IOEvent *handler = */queue.registerEvent(client.getSocket(), fp::EventType::READ, [&](const fp::DataEvent *event, fp::EventType eventType) {
EXPECT_EQ(fp::EventType::READ, eventType);
DEBUG_LOG("Client received data");
callbackFired = true;
int counter = 0;
char buffer[16];
ssize_t size = 0;
while(true) {
fp::Socket::ReadResult result = client.read(buffer, 16, size);
if (result == fp::Socket::MoreData) {
EXPECT_EQ(8, size);
EXPECT_STREQ(buffer, "goodbye");
break;
} else if (result == fp::Socket::NoData) {
std::this_thread::sleep_for(std::chrono::microseconds(10));
if (counter++ > 1000) {
break;
}
} else if (result == fp::Socket::Closed) {
DEBUG_LOG("Socket closed");
break;
}
}
});
DEBUG_LOG("Client sending data");
EXPECT_TRUE(client.send("hello", 6));
queue.dispatch(std::chrono::seconds(5));
EXPECT_TRUE(callbackFired);
server.join();
fp::Session::destroy();
}
TEST(Socket, NonBlockingServerReadWrite) {
bool callbackFired = false;
LOG_LEVEL(tf::logger::info);
fp::Session::initialise();
std::thread server([&]() {
fp::TCPSocketServer svr("localhost", "6966");
ASSERT_TRUE(svr.connect(fp::SocketOptionsNonBlocking));
ASSERT_NE(-1, svr.getSocket());
std::shared_ptr<fp::Socket> connection;
bool finished = false;
fp::BusySpinQueue queue;
auto client = [&](const fp::DataEvent *event, int eventType) {
EXPECT_EQ(fp::EventType::READ, eventType);
char buffer[16];
int counter = 0;
ssize_t size = 0;
while (true) {
fp::Socket::ReadResult result = connection->read(buffer, 16, size);
DEBUG_LOG("got stuff");
if (result == fp::Socket::MoreData) {
EXPECT_EQ(6, size);
EXPECT_STREQ(buffer, "hello");
break;
} else if (result == fp::Socket::NoData) {
std::this_thread::sleep_for(std::chrono::microseconds(10));
if (counter++ > 1000) {
break;
}
} else if (result == fp::Socket::Closed) {
DEBUG_LOG("Server Socket closed");
break;
}
}
EXPECT_TRUE(connection->send("goodbye", 8));
finished = true;
};
fp::DataEvent *clientHandler = nullptr;
fp::DataEvent *handler = queue.registerEvent(svr.getSocket(), fp::EventType::READ, [&](const fp::DataEvent *event, int eventType) {
EXPECT_EQ(fp::EventType::READ, eventType);
DEBUG_LOG("entering accept");
connection = svr.acceptPendingConnection();
if (connection != nullptr) {
DEBUG_LOG("out of accept");
clientHandler = queue.registerEvent(connection->getSocket(), fp::EventType::READ, client);
DEBUG_LOG("registered new client");
}
});
for (int i = 0; !finished && i < 15; i++) {
DEBUG_LOG("wait...");
queue.dispatch(std::chrono::milliseconds(1000));
DEBUG_LOG("...serviced event");
}
queue.unregisterEvent(handler);
queue.unregisterEvent(clientHandler);
});
fp::BusySpinQueue queue;
std::this_thread::sleep_for(std::chrono::microseconds(100));
fp::TCPSocketClient client("localhost", "6966");
ASSERT_TRUE(client.connect(fp::SocketOptionsDisableSigPipe));
EXPECT_NE(-1, client.getSocket());
/*fp::DataEvent *handler = */queue.registerEvent(client.getSocket(), fp::EventType::READ, [&](const fp::DataEvent *event, int eventType) {
EXPECT_EQ(fp::EventType::READ, eventType);
callbackFired = true;
int counter = 0;
char buffer[16];
ssize_t size = 0;
while(true) {
fp::Socket::ReadResult result = client.read(buffer, 16, size);
if (result == fp::Socket::MoreData) {
EXPECT_EQ(8, size);
EXPECT_STREQ(buffer, "goodbye");
break;
} else if (result == fp::Socket::NoData) {
std::this_thread::sleep_for(std::chrono::microseconds(10));
if (counter++ > 1000) {
break;
}
} else if (result == fp::Socket::Closed) {
DEBUG_LOG("Client Socket closed");
break;
}
}
});
EXPECT_TRUE(client.send("hello", 6));
queue.dispatch(std::chrono::seconds(5));
EXPECT_TRUE(callbackFired);
server.join();
fp::Session::destroy();
}
