SocketClientAsync::SocketClientAsync(const std::string &socketPath, ProtocolPtr protocol)
: m_socket(socketPath, 0), m_protocol(protocol) {
+ m_readQueue = std::make_shared<BinaryQueue>();
+ m_writeQueue = std::make_shared<BinaryQueue>();
}
Socket::ConnectionStatus SocketClientAsync::connect(void) {
}
bool SocketClientAsync::isDataToSend(void) {
- return m_socket.isDataToSend() || !m_writeQueue.empty();
+ return m_socket.isDataToSend() || !m_writeQueue->empty();
}
Socket::SendStatus SocketClientAsync::sendToCynara(void) {
- return m_socket.sendToServer(m_writeQueue);
+ return m_socket.sendToServer(*m_writeQueue);
}
bool SocketClientAsync::receiveFromCynara(void) {
- return m_socket.receiveFromServer(m_readQueue);
+ return m_socket.receiveFromServer(*m_readQueue);
}
ResponsePtr SocketClientAsync::getResponse(void) {
private:
Socket m_socket;
ProtocolPtr m_protocol;
- BinaryQueue m_readQueue;
- BinaryQueue m_writeQueue;
+ BinaryQueuePtr m_readQueue;
+ BinaryQueuePtr m_writeQueue;
};
} // namespace Cynara
*/
class BinaryQueue;
typedef std::shared_ptr<BinaryQueue> BinaryQueuePtr;
+typedef std::weak_ptr<BinaryQueue> BinaryQueueWeakPtr;
/**
* Binary stream implemented as constant size bucket list
*
* @todo Add optimized implementation for FlattenConsume
*/
-class BinaryQueue
-{
- public:
+class BinaryQueue {
+public:
typedef void (*BufferDeleter)(const void *buffer, size_t bufferSize,
void *userParam);
static void bufferDeleterFree(const void *buffer,
size_t bufferSize,
void *userParam);
-
- private:
- struct Bucket
- {
- const void *buffer;
- const void *ptr;
- size_t size;
- size_t left;
-
- BufferDeleter deleter;
- void *param;
-
- Bucket(const void *buffer,
- size_t bufferSize,
- BufferDeleter deleter,
- void *userParam);
- ~Bucket();
- // make it noncopyable
- Bucket(const Bucket &) = delete;
- const Bucket &operator=(const Bucket &) = delete;
- // make it nonmoveable
- Bucket(Bucket &&) = delete;
- Bucket &operator=(Bucket &&) = delete;
- };
-
- typedef std::list<Bucket *> BucketList;
- BucketList m_buckets;
- size_t m_size;
-
- static void deleteBucket(Bucket *bucket);
-
- public:
/**
* Construct empty binary queue
*/
* is larger than available bytes in binary queue
*/
void flattenConsume(void *buffer, size_t bufferSize);
+
+private:
+ struct Bucket {
+ const void *buffer;
+ const void *ptr;
+ size_t size;
+ size_t left;
+
+ BufferDeleter deleter;
+ void *param;
+
+ Bucket(const void *buffer,
+ size_t bufferSize,
+ BufferDeleter deleter,
+ void *userParam);
+ ~Bucket();
+ // make it noncopyable
+ Bucket(const Bucket &) = delete;
+ const Bucket &operator=(const Bucket &) = delete;
+ // make it nonmoveable
+ Bucket(Bucket &&) = delete;
+ Bucket &operator=(Bucket &&) = delete;
+ };
+
+ typedef std::list<Bucket *> BucketList;
+ BucketList m_buckets;
+ size_t m_size;
+
+ static void deleteBucket(Bucket *bucket);
};
} // namespace Cynara
--- /dev/null
+/*
+ * Copyright (c) 2014 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * 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.
+ */
+/**
+ * @file src/common/exceptions/ContextErrorException.h
+ * @author Zofia Abramowska <z.abramowska@samsung.com>
+ * @version 1.0
+ * @brief Implementation of ContextErrorException.h
+ */
+
+#ifndef SRC_COMMON_EXCEPTIONS_CONTEXTERROREXCEPTION_H_
+#define SRC_COMMON_EXCEPTIONS_CONTEXTERROREXCEPTION_H_
+
+#include "Exception.h"
+
+namespace Cynara {
+
+class ContextErrorException : public Exception {
+public:
+ ContextErrorException() = default;
+ virtual ~ContextErrorException() {};
+
+ virtual const std::string message(void) const {
+ return "ContextErrorException";
+ }
+};
+
+} /* namespace Cynara */
+
+#endif /* SRC_COMMON_EXCEPTIONS_CONTEXTERROREXCEPTION_H_ */
virtual ProtocolPtr clone(void) = 0;
- virtual RequestPtr extractRequestFromBuffer(BinaryQueue &bufferQueue) = 0;
- virtual ResponsePtr extractResponseFromBuffer(BinaryQueue &bufferQueue) = 0;
+ virtual RequestPtr extractRequestFromBuffer(BinaryQueuePtr bufferQueue) = 0;
+ virtual ResponsePtr extractResponseFromBuffer(BinaryQueuePtr bufferQueue) = 0;
ProtocolFrameHeader &frameHeader(void) {
return m_frameHeader;
m_frameHeader.sequenceNumber());
}
-RequestPtr ProtocolAdmin::extractRequestFromBuffer(BinaryQueue &bufferQueue) {
+RequestPtr ProtocolAdmin::extractRequestFromBuffer(BinaryQueuePtr bufferQueue) {
ProtocolFrameSerializer::deserializeHeader(m_frameHeader, bufferQueue);
if (m_frameHeader.isFrameComplete()) {
m_frameHeader.sequenceNumber());
}
-ResponsePtr ProtocolAdmin::extractResponseFromBuffer(BinaryQueue &bufferQueue) {
+ResponsePtr ProtocolAdmin::extractResponseFromBuffer(BinaryQueuePtr bufferQueue) {
ProtocolFrameSerializer::deserializeHeader(m_frameHeader, bufferQueue);
if (m_frameHeader.isFrameComplete()) {
ProtocolSerialization::serialize(frame, request->startBucket());
ProtocolSerialization::serialize(frame, request->recursive());
- ProtocolFrameSerializer::finishSerialization(frame, context->responseQueue());
+ ProtocolFrameSerializer::finishSerialization(frame, *(context->responseQueue()));
}
void ProtocolAdmin::execute(RequestContextPtr context, InsertOrUpdateBucketRequestPtr request) {
ProtocolSerialization::serialize(frame, request->result().policyType());
ProtocolSerialization::serialize(frame, request->result().metadata());
- ProtocolFrameSerializer::finishSerialization(frame, context->responseQueue());
+ ProtocolFrameSerializer::finishSerialization(frame, *(context->responseQueue()));
}
void ProtocolAdmin::execute(RequestContextPtr context, RemoveBucketRequestPtr request) {
ProtocolSerialization::serialize(frame, OpRemoveBucket);
ProtocolSerialization::serialize(frame, request->bucketId());
- ProtocolFrameSerializer::finishSerialization(frame, context->responseQueue());
+ ProtocolFrameSerializer::finishSerialization(frame, *(context->responseQueue()));
}
void ProtocolAdmin::execute(RequestContextPtr context, SetPoliciesRequestPtr request) {
}
}
- ProtocolFrameSerializer::finishSerialization(frame, context->responseQueue());
+ ProtocolFrameSerializer::finishSerialization(frame, *(context->responseQueue()));
}
void ProtocolAdmin::execute(RequestContextPtr context, CheckResponsePtr response) {
ProtocolSerialization::serialize(frame, response->m_resultRef.policyType());
ProtocolSerialization::serialize(frame, response->m_resultRef.metadata());
- ProtocolFrameSerializer::finishSerialization(frame, context->responseQueue());
+ ProtocolFrameSerializer::finishSerialization(frame, *(context->responseQueue()));
}
void ProtocolAdmin::execute(RequestContextPtr context, CodeResponsePtr response) {
ProtocolSerialization::serialize(frame, OpCodeResponse);
ProtocolSerialization::serialize(frame, static_cast<ProtocolResponseCode>(response->m_code));
- ProtocolFrameSerializer::finishSerialization(frame, context->responseQueue());
+ ProtocolFrameSerializer::finishSerialization(frame, *(context->responseQueue()));
}
} // namespace Cynara
virtual ProtocolPtr clone(void);
- virtual RequestPtr extractRequestFromBuffer(BinaryQueue &bufferQueue);
- virtual ResponsePtr extractResponseFromBuffer(BinaryQueue &bufferQueue);
+ virtual RequestPtr extractRequestFromBuffer(BinaryQueuePtr bufferQueue);
+ virtual ResponsePtr extractResponseFromBuffer(BinaryQueuePtr bufferQueue);
virtual void execute(RequestContextPtr context, AdminCheckRequestPtr request);
virtual void execute(RequestContextPtr context, InsertOrUpdateBucketRequestPtr request);
m_frameHeader.sequenceNumber());
}
-RequestPtr ProtocolClient::extractRequestFromBuffer(BinaryQueue &bufferQueue) {
+RequestPtr ProtocolClient::extractRequestFromBuffer(BinaryQueuePtr bufferQueue) {
ProtocolFrameSerializer::deserializeHeader(m_frameHeader, bufferQueue);
if (m_frameHeader.isFrameComplete()) {
return std::make_shared<CheckResponse>(policyResult, m_frameHeader.sequenceNumber());
}
-ResponsePtr ProtocolClient::extractResponseFromBuffer(BinaryQueue &bufferQueue) {
+ResponsePtr ProtocolClient::extractResponseFromBuffer(BinaryQueuePtr bufferQueue) {
ProtocolFrameSerializer::deserializeHeader(m_frameHeader, bufferQueue);
if (m_frameHeader.isFrameComplete()) {
ProtocolSerialization::serialize(frame, OpCancelRequest);
- ProtocolFrameSerializer::finishSerialization(frame, context->responseQueue());
+ ProtocolFrameSerializer::finishSerialization(frame, *(context->responseQueue()));
}
void ProtocolClient::execute(RequestContextPtr context, CheckRequestPtr request) {
ProtocolSerialization::serialize(frame, request->key().user().value());
ProtocolSerialization::serialize(frame, request->key().privilege().value());
- ProtocolFrameSerializer::finishSerialization(frame, context->responseQueue());
+ ProtocolFrameSerializer::finishSerialization(frame, *(context->responseQueue()));
}
void ProtocolClient::execute(RequestContextPtr context, CancelResponsePtr response) {
ProtocolSerialization::serialize(frame, OpCancelResponse);
- ProtocolFrameSerializer::finishSerialization(frame, context->responseQueue());
+ ProtocolFrameSerializer::finishSerialization(frame, *(context->responseQueue()));
}
void ProtocolClient::execute(RequestContextPtr context, CheckResponsePtr response) {
ProtocolSerialization::serialize(frame, response->m_resultRef.policyType());
ProtocolSerialization::serialize(frame, response->m_resultRef.metadata());
- ProtocolFrameSerializer::finishSerialization(frame, context->responseQueue());
+ ProtocolFrameSerializer::finishSerialization(frame, *(context->responseQueue()));
}
} // namespace Cynara
virtual ProtocolPtr clone(void);
- virtual RequestPtr extractRequestFromBuffer(BinaryQueue &bufferQueue);
- virtual ResponsePtr extractResponseFromBuffer(BinaryQueue &bufferQueue);
+ virtual RequestPtr extractRequestFromBuffer(BinaryQueuePtr bufferQueue);
+ virtual ResponsePtr extractResponseFromBuffer(BinaryQueuePtr bufferQueue);
virtual void execute(RequestContextPtr context, CancelRequestPtr request);
virtual void execute(RequestContextPtr context, CheckRequestPtr request);
namespace Cynara {
void ProtocolFrameSerializer::deserializeHeader(ProtocolFrameHeader &frameHeader,
- BinaryQueue &data) {
+ BinaryQueuePtr data) {
if (!frameHeader.isHeaderComplete()) {
- if ((data.size() < ProtocolFrameHeader::frameHeaderLength())) {
+ if ((data->size() < ProtocolFrameHeader::frameHeaderLength())) {
return;
}
LOGD("Deserializing frameHeader");
- frameHeader.setHeaderContent(BinaryQueuePtr(&data, [=] (BinaryQueue *) {}));
+ frameHeader.setHeaderContent(data);
ProtocolFrameSignature signature;
ProtocolDeserialization::deserialize(frameHeader, frameHeader.m_signature.length(),
frameHeader.setHeaderComplete();
}
- if (data.size() >= (frameHeader.frameLength() - ProtocolFrameHeader::frameHeaderLength())) {
+ if (data->size() >= (frameHeader.frameLength() - ProtocolFrameHeader::frameHeaderLength())) {
frameHeader.setBodyComplete();
}
}
class ProtocolFrameSerializer {
public:
- static void deserializeHeader(ProtocolFrameHeader &frameHeader, BinaryQueue &data);
+ static void deserializeHeader(ProtocolFrameHeader &frameHeader, BinaryQueuePtr data);
static ProtocolFrame startSerialization(ProtocolFrameSequenceNumber sequenceNumber);
static void finishSerialization(ProtocolFrame &frame, BinaryQueue &data);
};
return std::make_shared<ProtocolSignal>();
}
-RequestPtr ProtocolSignal::extractRequestFromBuffer(BinaryQueue &bufferQueue) {
- if (bufferQueue.size() >= sizeof(struct signalfd_siginfo)) {
+RequestPtr ProtocolSignal::extractRequestFromBuffer(BinaryQueuePtr bufferQueue) {
+ if (bufferQueue->size() >= sizeof(struct signalfd_siginfo)) {
struct signalfd_siginfo sigInfo;
- bufferQueue.flattenConsume(&sigInfo, sizeof(sigInfo));
+ bufferQueue->flattenConsume(&sigInfo, sizeof(sigInfo));
return std::make_shared<SignalRequest>(sigInfo);
}
return nullptr;
}
-ResponsePtr ProtocolSignal::extractResponseFromBuffer(BinaryQueue &bufferQueue UNUSED) {
+ResponsePtr ProtocolSignal::extractResponseFromBuffer(BinaryQueuePtr bufferQueue UNUSED) {
throw NotImplementedException();
}
virtual ProtocolPtr clone(void);
- virtual RequestPtr extractRequestFromBuffer(BinaryQueue &bufferQueue);
- virtual ResponsePtr extractResponseFromBuffer(BinaryQueue &bufferQueue);
+ virtual RequestPtr extractRequestFromBuffer(BinaryQueuePtr bufferQueue);
+ virtual ResponsePtr extractResponseFromBuffer(BinaryQueuePtr bufferQueue);
virtual void execute(RequestContextPtr context, SignalRequestPtr request);
};
#include <memory>
#include <containers/BinaryQueue.h>
+#include <exceptions/ContextErrorException.h>
#include <request/pointers.h>
#include <response/pointers.h>
#include <response/Response.h>
class RequestContext {
private:
ResponseTakerWeakPtr m_responseTaker;
- BinaryQueue &m_responseQueue;
+ BinaryQueueWeakPtr m_responseQueue;
public:
- RequestContext(ResponseTakerPtr responseTaker, BinaryQueue &responseQueue)
+ RequestContext(ResponseTakerPtr responseTaker, BinaryQueuePtr responseQueue)
: m_responseTaker(responseTaker), m_responseQueue(responseQueue) {
}
response->execute(response, taker, self);
}
- BinaryQueue &responseQueue(void) const {
- return m_responseQueue;
+ BinaryQueuePtr responseQueue(void) const {
+ auto bbqPtr = m_responseQueue.lock();
+ if (bbqPtr)
+ return bbqPtr;
+ throw ContextErrorException();
}
};
SocketClient::SocketClient(const std::string &socketPath, ProtocolPtr protocol)
: m_socket(socketPath), m_protocol(protocol) {
+ m_writeQueue = std::make_shared<BinaryQueue>();
+ m_readQueue = std::make_shared<BinaryQueue>();
}
bool SocketClient::connect(void) {
request->execute(request, m_protocol, context);
//send request to cynara
- if (m_socket.sendToServer(m_writeQueue) == Socket::SendStatus::CONNECTION_LOST) {
+ if (m_socket.sendToServer(*m_writeQueue) == Socket::SendStatus::CONNECTION_LOST) {
LOGW("Disconnected while sending request to Cynara.");
return nullptr;
}
// receive response from cynara
while (true) {
- if (!m_socket.receiveFromServer(m_readQueue)) {
+ if (!m_socket.receiveFromServer(*m_readQueue)) {
LOGW("Disconnected while receiving response from Cynara.");
return nullptr;
}
private:
Socket m_socket;
ProtocolPtr m_protocol;
- BinaryQueue m_readQueue;
- BinaryQueue m_writeQueue;
+ BinaryQueuePtr m_readQueue;
+ BinaryQueuePtr m_writeQueue;
public:
SocketClient(const std::string &socketPath, ProtocolPtr protocol);
Descriptor::Descriptor() : m_listen(false), m_used(false), m_client(false), m_protocol(nullptr) {
}
+void Descriptor::checkQueues(void) {
+ if (!m_writeQueue)
+ m_writeQueue = std::make_shared<BinaryQueue>();
+ if (!m_readQueue)
+ m_readQueue = std::make_shared<BinaryQueue>();
+}
+
bool Descriptor::hasDataToWrite(void) const {
- return !(m_writeQueue.empty() && m_writeBuffer.empty());
+ if (m_writeQueue)
+ return !(m_writeQueue->empty() && m_writeBuffer.empty());
+ return false;
}
ResponseTakerPtr Descriptor::responseTaker(void) const {
}
void Descriptor::pushReadBuffer(const RawBuffer &readbuffer) {
- m_readQueue.appendCopy(readbuffer.data(), readbuffer.size());
+ checkQueues();
+ m_readQueue->appendCopy(readbuffer.data(), readbuffer.size());
}
RequestPtr Descriptor::extractRequest(void) {
+ checkQueues();
return m_protocol->extractRequestFromBuffer(m_readQueue);
}
RawBuffer &Descriptor::prepareWriteBuffer(void) {
- size_t queuedDataSize = m_writeQueue.size();
+ checkQueues();
+ size_t queuedDataSize = m_writeQueue->size();
size_t bufferDataSize = m_writeBuffer.size();
m_writeBuffer.resize(queuedDataSize + bufferDataSize);
- m_writeQueue.flattenConsume(m_writeBuffer.data() + bufferDataSize, queuedDataSize);
+ m_writeQueue->flattenConsume(m_writeBuffer.data() + bufferDataSize, queuedDataSize);
return m_writeBuffer;
}
m_listen = false;
m_used = false;
m_client = false;
- m_readQueue.clear();
- m_writeQueue.clear();
+ m_readQueue.reset();
+ m_writeQueue.reset();
m_writeBuffer.clear();
m_protocol.reset();
}
namespace Cynara {
class Descriptor {
-private:
- bool m_listen;
- bool m_used;
- bool m_client;
-
- BinaryQueue m_readQueue;
- BinaryQueue m_writeQueue;
- RawBuffer m_writeBuffer;
-
- ProtocolPtr m_protocol;
-
public:
Descriptor();
ResponseTakerPtr responseTaker(void) const;
- BinaryQueue &writeQueue(void) {
+ BinaryQueuePtr writeQueue(void) {
return m_writeQueue;
}
RawBuffer &prepareWriteBuffer(void);
void clear(void);
+
+private:
+ bool m_listen;
+ bool m_used;
+ bool m_client;
+
+ BinaryQueuePtr m_readQueue;
+ BinaryQueuePtr m_writeQueue;
+ RawBuffer m_writeBuffer;
+
+ ProtocolPtr m_protocol;
+
+ void checkQueues(void);
};
} // namespace Cynara