← Back to branch summary

~ubuntu-branches/ubuntu/precise/crtmpserver/precise-backports

« back to all changes in this revision

Viewing changes to applications/proxypublish/src/proxypublishapplication.cpp

  • Committer: Package Import Robot
  • Author(s): Micah Gersten
  • Date: 2012-07-04 00:04:40 UTC
  • mfrom: (3.1.7 sid)
  • Revision ID: package-import@ubuntu.com-20120704000440-u9x7yhyglqjvspk8
Tags: 1.0~dfsg-3~ubuntu12.04.1
https://launchpad.net/bugs/964153
No-change backport to precise (LP: #964153)

Show diffs side-by-side

added added

removed removed

Lines of Context:
applications/proxypublish/src/proxypublishapplication.cpp
30
30
#include "protocols/protocolfactorymanager.h"
31
31
#include "application/clientapplicationmanager.h"
32
32
#include "netio/netio.h"
 
33
#include "jobstimerappprotocolhandler.h"
 
34
#include "jobstimerprotocol.h"
 
35
#include "protocols/protocolmanager.h"
33
36
using namespace app_proxypublish;
34
37
 
35
38
ProxyPublishApplication::ProxyPublishApplication(Variant &configuration)
44
47
        _pRTPHandler = NULL;
45
48
        _pRTSPHandler = NULL;
46
49
#endif /* HAS_PROTOCOL_RTP */
 
50
        _pJobsHandler = NULL;
 
51
        _jobsTimerProtocolId = 0;
47
52
}
48
53
 
49
54
ProxyPublishApplication::~ProxyPublishApplication() {
75
80
                _pRTSPHandler = NULL;
76
81
        }
77
82
#endif /* HAS_PROTOCOL_RTP */
 
83
 
 
84
        BaseProtocol *pProtocol = ProtocolManager::GetProtocol(_jobsTimerProtocolId);
 
85
        if (pProtocol != NULL) {
 
86
                pProtocol->EnqueueForDelete();
 
87
        }
 
88
 
 
89
        UnRegisterAppProtocolHandler(PT_TIMER);
 
90
        if (_pJobsHandler != NULL) {
 
91
                delete _pJobsHandler;
 
92
                _pJobsHandler = NULL;
 
93
        }
78
94
}
79
95
 
80
96
bool ProxyPublishApplication::Initialize() {
128
144
                        FATAL("Invalid uri: %s", STR(target["targetUri"]));
129
145
                        return false;
130
146
                }
131
 
                if (uri.scheme.find("rtmp") != 0) {
 
147
                if (uri.scheme().find("rtmp") != 0) {
132
148
                        FATAL("Supported target scheme is rtmp for now....");
133
149
                        return false;
134
150
                }
135
 
 
136
 
 
137
 
                target["targetUri"] = uri.ToVariant();
138
151
        }
139
152
        _targetServers = _configuration["targetServers"];
140
153
        _abortOnConnectError = (bool)_configuration["abortOnConnectError"];
160
173
        RegisterAppProtocolHandler(PT_RTSP, _pRTSPHandler);
161
174
#endif /* HAS_PROTOCOL_RTP */
162
175
 
 
176
        _pJobsHandler = new JobsTimerAppProtocolHandler(_configuration);
 
177
        RegisterAppProtocolHandler(PT_TIMER, _pJobsHandler);
 
178
 
 
179
        //2. Initialize the jobs timer
 
180
        BaseTimerProtocol *pProtocol = new JobsTimerProtocol();
 
181
        _jobsTimerProtocolId = pProtocol->GetId();
 
182
        pProtocol->SetApplication(this);
 
183
        pProtocol->EnqueueForTimeEvent(1);
 
184
 
163
185
        return PullExternalStreams();
