21 #include "kinetic/kinetic_connection_factory.h"
22 #include "socket_wrapper.h"
23 #include "nonblocking_packet_service.h"
29 KineticConnectionFactory NewKineticConnectionFactory() {
30 HmacProvider hmac_provider;
31 return KineticConnectionFactory(hmac_provider);
34 KineticConnectionFactory::KineticConnectionFactory(
35 HmacProvider hmac_provider)
36 : hmac_provider_(hmac_provider) {}
41 unique_ptr<NonblockingKineticConnection>& connection) {
42 return doNewConnection(options, connection);
47 shared_ptr<NonblockingKineticConnection>& connection) {
48 unique_ptr<NonblockingKineticConnection> nbc(
nullptr);
49 Status status = doNewConnection(options, nbc);
51 connection.reset(nbc.release());
57 unique_ptr<ThreadsafeNonblockingKineticConnection>& connection) {
58 unique_ptr<NonblockingKineticConnection> nbc(
nullptr);
59 Status status = doNewConnection(options, nbc);
67 shared_ptr<ThreadsafeNonblockingKineticConnection>& connection) {
68 unique_ptr<NonblockingKineticConnection> nbc(
nullptr);
69 Status status = doNewConnection(options, nbc);
77 unique_ptr<BlockingKineticConnection>& connection,
78 unsigned int network_timeout_seconds) {
79 unique_ptr<NonblockingKineticConnection> nbc(
nullptr);
80 Status status = doNewConnection(options, nbc);
88 shared_ptr<BlockingKineticConnection>& connection,
89 unsigned int network_timeout_seconds) {
90 unique_ptr<NonblockingKineticConnection> nbc(
nullptr);
91 Status status = doNewConnection(options, nbc);
99 unique_ptr<ThreadsafeBlockingKineticConnection>& connection,
100 unsigned int network_timeout_seconds) {
101 unique_ptr<BlockingKineticConnection> bc(
nullptr);
110 shared_ptr<ThreadsafeBlockingKineticConnection>& connection,
111 unsigned int network_timeout_seconds) {
112 unique_ptr<BlockingKineticConnection> bc(
nullptr);
119 Status KineticConnectionFactory::doNewConnection(
120 ConnectionOptions
const& options,
121 unique_ptr <NonblockingKineticConnection>& connection) {
123 auto socket_wrapper = make_shared<SocketWrapper>(options.host, options.port, options.use_ssl,
true);
124 if (!socket_wrapper->Connect())
125 throw std::runtime_error(
"Could not connect to socket.");
127 shared_ptr<NonblockingReceiverInterface> receiver;
128 receiver = shared_ptr<NonblockingReceiverInterface>(
new NonblockingReceiver(socket_wrapper, hmac_provider_, options));
130 auto writer_factory =
131 unique_ptr<NonblockingPacketWriterFactoryInterface>(
new NonblockingPacketWriterFactory());
132 auto sender = unique_ptr<NonblockingSenderInterface>(
new NonblockingSender(socket_wrapper,
133 receiver, move(writer_factory), hmac_provider_, options));
135 NonblockingPacketService *service =
new NonblockingPacketService(socket_wrapper, move(sender), receiver);
136 connection.reset(
new NonblockingKineticConnection(service));
138 }
catch(std::exception& e){
static Status makeInternalError(std::string error_message)
Helper for easily making a Status object indicating a generic error.
Kinetic connection class variant that synchronizes concurrent access and allows non-blocking IO...
Status NewThreadsafeNonblockingConnection(const ConnectionOptions &options, unique_ptr< ThreadsafeNonblockingKineticConnection > &connection)
Like NewNonblockingConnection, except the connection is safe for use by multiple threads.
Status NewNonblockingConnection(const ConnectionOptions &options, unique_ptr< NonblockingKineticConnection > &connection)
Creates and opens a new nonblocking connection using the given options. If the returned Status indica...
Status NewBlockingConnection(const ConnectionOptions &options, unique_ptr< BlockingKineticConnection > &connection, unsigned int network_timeout_seconds)
Creates and opens a new blocking connection using the given options. If the returned Status indicates...
static Status makeOk()
Helper for easily making a Status object indicating success.
bool ok() const
True if the operation succeeded.
Status NewThreadsafeBlockingConnection(const ConnectionOptions &options, unique_ptr< ThreadsafeBlockingKineticConnection > &connection, unsigned int network_timeout_seconds)
Like NewBlockingConnection, except the connection is safe for use by multiple threads.
Use this struct to pass all connection options to the KineticConnectionFactory.
Indicates the success/failure of an operation. Frequently when calling a Kinetic client method you'll...