def __test():
""" test function """
from raspiserver.utils import ConfigReader
cfg_parser = ConfigReader('./config/raspicam.cfg')
cfg = cfg_parser.parser()
videocmd = RaspvidCmd(cfg.video)
APPLOGGER.debug(videocmd.cmd())
def do_POST(self):
""" POST """
APPLOGGER.debug(self.path)
try:
_environ = {
'REQUEST_METHOD': 'POST',
'CONTENT_TYPE': self.headers['Content-Type'],
}
except KeyError as ex:
_environ = {}
APPLOGGER.warn(ex)
form = cgi.FieldStorage(fp=self.rfile,
headers=self.headers,
environ=_environ)
action = self.path
callinfo = action.replace('/', ' ').strip(' ')
callinfo = '__' + callinfo
try:
callback = getattr(self, '_' + self.__class__.__name__ + callinfo)
if callback != None and callable(callback):
callback(form)
else:
APPLOGGER.debug(self.path)
APPLOGGER.debug(str(form))
self.send_response(503)
self.end_headers()
except AttributeError as ex:
APPLOGGER.error(ex)
def do_POST(self):
""" POST """
APPLOGGER.debug(self.path)
try:
_environ = {'REQUEST_METHOD': 'POST',
'CONTENT_TYPE': self.headers['Content-Type'],}
except KeyError as ex:
_environ = {}
APPLOGGER.warn(ex)
form = cgi.FieldStorage(fp=self.rfile,
headers=self.headers,
environ=_environ)
action = self.path
callinfo = action.replace('/', ' ').strip(' ')
callinfo = '__' + callinfo
try:
callback = getattr(self, '_' + self.__class__.__name__ + callinfo)
if callback != None and callable(callback):
callback(form)
else:
APPLOGGER.debug(self.path)
APPLOGGER.debug(str(form))
self.send_response(503)
self.end_headers()
except AttributeError as ex:
APPLOGGER.error(ex)
def do_GET(self):
""" handle video request """
APPLOGGER.info(self.path)
if not exists(self.path) or not isfile(self.path) \
or not self.path.endswith('mp4'):
self.send_error(404, 'File Not Found: %s' % self.path)
return
try:
sendreply = False
if self.path.endswith('.mp4'):
mimetype = 'video/mp4'
sendreply = True
if sendreply == True:
# Open the static file requested and send it
_setvodfile(self.path)
fhandler = open(self.path)
self.send_response(200)
self.send_header('Content-type', mimetype)
self.end_headers()
self.wfile.write(fhandler.read())
fhandler.close()
return
except IOError:
self.send_error(404, 'File Not Found: %s' % self.path)
finally:
_setvodfile('')
def do_GET(self):
""" handle video request """
APPLOGGER.info(self.path)
if not exists(self.path) or not isfile(self.path) \
or not self.path.endswith('mp4'):
self.send_error(404, 'File Not Found: %s' % self.path)
return
try:
sendreply = False
if self.path.endswith('.mp4'):
mimetype = 'video/mp4'
sendreply = True
if sendreply == True:
# Open the static file requested and send it
_setvodfile(self.path)
fhandler = open(self.path)
self.send_response(200)
self.send_header('Content-type', mimetype)
self.end_headers()
self.wfile.write(fhandler.read())
fhandler.close()
return
except IOError:
self.send_error(404, 'File Not Found: %s' % self.path)
finally:
_setvodfile('')
def __test():
""" test function """
from raspiserver.utils import ConfigReader
cfg_parser = ConfigReader('./config/raspicam.cfg')
cfg = cfg_parser.parser()
videocmd = RaspvidCmd(cfg.video)
APPLOGGER.debug(videocmd.cmd())
def getvalue(src):
""" set value """
retval = -1
try:
retval = int(src)
except ValueError as ex:
APPLOGGER.warn(ex)
return retval
def getvalue(src):
""" set value """
retval = -1
try:
retval = int(src)
except ValueError as ex:
APPLOGGER.warn(ex)
return retval
def start(self):
""" start video process """
APPLOGGER.info('subcall in porcess')
child = None
child = subprocess.Popen(self.process_cmd.cmd(),
shell=True, preexec_fn=os.setsid)
if child is not None:
self.__vvprocess = child
APPLOGGER.info('video process start and set')
def __free_space(self):
""" free disk space for record if self.cycle == True """
rec_files = self.get_recordfiles()
def filesort(file1, file2):
""" sort by create time """
ctime1 = getctime(file1)
ctime2 = getctime(file2)
if ctime1 < ctime2:
return -1
elif ctime1 == ctime2:
return 0
else:
return 1
rec_files.sort(cmp=filesort)
def getfsize(path):
""" get size for %.3f """
return float("%.3f" % (getsize(path) / 1024.0 / 1024.0))
for item in rec_files:
if self.get_freespaces() < self.lefthrhold:
APPLOGGER.debug(getvodfile())
if getvodfile().strip(" ") == item.strip(" "):
APPLOGGER.debug("in use: " + getvodfile())
continue
else:
APPLOGGER.debug("relase space is : " + str(getfsize(item)))
remove(item)
else:
break
APPLOGGER.debug("free space is: " + str(self.get_freespaces()))
def __free_space(self):
""" free disk space for record if self.cycle == True """
rec_files = self.get_recordfiles()
def filesort(file1, file2):
""" sort by create time """
ctime1 = getctime(file1)
ctime2 = getctime(file2)
if ctime1 < ctime2:
return -1
elif ctime1 == ctime2:
return 0
else:
return 1
rec_files.sort(cmp=filesort)
def getfsize(path):
""" get size for %.3f """
return float('%.3f' % (getsize(path) / 1024.0 / 1024.0))
for item in rec_files:
if self.get_freespaces() < self.lefthrhold:
APPLOGGER.debug(getvodfile())
if getvodfile().strip(' ') == item.strip(' '):
APPLOGGER.debug('in use: ' + getvodfile())
continue
else:
APPLOGGER.debug('relase space is : ' + str(getfsize(item)))
remove(item)
else:
break
APPLOGGER.debug('free space is: ' + str(self.get_freespaces()))
def httpserve(cfg, recmng, vvpmng):
""" httpserve """
ipaddr = cfg.comm_port.address
serve_port = cfg.comm_port.http_port
try:
if ipaddr is '':
raise AppException('get local ip exp')
if int(serve_port) <= 0 or int(serve_port) > 65535:
raise AppException('port num err')
if cfg == None:
raise AppException('cfg is null')
else:
from raspiserver.utils import ConfigObject
if type(cfg) != ConfigObject:
raise AppException('parameter type not correct')
except AppException as ex:
APPLOGGER.error(ex)
sys.exit(1)
APPLOGGER.info('Server Up IP=%s PORT=%s', ipaddr, serve_port)
server = None
try:
server = HttpCtlServer((ipaddr, serve_port), \
HttpCtlHandler, cfg, recmng, vvpmng)
except socket.error as ex:
APPLOGGER.error(ex)
sys.exit(1)
if server:
server.serve_forever()
else:
APPLOGGER.error('http server start error')
def httpserve(cfg, recmng, vvpmng):
""" httpserve """
ipaddr = cfg.comm_port.address
serve_port = cfg.comm_port.http_port
try:
if ipaddr is '':
raise AppException('get local ip exp')
if int(serve_port) <= 0 or int(serve_port) > 65535:
raise AppException('port num err')
if cfg == None:
raise AppException('cfg is null')
else:
from raspiserver.utils import ConfigObject
if type(cfg) != ConfigObject:
raise AppException('parameter type not correct')
except AppException as ex:
APPLOGGER.error(ex)
sys.exit(1)
APPLOGGER.info('Server Up IP=%s PORT=%s', ipaddr, serve_port)
server = None
try:
server = HttpCtlServer((ipaddr, serve_port), \
HttpCtlHandler, cfg, recmng, vvpmng)
except socket.error as ex:
APPLOGGER.error(ex)
sys.exit(1)
if server:
server.serve_forever()
else:
APPLOGGER.error('http server start error')
def __change(self, form):
""" change video process params """
self.vvpmng.getlock()
try:
def getvalue(src):
""" set value """
retval = -1
try:
retval = int(src)
except ValueError as ex:
APPLOGGER.warn(ex)
return retval
def setpara(key, form, dst):
""" set params """
if key in form.keys():
tmpval = -1
tmpval = getvalue(form[key].value)
if tmpval != -1:
dst = tmpval
return dst
self.vvpmng.process_cmd.bright = \
setpara('para_bright', form, self.vvpmng.process_cmd.bright)
self.vvpmng.process_cmd.fps = \
setpara('para_fps', form, self.vvpmng.process_cmd.fps)
self.vvpmng.process_cmd.bitrate = \
setpara('para_bitrate', form, \
self.vvpmng.process_cmd.bitrate)
self.vvpmng.process_cmd.width = \
setpara('para_width', form, self.vvpmng.process_cmd.width)
self.vvpmng.process_cmd.height = \
setpara('para_height', form, self.vvpmng.process_cmd.height)
APPLOGGER.debug(self.vvpmng.process_cmd.cmd())
self.__sendmsg(200, self.vvpmng.process_cmd.cmd())
if not self.vvpmng.isset():
self.vvpmng.start()
return
if self.vvpmng.isrun():
self.vvpmng.stop()
self.vvpmng.setprocess(None)
self.vvpmng.start()
else:
self.vvpmng.start()
finally:
self.vvpmng.releaselock()
def __watch_dog(self):
""" watch the free space """
freespace = 0
while 1:
self.getlock()
try:
if not self.have_space() and self.cycle:
self.__free_space()
except OSError:
pass
finally:
freespace = self.get_freespaces()
self.releaselock()
APPLOGGER.debug("free space is: " + str(freespace) + "MB")
sleep(2)
def __change(self, form):
""" change video process params """
self.vvpmng.getlock()
try:
def getvalue(src):
""" set value """
retval = -1
try:
retval = int(src)
except ValueError as ex:
APPLOGGER.warn(ex)
return retval
def setpara(key, form, dst):
""" set params """
if key in form.keys():
tmpval = -1
tmpval = getvalue(form[key].value)
if tmpval != -1:
dst = tmpval
return dst
self.vvpmng.process_cmd.bright = \
setpara('para_bright', form, self.vvpmng.process_cmd.bright)
self.vvpmng.process_cmd.fps = \
setpara('para_fps', form, self.vvpmng.process_cmd.fps)
self.vvpmng.process_cmd.bitrate = \
setpara('para_bitrate', form, \
self.vvpmng.process_cmd.bitrate)
self.vvpmng.process_cmd.width = \
setpara('para_width', form, self.vvpmng.process_cmd.width)
self.vvpmng.process_cmd.height = \
setpara('para_height', form, self.vvpmng.process_cmd.height)
APPLOGGER.debug(self.vvpmng.process_cmd.cmd())
self.__sendmsg(200, self.vvpmng.process_cmd.cmd())
if not self.vvpmng.isset():
self.vvpmng.start()
return
if self.vvpmng.isrun():
self.vvpmng.stop()
self.vvpmng.setprocess(None)
self.vvpmng.start()
else:
self.vvpmng.start()
finally:
self.vvpmng.releaselock()
def __watch_dog(self):
""" watch the free space """
freespace = 0
while 1:
self.getlock()
try:
if not self.have_space() and self.cycle:
self.__free_space()
except OSError:
pass
finally:
freespace = self.get_freespaces()
self.releaselock()
APPLOGGER.debug('free space is: ' + \
str(freespace) + 'MB')
sleep(2)
def __change(self, data):
""" change video process paramters
change|cmd1=opt, cmd2=opt2, ... """
data = data.lstrip('change|')
data = data.split(',')
APPLOGGER.debug(data)
paradict = {}
try:
paradict = dict([item.split('=') for item in data if item != ''])
if not paradict:
raise AppException('paradict dict is empty')
except AppException as ex:
APPLOGGER.error(ex)
return
if 'brightness' in paradict:
self.vvpmng.process_cmd.bright = int(paradict['brightness'])
if 'bitrate' in paradict:
self.vvpmng.process_cmd.bitrate = int(paradict['bitrate'])
if 'fps' in paradict:
self.vvpmng.process_cmd.fps = int(paradict['fps'])
if 'height' in paradict:
self.vvpmng.process_cmd.height = int(paradict['height'])
if 'width' in paradict:
self.vvpmng.process_cmd.width = int(paradict['width'])
# just change parameter no record here
self.vvpmng.process_cmd.record = False
self.vvpmng.process_cmd.recordfname = ''
self.vvpmng.getlock()
try:
if not self.vvpmng.isset():
self.vvpmng.start()
return
if self.vvpmng.isrun():
self.vvpmng.stop()
self.vvpmng.setprocess(None)
self.vvpmng.start()
else:
self.vvpmng.start()
finally:
self.vvpmng.releaselock()
self.request.sendall(self.vvpmng.process_cmd.cmd())
self.request.close()
def __change(self, data):
""" change video process paramters
change|cmd1=opt, cmd2=opt2, ... """
data = data.lstrip('change|')
data = data.split(',')
APPLOGGER.debug(data)
paradict = {}
try:
paradict = dict([item.split('=') for item in data if item != ''])
if not paradict:
raise AppException('paradict dict is empty')
except AppException as ex:
APPLOGGER.error(ex)
return
if 'brightness' in paradict:
self.vvpmng.process_cmd.bright = int(paradict['brightness'])
if 'bitrate' in paradict:
self.vvpmng.process_cmd.bitrate = int(paradict['bitrate'])
if 'fps' in paradict:
self.vvpmng.process_cmd.fps = int(paradict['fps'])
if 'height' in paradict:
self.vvpmng.process_cmd.height = int(paradict['height'])
if 'width' in paradict:
self.vvpmng.process_cmd.width = int(paradict['width'])
# just change parameter no record here
self.vvpmng.process_cmd.record = False
self.vvpmng.process_cmd.recordfname = ''
self.vvpmng.getlock()
try:
if not self.vvpmng.isset():
self.vvpmng.start()
return
if self.vvpmng.isrun():
self.vvpmng.stop()
self.vvpmng.setprocess(None)
self.vvpmng.start()
else:
self.vvpmng.start()
finally:
self.vvpmng.releaselock()
self.request.sendall(self.vvpmng.process_cmd.cmd())
self.request.close()
def main():
""" serve for all """
config_path = '/home/pi/server/config/raspicam.cfg'
cfg_parser = ConfigReader(config_path)
cfg = cfg_parser.parser()
recmng = RecordMng(cfg.record)
vvpmng = VideoProcessMng(cfg.video)
global PROCESSMNG
PROCESSMNG = vvpmng
hyserve = HybirdServer()
# you can start tcp server or http server
try:
hyserve.setservices('httpserver', httpserve, (cfg, recmng, vvpmng))
hyserve.setservices('tcpserver', tcpserve, (cfg, recmng, vvpmng))
hyserve.setservices('vodserver', vodserve, (cfg,))
hyserve.serve()
except AppException as ex:
APPLOGGER.error(ex)
def main():
""" serve for all """
config_path = '/home/pi/server/config/raspicam.cfg'
cfg_parser = ConfigReader(config_path)
cfg = cfg_parser.parser()
recmng = RecordMng(cfg.record)
vvpmng = VideoProcessMng(cfg.video)
global PROCESSMNG
PROCESSMNG = vvpmng
hyserve = HybirdServer()
# you can start tcp server or http server
try:
hyserve.setservices('httpserver', httpserve, (cfg, recmng, vvpmng))
hyserve.setservices('tcpserver', tcpserve, (cfg, recmng, vvpmng))
hyserve.setservices('vodserver', vodserve, (cfg, ))
hyserve.serve()
except AppException as ex:
APPLOGGER.error(ex)
def tcpserve(cfg, recmng, vvpmng):
""" tcpserve """
ipaddr = cfg.comm_port.address
serve_port = cfg.comm_port.tcp_port
try:
if ipaddr is '':
raise AppException('get local ip exp')
if int(serve_port) <= 0 or int(serve_port) > 65535:
raise AppException('port num err')
except AppException as ex:
APPLOGGER.error(ex)
sys.exit(1)
host, port = ipaddr, int(serve_port)
server = None
try:
server = TcpCtlServer((host, port), TcpCtlHandler, cfg, recmng, vvpmng)
except socket.error as ex:
APPLOGGER.error(ex)
sys.exit(1)
APPLOGGER.info('Server Up IP=%s PORT=%s', ipaddr, serve_port)
if server:
server.serve_forever()
else:
raise AppException('server start err')
def tcpserve(cfg, recmng, vvpmng):
""" tcpserve """
ipaddr = cfg.comm_port.address
serve_port = cfg.comm_port.tcp_port
try:
if ipaddr is '':
raise AppException('get local ip exp')
if int(serve_port) <= 0 or int(serve_port) > 65535:
raise AppException('port num err')
except AppException as ex:
APPLOGGER.error(ex)
sys.exit(1)
host, port = ipaddr, int(serve_port)
server = None
try:
server = TcpCtlServer((host, port), TcpCtlHandler, cfg, recmng, vvpmng)
except socket.error as ex:
APPLOGGER.error(ex)
sys.exit(1)
APPLOGGER.info('Server Up IP=%s PORT=%s', ipaddr, serve_port)
if server:
server.serve_forever()
else:
raise AppException('server start err')
def __rm_records(self, data):
""" remove video record """
data = data.lstrip('rm_records|')
data = data.strip('\n')
allfiles = self.recmng.get_recordfiles()
if data not in allfiles:
return
self.recmng.getlock()
ret = -1
try:
ret = self.recmng.rm_recordfiles(data)
finally:
if ret == 0 or ret == 1:
APPLOGGER.info('rm success')
elif ret == -1:
APPLOGGER.info('rm failed')
reclist = self.recmng.get_recordfiles()
msg = 'records|'
msg += ','.join(reclist)
self.request.sendall(msg)
self.request.close()
self.recmng.releaselock()
def __record(self):
""" record video file """
recfname = ''
can_rec = False
self.recmng.getlock()
try:
if self.recmng.have_space() or self.recmng.cycle == True:
recfname = self.recmng.gen_recordfname()
if recfname == '':
raise AppException('record file name is null')
can_rec = True
else:
raise AppException('no space to record')
except AppException as ex:
APPLOGGER.error(ex)
finally:
self.recmng.releaselock()
if not can_rec:
return
self.vvpmng.getlock()
self.vvpmng.process_cmd.record = True
self.vvpmng.process_cmd.recordfname = recfname
APPLOGGER.debug(self.vvpmng.process_cmd.cmd())
try:
if not self.vvpmng.isset():
self.vvpmng.start()
return
if self.vvpmng.isrun():
self.vvpmng.stop()
self.vvpmng.setprocess(None)
self.vvpmng.start()
else:
self.vvpmng.start()
finally:
self.vvpmng.releaselock()
self.request.sendall(self.vvpmng.process_cmd.cmd())
self.request.close()
def __record(self, form):
""" record video """
_ = form
recfname = ''
can_rec = False
self.recmng.getlock()
try:
if self.recmng.have_space() or self.recmng.cycle == True:
recfname = self.recmng.gen_recordfname()
if recfname == '':
raise AppException('record file name is null')
can_rec = True
else:
raise AppException('no space to record')
except AppException as ex:
APPLOGGER.error(ex)
finally:
self.recmng.releaselock()
if not can_rec:
return
self.vvpmng.getlock()
self.vvpmng.process_cmd.record = True
self.vvpmng.process_cmd.recordfname = recfname
APPLOGGER.debug(self.vvpmng.process_cmd.cmd())
try:
if not self.vvpmng.isset():
self.vvpmng.start()
return
if self.vvpmng.isrun():
self.vvpmng.stop()
self.vvpmng.setprocess(None)
self.vvpmng.start()
else:
self.vvpmng.start()
finally:
self.__sendmsg(200, 'record start')
self.vvpmng.releaselock()
def __start(self, form):
""" start the video process """
_ = form
self.vvpmng.getlock()
self.vvpmng.process_cmd.record = False
self.vvpmng.process_cmd.recordfname = ''
try:
if not self.vvpmng.isset():
self.vvpmng.start()
self.__sendmsg(200, self.vvpmng.process_cmd.cmd())
APPLOGGER.info('video server run.')
else:
if self.vvpmng.isrun():
APPLOGGER.info('already run subprocess: ' +
str(self.vvpmng.currpid()))
APPLOGGER.info('video process already run.')
self.__sendmsg(200, 'already run')
else:
APPLOGGER.info('subprocess not running')
APPLOGGER.info('activeCount is ' + str(threading.activeCount()))
finally:
self.vvpmng.releaselock()
def __start(self, form):
""" start the video process """
_ = form
self.vvpmng.getlock()
self.vvpmng.process_cmd.record = False
self.vvpmng.process_cmd.recordfname = ''
try:
if not self.vvpmng.isset():
self.vvpmng.start()
self.__sendmsg(200, self.vvpmng.process_cmd.cmd())
APPLOGGER.info('video server run.')
else:
if self.vvpmng.isrun():
APPLOGGER.info('already run subprocess: ' +
str(self.vvpmng.currpid()))
APPLOGGER.info('video process already run.')
self.__sendmsg(200, 'already run')
else:
APPLOGGER.info('subprocess not running')
APPLOGGER.info('activeCount is ' + str(threading.activeCount()))
finally:
self.vvpmng.releaselock()
def __rm_records(self, data):
""" remove video record """
data = data.lstrip('rm_records|')
data = data.strip('\n')
allfiles = self.recmng.get_recordfiles()
if data not in allfiles:
return
self.recmng.getlock()
ret = -1
try:
ret = self.recmng.rm_recordfiles(data)
finally:
if ret == 0 or ret == 1:
APPLOGGER.info('rm success')
elif ret == -1:
APPLOGGER.info('rm failed')
reclist = self.recmng.get_recordfiles()
msg = 'records|'
msg += ','.join(reclist)
self.request.sendall(msg)
self.request.close()
self.recmng.releaselock()
def __start(self):
""" start video process """
self.vvpmng.getlock()
try:
self.vvpmng.process_cmd.record = False
self.vvpmng.process_cmd.recordfname = ''
if not self.vvpmng.isset():
self.vvpmng.start()
self.request.sendall(self.vvpmng.process_cmd.cmd())
APPLOGGER.info('video server run.')
else:
if self.vvpmng.isrun():
APPLOGGER.info('already run subprocess: ' +
str(self.vvpmng.currpid()))
APPLOGGER.info('video process already run.')
self.request.sendall(self.clientcmd_start + '|' + '1')
self.request.sendall(self.vvpmng.process_cmd.cmd())
else:
APPLOGGER.info('subprocess not running')
APPLOGGER.info('activeCount is ' + str(threading.activeCount()))
finally:
self.request.close()
self.vvpmng.releaselock()
def __start(self):
""" start video process """
self.vvpmng.getlock()
try:
self.vvpmng.process_cmd.record = False
self.vvpmng.process_cmd.recordfname = ''
if not self.vvpmng.isset():
self.vvpmng.start()
self.request.sendall(self.vvpmng.process_cmd.cmd())
APPLOGGER.info('video server run.')
else:
if self.vvpmng.isrun():
APPLOGGER.info('already run subprocess: ' +
str(self.vvpmng.currpid()))
APPLOGGER.info('video process already run.')
self.request.sendall(self.clientcmd_start + '|' + '1')
self.request.sendall(self.vvpmng.process_cmd.cmd())
else:
APPLOGGER.info('subprocess not running')
APPLOGGER.info('activeCount is ' + str(threading.activeCount()))
finally:
self.request.close()
self.vvpmng.releaselock()
def __rm_records(self, form):
""" remove video record """
para_key = 'rm_fname'
file2rm = ''
if para_key in form.keys():
file2rm = form[para_key].value
else:
return
if file2rm:
allfiles = self.recmng.get_recordfiles()
if file2rm not in allfiles:
return
self.recmng.getlock()
ret = -1
try:
ret = self.recmng.rm_recordfiles(file2rm)
finally:
if ret == 0 or ret == 1:
APPLOGGER.info('rm success')
elif ret == -1:
APPLOGGER.info('rm failed')
reclist = self.recmng.get_recordfiles()
self.__sendmsg(200, any2json_fstr(reclist))
self.recmng.releaselock()
def __rm_records(self, form):
""" remove video record """
para_key = 'rm_fname'
file2rm = ''
if para_key in form.keys():
file2rm = form[para_key].value
else:
return
if file2rm:
allfiles = self.recmng.get_recordfiles()
if file2rm not in allfiles:
return
self.recmng.getlock()
ret = -1
try:
ret = self.recmng.rm_recordfiles(file2rm)
finally:
if ret == 0 or ret == 1:
APPLOGGER.info('rm success')
elif ret == -1:
APPLOGGER.info('rm failed')
reclist = self.recmng.get_recordfiles()
self.__sendmsg(200, any2json_fstr(reclist))
self.recmng.releaselock()
def gen_recordfname(self):
""" generate the video filename """
currtime = gmtime()
rec_sub_dir_name = ''
rec_sub_dir_name += str(currtime.tm_year) + '_'
rec_sub_dir_name += str(currtime.tm_mon) + '_'
rec_sub_dir_name += str(currtime.tm_mday)
day_recdir = self.__recordbase + '/' + rec_sub_dir_name
filename = str(currtime.tm_hour) + ':' + \
str(currtime.tm_min) + ':' + \
str(currtime.tm_sec)
whole_fname = day_recdir + '/' + filename
try:
if exists(day_recdir):
if isdir(day_recdir):
if exists(whole_fname):
remove(whole_fname)
else:
remove(day_recdir)
makedirs(day_recdir)
else:
makedirs(day_recdir)
except OSError as ex:
APPLOGGER.error(ex)
# can record but don't have enough space
try:
if self.have_space():
return whole_fname
else:
if self.cycle:
self.__free_space()
return whole_fname
raise AppException('no space')
except AppException as ex:
APPLOGGER.info('free space is: ' + str(self.get_freespaces()))
APPLOGGER.info('limit is : ' + str(self.lefthrhold))
APPLOGGER.error(ex)
def vodserve(cfg):
""" vod serve """
ipaddr = cfg.comm_port.address
serve_port = cfg.comm_port.vod_port
try:
if ipaddr is '':
raise AppException('get local ip exp')
if int(serve_port) <= 0 or int(serve_port) > 65535:
raise AppException('port num err')
except AppException as ex:
APPLOGGER.error(ex)
sys.exit(1)
APPLOGGER.info('Server Up IP=%s PORT=%s', ipaddr, serve_port)
server = None
try:
server = VODServer((ipaddr, serve_port), VODReqHandler)
except sockerror as ex:
APPLOGGER.error(ex)
sys.exit(1)
if server:
server.serve_forever()
else:
APPLOGGER.error('vod server start error')
def vodserve(cfg):
""" vod serve """
ipaddr = cfg.comm_port.address
serve_port = cfg.comm_port.vod_port
try:
if ipaddr is '':
raise AppException('get local ip exp')
if int(serve_port) <= 0 or int(serve_port) > 65535:
raise AppException('port num err')
except AppException as ex:
APPLOGGER.error(ex)
sys.exit(1)
APPLOGGER.info('Server Up IP=%s PORT=%s', ipaddr, serve_port)
server = None
try:
server = VODServer((ipaddr, serve_port), VODReqHandler)
except sockerror as ex:
APPLOGGER.error(ex)
sys.exit(1)
if server:
server.serve_forever()
else:
APPLOGGER.error('vod server start error')
def signal_handler(signals, frame):
""" handle ctrl -c """
_, _ = signals, frame
if PROCESSMNG == None:
APPLOGGER.info('Process control object is None')
return
APPLOGGER.info('server exiting..')
PROCESSMNG.getlock()
try:
if PROCESSMNG.isset():
if PROCESSMNG.isrun():
os.killpg(PROCESSMNG.currpid(), signal.SIGTERM)
finally:
PROCESSMNG.releaselock()
APPLOGGER.info('shutdown complete')
sys.exit(0)
def signal_handler(signals, frame):
""" handle ctrl -c """
_, _ = signals, frame
if PROCESSMNG == None:
APPLOGGER.info('Process control object is None')
return
APPLOGGER.info('server exiting..')
PROCESSMNG.getlock()
try:
if PROCESSMNG.isset():
if PROCESSMNG.isrun():
os.killpg(PROCESSMNG.currpid(), signal.SIGTERM)
finally:
PROCESSMNG.releaselock()
APPLOGGER.info('shutdown complete')
sys.exit(0)
def gen_recordfname(self):
""" generate the video filename """
currtime = gmtime()
rec_sub_dir_name = ""
rec_sub_dir_name += str(currtime.tm_year) + "_"
rec_sub_dir_name += str(currtime.tm_mon) + "_"
rec_sub_dir_name += str(currtime.tm_mday)
day_recdir = self.__recordbase + "/" + rec_sub_dir_name
filename = str(currtime.tm_hour) + ":" + str(currtime.tm_min) + ":" + str(currtime.tm_sec)
whole_fname = day_recdir + "/" + filename
try:
if exists(day_recdir):
if isdir(day_recdir):
if exists(whole_fname):
remove(whole_fname)
else:
remove(day_recdir)
makedirs(day_recdir)
else:
makedirs(day_recdir)
except OSError as ex:
APPLOGGER.error(ex)
# can record but don't have enough space
try:
if self.have_space():
return whole_fname
else:
if self.cycle:
self.__free_space()
return whole_fname
raise AppException("no space")
except AppException as ex:
APPLOGGER.info("free space is: " + str(self.get_freespaces()))
APPLOGGER.info("limit is : " + str(self.lefthrhold))
APPLOGGER.error(ex)
def __stop(self, form):
""" stop the video process """
_ = form
self.vvpmng.getlock()
try:
if not self.vvpmng.isset():
APPLOGGER.warn('no process to stop')
self.__sendmsg(200, 'no process to stop')
return # jump to finally
if self.vvpmng.isrun():
self.vvpmng.stop()
APPLOGGER.warn('terminating..')
self.vvpmng.setprocess(None)
self.__sendmsg(200, 'terminating..')
else:
APPLOGGER.info('process is terminate')
self.vvpmng.setprocess(None)
self.__sendmsg(200, 'process is terminated')
finally:
self.vvpmng.releaselock()
def __stop(self, form):
""" stop the video process """
_ = form
self.vvpmng.getlock()
try:
if not self.vvpmng.isset():
APPLOGGER.warn('no process to stop')
self.__sendmsg(200, 'no process to stop')
return # jump to finally
if self.vvpmng.isrun():
self.vvpmng.stop()
APPLOGGER.warn('terminating..')
self.vvpmng.setprocess(None)
self.__sendmsg(200, 'terminating..')
else:
APPLOGGER.info('process is terminate')
self.vvpmng.setprocess(None)
self.__sendmsg(200, 'process is terminated')
finally:
self.vvpmng.releaselock()
def __init__(self, cfg):
self.__reclock = Lock()
self.__recordbase = cfg.base.strip("'") if cfg.base != "" else "/home/pi/records"
self.lefthrhold = cfg.fsp_limit if cfg.fsp_limit != -1 else 100
self.cycle = cfg.cycle if cfg.cycle != None else False
try:
if not exists(self.__recordbase):
makedirs(self.__recordbase)
elif not isdir(self.__recordbase):
remove(self.__recordbase)
makedirs(self.__recordbase)
except OSError as ex:
APPLOGGER.error(ex)
APPLOGGER.info("pls use sudo")
sys.exit(1)
self.__watchthr = None
self.__watchthr = Thread(target=self.__watch_dog)
self.__watchthr.setDaemon(True)
self.__watchthr.setName("watchthr")
self.__watchthr.start()
APPLOGGER.debug(cfg.base)
def __init__(self, cfg):
self.__reclock = Lock()
self.__recordbase = cfg.base.strip("'") \
if cfg.base != '' else '/home/pi/records'
self.lefthrhold = cfg.fsp_limit if cfg.fsp_limit != -1 else 100
self.cycle = cfg.cycle if cfg.cycle != None else False
try:
if not exists(self.__recordbase):
makedirs(self.__recordbase)
elif not isdir(self.__recordbase):
remove(self.__recordbase)
makedirs(self.__recordbase)
except OSError as ex:
APPLOGGER.error(ex)
APPLOGGER.info('pls use sudo')
sys.exit(1)
self.__watchthr = None
self.__watchthr = Thread(target=self.__watch_dog)
self.__watchthr.setDaemon(True)
self.__watchthr.setName('watchthr')
self.__watchthr.start()
APPLOGGER.debug(cfg.base)
def __stop(self):
""" __stop_process """
self.vvpmng.getlock()
try:
if not self.vvpmng.isset():
APPLOGGER.warn('no process to stop')
self.request.sendall(self.clientcmd_stop + '|' + '0')
return #just jump to finally
if self.vvpmng.isrun():
self.vvpmng.stop()
APPLOGGER.warn('terminating..')
self.vvpmng.setprocess(None)
# fake done
self.request.sendall(self.clientcmd_stop + '|' + '1')
else:
APPLOGGER.info('process is terminate')
self.vvpmng.setprocess(None)
self.request.sendall(self.clientcmd_stop + '|' + '0')
finally:
self.vvpmng.process_cmd.record = False
self.vvpmng.process_cmd.recordfname = ''
self.request.close()
self.vvpmng.releaselock()
def __stop(self):
""" __stop_process """
self.vvpmng.getlock()
try:
if not self.vvpmng.isset():
APPLOGGER.warn('no process to stop')
self.request.sendall(self.clientcmd_stop + '|' + '0')
return #just jump to finally
if self.vvpmng.isrun():
self.vvpmng.stop()
APPLOGGER.warn('terminating..')
self.vvpmng.setprocess(None)
# fake done
self.request.sendall(self.clientcmd_stop + '|' + '1')
else:
APPLOGGER.info('process is terminate')
self.vvpmng.setprocess(None)
self.request.sendall(self.clientcmd_stop + '|' + '0')
finally:
self.vvpmng.process_cmd.record = False
self.vvpmng.process_cmd.recordfname = ''
self.request.close()
self.vvpmng.releaselock()
def __process_req(self, data):
""" process req """
data = data.strip(' \n')
if len(data) <= 0:
return
callinfo = data.lower()
callinfo = '__' + callinfo
callinfo = callinfo.split('|')
splitlen = len(callinfo)
if splitlen < 1 or splitlen > 2:
APPLOGGER.warn('request parameter not correct')
return
try:
callback = getattr(self, '_' + \
self.__class__.__name__ + callinfo[0])
if callback != None and callable(callback):
if splitlen == 1:
callback()
else:
callback(data)
else:
APPLOGGER.error('request callback error')
except AttributeError as ex:
APPLOGGER.error(ex)
def __process_req(self, data):
""" process req """
data = data.strip(' \n')
if len(data) <= 0:
return
callinfo = data.lower()
callinfo = '__' + callinfo
callinfo = callinfo.split('|')
splitlen = len(callinfo)
if splitlen < 1 or splitlen > 2:
APPLOGGER.warn('request parameter not correct')
return
try:
callback = getattr(self, '_' + \
self.__class__.__name__ + callinfo[0])
if callback != None and callable(callback):
if splitlen == 1:
callback()
else:
callback(data)
else:
APPLOGGER.error('request callback error')
except AttributeError as ex:
APPLOGGER.error(ex)
def handle(self):
APPLOGGER.debug('theading number is ' + str(threading.activeCount()))
data = self.request.recv(self.maxbuf)
self.__process_req(data)
def parser(self):
""" parser func """
try:
if exists(self.__path) and isfile(self.__path):
with open(self.__path) as fhandler:
try:
config_parser = ConfigParser()
config_parser.readfp(fhandler)
if config_parser.has_option('video', 'width'):
self.__config.video.width = \
config_parser.getint('video', 'width')
if config_parser.has_option('video', 'height'):
self.__config.video.height = \
config_parser.getint('video', 'height')
if config_parser.has_option('video', 'fps'):
self.__config.video.fps = \
config_parser.getint('video', 'fps')
if config_parser.has_option('video', 'bitrate'):
self.__config.video.bitrate = \
config_parser.getint('video', 'bitrate')
if config_parser.has_option('video', 'brightness'):
self.__config.video.brightness = \
config_parser.getint('video', 'brightness')
if config_parser.has_option('video', 'rtsp_port'):
self.__config.video.rtsp_port = \
config_parser.getint('video', 'rtsp_port')
if config_parser.has_option('record', 'base'):
self.__config.record.base = \
config_parser.get('record', 'base')
if config_parser.has_option('record', 'cycle'):
self.__config.record.cycle = \
config_parser.getboolean('record', 'cycle')
if config_parser.has_option('record', 'limit'):
self.__config.record.fsp_limit = \
config_parser.getint('record', 'limit')
if config_parser.has_option('common', 'tcp_port'):
self.__config.comm_port.tcp_port = \
config_parser.getint('common', 'tcp_port')
if config_parser.has_option('common', 'http_port'):
self.__config.comm_port.http_port = \
config_parser.getint('common', 'http_port')
if config_parser.has_option('common', 'vod_port'):
self.__config.comm_port.vod_port = \
config_parser.getint('common', 'vod_port')
# assign default values if value is invalid
if not self.__config.comm_port.http_port:
self.__config.comm_port.http_port = 8080
if not self.__config.comm_port.tcp_port:
self.__config.comm_port.tcp_port = 9999
if not self.__config.comm_port.vod_port:
self.__config.comm_port.vod_port = 9001
self.__config.comm_port.address = get_local_ip()
except (AppException, ConfigError) as ex:
APPLOGGER.error(ex)
else:
raise AppException('config file error')
except OSError as ex:
APPLOGGER.error(ex)
return self.__config
def handle(self):
APPLOGGER.debug('theading number is ' + str(threading.activeCount()))
data = self.request.recv(self.maxbuf)
self.__process_req(data)
def __test():
""" test func """
from raspiserver.utils import ConfigReader
cfg_parser = ConfigReader("./config/raspicam.cfg")
cfg = cfg_parser.parser()
recordmng = RecordMng(cfg.record)
allfiles = recordmng.get_recordfiles()
APPLOGGER.debug(allfiles)
APPLOGGER.debug(len(allfiles))
APPLOGGER.debug(recordmng.get_freespaces())
APPLOGGER.debug(recordmng.have_space())
recordmng.lefthrhold = 330
recordmng.cycle = True
APPLOGGER.debug(recordmng.have_space())
APPLOGGER.debug(recordmng.gen_recordfname())
def stop(self):
""" kill video process """
if self.isset() and self.isrun():
os.killpg(self.__vvprocess.pid, signal.SIGTERM)
APPLOGGER.info('send video process stoped signal')
def __test():
""" test func """
from raspiserver.utils import ConfigReader
cfg_parser = ConfigReader('./config/raspicam.cfg')
cfg = cfg_parser.parser()
recordmng = RecordMng(cfg.record)
allfiles = recordmng.get_recordfiles()
APPLOGGER.debug(allfiles)
APPLOGGER.debug(len(allfiles))
APPLOGGER.debug(recordmng.get_freespaces())
APPLOGGER.debug(recordmng.have_space())
recordmng.lefthrhold = 330
recordmng.cycle = True
APPLOGGER.debug(recordmng.have_space())
APPLOGGER.debug(recordmng.gen_recordfname())
