cleanup of member names

arangod/Aql/grammar.h

@@ -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

lib/HttpServer/ApplicationEndpointServer.cpp

@@ -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();

lib/HttpServer/HttpCommTask.cpp

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

lib/HttpServer/HttpCommTask.h

@@ -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

lib/HttpServer/HttpServer.cpp

@@ -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
 ////////////////////////////////////////////////////////////////////////////////

lib/HttpServer/HttpServer.h

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

lib/HttpServer/HttpsCommTask.cpp

@@ -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;
 }

lib/Scheduler/SocketTask.cpp

@@ -51,21 +51,21 @@ using namespace triagens::rest;
 
 SocketTask::SocketTask (TRI_socket_t socket, double keepAliveTimeout)
   : Task("SocketTask"),
-    keepAliveWatcher(nullptr),
+    _keepAliveWatcher(nullptr),
-    readWatcher(nullptr),
+    _readWatcher(nullptr),
-    writeWatcher(nullptr),
+    _writeWatcher(nullptr),
-    watcher(nullptr),
+    _asyncWatcher(nullptr),
     _commSocket(socket),
     _keepAliveTimeout(keepAliveTimeout),
     _writeBuffer(nullptr),
 #ifdef TRI_ENABLE_FIGURES
     _writeBufferStatistics(nullptr),
 #endif
-    ownBuffer(true),
+    _ownBuffer(true),
-    writeLength(0),
+    _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) {
+  if (_keepAliveWatcher != nullptr && timeout > 0.0) {
-    _scheduler->rearmTimer(keepAliveWatcher, timeout);
+    _scheduler->rearmTimer(_keepAliveWatcher, timeout);
   }
 }
 
@@ -174,14 +174,14 @@ bool SocketTask::handleWrite () {
   size_t len = 0;
 
   if (nullptr != _writeBuffer) {
-    TRI_ASSERT(_writeBuffer->length() >= writeLength);
+    TRI_ASSERT(_writeBuffer->length() >= _writeLength);
-    len = _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;
+  _scheduler = scheduler;
-  this->_loop = loop;
+  _loop = loop;
 
-  watcher = _scheduler->installAsyncEvent(loop, this);
+  _asyncWatcher = _scheduler->installAsyncEvent(loop, this);
-  readWatcher = _scheduler->installSocketEvent(loop, EVENT_SOCKET_READ, this, _commSocket);
+  _readWatcher = _scheduler->installSocketEvent(loop, EVENT_SOCKET_READ, this, _commSocket);
-  writeWatcher = _scheduler->installSocketEvent(loop, EVENT_SOCKET_WRITE, 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;
+    _asyncWatcher = nullptr;
-    keepAliveWatcher = nullptr;
+    _keepAliveWatcher = nullptr;
-    readWatcher = nullptr;
+    _readWatcher = nullptr;
-    writeWatcher = nullptr;
+    _writeWatcher = nullptr;
     return;
   }
 
-  _scheduler->uninstallEvent(watcher);
+  _scheduler->uninstallEvent(_asyncWatcher);
-  watcher = nullptr;
+  _asyncWatcher = nullptr;
 
-  _scheduler->uninstallEvent(keepAliveWatcher);
+  _scheduler->uninstallEvent(_keepAliveWatcher);
-  keepAliveWatcher = nullptr;
+  _keepAliveWatcher = nullptr;
 
-  _scheduler->uninstallEvent(readWatcher);
+  _scheduler->uninstallEvent(_readWatcher);
-  readWatcher = nullptr;
+  _readWatcher = nullptr;
 
-  _scheduler->uninstallEvent(writeWatcher);
+  _scheduler->uninstallEvent(_writeWatcher);
-  writeWatcher = nullptr;
+  _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 (token == _readWatcher && (revents & EVENT_SOCKET_READ)) {
-    if (keepAliveWatcher != nullptr) {
+    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);
     }
   }
 

lib/Scheduler/SocketTask.h

@@ -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;
-
     };
   }
 }