Blinker

1) /* Blinker
2)    Copyright 2011 Stefan Schuermans <stefan@blinkenarea.org>
3)    Copyleft GNU public license - http://www.gnu.org/copyleft/gpl.html
4)    a blinkenarea.org project */
5) 
6) #ifndef SENDER_H
7) #define SENDER_H
8) 
9) #include <list>
10) #include <string>
11) 
12) #include <BlinkenLib/BlinkenFrame.h>
13) 
14) #include "CallMgr.h"
15) #include "Directory.h"
16) #include "File.h"
17) #include "Module.h"
18) #include "SettingFile.h"
19) #include "StreamMgr.h"
20) #include "StreamRecv.h"

21) #include "TimeCallee.h"

22) 
23) namespace Blinker {
24) 
25) /// stream sender
26) template<typename ADDR, typename SOCK>

27) class Sender: public Module, public StreamRecv, public TimeCallee

28) {
29) protected:
30)   /// static destination
31)   struct Dest {
32)     std::string m_name; ///< name of static destination
33)     SettingFile m_file; ///< setting file object
34)     ADDR        m_addr; ///< parsed address
35)     Dest(const std::string &name, const File &file); ///< constructor
36)     bool parse();       ///< parse address from current file
37)   };
38) 
39)   /// static destinations
40)   typedef std::list<Dest> Dests;
41) 
42) public:
43)   /**
44)    * @brief constructor
45)    * @param[in] callMgr callback manager
46)    * @param[in] streamMgr stream manager
47)    * @param[in] dirBase base directory
48)    */
49)   Sender(CallMgr &callMgr, StreamMgr &streamMgr, const Directory &dirBase);
50) 
51)   /// virtual destructor
52)   virtual ~Sender();
53) 
54) private:
55)   /// copy constructor disabled
56)   Sender(const Sender &that);
57) 
58)   /// assignment operator disabled
59)   const Sender & operator=(const Sender &that);
60) 
61) public:
62)   /// check for update of configuration
63)   virtual void updateConfig();
64) 
65)   /**
66)    * @brief set current frame
67)    * @param[in] pFrame current frame
68)    */
69)   virtual void setFrame(stBlinkenFrame *pFrame);
70) 
71)   /// set current frame to none
72)   virtual void setNoFrame();
73) 

74)   /// callback when requsted time reached
75)   virtual void timeCall();
76) 

77) protected:
78)   /// get input stream and attach to it
79)   void getInStream();
80) 
81)   /// detach from input stream and release it
82)   void releaseInStream();
83) 
84)   /// create socket and bind it
85)   void createSock();
86) 
87)   /// destroy socket
88)   void destroySock();
89) 
90)   /**
91)    * @brief light update of static destinations,
92)    *        i.e. stat all files in current static destination directory

93)    * @param[in] dests static destinations for protocol
94)    * @param[in] proto Blinken protocol identifier

95)    */

96)   void updateDestsLight(Dests &dests, etBlinkenProto proto);

97) 
98)   /**
99)    * @brief full update of static destinations,
100)    *        i.e. scan files in playlist directory

101)    * @param[in] dirDests static destinations directory for protocol
102)    * @param[in] dests static destinations for protocol
103)    * @param[in] proto Blinken protocol identifier

104)    */

105)   void updateDestsFull(Directory &dirDests, Dests &dests,
106)                        etBlinkenProto proto);

107) 
108)   /**
109)    * @brief send current frame to address
110)    * @param[in] addr address to send to

111)    * @param[in] proto Blinken protocol identifier

112)    */

113)   void sendCurFrame(const ADDR &addr, etBlinkenProto proto);

114) 
115)   /**

116)    * @brief send "no frame" to address

117)    * @param[in] addr address to send to

118)    * @param[in] proto Blinken protocol identifier

119)    */

120)   void sendNoFrame(const ADDR &addr, etBlinkenProto proto);

121) 
122)   /**

123)    * @brief send frame to address
124)    * @param[in] data protcol data of frame

125)    * @param[in] addr address to send to
126)    */

127)   void sendFrame(const std::string &data, const ADDR &addr);

