Viewing file:  TestSession.h (4.93 KB) -rw-r--r--
Select action/file-type:
 (+) |  (+) |  (+) | Code (+) | Session (+) |  (+) | SDB (+) |  (+) |  (+) |  (+) |  (+) |  (+) |
/*
* Phusion Passenger - https://www.phusionpassenger.com/
* Copyright (c) 2016-2018 Phusion Holding B.V.
*
* "Passenger", "Phusion Passenger" and "Union Station" are registered
* trademarks of Phusion Holding B.V.
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
#ifndef _PASSENGER_APPLICATION_POOL_TEST_SESSION_H_
#define _PASSENGER_APPLICATION_POOL_TEST_SESSION_H_
#include <boost/thread.hpp>
#include <string>
#include <cassert>
#include <IOTools/IOUtils.h>
#include <IOTools/BufferedIO.h>
#include <Core/ApplicationPool/AbstractSession.h>
namespace Passenger {
namespace ApplicationPool2 {
using namespace std;
/**
* The TestSession represents a session between the Core to the Application. There is a
* connection between the two, which is represented by a SocketPair having a first (Core side)
* and second (Application side) FD. These are also referred to as fd and peerFd.
*/
class TestSession: public AbstractSession {
private:
mutable boost::mutex syncher;
mutable unsigned int refcount;
pid_t pid;
string gupid;
string protocol;
ApiKey apiKey;
SocketPair connection;
BufferedIO peerBufferedIO;
unsigned int stickySessionId;
mutable bool closed;
mutable bool success;
mutable bool wantKeepAlive;
public:
TestSession()
: refcount(1),
pid(123),
gupid("gupid-123"),
protocol("session"),
stickySessionId(0),
closed(false),
success(false),
wantKeepAlive(false)
{ }
virtual void ref() const {
boost::lock_guard<boost::mutex> l(syncher);
assert(refcount > 0);
refcount++;
}
virtual void unref() const {
boost::lock_guard<boost::mutex> l(syncher);
assert(refcount > 0);
refcount--;
if (refcount == 0) {
if (!closed) {
closed = true;
success = false;
wantKeepAlive = false;
}
}
}
virtual pid_t getPid() const {
boost::lock_guard<boost::mutex> l(syncher);
return pid;
}
void setPid(pid_t p) {
boost::lock_guard<boost::mutex> l(syncher);
pid = p;
}
virtual StaticString getGupid() const {
boost::lock_guard<boost::mutex> l(syncher);
return gupid;
}
void setGupid(const string &v) {
boost::lock_guard<boost::mutex> l(syncher);
gupid = v;
}
virtual StaticString getProtocol() const {
boost::lock_guard<boost::mutex> l(syncher);
return protocol;
}
void setProtocol(const string &v) {
boost::lock_guard<boost::mutex> l(syncher);
protocol = v;
}
virtual unsigned int getStickySessionId() const {
boost::lock_guard<boost::mutex> l(syncher);
return stickySessionId;
}
void setStickySessionId(unsigned int v) {
boost::lock_guard<boost::mutex> l(syncher);
stickySessionId = v;
}
virtual const ApiKey &getApiKey() const {
return apiKey;
}
virtual int fd() const {
boost::lock_guard<boost::mutex> l(syncher);
return connection.first;
}
virtual int peerFd() const {
boost::lock_guard<boost::mutex> l(syncher);
return connection.second;
}
virtual BufferedIO &getPeerBufferedIO() {
boost::lock_guard<boost::mutex> l(syncher);
return peerBufferedIO;
}
virtual bool isClosed() const {
boost::lock_guard<boost::mutex> l(syncher);
return closed;
}
bool isSuccessful() const {
boost::lock_guard<boost::mutex> l(syncher);
return success;
}
bool wantsKeepAlive() const {
boost::lock_guard<boost::mutex> l(syncher);
return wantKeepAlive;
}
virtual void initiate(bool blocking = true) {
boost::lock_guard<boost::mutex> l(syncher);
connection = createUnixSocketPair(__FILE__, __LINE__);
peerBufferedIO = BufferedIO(connection.second);
if (!blocking) {
setNonBlocking(connection.first);
}
}
virtual void close(bool _success, bool _wantKeepAlive = false) {
boost::lock_guard<boost::mutex> l(syncher);
closed = true;
success = _success;
wantKeepAlive = _wantKeepAlive;
}
void closePeerFd() {
boost::lock_guard<boost::mutex> l(syncher);
connection.second.close();
}
};
} // namespace ApplicationPool2
} // namespace Passenger
#endif /* _PASSENGER_APPLICATION_POOL2_TEST_SESSION_H_ */
|