class IVTSession(RPCSession):
request_publish_rtmp_schame = Schema({
'channel': IntVal(min=0),
'quality': VideoQuality.schema,
'url': Use(STRING),
'stream_id': Use(STRING),
})
request_stop_rtmp_schema = Schema({
'channel': IntVal(min=0),
'stream_id': Use(STRING),
})
def __init__(self, ivt, transport):
self._ivt = ivt
super(IVTSession, self).__init__(transport)
self._keepalive_greenlet = gevent.spawn(self._keepalive)
def _keepalive(self):
while True:
try:
data = {}
for c in self._ivt.iter_cameras():
data[c.channel] = {'is_online': c.is_online}
self._send_event('keepalive', data)
except Exception:
log.exception('Failed to send keepalive to IVC')
finally:
gevent.sleep(self._ivt.keepalive_interval)
def on_close(self):
try:
gevent.kill(self._keepalive_greenlet)
except Exception:
log.exception('Failed to kill keepalive greenlet')
super(IVTSession, self).on_close()
self._ivt.session_closed()
def rpc_getInfo(self):
return {'id': self._ivt.id, 'cameras': self._ivt.cameras_info()}
def rpc_RTMPPublish(self, params):
params = self.request_publish_rtmp_schame.validate(params)
self._ivt.rtmp_publish(params['channel'], params['quality'],
params['url'], params['stream_id'])
def rpc_RTMPStopPublish(self, params):
params = self.request_stop_rtmp_schema.validate(params)
self._ivt.rtmp_stop_publish(params['channel'], params['stream_id'])
class DeviceWSConnectionManager(DeviceManager):
login_params_schema = Schema({
'project': Use(STRING),
'login_code': Use(STRING),
'login_passwd': Use(STRING)
})
def __init__(self, device_dao, device_ttl):
super(DeviceWSConnectionManager, self).__init__(device_dao)
self._device_ttl = device_ttl
self._device_connections = {}
def device_online(self, transport, params):
params = self.login_params_schema.validate(params)
project_name = params['project']
login_code = params['login_code']
login_passwd = params['login_passwd']
device = self._dao.get_by_login_code(login_code)
if not device:
raise IVRError('Unknown device <{0}> try to login: {1}'.format(
login_code, params))
if device.project_name != project_name:
raise IVRError(
'Device <{0}> of project <{1}> attampts to login as project <{2}> device'
.format(login_code, device.project_name, project_name))
if device.login_passwd != login_passwd:
raise IVRError(
'Device login failed with wrong password: {0}'.format(params))
device_conn = DeviceConn(self, project_name, device.uuid, transport,
self._device_ttl)
old_device_conn = self._device_connections.pop(device.uuid, None)
if old_device_conn:
log.warning('There is old {0}, disconnect it first'.format(
old_device_conn))
try:
old_device_conn.force_shutdown()
except Exception:
log.exception(
'failed to force shutdown {0}'.format(old_device_conn))
self._device_connections[device.uuid] = device_conn
log.info('{0} online'.format(device))
device.state = device.STATE_ONLINE
device.ltime = datetime.datetime.now()
self._dao.update(device)
return device_conn
def device_keepalive(self, device_id, params):
device_conn = self._device_connections.get(device_id)
if not device_conn:
log.error(
'BUG: device connection not found for keepalive device <{0}>'.
format(device_id))
device = self._dao.get_by_uuid(device_id)
if not device:
self._device_connections.pop(device_id, None)
try:
device_conn.force_shutdown()
except Exception:
log.exception(
'Failed to force shutdown {0}'.format(device_conn))
raise IVRError('Unkonw device for {0}'.format(device_conn))
device.is_online = device.STATE_ONLINE
device.ltime = datetime.datetime.now()
self._dao.update(device)
for channel in params:
self._camera_mngr.set_camera_state_by_device_channel(
device.project_name, device.uuid, channel,
params[channel]['is_online'])
def conn_closed_cbk(self, conn):
self._device_connections.pop(conn.device_id, None)
device = self.get_device(conn.project_name, conn.device_id)
device.is_online = device.STATE_ONLINE
self.update_device(conn.project_name, device)
def rtmp_publish_stream(self, project_name, device_id, channel, stream_id,
quality, publish_url):
device_conn = self._device_connections.get(device_id)
if not device_conn:
raise IVRError(
'Device <{0}> of project <{1}> is not online'.format(
device_id, project_name))
device_conn.rtmp_publish_stream(channel, quality, publish_url,
stream_id)
def stop_rtmp_publish(self, project_name, device_id, channel, stream_id):
device_conn = self._device_connections.get(device_id)
if not device_conn:
raise IVRError(
'Device <{0}> of project <{1}> is not online'.format(
device_id, project_name))
device_conn.stop_rtmp_publish(channel, stream_id)
resp = {'total': total,
'start': req['start'],
'list': []}
if limit > 0 and start < total:
camera_list = request.registry.camera_mngr.get_camera_list(request.matchdict['project_name'],
req['start'],
req['limit'])
resp['list'] = camera_list
return resp
new_camera_request_schema = Schema({
'name': StrVal(max_len=255),
Optional('desc'): StrVal(max_len=255),
Optional('long_desc'): StrVal(max_len=1024),
'device_uuid': Use(unicode),
'channel_index': IntVal(min=0),
'flags': IntVal(),
Optional('longitude'): Use(float),
Optional('latitude'): Use(float),
Optional('altitude'): Use(float),
})
@post_view(route_name='camera_list')
def new_camera(request):
req = get_params_from_request(request, new_camera_request_schema)
camera_id = request.registry.camera_mngr.add_camera(project_name=request.matchdict['project_name'], **req)
return {'uuid': camera_id}
IntVal(),
Optional('login_code'):
StrVal(max_len=64),
'login_passwd':
StrVal(max_len=64),
Optional('firmware_model'):
StrVal(max_len=255),
Optional('hardware_model'):
StrVal(max_len=255),
# Optional('media_channel_num'): IntVal(),
Optional('desc'):
StrVal(max_len=255),
Optional('long_desc'):
StrVal(max_len=1024),
Optional('longitude'):
Use(float),
Optional('latitude'):
Use(float),
Optional('altitude'):
Use(float),
})
@post_view(route_name='device_list')
def new_device(request):
req = get_params_from_request(request, new_device_request_schema)
device_id = request.registry.device_mngr.add_device(
project_name=request.matchdict['project_name'], **req)
return {'uuid': device_id}
'list': []}
if limit > 0 and start < total:
session_list = request.registry.user_session_mngr.get_running_session_list(
request.matchdict['project_name'],
camera_id=request.matchdict['camera_id'],
start=req['start'],
limit=req['limit']
)
resp['list'] = session_list
return resp
get_stream_schema = Schema({'format': EnumVal(['hls', 'rtmp']),
Optional('quality'): Default(EnumVal(['ld', 'sd', 'hd']), default='ld'),
Optional('create'): Default(BoolVal(), default=True),
Optional('user'): Default(Use(STRING), default='')})
@post_view(route_name='user_session_list')
def request_user_session(request):
req = get_params_from_request(request, get_stream_schema)
url, session_id = request.registry.user_session_mngr.request_session(
request.matchdict['project_name'],
request.matchdict['camera_id'],
stream_format=req['format'],
stream_quality=req['quality'],
create=req['create'],
ip=request.client_addr or '',
user_agent=request.user_agent,
username='',
subuser=req['user']
def includeme(config):
# block device list resource
# GET: block device list
config.add_route('access_key_list', '/access_keys')
config.add_route('user_access_key_list', '/users/{username}/access_keys')
config.add_route('access_key', '/access_keys/{key_id}')
config.add_route('access_key_secret', '/access_keys/{key_id}/secret')
get_access_key_list_schema = Schema({
Optional('username'): StrRe(r"^\w*$"),
Optional('key_type'): IntVal(values=[AccessKey.KEY_TYPE_NORMAL,
AccessKey.KEY_TYPE_PRIVILEGE]),
Optional('start'): Default(IntVal(min=0), default=0),
Optional('limit'): Default(IntVal(min=0, max=65535), default=65535),
DoNotCare(Use(STRING)): object # for all other key we don't care
})
@get_view(route_name='access_key_list')
def get_access_key_list(request):
params = get_params_from_request(request, get_access_key_list_schema)
total, access_key_list = request.registry.access_key_mngr.get_key_list_in_pages(
username=params.get('username', None),
key_type=params.get('key_type', None),
start_index=params['start'],
max_number=params['limit'])
resp = {'total': total,
'start': params['start'],
'list': access_key_list}
return resp
from ivr.common.logger import default_config as default_log_config
from ivr.common.ws import WSServer
from ivr.common.schema import Schema, Use, IntVal, Default, Optional, BoolVal
from ivr.common.confparser import parse as parse_conf
from ivr.common.utils import STRING
from ivr.ivc.manager.camera import CameraManager
from ivr.ivc.manager.device_ws import DeviceWSConnectionManager
from ivr.ivc.manager.session import UserSessionManager
from ivr.ivc.manager.stream import StreamManager
from ivr.ivc.manager.project import ProjectManager
from ivr.ivc.manager.user import UserManager
from ivr.ivc.manager.sessionlog import UserSessionLogManager
from ivr.ivc.manager.access_key import AccessKeyManager
config_schema = Schema({
'rest_listen': Use(STRING),
'ws_listen': Use(STRING),
'rtmp_publish_url_prefix': Use(STRING),
'rtmp_url_prefix': Use(STRING),
'hls_url_prefix': Use(STRING),
'stream_ttl': IntVal(min=10, max=1800),
'user_session_ttl': IntVal(min=10, max=1800),
'device_ttl': IntVal(min=10, max=1800),
Optional('sqlalchemy'): {
'url': Use(STRING)
},
Optional('debug'): Default(BoolVal(), default=False),
})
def main():
# block device list resource
# GET: block device list
config.add_route('user_list', '/users')
config.add_route('project_user_list', '/projects/{project_name}/users')
config.add_route('user', '/users/{username}')
config.add_route('user_project_list', '/users/{username}/projects')
config.add_route('user_password', '/users/{username}/password')
config.add_route('user_password_reset', '/users/{username}/password_reset')
get_user_list_schema = Schema({
Optional('filter_key'): StrRe(r"^\S*$"),
Optional('filter_value'): StrRe(r"^\S*$"),
Optional('start'): Default(IntVal(min=0), default=0),
Optional('limit'): Default(IntVal(min=0, max=65535), default=65535),
DoNotCare(Use(STRING)): object # for all other key we don't care
})
@get_view(route_name='user_list')
def get_user_list(request):
params = get_params_from_request(request, get_user_list_schema)
total, user_list = request.registry.user_mngr.get_user_list_in_pages(
params.get('filter_key', None),
params.get('filter_value', ""),
params['start'],
params['limit'])
resp = {'total': total,
'start': params['start'],
'list': user_list}
return resp
import urllib
from ivr.common.logger import default_config as default_log_config
from ivr.common.ws import WSClientTransport
from ivr.common.schema import Schema, Use, EnumVal, IntVal, ListVal, DoNotCare, Optional
from ivr.ivt.ivt import IVT
from ivr.common.confparser import parse as parse_conf
from ivr.common.utils import STRING
from ivr.common.datatype import VideoQuality
from streamswitch.port_mngr import SubProcessPort
from streamswitch.ports.rtsp_port import RTSP_PORT_PROGRAM_NAME
config_schema = Schema({
'ivc':
Use(STRING),
'project':
Use(STRING),
'login_code':
Use(STRING),
'login_passwd':
Use(STRING),
'keepalive_interval':
IntVal(min=1, max=1800),
Optional('preview_upload_server'):
Use(STRING),
'cameras':
ListVal({
'channel':
IntVal(min=0),
'type':