128) 
129)   /**

130)    * @brief convert frame to protocol data

131)    * @param[in] pFrame frame

132)    * @param[in] proto Blinken protocol identifier
133)    * @param[out] data protcol data

134)    */

135)   void frame2data(stBlinkenFrame *pFrame, etBlinkenProto proto,
136)                   std::string &data);
137) 
138)   /**
139)    * @brief get "no frame" protocol data
140)    * @param[in] proto Blinken protocol identifier
141)    * @param[out] data protcol data
142)    */
143)   void noFrame2data(etBlinkenProto proto, std::string &data);

144) 
145) protected:
146)   SettingFile m_fileInStream; ///< input stream name file
147)   SettingFile m_fileBind;     ///< bind address file

148)   Directory   m_dirDestsBlp;  ///< static BLP destinations directory
149)   Directory   m_dirDestsEblp; ///< static EBLP destinations directory

150)   Directory   m_dirDestsMcuf; ///< static MCUF destinations directory

151)   std::string m_nameInStream; ///< name of input stream
152)   Stream      *m_pInStream;   ///< input stream
153)   SOCK        *m_pSock;       ///< socket to use for sending streams

154)   Dests        m_destsBlp;    ///< current static BLP destinations
155)   Dests        m_destsEblp;   ///< current static EBLP destinations

156)   Dests        m_destsMcuf;   ///< current static MCUF destinations

157) }; // class Sender
158) 
159) /* ##########
160)    # Sender #
161)    ########## */
162) 
163) /**
164)  * @brief constructor
165)  * @param[in] callMgr callback manager
166)  * @param[in] streamMgr stream manager
167)  * @param[in] dirBase base directory
168)  */
169) template<typename ADDR, typename SOCK>
170) Sender<ADDR, SOCK>::Sender(CallMgr &callMgr, StreamMgr &streamMgr,
171)                            const Directory &dirBase):
172)   Module(callMgr, streamMgr, dirBase),
173)   m_fileInStream(dirBase.getFile("instream")),
174)   m_fileBind(dirBase.getFile("bind")),

175)   m_dirDestsBlp(dirBase.getSubdir("blp")),
176)   m_dirDestsEblp(dirBase.getSubdir("eblp")),

177)   m_dirDestsMcuf(dirBase.getSubdir("mcuf")),

178)   m_pInStream(NULL),
179)   m_pSock(NULL)
180) {
181)   // get input stream and attach to it
182)   getInStream();
183)   // create and bind socket
184)   createSock();
185) 
186)   // load static destinations

187)   updateDestsFull(m_dirDestsBlp, m_destsBlp, BlinkenProtoBlp);
188)   updateDestsFull(m_dirDestsEblp, m_destsEblp, BlinkenProtoEblp);

189)   updateDestsFull(m_dirDestsMcuf, m_destsMcuf, BlinkenProtoMcuf);

190) }
191) 
192) /// virtual destructor
193) template<typename ADDR, typename SOCK>
194) Sender<ADDR, SOCK>::~Sender()
195) {

196)   // send no frame to all destinations
197)   setNoFrame();

198) 
199)   // destroy socket
200)   destroySock();
201)   // detach from input stream and release it
202)   releaseInStream();

203)   // cancel time callback
204)   m_callMgr.cancelTimeCall(this);

205) }
206) 
207) /// check for update of configuration
208) template<typename ADDR, typename SOCK>
209) void Sender<ADDR, SOCK>::updateConfig()
210) {
211)   // input stream name file was modified -> re-get input stream
212)   if (m_fileInStream.checkModified()) {
213)     releaseInStream();
214)     getInStream();
215)   }
216) 
217)   // bind address file was modified -> re-create socket
218)   if (m_fileBind.checkModified()) {
219)     destroySock();
220)     createSock();
221)   }
222) 
223)   // static destinations update
224)   // (directory modified -> full, otherwise -> light)

