Hawkin
/
arangodb
mirror of https://gitee.com/bigwinds/arangodb
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

cleanup of member names

This commit is contained in:
Frank Celler 2015-07-20 17:40:13 +02:00
parent b5ff2f8f4f
commit 9b95e08765
10 changed files with 406 additions and 441 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

650
arangod/Aql/grammar.cpp
View File

File diff suppressed because it is too large Load Diff

12
arangod/Aql/grammar.h
View File

@ -1,8 +1,8 @@
/* A Bison parser, made by GNU Bison 3.0.2. */
/* A Bison parser, made by GNU Bison 3.0.4. */
/* Bison interface for Yacc-like parsers in C
Copyright (C) 1984, 1989-1990, 2000-2013 Free Software Foundation, Inc.
Copyright (C) 1984, 1989-1990, 2000-2015 Free Software Foundation, Inc.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
@ -109,18 +109,20 @@ extern int Aqldebug;
/* Value type. */
#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
typedef union YYSTYPE YYSTYPE;
union YYSTYPE
{
#line 22 "arangod/Aql/grammar.y" /* yacc.c:1909 */
#line 22 "arangod/Aql/grammar.y" /* yacc.c:1915 */
triagens::aql::AstNode* node;
char* strval;
bool boolval;
int64_t intval;
#line 123 "arangod/Aql/grammar.hpp" /* yacc.c:1909 */
#line 123 "arangod/Aql/grammar.hpp" /* yacc.c:1915 */
};
typedef union YYSTYPE YYSTYPE;
# define YYSTYPE_IS_TRIVIAL 1
# define YYSTYPE_IS_DECLARED 1
#endif

5
lib/HttpServer/ApplicationEndpointServer.cpp
View File

