eelke/pgLab
1
0
Fork 0
Code Issues 28 Pull requests Projects Releases 1 Packages Wiki Activity Actions

Cleanup, removed commented out code, removed two units specific to windows which were not needed anymore

Browse source 
because we are using boost::asio now.
This commit is contained in:
Eelke Klein 2017-08-25 08:45:54 +02:00
parent 03f1c55f0b
commit 52442a145d
7 changed files with 0 additions and 494 deletions
Download patch file Download diff file Expand all files Collapse all files

297
pglab/ASyncDBConnection.cpp
View file

@ -1,8 +1,6 @@
#include "ASyncDBConnection.h"
#include "waithandlelist.h"
#include "ScopeGuard.h"
#include <chrono>
#include <sys/select.h>
using namespace boost::asio;
@ -19,13 +17,6 @@ ASyncDBConnection::State ASyncDBConnection::state() const
void ASyncDBConnection::setupConnection(const ConnectionConfig &config)
{
// if (m_thread.joinable()) {
// m_threadData.stop();
// m_thread.join();
// }
// m_threadData.m_config = config;
// m_thread = std::thread([this] () { m_threadData.run(); });
m_config = config;
auto keywords = m_config.getKeywords();
auto values = m_config.getValues();
@ -92,10 +83,6 @@ void ASyncDBConnection::doStateCallback(State state)
void ASyncDBConnection::closeConnection()
{
// m_threadData.stop();
// if (m_thread.joinable()) {
// m_thread.join();
// }
// SHould this be async too????
if (m_state == State::QuerySend) {
m_canceller.cancel(nullptr);
@ -107,12 +94,6 @@ void ASyncDBConnection::closeConnection()
bool ASyncDBConnection::send(const std::string &command, on_result_callback on_result)
{
// {
// std::lock_guard<std::mutex> lg(m_threadData.m_commandQueue.m_mutex);
// m_threadData.m_commandQueue.m_queue.emplace(command, on_result);
// m_threadData.m_commandQueue.m_newEvent.notify_one();
// }
m_connection.sendQuery(command);
m_timer.start();
doStateCallback(State::QuerySend);
@ -125,11 +106,6 @@ bool ASyncDBConnection::send(const std::string &command, on_result_callback on_r
bool ASyncDBConnection::send(const std::string &command, Pgsql::Params params, on_result_callback on_result)
{
// {
// std::lock_guard<std::mutex> lg(m_threadData.m_commandQueue.m_mutex);
// m_threadData.m_commandQueue.m_queue.emplace(command, std::move(params), on_result);
// m_threadData.m_commandQueue.m_newEvent.notify_one();
// }
m_connection.sendQueryParams(command.c_str(), params);
m_timer.start();
doStateCallback(State::QuerySend);
@ -197,276 +173,3 @@ void ASyncDBConnection::processNotice(const PGresult *result)
m_noticeCallback.m_func(details);
}
}
// ASyncDBConnection::Thread::Thread()
// {}
//
// void ASyncDBConnection::Thread::run()
// {
// m_terminated = false;
// SCOPE_EXIT {
// m_state = State::NotConnected;
// m_terminated = true;
// };
// while (!terminateRequested) {
//
// // make or recover connection
// if (makeConnection()) {
// m_connection.setNoticeReceiver(
// [this](const PGresult *result) { processNotice(result); });
// m_canceller = m_connection.getCancel();
//
//
// // send commands and receive results
// communicate();
// }
// else {
// // It is not possible to determine the source of the problem.
// // Accept for PQconnectionNeedsPassword
//
// // Pass problem to main thread and stop this thread
//
// // Main thread needs to know it has to restart connecting if it want's to.
// // TODO: add status functions to help main thread so it doesn't have to remember
// // everything reported through callbacks.
//
// break;
// }
// }
// // close connection
// }
//
// bool ASyncDBConnection::Thread::cancel()
// {
// return m_canceller.cancel(nullptr);
// }
// bool ASyncDBConnection::Thread::makeConnection()
// {
// //using namespace std::literals::chrono_literals;
//
// // start connecting
// auto keywords = m_config.getKeywords();
// auto values = m_config.getValues();
// #if true
// bool result = m_connection.connect(keywords, values, 0);
// if (result) {
// doStateCallback(State::Connected);
// }
// return result;
// #else
// while (!terminateRequested) {
//
// bool ok = m_connection.connectStart(keywords, values);
// auto start = std::chrono::steady_clock::now();
// if (ok && m_connection.status() != CONNECTION_BAD) {
// int sock = m_connection.socket();
// Win32Event socket_event(Win32Event::Reset::Auto, Win32Event::Initial::Clear);
//
// long fd = FD_WRITE;
// while (true) {
// // poll till complete or failed (we can get an abort command)
// WSAEventSelect(sock, socket_event.handle(), fd);
// WaitHandleList whl;
// auto wait_result_socket_event = whl.add(socket_event);
// //auto wait_result_stop = whl.add(m_stopEvent);
//
// auto nu = std::chrono::steady_clock::now();
// std::chrono::duration<float, std::milli> diff = -(nu-start);
// diff += 30s;
// DWORD timeout = diff.count();
//
// DWORD res = MsgWaitForMultipleObjectsEx(
// whl.count(), // _In_ DWORD nCount,
// whl, // _In_ const HANDLE *pHandles,
// timeout, // _In_ DWORD dwMilliseconds,
// 0, // _In_ DWORD dwWakeMask,
// 0 // _In_ DWORD dwFlags
// );
// if (res == wait_result_socket_event) {
// auto poll_state = m_connection.connectPoll();
// if (poll_state == PGRES_POLLING_OK) {
// // if connected return true
// doStateCallback(State::Connected);
// return true;
// }
// else if (poll_state == PGRES_POLLING_FAILED) {
// doStateCallback(State::NotConnected);
// return false;
// }
// else if (poll_state == PGRES_POLLING_READING) {
// doStateCallback(State::Connecting);
// fd = FD_READ;
// }
// else if (poll_state == PGRES_POLLING_WRITING) {
// doStateCallback(State::Connecting);
// fd = FD_WRITE;
// }
// }
// else if (res == wait_result_stop) {
//
// }
// } // end while (true)
// }
// }
// return false;
// #endif
// }
//
// void ASyncDBConnection::Thread::communicate()
// {
// while (!terminateRequested) {
// // wait for something to do:
// // - command to send to server
// // - wait for results and (notifies can also come in)
// // - pass each result on to the completion routine
// // - notify comming in from the server
// // - pass to notify callback
// // - connection raises an error
// // - return
// // - stop signal
// // - return
//
//
// if (m_state == State::Connected) {
// waitForAndSendCommand();
// }
// else if (m_state == State::QuerySend || m_state == State::CancelSend) {
// // Wait for result, even after a cancel we should wait, for all results
// // New command's are not excepted when one has been send
// waitForResult();
// }
//
// }
// }
//
// void ASyncDBConnection::Thread::stop()
// {
// terminateRequested = true;
// //m_stopEvent.set();
// }
// void ASyncDBConnection::Thread::doStateCallback(State state)
// {
// m_state = state;
// std::lock_guard<std::mutex> lg(m_stateCallback.m_mutex);
// if (m_stateCallback.m_func) {
// m_stateCallback.m_func(state);
// }
// }
// void ASyncDBConnection::Thread::waitForAndSendCommand()
// {
// using namespace std::chrono_literals;
// // lock the data
// std::unique_lock<std::mutex> lk(m_commandQueue.m_mutex);
// if (m_commandQueue.m_queue.empty()) {
// // no data wait till there is data
// m_commandQueue.m_newEvent.wait_for(lk, 1000ms);
// // can we use the predicate to reimplement the stop function???, []{return ready;});
//
// }
// doNewCommand();
//
// #if false
// WaitHandleList whl;
// auto wait_result_new_command = whl.add(m_commandQueue.m_newEvent);
// //auto wait_result_stop =
// //whl.add(m_stopEvent);
//
// DWORD res = MsgWaitForMultipleObjectsEx(
// whl.count(), // _In_ DWORD nCount,
// whl, // _In_ const HANDLE *pHandles,
// INFINITE, // _In_ DWORD dwMilliseconds,
// 0, // _In_ DWORD dwWakeMask,
// 0 // _In_ DWORD dwFlags
// );
// if (res == wait_result_new_command) {
// doNewCommand();
// }
// // if (res == wait_result_stop) return;
// #endif
// }
// void ASyncDBConnection::Thread::doNewCommand()
// {
// // get command from top of queue (but leave it in the queue, we need the callback)
// if (! m_commandQueue.m_queue.empty()) {
// const Command &command = m_commandQueue.m_queue.front();
// if (!command.command.empty()) {
// bool query_send = false;
// if (command.params.empty())
// query_send = m_connection.sendQuery(command.command.c_str());
// else
// query_send = m_connection.sendQueryParams(command.command.c_str(), command.params);
//
// if (query_send) {
// m_timer.start();
// doStateCallback(State::QuerySend);
// }
// else {
// std::string error = m_connection.getErrorMessage();
// // todo: need to report the error
// }
// }
// }
//
// }
// bool ASyncDBConnection::Thread::consumeResultInput()
// {
// bool finished = false;
// if (m_connection.consumeInput()) {
// while ( ! finished && ! m_connection.isBusy()) {
// auto res(m_connection.getResult());
// {
// qint64 ms = m_timer.restart();
// std::lock_guard<std::mutex> lg(m_commandQueue.m_mutex);
// m_commandQueue.m_queue.front().on_result(res, ms);
// if (res == nullptr) {
// m_timer.invalidate();
// m_commandQueue.m_queue.pop();
// doStateCallback(State::Connected);
// finished = true;
// }
// }
//
// }
// // else is still waiting for more data
//
// }
// else {
// // error during consume
//
// }
// return finished;
// }
// void ASyncDBConnection::Thread::waitForResult()
// {
// int sock = m_connection.socket();
//
// fd_set readfds;
// timeval timeout;
// bool finished = false;
// while (!finished && !terminateRequested) {
// FD_ZERO(&readfds);
// FD_SET(sock, &readfds);
//
// timeout.tv_sec = 5;
// timeout.tv_usec = 0;
//
// int select_result = select(sock + 1, &readfds, nullptr, nullptr, &timeout);
// if (select_result > 0) {
// if (FD_ISSET(sock, &readfds)) {
// if (consumeResultInput()) {
// finished = true;
// }
// }
// }
//
// }
// }
/*
*/

83
pglab/ASyncDBConnection.h
View file

@ -38,7 +38,6 @@ public:
~ASyncDBConnection();
State state() const;
// void setupConnection(const std::string &connstring);
void setupConnection(const ConnectionConfig &config);
void closeConnection();
@ -77,88 +76,6 @@ private:
void async_query_handler(boost::system::error_code ec, std::size_t s, on_result_callback on_result);
void doStateCallback(State state);
void processNotice(const PGresult *result);
// class Command {
// public:
// std::string command;
// Pgsql::Params params;
// on_result_callback on_result;
//
// Command() = default;
// Command(const std::string &cmd, on_result_callback cb)
// : command(cmd), on_result(cb)
// {}
// Command(const std::string &cmd, Pgsql::Params &&p, on_result_callback cb)
// : command(cmd), params(p), on_result(cb)
// {}
// };
//
// /// Contains all the members accessed by the thread
// class Thread {
// public:
// using t_CommandQueue = std::queue<Command>;
// struct {
// std::mutex m_mutex;
// on_state_callback m_func;
// } m_stateCallback;
// struct {
// std::mutex m_mutex;
// on_notice_callback m_func;
// } m_noticeCallback;
//
// struct t_Command {
// std::mutex m_mutex;
// t_CommandQueue m_queue;
// std::condition_variable m_newEvent;
// t_Command()
// {}
// } m_commandQueue;
//
// // std::string m_initString;
// ConnectionConfig m_config;
// State m_state = State::NotConnected;
//
// Thread();
//
// /// Is started as a seperate thread by ASyncDBConnection
// void run();
//
// /// Sends a cancel request to the DB server
// bool cancel();
//
// void stop();
//
// private:
//
// /// \todo Implement new method to stop the thread
// //Win32Event m_stopEvent;
// Pgsql::Connection m_connection;
// bool terminateRequested = false; ///< is set when the thread should stop
// bool m_terminated = true;
// Pgsql::Canceller m_canceller;
// QElapsedTimer m_timer;
//
//
// bool makeConnection();
// void communicate();
//
// void doStateCallback(State state);
// /// Wait's for a command to come in and send's it to the server
// void waitForAndSendCommand();
// void doNewCommand();
// void waitForResult();
//
//
// void processNotice(const PGresult *result);
// /** Function to call when after sending a command the socket is ready for reading.
// *
// * It might take several consumes before all data is read.
// */
// bool consumeResultInput();
// };
//
// Thread m_threadData;
// std::thread m_thread;
};
#endif // ASYNCDBCONNECTION_H

34
pglab/waithandlelist.cpp
View file

@ -1,34 +0,0 @@
#include "waithandlelist.h"
#include "win32event.h"
#ifdef _WIN32
WaitHandleList::WaitHandleList() = default;
WaitHandleList::~WaitHandleList() = default;
WaitResultValue WaitHandleList::add(HANDLE h)
{
m_waitHandles.push_back(h);
return WAIT_OBJECT_0 + static_cast<DWORD>(m_waitHandles.size() - 1);
}
WaitResultValue WaitHandleList::add(Win32Event &e)
{
return add(e.handle());
}
DWORD WaitHandleList::count() const
{
return static_cast<DWORD>(m_waitHandles.size());
}
void WaitHandleList::clear()
{
m_waitHandles.clear();
}
WaitHandleList::operator const HANDLE*() const
{
return m_waitHandles.data();
}
#endif

28
pglab/waithandlelist.h
View file

@ -1,28 +0,0 @@
#ifndef WAITHANDLELIST_H
#define WAITHANDLELIST_H
#ifdef _WIN32
#include <windows.h>
#include <vector>
class Win32Event;
using WaitResultValue = DWORD;
class WaitHandleList {
public:
WaitHandleList();
~WaitHandleList();
WaitResultValue add(HANDLE h);
WaitResultValue add(Win32Event &e);
DWORD count() const;
void clear();
operator const HANDLE*() const;
private:
std::vector<HANDLE> m_waitHandles;
};
#endif // _WIN32
#endif // WAITHANDLELIST_H

1
pglab/win32event.cpp
View file

@ -1 +0,0 @@
#include "win32event.h"

49
pglab/win32event.h
View file

@ -1,49 +0,0 @@
#ifndef WIN32EVENT_H
#define WIN32EVENT_H
#ifdef _WIN32
#include <WinSock2.h>
#include <windows.h>
/** Simpel wrapper around a Win32 Event object.
Mostly to make cleanup automatic.*/
class Win32Event {
public:
enum class Reset { Auto=0, Manual=1 };
enum class Initial { Clear=0, Set=1 };
Win32Event(Reset r, Initial is)
: hEvent(CreateEvent(
nullptr, // _In_opt_ LPSECURITY_ATTRIBUTES lpEventAttributes,
BOOL(r), // _In_ BOOL bManualReset,
BOOL(is), // _In_ BOOL bInitialState,
nullptr //_In_opt_ LPCTSTR lpName
))
{}
Win32Event(Reset r, Initial is, int sock, long net_events)
: Win32Event(r, is)
{
WSAEventSelect(sock, hEvent, net_events);
}
~Win32Event()
{
CloseHandle(hEvent);
}
Win32Event(const Win32Event &) = delete;
Win32Event &operator=(const Win32Event &) = delete;
void set() { SetEvent(hEvent); }
void reset() { ResetEvent(hEvent); }
HANDLE handle() { return hEvent; }
private:
HANDLE hEvent;
};
#endif // _WIN32
#endif // WIN32EVENT_H