225)   if (m_dirDestsBlp.checkModified())
226)     updateDestsFull(m_dirDestsBlp, m_destsBlp, BlinkenProtoBlp);
227)   else
228)     updateDestsLight(m_destsBlp, BlinkenProtoBlp);
229)   if (m_dirDestsEblp.checkModified())
230)     updateDestsFull(m_dirDestsEblp, m_destsEblp, BlinkenProtoEblp);
231)   else
232)     updateDestsLight(m_destsEblp, BlinkenProtoEblp);

233)   if (m_dirDestsMcuf.checkModified())
234)     updateDestsFull(m_dirDestsMcuf, m_destsMcuf, BlinkenProtoMcuf);

235)   else

236)     updateDestsLight(m_destsMcuf, BlinkenProtoMcuf);

237) }
238) 
239) /**
240)  * @brief set current frame
241)  * @param[in] pFrame current frame
242)  */
243) template<typename ADDR, typename SOCK>
244) void Sender<ADDR, SOCK>::setFrame(stBlinkenFrame *pFrame)
245) {

246)   std::string blp, eblp, mcuf;

247) 

248)   // convert frame to protocol data

249)   if (!m_destsBlp.empty())
250)     frame2data(pFrame, BlinkenProtoBlp, blp);
251)   if (!m_destsEblp.empty())
252)     frame2data(pFrame, BlinkenProtoEblp, eblp);

253)   if (!m_destsMcuf.empty())
254)     frame2data(pFrame, BlinkenProtoMcuf, mcuf);

255) 

256)   // send frame to all static destinations

257)   typename Dests::const_iterator itDest;

258)   for (itDest = m_destsBlp.begin(); itDest != m_destsBlp.end(); ++itDest)
259)     sendFrame(blp, itDest->m_addr);
260)   for (itDest = m_destsEblp.begin(); itDest != m_destsEblp.end(); ++itDest)
261)     sendFrame(eblp, itDest->m_addr);

262)   for (itDest = m_destsMcuf.begin(); itDest != m_destsMcuf.end(); ++itDest)

263)     sendFrame(mcuf, itDest->m_addr);

264) 
265)   // request time callback in one second
266)   m_callMgr.requestTimeCall(this, Time::now() + Time(1));

267) }
268) 
269) /// set current frame to none
270) template<typename ADDR, typename SOCK>
271) void Sender<ADDR, SOCK>::setNoFrame()
272) {

273)   std::string blp, eblp, mcuf;

274) 
275)   // get "no frame" protocol data

276)   if (!m_destsBlp.empty())
277)     noFrame2data(BlinkenProtoBlp, blp);
278)   if (!m_destsEblp.empty())
279)     noFrame2data(BlinkenProtoEblp, eblp);

280)   if (!m_destsMcuf.empty())
281)     noFrame2data(BlinkenProtoMcuf, mcuf);
282) 

283)   // send "no frame" to all staticdestinations

284)   typename Dests::const_iterator itDest;

285)   for (itDest = m_destsBlp.begin(); itDest != m_destsBlp.end(); ++itDest)
286)     sendFrame(blp, itDest->m_addr);
287)   for (itDest = m_destsEblp.begin(); itDest != m_destsEblp.end(); ++itDest)
288)     sendFrame(eblp, itDest->m_addr);

289)   for (itDest = m_destsMcuf.begin(); itDest != m_destsMcuf.end(); ++itDest)
290)     sendFrame(mcuf, itDest->m_addr);
291) 
292)   // request time callback in one second
293)   m_callMgr.requestTimeCall(this, Time::now() + Time(1));
294) }
295) 
296) /// callback when requsted time reached
297) template<typename ADDR, typename SOCK>
298) void Sender<ADDR, SOCK>::timeCall()
299) {
300)   stBlinkenFrame *pFrame;
301)   std::string data;
302) 
303)   // get current frame from stream
304)   if (m_pInStream && m_pInStream->getCurFrame(pFrame))
305)     // repeat frame - behave exactly like this frame had been set
306)     setFrame(pFrame);
307) 
308)   // no stream of no current frame
309)   else
310)     // repeat "no frame" - behave exactly like "no frame" had been set
311)     setNoFrame();

