def create_new_item(list_form_data):
for form_data in list_form_data:
ret = check_form_data(form_data)
if ret != 1:
return ret
# noinspection PyBroadException
try:
db_conn = SSODBPool.connection()
db_cursor = db_conn.cursor()
for form_data in list_form_data:
db_cursor.execute(
"insert into sso_site_list(id, site_name, serial_number, url, origins_permission, remark)"
" values ('%s', '%s', '%s', '%s', '%s', '%s')" % (
str(uuid.uuid1()).replace('-', ''),
form_data["site_name"],
form_data["serial_number"],
form_data["url"],
form_data["origins_permission"],
form_data["remark"],
))
db_conn.commit()
db_conn.close()
except Exception:
logger.error(traceback.format_exc())
return traceback.format_exc()
return 1
def download_url(url, filename):
try:
logger.debug('download_url : %s', url)
save_path = ModelSetting.get('save_path')
max_pf_count = ModelSetting.get('max_pf_count')
tmp = Wavve.get_prefer_url(url)
proxy = None
if ModelSetting.get_bool('use_proxy'):
proxy = ModelSetting.get('proxy_url')
f = ffmpeg.Ffmpeg(tmp,
filename,
plugin_id=-1,
listener=LogicBasic.ffmpeg_listener,
max_pf_count=max_pf_count,
call_plugin='wavve_basic',
save_path=save_path,
proxy=proxy)
#f.start_and_wait()
f.start()
#time.sleep(60)
return True
except Exception as e:
logger.error('Exception:%s', e)
logger.error(traceback.format_exc())
def main():
"""The main entrypoint for the plugin."""
try:
api_token = dronecli.get('API_TOKEN')
account_id = dronecli.get('PLUGIN_ACCOUNT_ID')
esg_name = dronecli.get('PLUGIN_ESG_NAME')
adjustment_type = dronecli.get('PLUGIN_ADJUSTMENT_TYPE', default='count')
adjustment = dronecli.get('PLUGIN_ADJUSTMENT', default=1)
plugin = SpotinstEsgScaler(
api_token=api_token,
account_id=account_id,
esg_name=esg_name,
adjustment_type=adjustment_type,
adjustment=adjustment
)
logger.info("The drone plugin has been initialized with: {}".format(plugin))
plugin.setup()
except Exception as e:
logger.error("Error while executing the plugin: {}".format(e))
raise e
sys.exit(1)
def post(self):
try:
req = self.request
protocol = req.protocol
host = req.host
method = req.method
uri = req.uri
urigroups = uri.split('/')
if urigroups[1] == "errorpage":
path = self.get_argument("path")
sc = urigroups[2]
if sc == "404":
reason = "<h1>Not Found</h1><p>The requested URL %s was not found on this server.</p>" % path
else:
reason = "<h1>Internal Server Error</h1>"
self.set_status(int(sc))
self.write(reason)
self.finish()
return
except Exception, e:
self.set_status(500, "Internal Server Error!")
logger.error(
e.message, 'line %d (/apps/api/handlers.py)' %
(sys._getframe().f_lineno - 2))
self.finish()
return
def request(self, url, method='get'):
"""Make request to spotinst."""
headers = {
"Content-Type": "application/json",
"Authorization": "Bearer {}".format(self._api_token)
}
try:
r = None
if method == 'get':
r = requests.get(url=url, headers=headers)
elif method == 'post':
r = requests.post(url=url, headers=headers)
elif method == 'put':
r = requests.put(url=url, headers=headers)
else:
logger.error("{} is not supported by this fuction.")
sys.exit(1)
r_json = r.json()
r.raise_for_status()
return r_json['response']
except RequestException as e:
e_msg = "(-)"
try:
e_msg = r_json['response']['errors'][0]['message']
except Exception:
pass
logger.error("Error occured while making the following request: {} {} - Error details: {}".format(url, e, e_msg))
sys.exit(1)
def scheduler_start():
try:
interval = ModelSetting.get('auto_interval')
job = Job(package_name, package_name, interval,
Logic.scheduler_function, u"웨이브 최신 TV VOD 다운로드", True)
scheduler.add_job_instance(job)
except Exception as e:
logger.error('Exception:%s', e)
logger.error(traceback.format_exc())
def db_init():
try:
for key, value in Logic.db_default.items():
if db.session.query(ModelSetting).filter_by(key=key).count() == 0:
db.session.add(ModelSetting(key, value))
db.session.commit()
except Exception as e:
logger.error('Exception:%s', e)
logger.error(traceback.format_exc())
def plugin_load():
try:
logger.debug('%s plugin_load', package_name)
# DB 초기화
Logic.db_init()
# 편의를 위해 json 파일 생성
from plugin import plugin_info
Util.save_from_dict_to_json(plugin_info, os.path.join(os.path.dirname(__file__), 'info.json'))
except Exception as e:
logger.error('Exception:%s', e)
logger.error(traceback.format_exc())
def analyze_program_page(code, page):
try:
data = Wavve.vod_program_contents_programid(code, page=page)
return {
'url_type': 'program',
'page': page,
'code': code,
'data': data
}
except Exception as e:
logger.error('Exception:%s', e)
logger.error(traceback.format_exc())
def delete_item(form_data):
# noinspection PyBroadException
try:
db_conn = SSODBPool.connection()
db_cursor = db_conn.cursor()
db_cursor.execute("delete from sso_site_list where id = '%s'" %
form_data["id"])
db_conn.commit()
db_conn.close()
except Exception:
logger.error(traceback.format_exc())
return traceback.format_exc()
return 1
def login():
try:
credential = Wavve.do_login(ModelSetting.get('id'),
ModelSetting.get('pw'))
logger.info('Wavve Credential : %s', credential)
if credential is None:
return False
db.session.query(ModelSetting).filter_by(
key='credential').with_for_update().first().value = credential
db.session.commit()
return True
except Exception as e:
logger.error('Exception:%s', e)
logger.error(traceback.format_exc())
def login(force=False):
try:
if ModelSetting.get('credential') == '' or force:
credential = Wavve.do_login(ModelSetting.get('id'),
ModelSetting.get('pw'))
logger.info('Wavve Credential : %s', credential)
if credential is None:
return False
ModelSetting.set('credential', credential)
db.session.commit()
else:
pass
return True
except Exception as e:
logger.error('Exception:%s', e)
logger.error(traceback.format_exc())
def plugin_load():
try:
logger.debug('%s plugin_load', package_name)
# DB 초기화
Logic.db_init()
LogicBasic.login()
if ModelSetting.get('auto_start') == 'True':
Logic.scheduler_start()
# 편의를 위해 json 파일 생성
from plugin import plugin_info
Util.save_from_dict_to_json(
plugin_info,
os.path.join(os.path.dirname(__file__), 'info.json'))
except Exception as e:
logger.error('Exception:%s', e)
logger.error(traceback.format_exc())
def download_url(url, filename):
try:
save_path = ModelSetting.get('save_path')
max_pf_count = ModelSetting.get('max_pf_count')
f = ffmpeg.Ffmpeg(url,
filename,
plugin_id=-1,
listener=LogicBasic.ffmpeg_listener,
max_pf_count=max_pf_count,
call_plugin='wavve_basic',
save_path=save_path)
#f.start_and_wait()
f.start()
#time.sleep(60)
return True
except Exception as e:
logger.error('Exception:%s', e)
logger.error(traceback.format_exc())
def modify_content(form_data):
ret = check_form_data(form_data)
if ret != 1:
return ret
# noinspection PyBroadException
try:
db_conn = SSODBPool.connection()
db_cursor = db_conn.cursor()
db_cursor.execute(
"update sso_site_list set site_name = '%s', serial_number = '%s', url = '%s',"
"origins_permission = '%s',remark = '%s' where id = '%s'" %
(form_data["site_name"], form_data["serial_number"],
form_data["url"], form_data["origins_permission"],
form_data["remark"], form_data["id"]))
db_conn.commit()
db_conn.close()
except Exception:
logger.error(traceback.format_exc())
return traceback.format_exc()
return 1
class IndexHandler(BaseHandler):
def on_response(self, respnose):
if respnose.code != 200:
self.set_status(respnose.code, respnose.error.message)
else:
for k in respnose.headers:
self.set_header(k, respnose.headers.get(k))
self.write(respnose.body)
self.finish()
@tornado.web.asynchronous
def post(self):
try:
req = self.request
protocol = req.protocol
host = req.host
method = req.method
uri = req.uri
urigroups = uri.split('/')
if urigroups[1] == "errorpage":
path = self.get_argument("path")
sc = urigroups[2]
if sc == "404":
reason = "<h1>Not Found</h1><p>The requested URL %s was not found on this server.</p>" % path
else:
reason = "<h1>Internal Server Error</h1>"
self.set_status(int(sc))
self.write(reason)
self.finish()
return
except Exception, e:
self.set_status(500, "Internal Server Error!")
logger.error(
e.message, 'line %d (/apps/api/handlers.py)' %
(sys._getframe().f_lineno - 2))
self.finish()
return
try:
headers_o = req.headers
body_o = req.body
remote_ip = req.remote_ip
path = req.path
request_headers = req.headers
request_query = req.arguments
request_body = req.body
serviceName = request_headers.get("downstream-service-id", None)
except Exception, e:
self.set_status(500, "Internal Server Error!")
logger.error(
e.message, 'line %d (/apps/api/handlers.py)' %
(sys._getframe().f_lineno - 2))
self.finish()
return
def setting_save(req):
try:
flag_login = False
for key, value in req.form.items():
logger.debug('Key:%s Value:%s', key, value)
entity = db.session.query(ModelSetting).filter_by(
key=key).with_for_update().first()
if key == 'id' or key == 'pw':
if entity.value != value:
flag_login = True
if entity is not None:
entity.value = value
db.session.commit()
if flag_login:
if LogicBasic.login(force=True):
return 1
else:
return 2
return True
except Exception as e:
logger.error('Exception:%s', e)
logger.error(traceback.format_exc())
logger.error('key:%s value:%s', key, value)
return False
def sso_login():
if request.method == "GET":
app_server = request.args.get("AppServer", None)
srv_path = request.args.get("srv_path", "")
if app_server is None:
return "Hello World!"
app_server = check_app_server(app_server)
if app_server == 0:
return "Hello World!"
if session.get("token") is not None:
return redirect(app_server + "/" + srv_path + "?token=" +
session.get("token"))
return render_template("login.html",
app_server=app_server,
srv_path=srv_path)
elif request.method == "POST":
token = request.headers.get("Token")
if token is not None:
# the header contains token
token = rc4_decrypt(token, rc4_key)
redis_ret = check_token(token)
session.clear()
if redis_ret == 1:
# Token is valid
ret = query_user_info(token)
if ret == 2:
return jsonify({
"status": 200,
"retCode": 2
}) # The account doesn't exist
elif ret == 3:
return jsonify({
"status": 200,
"retCode": 3
}) # The account was blocked
else:
logger.info("Login success:" + token.split(":")[0])
return jsonify({
"status": 200,
"retCode": 1,
"name": ret[0],
"department": ret[1],
"department_id": ret[2],
"username": token.split(":")[0]
})
# Matched correct token
else:
set_session_expired(token)
return jsonify({
"status": 200,
"retCode": 4
}) # No match, login needed
else:
# the header doesn't contains token
form_data = json.loads(request.get_data().decode("utf-8"))
if "username" not in form_data or "password" not in form_data:
return jsonify({
"status": 200,
"retCode": 5
}) # No match, need login
username = form_data["username"]
password = form_data["password"]
if session.get("token") is not None:
# maybe from cross_origin
token = rc4_decrypt(session.get("token"), rc4_key)
if token.split(":")[0] == username:
redis_ret = check_token(token)
if redis_ret == 1:
logger.info("Send token to cross_origin:" + username)
return jsonify({
"status": 200,
"retCode": 1,
"token": session.get("token")
})
limit_counts = login_attempt_limit(username, method="get")
if limit_counts >= 5:
logger.info("Too many login attempts:" + username)
return jsonify({"status": 200, "retCode": 6})
ret = query_login(username, password)
logger.info("Attempt Login:"******"Internal Server Error")
return jsonify({"status": 200, "retCode": 4})
logger.info(
"Login fail: wrong account or password, current limit times="
+ str(limit_counts))
return jsonify({
"status": 200,
"retCode": 2,
"limit_counts": limit_counts
})
# Wrong username or password
elif ret == 3:
logger.info("Login fail: the account was blocked")
return jsonify({
"status": 200,
"retCode": 3
}) # The account was blocked
elif ret == 1:
token = username + ":" + session.sid
redis_ret = set_token(token)
token = rc4_encrypt(token, rc4_key)
if redis_ret != 1:
return jsonify({
"status": 200,
"retCode": 7
}) # Server Error
session["token"] = token
logger.info("Create token:" + username)
return jsonify({"status": 200, "retCode": 1, "token": token})
# Login success, create token
else:
return jsonify({"status": 200, "retCode": 4})
path = req.path
request_headers = req.headers
request_query = req.arguments
request_body = req.body
serviceName = request_headers.get("downstream-service-id", None)
except Exception, e:
self.set_status(500, "Internal Server Error!")
logger.error(
e.message, 'line %d (/apps/api/handlers.py)' %
(sys._getframe().f_lineno - 2))
self.finish()
return
if not serviceName:
self.set_status(500, "The request header resolution failed!")
logger.error(
"请求头解析失败!", 'line %d (/apps/api/handlers.py)' %
(sys._getframe().f_lineno - 2))
self.finish()
return
if not request_body:
request_body = {}
else:
try:
request_body = json.loads(request_body)
except:
request_body = {}
t = {}
for i in request_query:
t.setdefault(i, request_query[i][-1])
request_query = t
responseID, headers = checkMockMatch(serviceName, uri, request_headers,
def plugin_unload():
try:
logger.debug('%s plugin_unload', package_name)
except Exception as e:
logger.error('Exception:%s', e)
logger.error(traceback.format_exc())
def scheduler_stop():
try:
scheduler.remove_job(package_name)
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 scheduler_function():
try:
LogicRecent.scheduler_function()
except Exception as e:
logger.error('Exception:%s', e)
logger.error(traceback.format_exc())
