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_dirDestsMcuf; ///< static MCUF destinations directory

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

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

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

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

172)   m_pInStream(NULL),
173)   m_pSock(NULL)
174) {
175)   // get input stream and attach to it
176)   getInStream();
177)   // create and bind socket
178)   createSock();
179) 
180)   // load static destinations

181)   updateDestsFull(m_dirDestsMcuf, m_destsMcuf, BlinkenProtoMcuf);

182) }
183) 
184) /// virtual destructor
185) template<typename ADDR, typename SOCK>
186) Sender<ADDR, SOCK>::~Sender()
187) {

188)   // send no frame to all destinations
189)   setNoFrame();

190) 
191)   // destroy socket
192)   destroySock();
193)   // detach from input stream and release it
194)   releaseInStream();

195)   // cancel time callback
196)   m_callMgr.cancelTimeCall(this);

197) }
198) 
199) /// check for update of configuration
200) template<typename ADDR, typename SOCK>
201) void Sender<ADDR, SOCK>::updateConfig()
202) {
203)   // input stream name file was modified -> re-get input stream
204)   if (m_fileInStream.checkModified()) {
205)     releaseInStream();
206)     getInStream();
207)   }
208) 
209)   // bind address file was modified -> re-create socket
210)   if (m_fileBind.checkModified()) {
211)     destroySock();
212)     createSock();
213)   }
214) 
215)   // static destinations update
216)   // (directory modified -> full, otherwise -> light)

217)   if (m_dirDestsMcuf.checkModified())
218)     updateDestsFull(m_dirDestsMcuf, m_destsMcuf, BlinkenProtoMcuf);

219)   else

220)     updateDestsLight(m_destsMcuf, BlinkenProtoMcuf);

221) }
222) 
223) /**
224)  * @brief set current frame
225)  * @param[in] pFrame current frame
226)  */
227) template<typename ADDR, typename SOCK>
228) void Sender<ADDR, SOCK>::setFrame(stBlinkenFrame *pFrame)
229) {
230)   std::string mcuf;
231) 

232)   // convert frame to protocol data
233)   if (!m_destsMcuf.empty())
234)     frame2data(pFrame, BlinkenProtoMcuf, mcuf);

235) 

236)   // send frame to all static MCUF destinations

237)   typename Dests::const_iterator itDest;

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

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

240) 
241)   // request time callback in one second
242)   m_callMgr.requestTimeCall(this, Time::now() + Time(1));

243) }
244) 
245) /// set current frame to none
246) template<typename ADDR, typename SOCK>
247) void Sender<ADDR, SOCK>::setNoFrame()
248) {

249)   std::string mcuf;
250) 
251)   // get "no frame" protocol data
252)   if (!m_destsMcuf.empty())
253)     noFrame2data(BlinkenProtoMcuf, mcuf);
254) 
255)   // send "no frame" to all static MCUF destinations

256)   typename Dests::const_iterator itDest;

257)   for (itDest = m_destsMcuf.begin(); itDest != m_destsMcuf.end(); ++itDest)
258)     sendFrame(mcuf, itDest->m_addr);
259) 
260)   // request time callback in one second
261)   m_callMgr.requestTimeCall(this, Time::now() + Time(1));
262) }
263) 
264) /// callback when requsted time reached
265) template<typename ADDR, typename SOCK>
266) void Sender<ADDR, SOCK>::timeCall()
267) {
268)   stBlinkenFrame *pFrame;
269)   std::string data;
270) 
271)   // get current frame from stream
272)   if (m_pInStream && m_pInStream->getCurFrame(pFrame))
273)     // repeat frame - behave exactly like this frame had been set
274)     setFrame(pFrame);
275) 
276)   // no stream of no current frame
277)   else
278)     // repeat "no frame" - behave exactly like "no frame" had been set
279)     setNoFrame();

280) }
281) 
282) /// get input stream and attach to it
283) template<typename ADDR, typename SOCK>
284) void Sender<ADDR, SOCK>::getInStream()
285) {
286)   // get input stream
287)   m_fileInStream.getStr(m_nameInStream);
288)   m_pInStream = &m_streamMgr.refStream(m_nameInStream);
289) 
290)   // attach to input stream
291)   if (m_pInStream)
292)     m_pInStream->attach(this);
293) }
294) 
295) /// detach from input stream and release it
296) template<typename ADDR, typename SOCK>
297) void Sender<ADDR, SOCK>::releaseInStream()
298) {
299)   // detach from input stream
300)   if (m_pInStream)
301)     m_pInStream->detach(this);
302) 
303)   // unreference stream
304)   m_pInStream = NULL;
305)   m_streamMgr.unrefStream(m_nameInStream);
306) }
307) 
308) /// create socket and bind it
309) template<typename ADDR, typename SOCK>
310) void Sender<ADDR, SOCK>::createSock()
311) {
312)   std::string strAddr;
313)   ADDR addr;
314) 
315)   // create socket
316)   if (!m_pSock) {
317)     m_pSock = new SOCK();
318)     if (!m_pSock)
319)       return;
320)   }
321) 
322)   // get bind address from bind address setting file
323)   if (!m_fileBind.getStr(strAddr) || !addr.fromStr(strAddr)) {
324)     delete m_pSock;
325)     m_pSock = NULL;
326)     return;
327)   }
328) 
329)   // bind socket
330)   if (!m_pSock->bind(addr)) {
331)     delete m_pSock;
332)     m_pSock = NULL;
333)     return;
334)   }
335) }
336) 
337) /// destroy socket
338) template<typename ADDR, typename SOCK>
339) void Sender<ADDR, SOCK>::destroySock()
340) {
341)   // destroy socket
342)   if (m_pSock) {
343)     delete m_pSock;
344)     m_pSock = NULL;
345)   }
346) }
347) 
348) /**
349)  * @brief light update of static destinations,
350)  *        i.e. stat all files in current static destination directory

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

353)  */
354) template<typename ADDR, typename SOCK>

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