312) }
313) 
314) /// get input stream and attach to it
315) template<typename ADDR, typename SOCK>
316) void Sender<ADDR, SOCK>::getInStream()
317) {
318)   // get input stream
319)   m_fileInStream.getStr(m_nameInStream);
320)   m_pInStream = &m_streamMgr.refStream(m_nameInStream);
321) 
322)   // attach to input stream
323)   if (m_pInStream)
324)     m_pInStream->attach(this);
325) }
326) 
327) /// detach from input stream and release it
328) template<typename ADDR, typename SOCK>
329) void Sender<ADDR, SOCK>::releaseInStream()
330) {
331)   // detach from input stream
332)   if (m_pInStream)
333)     m_pInStream->detach(this);
334) 
335)   // unreference stream
336)   m_pInStream = NULL;
337)   m_streamMgr.unrefStream(m_nameInStream);
338) }
339) 
340) /// create socket and bind it
341) template<typename ADDR, typename SOCK>
342) void Sender<ADDR, SOCK>::createSock()
343) {
344)   std::string strAddr;
345)   ADDR addr;
346) 
347)   // create socket
348)   if (!m_pSock) {
349)     m_pSock = new SOCK();
350)     if (!m_pSock)
351)       return;
352)   }
353) 
354)   // get bind address from bind address setting file
355)   if (!m_fileBind.getStr(strAddr) || !addr.fromStr(strAddr)) {
356)     delete m_pSock;
357)     m_pSock = NULL;
358)     return;
359)   }
360) 
361)   // bind socket
362)   if (!m_pSock->bind(addr)) {
363)     delete m_pSock;
364)     m_pSock = NULL;
365)     return;
366)   }
367) }
368) 
369) /// destroy socket
370) template<typename ADDR, typename SOCK>
371) void Sender<ADDR, SOCK>::destroySock()
372) {
373)   // destroy socket
374)   if (m_pSock) {
375)     delete m_pSock;
376)     m_pSock = NULL;
377)   }
378) }
379) 
380) /**
381)  * @brief light update of static destinations,
382)  *        i.e. stat all files in current static destination directory

383)  * @param[in] dests static destinations for one protocol
384)  * @param[in] proto Blinken protocol identifier

385)  */
386) template<typename ADDR, typename SOCK>

387) void Sender<ADDR, SOCK>::updateDestsLight(Dests &dests, etBlinkenProto proto)

388) {
389)   // walk through all files in static dest dir and check for modification

390)   typename Dests::iterator itDest = dests.begin();
391)   while (itDest != dests.end()) {

392) 
393)     // address changed
394)     if (itDest->m_file.checkModified()) {
395)       // send "no frame" to old address

396)       sendNoFrame(itDest->m_addr, proto);

397)       // re-load address
398)       if (!itDest->parse()) {
399)         // parsing address failed -> remove destination

400)         itDest = dests.erase(itDest);

401)         // do not advance to next destination
402)         continue;
403)       }
404)       // send current frame to new address

405)       sendCurFrame(itDest->m_addr, proto);

406)     }
407) 
408)     // advance to next destination
409)     ++itDest;
410) 
411)   } // while itDest
412) }
413) 
414) /**
415)  * @brief full update of static destinations,
416)  *        i.e. scan files in playlist directory

417)  * @param[in] dirDests static destinations directory for protocol
418)  * @param[in] dests static destinations for protocol
419)  * @param[in] proto Blinken protocol identifier

420)  */
421) template<typename ADDR, typename SOCK>

422) void Sender<ADDR, SOCK>::updateDestsFull(Directory &dirDests, Dests &dests,
423)                                          etBlinkenProto proto)

424) {
425)   // get list of files in static destinations directory
426)   typedef std::list<std::string> Filelist;
427)   Filelist curFiles;

428)   dirDests.getEntries(Directory::TypeFile, curFiles);

429) 
430)   // walk through current static destinations and file list simultaneously
431)   Filelist::const_iterator itFile = curFiles.begin();

432)   typename Dests::iterator itDest = dests.begin();
433)   while (itFile != curFiles.end() || itDest != dests.end()) {

434) 
435)     // new static destination inserted

436)     if (itDest == dests.end() ||

437)         (itFile != curFiles.end() && *itFile < itDest->m_name)) {
438)       // parse new address

