80fc0f7850974d3aea32ffd03107a368d29a8b26
[vpproxy.git] / vlcclient / vlcclient.py
1 '''
2 Minimal VLC VLM client for AceProxy. Client class.
3 '''
4
5 import gevent
6 import gevent.event
7 import gevent.coros
8 import telnetlib
9 import logging
10 from vlcmessages import *
11 import time
12 from pprint import pprint
13
14 class VlcException(Exception):
15
16     '''
17     Exception from VlcClient
18     '''
19     pass
20
21
22 class VlcClient(object):
23
24     '''
25     VLC Client class
26     '''
27
28     def __init__(
29         self, host='127.0.0.1', port=4212, password='admin', connect_timeout=10,
30             result_timeout=10, out_port=8081):
31         # Receive buffer
32         self._recvbuffer = None
33         # Output port
34         self._out_port = out_port
35         # VLC socket
36         self._socket = None
37         # Result timeout
38         self._resulttimeout = result_timeout
39         # Shutting down flag
40         self._shuttingDown = gevent.event.Event()
41         # Authentication done event
42         self._auth = gevent.event.AsyncResult()
43         # Request lock
44         self._resultlock = gevent.coros.RLock()
45         # Request result
46         self._result = gevent.event.AsyncResult()
47         # VLC version string
48         self._vlcver = None
49         # Saving password
50         self._password = password
51
52         # Logger
53         logger = logging.getLogger('VlcClient_init')
54
55         # Streams
56         self.streams=dict()
57
58         # Making connection
59         try:
60             self._socket = telnetlib.Telnet(host, port, connect_timeout)
61             logger.info("Successfully connected with VLC socket!")
62         except Exception as e:
63             raise VlcException(
64                 "Socket creation error! VLC is not running? ERROR: " + repr(e))
65
66         # Spawning recvData greenlet
67         gevent.spawn(self._recvData)
68         gevent.sleep()
69
70         # Waiting for authentication event
71         try:
72             if self._auth.get(timeout=self._resulttimeout) == False:
73                 errmsg = "Authentication error"
74                 logger.error(errmsg)
75                 raise VlcException(errmsg)
76         except gevent.Timeout:
77             errmsg = "Authentication timeout"
78             logger.error(errmsg)
79             raise VlcException(errmsg)
80
81     def __del__(self):
82         # Destructor just calls destroy() method
83         self.destroy()
84
85     def destroy(self):
86         # Logger
87         logger = logging.getLogger("VlcClient_destroy")
88
89         if self._shuttingDown.isSet():
90             # Already in the middle of destroying
91             return
92
93         # If socket is still alive (connected)
94         if self._socket:
95             try:
96                 logger.info("Destroying VlcClient...")
97                 self._write(VlcMessage.request.SHUTDOWN)
98                 # Set shuttingDown flag for recvData
99                 self._shuttingDown.set()
100             except:
101                 # Ignore exceptions on destroy
102                 pass
103
104     def _write(self, message):
105
106         logger = logging.getLogger("VlcClient_write")
107
108         # Return if in the middle of destroying
109         if self._shuttingDown.isSet():
110             return
111
112         try:
113             # Write message
114             logger.info('VLC command: ' + message)
115             self._socket.write(message + "\r\n")
116         except EOFError as e:
117             raise VlcException("Vlc Write error! ERROR: " + repr(e))
118
119     def _broadcast(self, brtype, stream_name, input=None, muxer='ts', pre_access='', qtype='default'):
120         if self._shuttingDown.isSet():
121             return
122
123         # Start/stop broadcast with VLC
124         # Logger
125         if brtype == True:
126             broadcast = 'startBroadcast'
127         else:
128             broadcast = 'stopBroadcast'
129
130         logger = logging.getLogger("VlcClient_" + broadcast)
131         # Clear AsyncResult
132         self._result = gevent.event.AsyncResult()
133         # Get lock
134         self._resultlock.acquire()
135         # Write message to VLC socket
136         if brtype == True:
137             msg = VlcMessage.request.startBroadcast(stream_name, input, self._out_port, muxer, pre_access, qtype)
138             self._write(msg)
139         else:
140             if stream_name not in self.streams:
141                 self._resultlock.release()
142                 logger.error("Attempting to delete not existing stream %s" % stream_name)
143                 return
144             self._write(VlcMessage.request.stopBroadcast(stream_name))
145
146         try:
147             gevent.sleep()
148             result = self._result.get(timeout=self._resulttimeout)
149             if result == False:
150                 logger.error(broadcast + " error")
151                 raise VlcException(broadcast + " error")
152         except gevent.Timeout:
153             logger.error(broadcast + " result timeout")
154             raise VlcException(broadcast + " result timeout")
155         finally:
156             logger.info("working with %s stream: %s" % (stream_name,broadcast))
157             if brtype == True:
158                 self.streams[stream_name]=time.time()
159             else:
160                 del self.streams[stream_name]
161             self._resultlock.release()
162             logger.info("worked with %s stream: %s" % (stream_name,broadcast))
163
164         if brtype == True:
165             logger.info("Broadcast started")
166         else:
167             logger.info("Broadcast stopped")
168
169     def startBroadcast(self, stream_name, input, muxer='ts', pre_access='', qtype='default'):
170         logger = logging.getLogger("VlcClient_startBroadcast")
171         logger.debug("Starting broadcast......")
172         return self._broadcast(True, stream_name, input, muxer, pre_access, qtype)
173
174     def stopBroadcast(self, stream_name):
175         return self._broadcast(False, stream_name)
176
177     def mark(self,stream_name):
178       self.streams[stream_name]=time.time()
179
180     def clean_streams(self,timeout=15):
181       self._resultlock.acquire()
182       to_stop=set()
183       for stream,lasttime in self.streams.iteritems():
184         print stream,lasttime
185         if time.time()-lasttime>timeout:
186           to_stop.add(stream)
187       for stream in to_stop:    
188         self.stopBroadcast(stream)
189       self._resultlock.release()
190
191     def pauseBroadcast(self, stream_name):
192         return self._write(VlcMessage.request.pauseBroadcast(stream_name))
193
194     def playBroadcast(self, stream_name):
195         return self._write(VlcMessage.request.playBroadcast(stream_name))
196
197     def _recvData(self):
198         # Logger
199         logger = logging.getLogger("VlcClient_recvData")
200
201         while True:
202             gevent.sleep()
203             try:
204                 self._recvbuffer = self._socket.read_until("\n")
205                 # Stripping "> " from VLC
206                 self._recvbuffer = self._recvbuffer.lstrip("> ")
207             except:
208                 # If something happened during read, abandon reader
209                 if not self._shuttingDown.isSet():
210                     logger.error("Exception at socket read")
211                     self._shuttingDown.set()
212                 return
213
214             # Parsing everything only if the string is not empty
215             if self._recvbuffer:
216                 if not self._vlcver:
217                     # First line (VLC version)
218                     self._vlcver = self._recvbuffer.strip()
219                     # Send password here since PASSWORD doesn't have \n
220                     self._write(self._password)
221
222                 elif self._recvbuffer.startswith(VlcMessage.response.SHUTDOWN):
223                     # Exit from this loop
224                     logger.debug("Got SHUTDOWN from VLC")
225                     return
226
227                 elif self._recvbuffer.startswith(VlcMessage.response.WRONGPASS):
228                     # Wrong password
229                     logger.error("Wrong VLC password!")
230                     self._auth.set(False)
231                     return
232
233                 elif self._recvbuffer.startswith(VlcMessage.response.AUTHOK):
234                     # Authentication OK
235                     logger.info("Authentication successful")
236                     self._auth.set(True)
237
238                 elif VlcMessage.response.BROADCASTEXISTS in self._recvbuffer:
239                     # Broadcast already exists
240                     logger.error("Broadcast already exists!")
241                     self._result.set(False)
242
243                 elif VlcMessage.response.STOPERR in self._recvbuffer:
244                     # Media unknown (stopping non-existent stream)
245                     logger.error("Broadcast does not exist!")
246                     self._result.set(False)
247
248                 # Do not move this before error handlers!
249                 elif self._recvbuffer.startswith(VlcMessage.response.STARTOK):
250                     # Broadcast started
251                     logger.info("Broadcast started")
252                     self._result.set(True)
253
254                 elif self._recvbuffer.startswith(VlcMessage.response.STOPOK):
255                     # Broadcast stopped
256                     logger.info("Broadcast stopped")
257                     self._result.set(True)