@ -612,11 +612,6 @@ void ApplicationEndpointServer::close () {
return;
}
// close all open connections
for (auto server : _servers) {
server->shutdownHandlers();
}
// close all listen sockets
for (auto server : _servers) {
server->stopListening();

7
lib/HttpServer/HttpCommTask.cpp
View File

@ -249,13 +249,6 @@ int HttpCommTask::signalChunk (const string& data) {
return _chunkedTask.signalChunk(data);
}
////////////////////////////////////////////////////////////////////////////////
/// @brief begins shutdown
////////////////////////////////////////////////////////////////////////////////
void HttpCommTask::beginShutdown () {
}
////////////////////////////////////////////////////////////////////////////////
/// @brief handles response
////////////////////////////////////////////////////////////////////////////////

10
lib/HttpServer/HttpCommTask.h
View File

@ -150,12 +150,6 @@ namespace triagens {
int signalChunk (const std::string&);
////////////////////////////////////////////////////////////////////////////////
/// @brief begins shutdown
////////////////////////////////////////////////////////////////////////////////
void beginShutdown ();
////////////////////////////////////////////////////////////////////////////////
/// @brief handles response
////////////////////////////////////////////////////////////////////////////////
@ -283,7 +277,7 @@ namespace triagens {
/// {@inheritDoc}
////////////////////////////////////////////////////////////////////////////////
bool handleAsync ();
bool handleAsync () override;
// -----------------------------------------------------------------------------
// --SECTION-- SocketTask methods
@ -307,7 +301,7 @@ namespace triagens {
/// {@inheritDoc}
////////////////////////////////////////////////////////////////////////////////
void handleTimeout () override;
void handleTimeout () override;
// -----------------------------------------------------------------------------
// --SECTION-- protected variables

14
lib/HttpServer/HttpServer.cpp
View File

@ -244,20 +244,6 @@ void HttpServer::unregisterChunkedTask (HttpCommTask* task) {
HttpCommTaskMap.erase(task->taskId());
}
////////////////////////////////////////////////////////////////////////////////
/// @brief shuts down handlers
////////////////////////////////////////////////////////////////////////////////
void HttpServer::shutdownHandlers () {
{
GENERAL_SERVER_LOCKER(_commTasksLock);
for (auto& i : _commTasks) {
i->beginShutdown();
}
}
}
////////////////////////////////////////////////////////////////////////////////
/// @brief removes all listen and comm tasks
////////////////////////////////////////////////////////////////////////////////

6
lib/HttpServer/HttpServer.h
View File

@ -206,12 +206,6 @@ namespace triagens {
void unregisterChunkedTask (HttpCommTask*);
////////////////////////////////////////////////////////////////////////////////
/// @brief shuts down all handlers
////////////////////////////////////////////////////////////////////////////////
void shutdownHandlers ();
////////////////////////////////////////////////////////////////////////////////
/// @brief removes all listen and comm tasks
////////////////////////////////////////////////////////////////////////////////

26
lib/HttpServer/HttpsCommTask.cpp
View File

@ -117,7 +117,7 @@ bool HttpsCommTask::setup (Scheduler* scheduler, EventLoop loop) {
SSL_set_fd(_ssl, (int) TRI_get_fd_or_handle_of_socket(_commSocket));
// accept might need writes
_scheduler->startSocketEvents(writeWatcher);
_scheduler->startSocketEvents(_writeWatcher);
return true;
}
@ -130,21 +130,21 @@ bool HttpsCommTask::handleEvent (EventToken token, EventType revents) {
// try to accept the SSL connection
if (! _accepted) {
if (token == readWatcher && (revents & EVENT_SOCKET_READ)) {
if (token == _readWatcher && (revents & EVENT_SOCKET_READ)) {
return trySSLAccept();
}
if (token == writeWatcher && (revents & EVENT_SOCKET_WRITE)) {
if (token == _writeWatcher && (revents & EVENT_SOCKET_WRITE)) {
return trySSLAccept();
}
}
// if we blocked on write, read can be called when the socket is writeable
if (_readBlockedOnWrite && token == writeWatcher && (revents & EVENT_SOCKET_WRITE)) {
if (_readBlockedOnWrite && token == _writeWatcher && (revents & EVENT_SOCKET_WRITE)) {
_readBlockedOnWrite = false;
revents &= ~EVENT_SOCKET_WRITE;
revents |= EVENT_SOCKET_READ;
token = readWatcher;
token = _readWatcher;
}
// handle normal socket operation
@ -153,7 +153,7 @@ bool HttpsCommTask::handleEvent (EventToken token, EventType revents) {
// we might need to start listing for writes (even we only want to READ)
if (result && ! _clientClosed) {
if (_readBlockedOnWrite || _writeBlockedOnRead) {
_scheduler->startSocketEvents(writeWatcher);
_scheduler->startSocketEvents(_writeWatcher);
}
}
@ -222,7 +222,7 @@ bool HttpsCommTask::trySSLAccept () {
_accepted = true;
// accept done, remove write events
_scheduler->stopSocketEvents(writeWatcher);
_scheduler->stopSocketEvents(_writeWatcher);
return true;
}
@ -346,10 +346,10 @@ bool HttpsCommTask::trySSLWrite () {
size_t len = 0;
if (nullptr != _writeBuffer) {
TRI_ASSERT(_writeBuffer->length() >= writeLength);
TRI_ASSERT(_writeBuffer->length() >= _writeLength);
// size_t is unsigned, should never get < 0
len = _writeBuffer->length() - writeLength;
len = _writeBuffer->length() - _writeLength;
}
// write buffer to SSL connection
@ -357,7 +357,7 @@ bool HttpsCommTask::trySSLWrite () {
if (0 < len) {
ERR_clear_error();
nr = SSL_write(_ssl, _writeBuffer->begin() + writeLength, (int) len);
nr = SSL_write(_ssl, _writeBuffer->begin() + _writeLength, (int) len);
if (nr <= 0) {
int res = SSL_get_error(_ssl, nr);
@ -414,14 +414,14 @@ bool HttpsCommTask::trySSLWrite () {
}
if (len == 0) {
if (ownBuffer) {
if (_ownBuffer) {
delete _writeBuffer;
}
callCompletedWriteBuffer = true;
}
else {
writeLength += nr;
_writeLength += nr;
}
// we have to release the lock, before calling completedWriteBuffer
@ -435,7 +435,7 @@ bool HttpsCommTask::trySSLWrite () {
}
// we might have a new write buffer
_scheduler->sendAsync(SocketTask::watcher);
_scheduler->sendAsync(SocketTask::_asyncWatcher);
return true;
}

102
lib/Scheduler/SocketTask.cpp
View File

@ -51,21 +51,21 @@ using namespace triagens::rest;
SocketTask::SocketTask (TRI_socket_t socket, double keepAliveTimeout)
: Task("SocketTask"),
keepAliveWatcher(nullptr),
readWatcher(nullptr),
writeWatcher(nullptr),
watcher(nullptr),
_keepAliveWatcher(nullptr),
_readWatcher(nullptr),
_writeWatcher(nullptr),
_asyncWatcher(nullptr),
_commSocket(socket),
_keepAliveTimeout(keepAliveTimeout),
_writeBuffer(nullptr),
#ifdef TRI_ENABLE_FIGURES
_writeBufferStatistics(nullptr),
#endif
ownBuffer(true),
writeLength(0),
_ownBuffer(true),
_writeLength(0),
_readBuffer(nullptr),
_clientClosed(false),
tid(0) {
_tid(0) {
_readBuffer = new StringBuffer(TRI_UNKNOWN_MEM_ZONE);
@ -85,7 +85,7 @@ SocketTask::~SocketTask () {
TRI_invalidatesocket(&_commSocket);
}
if (ownBuffer) {
if (_ownBuffer) {
delete _writeBuffer;
}
@ -112,8 +112,8 @@ SocketTask::~SocketTask () {
////////////////////////////////////////////////////////////////////////////////
void SocketTask::setKeepAliveTimeout (double timeout) {
if (keepAliveWatcher != nullptr && timeout > 0.0) {
_scheduler->rearmTimer(keepAliveWatcher, timeout);
if (_keepAliveWatcher != nullptr && timeout > 0.0) {
_scheduler->rearmTimer(_keepAliveWatcher, timeout);
}
}
@ -174,14 +174,14 @@ bool SocketTask::handleWrite () {
size_t len = 0;
if (nullptr != _writeBuffer) {
TRI_ASSERT(_writeBuffer->length() >= writeLength);
len = _writeBuffer->length() - writeLength;
TRI_ASSERT(_writeBuffer->length() >= _writeLength);
len = _writeBuffer->length() - _writeLength;
}
int nr = 0;
if (0 < len) {
nr = TRI_WRITE_SOCKET(_commSocket, _writeBuffer->begin() + writeLength, (int) len, 0);
nr = TRI_WRITE_SOCKET(_commSocket, _writeBuffer->begin() + _writeLength, (int) len, 0);
if (nr < 0) {
if (errno == EINTR) {
@ -201,14 +201,14 @@ bool SocketTask::handleWrite () {
}
if (len == 0) {
if (nullptr != _writeBuffer && ownBuffer) {
if (nullptr != _writeBuffer && _ownBuffer) {
delete _writeBuffer;
}
callCompletedWriteBuffer = true;
}
else {
writeLength += nr;
_writeLength += nr;
}
if (callCompletedWriteBuffer) {
@ -225,10 +225,10 @@ bool SocketTask::handleWrite () {
// we might have a new write buffer or none at all
if (_writeBuffer == nullptr) {
_scheduler->stopSocketEvents(writeWatcher);
_scheduler->stopSocketEvents(_writeWatcher);
}
else {
_scheduler->startSocketEvents(writeWatcher);
_scheduler->startSocketEvents(_writeWatcher);
}
return true;
@ -258,7 +258,7 @@ void SocketTask::setWriteBuffer (StringBuffer* buffer,
#endif
writeLength = 0;
_writeLength = 0;
if (buffer->empty()) {
if (ownBuffer) {
@ -269,13 +269,13 @@ void SocketTask::setWriteBuffer (StringBuffer* buffer,
}
else {
if (_writeBuffer != nullptr) {
if (this->ownBuffer) {
if (_ownBuffer) {
delete _writeBuffer;
}
}
_writeBuffer = buffer;
this->ownBuffer = ownBuffer;
_ownBuffer = ownBuffer;
}
if (callCompletedWriteBuffer) {
@ -288,13 +288,13 @@ void SocketTask::setWriteBuffer (StringBuffer* buffer,
}
// we might have a new write buffer or none at all
TRI_ASSERT(tid == Thread::currentThreadId());
TRI_ASSERT(_tid == Thread::currentThreadId());
if (_writeBuffer == nullptr) {
_scheduler->stopSocketEvents(writeWatcher);
_scheduler->stopSocketEvents(_writeWatcher);
}
else {
_scheduler->startSocketEvents(writeWatcher);
_scheduler->startSocketEvents(_writeWatcher);
}
}
@ -353,24 +353,24 @@ bool SocketTask::setup (Scheduler* scheduler, EventLoop loop) {
#endif
this->_scheduler = scheduler;
this->_loop = loop;
_scheduler = scheduler;
_loop = loop;
watcher = _scheduler->installAsyncEvent(loop, this);
readWatcher = _scheduler->installSocketEvent(loop, EVENT_SOCKET_READ, this, _commSocket);
writeWatcher = _scheduler->installSocketEvent(loop, EVENT_SOCKET_WRITE, this, _commSocket);
_asyncWatcher = _scheduler->installAsyncEvent(loop, this);
_readWatcher = _scheduler->installSocketEvent(loop, EVENT_SOCKET_READ, this, _commSocket);
_writeWatcher = _scheduler->installSocketEvent(loop, EVENT_SOCKET_WRITE, this, _commSocket);
if (readWatcher == nullptr || writeWatcher == nullptr) {
if (_readWatcher == nullptr || _writeWatcher == nullptr) {
return false;
}
// install timer for keep-alive timeout with some high default value
keepAliveWatcher = _scheduler->installTimerEvent(loop, this, 60.0);
_keepAliveWatcher = _scheduler->installTimerEvent(loop, this, 60.0);
// and stop it immediately so it's not actively at the start
_scheduler->clearTimer(keepAliveWatcher);
_scheduler->clearTimer(_keepAliveWatcher);
tid = Thread::currentThreadId();
_tid = Thread::currentThreadId();
return true;
}
@ -381,24 +381,24 @@ bool SocketTask::setup (Scheduler* scheduler, EventLoop loop) {
void SocketTask::cleanup () {
if (_scheduler == nullptr) {
LOG_WARNING("In SocketTask::cleanup the scheduler has disappeared -- invalid pointer");
watcher = nullptr;
keepAliveWatcher = nullptr;
readWatcher = nullptr;
writeWatcher = nullptr;
_asyncWatcher = nullptr;
_keepAliveWatcher = nullptr;
_readWatcher = nullptr;
_writeWatcher = nullptr;
return;
}
_scheduler->uninstallEvent(watcher);
watcher = nullptr;
_scheduler->uninstallEvent(_asyncWatcher);
_asyncWatcher = nullptr;
_scheduler->uninstallEvent(keepAliveWatcher);
keepAliveWatcher = nullptr;
_scheduler->uninstallEvent(_keepAliveWatcher);
_keepAliveWatcher = nullptr;
_scheduler->uninstallEvent(readWatcher);
readWatcher = nullptr;
_scheduler->uninstallEvent(_readWatcher);
_readWatcher = nullptr;
_scheduler->uninstallEvent(writeWatcher);
writeWatcher = nullptr;
_scheduler->uninstallEvent(_writeWatcher);
_writeWatcher = nullptr;
}
////////////////////////////////////////////////////////////////////////////////
@ -408,7 +408,7 @@ void SocketTask::cleanup () {
bool SocketTask::handleEvent (EventToken token, EventType revents) {
bool result = true;
if (token == keepAliveWatcher && (revents & EVENT_TIMER)) {
if (token == _keepAliveWatcher && (revents & EVENT_TIMER)) {
// got a keep-alive timeout
LOG_TRACE("got keep-alive timeout signal, closing connection");
@ -420,16 +420,16 @@ bool SocketTask::handleEvent (EventToken token, EventType revents) {
return false;
}
if (token == readWatcher && (revents & EVENT_SOCKET_READ)) {
if (keepAliveWatcher != nullptr) {
if (token == _readWatcher && (revents & EVENT_SOCKET_READ)) {
if (_keepAliveWatcher != nullptr) {
// disable timer for keep-alive timeout
_scheduler->clearTimer(keepAliveWatcher);
_scheduler->clearTimer(_keepAliveWatcher);
}
result = handleRead();
}
if (result && ! _clientClosed && token == writeWatcher) {
if (result && ! _clientClosed && token == _writeWatcher) {
if (revents & EVENT_SOCKET_WRITE) {
result = handleWrite();
}
@ -437,10 +437,10 @@ bool SocketTask::handleEvent (EventToken token, EventType revents) {
if (result) {
if (_writeBuffer == nullptr) {
_scheduler->stopSocketEvents(writeWatcher);
_scheduler->stopSocketEvents(_writeWatcher);
}
else {
_scheduler->startSocketEvents(writeWatcher);
_scheduler->startSocketEvents(_writeWatcher);
}
}

15
lib/Scheduler/SocketTask.h
View File

@ -205,25 +205,25 @@ namespace triagens {
/// @brief event for keep-alive timeout
////////////////////////////////////////////////////////////////////////////////
EventToken keepAliveWatcher;
EventToken _keepAliveWatcher;
////////////////////////////////////////////////////////////////////////////////
/// @brief event for read
////////////////////////////////////////////////////////////////////////////////
EventToken readWatcher;
EventToken _readWatcher;
////////////////////////////////////////////////////////////////////////////////
/// @brief event for write
////////////////////////////////////////////////////////////////////////////////
EventToken writeWatcher;
EventToken _writeWatcher;
////////////////////////////////////////////////////////////////////////////////
/// @brief event for async
////////////////////////////////////////////////////////////////////////////////
EventToken watcher;
EventToken _asyncWatcher;
////////////////////////////////////////////////////////////////////////////////
/// @brief communication socket
@ -260,13 +260,13 @@ namespace triagens {
/// client. If false, the writeBuffer is keep alive.
////////////////////////////////////////////////////////////////////////////////
bool ownBuffer;
bool _ownBuffer;
////////////////////////////////////////////////////////////////////////////////
/// @brief number of bytes already written
////////////////////////////////////////////////////////////////////////////////
size_t writeLength;
size_t _writeLength;
////////////////////////////////////////////////////////////////////////////////
/// @brief read buffer
@ -292,8 +292,7 @@ namespace triagens {
/// @brief current thread identifier
////////////////////////////////////////////////////////////////////////////////
TRI_tid_t tid;
TRI_tid_t _tid;
};
}
}