439)       Dest dest(*itFile, dirDests.getFile(*itFile));

440)       if (dest.parse()) {
441)         // insert new static destination

442)         dests.insert(itDest, dest);

443)         // send current frame to new static destination

444)         sendCurFrame(itDest->m_addr, proto);

445)       }
446)       // advance to next file
447)       ++itFile;
448)     }
449) 
450)     // static destination removed
451)     // static destination changed (=> remove and re-insert in next iteration)
452)     else if (itFile == curFiles.end() || *itFile > itDest->m_name ||
453)              itDest->m_file.checkModified()) {
454)       // send "no frame" to old static destination

455)       sendNoFrame(itDest->m_addr, proto);

456)       // remove static destination

457)       itDest = dests.erase(itDest);

458)       // do not advance to next file
459)     }
460) 
461)     // static destination stayed in playlist and did not change
462)     else {
463)       // advance to next file and next static destination
464)       ++itFile;
465)       ++itDest;
466)     }
467) 
468)   } // while itFile itDest
469) }
470) 
471) /**
472)  * @brief send current frame to address
473)  * @param[in] addr address to send to

474)  * @param[in] proto Blinken protocol identifier

475)  */
476) template<typename ADDR, typename SOCK>

477) void Sender<ADDR, SOCK>::sendCurFrame(const ADDR &addr, etBlinkenProto proto)

478) {
479)   stBlinkenFrame *pFrame;

480)   std::string data;

481) 
482)   // get current frame from stream
483)   if (m_pInStream && m_pInStream->getCurFrame(pFrame)) {

484)     // convert frame to protocal data
485)     frame2data(pFrame, proto, data);

486)     // send frame to address

487)     sendFrame(data, addr);

488)   }
489) 
490)   // no stream of no current frame
491)   else {

492)     // get "no frame" ad protocal data
493)     noFrame2data(proto, data);

494)     // send "no frame" to address

495)     sendFrame(data, addr);

496)   }
497) }
498) 
499) /**

500)  * @brief send "no frame" to address

501)  * @param[in] addr address to send to

502)  * @param[in] proto Blinken protocol identifier

503)  */
504) template<typename ADDR, typename SOCK>

505) void Sender<ADDR, SOCK>::sendNoFrame(const ADDR &addr, etBlinkenProto proto)

506) {

507)   std::string data;
508) 
509)   // get "no frame" ad protocal data
510)   noFrame2data(proto, data);
511) 
512)   // send "no frame" to address
513)   sendFrame(data, addr);

514) }
515) 
516) /**

517)  * @brief send frame to address
518)  * @param[in] data protocol data of frame

519)  * @param[in] addr address to send to
520)  */
521) template<typename ADDR, typename SOCK>

522) void Sender<ADDR, SOCK>::sendFrame(const std::string &data, const ADDR &addr)

523) {
524)   if (m_pSock) {

525)     m_pSock->send(data, addr);

526)   }
527) }
528) 
529) /**

530)  * @brief convert frame to protocol data

531)  * @param[in] pFrame frame

532)  * @param[in] proto Blinken protocol identifier
533)  * @param[out] data protocol data

534)  */
535) template<typename ADDR, typename SOCK>

536) void Sender<ADDR, SOCK>::frame2data(stBlinkenFrame *pFrame,
537)                                     etBlinkenProto proto, std::string &data)

538) {
539)   char buf[65536];
540)   int len;
541) 

542)   // convert frame to protcol data
543)   len = BlinkenFrameToNetwork(pFrame, proto, buf, sizeof(buf));
544)   data.assign(buf, len);
545) }
546) 
547) /**
548)  * @brief get "no frame" protocol data
549)  * @param[in] proto Blinken protocol identifier
550)  * @param[out] data protcol data
551)  */
552) template<typename ADDR, typename SOCK>
553) void Sender<ADDR, SOCK>::noFrame2data(etBlinkenProto proto, std::string &data)
554) {
555)   // obtain "no frame" protcol data
556)   (void)proto; // FIXME

557)   data.assign("", 1); // FIXME