Simple Client Counter for VLC VLM
'''
+import gevent
+import logging
class ClientCounter(object):
def __init__(self):
self.clients = dict()
+ self._lock = gevent.coros.RLock()
self.total = 0
def get(self, id):
return self.clients.get(id, (False,))[0]
- def add(self, id, ip):
+ def add(self, id, ip, unic):
+ self._lock.acquire()
+ logger = logging.getLogger('clientcounter_Add')
if self.clients.has_key(id):
self.clients[id][0] += 1
- self.clients[id][1].append(ip)
+ self.clients[id][1].append([ip,unic])
+ logger.info('counter for %s incremented to %s' % (id,self.clients[id][0]))
else:
- self.clients[id] = [1, [ip]]
+ self.clients[id] = [1, [[ip,unic]]]
+ logger.info('counter for %s started (1)' % id)
self.total += 1
+ logger.info('total count = %s' % self.total)
+
+ self._lock.release()
return self.clients[id][0]
- def delete(self, id, ip):
+ def delete(self, id, ip, unic):
+ self._lock.acquire()
+ logger = logging.getLogger('clientcounter_Del')
if self.clients.has_key(id):
self.total -= 1
+ logger.info('total count = %s' % self.total)
if self.clients[id][0] == 1:
del self.clients[id]
+ logger.info('counter for %s decremented to zero' % id )
+ self._lock.release()
return False
else:
self.clients[id][0] -= 1
- self.clients[id][1].remove(ip)
+ self.clients[id][1].remove([ip,unic])
+ logger.info('counter for %s decremented to %s' % (id,self.clients[id][0]))
else:
+ self._lock.release()
return False
+ self._lock.release()
return self.clients[id][0]
-
import telnetlib
import logging
from vlcmessages import *
-
+import time
+from pprint import pprint
class VlcException(Exception):
# Logger
logger = logging.getLogger('VlcClient_init')
+ # Streams
+ self.streams=dict()
+
# Making connection
try:
self._socket = telnetlib.Telnet(host, port, connect_timeout)
- logger.debug("Successfully connected with VLC socket!")
+ logger.info("Successfully connected with VLC socket!")
except Exception as e:
raise VlcException(
"Socket creation error! VLC is not running? ERROR: " + repr(e))
# If socket is still alive (connected)
if self._socket:
try:
- logger.debug("Destroying VlcClient...")
+ logger.info("Destroying VlcClient...")
self._write(VlcMessage.request.SHUTDOWN)
# Set shuttingDown flag for recvData
self._shuttingDown.set()
try:
# Write message
- logger.debug('VLC command: ' + message)
+ logger.info('VLC command: ' + message)
self._socket.write(message + "\r\n")
except EOFError as e:
raise VlcException("Vlc Write error! ERROR: " + repr(e))
msg = VlcMessage.request.startBroadcast(stream_name, input, self._out_port, muxer, pre_access, qtype)
self._write(msg)
else:
+ if stream_name not in self.streams:
+ self._resultlock.release()
+ logger.error("Attempting to delete not existing stream %s" % stream_name)
+ return
self._write(VlcMessage.request.stopBroadcast(stream_name))
try:
logger.error(broadcast + " result timeout")
raise VlcException(broadcast + " result timeout")
finally:
+ logger.info("working with %s stream: %s" % (stream_name,broadcast))
+ if brtype == True:
+ self.streams[stream_name]=time.time()
+ else:
+ del self.streams[stream_name]
self._resultlock.release()
+ logger.info("worked with %s stream: %s" % (stream_name,broadcast))
if brtype == True:
- logger.debug("Broadcast started")
+ logger.info("Broadcast started")
else:
- logger.debug("Broadcast stopped")
+ logger.info("Broadcast stopped")
def startBroadcast(self, stream_name, input, muxer='ts', pre_access='', qtype='default'):
logger = logging.getLogger("VlcClient_startBroadcast")
def stopBroadcast(self, stream_name):
return self._broadcast(False, stream_name)
+ def mark(self,stream_name):
+ self.streams[stream_name]=time.time()
+
+ def clean_streams(self,timeout=15):
+ self._resultlock.acquire()
+ to_stop=set()
+ for stream,lasttime in self.streams.iteritems():
+ print stream,lasttime
+ if time.time()-lasttime>timeout:
+ to_stop.add(stream)
+ for stream in to_stop:
+ self.stopBroadcast(stream)
+ self._resultlock.release()
+
def pauseBroadcast(self, stream_name):
return self._write(VlcMessage.request.pauseBroadcast(stream_name))
# Do not move this before error handlers!
elif self._recvbuffer.startswith(VlcMessage.response.STARTOK):
# Broadcast started
- logger.debug("Broadcast started")
+ logger.info("Broadcast started")
self._result.set(True)
elif self._recvbuffer.startswith(VlcMessage.response.STOPOK):
# Broadcast stopped
- logger.debug("Broadcast stopped")
+ logger.info("Broadcast stopped")
self._result.set(True)
except ImportError:
pass
+import uuid
+from apscheduler.schedulers.background import BackgroundScheduler
class HTTPHandler(BaseHTTPServer.BaseHTTPRequestHandler):
try:
while True:
-
+
if not self.clientconnected:
logger.debug("Client is not connected, terminating")
break
+ VPStuff.vlcclient.mark(self.vlcid)
data = self.video.read(4096)
if data and self.clientconnected:
self.wfile.write(data)
self.handleRequest(headers_only)
def handleRequest(self, headers_only):
+
+ self.unic = uuid.uuid4()
# Limit concurrent connections
if 0 < VPConfig.maxconns <= VPStuff.clientcounter.total:
self.params.append('0')
# Adding client to clientcounter
- clients = VPStuff.clientcounter.add(self.reqtype+'\\'+self.path_unquoted, self.clientip)
+ clients = VPStuff.clientcounter.add(self.reqtype+'\\'+self.path_unquoted, self.clientip, self.unic)
# If we are the one client, but sucessfully got vp instance from clientcounter,
# then somebody is waiting in the videodestroydelay state
# End headers. Next goes video data
self.end_headers()
logger.debug("Headers sent")
+ self.headerssent = True
# Run proxyReadWrite
self.proxyReadWrite()
finally:
logger.debug("END REQUEST")
logger.info("Closed connection from " + self.clientip + " path " + self.path)
- VPStuff.clientcounter.delete(self.reqtype+'\\'+self.path_unquoted, self.clientip)
- if not VPStuff.clientcounter.get(self.reqtype+'\\'+self.path_unquoted):
- try:
- logger.debug("That was the last client, destroying VPClient")
- logger.info("Stopping broadcasting " + self.path)
- VPStuff.vlcclient.stopBroadcast(self.vlcid)
- except:
- pass
- self.vp.destroy()
- if not self.headerssent:
- logger.error("Problem receiving video stream, no headers!")
- if VPStuff.clientcounter.total == 0:
- logger.error("Probably VLC hang")
- VPStuff.vlc.kill()
+ VPStuff.clientcounter.delete(self.reqtype+'\\'+self.path_unquoted, self.clientip, self.unic)
+# if not VPStuff.clientcounter.get(self.reqtype+'\\'+self.path_unquoted):
+# try:
+# logger.debug("That was the last client, destroying VPClient")
+# logger.info("Stopping broadcasting " + self.path)
+# VPStuff.vlcclient.stopBroadcast(self.vlcid)
+# except vlcclient.VlcException:
+# logger.error("VLC connection problem, %s client(s)!" % VPStuff.clientcounter.total)
+# if VPStuff.clientcounter.total == 0:
+# logger.error("Probably VLC hang")
+# VPStuff.vlc.kill()
+# except:
+# pass
+ self.vp.destroy()
class HTTPServer(SocketServer.ThreadingMixIn, BaseHTTPServer.HTTPServer):
from vpconfig import VPConfig
logger.info('Config reloaded')
+sched = BackgroundScheduler()
+sched.start()
+
+def clean_streams():
+ VPStuff.vlcclient.clean_streams(15)
+
+job = sched.add_job(clean_streams, 'interval', seconds=15)
+
# setting signal handlers
try:
gevent.signal(signal.SIGHUP, _reloadconfig)
try:
logger.info("Using gevent %s" % gevent.__version__)
- logger.info("Using psutil %s" % psutil.__version__)
+ logger.info("Usig psutil %s" % psutil.__version__)
logger.info("Using VLC %s" % VPStuff.vlcclient._vlcver)
logger.info("Server started.")
while True:
import xml.dom.minidom
import sys,os
-from pprint import pprint
from plugins.modules.PlaylistGenerator import PlaylistGenerator
tvguide_url="http://www.teleguide.info/download/new3/jtv.zip"
projects / vpproxy.git / commitdiff