-
Notifications
You must be signed in to change notification settings - Fork 584
/
Connection.h
203 lines (170 loc) · 5.02 KB
/
Connection.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
/* -*- C++ -*-; c-basic-offset: 4; indent-tabs-mode: nil */
/*!
* @file Connection.h
* @brief Interface definition file for Connection
*/
/* Copyright (c) 2009 Webroot Software, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may not
* use this file except in compliance with the License. You may obtain a copy of
* the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations under
* the License.
*/
#ifndef CONNECTION_H
#define CONNECTION_H
#include <voldemort/ClientConfig.h>
#include "RequestFormat.h"
#include <streambuf>
#include <sstream>
#include <iostream>
#include <boost/asio.hpp>
#include <boost/thread/condition_variable.hpp>
namespace Voldemort {
using namespace boost;
using asio::ip::tcp;
class ConnectionBuffer;
/**
* Connection class holds a persistent connection to a Voldemort
* server
*/
class Connection {
public:
/**
* Construct a new Connection object
*
* @param hostName the host to connect to
* @param portNum the port to connect to
* @param negString the protocol negotiation string
* @param conf the client config object */
Connection(const std::string& hostName,
const std::string& portNum,
const std::string& negString,
shared_ptr<ClientConfig>& conf);
~Connection();
/**
* Connect to the remote host
*/
void connect();
/**
* Close the underlying connection. After calling this the
* Connection object cannot be used.
*/
void close();
/**
* Get a stream object for this connection that supports
* appropriate buffering and timeouts.
*
* @return the stream
*/
std::iostream& get_io_stream();
/**
* Read some data from the socket up to the provided bufferLen
* into buffer. May read less than bufferLen.
*
* @param buffer the buffer to read into
* @param bufferLen the maximum number of bytes
* @return the number of bytes read
*/
size_t read_some(char* buffer, size_t bufferLen);
/**
* Write the data provided to the socket from the buffer. Will
* write all the data or generate an error.
*
* @param buffer the buffer to read from
* @param bufferLen the bytes to write
* @return the number of bytes written
*/
size_t write(const char* buffer, size_t bufferLen);
/**
* Checks whether the provided connection is still good
*
* @return whether the connection is functioning
*/
bool is_active();
/**
* Get the host for this connection
*
* @return The host string
*/
std::string& get_host();
/**
* Get the port for this connection
*
* @return The port string
*/
std::string& get_port();
private:
void wait_for_operation(long millis);
void timeout();
void handle_connect(const boost::system::error_code& err,
tcp::resolver::iterator endpoint_iterator);
void handle_resolve(const boost::system::error_code& err,
tcp::resolver::iterator endpoint_iterator);
#if 0
void handle_data_op(const boost::system::error_code& err,
size_t transferred);
#endif
void check_error(const boost::system::error_code& err);
shared_ptr<ClientConfig> config;
std::string host;
std::string port;
std::string negotiationString;
asio::io_service io_service;
tcp::resolver resolver;
asio::deadline_timer timer;
tcp::socket socket;
bool op_timeout;
bool op_complete;
size_t bytesTransferred;
ConnectionBuffer* connbuf;
std::iostream* connstream;
bool active;
};
/** Stream buffer used to construct iostream */
class ConnectionBuffer
: public std::basic_streambuf<char>
{
public:
/**
* Create a new connection buffer object connected to the given
* @ref Connection.
*/
explicit ConnectionBuffer(Connection& con);
virtual ~ConnectionBuffer();
/**
* Implementation of basic_streambuf::overflow
*
* @param c the overflow character
* @return status information
*/
virtual traits_type::int_type overflow(traits_type::int_type c = EOF);
/**
* Implementation of basic_streambuf::underflow
*
* @return status information
*/
virtual traits_type::int_type underflow();
/**
* Implementation of basic_streambuf::sync
*
* @return status information
*/
virtual int sync();
private:
void init_buffers();
Connection& conn;
enum { putback_max = 8 };
enum { buffer_size = 8196 };
boost::array<char, buffer_size> get_buffer_;
boost::array<char, buffer_size> put_buffer_;
bool unbuffered_;
};
} /* namespace Voldemort */
#endif /* CONNECTION_H */