164
186
}
165
187
 
 
188
void ProxyPublishApplication::UnRegisterProtocol(BaseProtocol *pProtocol) {
 
189
        //1. Get the parameters assigned to this connection
 
190
        Variant &parameters = pProtocol->GetCustomParameters();
 
191
 
 
192
        //FINEST("parameters:\n%s", STR(parameters.ToString()));
 
193
        //2. depending on the pull/push config, we retry only if keepAlive is true and the
 
194
        //source stream is still there
 
195
        if ((parameters.HasKeyChain(V_BOOL, true, 3, "customParameters", "localStreamConfig", "keepAlive"))
 
196
                        && ((bool)parameters["customParameters"]["localStreamConfig"]["keepAlive"])
 
197
                        && (parameters.HasKeyChain(_V_NUMERIC, true, 3, "customParameters", "localStreamConfig", "localUniqueStreamId"))) {
 
198
                //3. This is a push.  First, fix the uri
 
199
                string uri = parameters["customParameters"]["localStreamConfig"]["targetUri"]["fullUriWithAuth"];
 
200
                parameters["customParameters"]["localStreamConfig"]["targetUri"] = uri;
 
201
                EnqueuePush(parameters["customParameters"]["localStreamConfig"]);
 
202
        } else if ((parameters.HasKeyChain(V_BOOL, true, 3, "customParameters", "externalStreamConfig", "keepAlive"))
 
203
                        && ((bool)parameters["customParameters"]["externalStreamConfig"]["keepAlive"])) {
 
204
                //4. This is a pull with keep alive. Just o it again. First, fix the uri
 
205
                //which is currently "resolved"
 
206
                string uri = parameters["customParameters"]["externalStreamConfig"]["uri"]["fullUriWithAuth"];
 
207
                parameters["customParameters"]["externalStreamConfig"]["uri"] = uri;
 
208
                EnqueuePull(parameters["customParameters"]["externalStreamConfig"]);
 
209
        }
 
210
 
 
211
        //5. Finally, call the base class
 
212
        BaseClientApplication::UnRegisterProtocol(pProtocol);
 
213
}
 
214
 
166
215
void ProxyPublishApplication::SignalStreamRegistered(BaseStream *pStream) {
167
216
        //1. Call the base class
168
217
        BaseClientApplication::SignalStreamRegistered(pStream);
181
230
        }
182
231
}
183
232
 
 
233
void ProxyPublishApplication::EnqueuePush(Variant &parameters) {
 
234
        //1. get the timer protocol
 
235
        JobsTimerProtocol *pProtocol = (JobsTimerProtocol *) ProtocolManager::GetProtocol(
 
236
                        _jobsTimerProtocolId);
 
237
        if (pProtocol == NULL) {
 
238
                FATAL("Jobs protocol died. Aborting ...");
 
239
                return;
 
240
        }
 
241
 
 
242
        //2. Enqueue the operation
 
243
        pProtocol->EnqueuePush(parameters);
 
244
}
 
245
 
 
246
void ProxyPublishApplication::EnqueuePull(Variant &parameters) {
 
247
        //1. get the timer protocol
 
248
        JobsTimerProtocol *pProtocol = (JobsTimerProtocol *) ProtocolManager::GetProtocol(
 
249
                        _jobsTimerProtocolId);
 
250
        if (pProtocol == NULL) {
 
251
                FATAL("Jobs protocol died. Aborting ...");
 
252
                return;
 
253
        }
 
254
 
 
255
        //2. Enqueue the operation
 
256
        pProtocol->EnqueuePull(parameters);
 
257
}
 
258
 
184
259
bool ProxyPublishApplication::InitiateForwardingStream(BaseInStream *pStream) {
185
260
 
186
261
        FOR_MAP(_targetServers, string, Variant, i) {
229
304
                        STR(tagToString(pStream->GetType())),
230
305
                        STR(pStream->GetName()),
231
306
                        STR(GetName()),
232
 
                        STR((string) target["targetUri"]["fullUri"]),
 
307
                        STR((string) target["targetUri"]),
233
308
                        STR(parameters["targetStreamName"]));
234
309
 
235
 
        //3. Since we only accept RTMP targets, we will just fetch the RTMP handler
236
 
        //and push the stream
237
 
        return _pRTMPHandler->PushLocalStream(parameters);
 
310
        //4. Enqueue the push
 
311
        EnqueuePush(parameters);
 
312
        return true;
238
313
#endif /* HAS_PROTOCOL_RTMP */
239
314
}