jessequ
/
qamqp
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

use Q_Q/Q_D from Qt rather than P_Q/P_D, style cleanups for Qt coding style 

delete exception-related code, as Qt does not officially support them anymore
This commit is contained in:
Matt Broadstone 2014-05-28 12:25:28 -04:00
parent 387af4038e
commit c069b063d3
25 changed files with 4134 additions and 4301 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

282
src/qamqp/amqp.cpp
View File

@ -7,6 +7,7 @@
#include "amqp_exchange_p.h"
#include "amqp_queue.h"
#include "amqp_queue_p.h"
#include "amqp_connection_p.h"
#include "amqp_authenticator.h"
using namespace QAMQP;
@ -31,56 +32,47 @@ struct ClientExceptionCleaner
//////////////////////////////////////////////////////////////////////////
ClientPrivate::ClientPrivate( Client * q ) :
port(AMQPPORT)
, host(QString::fromLatin1(AMQPHOST))
, virtualHost(QString::fromLatin1(AMQPVHOST))
, pq_ptr(q)
ClientPrivate::ClientPrivate(Client * q)
: port(AMQPPORT),
host(QString::fromLatin1(AMQPHOST)),
virtualHost(QString::fromLatin1(AMQPVHOST)),
q_ptr(q)
{
}
ClientPrivate::~ClientPrivate()
{
}
void ClientPrivate::init(QObject * parent)
void ClientPrivate::init(QObject *parent)
{
pq_func()->setParent(parent);
if(!network_)
{
network_ = new QAMQP::Network(pq_func());
}
if(!connection_)
{
connection_ = new QAMQP::Connection(pq_func());
}
Q_Q(QAMQP::Client);
q->setParent(parent);
if (!network_)
network_ = new QAMQP::Network(q);
if (!connection_)
connection_ = new QAMQP::Connection(q);
network_->setMethodHandlerConnection(connection_);
setAuth(new AMQPlainAuthenticator(QString::fromLatin1(AMQPLOGIN), QString::fromLatin1(AMQPPSWD)));
QObject::connect(connection_, SIGNAL(connected()), pq_func(), SIGNAL(connected()));
QObject::connect(connection_, SIGNAL(disconnected()), pq_func(), SIGNAL(disconnected()));
QObject::connect(connection_, SIGNAL(connected()), q, SIGNAL(connected()));
QObject::connect(connection_, SIGNAL(disconnected()), q, SIGNAL(disconnected()));
}
void ClientPrivate::init(QObject * parent, const QUrl & con)
void ClientPrivate::init(QObject *parent, const QUrl &connectionString)
{
init(parent);
parseCnnString(con);
ClientPrivate::connect();
parseConnectionString(connectionString);
connect();
}
void ClientPrivate::setAuth( Authenticator* auth )
void ClientPrivate::setAuth(Authenticator *auth)
{
auth_ = QSharedPointer<Authenticator>(auth);
}
void ClientPrivate::printConnect() const
{
QTextStream stream(stdout);
@ -88,176 +80,161 @@ void ClientPrivate::printConnect() const
stream << "host = " << host << endl;
stream << "vhost = " << virtualHost << endl;
if(auth_ && auth_->type() == "AMQPLAIN")
{
if (auth_ && auth_->type() == QLatin1String("AMQPLAIN")) {
QSharedPointer<AMQPlainAuthenticator> a = auth_.staticCast<AMQPlainAuthenticator>();
stream << "user = " << a->login() << endl;
stream << "passw = " << a->password() << endl;
}
}
void ClientPrivate::connect()
{
ClientPrivate::sockConnect();
ClientPrivate::login();
sockConnect();
login();
}
void ClientPrivate::parseCnnString( const QUrl & con )
void ClientPrivate::parseConnectionString(const QUrl &connectionString)
{
P_Q(QAMQP::Client);
if(con.scheme() == AMQPSCHEME || con.scheme() == AMQPSSCHEME )
{
q->setSsl(con.scheme() == AMQPSSCHEME);
q->setPassword(con.password());
q->setUser(con.userName());
q->setPort(con.port(AMQPPORT));
q->setHost(con.host());
q->setVirtualHost(con.path());
Q_Q(QAMQP::Client);
if (connectionString.scheme() != AMQPSCHEME &&
connectionString.scheme() != AMQPSSCHEME) {
qDebug() << Q_FUNC_INFO << "invalid scheme: " << connectionString.scheme();
return;
}
q->setSsl(connectionString.scheme() == AMQPSSCHEME);
q->setPassword(connectionString.password());
q->setUser(connectionString.userName());
q->setPort(connectionString.port(AMQPPORT));
q->setHost(connectionString.host());
q->setVirtualHost(connectionString.path());
}
void ClientPrivate::sockConnect()
{
if(network_->state() != QAbstractSocket::UnconnectedState )
{
if (network_->state() != QAbstractSocket::UnconnectedState)
disconnect();
}
network_->connectTo(host, port);
}
void ClientPrivate::login()
{
}
Exchange * ClientPrivate::createExchange(int channelNumber, const QString &name )
Exchange *ClientPrivate::createExchange(int channelNumber, const QString &name)
{
Exchange * exchange_ = new Exchange(channelNumber, pq_func());
Q_Q(QAMQP::Client);
Exchange * exchange_ = new Exchange(channelNumber, q);
network_->addMethodHandlerForChannel(exchange_->channelNumber(), exchange_);
QObject::connect(connection_, SIGNAL(connected()), exchange_, SLOT(_q_open()));
exchange_->pd_func()->open();
QObject::connect(pq_func(), SIGNAL(disconnected()), exchange_, SLOT(_q_disconnected()));
exchange_->d_func()->open();
QObject::connect(q, SIGNAL(disconnected()), exchange_, SLOT(_q_disconnected()));
exchange_->setName(name);
return exchange_;
}
Queue * ClientPrivate::createQueue(int channelNumber, const QString &name )
Queue *ClientPrivate::createQueue(int channelNumber, const QString &name )
{
Queue * queue_ = new Queue(channelNumber, pq_func());
Q_Q(QAMQP::Client);
Queue *queue_ = new Queue(channelNumber, q);
network_->addMethodHandlerForChannel(queue_->channelNumber(), queue_);
network_->addContentHandlerForChannel(queue_->channelNumber(), queue_);
network_->addContentBodyHandlerForChannel(queue_->channelNumber(), queue_);
QObject::connect(connection_, SIGNAL(connected()), queue_, SLOT(_q_open()));
queue_->pd_func()->open();
QObject::connect(pq_func(), SIGNAL(disconnected()), queue_, SLOT(_q_disconnected()));
queue_->d_func()->open();
QObject::connect(q, SIGNAL(disconnected()), queue_, SLOT(_q_disconnected()));
queue_->setName(name);
return queue_;
}
void ClientPrivate::disconnect()
{
P_Q(QAMQP::Client);
Q_UNUSED(q);
if(network_->state() != QAbstractSocket::UnconnectedState)
{
network_->QAMQP::Network::disconnect();
connection_->pd_func()->connected = false;
emit pq_func()->disconnected();
Q_Q(QAMQP::Client);
if (network_->state() != QAbstractSocket::UnconnectedState) {
network_->disconnect();
connection_->d_func()->connected = false;
Q_EMIT q->disconnected();
}
}
//////////////////////////////////////////////////////////////////////////
QAMQP::Client::Client( QObject * parent /*= 0*/ )
: pd_ptr(new ClientPrivate(this))
QAMQP::Client::Client(QObject *parent)
: QObject(parent),
d_ptr(new ClientPrivate(this))
{
QT_TRY {
pd_func()->init(parent);
} QT_CATCH(...) {
ClientExceptionCleaner::cleanup(this, pd_func());
QT_RETHROW;
}
d_ptr->init(parent);
}
QAMQP::Client::Client( const QUrl & connectionString, QObject * parent /*= 0*/ )
: pd_ptr(new ClientPrivate(this))
QAMQP::Client::Client(const QUrl & connectionString, QObject * parent)
: d_ptr(new ClientPrivate(this))
{
QT_TRY {
pd_func()->init(parent, connectionString);
} QT_CATCH(...) {
ClientExceptionCleaner::cleanup(this, pd_func());
QT_RETHROW;
}
d_ptr->init(parent, connectionString);
}
QAMQP::Client::~Client()
{
QT_TRY {
QEvent e(QEvent::Destroy);
QCoreApplication::sendEvent(this, &e);
} QT_CATCH(const std::exception&) {
// if this fails we can't do anything about it but at least we are not allowed to throw.
}
}
quint32 QAMQP::Client::port() const
quint16 QAMQP::Client::port() const
{
return pd_func()->port;
Q_D(const QAMQP::Client);
return d->port;
}
void QAMQP::Client::setPort( quint32 port )
void QAMQP::Client::setPort(quint16 port)
{
pd_func()->port = port;
Q_D(QAMQP::Client);
d->port = port;
}
QString QAMQP::Client::host() const
{
return pd_func()->host;
Q_D(const QAMQP::Client);
return d->host;
}
void QAMQP::Client::setHost( const QString & host )
{
pd_func()->host = host;
Q_D(QAMQP::Client);
d->host = host;
}
QString QAMQP::Client::virtualHost() const
{
return pd_func()->virtualHost;
Q_D(const QAMQP::Client);
return d->virtualHost;
}
void QAMQP::Client::setVirtualHost( const QString & virtualHost )
void QAMQP::Client::setVirtualHost(const QString &virtualHost)
{
pd_func()->virtualHost = virtualHost;
Q_D(QAMQP::Client);
d->virtualHost = virtualHost;
}
QString QAMQP::Client::user() const
{
const Authenticator * auth = pd_func()->auth_.data();
if(auth && auth->type() == "AMQPLAIN")
{
Q_D(const QAMQP::Client);
const Authenticator * auth = d->auth_.data();
if (auth && auth->type() == QLatin1String("AMQPLAIN")) {
const AMQPlainAuthenticator * a = static_cast<const AMQPlainAuthenticator *>(auth);
return a->login();
}
return QString();
}
void QAMQP::Client::setUser( const QString & user )
void QAMQP::Client::setUser(const QString &user)
{
Authenticator * auth = pd_func()->auth_.data();
if(auth && auth->type() == "AMQPLAIN")
{
Q_D(const QAMQP::Client);
Authenticator * auth = d->auth_.data();
if (auth && auth->type() == QLatin1String("AMQPLAIN")) {
AMQPlainAuthenticator * a = static_cast<AMQPlainAuthenticator *>(auth);
a->setLogin(user);
}
@ -265,22 +242,21 @@ void QAMQP::Client::setUser( const QString & user )
QString QAMQP::Client::password() const
{
const Authenticator * auth = pd_func()->auth_.data();
if(auth && auth->type() == "AMQPLAIN")
{
Q_D(const QAMQP::Client);
const Authenticator * auth = d->auth_.data();
if (auth && auth->type() == "AMQPLAIN") {
const AMQPlainAuthenticator * a = static_cast<const AMQPlainAuthenticator *>(auth);
return a->password();
}
return QString();
}
void QAMQP::Client::setPassword( const QString & password )
void QAMQP::Client::setPassword(const QString &password)
{
Authenticator * auth = pd_func()->auth_.data();
if(auth && auth->type() == "AMQPLAIN")
{
Q_D(QAMQP::Client);
Authenticator *auth = d->auth_.data();
if (auth && auth->type() == QLatin1String("AMQPLAIN")) {
AMQPlainAuthenticator * a = static_cast<AMQPlainAuthenticator *>(auth);
a->setPassword(password);
}
@ -289,98 +265,116 @@ void QAMQP::Client::setPassword( const QString & password )
void QAMQP::Client::printConnect() const
{
#ifdef _DEBUG
pd_func()->printConnect();
Q_D(const QAMQP::Client);
d->printConnect();
#endif // _DEBUG
}
void QAMQP::Client::closeChannel()
{
}
Exchange * QAMQP::Client::createExchange(int channelNumber)
Exchange *QAMQP::Client::createExchange(int channelNumber)
{
return pd_func()->createExchange(channelNumber, QString());
Q_D(QAMQP::Client);
return d->createExchange(channelNumber, QString());
}
Exchange * QAMQP::Client::createExchange( const QString &name, int channelNumber )
Exchange *QAMQP::Client::createExchange( const QString &name, int channelNumber )
{
return pd_func()->createExchange(channelNumber, name);
Q_D(QAMQP::Client);
return d->createExchange(channelNumber, name);
}
Queue * QAMQP::Client::createQueue(int channelNumber)
Queue *QAMQP::Client::createQueue(int channelNumber)
{
return pd_func()->createQueue(channelNumber, QString());
Q_D(QAMQP::Client);
return d->createQueue(channelNumber, QString());
}
Queue * QAMQP::Client::createQueue( const QString &name, int channelNumber )
Queue *QAMQP::Client::createQueue( const QString &name, int channelNumber )
{
return pd_func()->createQueue(channelNumber, name);
Q_D(QAMQP::Client);
return d->createQueue(channelNumber, name);
}
void QAMQP::Client::open()
{
return pd_func()->connect();
Q_D(QAMQP::Client);
return d->connect();
}
void QAMQP::Client::open( const QUrl & connectionString )
void QAMQP::Client::open(const QUrl &connectionString)
{
pd_func()->parseCnnString(connectionString);
Q_D(QAMQP::Client);
d->parseConnectionString(connectionString);
open();
}
void QAMQP::Client::close()
{
return pd_func()->disconnect();
Q_D(QAMQP::Client);
return d->disconnect();
}
void QAMQP::Client::reopen()
{
pd_func()->disconnect();
pd_func()->connect();
Q_D(QAMQP::Client);
d->disconnect();
d->connect();
}
void QAMQP::Client::setAuth( Authenticator * auth )
void QAMQP::Client::setAuth(Authenticator *auth)
{
pd_func()->setAuth(auth);
Q_D(QAMQP::Client);
d->setAuth(auth);
}
Authenticator * QAMQP::Client::auth() const
Authenticator *QAMQP::Client::auth() const
{
return pd_func()->auth_.data();
Q_D(const QAMQP::Client);
return d->auth_.data();
}
bool QAMQP::Client::isSsl() const
{
return pd_func()->network_->isSsl();
Q_D(const QAMQP::Client);
return d->network_->isSsl();
}
void QAMQP::Client::setSsl( bool value )
void QAMQP::Client::setSsl(bool value)
{
pd_func()->network_->setSsl(value);
Q_D(QAMQP::Client);
d->network_->setSsl(value);
}
bool QAMQP::Client::autoReconnect() const
{
return pd_func()->network_->autoReconnect();
Q_D(const QAMQP::Client);
return d->network_->autoReconnect();
}
void QAMQP::Client::setAutoReconnect( bool value )
void QAMQP::Client::setAutoReconnect(bool value)
{
pd_func()->network_->setAutoReconnect(value);
Q_D(QAMQP::Client);
d->network_->setAutoReconnect(value);
}
bool QAMQP::Client::isConnected() const
{
return pd_func()->connection_->isConnected();
Q_D(const QAMQP::Client);
return d->connection_->isConnected();
}
void QAMQP::Client::addCustomProperty( const QString & name, const QString & value )
void QAMQP::Client::addCustomProperty(const QString &name, const QString &value)
{
return pd_func()->connection_->addCustomProperty(name, value);
Q_D(QAMQP::Client);
return d->connection_->addCustomProperty(name, value);
}
QString QAMQP::Client::customProperty( const QString & name ) const
QString QAMQP::Client::customProperty(const QString &name) const
{
return pd_func()->connection_->customProperty(name);
Q_D(const QAMQP::Client);
return d->connection_->customProperty(name);
}

100
src/qamqp/amqp.h
View File

@ -1,73 +1,68 @@
#ifndef qamqp_amqp_h__
#define qamqp_amqp_h__
#ifndef QAMQP_H
#define QAMQP_H
#include <QObject>
#include <QUrl>
#include "amqp_global.h"
namespace QAMQP
{
class Exchange;
class Queue;
class ClientPrivate;
class Authenticator;
class ConnectionPrivate;
class Client : public QObject
{
class Exchange;
class Queue;
class ClientPrivate;
class Authenticator;
class ConnectionPrivate;
class Client : public QObject
{
Q_OBJECT
Q_PROPERTY(quint32 port READ port WRITE setPort)
Q_PROPERTY(QString host READ host WRITE setHost)
Q_PROPERTY(QString virtualHost READ virtualHost WRITE setVirtualHost)
Q_PROPERTY(QString user READ user WRITE setUser)
Q_PROPERTY(QString password READ password WRITE setPassword)
Q_PROPERTY(bool ssl READ isSsl WRITE setSsl)
Q_PROPERTY(bool autoReconnect READ autoReconnect WRITE setAutoReconnect)
Q_PROPERTY(bool connected READ isConnected )
Q_PROPERTY(quint32 port READ port WRITE setPort);
Q_PROPERTY(QString host READ host WRITE setHost);
Q_PROPERTY(QString virtualHost READ virtualHost WRITE setVirtualHost);
Q_PROPERTY(QString user READ user WRITE setUser);
Q_PROPERTY(QString password READ password WRITE setPassword);
Q_PROPERTY(bool ssl READ isSsl WRITE setSsl);
Q_PROPERTY(bool autoReconnect READ autoReconnect WRITE setAutoReconnect);
Q_PROPERTY(bool connected READ isConnected );
Q_DISABLE_COPY(Client)
P_DECLARE_PRIVATE(QAMQP::Client)
friend class ConnectionPrivate;
friend class ChannelPrivate;
public:
Client(QObject * parent = 0);
Client(const QUrl & connectionString, QObject * parent = 0);
public:
Client(QObject *parent = 0);
Client(const QUrl &connectionString, QObject *parent = 0);
~Client();
void printConnect() const;
void closeChannel();
void addCustomProperty(const QString & name, const QString & value);
QString customProperty(const QString & name) const;
void addCustomProperty(const QString &name, const QString &value);
QString customProperty(const QString &name) const;
Exchange * createExchange(int channelNumber = -1);
Exchange * createExchange(const QString &name, int channelNumber = -1);
Exchange *createExchange(int channelNumber = -1);
Exchange *createExchange(const QString &name, int channelNumber = -1);
Queue * createQueue(int channelNumber = -1);
Queue * createQueue(const QString &name, int channelNumber = -1);
Queue *createQueue(int channelNumber = -1);
Queue *createQueue(const QString &name, int channelNumber = -1);
quint32 port() const;
void setPort(quint32 port);
quint16 port() const;
void setPort(quint16 port);
QString host() const;
void setHost(const QString & host);
void setHost(const QString &host);
QString virtualHost() const;
void setVirtualHost(const QString & virtualHost);
void setVirtualHost(const QString &virtualHost);
QString user() const;
void setUser(const QString & user);
void setUser(const QString &user);
QString password() const;
void setPassword(const QString & password);
void setPassword(const QString &password);
void setAuth(Authenticator *auth);
Authenticator *auth() const;
void setAuth(Authenticator * auth);
Authenticator * auth() const;
void open();
void open(const QUrl & connectionString);
void open(const QUrl &connectionString);
void close();
void reopen();
@ -79,19 +74,20 @@ namespace QAMQP
bool isConnected() const;
signals:
signals:
void connected();
void disconnected();
private:
Q_DISABLE_COPY(Client)
Q_DECLARE_PRIVATE(QAMQP::Client)
QScopedPointer<ClientPrivate> d_ptr;
protected:
ClientPrivate * const pd_ptr;
private:
friend class ConnectionPrivate;
friend class ChannelPrivate;
friend struct ClientExceptionCleaner;
};
//void chanalConnect();
};
}
} // namespace QAMQP
#endif // qamqp_amqp_h__
#endif // QAMQP

35
src/qamqp/amqp_authenticator.cpp
View File

@ -1,43 +1,44 @@
#include "amqp_authenticator.h"
#include "amqp_frame.h"
QString QAMQP::AMQPlainAuthenticator::login() const
using namespace QAMQP;
AMQPlainAuthenticator::AMQPlainAuthenticator(const QString &l, const QString &p)
: login_(l),
password_(p)
{
}
AMQPlainAuthenticator::~AMQPlainAuthenticator()
{
}
QString AMQPlainAuthenticator::login() const
{
return login_;
}
QString QAMQP::AMQPlainAuthenticator::password() const
QString AMQPlainAuthenticator::password() const
{
return password_;
}
QAMQP::AMQPlainAuthenticator::AMQPlainAuthenticator( const QString & l /*= QString()*/, const QString & p /*= QString()*/ )
{
login_ = l;
password_ = p;
}
QAMQP::AMQPlainAuthenticator::~AMQPlainAuthenticator()
{
}
QString QAMQP::AMQPlainAuthenticator::type() const
QString AMQPlainAuthenticator::type() const
{
return "AMQPLAIN";
}
void QAMQP::AMQPlainAuthenticator::setLogin( const QString& l )
void AMQPlainAuthenticator::setLogin(const QString &l)
{
login_ = l;
}
void QAMQP::AMQPlainAuthenticator::setPassword( const QString &p )
void AMQPlainAuthenticator::setPassword(const QString &p)
{
password_ = p;
}
void QAMQP::AMQPlainAuthenticator::write( QDataStream & out )
void AMQPlainAuthenticator::write(QDataStream &out)
{
QAMQP::Frame::writeField('s', out, type());
QAMQP::Frame::TableField response;

41
src/qamqp/amqp_authenticator.h
View File

@ -1,33 +1,42 @@
#ifndef amqp_authenticator_h__
#define amqp_authenticator_h__
#include "amqp_global.h"
#include <QString>
#include <QDataStream>
#include "amqp_global.h"
namespace QAMQP
{
class Authenticator
{
public:
virtual ~Authenticator(){};
virtual QString type() const = 0;
virtual void write(QDataStream & out) = 0;
};
class AMQPlainAuthenticator : public Authenticator
{
QString login_, password_;
public:
AMQPlainAuthenticator(const QString & login = QString(), const QString & password = QString());
class Authenticator
{
public:
virtual ~Authenticator() {}
virtual QString type() const = 0;
virtual void write(QDataStream &out) = 0;
};
class AMQPlainAuthenticator : public Authenticator
{
public:
AMQPlainAuthenticator(const QString &login = QString(), const QString &password = QString());
virtual ~AMQPlainAuthenticator();
QString login() const;
void setLogin(const QString& l);
void setLogin(const QString &l);
QString password() const;
void setPassword(const QString &p);
virtual QString type() const;
virtual void write(QDataStream & out);
};
virtual void write(QDataStream &out);
private:
QString login_;
QString password_;
};
}
#endif // amqp_authenticator_h__

165
src/qamqp/amqp_channel.cpp
View File

@ -1,5 +1,6 @@
#include "amqp_channel.h"
#include "amqp_channel_p.h"
#include "amqp_connection_p.h"
#include "amqp.h"
#include "amqp_p.h"
@ -10,90 +11,63 @@
using namespace QAMQP;
namespace QAMQP
{
int ChannelPrivate::nextChannelNumber_ = 0;
struct ChannelExceptionCleaner
{
/* this cleans up when the constructor throws an exception */
static inline void cleanup(Channel *that, ChannelPrivate *d)
{
#ifdef QT_NO_EXCEPTIONS
Q_UNUSED(that);
Q_UNUSED(d);
#else
Q_UNUSED(that);
Q_UNUSED(d);
#endif
}
};
}
//////////////////////////////////////////////////////////////////////////
QAMQP::Channel::Channel(int channelNumber /*= -1*/, Client * parent /*= 0*/ )
: pd_ptr(new ChannelPrivate(this))
QAMQP::Channel::Channel(int channelNumber, Client *parent)
: QObject(parent),
d_ptr(new ChannelPrivate(this))
{
QT_TRY {
pd_func()->init(channelNumber, parent);
} QT_CATCH(...) {
ChannelExceptionCleaner::cleanup(this, pd_func());
QT_RETHROW;
}
Q_D(QAMQP::Channel);
d->init(channelNumber, parent);
}
QAMQP::Channel::Channel( ChannelPrivate * d )
: pd_ptr(d)
QAMQP::Channel::Channel(ChannelPrivate *dd, Client *parent)
: QObject(parent),
d_ptr(dd)
{
}
QAMQP::Channel::~Channel()
{
QT_TRY {
QEvent e(QEvent::Destroy);
QCoreApplication::sendEvent(this, &e);
} QT_CATCH(const std::exception&) {
// if this fails we can't do anything about it but at least we are not allowed to throw.
}
}
void QAMQP::Channel::closeChannel()
{
P_D(Channel);
Q_D(QAMQP::Channel);
d->needOpen = true;
if(d->opened)
if (d->opened)
d->close(0, QString(), 0,0);
}
void QAMQP::Channel::reopen()
{
Q_D(QAMQP::Channel);
closeChannel();
pd_func()->open();
d->open();
}
QString QAMQP::Channel::name()
QString QAMQP::Channel::name() const
{
return pd_func()->name;
Q_D(const QAMQP::Channel);
return d->name;
}
int QAMQP::Channel::channelNumber()
int QAMQP::Channel::channelNumber() const
{
return pd_func()->number;
Q_D(const QAMQP::Channel);
return d->number;
}
void QAMQP::Channel::setName( const QString &name )
void QAMQP::Channel::setName(const QString &name)
{
pd_func()->name = name;
Q_D(QAMQP::Channel);
d->name = name;
}
void QAMQP::Channel::stateChanged( int state )
void QAMQP::Channel::stateChanged(int state)
{
switch(ChannelPrivate::State(state))
{
switch(ChannelPrivate::State(state)) {
case ChannelPrivate::csOpened:
emit opened();
break;
@ -111,67 +85,68 @@ void QAMQP::Channel::stateChanged( int state )
void QAMQP::Channel::_q_method(const Frame::Method &frame)
{
pd_func()->_q_method(frame);
Q_D(QAMQP::Channel);
d->_q_method(frame);
}
bool QAMQP::Channel::isOpened() const
{
return pd_func()->opened;
Q_D(const QAMQP::Channel);
return d->opened;
}
void QAMQP::Channel::onOpen()
{
}
void QAMQP::Channel::onClose()
{
}
void QAMQP::Channel::setQOS( qint32 prefetchSize, quint16 prefetchCount )
void QAMQP::Channel::setQOS(qint32 prefetchSize, quint16 prefetchCount)
{
pd_func()->setQOS(prefetchSize, prefetchCount);
Q_D(QAMQP::Channel);
d->setQOS(prefetchSize, prefetchCount);
}
//////////////////////////////////////////////////////////////////////////
int ChannelPrivate::nextChannelNumber_ = 0;
ChannelPrivate::ChannelPrivate(Channel * q)
: number(0)
, opened(false)
, needOpen(true)
, pq_ptr(q)
: number(0),
opened(false),
needOpen(true),
q_ptr(q)
{
}
ChannelPrivate::~ChannelPrivate()
{
}
void ChannelPrivate::init(int channelNumber, Client * parent)
void ChannelPrivate::init(int channelNumber, Client *parent)
{
Q_Q(QAMQP::Channel);
needOpen = channelNumber == -1 ? true : false;
number = channelNumber == -1 ? ++nextChannelNumber_ : channelNumber;
nextChannelNumber_ = qMax(channelNumber, (nextChannelNumber_ + 1));
pq_func()->setParent(parent);
q->setParent(parent);
client_ = parent;
}
bool ChannelPrivate::_q_method( const QAMQP::Frame::Method & frame )
bool ChannelPrivate::_q_method(const QAMQP::Frame::Method &frame)
{
Q_ASSERT(frame.channel() == number);
if(frame.channel() != number )
if (frame.channel() != number)
return true;
if(frame.methodClass() != QAMQP::Frame::fcChannel)
if (frame.methodClass() != QAMQP::Frame::fcChannel)
return false;
qDebug("Channel#%d:", number);
switch(frame.id())
{
switch (frame.id()) {
case miOpenOk:
openOk(frame);
break;
@ -197,22 +172,21 @@ void ChannelPrivate::_q_open()
}
void ChannelPrivate::sendFrame( const QAMQP::Frame::Base & frame )
void ChannelPrivate::sendFrame(const QAMQP::Frame::Base &frame)
{
if(client_)
{
client_->pd_func()->network_->sendFrame(frame);
if (client_) {
client_->d_func()->network_->sendFrame(frame);
}
}
void ChannelPrivate::open()
{
if(!needOpen || opened)
if (!needOpen || opened)
return;
if(!client_->pd_func()->connection_->isConnected())
if (!client_->d_func()->connection_->isConnected())
return;
qDebug("Open channel #%d", number);
QAMQP::Frame::Method frame(QAMQP::Frame::fcChannel, miOpen);
frame.setChannel(number);
@ -223,28 +197,25 @@ void ChannelPrivate::open()
sendFrame(frame);
}
void ChannelPrivate::flow()
{
}
void ChannelPrivate::flow( const QAMQP::Frame::Method & frame )
void ChannelPrivate::flow(const QAMQP::Frame::Method &frame)
{
Q_UNUSED(frame);
}
void ChannelPrivate::flowOk()
{
}
void ChannelPrivate::flowOk( const QAMQP::Frame::Method & frame )
void ChannelPrivate::flowOk(const QAMQP::Frame::Method &frame)
{
Q_UNUSED(frame);
}
void ChannelPrivate::close(int code, const QString & text, int classId, int methodId)
void ChannelPrivate::close(int code, const QString &text, int classId, int methodId)
{
QAMQP::Frame::Method frame(QAMQP::Frame::fcChannel, miClose);
QByteArray arguments_;
@ -258,12 +229,13 @@ void ChannelPrivate::close(int code, const QString & text, int classId, int meth
stream << qint16(methodId);
frame.setArguments(arguments_);
client_->pd_func()->network_->sendFrame(frame);
client_->d_func()->network_->sendFrame(frame);
}
void ChannelPrivate::close( const QAMQP::Frame::Method & frame )
void ChannelPrivate::close(const QAMQP::Frame::Method &frame)
{
pq_func()->stateChanged(csClosed);
Q_Q(QAMQP::Channel);
q->stateChanged(csClosed);
qDebug(">> CLOSE");
QByteArray data = frame.arguments();
@ -278,7 +250,6 @@ void ChannelPrivate::close( const QAMQP::Frame::Method & frame )
qDebug(">> text: %s", qPrintable(text));
qDebug(">> class-id: %d", classId);
qDebug(">> method-id: %d", methodId);
}
void ChannelPrivate::closeOk()
@ -287,34 +258,36 @@ void ChannelPrivate::closeOk()
sendFrame(frame);
}
void ChannelPrivate::closeOk( const QAMQP::Frame::Method & frame )
void ChannelPrivate::closeOk(const QAMQP::Frame::Method &frame)
{
Q_UNUSED(frame);
P_Q(Channel);
Q_UNUSED(frame)
Q_Q(QAMQP::Channel);
q->stateChanged(csClosed);
q->onClose();
opened = false;
}
void ChannelPrivate::openOk( const QAMQP::Frame::Method & frame )
void ChannelPrivate::openOk(const QAMQP::Frame::Method &frame)
{
Q_UNUSED(frame);
P_Q(Channel);
Q_UNUSED(frame)
Q_Q(QAMQP::Channel);
qDebug(">> OpenOK");
opened = true;
q->stateChanged(csOpened);
q->onOpen();
}
void ChannelPrivate::setQOS( qint32 prefetchSize, quint16 prefetchCount )
void ChannelPrivate::setQOS(qint32 prefetchSize, quint16 prefetchCount)
{
client_->pd_func()->connection_->pd_func()->setQOS(prefetchSize, prefetchCount, number, false);
client_->d_func()->connection_->d_func()->setQOS(prefetchSize, prefetchCount, number, false);
}
void ChannelPrivate::_q_disconnected()
{
nextChannelNumber_ = 0;
opened = false;
}
#include "moc_amqp_channel.cpp"

54
src/qamqp/amqp_channel.h
View File

@ -7,54 +7,52 @@
namespace QAMQP
{
class ChannelPrivate;
class Client;
class Channel : public QObject, public Frame::MethodHandler
{
class Client;
class ChannelPrivate;
class Channel : public QObject, public Frame::MethodHandler
{
Q_OBJECT
Q_PROPERTY(int number READ channelNumber)
Q_PROPERTY(QString name READ name WRITE setName)
Q_PROPERTY(int number READ channelNumber);
Q_PROPERTY(QString name READ name WRITE setName);
P_DECLARE_PRIVATE(QAMQP::Channel)
Q_DISABLE_COPY(Channel)
public:
public:
~Channel();
void closeChannel();
void reopen();
QString name();
int channelNumber();
QString name() const;
int channelNumber() const;
void setName(const QString &name);
void setQOS(qint32 prefetchSize, quint16 prefetchCount);
bool isOpened() const;
signals:
signals:
void opened();
void closed();
void flowChanged(bool enabled);
protected:
Channel(int channelNumber = -1, Client * parent = 0);
Channel(ChannelPrivate * d);
protected:
Q_DISABLE_COPY(Channel)
Q_DECLARE_PRIVATE(QAMQP::Channel)
Channel(int channelNumber = -1, Client *parent = 0);
Channel(ChannelPrivate *dd, Client *parent = 0);
QScopedPointer<ChannelPrivate> d_ptr;
Q_PRIVATE_SLOT(d_func(), void _q_open())
Q_PRIVATE_SLOT(d_func(), void _q_disconnected())
virtual void onOpen();
virtual void onClose();
ChannelPrivate * const pd_ptr;
private:
void stateChanged(int state);
friend class ClientPrivate;
void _q_method(const QAMQP::Frame::Method & frame);
void _q_method(const QAMQP::Frame::Method &frame);
friend class ClientPrivate;
};
Q_PRIVATE_SLOT(pd_func(), void _q_open())
Q_PRIVATE_SLOT(pd_func(), void _q_disconnected())
};
}
#ifdef QAMQP_P_INCLUDE
# include "amqp_channel_p.h"
#endif
#endif // amqp_channel_h__

38
src/qamqp/amqp_channel_p.h
View File

@ -8,14 +8,12 @@
namespace QAMQP
{
class Client;
class ClientPrivate;
class ChannelPrivate
{
P_DECLARE_PUBLIC(QAMQP::Channel)
public:
enum MethodId
{
class Client;
class ClientPrivate;
class ChannelPrivate
{
public:
enum MethodId {
METHOD_ID_ENUM(miOpen, 10),
METHOD_ID_ENUM(miFlow, 20),
METHOD_ID_ENUM(miClose, 40)
@ -47,28 +45,28 @@ namespace QAMQP
ChannelPrivate(Channel * q);
virtual ~ChannelPrivate();
void init(int channelNumber, Client * parent);
void init(int channelNumber, Client *parent);
void open();
void flow();
void flowOk();
void close(int code, const QString & text, int classId, int methodId);
void close(int code, const QString &text, int classId, int methodId);
void closeOk();
//////////////////////////////////////////////////////////////////////////
void openOk(const QAMQP::Frame::Method & frame);
void flow(const QAMQP::Frame::Method & frame);
void flowOk(const QAMQP::Frame::Method & frame);
void close(const QAMQP::Frame::Method & frame);
void closeOk(const QAMQP::Frame::Method & frame);
void openOk(const QAMQP::Frame::Method &frame);
void flow(const QAMQP::Frame::Method &frame);
void flowOk(const QAMQP::Frame::Method &frame);
void close(const QAMQP::Frame::Method &frame);
void closeOk(const QAMQP::Frame::Method &frame);
virtual bool _q_method(const QAMQP::Frame::Method & frame);
virtual bool _q_method(const QAMQP::Frame::Method &frame);
virtual void _q_disconnected();
void _q_open();
void setQOS(qint32 prefetchSize, quint16 prefetchCount);
void sendFrame(const QAMQP::Frame::Base & frame);
void sendFrame(const QAMQP::Frame::Base &frame);
QPointer<Client> client_;
@ -79,7 +77,9 @@ namespace QAMQP
bool opened;
bool needOpen;
Channel * const pq_ptr;
};
Q_DECLARE_PUBLIC(QAMQP::Channel)
Channel * const q_ptr;
};
}
#endif // amqp_channel_p_h__

198
src/qamqp/amqp_connection.cpp
View File

@ -12,50 +12,24 @@
using namespace QAMQP;
namespace QAMQP
ConnectionPrivate::ConnectionPrivate(Connection * q)
: closed_(false),
connected(false),
q_ptr(q)
{
struct ConnectionExceptionCleaner
{
/* this cleans up when the constructor throws an exception */
static inline void cleanup(Connection *that, ConnectionPrivate *d)
{
#ifdef QT_NO_EXCEPTIONS
Q_UNUSED(that);
Q_UNUSED(d);
#else
Q_UNUSED(that);
Q_UNUSED(d);
#endif
}
};
}
//////////////////////////////////////////////////////////////////////////
ConnectionPrivate::ConnectionPrivate( Connection * q)
: closed_(false)
, connected(false)
, pq_ptr(q)
{
}
ConnectionPrivate::~ConnectionPrivate()
{
}
void ConnectionPrivate::init(Client * parent)
{
pq_func()->setParent(parent);
Q_Q(QAMQP::Connection);
q->setParent(parent);
client_ = parent;
heartbeatTimer_ = new QTimer(parent);
QObject::connect(heartbeatTimer_, SIGNAL(timeout()),
pq_func(), SLOT(_q_heartbeat()));
QObject::connect(heartbeatTimer_, SIGNAL(timeout()), q, SLOT(_q_heartbeat()));
}
void ConnectionPrivate::startOk()
@ -71,19 +45,14 @@ void ConnectionPrivate::startOk()
clientProperties.unite(customProperty);
QAMQP::Frame::serialize(stream, clientProperties);
client_->pd_func()->auth_->write(stream);
client_->d_func()->auth_->write(stream);
QAMQP::Frame::writeField('s', stream, "en_US");
frame.setArguments(arguments_);
client_->pd_func()->network_->sendFrame(frame);
client_->d_func()->network_->sendFrame(frame);
}
void ConnectionPrivate::secureOk()
{
}
void ConnectionPrivate::tuneOk()
@ -97,7 +66,7 @@ void ConnectionPrivate::tuneOk()
stream << qint16(heartbeatTimer_->interval() / 1000); //heartbeat
frame.setArguments(arguments_);
client_->pd_func()->network_->sendFrame(frame);
client_->d_func()->network_->sendFrame(frame);
}
void ConnectionPrivate::open()
@ -112,10 +81,10 @@ void ConnectionPrivate::open()
stream << qint8(0);
frame.setArguments(arguments_);
client_->pd_func()->network_->sendFrame(frame);
client_->d_func()->network_->sendFrame(frame);
}
void ConnectionPrivate::start( const QAMQP::Frame::Method & frame )
void ConnectionPrivate::start(const QAMQP::Frame::Method &frame)
{
qDebug(">> Start");
QByteArray data = frame.arguments();
@ -142,12 +111,12 @@ void ConnectionPrivate::start( const QAMQP::Frame::Method & frame )
startOk();
}
void ConnectionPrivate::secure( const QAMQP::Frame::Method & frame )
void ConnectionPrivate::secure(const QAMQP::Frame::Method &frame)
{
Q_UNUSED(frame);
Q_UNUSED(frame)
}
void ConnectionPrivate::tune( const QAMQP::Frame::Method & frame )
void ConnectionPrivate::tune(const QAMQP::Frame::Method &frame)
{
qDebug(">> Tune");
QByteArray data = frame.arguments();
@ -165,30 +134,32 @@ void ConnectionPrivate::tune( const QAMQP::Frame::Method & frame )
qDebug(">> frame_max: %d", frame_max);
qDebug(">> heartbeat: %d", heartbeat);
if(heartbeatTimer_)
{
if (heartbeatTimer_) {
heartbeatTimer_->setInterval(heartbeat * 1000);
if(heartbeatTimer_->interval())
{
if (heartbeatTimer_->interval())
heartbeatTimer_->start();
} else {
else
heartbeatTimer_->stop();
}
}
tuneOk();
open();
}
void ConnectionPrivate::openOk( const QAMQP::Frame::Method & frame )
void ConnectionPrivate::openOk(const QAMQP::Frame::Method &frame)
{
Q_UNUSED(frame);
Q_UNUSED(frame)
Q_Q(QAMQP::Connection);
qDebug(">> OpenOK");
connected = true;
pq_func()->openOk();
q->openOk();
}
void ConnectionPrivate::close( const QAMQP::Frame::Method & frame )
void ConnectionPrivate::close(const QAMQP::Frame::Method &frame)
{
Q_Q(QAMQP::Connection);
qDebug(">> CLOSE");
QByteArray data = frame.arguments();
QDataStream stream(&data, QIODevice::ReadOnly);
@ -203,11 +174,11 @@ void ConnectionPrivate::close( const QAMQP::Frame::Method & frame )
qDebug(">> class-id: %d", classId);
qDebug(">> method-id: %d", methodId);
connected = false;
client_->pd_func()->network_->error(QAbstractSocket::RemoteHostClosedError);
QMetaObject::invokeMethod(pq_func(), "disconnected");
client_->d_func()->network_->error(QAbstractSocket::RemoteHostClosedError);
QMetaObject::invokeMethod(q, "disconnected");
}
void ConnectionPrivate::close(int code, const QString & text, int classId, int methodId)
void ConnectionPrivate::close(int code, const QString &text, int classId, int methodId)
{
QAMQP::Frame::Method frame(QAMQP::Frame::fcConnection, miClose);
QByteArray arguments_;
@ -221,29 +192,30 @@ void ConnectionPrivate::close(int code, const QString & text, int classId, int m
stream << qint16(methodId);
frame.setArguments(arguments_);
client_->pd_func()->network_->sendFrame(frame);
client_->d_func()->network_->sendFrame(frame);
}
void ConnectionPrivate::closeOk()
{
QAMQP::Frame::Method frame(QAMQP::Frame::fcConnection, miCloseOk);
connected = false;
client_->pd_func()->network_->sendFrame(frame);
client_->d_func()->network_->sendFrame(frame);
}
void ConnectionPrivate::closeOk( const QAMQP::Frame::Method & )
void ConnectionPrivate::closeOk(const QAMQP::Frame::Method &frame)
{
Q_UNUSED(frame)
Q_Q(QAMQP::Connection);
connected = false;
QMetaObject::invokeMethod(pq_func(), "disconnected");
if(heartbeatTimer_)
{
QMetaObject::invokeMethod(q, "disconnected");
if (heartbeatTimer_)
heartbeatTimer_->stop();
}
}
void ConnectionPrivate::setQOS( qint32 prefetchSize, quint16 prefetchCount, int channel, bool global )
void ConnectionPrivate::setQOS(qint32 prefetchSize, quint16 prefetchCount, int channel, bool global)
{
QAMQP::Frame::Method frame(QAMQP::Frame::fcBasic, 10);
frame.setChannel(channel);
@ -255,26 +227,25 @@ void ConnectionPrivate::setQOS( qint32 prefetchSize, quint16 prefetchCount, int
out << qint8(global ? 1 : 0);
frame.setArguments(arguments_);
client_->pd_func()->network_->sendFrame(frame);
client_->d_func()->network_->sendFrame(frame);
}
bool ConnectionPrivate::_q_method( const QAMQP::Frame::Method & frame )
bool ConnectionPrivate::_q_method(const QAMQP::Frame::Method &frame)
{
Q_ASSERT(frame.methodClass() == QAMQP::Frame::fcConnection);
if(frame.methodClass() != QAMQP::Frame::fcConnection)
if (frame.methodClass() != QAMQP::Frame::fcConnection)
return true;
qDebug() << "Connection:";
if (closed_)
{
if( frame.id() == miCloseOk)
if (closed_) {
if (frame.id() == miCloseOk)
closeOk(frame);
return true;
}
switch(MethodId(frame.id()))
{
switch (MethodId(frame.id())) {
case miStart:
start(frame);
break;
@ -297,101 +268,102 @@ bool ConnectionPrivate::_q_method( const QAMQP::Frame::Method & frame )
qWarning("Unknown method-id %d", frame.id());
return false;
}
return true;
}
void ConnectionPrivate::_q_heartbeat()
{
QAMQP::Frame::Heartbeat frame;
client_->pd_func()->network_->sendFrame(frame);
client_->d_func()->network_->sendFrame(frame);
}
//////////////////////////////////////////////////////////////////////////
Connection::Connection( Client * parent /*= 0*/ )
: pd_ptr(new ConnectionPrivate(this))
Connection::Connection(Client *parent)
: QObject(parent),
d_ptr(new ConnectionPrivate(this))
{
QT_TRY {
pd_func()->init(parent);
} QT_CATCH(...) {
ConnectionExceptionCleaner::cleanup(this, pd_func());
QT_RETHROW;
}
Q_D(QAMQP::Connection);
d->init(parent);
}
Connection::~Connection()
{
QT_TRY {
QEvent e(QEvent::Destroy);
QCoreApplication::sendEvent(this, &e);
} QT_CATCH(const std::exception&) {
// if this fails we can't do anything about it but at least we are not allowed to throw.
}
}
void Connection::startOk()
{
pd_func()->startOk();
Q_D(QAMQP::Connection);
d->startOk();
}
void Connection::secureOk()
{
pd_func()->secureOk();
Q_D(QAMQP::Connection);
d->secureOk();
}
void Connection::tuneOk()
{
pd_func()->tuneOk();
Q_D(QAMQP::Connection);
d->tuneOk();
}
void Connection::open()
{
pd_func()->open();
Q_D(QAMQP::Connection);
d->open();
}
void Connection::close(int code, const QString & text, int classId , int methodId)
void Connection::close(int code, const QString &text, int classId , int methodId)
{
pd_func()->close(code, text, classId, methodId);
Q_D(QAMQP::Connection);
d->close(code, text, classId, methodId);
}
void Connection::closeOk()
{
pd_func()->closeOk();
emit disconnect();
Q_D(QAMQP::Connection);
d->closeOk();
Q_EMIT disconnect();
}
void Connection::openOk()
{
emit connected();
Q_EMIT connected();
}
void Connection::_q_method(const QAMQP::Frame::Method & frame)
void Connection::_q_method(const QAMQP::Frame::Method &frame)
{
pd_func()->_q_method(frame);
Q_D(QAMQP::Connection);
d->_q_method(frame);
}
bool Connection::isConnected() const
{
return pd_func()->connected;
Q_D(const QAMQP::Connection);
return d->connected;
}
void Connection::setQOS( qint32 prefetchSize, quint16 prefetchCount )
void Connection::setQOS(qint32 prefetchSize, quint16 prefetchCount)
{
pd_func()->setQOS(prefetchSize, prefetchCount, 0, true);
Q_D(QAMQP::Connection);
d->setQOS(prefetchSize, prefetchCount, 0, true);
}
void Connection::addCustomProperty( const QString & name, const QString & value )
void Connection::addCustomProperty(const QString &name, const QString &value)
{
pd_func()->customProperty[name] = value;
Q_D(QAMQP::Connection);
d->customProperty[name] = value;
}
QString Connection::customProperty( const QString & name ) const
QString Connection::customProperty(const QString &name) const
{
if(pd_func()->customProperty.contains(name))
{
return pd_func()->customProperty.value(name).toString();
}
Q_D(const QAMQP::Connection);
if (d->customProperty.contains(name))
return d->customProperty.value(name).toString();
return QString();
}
#include "moc_amqp_connection.cpp"

51
src/qamqp/amqp_connection.h
View File

@ -7,53 +7,50 @@
namespace QAMQP
{
class ConnectionPrivate;
class ChannelPrivate;
class ClientPrivate;
class Client;
class Connection : public QObject, public Frame::MethodHandler
{
class Client;
class ClientPrivate;
class ChannelPrivate;
class ConnectionPrivate;
class Connection : public QObject, public Frame::MethodHandler
{
Q_OBJECT
P_DECLARE_PRIVATE(QAMQP::Connection)
Q_DISABLE_COPY(Connection)
Connection(Client * parent = 0);
public:
~Connection();
public:
virtual ~Connection();
void addCustomProperty(const QString & name, const QString & value);
QString customProperty(const QString & name) const;
void addCustomProperty(const QString &name, const QString &value);
QString customProperty(const QString &name) const;
void startOk();
void secureOk();
void tuneOk();
void open();
void close(int code, const QString & text, int classId = 0, int methodId = 0);
void close(int code, const QString &text, int classId = 0, int methodId = 0);
void closeOk();
bool isConnected() const;
void setQOS(qint32 prefetchSize, quint16 prefetchCount);
Q_SIGNALS:
Q_SIGNALS:
void disconnected();
void connected();
protected:
ConnectionPrivate * const pd_ptr;
private:
private:
Q_DISABLE_COPY(Connection)
Q_DECLARE_PRIVATE(Connection)
QScopedPointer<ConnectionPrivate> d_ptr;
Connection(Client * parent = 0);
void openOk();
friend class ClientPrivate;
friend class ChannelPrivate;
void _q_method(const QAMQP::Frame::Method & frame);
Q_PRIVATE_SLOT(pd_func(), void _q_heartbeat());
};
void _q_method(const QAMQP::Frame::Method &frame);
Q_PRIVATE_SLOT(d_func(), void _q_heartbeat())
};
}
// Include private header so MOC won't complain
#ifdef QAMQP_P_INCLUDE
# include "amqp_connection_p.h"
#endif
#endif // amqp_connection_h__

43
src/qamqp/amqp_connection_p.h
View File

@ -9,14 +9,13 @@ class QTimer;
namespace QAMQP
{
class Client;
class ClientPrivate;
class ConnectionPrivate
{
P_DECLARE_PUBLIC(QAMQP::Connection)
public:
enum MethodId
{
class Client;
class ClientPrivate;
class Connection;
class ConnectionPrivate
{
public:
enum MethodId {
METHOD_ID_ENUM(miStart, 10),
METHOD_ID_ENUM(miSecure, 20),
METHOD_ID_ENUM(miTune, 30),
@ -24,9 +23,10 @@ namespace QAMQP
METHOD_ID_ENUM(miClose, 50)
};
ConnectionPrivate(Connection * q);
ConnectionPrivate(Connection *q);
~ConnectionPrivate();
void init(Client * parent);
void init(Client *parent);
void startOk();
void secureOk();
void tuneOk();
@ -34,13 +34,14 @@ namespace QAMQP
void close(int code, const QString & text, int classId = 0, int methodId = 0);
void closeOk();
void start(const QAMQP::Frame::Method & frame);
void secure(const QAMQP::Frame::Method & frame);
void tune(const QAMQP::Frame::Method & frame);
void openOk(const QAMQP::Frame::Method & frame);
void close(const QAMQP::Frame::Method & frame);
void closeOk(const QAMQP::Frame::Method & frame);
bool _q_method(const QAMQP::Frame::Method & frame);
void start(const QAMQP::Frame::Method &frame);
void secure(const QAMQP::Frame::Method &frame);
void tune(const QAMQP::Frame::Method &frame);
void openOk(const QAMQP::Frame::Method &frame);
void close(const QAMQP::Frame::Method &frame);
void closeOk(const QAMQP::Frame::Method &frame);
bool _q_method(const QAMQP::Frame::Method &frame);
void _q_heartbeat();
void setQOS(qint32 prefetchSize, quint16 prefetchCount, int channel, bool global);
@ -50,10 +51,12 @@ namespace QAMQP
bool connected;
QPointer<QTimer> heartbeatTimer_;
Connection * const pq_ptr;
QAMQP::Frame::TableField customProperty;
};
Q_DECLARE_PUBLIC(QAMQP::Connection)
Connection * const q_ptr;
};
}
#endif // amqp_connection_p_h__

146
src/qamqp/amqp_exchange.cpp
View File

@ -9,36 +9,11 @@ using namespace QAMQP::Frame;
#include <QDebug>
#include <QDataStream>
namespace QAMQP
Exchange::Exchange(int channelNumber, Client *parent)
: Channel(new ExchangePrivate(this), parent)
{
struct ExchangeExceptionCleaner
{
/* this cleans up when the constructor throws an exception */
static inline void cleanup(Exchange *that, ExchangePrivate *d)
{
#ifdef QT_NO_EXCEPTIONS
Q_UNUSED(that);
Q_UNUSED(d);
#else
Q_UNUSED(that);
Q_UNUSED(d);
#endif
}
};
}
Exchange::Exchange(int channelNumber, Client * parent /*= 0*/ )
: Channel(new ExchangePrivate(this))
{
QT_TRY {
pd_func()->init(channelNumber, parent);
} QT_CATCH(...) {
ExchangeExceptionCleaner::cleanup(this, pd_func());
QT_RETHROW;
}
Q_D(QAMQP::Exchange);
d->init(channelNumber, parent);
}
Exchange::~Exchange()
@ -48,105 +23,106 @@ Exchange::~Exchange()
void Exchange::onOpen()
{
P_D(Exchange);
if(d->delayedDeclare)
{
Q_D(QAMQP::Exchange);
if (d->delayedDeclare)
d->declare();
}
}
void Exchange::onClose()
{
pd_func()->remove(true, true);
Q_D(QAMQP::Exchange);
d->remove(true, true);
}
Exchange::ExchangeOptions Exchange::option() const
{
return pd_func()->options;
Q_D(const QAMQP::Exchange);
return d->options;
}
QString Exchange::type() const
{
return pd_func()->type;
Q_D(const QAMQP::Exchange);
return d->type;
}
void Exchange::declare(const QString &type, ExchangeOptions option , const TableField & arg)
void Exchange::declare(const QString &type, ExchangeOptions option , const TableField &arg)
{
P_D(Exchange);
Q_D(QAMQP::Exchange);
d->options = option;
d->type = type;
d->arguments = arg;
d->declare();
}
void Exchange::remove( bool ifUnused /*= true*/, bool noWait /*= true*/ )
void Exchange::remove(bool ifUnused, bool noWait)
{
pd_func()->remove(ifUnused, noWait);
Q_D(QAMQP::Exchange);
d->remove(ifUnused, noWait);
}
void Exchange::bind( QAMQP::Queue * queue )
void Exchange::bind(QAMQP::Queue *queue)
{
queue->bind(this, pd_func()->name);
Q_D(QAMQP::Exchange);
queue->bind(this, d->name);
}
void Exchange::bind( const QString & queueName )
void Exchange::bind(const QString &queueName)
{
Q_UNUSED(queueName);
qWarning("Not implement");
qWarning("Not implemented");
}
void Exchange::bind( const QString & queueName, const QString &key )
void Exchange::bind(const QString &queueName, const QString &key)
{
Q_UNUSED(queueName);
Q_UNUSED(key);
qWarning("Not implement");
qWarning("Not implemented");
}
void Exchange::publish( const QString & message, const QString & key, const MessageProperties &prop )
void Exchange::publish(const QString &message, const QString &key, const MessageProperties &prop)
{
pd_func()->publish(message.toUtf8(), key, QString::fromLatin1("text.plain"), QVariantHash(), prop);
Q_D(QAMQP::Exchange);
d->publish(message.toUtf8(), key, QLatin1String("text.plain"), QVariantHash(), prop);
}
void Exchange::publish( const QByteArray & message, const QString & key, const QString &mimeType, const MessageProperties &prop )
void Exchange::publish(const QByteArray &message, const QString &key,
const QString &mimeType, const MessageProperties &prop)
{
pd_func()->publish(message, key, mimeType, QVariantHash(), prop);
Q_D(QAMQP::Exchange);
d->publish(message, key, mimeType, QVariantHash(), prop);
}
void Exchange::publish( const QByteArray & message, const QString & key, const QVariantHash &headers, const QString &mimeType, const MessageProperties &prop )
void Exchange::publish(const QByteArray &message, const QString &key,
const QVariantHash &headers, const QString &mimeType,
const MessageProperties &prop)
{
pd_func()->publish(message, key, mimeType, headers, prop);
Q_D(QAMQP::Exchange);
d->publish(message, key, mimeType, headers, prop);
}
//////////////////////////////////////////////////////////////////////////
ExchangePrivate::ExchangePrivate(Exchange * q)
:ChannelPrivate(q)
, delayedDeclare(false)
, declared(false)
: ChannelPrivate(q),
delayedDeclare(false),
declared(false)
{
}
ExchangePrivate::~ExchangePrivate()
{
}
bool ExchangePrivate::_q_method( const QAMQP::Frame::Method & frame )
bool ExchangePrivate::_q_method(const QAMQP::Frame::Method &frame)
{
if(ChannelPrivate::_q_method(frame))
if (ChannelPrivate::_q_method(frame))
return true;
if(frame.methodClass() != QAMQP::Frame::fcExchange)
if (frame.methodClass() != QAMQP::Frame::fcExchange)
return false;
switch(frame.id())
{
switch(frame.id()) {
case miDeclareOk:
declareOk(frame);
break;
@ -156,32 +132,36 @@ bool ExchangePrivate::_q_method( const QAMQP::Frame::Method & frame )
default:
break;
}
return true;
}
void ExchangePrivate::declareOk( const QAMQP::Frame::Method & )
void ExchangePrivate::declareOk(const QAMQP::Frame::Method &frame)
{
Q_UNUSED(frame)
Q_Q(QAMQP::Exchange);
qDebug() << "Declared exchange: " << name;
declared = true;
QMetaObject::invokeMethod(pq_func(), "declared");
QMetaObject::invokeMethod(q, "declared");
}
void ExchangePrivate::deleteOk( const QAMQP::Frame::Method & )
void ExchangePrivate::deleteOk(const QAMQP::Frame::Method &frame)
{
Q_UNUSED(frame)
Q_Q(QAMQP::Exchange);
qDebug() << "Deleted exchange: " << name;
declared = false;
QMetaObject::invokeMethod(pq_func(), "removed");
QMetaObject::invokeMethod(q, "removed");
}
void ExchangePrivate::declare( )
void ExchangePrivate::declare()
{
if(!opened)
{
if (!opened) {
delayedDeclare = true;
return;
}
if(name.isEmpty())
if (name.isEmpty())
return;
QAMQP::Frame::Method frame(QAMQP::Frame::fcExchange, miDeclare);
@ -200,7 +180,7 @@ void ExchangePrivate::declare( )
delayedDeclare = false;
}
void ExchangePrivate::remove( bool ifUnused /*= true*/, bool noWait /*= true*/ )
void ExchangePrivate::remove(bool ifUnused, bool noWait)
{
QAMQP::Frame::Method frame(QAMQP::Frame::fcExchange, miDelete);
frame.setChannel(number);
@ -221,7 +201,9 @@ void ExchangePrivate::remove( bool ifUnused /*= true*/, bool noWait /*= true*/ )
sendFrame(frame);
}
void ExchangePrivate::publish( const QByteArray & message, const QString & key, const QString &mimeType /*= QString::fromLatin1("text/plain")*/, const QVariantHash & headers, const Exchange::MessageProperties & prop )
void ExchangePrivate::publish(const QByteArray &message, const QString &key,
const QString &mimeType, const QVariantHash & headers,
const Exchange::MessageProperties &prop)
{
QAMQP::Frame::Method frame(QAMQP::Frame::fcBasic, bmPublish);
frame.setChannel(number);
@ -236,7 +218,6 @@ void ExchangePrivate::publish( const QByteArray & message, const QString & key,
frame.setArguments(arguments_);
sendFrame(frame);
QAMQP::Frame::Content content(QAMQP::Frame::fcBasic);
content.setChannel(number);
content.setProperty(Content::cpContentType, mimeType);
@ -246,27 +227,22 @@ void ExchangePrivate::publish( const QByteArray & message, const QString & key,
Exchange::MessageProperties::ConstIterator i;
for(i = prop.begin(); i != prop.end(); ++i)
{
for (i = prop.begin(); i != prop.end(); ++i)
content.setProperty(i.key(), i.value());
}
content.setBody(message);
sendFrame(content);
int fullSize = message.size();
for (int sended_ = 0; sended_ < fullSize; sended_+= (FRAME_MAX - 7))
{
for (int sended_ = 0; sended_ < fullSize; sended_+= (FRAME_MAX - 7)) {
QAMQP::Frame::ContentBody body;
QByteArray partition_ = message.mid(sended_, (FRAME_MAX - 7));
body.setChannel(number);
body.setBody(partition_);
sendFrame(body);
}
}
void ExchangePrivate::_q_disconnected()
{
ChannelPrivate::_q_disconnected();

72
src/qamqp/amqp_exchange.h
View File

@ -2,31 +2,24 @@
#define amqp_exchange_h__
#include "amqp_channel.h"
namespace QAMQP
{
class Client;
class Queue;
class ClientPrivate;
class ExchangePrivate;
using namespace QAMQP::Frame;
class Exchange : public Channel
{
Q_OBJECT;
Exchange(int channelNumber = -1, Client * parent = 0);
using namespace QAMQP::Frame;
Q_PROPERTY(QString type READ type);
Q_PROPERTY(ExchangeOptions option READ option );
P_DECLARE_PRIVATE(QAMQP::Exchange)
Q_DISABLE_COPY(Exchange);
friend class ClientPrivate;
protected:
void onOpen();
void onClose();
public:
class Client;
class Queue;
class ClientPrivate;
class ExchangePrivate;
class Exchange : public Channel
{
Q_OBJECT
Q_PROPERTY(QString type READ type)
Q_PROPERTY(ExchangeOptions option READ option)
Q_ENUMS(ExchangeOption)
public:
enum ExchangeOption {
NoOptions = 0x0,
Passive = 0x01,
@ -39,26 +32,45 @@ namespace QAMQP
typedef QHash<QAMQP::Frame::Content::Property, QVariant> MessageProperties;
~Exchange();
virtual ~Exchange();
QString type() const;
ExchangeOptions option() const;
void declare(const QString &type = QString::fromLatin1("direct"), ExchangeOptions option = NoOptions, const TableField & arg = TableField());
void declare(const QString &type = QLatin1String("direct"),
ExchangeOptions option = NoOptions,
const TableField &arg = TableField());
void remove(bool ifUnused = true, bool noWait = true);
void bind(QAMQP::Queue * queue);
void bind(const QString & queueName);
void bind(const QString & queueName, const QString &key);
void bind(QAMQP::Queue *queue);
void bind(const QString &queueName);
void bind(const QString &queueName, const QString &key);
void publish(const QString & message, const QString & key, const MessageProperties &property = MessageProperties() );
void publish(const QByteArray & message, const QString & key, const QString &mimeType, const MessageProperties &property = MessageProperties());
void publish(const QByteArray & message, const QString & key, const QVariantHash &headers, const QString &mimeType, const MessageProperties &property = MessageProperties());
void publish(const QString &message, const QString &key,
const MessageProperties &property = MessageProperties());
void publish(const QByteArray &message, const QString &key,
const QString &mimeType, const MessageProperties &property = MessageProperties());
void publish(const QByteArray &message, const QString &key, const QVariantHash &headers,
const QString &mimeType, const MessageProperties &property = MessageProperties());
Q_SIGNALS:
Q_SIGNALS:
void declared();
void removed();
};
protected:
void onOpen();
void onClose();
private:
Q_DISABLE_COPY(Exchange)
Q_DECLARE_PRIVATE(QAMQP::Exchange)
Exchange(int channelNumber = -1, Client * parent = 0);
friend class ClientPrivate;
};
}
Q_DECLARE_OPERATORS_FOR_FLAGS(QAMQP::Exchange::ExchangeOptions)
#endif // amqp_exchange_h__

28
src/qamqp/amqp_exchange_p.h
View File

@ -1,16 +1,15 @@
#include "amqp_channel_p.h"
#define METHOD_ID_ENUM(name, id) name = id, name ## Ok
namespace QAMQP
{
using namespace QAMQP::Frame;
class ExchangePrivate: public ChannelPrivate
{
P_DECLARE_PUBLIC(QAMQP::Exchange)
public:
enum MethodId
{
using namespace QAMQP::Frame;
class ExchangePrivate: public ChannelPrivate
{
public:
enum MethodId {
METHOD_ID_ENUM(miDeclare, 10),
METHOD_ID_ENUM(miDelete, 20)
};
@ -21,20 +20,25 @@ namespace QAMQP
void declare();
void remove(bool ifUnused = true, bool noWait = true);
void declareOk(const QAMQP::Frame::Method & frame);
void deleteOk(const QAMQP::Frame::Method & frame);
void declareOk(const QAMQP::Frame::Method &frame);
void deleteOk(const QAMQP::Frame::Method &frame);
void publish(const QByteArray & message, const QString & key, const QString &mimeType = QString::fromLatin1("text/plain"), const QVariantHash & headers = QVariantHash(), const Exchange::MessageProperties & properties = Exchange::MessageProperties());
void publish(const QByteArray &message, const QString &key,
const QString &mimeType = QLatin1String("text/plain"),
const QVariantHash &headers = QVariantHash(),
const Exchange::MessageProperties &properties = Exchange::MessageProperties());
QString type;
Exchange::ExchangeOptions options;
TableField arguments;
bool _q_method(const QAMQP::Frame::Method & frame);
bool _q_method(const QAMQP::Frame::Method &frame);
void _q_disconnected();
bool delayedDeclare;
bool declared;
};
Q_DECLARE_PUBLIC(QAMQP::Exchange)
};
}

231
src/qamqp/amqp_frame.cpp
View File

@ -1,14 +1,20 @@
#include "amqp_frame.h"
#include <float.h>
#include <QDateTime>
#include <QList>
#include <QDebug>
#include <float.h>
using namespace QAMQP::Frame;
Base::Base( Type type ) : size_(0), type_(type), channel_(0) {}
Base::Base(Type type)
: size_(0),
type_(type),
channel_(0)
{
}
Base::Base( QDataStream& raw )
Base::Base(QDataStream &raw)
{
readHeader(raw);
}
@ -21,7 +27,7 @@ Type Base::type() const
Base::~Base()
{}
void Base::setChannel( qint16 channel )
void Base::setChannel(qint16 channel)
{
channel_ = channel;
}
@ -36,15 +42,14 @@ qint32 Base::size() const
return 0;
}
void QAMQP::Frame::Base::writeHeader( QDataStream & stream ) const
void QAMQP::Frame::Base::writeHeader(QDataStream &stream) const
{
stream << type_;
stream << channel_;
stream << qint32(size());
}
void QAMQP::Frame::Base::writeEnd( QDataStream & stream ) const
void QAMQP::Frame::Base::writeEnd(QDataStream &stream) const
{
stream << qint8(FRAME_END);
}
@ -56,25 +61,23 @@ void QAMQP::Frame::Base::readHeader( QDataStream & stream )
stream >> type_;
stream >> channel_;
stream >> size_;
}
void QAMQP::Frame::Base::readEnd( QDataStream & stream )
void QAMQP::Frame::Base::readEnd(QDataStream &stream)
{
unsigned char end_ = 0;
stream.readRawData(reinterpret_cast<char*>(&end_), sizeof(end_));
if(end_ != FRAME_END )
{
if (end_ != FRAME_END) {
qWarning("Wrong end of frame");
}
}
void QAMQP::Frame::Base::readPayload( QDataStream & stream )
void QAMQP::Frame::Base::readPayload(QDataStream &stream)
{
stream.skipRawData(size_);
}
void QAMQP::Frame::Base::toStream( QDataStream & stream ) const
void QAMQP::Frame::Base::toStream(QDataStream &stream) const
{
writeHeader(stream);
writePayload(stream);
@ -83,22 +86,19 @@ void QAMQP::Frame::Base::toStream( QDataStream & stream ) const
//////////////////////////////////////////////////////////////////////////
QAMQP::Frame::Method::Method( MethodClass methodClass, qint16 id )
: Base(ftMethod), methodClass_(methodClass), id_(id)
QAMQP::Frame::Method::Method(MethodClass methodClass, qint16 id)
: Base(ftMethod), methodClass_(methodClass), id_(id)
{
}
QAMQP::Frame::Method::Method( QDataStream& raw )
: Base(raw)
QAMQP::Frame::Method::Method(QDataStream &raw)
: Base(raw)
{
readPayload(raw);
}
QAMQP::Frame::Method::Method(): Base(ftMethod)
{
}
MethodClass QAMQP::Frame::Method::methodClass() const
@ -116,7 +116,7 @@ qint32 QAMQP::Frame::Method::size() const
return sizeof(id_) + sizeof(methodClass_) + arguments_.size();
}
void QAMQP::Frame::Method::setArguments( const QByteArray & data )
void QAMQP::Frame::Method::setArguments(const QByteArray &data)
{
arguments_ = data;
}
@ -126,7 +126,7 @@ QByteArray QAMQP::Frame::Method::arguments() const
return arguments_;
}
void QAMQP::Frame::Method::readPayload( QDataStream & stream )
void QAMQP::Frame::Method::readPayload(QDataStream &stream)
{
stream >> methodClass_;
stream >> id_;
@ -135,26 +135,23 @@ void QAMQP::Frame::Method::readPayload( QDataStream & stream )
stream.readRawData(arguments_.data(), arguments_.size());
}
void QAMQP::Frame::Method::writePayload( QDataStream & stream ) const
void QAMQP::Frame::Method::writePayload(QDataStream &stream) const
{
stream << quint16(methodClass_);
stream << quint16(id_);
stream.writeRawData(arguments_.data(), arguments_.size());
}
//////////////////////////////////////////////////////////////////////////
QVariant QAMQP::Frame::readField( qint8 valueType, QDataStream &s )
QVariant QAMQP::Frame::readField(qint8 valueType, QDataStream &s)
{
QVariant value;
QByteArray tmp;
qint8 nameSize_ = 0;
char octet = 0;
switch(valueType)
{
switch(valueType) {
case 't':
s.readRawData(&octet, sizeof(octet));
value = QVariant::fromValue<bool>(octet > 0);
@ -237,11 +234,7 @@ QVariant QAMQP::Frame::readField( qint8 valueType, QDataStream &s )
s >> nameSize_;
tmp.resize(nameSize_);
s.readRawData(tmp.data(), tmp.size());
#if QT_VERSION < 0x050000
value = QString::fromAscii(tmp.data(), nameSize_);
#else // For Qt5
value = QString::fromLatin1(tmp.data(), nameSize_);
#endif
break;
case 'S':
{
@ -251,11 +244,7 @@ QVariant QAMQP::Frame::readField( qint8 valueType, QDataStream &s )
tmp.resize(length_);
}
s.readRawData(tmp.data(), tmp.size());
#if QT_VERSION < 0x050000
value = QString::fromAscii(tmp.data(), tmp.size());
#else // For Qt5
value = QString::fromLatin1(tmp.data(), tmp.size());
#endif
break;
case 'A':
{
@ -263,8 +252,7 @@ QVariant QAMQP::Frame::readField( qint8 valueType, QDataStream &s )
qint8 type = 0;
s >> length_;
QList<QVariant> array_;
for (int i =0; i < length_; ++i)
{
for (int i =0; i < length_; ++i) {
s >> type;
array_ << readField(type, s);
}
@ -293,16 +281,14 @@ QVariant QAMQP::Frame::readField( qint8 valueType, QDataStream &s )
return value;
}
QDataStream & QAMQP::Frame::deserialize( QDataStream & stream, QAMQP::Frame::TableField & f )
QDataStream & QAMQP::Frame::deserialize(QDataStream &stream, QAMQP::Frame::TableField &f)
{
QByteArray data;
stream >> data;
QDataStream s(&data, QIODevice::ReadOnly);
while(!s.atEnd())
{
while(!s.atEnd()) {
qint8 valueType = 0;
QString name = readField('s', s).toString();
s >> valueType;
f[name] = readField(valueType, s);
@ -311,18 +297,17 @@ QDataStream & QAMQP::Frame::deserialize( QDataStream & stream, QAMQP::Frame::Tab
return stream;
}
QDataStream & QAMQP::Frame::serialize( QDataStream & stream, const TableField & f )
QDataStream & QAMQP::Frame::serialize(QDataStream &stream, const TableField &f)
{
QByteArray data;
QDataStream s(&data, QIODevice::WriteOnly);
TableField::ConstIterator i;
for(i = f.begin(); i != f.end(); ++i)
{
for (i = f.begin(); i != f.end(); ++i) {
writeField('s', s, i.key());
writeField(s, i.value());
}
if(data.isEmpty())
{
if (data.isEmpty()) {
stream << qint32(0);
} else {
stream << data;
@ -331,13 +316,11 @@ QDataStream & QAMQP::Frame::serialize( QDataStream & stream, const TableField &
return stream;
}
void QAMQP::Frame::print( const TableField & f )
void QAMQP::Frame::print(const TableField &f)
{
TableField::ConstIterator i;
for(i = f.begin(); i != f.end(); ++i)
{
switch(i.value().type())
{
for (i = f.begin(); i != f.end(); ++i) {
switch(i.value().type()) {
case QVariant::Hash:
qDebug() << "\t" << qPrintable(i.key()) << ": FIELD_TABLE";
break;
@ -350,14 +333,13 @@ void QAMQP::Frame::print( const TableField & f )
}
}
void QAMQP::Frame::writeField( qint8 valueType, QDataStream &s, const QVariant & value, bool withType )
void QAMQP::Frame::writeField(qint8 valueType, QDataStream &s, const QVariant &value, bool withType)
{
QByteArray tmp;
if(withType)
if (withType)
s << valueType;
switch(valueType)
{
switch (valueType) {
case 't':
s << (value.toBool() ? qint8(1) : qint8(0));
break;
@ -402,22 +384,14 @@ void QAMQP::Frame::writeField( qint8 valueType, QDataStream &s, const QVariant &
{
QString str = value.toString();
s << quint8(str.length());
#if QT_VERSION < 0x050000
s.writeRawData(str.toAscii().data(), str.length());
#else // For Qt5
s.writeRawData(str.toLatin1().data(), str.length());
#endif
}
break;
case 'S':
{
QString str = value.toString();
s << quint32(str.length());
#if QT_VERSION < 0x050000
s.writeRawData(str.toAscii().data(), str.length());
#else // For Qt5
s.writeRawData(str.toLatin1().data(), str.length());
#endif
}
break;
case 'A':
@ -425,10 +399,8 @@ void QAMQP::Frame::writeField( qint8 valueType, QDataStream &s, const QVariant &
QList<QVariant> array_(value.toList());
s << quint32(array_.count());
for (int i =0; i < array_.count(); ++i)
{
writeField(s, array_.at(i));
}
}
break;
case 'T':
s << qulonglong(value.toDateTime().toMSecsSinceEpoch());
@ -446,11 +418,10 @@ void QAMQP::Frame::writeField( qint8 valueType, QDataStream &s, const QVariant &
}
}
void QAMQP::Frame::writeField( QDataStream &s, const QVariant & value )
void QAMQP::Frame::writeField(QDataStream &s, const QVariant &value)
{
char type = 0;
switch(value.type())
{
switch (value.type()) {
case QVariant::Bool:
type = 't';
break;
@ -460,11 +431,11 @@ void QAMQP::Frame::writeField( QDataStream &s, const QVariant & value )
case QVariant::Int:
{
int i = qAbs(value.toInt());
if(i <= qint8(0xFF)) {
if (i <= qint8(0xFF)) {
type = 'b';
} else if(i <= qint16(0xFFFF)) {
} else if (i <= qint16(0xFFFF)) {
type = 'U';
} else if(i <= qint16(0xFFFFFFFF)) {
} else if (i <= qint16(0xFFFFFFFF)) {
type = 'I';
}
}
@ -472,11 +443,11 @@ void QAMQP::Frame::writeField( QDataStream &s, const QVariant & value )
case QVariant::UInt:
{
int i = value.toInt();
if(i <= qint8(0xFF)) {
if (i <= qint8(0xFF)) {
type = 'B';
} else if(i <= qint16(0xFFFF)) {
} else if (i <= qint16(0xFFFF)) {
type = 'u';
} else if(i <= qint16(0xFFFFFFFF)) {
} else if (i <= qint16(0xFFFFFFFF)) {
type = 'i';
}
}
@ -502,26 +473,30 @@ void QAMQP::Frame::writeField( QDataStream &s, const QVariant & value )
case QVariant::List:
type = 'A';
break;
default:;
default:
qDebug() << Q_FUNC_INFO << "unhandled variant type: " << value.type();
}
if(type)
if (type)
writeField(type, s, value, true);
}
//////////////////////////////////////////////////////////////////////////
QAMQP::Frame::Content::Content():Base(ftHeader)
QAMQP::Frame::Content::Content()
: Base(ftHeader)
{
}
QAMQP::Frame::Content::Content( MethodClass methodClass ):Base(ftHeader)
QAMQP::Frame::Content::Content(MethodClass methodClass)
: Base(ftHeader)
{
methodClass_ = methodClass;
}
QAMQP::Frame::Content::Content( QDataStream& raw ): Base(raw)
QAMQP::Frame::Content::Content(QDataStream &raw)
: Base(raw)
{
readPayload(raw);
}
@ -541,58 +516,55 @@ qint32 QAMQP::Frame::Content::size() const
qint16 prop_ = 0;
foreach (int p, properties_.keys())
{
prop_ |= p;
}
out << prop_;
if(prop_ & cpContentType)
if (prop_ & cpContentType)
writeField('s', out, properties_[cpContentType]);
if(prop_ & cpContentEncoding)
if (prop_ & cpContentEncoding)
writeField('s', out, properties_[cpContentEncoding]);
if(prop_ & cpHeaders)
if (prop_ & cpHeaders)
writeField('F', out, properties_[cpHeaders]);
if(prop_ & cpDeliveryMode)
if (prop_ & cpDeliveryMode)
writeField('b', out, properties_[cpDeliveryMode]);
if(prop_ & cpPriority)
if (prop_ & cpPriority)
writeField('b', out, properties_[cpPriority]);
if(prop_ & cpCorrelationId)
if (prop_ & cpCorrelationId)
writeField('s', out, properties_[cpCorrelationId]);
if(prop_ & cpReplyTo)
if (prop_ & cpReplyTo)
writeField('s', out, properties_[cpReplyTo]);
if(prop_ & cpExpiration)
if (prop_ & cpExpiration)
writeField('s', out, properties_[cpExpiration]);
if(prop_ & cpMessageId)
if (prop_ & cpMessageId)
writeField('s', out, properties_[cpMessageId]);
if(prop_ & cpTimestamp)
if (prop_ & cpTimestamp)
writeField('T', out, properties_[cpTimestamp]);
if(prop_ & cpType)
if (prop_ & cpType)
writeField('s', out, properties_[cpType]);
if(prop_ & cpUserId)
if (prop_ & cpUserId)
writeField('s', out, properties_[cpUserId]);
if(prop_ & cpAppId)
if (prop_ & cpAppId)
writeField('s', out, properties_[cpAppId]);
if(prop_ & cpClusterID)
if (prop_ & cpClusterID)
writeField('s', out, properties_[cpClusterID]);
return buffer_.size();
}
void QAMQP::Frame::Content::setBody( const QByteArray & data )
void QAMQP::Frame::Content::setBody(const QByteArray &data)
{
body_ = data;
}
@ -602,68 +574,68 @@ QByteArray QAMQP::Frame::Content::body() const
return body_;
}
void QAMQP::Frame::Content::setProperty( Property prop, const QVariant & value )
void QAMQP::Frame::Content::setProperty(Property prop, const QVariant &value)
{
properties_[prop] = value;
}
QVariant QAMQP::Frame::Content::property( Property prop ) const
QVariant QAMQP::Frame::Content::property(Property prop) const
{
return properties_.value(prop);
}
void QAMQP::Frame::Content::writePayload( QDataStream & out ) const
void QAMQP::Frame::Content::writePayload(QDataStream &out) const
{
out.writeRawData(buffer_.data(), buffer_.size());
}
void QAMQP::Frame::Content::readPayload( QDataStream & in )
void QAMQP::Frame::Content::readPayload(QDataStream &in)
{
in >> methodClass_;
in.skipRawData(2); //weight
in >> bodySize_;
qint16 flags_ = 0;
in >> flags_;
if(flags_ & cpContentType)
if (flags_ & cpContentType)
properties_[cpContentType] = readField('s', in);
if(flags_ & cpContentEncoding)
if (flags_ & cpContentEncoding)
properties_[cpContentEncoding] = readField('s', in);
if(flags_ & cpHeaders)
if (flags_ & cpHeaders)
properties_[cpHeaders] = readField('F', in);
if(flags_ & cpDeliveryMode)
if (flags_ & cpDeliveryMode)
properties_[cpDeliveryMode] = readField('b', in);
if(flags_ & cpPriority)
if (flags_ & cpPriority)
properties_[cpPriority] = readField('b', in);
if(flags_ & cpCorrelationId)
if (flags_ & cpCorrelationId)
properties_[cpCorrelationId] = readField('s', in);
if(flags_ & cpReplyTo)
if (flags_ & cpReplyTo)
properties_[cpReplyTo] = readField('s', in);
if(flags_ & cpExpiration)
if (flags_ & cpExpiration)
properties_[cpExpiration] = readField('s', in);
if(flags_ & cpMessageId)
if (flags_ & cpMessageId)
properties_[cpMessageId] = readField('s', in);
if(flags_ & cpTimestamp)
if (flags_ & cpTimestamp)
properties_[cpTimestamp] = readField('T', in);
if(flags_ & cpType)
if (flags_ & cpType)
properties_[cpType] = readField('s', in);
if(flags_ & cpUserId)
if (flags_ & cpUserId)
properties_[cpUserId] = readField('s', in);
if(flags_ & cpAppId)
if (flags_ & cpAppId)
properties_[cpAppId] = readField('s', in);
if(flags_ & cpClusterID)
if (flags_ & cpClusterID)
properties_[cpClusterID] = readField('s', in);
}
@ -673,15 +645,18 @@ qlonglong QAMQP::Frame::Content::bodySize() const
}
//////////////////////////////////////////////////////////////////////////
ContentBody::ContentBody() : Base(ftBody)
{}
ContentBody::ContentBody()
: Base(ftBody)
{
}
QAMQP::Frame::ContentBody::ContentBody( QDataStream& raw ): Base(raw)
QAMQP::Frame::ContentBody::ContentBody(QDataStream &raw)
: Base(raw)
{
readPayload(raw);
}
void QAMQP::Frame::ContentBody::setBody( const QByteArray & data )
void QAMQP::Frame::ContentBody::setBody(const QByteArray &data)
{
body_ = data;
}
@ -691,12 +666,12 @@ QByteArray QAMQP::Frame::ContentBody::body() const
return body_;
}
void QAMQP::Frame::ContentBody::writePayload( QDataStream & out ) const
void QAMQP::Frame::ContentBody::writePayload(QDataStream &out) const
{
out.writeRawData(body_.data(), body_.size());
}
void QAMQP::Frame::ContentBody::readPayload( QDataStream & in )
void QAMQP::Frame::ContentBody::readPayload(QDataStream &in)
{
body_.resize(size_);
in.readRawData(body_.data(), body_.size());
@ -709,8 +684,10 @@ qint32 QAMQP::Frame::ContentBody::size() const
//////////////////////////////////////////////////////////////////////////
QAMQP::Frame::Heartbeat::Heartbeat() : Base(ftHeartbeat) {}
void QAMQP::Frame::Heartbeat::readPayload(QDataStream & ) {}
void QAMQP::Frame::Heartbeat::writePayload(QDataStream & ) const {}
QAMQP::Frame::Heartbeat::Heartbeat()
: Base(ftHeartbeat)
{
}
void QAMQP::Frame::Heartbeat::readPayload(QDataStream &) {}
void QAMQP::Frame::Heartbeat::writePayload(QDataStream &) const {}

384
src/qamqp/amqp_frame.h
View File

@ -20,36 +20,36 @@
#define AMQP_BASIC_APP_ID_FLAG (1 << 3)
#define AMQP_BASIC_CLUSTER_ID_FLAG (1 << 2)
/*!
Library namespace
@namespace QAMQP
*/
/**
* Library namespace
* @namespace QAMQP
*/
namespace QAMQP
{
class QueuePrivate;
/*!
Frame namespace
@namespace Frame
*/
namespace Frame
{
class QueuePrivate;
namespace Frame
{
typedef quint16 channel_t;
/*!
@brief Header size in bytes
/*
* @brief Header size in bytes
*/
static const qint64 HEADER_SIZE = 7;
/*!
@brief Frame end indicator size in bytes
/*
* @brief Frame end indicator size in bytes
*/
static const qint64 FRAME_END_SIZE = 1;
/*!
@brief Frame end marker
/*
* @brief Frame end marker
*/
static const quint8 FRAME_END = 0xCE;
/*!
@brief Frame type
/*
* @brief Frame type
*/
enum Type
{
@ -59,17 +59,17 @@ namespace QAMQP
ftHeartbeat = 8 /*!< Used define heartbeat frame */
};
/*!
@brief Frame method class
@enum MethodClass
/*
* @brief Frame method class
* @enum MethodClass
*/
enum MethodClass
{
fcConnection = 10, /*!< Define class of methods related to connection */
fcChannel = 20, /*!< Define class of methods related to channel */
fcExchange = 40, /*!< Define class of methods related to exchange */
fcQueue = 50, /*!< Define class of methods related to queue */
fcBasic = 60, /*!< Define class of methods related to basic command */
fcConnection = 10, // Define class of methods related to connection
fcChannel = 20, // Define class of methods related to channel
fcExchange = 40, // Define class of methods related to exchange
fcQueue = 50, // Define class of methods related to queue
fcBasic = 60, // Define class of methods related to basic command
fcTx = 90,
};
@ -77,13 +77,12 @@ namespace QAMQP
{
qint8 scale;
quint32 value;
};
/*!
@brief Definition implementation of TableField type
@detailed Define implementation TableField type in builtin Qt types. Key contains field name, value contains field data.
It can by any type witch support serialization in AMQP types.
/*
* @brief Definition implementation of TableField type
* @detailed Define implementation TableField type in builtin Qt types. Key contains field name, value contains field data.
* It can by any type witch support serialization in AMQP types.
*/
typedef QHash<QString, QVariant> TableField;
@ -94,146 +93,146 @@ namespace QAMQP
void writeField( qint8 valueType, QDataStream &s, const QVariant & value, bool withType = false );
void print( const QAMQP::Frame::TableField & f );
/*!
@brief Base class for any frames.
@detailed Implement main methods for serialize and deserialize raw frame data.
All frames start with a 7-octet header composed of a type field (octet), a channel field (short integer) and a
size field (long integer):
@code Frame struct
0 1 3 7 size+7 size+8
+------+---------+---------+ +-------------+ +-----------+
| type | channel | size | | payload | | frame-end |
+------+---------+---------+ +-------------+ +-----------+
@endcode
octet short long 'size' octets octet
/*
* @brief Base class for any frames.
* @detailed Implement main methods for serialize and deserialize raw frame data.
* All frames start with a 7-octet header composed of a type field (octet), a channel field (short integer) and a
* size field (long integer):
* @code Frame struct
* 0 1 3 7 size+7 size+8
* +------+---------+---------+ +-------------+ +-----------+
* | type | channel | size | | payload | | frame-end |
* +------+---------+---------+ +-------------+ +-----------+
* @endcode
* octet short long 'size' octets octet
*/
class Base
{
public:
/*!
Base class constructor.
@detailed Construct frame class for sending.
@param type Define type of constructed frame.
/*
* Base class constructor.
* @detailed Construct frame class for sending.
* @param type Define type of constructed frame.
*/
Base(Type type);
/*!
Base class constructor.
@detailed Construct frame class from received raw data.
@param raw Data stream for reading source data.
/*
* Base class constructor.
* @detailed Construct frame class from received raw data.
* @param raw Data stream for reading source data.
*/
Base(QDataStream& raw);
/*!
Base class virtual destructor
/*
* Base class virtual destructor
*/
virtual ~Base();
/*!
Frame type
@detailed Return type of current frame.
/*
* Frame type
* @detailed Return type of current frame.
*/
Type type() const;
/*!
Set number of associated channel.
@param channel Number of channel.
@sa channel()
/*
* Set number of associated channel.
* @param channel Number of channel.
* @sa channel()
*/
void setChannel(qint16 channel);
/*!
Return number of associated channel.
@sa setChannel()
/*
* Return number of associated channel.
* @sa setChannel()
*/
qint16 channel() const;
/*!
Return size of frame.
/*
* Return size of frame.
*/
virtual qint32 size() const;
/*!
Output frame to stream.
@param stream Stream for serilize frame.
/*
* Output frame to stream.
* @param stream Stream for serilize frame.
*/
void toStream(QDataStream & stream) const;
void toStream(QDataStream &stream) const;
protected:
void writeHeader(QDataStream & stream) const;
virtual void writePayload(QDataStream & stream) const;
void writeEnd(QDataStream & stream) const;
void writeHeader(QDataStream &stream) const;
virtual void writePayload(QDataStream &stream) const;
void writeEnd(QDataStream &stream) const;
void readHeader(QDataStream & stream);
virtual void readPayload(QDataStream & stream);
void readEnd(QDataStream & stream);
void readHeader(QDataStream &stream);
virtual void readPayload(QDataStream &stream);
void readEnd(QDataStream &stream);
qint32 size_;
private:
qint8 type_;
qint16 channel_;
};
/*!
@brief Class for working with method frames.
@detailed Implement main methods for serialize and deserialize raw method frame data.
Method frame bodies consist of an invariant list of data fields, called "arguments". All method bodies start
with identifier numbers for the class and method:
@code Frame struct
0 2 4
+----------+-----------+-------------- - -
| class-id | method-id | arguments...
+----------+-----------+-------------- - -
short short ...
@endcode
/*
* @brief Class for working with method frames.
* @detailed Implement main methods for serialize and deserialize raw method frame data.
* Method frame bodies consist of an invariant list of data fields, called "arguments". All method bodies start
* with identifier numbers for the class and method:
* @code Frame struct
* 0 2 4
* +----------+-----------+-------------- - -
* | class-id | method-id | arguments...
* +----------+-----------+-------------- - -
* short short ...
* @endcode
*/
class Method : public Base
{
public:
/*!
Method class constructor.
@detailed Construct frame class for sending.
/*
* Method class constructor.
* @detailed Construct frame class for sending.
*/
Method();
/*!
Method class constructor.
@detailed Construct frame class for sending.
@param methodClass Define method class id of constructed frame.
@param id Define method id of constructed frame.
/*
* Method class constructor.
* @detailed Construct frame class for sending.
* @param methodClass Define method class id of constructed frame.
* @param id Define method id of constructed frame.
*/
Method(MethodClass methodClass, qint16 id);
/*!
Method class constructor.
@detailed Construct frame class from received raw data.
@param raw Data stream for reading source data.
/*
* Method class constructor.
* @detailed Construct frame class from received raw data.
* @param raw Data stream for reading source data.
*/
Method(QDataStream& raw);
Method(QDataStream &raw);
/*!
Method class type.
/*
* Method class type.
*/
MethodClass methodClass() const;
/*!
Method id.
/*
* Method id.
*/
qint16 id() const;
qint32 size() const;
/*!
Set arguments for method.
@param data Serialized method arguments.
@sa arguments
/*
* Set arguments for method.
* @param data Serialized method arguments.
* @sa arguments
*/
void setArguments(const QByteArray & data);
void setArguments(const QByteArray &data);
/*!
Return arguments for method.
@sa setArguments
/*
* Return arguments for method.
* @sa setArguments
*/
QByteArray arguments() const;
@ -243,49 +242,49 @@ namespace QAMQP
short methodClass_;
qint16 id_;
QByteArray arguments_;
};
/*!
@brief Class for working with content frames.
@detailed Implement main methods for serialize and deserialize raw content frame data.
A content header payload has this format:
@code Frame struct
+----------+--------+-----------+----------------+------------- - -
| class-id | weight | body size | property flags | property list...
+----------+--------+-----------+----------------+------------- - -
short short long long short remainder...
@endcode
| Property | Description |
| ---------- | ----------- |
|cpContentType | MIME content type |
| ocpContentEncoding | MIME content encoding |
| cpHeaders | message header field table |
| cpDeliveryMode| nonpersistent (1) or persistent (2) |
| cpPriority | message priority, 0 to 9 |
| cpCorrelationId | application correlation identifier |
| cpReplyTo | address to reply to |
| cpExpiration | message expiration specification |
| cpMessageId | application message identifier |
| cpTimestamp | message timestamp |
| cpType | message type name |
| cpUserId | creating user id |
| cpAppId | creating application id |
| cpClusterID| cluster ID |
Default property:
@sa setProperty
@sa property
/*
* @brief Class for working with content frames.
* @detailed Implement main methods for serialize and deserialize raw content frame data.
* A content header payload has this format:
* @code Frame struct
* +----------+--------+-----------+----------------+------------- - -
* | class-id | weight | body size | property flags | property list...
* +----------+--------+-----------+----------------+------------- - -
* short short long long short remainder...
* @endcode
*
* | Property | Description |
* | ---------- | ----------- |
* |cpContentType | MIME content type |
* | ocpContentEncoding | MIME content encoding |
* | cpHeaders | message header field table |
* | cpDeliveryMode| nonpersistent (1) or persistent (2) |
* | cpPriority | message priority, 0 to 9 |
* | cpCorrelationId | application correlation identifier |
* | cpReplyTo | address to reply to |
* | cpExpiration | message expiration specification |
* | cpMessageId | application message identifier |
* | cpTimestamp | message timestamp |
* | cpType | message type name |
* | cpUserId | creating user id |
* | cpAppId | creating application id |
* | cpClusterID| cluster ID |
*
* Default property:
* @sa setProperty
* @sa property
*/
class Content : public Base
{
friend class QAMQP::QueuePrivate;
public:
/*! Default content frame property
/*
* Default content frame property
*/
enum Property
{
@ -304,55 +303,54 @@ namespace QAMQP
cpAppId = AMQP_BASIC_APP_ID_FLAG,
cpClusterID = AMQP_BASIC_CLUSTER_ID_FLAG
};
Q_DECLARE_FLAGS(Properties, Property);
Q_DECLARE_FLAGS(Properties, Property)
/*!
Content class constructor.
@detailed Construct frame content header class for sending.
/*
* Content class constructor.
* @detailed Construct frame content header class for sending.
*/
Content();
/*!
Content class constructor.
@detailed Construct frame content header class for sending.
@param methodClass Define method class id of constructed frame.
/*
* Content class constructor.
* @detailed Construct frame content header class for sending.
* @param methodClass Define method class id of constructed frame.
*/
Content(MethodClass methodClass);
/*!
Content class constructor.
@detailed Construct frame content header class for sending.
@param raw Data stream for reading source data.
/*
* Content class constructor.
* @detailed Construct frame content header class for sending.
* @param raw Data stream for reading source data.
*/
Content(QDataStream& raw);
Content(QDataStream &raw);
/*!
Method class type.
/*
* Method class type.
*/
MethodClass methodClass() const;
qint32 size() const;
/*!
Set default content header property
@param prop Any default content header property
@param value Associated data
/*
* Set default content header property
* @param prop Any default content header property
* @param value Associated data
*/
void setProperty(Property prop, const QVariant & value);
void setProperty(Property prop, const QVariant &value);
/*!
Return associated with property value
@param prop Any default content header property
/*
* Return associated with property value
* @param prop Any default content header property
*/
QVariant property(Property prop) const;
void setBody(const QByteArray & data);
void setBody(const QByteArray &data);
QByteArray body() const;
qlonglong bodySize() const;
protected:
void writePayload(QDataStream & stream) const;
void readPayload(QDataStream & stream);
void writePayload(QDataStream &stream) const;
void readPayload(QDataStream &stream);
short methodClass_;
qint16 id_;
QByteArray body_;
@ -365,40 +363,42 @@ namespace QAMQP
{
public:
ContentBody();
ContentBody(QDataStream& raw);
void setBody(const QByteArray & data);
ContentBody(QDataStream &raw);
void setBody(const QByteArray &data);
QByteArray body() const;
qint32 size() const;
protected:
void writePayload(QDataStream & stream) const;
void readPayload(QDataStream & stream);
void writePayload(QDataStream &stream) const;
void readPayload(QDataStream &stream);
private:
QByteArray body_;
};
/*!
@brief Class for working with heartbeat frames.
@detailed Implement frame for heartbeat send.
/*
* @brief Class for working with heartbeat frames.
* @detailed Implement frame for heartbeat send.
*/
class Heartbeat : public Base
{
public:
/*!
Heartbeat class constructor.
@detailed Construct frame class for sending.
/*
* Heartbeat class constructor.
* @detailed Construct frame class for sending.
*/
Heartbeat();
protected:
void writePayload(QDataStream & stream) const;
void readPayload(QDataStream & stream);
void writePayload(QDataStream &stream) const;
void readPayload(QDataStream &stream);
};
class MethodHandler
{
public:
virtual void _q_method(const QAMQP::Frame::Method & frame) = 0;
virtual void _q_method(const QAMQP::Frame::Method &frame) = 0;
};
class ContentHandler
@ -412,10 +412,10 @@ namespace QAMQP
public:
virtual void _q_body(const QAMQP::Frame::ContentBody & frame) = 0;
};
}
}
}
Q_DECLARE_METATYPE(QAMQP::Frame::decimal);
Q_DECLARE_METATYPE(QAMQP::Frame::TableField);
Q_DECLARE_METATYPE(QAMQP::Frame::decimal)
Q_DECLARE_METATYPE(QAMQP::Frame::TableField)
#endif // amqp_frame_h__

19
src/qamqp/amqp_global.h
View File

@ -1,8 +1,6 @@
#ifndef qamqp_global_h__
#define qamqp_global_h__
#include <QtCore/qglobal.h>
#define QAMQP_P_INCLUDE
#define AMQPSCHEME "amqp"
#define AMQPSSCHEME "amqps"
@ -15,23 +13,6 @@
#define QAMQP_VERSION "0.2.0"
#define AMQP_CONNECTION_FORCED 320
#define P_DECLARE_PRIVATE(Class) \
friend class Class##Private; \
inline Class##Private* pd_func() { return reinterpret_cast<Class##Private *>(this->pd_ptr); } \
inline const Class##Private* pd_func() const { return reinterpret_cast<const Class##Private *>(this->pd_ptr); }
#define P_DECLARE_PUBLIC(Class) \
inline Class* pq_func() { return static_cast<Class *>(this->pq_ptr); } \
inline const Class* pq_func() const { return static_cast<const Class *>(this->pq_ptr); } \
friend class Class;
#define P_D(Class) Class##Private * const d = this->pd_func()
#define P_Q(Class) Class * const q = this->pq_func()
#endif // qamqp_global_h__

15
src/qamqp/amqp_message.cpp Normal file
View File

@ -0,0 +1,15 @@
#include "amqp_message.h"
using namespace QAMQP;
Message::Message()
{
qDebug("Message create");
leftSize = 0;
deliveryTag = 0;
}
Message::~Message()
{
qDebug("Message release");
}

25
src/qamqp/amqp_message.h
View File

@ -5,20 +5,14 @@
namespace QAMQP
{
struct Message
{
Message()
{
qDebug("Message create");
leftSize = 0;
deliveryTag = 0;
}
~Message()
{
qDebug("Message release");
}
struct Message
{
Message();
virtual ~Message();
typedef QAMQP::Frame::Content::Property MessageProperty;
Q_DECLARE_FLAGS(MessageProperties, MessageProperty);
Q_DECLARE_FLAGS(MessageProperties, MessageProperty)
qlonglong deliveryTag;
QByteArray payload;
@ -27,7 +21,8 @@ namespace QAMQP
QString routeKey;
QString exchangeName;
int leftSize;
};
};
typedef QSharedPointer<QAMQP::Message> MessagePtr;
typedef QSharedPointer<QAMQP::Message> MessagePtr;
}

129
src/qamqp/amqp_network.cpp
View File

@ -3,7 +3,8 @@
#include <QTimer>
#include <QtEndian>
QAMQP::Network::Network( QObject * parent /*= 0*/ ):QObject(parent)
QAMQP::Network::Network( QObject * parent)
: QObject(parent)
{
qRegisterMetaType<QAMQP::Frame::Method>("QAMQP::Frame::Method");
@ -19,23 +20,22 @@ QAMQP::Network::~Network()
disconnect();
}
void QAMQP::Network::connectTo( const QString & host, quint32 port )
void QAMQP::Network::connectTo(const QString & host, quint16 port)
{
if(!socket_)
{
if(!socket_) {
qWarning("AMQP: Socket didn't create.");
return;
}
QString h(host);
int p(port);
connect_ = true;
if(host.isEmpty())
if (host.isEmpty())
h = lastHost_ ;
if(port == 0)
if (port == 0)
p = lastPort_;
if (isSsl())
{
if (isSsl()) {
#ifndef QT_NO_SSL
static_cast<QSslSocket *>(socket_.data())->connectToHostEncrypted(h, p);
#else
@ -52,25 +52,20 @@ void QAMQP::Network::connectTo( const QString & host, quint32 port )
void QAMQP::Network::disconnect()
{
connect_ = false;
if(socket_)
if (socket_)
socket_->close();
}
void QAMQP::Network::error( QAbstractSocket::SocketError socketError )
void QAMQP::Network::error(QAbstractSocket::SocketError socketError)
{
if(timeOut_ == 0)
{
if (timeOut_ == 0) {
timeOut_ = 1000;
} else {
if(timeOut_ < 120000)
{
if (timeOut_ < 120000)
timeOut_ *= 5;
}
}
Q_UNUSED(socketError);
switch(socketError)
{
switch(socketError) {
case QAbstractSocket::ConnectionRefusedError:
case QAbstractSocket::RemoteHostClosedError:
case QAbstractSocket::SocketTimeoutError:
@ -84,90 +79,69 @@ void QAMQP::Network::error( QAbstractSocket::SocketError socketError )
break;
}
if( autoReconnect_ && connect_ )
{
if (autoReconnect_ && connect_)
QTimer::singleShot(timeOut_, this, SLOT(connectTo()));
}
}
void QAMQP::Network::readyRead()
{
while(socket_->bytesAvailable() >= Frame::HEADER_SIZE)
{
char* headerData = buffer_.data();
while (socket_->bytesAvailable() >= Frame::HEADER_SIZE) {
char *headerData = buffer_.data();
socket_->peek(headerData, Frame::HEADER_SIZE);
const quint32 payloadSize = qFromBigEndian<quint32>(*(quint32*)&headerData[3]);
const qint64 readSize = Frame::HEADER_SIZE+payloadSize+Frame::FRAME_END_SIZE;
if(socket_->bytesAvailable() >= readSize)
{
if (socket_->bytesAvailable() >= readSize) {
buffer_.resize(readSize);
socket_->read(buffer_.data(), readSize);
const char* bufferData = buffer_.constData();
const quint8 type = *(quint8*)&bufferData[0];
const quint8 magic = *(quint8*)&bufferData[Frame::HEADER_SIZE+payloadSize];
if(magic != QAMQP::Frame::FRAME_END)
{
if (magic != QAMQP::Frame::FRAME_END)
qWarning() << "Wrong end frame";
}
QDataStream streamB(&buffer_, QIODevice::ReadOnly);
switch(QAMQP::Frame::Type(type))
{
switch(QAMQP::Frame::Type(type)) {
case QAMQP::Frame::ftMethod:
{
QAMQP::Frame::Method frame(streamB);
if(frame.methodClass() == QAMQP::Frame::fcConnection)
{
if (frame.methodClass() == QAMQP::Frame::fcConnection) {
m_pMethodHandlerConnection->_q_method(frame);
}
else
{
} else {
foreach(Frame::MethodHandler* pMethodHandler, m_methodHandlersByChannel[frame.channel()])
{
pMethodHandler->_q_method(frame);
}
}
}
break;
case QAMQP::Frame::ftHeader:
{
QAMQP::Frame::Content frame(streamB);
foreach(Frame::ContentHandler* pMethodHandler, m_contentHandlerByChannel[frame.channel()])
{
pMethodHandler->_q_content(frame);
}
}
break;
case QAMQP::Frame::ftBody:
{
QAMQP::Frame::ContentBody frame(streamB);
foreach(Frame::ContentBodyHandler* pMethodHandler, m_bodyHandlersByChannel[frame.channel()])
{
pMethodHandler->_q_body(frame);
}
}
break;
case QAMQP::Frame::ftHeartbeat:
{
qDebug("AMQP: Heartbeat");
}
break;
default:
qWarning() << "AMQP: Unknown frame type: " << type;
}
}
else
{
} else {
break;
}
}
}
void QAMQP::Network::sendFrame( const QAMQP::Frame::Base & frame )
void QAMQP::Network::sendFrame(const QAMQP::Frame::Base &frame)
{
if(socket_->state() == QAbstractSocket::ConnectedState)
{
if (socket_->state() == QAbstractSocket::ConnectedState) {
QDataStream stream(socket_);
frame.toStream(stream);
}
@ -175,31 +149,29 @@ void QAMQP::Network::sendFrame( const QAMQP::Frame::Base & frame )
bool QAMQP::Network::isSsl() const
{
if(socket_)
{
return QString(socket_->metaObject()->className()).compare( "QSslSocket", Qt::CaseInsensitive) == 0;
}
if (socket_)
return QString(socket_->metaObject()->className()).compare("QSslSocket", Qt::CaseInsensitive) == 0;
return false;
}
void QAMQP::Network::setSsl( bool value )
void QAMQP::Network::setSsl(bool value)
{
initSocket(value);
}
void QAMQP::Network::initSocket( bool ssl /*= false*/ )
void QAMQP::Network::initSocket(bool ssl)
{
if(socket_)
delete socket_;
if (socket_) {
socket_->deleteLater();
socket_ = 0;
}
if(ssl)
{
if (ssl) {
#ifndef QT_NO_SSL
socket_ = new QSslSocket(this);
QSslSocket * ssl_= static_cast<QSslSocket*> (socket_.data());
ssl_->setProtocol(QSsl::AnyProtocol);
connect(socket_, SIGNAL(sslErrors(const QList<QSslError> &)), this, SLOT(sslErrors()));
connect(socket_, SIGNAL(connected()), this, SLOT(conectionReady()));
#else
qWarning("AMQP: You library has builded with QT_NO_SSL option.");
@ -209,27 +181,26 @@ void QAMQP::Network::initSocket( bool ssl /*= false*/ )
connect(socket_, SIGNAL(connected()), this, SLOT(conectionReady()));
}
if(socket_)
{
if (socket_) {
connect(socket_, SIGNAL(disconnected()), this, SIGNAL(disconnected()));
connect(socket_, SIGNAL(readyRead()), this, SLOT(readyRead()));
connect(socket_, SIGNAL(error(QAbstractSocket::SocketError)), this, SLOT(error(QAbstractSocket::SocketError)));
connect(socket_, SIGNAL(error(QAbstractSocket::SocketError)),
this, SLOT(error(QAbstractSocket::SocketError)));
}
}
void QAMQP::Network::sslErrors( )
void QAMQP::Network::sslErrors()
{
#ifndef QT_NO_SSL
#ifndef QT_NO_SSL
static_cast<QSslSocket*>(socket_.data())->ignoreSslErrors();
#endif
#endif
}
void QAMQP::Network::conectionReady()
{
emit connected();
Q_EMIT connected();
timeOut_ = 0;
char header_[8] = {'A', 'M', 'Q', 'P', 0,0,9,1};
socket_->write(header_, 8);
}
@ -239,38 +210,34 @@ bool QAMQP::Network::autoReconnect() const
return autoReconnect_;
}
void QAMQP::Network::setAutoReconnect( bool value )
void QAMQP::Network::setAutoReconnect(bool value)
{
autoReconnect_ = value;
}
QAbstractSocket::SocketState QAMQP::Network::state() const
{
if(socket_)
{
if (socket_)
return socket_->state();
} else {
return QAbstractSocket::UnconnectedState;
}
}
void QAMQP::Network::setMethodHandlerConnection(Frame::MethodHandler* pMethodHandlerConnection)
void QAMQP::Network::setMethodHandlerConnection(Frame::MethodHandler *pMethodHandlerConnection)
{
m_pMethodHandlerConnection = pMethodHandlerConnection;
}
void QAMQP::Network::addMethodHandlerForChannel(Channel channel, Frame::MethodHandler* pHandler)
void QAMQP::Network::addMethodHandlerForChannel(Channel channel, Frame::MethodHandler *pHandler)
{
m_methodHandlersByChannel[channel].append(pHandler);
}
void QAMQP::Network::addContentHandlerForChannel(Channel channel, Frame::ContentHandler* pHandler)
void QAMQP::Network::addContentHandlerForChannel(Channel channel, Frame::ContentHandler *pHandler)
{
m_contentHandlerByChannel[channel].append(pHandler);
}
void QAMQP::Network::addContentBodyHandlerForChannel(Channel channel, Frame::ContentBodyHandler* pHandler)
void QAMQP::Network::addContentBodyHandlerForChannel(Channel channel, Frame::ContentBodyHandler *pHandler)
{
m_bodyHandlersByChannel[channel].append(pHandler);
}

49
src/qamqp/amqp_network.h
View File

@ -4,7 +4,7 @@
#include <QObject>
#include <QTcpSocket>
#ifndef QT_NO_SSL
#include <QSslSocket>
# include <QSslSocket>
#endif
#include <QPointer>
#include <QBuffer>
@ -13,20 +13,18 @@
namespace QAMQP
{
class Network : public QObject
{
Q_OBJECT
Q_DISABLE_COPY(Network)
public:
typedef qint16 Channel;
Network(QObject * parent = 0);
class Network : public QObject
{
Q_OBJECT
public:
Network(QObject *parent = 0);
~Network();
void disconnect();
void sendFrame();
void sendFrame(const QAMQP::Frame::Base & frame);
void sendFrame(const QAMQP::Frame::Base &frame);
bool isSsl() const;
void setSsl(bool value);
@ -36,28 +34,28 @@ namespace QAMQP
QAbstractSocket::SocketState state() const;
void setMethodHandlerConnection(Frame::MethodHandler* pMethodHandlerConnection);
void addMethodHandlerForChannel(Channel channel, Frame::MethodHandler* pHandler);
void addContentHandlerForChannel(Channel channel, Frame::ContentHandler* pHandler);
void addContentBodyHandlerForChannel(Channel channel, Frame::ContentBodyHandler* pHandler);
typedef qint16 Channel;
void setMethodHandlerConnection(Frame::MethodHandler *pMethodHandlerConnection);
void addMethodHandlerForChannel(Channel channel, Frame::MethodHandler *pHandler);
void addContentHandlerForChannel(Channel channel, Frame::ContentHandler *pHandler);
void addContentBodyHandlerForChannel(Channel channel, Frame::ContentBodyHandler *pHandler);
public slots:
void connectTo(const QString & host = QString(), quint32 port = 0);
void error( QAbstractSocket::SocketError socketError );
public slots:
void connectTo(const QString &host = QString(), quint16 port = 0);
void error(QAbstractSocket::SocketError socketError);
signals:
Q_SIGNALS:
void connected();
void disconnected();
private slots:
private Q_SLOTS:
void readyRead();
void sslErrors ( );
void sslErrors();
void conectionReady();
private:
private:
Q_DISABLE_COPY(Network)
void initSocket(bool ssl = false);
QPointer<QTcpSocket> socket_;
QByteArray buffer_;
@ -67,11 +65,12 @@ namespace QAMQP
int timeOut_;
bool connect_;
Frame::MethodHandler* m_pMethodHandlerConnection;
Frame::MethodHandler *m_pMethodHandlerConnection;
QHash<Channel, QList<Frame::MethodHandler*> > m_methodHandlersByChannel;
QHash<Channel, QList<Frame::ContentHandler*> > m_contentHandlerByChannel;
QHash<Channel, QList<Frame::ContentBodyHandler*> > m_bodyHandlersByChannel;
};
};
}
#endif // amqp_network_h__

32
src/qamqp/amqp_p.h
View File

@ -1,5 +1,5 @@
#ifndef qamqp_amqp_p_h__
#define qamqp_amqp_p_h__
#ifndef QAMQP_P_H
#define QAMQP_P_H
#include <QSharedPointer>
@ -10,26 +10,27 @@
namespace QAMQP
{
class ClientPrivate
{
P_DECLARE_PUBLIC(QAMQP::Client)
public:
ClientPrivate(Client * q ) ;
class Queue;
class Exchange;
class ClientPrivate
{
public:
ClientPrivate(Client *q);
~ClientPrivate();
void init(QObject *parent);
void init(QObject *parent, const QUrl &connectionString);
void init(QObject * parent);
void init(QObject * parent, const QUrl & connectionString);
void printConnect() const;
void connect();
void disconnect();
void parseCnnString( const QUrl & connectionString);
void parseConnectionString( const QUrl &connectionString);
void sockConnect();
void login();
void setAuth(Authenticator* auth);
Exchange * createExchange(int channelNumber, const QString &name);
Queue * createQueue(int channelNumber, const QString &name);
Exchange *createExchange(int channelNumber, const QString &name);
Queue *createQueue(int channelNumber, const QString &name);
quint32 port;
QString host;
@ -41,11 +42,10 @@ namespace QAMQP
bool isSSl() const;
Client * const q_ptr;
Q_DECLARE_PUBLIC(QAMQP::Client)
Client * const pq_ptr;
};
};
}
#endif // amqp_p_h__

284
src/qamqp/amqp_queue.cpp
View File

@ -10,34 +10,11 @@ using namespace QAMQP::Frame;
#include <QDataStream>
#include <QFile>
namespace QAMQP
Queue::Queue(int channelNumber, Client *parent)
: Channel(new QueuePrivate(this), parent)
{
struct QueueExceptionCleaner
{
/* this cleans up when the constructor throws an exception */
static inline void cleanup(Queue *that, QueuePrivate *d)
{
#ifdef QT_NO_EXCEPTIONS
Q_UNUSED(that);
Q_UNUSED(d);
#else
Q_UNUSED(that);
Q_UNUSED(d);
#endif
}
};
}
Queue::Queue( int channelNumber, Client * parent /*= 0*/ )
: Channel(new QueuePrivate(this))
{
QT_TRY {
pd_func()->init(channelNumber, parent);
} QT_CATCH(...) {
QueueExceptionCleaner::cleanup(this, pd_func());
QT_RETHROW;
}
Q_D(QAMQP::Queue);
d->init(channelNumber, parent);
}
Queue::~Queue()
@ -47,169 +24,176 @@ Queue::~Queue()
void Queue::onOpen()
{
P_D(Queue);
if(d->delayedDeclare)
{
Q_D(QAMQP::Queue);
if (d->delayedDeclare)
d->declare();
}
if(!d->delayedBindings.isEmpty())
{
if (!d->delayedBindings.isEmpty()) {
typedef QPair<QString, QString> BindingPair;
foreach(BindingPair binding, d->delayedBindings)
{
d->bind(binding.first, binding.second);
}
d->delayedBindings.clear();
}
}
void Queue::onClose()
{
pd_func()->remove(true, true);
Q_D(QAMQP::Queue);
d->remove(true, true);
}
Queue::QueueOptions Queue::option() const
{
return pd_func()->options;
Q_D(const QAMQP::Queue);
return d->options;
}
void Queue::setNoAck( bool noAck )
void Queue::setNoAck(bool noAck)
{
pd_func()->noAck = noAck;
Q_D(QAMQP::Queue);
d->noAck = noAck;
}
bool Queue::noAck() const
{
return pd_func()->noAck;
Q_D(const QAMQP::Queue);
return d->noAck;
}
void Queue::declare()
{
P_D(Queue);
Q_D(QAMQP::Queue);
declare(d->name, QueueOptions(Durable | AutoDelete));
}
void Queue::declare( const QString &name, QueueOptions options )
void Queue::declare(const QString &name, QueueOptions options)
{
P_D(Queue);
Q_D(QAMQP::Queue);
setName(name);
d->options = options;
d->declare();
}
void Queue::remove( bool ifUnused /*= true*/, bool ifEmpty /*= true*/, bool noWait /*= true*/ )
void Queue::remove(bool ifUnused, bool ifEmpty, bool noWait)
{
pd_func()->remove(ifUnused, ifEmpty, noWait);
Q_D(QAMQP::Queue);
d->remove(ifUnused, ifEmpty, noWait);
}
void Queue::purge()
{
pd_func()->purge();
Q_D(QAMQP::Queue);
d->purge();
}
void Queue::bind( const QString & exchangeName, const QString & key )
void Queue::bind(const QString &exchangeName, const QString &key)
{
pd_func()->bind(exchangeName, key);
Q_D(QAMQP::Queue);
d->bind(exchangeName, key);
}
void Queue::bind( Exchange * exchange, const QString & key )
void Queue::bind(Exchange *exchange, const QString &key)
{
if(exchange)
pd_func()->bind(exchange->name(), key);
Q_D(QAMQP::Queue);
if (exchange)
d->bind(exchange->name(), key);
}
void Queue::unbind( const QString & exchangeName, const QString & key )
void Queue::unbind(const QString &exchangeName, const QString &key)
{
pd_func()->unbind(exchangeName, key);
Q_D(QAMQP::Queue);
d->unbind(exchangeName, key);
}
void Queue::unbind( Exchange * exchange, const QString & key )
void Queue::unbind(Exchange *exchange, const QString &key)
{
if(exchange)
pd_func()->unbind(exchange->name(), key);
Q_D(QAMQP::Queue);
if (exchange)
d->unbind(exchange->name(), key);
}
void Queue::_q_content(const Content &frame)
{
pd_func()->_q_content(frame);
Q_D(QAMQP::Queue);
d->_q_content(frame);
}
void Queue::_q_body(const ContentBody &frame)
{
pd_func()->_q_body(frame);
Q_D(QAMQP::Queue);
d->_q_body(frame);
}
QAMQP::MessagePtr Queue::getMessage()
{
return pd_func()->messages_.dequeue();
Q_D(QAMQP::Queue);
return d->messages_.dequeue();
}
bool Queue::hasMessage() const
{
if(pd_func()->messages_.isEmpty())
{
Q_D(const QAMQP::Queue);
if (d->messages_.isEmpty())
return false;
}
const MessagePtr &q = pd_func()->messages_.head();
const MessagePtr &q = d->messages_.head();
return q->leftSize == 0;
}
void Queue::consume(ConsumeOptions options)
{
pd_func()->consume(options);
Q_D(QAMQP::Queue);
d->consume(options);
}
void Queue::setConsumerTag( const QString &consumerTag )
void Queue::setConsumerTag(const QString &consumerTag)
{
pd_func()->consumerTag = consumerTag;
Q_D(QAMQP::Queue);
d->consumerTag = consumerTag;
}
QString Queue::consumerTag() const
{
return pd_func()->consumerTag;
Q_D(const QAMQP::Queue);
return d->consumerTag;
}
void Queue::get()
{
pd_func()->get();
Q_D(QAMQP::Queue);
d->get();
}
void Queue::ack( const MessagePtr & message )
void Queue::ack(const MessagePtr &message)
{
pd_func()->ack(message);
Q_D(QAMQP::Queue);
d->ack(message);
}
//////////////////////////////////////////////////////////////////////////
QueuePrivate::QueuePrivate(Queue * q)
:ChannelPrivate(q)
, delayedDeclare(false)
, declared(false)
, noAck(true)
, recievingMessage(false)
: ChannelPrivate(q),
delayedDeclare(false),
declared(false),
noAck(true),
recievingMessage(false)
{
}
QueuePrivate::~QueuePrivate()
{
}
bool QueuePrivate::_q_method( const QAMQP::Frame::Method & frame )
bool QueuePrivate::_q_method(const QAMQP::Frame::Method &frame)
{
if(ChannelPrivate::_q_method(frame))
Q_Q(QAMQP::Queue);
if (ChannelPrivate::_q_method(frame))
return true;
if(frame.methodClass() == QAMQP::Frame::fcQueue)
{
switch(frame.id())
{
if (frame.methodClass() == QAMQP::Frame::fcQueue) {
switch (frame.id()) {
case miDeclareOk:
declareOk(frame);
break;
@ -228,13 +212,12 @@ bool QueuePrivate::_q_method( const QAMQP::Frame::Method & frame )
default:
break;
}
return true;
}
if(frame.methodClass() == QAMQP::Frame::fcBasic)
{
switch(frame.id())
{
if (frame.methodClass() == QAMQP::Frame::fcBasic) {
switch(frame.id()) {
case bmConsumeOk:
consumeOk(frame);
break;
@ -245,7 +228,7 @@ bool QueuePrivate::_q_method( const QAMQP::Frame::Method & frame )
getOk(frame);
break;
case bmGetEmpty:
QMetaObject::invokeMethod(pq_func(), "empty");
QMetaObject::invokeMethod(q, "empty");
break;
default:
break;
@ -253,14 +236,12 @@ bool QueuePrivate::_q_method( const QAMQP::Frame::Method & frame )
return true;
}
return false;
}
void QueuePrivate::declareOk( const QAMQP::Frame::Method & frame )
void QueuePrivate::declareOk(const QAMQP::Frame::Method &frame)
{
Q_Q(QAMQP::Queue);
qDebug() << "Declared queue: " << name;
declared = true;
@ -272,11 +253,12 @@ void QueuePrivate::declareOk( const QAMQP::Frame::Method & frame )
stream >> messageCount >> consumerCount;
qDebug("Message count %d\nConsumer count: %d", messageCount, consumerCount);
QMetaObject::invokeMethod(pq_func(), "declared");
QMetaObject::invokeMethod(q, "declared");
}
void QueuePrivate::deleteOk( const QAMQP::Frame::Method & frame )
void QueuePrivate::deleteOk(const QAMQP::Frame::Method &frame)
{
Q_Q(QAMQP::Queue);
qDebug() << "Deleted or purged queue: " << name;
declared = false;
@ -285,26 +267,30 @@ void QueuePrivate::deleteOk( const QAMQP::Frame::Method & frame )
qint32 messageCount = 0;
stream >> messageCount;
qDebug("Message count %d", messageCount);
QMetaObject::invokeMethod(pq_func(), "removed");
QMetaObject::invokeMethod(q, "removed");
}
void QueuePrivate::bindOk( const QAMQP::Frame::Method & )
void QueuePrivate::bindOk(const QAMQP::Frame::Method &frame)
{
Q_UNUSED(frame)
Q_Q(QAMQP::Queue);
qDebug() << "Binded to queue: " << name;
QMetaObject::invokeMethod(pq_func(), "binded", Q_ARG(bool, true));
QMetaObject::invokeMethod(q, "binded", Q_ARG(bool, true));
}
void QueuePrivate::unbindOk( const QAMQP::Frame::Method & )
void QueuePrivate::unbindOk(const QAMQP::Frame::Method &frame)
{
Q_UNUSED(frame)
Q_Q(QAMQP::Queue);
qDebug() << "Unbinded queue: " << name;
QMetaObject::invokeMethod(pq_func(), "binded", Q_ARG(bool, false));
QMetaObject::invokeMethod(q, "binded", Q_ARG(bool, false));
}
void QueuePrivate::declare()
{
if(!opened)
{
if (!opened) {
delayedDeclare = true;
return;
}
@ -321,13 +307,11 @@ void QueuePrivate::declare()
frame.setArguments(arguments_);
sendFrame(frame);
delayedDeclare = false;
}
void QueuePrivate::remove( bool ifUnused /*= true*/, bool ifEmpty /*= true*/, bool noWait /*= true*/ )
void QueuePrivate::remove(bool ifUnused, bool ifEmpty, bool noWait)
{
if(!declared)
if (!declared)
return;
QAMQP::Frame::Method frame(QAMQP::Frame::fcQueue, miDelete);
@ -348,15 +332,12 @@ void QueuePrivate::remove( bool ifUnused /*= true*/, bool ifEmpty /*= true*/, bo
frame.setArguments(arguments_);
sendFrame(frame);
}
void QueuePrivate::purge()
{
if(!opened)
{
if (!opened)
return;
}
QAMQP::Frame::Method frame(QAMQP::Frame::fcQueue, miPurge);
frame.setChannel(number);
@ -367,13 +348,11 @@ void QueuePrivate::purge()
out << qint8(0); // no-wait
frame.setArguments(arguments_);
sendFrame(frame);
}
void QueuePrivate::bind( const QString & exchangeName, const QString & key )
void QueuePrivate::bind(const QString & exchangeName, const QString &key)
{
if(!opened)
{
if (!opened) {
delayedBindings.append(QPair<QString,QString>(exchangeName, key));
return;
}
@ -391,15 +370,12 @@ void QueuePrivate::bind( const QString & exchangeName, const QString & key )
frame.setArguments(arguments_);
sendFrame(frame);
}
void QueuePrivate::unbind( const QString & exchangeName, const QString & key )
void QueuePrivate::unbind(const QString &exchangeName, const QString &key)
{
if(!opened)
{
if (!opened)
return;
}
QAMQP::Frame::Method frame(QAMQP::Frame::fcQueue, miUnbind);
frame.setChannel(number);
@ -413,16 +389,12 @@ void QueuePrivate::unbind( const QString & exchangeName, const QString & key )
frame.setArguments(arguments_);
sendFrame(frame);
}
void QueuePrivate::get()
{
if(!opened)
{
if (!opened)
return;
}
QAMQP::Frame::Method frame(QAMQP::Frame::fcBasic, bmGet);
frame.setChannel(number);
@ -436,8 +408,7 @@ void QueuePrivate::get()
sendFrame(frame);
}
void QueuePrivate::getOk( const QAMQP::Frame::Method & frame )
void QueuePrivate::getOk(const QAMQP::Frame::Method &frame)
{
QByteArray data = frame.arguments();
QDataStream in(&data, QIODevice::ReadOnly);
@ -456,13 +427,10 @@ void QueuePrivate::getOk( const QAMQP::Frame::Method & frame )
messages_.enqueue(newMessage);
}
void QueuePrivate::ack( const MessagePtr & Message )
void QueuePrivate::ack(const MessagePtr &Message)
{
if(!opened)
{
if (!opened)
return;
}
QAMQP::Frame::Method frame(QAMQP::Frame::fcBasic, bmAck);
frame.setChannel(number);
@ -475,12 +443,10 @@ void QueuePrivate::ack( const MessagePtr & Message )
sendFrame(frame);
}
void QueuePrivate::consume( Queue::ConsumeOptions options )
void QueuePrivate::consume(Queue::ConsumeOptions options)
{
if(!opened)
{
if (!opened)
return;
}
QAMQP::Frame::Method frame(QAMQP::Frame::fcBasic, bmConsume);
frame.setChannel(number);
@ -494,13 +460,10 @@ void QueuePrivate::consume( Queue::ConsumeOptions options )
frame.setArguments(arguments_);
sendFrame(frame);
}
void QueuePrivate::consumeOk( const QAMQP::Frame::Method & frame )
void QueuePrivate::consumeOk(const QAMQP::Frame::Method &frame)
{
qDebug() << "Consume ok: " << name;
declared = false;
@ -510,17 +473,13 @@ void QueuePrivate::consumeOk( const QAMQP::Frame::Method & frame )
qDebug("Consumer tag = %s", qPrintable(consumerTag));
}
void QueuePrivate::deliver( const QAMQP::Frame::Method & frame )
void QueuePrivate::deliver(const QAMQP::Frame::Method &frame)
{
QByteArray data = frame.arguments();
QDataStream in(&data, QIODevice::ReadOnly);
QString consumer_ = readField('s',in).toString();
if(consumer_ != consumerTag)
{
if (consumer_ != consumerTag)
return;
}
qlonglong deliveryTag = readField('L',in).toLongLong();
bool redelivered = readField('t',in).toBool();
@ -534,45 +493,42 @@ void QueuePrivate::deliver( const QAMQP::Frame::Method & frame )
newMessage->exchangeName = exchangeName;
newMessage->deliveryTag = deliveryTag;
messages_.enqueue(newMessage);
}
void QueuePrivate::_q_content( const QAMQP::Frame::Content & frame )
void QueuePrivate::_q_content(const QAMQP::Frame::Content &frame)
{
Q_ASSERT(frame.channel() == number);
if(frame.channel() != number)
if (frame.channel() != number)
return;
if(messages_.isEmpty())
{
if (messages_.isEmpty()) {
qErrnoWarning("Received content-header without method frame before");
return;
}
MessagePtr &message = messages_.last();
message->leftSize = frame.bodySize();
QHash<int, QVariant>::ConstIterator i;
for (i = frame.properties_.begin(); i != frame.properties_.end(); ++i)
{
message->property[Message::MessageProperty(i.key())]= i.value();
}
}
void QueuePrivate::_q_body(const QAMQP::Frame::ContentBody & frame)
void QueuePrivate::_q_body(const QAMQP::Frame::ContentBody &frame)
{
Q_Q(QAMQP::Queue);
Q_ASSERT(frame.channel() == number);
if(frame.channel() != number)
if (frame.channel() != number)
return;
if(messages_.isEmpty())
{
if (messages_.isEmpty()) {
qErrnoWarning("Received content-body without method frame before");
return;
}
MessagePtr &message = messages_.last();
message->payload.append(frame.body());
message->leftSize -= frame.body().size();
if(message->leftSize == 0 && messages_.size() == 1)
{
emit pq_func()->messageReceived(pq_func());
}
if (message->leftSize == 0 && messages_.size() == 1)
Q_EMIT q->messageReceived(q);
}

50
src/qamqp/amqp_queue.h
View File

@ -6,28 +6,20 @@
namespace QAMQP
{
class Client;
class ClientPrivate;
class Exchange;
class QueuePrivate;
class Queue : public Channel, public Frame::ContentHandler, public Frame::ContentBodyHandler
{
Q_OBJECT
Queue(int channelNumber = -1, Client * parent = 0);
Q_PROPERTY(QueueOptions option READ option );
class Client;
class ClientPrivate;
class Exchange;
class QueuePrivate;
class Queue : public Channel, public Frame::ContentHandler, public Frame::ContentBodyHandler
{
Q_OBJECT
Q_ENUMS(QueueOptions)
Q_PROPERTY(QueueOptions option READ option)
Q_PROPERTY(QString consumerTag READ consumerTag WRITE setConsumerTag)
Q_PROPERTY(bool noAck READ noAck WRITE setNoAck)
P_DECLARE_PRIVATE(QAMQP::Queue)
Q_DISABLE_COPY(Queue);
friend class ClientPrivate;
protected:
void onOpen();
void onClose();
public:
public:
enum QueueOption {
NoOptions = 0x0,
Passive = 0x01,
@ -47,7 +39,6 @@ namespace QAMQP
Q_DECLARE_FLAGS(ConsumeOptions, ConsumeOption)
~Queue();
QueueOptions option() const;
void declare();
@ -73,17 +64,30 @@ namespace QAMQP
void setNoAck(bool noAck);
bool noAck() const;
Q_SIGNALS:
Q_SIGNALS:
void declared();
void binded(bool);
void removed();
void messageReceived(QAMQP::Queue* pQueue);
void messageReceived(QAMQP::Queue *pQueue);
void empty();
private:
protected:
void onOpen();
void onClose();
private:
Queue(int channelNumber = -1, Client * parent = 0);
void _q_content(const QAMQP::Frame::Content & frame);
void _q_body(const QAMQP::Frame::ContentBody & frame);
};
Q_DISABLE_COPY(Queue)
Q_DECLARE_PRIVATE(QAMQP::Queue)
friend class ClientPrivate;
};
}
#ifdef QAMQP_P_INCLUDE
# include "amqp_queue_p.h"

47
src/qamqp/amqp_queue_p.h
View File

@ -7,14 +7,13 @@
namespace QAMQP
{
using namespace QAMQP::Frame;
class QueuePrivate: public ChannelPrivate
{
P_DECLARE_PUBLIC(QAMQP::Queue)
public:
enum MethodId
{
using namespace QAMQP::Frame;
class QueuePrivate: public ChannelPrivate
{
public:
enum MethodId {
METHOD_ID_ENUM(miDeclare, 10),
METHOD_ID_ENUM(miBind, 20),
METHOD_ID_ENUM(miUnbind, 50),
@ -22,36 +21,36 @@ namespace QAMQP
METHOD_ID_ENUM(miDelete, 40)
};
QueuePrivate(Queue * q);
QueuePrivate(Queue *q);
~QueuePrivate();
void declare();
void remove(bool ifUnused = true, bool ifEmpty = true, bool noWait = true);
void purge();
void bind(const QString & exchangeName, const QString & key);
void unbind(const QString & exchangeName, const QString & key);
void bind(const QString &exchangeName, const QString &key);
void unbind(const QString &exchangeName, const QString &key);
void declareOk(const QAMQP::Frame::Method & frame);
void deleteOk(const QAMQP::Frame::Method & frame);
void bindOk(const QAMQP::Frame::Method & frame);
void unbindOk(const QAMQP::Frame::Method & frame);
void declareOk(const QAMQP::Frame::Method &frame);
void deleteOk(const QAMQP::Frame::Method &frame);
void bindOk(const QAMQP::Frame::Method &frame);
void unbindOk(const QAMQP::Frame::Method &frame);
/************************************************************************/
/* CLASS BASIC METHODS */
/************************************************************************/
void consume(Queue::ConsumeOptions options);
void consumeOk(const QAMQP::Frame::Method & frame);
void deliver(const QAMQP::Frame::Method & frame);
void consumeOk(const QAMQP::Frame::Method &frame);
void deliver(const QAMQP::Frame::Method &frame);
void get();
void getOk(const QAMQP::Frame::Method & frame);
void ack(const MessagePtr & Message);
void getOk(const QAMQP::Frame::Method &frame);
void ack(const MessagePtr &Message);
QString type;
Queue::QueueOptions options;
bool _q_method(const QAMQP::Frame::Method & frame);
bool _q_method(const QAMQP::Frame::Method &frame);
bool delayedDeclare;
bool declared;
@ -63,8 +62,12 @@ namespace QAMQP
bool recievingMessage;
void _q_content(const QAMQP::Frame::Content & frame);
void _q_body(const QAMQP::Frame::ContentBody & frame);
};
void _q_content(const QAMQP::Frame::Content &frame);
void _q_body(const QAMQP::Frame::ContentBody &frame);
Q_DECLARE_PUBLIC(QAMQP::Queue)
};
}
#endif // amqp_queue_p_h__

1
src/qamqp/qamqp.pri
View File

@ -24,5 +24,6 @@ SOURCES += $$PWD/amqp.cpp \
$$PWD/amqp_connection.cpp \
$$PWD/amqp_exchange.cpp \
$$PWD/amqp_frame.cpp \
$$PWD/amqp_message.cpp \
$$PWD/amqp_network.cpp \
$$PWD/amqp_queue.cpp \