356) {
357)   // walk through all files in static dest dir and check for modification

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

360) 
361)     // address changed
362)     if (itDest->m_file.checkModified()) {
363)       // send "no frame" to old address

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

365)       // re-load address
366)       if (!itDest->parse()) {
367)         // parsing address failed -> remove destination

368)         itDest = dests.erase(itDest);

369)         // do not advance to next destination
370)         continue;
371)       }
372)       // send current frame to new address

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

374)     }
375) 
376)     // advance to next destination
377)     ++itDest;
378) 
379)   } // while itDest
380) }
381) 
382) /**
383)  * @brief full update of static destinations,
384)  *        i.e. scan files in playlist directory

385)  * @param[in] dirDests static destinations directory for protocol
386)  * @param[in] dests static destinations for protocol
387)  * @param[in] proto Blinken protocol identifier

388)  */
389) template<typename ADDR, typename SOCK>

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

392) {
393)   // get list of files in static destinations directory
394)   typedef std::list<std::string> Filelist;
395)   Filelist curFiles;

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

397) 
398)   // walk through current static destinations and file list simultaneously
399)   Filelist::const_iterator itFile = curFiles.begin();

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

402) 
403)     // new static destination inserted

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

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

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

408)       if (dest.parse()) {
409)         // insert new static destination

410)         dests.insert(itDest, dest);

411)         // send current frame to new static destination

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

413)       }
414)       // advance to next file
415)       ++itFile;
416)     }
417) 
418)     // static destination removed
419)     // static destination changed (=> remove and re-insert in next iteration)
420)     else if (itFile == curFiles.end() || *itFile > itDest->m_name ||
421)              itDest->m_file.checkModified()) {
422)       // send "no frame" to old static destination

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

424)       // remove static destination

425)       itDest = dests.erase(itDest);

426)       // do not advance to next file
427)     }
428) 
429)     // static destination stayed in playlist and did not change
430)     else {
431)       // advance to next file and next static destination
432)       ++itFile;
433)       ++itDest;
434)     }
435) 
436)   } // while itFile itDest
437) }
438) 
439) /**
440)  * @brief send current frame to address
441)  * @param[in] addr address to send to

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

443)  */
444) template<typename ADDR, typename SOCK>

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

446) {
447)   stBlinkenFrame *pFrame;

448)   std::string data;

449) 
450)   // get current frame from stream
451)   if (m_pInStream && m_pInStream->getCurFrame(pFrame)) {

452)     // convert frame to protocal data
453)     frame2data(pFrame, proto, data);

454)     // send frame to address

455)     sendFrame(data, addr);

456)   }
457) 
458)   // no stream of no current frame
459)   else {

460)     // get "no frame" ad protocal data
461)     noFrame2data(proto, data);

462)     // send "no frame" to address

463)     sendFrame(data, addr);

464)   }
465) }
466) 
467) /**

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

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

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

471)  */
472) template<typename ADDR, typename SOCK>

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

474) {

475)   std::string data;
476) 
477)   // get "no frame" ad protocal data
478)   noFrame2data(proto, data);
479) 
480)   // send "no frame" to address
481)   sendFrame(data, addr);

482) }
483) 
484) /**

485)  * @brief send frame to address
486)  * @param[in] data protocol data of frame

487)  * @param[in] addr address to send to
488)  */
489) template<typename ADDR, typename SOCK>

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

491) {
492)   if (m_pSock) {

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

494)   }
495) }
496) 
497) /**

498)  * @brief convert frame to protocol data

499)  * @param[in] pFrame frame

500)  * @param[in] proto Blinken protocol identifier
501)  * @param[out] data protocol data

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

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

506) {
507)   char buf[65536];
508)   int len;
509) 

510)   // convert frame to protcol data
511)   len = BlinkenFrameToNetwork(pFrame, proto, buf, sizeof(buf));
512)   data.assign(buf, len);
513) }
514) 
515) /**
516)  * @brief get "no frame" protocol data
517)  * @param[in] proto Blinken protocol identifier
518)  * @param[out] data protcol data
519)  */
520) template<typename ADDR, typename SOCK>
521) void Sender<ADDR, SOCK>::noFrame2data(etBlinkenProto proto, std::string &data)
522) {
523)   // obtain "no frame" protcol data
524)   (void)proto; // FIXME
525)   data.clear(); // FIXME