1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
|
#ifndef _QmfEngineAgent_
#define _QmfEngineAgent_
/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
#include <qmf/engine/Schema.h>
#include <qmf/engine/ObjectId.h>
#include <qmf/engine/Object.h>
#include <qmf/engine/Event.h>
#include <qmf/engine/Query.h>
#include <qmf/engine/Value.h>
#include <qmf/engine/Message.h>
namespace qmf {
namespace engine {
/**
* AgentEvent
*
* This structure represents a QMF event coming from the agent to
* the application.
*/
struct AgentEvent {
enum EventKind {
GET_QUERY = 1,
START_SYNC = 2,
END_SYNC = 3,
METHOD_CALL = 4,
DECLARE_QUEUE = 5,
DELETE_QUEUE = 6,
BIND = 7,
UNBIND = 8,
SETUP_COMPLETE = 9
};
EventKind kind;
uint32_t sequence; // Protocol sequence (for all kinds)
char* authUserId; // Authenticated user ID (for all kinds)
char* authToken; // Authentication token if issued (for all kinds)
char* name; // Name of the method/sync query
// (METHOD_CALL, START_SYNC, END_SYNC, DECLARE_QUEUE, BIND, UNBIND)
Object* object; // Object involved in method call (METHOD_CALL)
ObjectId* objectId; // ObjectId for method call (METHOD_CALL)
Query* query; // Query parameters (GET_QUERY, START_SYNC)
Value* arguments; // Method parameters (METHOD_CALL)
char* exchange; // Exchange for bind (BIND, UNBIND)
char* bindingKey; // Key for bind (BIND, UNBIND)
const SchemaObjectClass* objectClass; // (METHOD_CALL)
};
class AgentImpl;
/**
* Agent - Protocol engine for the QMF agent
*/
class Agent {
public:
Agent(char* label, bool internalStore=true);
~Agent();
/**
* Configure the directory path for storing persistent data.
*@param path Null-terminated string containing a directory path where files can be
* created, written, and read. If NULL, no persistent storage will be
* attempted.
*/
void setStoreDir(const char* path);
/**
* Configure the directory path for files transferred over QMF.
*@param path Null-terminated string containing a directory path where files can be
* created, deleted, written, and read. If NULL, file transfers shall not
* be permitted.
*/
void setTransferDir(const char* path);
/**
* Pass messages received from the AMQP session to the Agent engine.
*@param message AMQP messages received on the agent session.
*/
void handleRcvMessage(Message& message);
/**
* Get the next message to be sent to the AMQP network.
*@param item The Message structure describing the message to be produced.
*@return true if the Message is valid, false if there are no messages to send.
*/
bool getXmtMessage(Message& item) const;
/**
* Remove and discard one message from the head of the transmit queue.
*/
void popXmt();
/**
* Get the next application event from the agent engine.
*@param event The event iff the return value is true
*@return true if event is valid, false if there are no events to process
*/
bool getEvent(AgentEvent& event) const;
/**
* Remove and discard one event from the head of the event queue.
*/
void popEvent();
/**
* A new AMQP session has been established for Agent communication.
*/
void newSession();
/**
* Start the QMF Agent protocol. This should be invoked after a SETUP_COMPLETE event
* is received from the Agent engine.
*/
void startProtocol();
/**
* This method is called periodically so the agent can supply a heartbeat.
*/
void heartbeat();
/**
* Respond to a method request.
*@param sequence The sequence number from the method request event.
*@param status The method's completion status.
*@param text Status text ("OK" or an error message)
*@param arguments The list of output arguments from the method call.
*/
void methodResponse(uint32_t sequence, uint32_t status, char* text, const Value& arguments);
/**
* Send a content indication to the QMF bus. This is only needed for objects that are
* managed by the application. This is *NOT* needed for objects managed by the Agent
* (inserted using addObject).
*@param sequence The sequence number of the GET request or the SYNC_START request.
*@param object The object (annotated with "changed" flags) for publication.
*@param prop If true, changed object properties are transmitted.
*@param stat If true, changed object statistics are transmitted.
*/
void queryResponse(uint32_t sequence, Object& object, bool prop = true, bool stat = true);
/**
* Indicate the completion of a query. This is not used for SYNC_START requests.
*@param sequence The sequence number of the GET request.
*/
void queryComplete(uint32_t sequence);
/**
* Register a schema class with the Agent.
*@param cls A SchemaObejctClass object that defines data managed by the agent.
*/
void registerClass(SchemaObjectClass* cls);
/**
* Register a schema class with the Agent.
*@param cls A SchemaEventClass object that defines events sent by the agent.
*/
void registerClass(SchemaEventClass* cls);
/**
* Give an object to the Agent for storage and management. Once added, the agent takes
* responsibility for the life cycle of the object.
*@param obj The object to be managed by the Agent.
*@param persistId A unique non-zero value if the object-id is to be persistent.
*@return The objectId of the managed object.
*/
const ObjectId* addObject(Object& obj, uint64_t persistId);
// const ObjectId* addObject(Object& obj, uint32_t persistIdLo, uint32_t persistIdHi);
/**
* Allocate an object-id for an object that will be managed by the application.
*@param persistId A unique non-zero value if the object-id is to be persistent.
*@return The objectId structure for the allocated ID.
*/
const ObjectId* allocObjectId(uint64_t persistId);
const ObjectId* allocObjectId(uint32_t persistIdLo, uint32_t persistIdHi);
/**
* Raise an event into the QMF network..
*@param event The event object for the event to be raised.
*/
void raiseEvent(Event& event);
private:
AgentImpl* impl;
};
}
}
#endif
|
