def get_url(cls, source_id, quality, mode, retry=True):
try:
proxy = None
if ModelSetting.get_bool('wavve_use_proxy'):
proxy = ModelSetting.get('wavve_proxy_url')
try:
data = Wavve.streaming('live',
source_id,
quality,
cls.login_data,
proxy=proxy)
surl = None
if data is not None:
surl = data['playurl']
if surl is None:
raise Exception('no url')
except:
if retry:
logger.debug('RETRY')
cls.login_data = Wavve.do_login(
ModelSetting.get('wavve_id'),
ModelSetting.get('wavve_pw'))
ModelSetting.set('wavve_credential', cls.login_data)
return cls.get_url(source_id, quality, mode, retry=False)
if ModelSetting.get('wavve_streaming_type') == '2':
return 'redirect', surl
return 'return_after_read', surl
except Exception as e:
logger.error('Exception:%s', e)
logger.error(traceback.format_exc())
def streaming(cls, req):
try:
contentid = req.args.get('contentid')
contenttype = req.args.get('type')
quality = ModelSetting.get('wavve_quality')
json_data = Wavve.streaming(contenttype, contentid, quality)
tmp = json_data['playurl']
#logger.debug(tmp)
return redirect(tmp, code=302)
except Exception as e:
logger.error('Exception:%s', e)
logger.error(traceback.format_exc())
def stream(self, code):
try:
show = None
if code[1] == 'V':
import framework.tving.api as Tving
data, url = Tving.get_episode_json_default(code[2:], 'stream50')
return {'ret':'success', 'site':'tving', 'url':url}
elif code[1] == 'W':
import framework.wavve.api as Wavve
data = Wavve.streaming('vod', code[2:], '1080p', return_url=True)
return {'ret':'success', 'site':'wavve', 'url':data}
except Exception as e:
P.logger.error('Exception:%s', e)
P.logger.error(traceback.format_exc())
def get_url(cls, source_id, quality, mode, retry=True):
try:
data = Wavve.streaming('live', source_id, quality)
surl = None
if data is not None:
surl = data['playurl']
if surl is None:
raise Exception('no url')
if ModelSetting.get('wavve_streaming_type') == '2':
return 'redirect', surl
return 'return_after_read', surl
except Exception as e:
logger.error('Exception:%s', e)
logger.error(traceback.format_exc())
def analyze(url, quality=None):
try:
logger.debug('analyze :%s', url)
url_type = None
code = None
corner_id = None
vod_type = None
if url.startswith('http'):
match = re.compile(
r'contentid\=(?P<contentid>.*?)(\&|$|\#)').search(url)
match2 = re.compile(
r'programid\=(?P<programid>.*?)(\&|$|\#)').search(url)
if match:
code = match.group('contentid')
url_type = 'episode'
elif match2:
url_type = 'program'
code = match2.group('programid')
else:
match = re.compile(
r'movieid\=(?P<movieid>.*?)($|\#)').search(url)
if match:
url_type = 'movie'
code = match.group('movieid')
else:
if len(url.split('.')) == 2:
url_type = 'episode'
code = url.strip()
elif url.startswith('MV_'):
url_type = 'movie'
code = url.strip()
elif url.find('_') != -1:
url_type = 'program'
code = url.strip()
else:
pass
logger.debug('Analyze %s %s', url_type, code)
if url_type is None:
return {'url_type': 'None'}
elif url_type == 'episode':
if quality is None:
quality = ModelSetting.get('quality')
data = Wavve.vod_contents_contentid(code)
contenttype = 'onairvod' if data['type'] == 'onair' else 'vod'
proxy = None
data2 = Wavve.streaming(contenttype, code, quality,
ModelSetting.get('credential'))
try:
tmp = data2['playurl']
except:
try:
LogicBasic.login()
data2 = Wavve.streaming(contenttype, code, quality,
ModelSetting.get('credential'))
except:
pass
#logger.debug(data2)
data3 = {}
data3['filename'] = Wavve.get_filename(data, quality)
data3['preview'] = (data2['playurl'].find('preview') != -1)
data3['current_quality'] = quality
ModelSetting.set('recent_code', code)
return {
'url_type': url_type,
'code': code,
'episode': data,
'streaming': data2,
'available': data3
}
elif url_type == 'program':
data = Wavve.vod_program_contents_programid(code)
ModelSetting.set('recent_code', code)
return {
'url_type': url_type,
'page': '1',
'code': code,
'data': data
}
elif url_type == 'movie':
if quality is None:
quality = ModelSetting.get('quality')
data = Wavve.movie_contents_movieid(code)
data2 = Wavve.streaming('movie', code, quality,
ModelSetting.get('credential'))
try:
tmp = data2['playurl']
except:
try:
LogicBasic.login()
data2 = Wavve.streaming('movie', code, quality,
ModelSetting.get('credential'))
except:
pass
data3 = {}
data3['filename'] = Wavve.get_filename(data, quality)
data3['preview'] = (data2['playurl'].find('preview') != -1)
data3['current_quality'] = quality
ModelSetting.set('recent_code', code)
return {
'url_type': url_type,
'code': code,
'info': data,
'streaming': data2,
'available': data3
}
except Exception as e:
logger.error('Exception:%s', e)
logger.error(traceback.format_exc())
def ajax(sub):
logger.debug('Wavve AJAX sub:%s', sub)
try:
if sub == 'setting_save':
try:
ret = Logic.setting_save(request)
return jsonify(ret)
except Exception as e:
logger.error('Exception:%s', e)
logger.error(traceback.format_exc())
return jsonify('fail')
elif sub == 'scheduler':
try:
go = request.form['scheduler']
logger.debug('scheduler :%s', go)
if go == 'true':
Logic.scheduler_start()
else:
Logic.scheduler_stop()
return jsonify(go)
except Exception as e:
logger.error('Exception:%s', e)
logger.error(traceback.format_exc())
return jsonify('fail')
elif sub == 'login':
try:
ret = Wavve.do_login(request.form['id'], request.form['pw'], json_return=True)
return jsonify(ret)
except Exception as e:
logger.error('Exception:%s', e)
logger.error(traceback.format_exc())
return jsonify('fail')
#########################################################
# 기본
#########################################################
# 프로그램에서도 사용
elif sub == 'analyze':
url = request.form['url']
quality = None
if 'quality' in request.form:
quality = request.form['quality']
ret = LogicBasic.analyze(url, quality=quality)
return jsonify(ret)
elif sub == 'episode_download_url':
logger.debug(request.form)
url = request.form['url']
filename = request.form['filename']
logger.debug('download %s %s', url, filename)
ret = LogicBasic.download_url(url, filename)
return jsonify(ret)
#########################################################
# 자동
#########################################################
elif sub == 'auto_list':
try:
ret = LogicRecent.get_list(request)
logger.debug('len list :%s', len(ret))
return jsonify(ret)
except Exception as e:
logger.error('Exception:%s', e)
elif sub == 'add_condition_list':
try:
ret = LogicRecent.add_condition_list(request)
return jsonify(ret)
except Exception as e:
logger.error('Exception:%s', e)
logger.error(traceback.format_exc())
elif sub == 'reset_db':
try:
ret = LogicRecent.reset_db()
return jsonify(ret)
except Exception as e:
logger.error('Exception:%s', e)
logger.error(traceback.format_exc())
#########################################################
# 프로그램
#########################################################
# more버튼
elif sub == 'program_page':
try:
code = request.form['code']
page = request.form['page']
ret = LogicBasic.analyze_program_page(code, page)
return jsonify(ret)
except Exception as e:
logger.error('Exception:%s', e)
logger.error(traceback.format_exc())
# 화질확인
elif sub == 'get_contents':
try:
code = request.form['code']
ret = Wavve.vod_contents_contentid(code)
ret = Wavve.streaming(ret['type'], ret['contentid'], '2160p', ModelSetting.get('credential'))
return jsonify(ret)
except Exception as e:
logger.error('Exception:%s', e)
logger.error(traceback.format_exc())
elif sub == 'download_program':
try:
ret = LogicProgram.download_program(request)
return jsonify(ret)
except Exception as e:
logger.error('Exception:%s', e)
logger.error(traceback.format_exc())
elif sub == 'download_program_check':
try:
ret = LogicProgram.download_program_check(request)
return jsonify(ret)
except Exception as e:
logger.error('Exception:%s', e)
logger.error(traceback.format_exc())
elif sub == 'program_auto_command':
try:
ret = LogicProgram.program_auto_command(request)
return jsonify(ret)
except Exception as e:
logger.error('Exception:%s', e)
logger.error(traceback.format_exc())
except Exception as e:
logger.error('Exception:%s', e)
logger.error(traceback.format_exc())
def scheduler_function():
try:
logger.debug('Wavve scheduler_function start..')
LogicBasic.login()
page = int(ModelSetting.get('auto_page'))
max_pf_count = ModelSetting.get('max_pf_count')
save_path = ModelSetting.get('auto_save_path')
auto_quality = ModelSetting.get('auto_quality')
retry_user_abort = (ModelSetting.get('retry_user_abort') == 'True')
credential = ModelSetting.get('credential')
qvod_download = (ModelSetting.get('qvod_download') == 'True')
except_channel = ModelSetting.get('except_channel')
except_program = ModelSetting.get('except_program')
download_program_in_qvod = ModelSetting.get(
'download_program_in_qvod')
download_mode = ModelSetting.get('download_mode')
whitelist_program = ModelSetting.get('whitelist_program')
whitelist_first_episode_download = (
ModelSetting.get('whitelist_first_episode_download') == 'True')
except_channels = [
x.strip() for x in except_channel.replace('\n', ',').split(',')
]
except_programs = [
x.strip().replace(' ', '')
for x in except_program.replace('\n', ',').split(',')
]
download_program_in_qvods = [
x.strip().replace(' ', '')
for x in download_program_in_qvod.replace('\n', ',').split(',')
]
whitelist_programs = [
x.strip().replace(' ', '')
for x in whitelist_program.replace('\n', ',').split(',')
]
Util.get_list_except_empty(except_channels)
except_channels = Util.get_list_except_empty(except_channels)
except_programs = Util.get_list_except_empty(except_programs)
download_program_in_qvods = Util.get_list_except_empty(
download_program_in_qvods)
whitelist_programs = Util.get_list_except_empty(whitelist_programs)
logger.debug('except_channels:%s', except_channels)
logger.debug('except_programs:%s', except_programs)
logger.debug('qvod_download :%s %s', qvod_download,
type(qvod_download))
for i in range(1, page + 1):
vod_list = Wavve.vod_newcontents(page=i)['list']
#logger.debug(vod_list)
logger.debug('Page:%s vod len:%s', page, len(vod_list))
for vod in vod_list:
try:
while True:
if LogicRecent.current_auto_count_ffmpeg < int(
ModelSetting.get('auto_count_ffmpeg')):
break
time.sleep(10)
#logger.debug('wavve wait : %s', LogicRecent.current_auto_count_ffmpeg)
#logger.debug(vod)
contentid = vod["contentid"]
contenttype = 'onairvod' if vod[
'type'] == 'onair' else 'vod'
episode = db.session.query(ModelWavveEpisode) \
.filter((ModelWavveEpisode.call == 'auto') | (ModelWavveEpisode.call == None)) \
.filter_by(contentid=contentid) \
.with_for_update().first() \
if episode is not None:
if episode.completed:
continue
elif episode.user_abort:
if retry_user_abort:
episode.user_abort = False
else:
#사용자 중지로 중단했고, 다시받기가 false이면 패스
continue
elif episode.etc_abort > 10:
# 1:알수없는이유 시작실패, 2 타임오버, 3, 강제스톱.킬
# 11:제외채널, 12:제외프로그램
# 13:장르제외, 14:화이트리스트 제외, 7:권한없음, 6:화질다름
#logger.debug('EPC Abort : %s', episode.etc_abort)
continue
elif episode.retry > 20:
logger.debug('retry 20')
episode.etc_abort = 9
continue
# URL때문에 DB에 있어도 다시 JSON을 받아야함.
for episode_try in range(3):
json_data = Wavve.streaming(
contenttype, contentid, auto_quality,
credential)
try:
tmp = json_data['playurl']
except:
try:
LogicBasic.login()
json_data = Wavve.streaming(
contenttype, contentid, auto_quality,
credential)
except:
pass
if json_data is None:
logger.debug('episode fail.. %s', episode_try)
time.sleep(20)
else:
break
if episode is None:
if json_data is None:
episode = ModelWavveEpisode(
'auto', info=vod, streaming=json_data)
db.session.add(episode)
db.session.commit()
continue
else:
episode = ModelWavveEpisode(
'auto', info=vod, streaming=json_data)
db.session.add(episode)
else:
if json_data is None:
continue
else:
episode.set_streaming(json_data)
if json_data['playurl'].find('preview') != -1:
episode.etc_abort = 7
db.session.commit()
continue
# 채널, 프로그램 체크
flag_download = True
if contenttype == 'onairvod':
if not qvod_download:
episode.etc_abort = 11
flag_download = False
for programtitle in download_program_in_qvods:
if episode.programtitle.replace(
' ', '').find(programtitle) != -1:
flag_download = True
episode.etc_abort = 0
break
# 시간체크
if flag_download:
logger.debug(episode.episodetitle)
match = re.compile(
r'Quick\sVOD\s(?P<time>\d{2}\:\d{2})\s'
).search(episode.episodetitle)
if match:
dt_now = datetime.now()
logger.debug(dt_now)
dt_tmp = datetime.strptime(
match.group('time'), '%H:%M')
dt_start = datetime(
dt_now.year, dt_now.month, dt_now.day,
dt_tmp.hour, dt_tmp.minute, 0, 0)
logger.debug(dt_start)
if (dt_now - dt_start).seconds < 0:
dt_start = dt_start + timedelta(
days=-1)
#detail = Wavve.vod_contents_contentid(episode.contentid)
if 'detail' not in episode.contents_json:
episode.contents_json[
'detail'] = Wavve.vod_contents_contentid(
episode.contentid)
qvod_playtime = episode.contents_json[
'detail']['playtime']
delta = (dt_now - dt_start).seconds
if int(qvod_playtime) > delta:
flag_download = False
episode.etc_abort = 8
logger.debug('QVOD %s %s %s %s',
flag_download,
match.group('time'),
qvod_playtime, delta)
else:
logger.debug('QVOD fail..')
flag_download = False
episode.etc_abort = 7
if download_mode == '0':
for program_name in except_programs:
if episode.programtitle.replace(
' ', '').find(program_name) != -1:
episode.etc_abort = 13
flag_download = False
break
if episode.channelname in except_channels:
episode.etc_abort = 12
flag_download = False
else:
if flag_download:
find_in_whitelist = False
for program_name in whitelist_programs:
if episode.programtitle.replace(
' ', '').find(program_name) != -1:
find_in_whitelist = True
break
if not find_in_whitelist:
episode.etc_abort = 14
flag_download = False
if not flag_download and whitelist_first_episode_download and episode.episodenumber == '1':
flag_download = True
#logger.debug(episode.quality)
if flag_download and episode.quality != auto_quality:
if auto_quality == '2160p' and episode.quality == '1080p' and ModelSetting.get_bool(
'2160_receive_1080'):
if episode.created_time + timedelta(
minutes=ModelSetting.get_int(
'2160_wait_minute')
) < datetime.now():
logger.debug('1080p download')
pass
else:
episode.etc_abort = 5
db.session.commit()
continue
else:
episode.etc_abort = 6
db.session.commit()
continue
if flag_download:
episode.etc_abort = 0
episode.retry += 1
episode.pf = 0 # 재시도
episode.save_path = save_path
episode.start_time = datetime.now()
db.session.commit()
else:
db.session.commit()
continue
logger.debug('FFMPEG Start.. id:%s', episode.id)
if episode.id is None:
logger.debug('PROGRAM:%s', episode.programtitle)
tmp = Wavve.get_prefer_url(episode.playurl)
f = ffmpeg.Ffmpeg(tmp,
episode.filename,
plugin_id=episode.id,
listener=LogicBasic.ffmpeg_listener,
max_pf_count=max_pf_count,
call_plugin='%s_recent' %
package_name,
save_path=save_path)
f.start()
LogicRecent.current_auto_count_ffmpeg += 1
#f.start_and_wait()
time.sleep(20)
#return
except Exception as e:
logger.error('Exception:%s', e)
logger.error(traceback.format_exc())
#db.session.rollback()
logger.debug(
'ROLLBACK!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!')
finally:
#logger.debug('wait..')
pass
logger.debug('=======================================')
except Exception as e:
logger.error('Exception:%s', e)
logger.error(traceback.format_exc())
def download_thread_function():
while True:
try:
while True:
if LogicProgram.current_ffmpeg_count < int(
ModelSetting.get('program_auto_count_ffmpeg')):
break
time.sleep(5)
entity = LogicProgram.download_queue.get()
if entity.cancel:
continue
# 초기화
if entity is None:
return
contenttype = 'onairvod' if entity.json_data[
'type'] == 'onair' else 'vod'
count = 0
while True:
count += 1
streaming_data = Wavve.streaming(
contenttype, entity.episode_code, entity.quality,
ModelSetting.get('credential'))
try:
tmp = data2['playurl']
except:
try:
from .logic_basic import LogicBasic
LogicBasic.login()
streaming_data = Wavve.streaming(
contenttype, entity.episode_code,
entity.quality, ModelSetting.get('credential'))
except:
pass
entity.json_data['filename'] = Wavve.get_filename(
entity.json_data, streaming_data['quality'])
if streaming_data is not None:
break
else:
time.sleep(20)
if count > 10:
entity.ffmpeg_status_kor = u'URL실패'
break
if streaming_data is None:
continue
import ffmpeg
max_pf_count = ModelSetting.get('max_pf_count')
save_path = ModelSetting.get('program_auto_path')
if ModelSetting.get('program_auto_make_folder') == 'True':
program_path = os.path.join(
save_path, entity.json_data['programtitle'])
save_path = program_path
try:
if not os.path.exists(save_path):
os.makedirs(save_path)
except:
logger.debug('program path make fail!!')
### edit by lapis
ModelWavveProgram.update(entity)
###
# 파일 존재여부 체크
if os.path.exists(
os.path.join(save_path, entity.json_data['filename'])):
entity.ffmpeg_status_kor = '파일 있음'
entity.ffmpeg_percent = 100
### edit by lapis
ModelWavveProgram.delete(entity.episode_code,
entity.quality)
###
plugin.socketio_list_refresh()
continue
tmp = Wavve.get_prefer_url(streaming_data['playurl'])
f = ffmpeg.Ffmpeg(tmp,
entity.json_data['filename'],
plugin_id=entity.entity_id,
listener=LogicProgram.ffmpeg_listener,
max_pf_count=max_pf_count,
call_plugin='wavve_program',
save_path=save_path)
f.start()
LogicProgram.current_ffmpeg_count += 1
LogicProgram.download_queue.task_done()
except Exception as e:
logger.error('Exception:%s', e)
logger.error(traceback.format_exc())
