def check_cisco_authentication():
preferences = Preferences.get(DBSession(), current_user.id)
if preferences is not None:
if not is_empty(preferences.cco_username) and not is_empty(preferences.cco_password):
return jsonify({'status': 'OK'})
return jsonify({'status': 'Failed'})
def _init(self):
fee = self.problem.fee
self._filter_pay_requests(self.problem.payRequests, fee)
if is_empty(self._payRequests):
raise RuntimeError("No pay request")
amount = utils.get_tx_amount(self._payRequests, fee)
# utxos = utxos - cost of using it in tx
utxos = map(lambda v: v - fee * utils.inputSizeBytes,
self.problem.utxos)
utxos = filter(lambda v: v > 0, utxos)
utxos = filter(lambda v: v < amount, utxos)
utxos = list(utxos)
#utxos = sorted(utxos, reverse=True)
if is_empty(utxos):
raise RuntimeError("Insufficient funds")
if amount > sum(utxos):
raise RuntimeError("Insufficient funds")
solution = Solver._build_any_solution(utxos, amount, fee)
self.utxos = utxos
self.amount = amount
self.solution = solution
def img_files_flow_page(page, img_detail):
"""
图片文件流加载
:param page:
:param img_detail:
:return:
"""
page, pagination = img_detail.dao_find_page(page)
flow_img_details = []
for img_detail in pagination.items:
url = url_for('file.file_download',
id=img_detail.file_id,
md5_id=img_detail.file_md5)
if not img_detail.is_handle:
alt = '待处理'
elif is_not_empty(img_detail.img_type):
alt = img_detail.img_type.type_explain
else:
alt = img_detail.err_msg
flow_info = FlowInfo(url, url, alt, img_detail.file_id)
flow_img_details.append(flow_info)
flow_img_details_dict, errors = FlowInfoSchema().dump(flow_img_details,
many=True)
Assert.is_true(is_empty(errors), errors)
page_dict, page_errors = PageSchema().dump(page)
Assert.is_true(is_empty(page_errors), page_errors)
page_dict['data'] = flow_img_details_dict
return render_info(page_dict)
def mvsi(self, url, image_bs64):
"""
机动车销售发票OCR识别
:param url: OCR接口地址
:param image_bs64: 图片base64数据, base64编码后大小不超过10M。图片最小边不小于15像素，最长边不超过4096像素,
支持JPG/PNG/BMP/TIFF格式
:return:
"""
headers = {
'Content-Type': 'application/json',
'charset': 'UTF-8',
'X-Auth-Token': self.token
}
res = requests.post(url=url, data=json.dumps(obj={'image': image_bs64}), headers=headers)
res.encoding = encodes.Unicode.UTF_8.value
print(json.dumps(res.json(), indent=4, ensure_ascii=False))
if res is None or res.status_code != codes.ok:
mvsi_error, errors = MvsiResultSchema(only=MvsiResultSchema().only_error()).load(res.json())
Assert.is_true(is_empty(errors), errors)
return mvsi_error
mvsi_result, errors = MvsiResultSchema(only=MvsiResultSchema().only_success()).load(res.json().get('result'))
Assert.is_true(is_empty(errors), errors)
return mvsi_result
def get_host_list_by(db_session, platform, software_versions, region_ids, roles):
"""
:param platform: Host platform
:param software_versions: a list of software versions or 'ALL'
:param region_ids: a list of region ids or 'ALL'
:param roles: a list of roles or 'ALL'
:return: a list of hosts that satisfied the criteria.
"""
clauses = []
clauses.append(Host.software_platform == platform)
if 'ALL' not in software_versions:
clauses.append(Host.software_version.in_(software_versions))
if 'ALL' not in region_ids:
clauses.append(Host.region_id.in_(region_ids))
roles_list = [] if 'ALL' in roles else roles
# Retrieve relevant hosts
hosts = db_session.query(Host).filter(and_(*clauses)).order_by(Host.hostname.asc()).all()
host_list = []
for host in hosts:
# Match on selected roles given by the user
if not is_empty(roles_list):
if not is_empty(host.roles):
for role in host.roles.split(','):
if role in roles_list:
host_list.append(host)
break
else:
host_list.append(host)
return host_list
def api_get_distinct_host_roles(platform, software_versions, region_ids):
"""
software_versions may equal to 'ALL' or multiple software versions
region_ids may equal to 'ALL' or multiple region ids
"""
clauses = []
db_session = DBSession()
clauses.append(Host.software_platform == platform)
if 'ALL' not in software_versions:
clauses.append(Host.software_version.in_(software_versions.split(',')))
if 'ALL' not in region_ids:
clauses.append(Host.region_id.in_(region_ids.split(',')))
host_roles = db_session.query(Host.roles).filter(and_(*clauses)).distinct()
# Change a list of tuples to a list
# Example of roles_list = [u'PE Router', u'PE1,R0', u'PE1,PE4', u'PE2,R1', u'Core']
roles_list = [roles[0] for roles in host_roles if not is_empty(roles[0])]
# Collapses the comma delimited strings to list
roles_list = [] if is_empty(roles_list) else ",".join(roles_list).split(',')
# Make the list unique, then sort it
roles_list = sorted(list(set(roles_list)))
rows = []
for role in roles_list:
rows.append({'role': role})
return jsonify(**{'data': rows})
def lexer_label(text, asr_nlp_data):
"""
语义标签过滤
:param str text:
:param asr_nlp_data:
:return:
"""
_item = '<font id="{id}" class="{ne} lexer_font_show" color="{color}" ' \
'data-ne-title="{ne_title}" data-bg="{bg}" data-ed="{ed}" ' \
'data-onebest="{onebest}" data-speaker="{speaker}">{item}</font>'
_ne_key = 'ne_{0}'
if is_empty(asr_nlp_data) or is_empty(asr_nlp_data.items):
return text
ne_dict = {}
for item in asr_nlp_data.items:
lexer = AudioLexerNeModel().dao_get_by_code(item.ne) # type: AudioLexerNeModel
ne_key = '{' + _ne_key.format(str(item.byte_offset)) + '}'
text = text.replace(item.item, ne_key, 1)
ne_dict.update(
{_ne_key.format(str(item.byte_offset)): _item.format(
id=item.id,
ne=item.ne,
color=lexer.color,
ne_title=lexer.title,
item=item.item,
bg=asr_nlp_data.bg,
ed=asr_nlp_data.ed,
onebest=asr_nlp_data.onebest,
speaker=asr_nlp_data.speaker
)}
)
return text.format_map(ne_dict)
def update(self):
if mode['micro_battles']:
self.d['battle_just_ended'] = False
self.d['battle_won'] = False
if not utils.is_empty(self.d['deaths']):
for uid in self.d['deaths']:
self._remove_unit(uid)
if self._check_battle_ended(self.d['units_myself'],
self.d['units_enemy']):
# Ignore the killing of remaining units in that battle.
# This will be re-initialized anyway in the next frame.
break
if not mode['micro_battles'] or not self.d['battle_just_ended']:
if not mode['replay'] and self.d['frame'] is not None:
self._parse_unit()
if not utils.is_empty(self.d['deaths']):
for uid in self.d['deaths']:
self._remove_unit(uid)
self.d['deaths'] = None
if mode['micro_battles'] and self.d['waiting_for_restart']:
we = utils.is_empty(self.d['units_myself'])
ee = utils.is_empty(self.d['units_enemy'])
if not we and not ee: # We both have units
self.d['waiting_for_restart'] = False
def _init(self):
fee = self.problem.fee
self._filter_pay_requests(self.problem.payRequests, fee)
if is_empty(self._payRequests):
raise RuntimeError("No pay request")
# utxos = utxos - cost of using it in tx
utxos = map(lambda v: v - fee * utils.inputSizeBytes,
self.problem.utxos)
utxos = filter(lambda v: v > 0, utxos)
utxos = list(utxos)
if is_empty(utxos):
raise RuntimeError("Insufficient funds")
amount = utils.get_tx_amount(self._payRequests, fee)
if amount > sum(utxos):
raise RuntimeError("Insufficient funds")
largeUtxos = list(filter(lambda v: v >= amount, utxos))
if is_not_empty(largeUtxos):
minUtxo = min(largeUtxos)
change = minUtxo - amount
solution = Solution(change, [minUtxo],
utils.get_solution_expense(fee, change))
utxos = list(filter(lambda v: v < minUtxo, utxos))
else:
solution = Solver._build_solution_min_inputs_with_change(
utxos, amount, fee)
# solution - the best solution so far
if solution is None or len(solution.inputs) > self._inputCountMax:
raise RuntimeError("No solution")
self.utxos = utxos
self.amount = amount
self.solution = solution
def get_file_and_directory_dict(self, sub_directory=None):
result_list = []
is_reachable = False
if is_empty(sub_directory):
path = self.server.server_directory
else:
path = os.path.join(self.server.server_directory, sub_directory)
if os.path.exists(path):
for name in os.listdir(path):
file = dict()
if os.path.isfile(os.path.join(path, name)):
file['filename'] = name
file['is_directory'] = False
else:
file['filename'] = name if is_empty(sub_directory) else (sub_directory + os.sep + name)
file['is_directory'] = True
result_list.append(file)
is_reachable = True
return result_list, is_reachable
def check_cisco_authentication():
preferences = Preferences.get(DBSession(), current_user.id)
if preferences is not None:
if not is_empty(preferences.cco_username) and not is_empty(
preferences.cco_password):
return jsonify({'status': 'OK'})
return jsonify({'status': 'Failed'})
def server_repository_url(self):
"""
Return the server repository URL (TFTP/FTP) where the packages can be found.
tftp://223.255.254.254;VRF/auto/tftp-gud/sit
ftp://username:[email protected];VRF/remote/directory
"""
server_id = self.install_job.server_id
server = self.db_session.query(Server).filter(
Server.id == server_id).first()
if server is not None:
server_type = server.server_type
if server_type == ServerType.TFTP_SERVER:
tftp_string = 'tftp://'
url = '{}{}'.format(tftp_string,
server.server_url.replace(tftp_string, ''))
if not is_empty(server.vrf):
try:
pos = url.index('/', len(tftp_string))
except ValueError:
pos = len(url)
url = url[:pos] + ';' + server.vrf + url[pos:]
server_sub_directory = self.install_job.server_directory
if not is_empty(server_sub_directory):
url += '/' + server_sub_directory
return url
elif server_type == ServerType.FTP_SERVER or server_type == ServerType.SFTP_SERVER:
protocol = 'ftp' if server_type == ServerType.FTP_SERVER else 'sftp'
url = protocol + "://{}:{}@{}".format(
server.username, server.password, server.server_url)
if server_type == ServerType.FTP_SERVER and not is_empty(
server.vrf):
url = url + ";{}".format(server.vrf)
remote_directory = concatenate_dirs(
server.server_directory, self.install_job.server_directory)
if not is_empty(remote_directory):
url = url + "/{}".format(remote_directory)
return url
elif server_type == ServerType.SCP_SERVER:
# scp root:[email protected]:/home_directory destination_on_host
return "scp {}:{}@{}:{} {}".format(server.username,
server.password,
server.server_url,
server.server_directory,
server.destination_on_host)
elif server_type == ServerType.LOCAL_SERVER:
return server.server_url
return None
def upload_machine_information(self):
client = self.docker_client
current_status = status.Status.IDLE.value
client_containers_count = len(client.containers.list())
if client_containers_count == 0:
if not utils.is_empty(self.key):
current_status = status.Status.COMPLETE.value
# put.Put(self.key, 'result').put('/root/result', True)
else:
current_status = status.Status.IDLE.value
if client_containers_count > 0:
if utils.is_empty(self.key):
self.clean_docker()
current_status = status.Status.RUNNING.value
data = utils.get_device_info()
data['status_info'] = {'key': self.key, 'status': current_status}
data['mac'] = "machine_%s" % get_mac()
response = self.api.upload_machine_and_get_task(data)
print(data, response)
if type(response) is not list:
option = response.get('option')
project = response.get('project')
pivot = response.get('pivot')
key = None
if project is not None:
key = project.get('key')
if not utils.is_empty(key):
if option == 'init' and self.can_init:
self.can_init = False
clean_file()
create_directories()
get.Get(key).get('/root', True)
self.key = key
self.run_cmd_and_upload_result(pivot)
for container in client.containers.list():
# start_new_thread(cat_logs_in_background(container))
cat_logs_background_threading = CatContainerLog(
container, self)
cat_logs_background_threading.start()
# wait till the background thread is done
# cat_logs_background_threading.join()
elif option == 'cmd':
self.run_cmd_and_upload_result(pivot)
if option == 'clean':
self.clean_docker()
if not utils.is_empty(self.key):
put.Put(self.key, 'result').put('/root/result', True)
self.key = ''
self.can_init = True
def ldap_auth(system_option, username, password):
"""
Use LDAP server to authenticate the user.
ldap.set_option(ldap.OPT_X_TLS_REQUIRE_CERT, ldap.OPT_X_TLS_NEVER)
con = ldap.initialize("ldap://ds.cisco.com:389")
con.start_tls_s()
con.simple_bind_s(user, password)
or
ldap.set_option(ldap.OPT_X_TLS_REQUIRE_CERT, ldap.OPT_X_TLS_NEVER)
con = ldap.initialize("ldaps://ds.cisco.com")
con.simple_bind_s(user, password)
"""
# First check if LDAP authentication has been enabled
if not system_option.enable_ldap_auth:
return False
ldap_server_url = system_option.ldap_server_url
if is_empty(ldap_server_url):
raise CSMLDAPException(
"ldap_auth: The LDAP server URL is not specified.")
if is_empty(username) or is_empty(password):
raise CSMLDAPException(
"ldap_auth: The username or password is not specified.")
try:
import ldap
except ImportError:
raise CSMLDAPException("ldap_auth: Unable to import ldap")
ldap.set_option(ldap.OPT_X_TLS_REQUIRE_CERT, ldap.OPT_X_TLS_NEVER)
try:
con = ldap.initialize(ldap_server_url)
if 'cisco' in ldap_server_url and is_empty(
system_option.ldap_server_distinguished_names):
username = '******'.format(username)
if not is_empty(system_option.ldap_server_distinguished_names):
username = system_option.ldap_server_distinguished_names.format(
username)
con.bind_s(username, password)
return True
except ldap.INVALID_CREDENTIALS:
raise CSMLDAPException(
"ldap_auth: The username or password is incorrect.")
except ldap.LDAPError as e:
if type(e.message) == dict and e.message.has_key('desc'):
raise CSMLDAPException("ldap_auth: " + e.message['desc'])
else:
raise CSMLDAPException("ldap_auth() hit exception")
return False
def _check_battle_ended(self, units_myself, units_enemy):
if self.d['waiting_for_restart']:
return False
if utils.is_empty(units_myself) or utils.is_empty(units_enemy):
self.d['battle_just_ended'] = True
self.d['waiting_for_restart'] = True
self.d['last_battle_ended'] = self.d['frame_from_bwapi']
if not utils.is_empty(units_myself) or utils.is_empty(units_enemy):
self.d['battle_won'] = True
return True
return False
def authenticate(cls, query, username, password):
username = username.strip().lower()
db_session = DBSession()
# Authenticate with LDAP Server first
system_option = SystemOption.get(db_session)
ldap_authenticated = False
try:
if system_option.enable_ldap_auth and not is_empty(
username) and not is_empty(password):
ldap_authenticated = ldap_auth(system_option, username,
password)
except CSMLDAPException:
# logger.exception("authenticate hit exception")
pass
user = query(cls).filter(cls.username == username).first()
if ldap_authenticated:
if user is None:
# Create a LDAP user with initial granted privilege
user_privilege_list = get_user_privilege_list()
if system_option.ldap_default_user_privilege in user_privilege_list:
user_privilege = system_option.ldap_default_user_privilege
else:
user_privilege = UserPrivilege.VIEWER
user = create_user(db_session, username, password,
user_privilege, username, username)
return user, True
else:
# Update the password
if not is_empty(password):
user.password = password
db_session.commit()
if user is None:
return None, False
if not user.active:
return user, False
authenticated = user.check_password(password)
# This is for backward compatibility. Existing users before the feature "Use CSM Server User Credential"
# will need to have their password encrypted for device installation authentication.
if authenticated and is_empty(user.host_password):
user.host_password = password
db_session.commit()
return user, user.check_password(password)
def dict_add(id=None):
"""
添加字典页面
:param id:
:return:
"""
sys_dict = SysDict()
if is_empty(id):
sys_dict.sort = 10
else:
sys_dict = SysDict().dao_get(id)
sys_dict.sort = 10 if is_empty(sys_dict.sort) else sys_dict.sort + 10
return render_template('sys/dict/dict_add.html', dict=sys_dict)
def server_repository_url(self):
"""
Return the server repository URL (TFTP/FTP) where the packages can be found.
tftp://223.255.254.254;VRF/auto/tftp-gud/sit
ftp://username:[email protected];VRF/remote/directory
"""
server_id = self.install_job.server_id
server = self.db_session.query(Server).filter(Server.id == server_id).first()
if server is not None:
server_type = server.server_type
if server_type == ServerType.TFTP_SERVER:
tftp_string = 'tftp://'
url = '{}{}'.format(tftp_string, server.server_url.replace(tftp_string, ''))
if not is_empty(server.vrf):
try:
pos = url.index('/', len(tftp_string))
except ValueError:
pos = len(url)
url = url[:pos] + ';' + server.vrf + url[pos:]
server_sub_directory = self.install_job.server_directory
if not is_empty(server_sub_directory):
url += '/' + server_sub_directory
return url
elif server_type == ServerType.FTP_SERVER or server_type == ServerType.SFTP_SERVER:
protocol = 'ftp' if server_type == ServerType.FTP_SERVER else 'sftp'
url = protocol + "://{}:{}@{}".format(server.username, server.password, server.server_url)
if server_type == ServerType.FTP_SERVER and not is_empty(server.vrf):
url = url + ";{}".format(server.vrf)
remote_directory = concatenate_dirs(server.server_directory, self.install_job.server_directory)
if not is_empty(remote_directory):
url = url + "/{}".format(remote_directory)
return url
elif server_type == ServerType.SCP_SERVER:
# scp root:[email protected]:/home_directory destination_on_host
return "scp {}:{}@{}:{} {}".format(server.username, server.password, server.server_url,
server.server_directory, server.destination_on_host)
elif server_type == ServerType.LOCAL_SERVER:
return server.server_url
return None
def dao_get_all(self, is_dump=False):
"""
获取全部菜单列表 包括功能菜单
:param is_dump:
:return:
"""
menus = self.query.order_by(Menu.sort.asc()).all()
if is_dump:
if is_empty(menus):
return []
menus, errors = MenuSchema().dump(menus, many=True)
Assert.is_true(is_empty(errors), errors)
return menus
def authenticate(cls, query, username, password):
username = username.strip().lower()
db_session = DBSession()
# Authenticate with LDAP Server first
system_option = SystemOption.get(db_session)
ldap_authenticated = False
try:
if system_option.enable_ldap_auth and not is_empty(username) and not is_empty(password):
ldap_authenticated = ldap_auth(system_option, username, password)
except CSMLDAPException:
# logger.exception("authenticate hit exception")
pass
user = query(cls).filter(cls.username == username).first()
if ldap_authenticated:
if user is None:
# Create a LDAP user with initial granted privilege
user_privilege_list = get_user_privilege_list()
if system_option.ldap_default_user_privilege in user_privilege_list:
user_privilege = system_option.ldap_default_user_privilege
else:
user_privilege = UserPrivilege.VIEWER
user = create_user(db_session, username, password, user_privilege, username, username)
return user, True
else:
# Update the password
if not is_empty(password):
user.password = password
db_session.commit()
if user is None:
return None, False
if not user.active:
return user, False
authenticated = user.check_password(password)
# This is for backward compatibility. Existing users before the feature "Use CSM Server User Credential"
# will need to have their password encrypted for device installation authentication.
if authenticated and is_empty(user.host_password):
user.host_password = password
db_session.commit()
return user, user.check_password(password)
def asr_nlp(id):
"""
音频转写加词性分析
:param id:
:return:
"""
result = []
with open(
os.path.join('D:/AIData/音频转写', id, '{id}_lexer.txt'.format(id=id)),
'r') as f:
for line in f.readlines():
result.append(json.loads(line.strip('\n').replace("'", "\"")))
asr_nlp_datas, errors = AudioAsrNlp.AudioAsrNlpSchema().load(result,
many=True)
Assert.is_true(is_empty(errors), errors)
# 查询识别出的词性列表, 单词性
# ne_list = []
# for asr_nlp_data in asr_nlp_datas:
# if is_not_empty(asr_nlp_data.ne_list):
# ne_list.extend(asr_nlp_data.ne_list)
# audio_lexers = AudioLexerNeModel().dao_get_by_codes(ne_list)
# ***********************************
items = []
for asr_nlp_data in asr_nlp_datas:
for item in asr_nlp_data.items:
items.append(item)
audio_lexers = AudioLexerNeModel().dao_get_all()
for audio_lexer in audio_lexers:
audio_lexer.items = []
for item in items:
if audio_lexer.code == item.ne:
audio_lexer.items.append(item)
# 移除 item 为空的标签栏
for audio_lexer in audio_lexers.copy():
if is_empty(audio_lexer.items):
audio_lexers.remove(audio_lexer)
return render_template('audio/asr_nlp.html',
audio_src=url_for(
'static',
filename='songs/{id}.wav'.format(id=id)),
asr_nlp_datas=asr_nlp_datas,
audio_lexers=audio_lexers)
def ldap_auth(system_option, username, password):
"""
Use LDAP server to authenticate the user.
ldap.set_option(ldap.OPT_X_TLS_REQUIRE_CERT, ldap.OPT_X_TLS_NEVER)
con = ldap.initialize("ldap://ds.cisco.com:389")
con.start_tls_s()
con.simple_bind_s(user, password)
or
ldap.set_option(ldap.OPT_X_TLS_REQUIRE_CERT, ldap.OPT_X_TLS_NEVER)
con = ldap.initialize("ldaps://ds.cisco.com")
con.simple_bind_s(user, password)
"""
# First check if LDAP authentication has been enabled
if not system_option.enable_ldap_auth:
return False
ldap_server_url = system_option.ldap_server_url
if is_empty(ldap_server_url):
raise CSMLDAPException("ldap_auth: The LDAP server URL is not specified.")
if is_empty(username) or is_empty(password):
raise CSMLDAPException("ldap_auth: The username or password is not specified.")
try:
import ldap
except ImportError:
raise CSMLDAPException("ldap_auth: Unable to import ldap")
ldap.set_option(ldap.OPT_X_TLS_REQUIRE_CERT, ldap.OPT_X_TLS_NEVER)
try:
con = ldap.initialize(ldap_server_url)
if 'cisco' in ldap_server_url:
username = '******'.format(username)
con.bind_s(username, password)
return True
except ldap.INVALID_CREDENTIALS:
raise CSMLDAPException("ldap_auth: The username or password is incorrect.")
except ldap.LDAPError as e:
if type(e.message) == dict and e.message.has_key('desc'):
raise CSMLDAPException("ldap_auth: " + e.message['desc'])
else:
raise CSMLDAPException("ldap_auth hit exception")
return False
def dao_get_sub_menus(self, id, is_dump=False):
"""
根据ID获取全部子级菜单
:param id:
:param is_dump: 是否序列化字典(序列化尽量写在同一个方法，因为relationship的懒加载机制，结合缓存会报Session异常)
:return:
"""
menus = self.query.filter(Menu.parent_id == id).order_by(Menu.sort.asc()).all()
if is_dump:
if is_empty(menus):
return []
menus, errors = MenuSchema().dump(menus, many=True)
Assert.is_true(is_empty(errors), errors)
return menus
def empty(o):
"""
判断是否为空
:param o:
:return:
"""
return True if is_empty(o) else False
def create_app(config_name=None):
"""
工厂函数
:param config_name:
:return:
"""
if is_empty(config_name) or config_name not in [env.value for env in Env]:
config_name = os.getenv('FLASK_CONFIG', Env.DEVELOPMENT.value)
app = Flask(import_name=__name__)
# 加载配置
app.config.from_object(obj=config[config_name])
# 注册JSON解析器
app.json_encoder = JSONEncoder
# 注册日志
app.logger.addHandler(init_log(app.config.get('PROJECT_NAME', None), app.config.get('LOGGER_LEVER', None)))
# 注册扩展
register_extensions(app)
# 注册蓝本
register_blueprints(app)
# 注册错误处理函数
register_errors(app)
# 注册shell上下文处理函数
register_shell_context(app)
# 注册模板上下文处理函数
register_template_context(app)
# 注册模板过滤器
register_template_filter(app)
# 注册模板测试器
register_template_test(app)
return app
def api_get_distinct_host_regions(platform, software_versions):
"""
software_versions may equal to 'ALL' or multiple software versions
"""
clauses = []
db_session = DBSession()
clauses.append(Host.software_platform == platform)
if 'ALL' not in software_versions:
clauses.append(Host.software_version.in_(software_versions.split(',')))
region_ids = db_session.query(Host.region_id).filter(and_(*clauses)).distinct()
# Change a list of tuples to a list
region_ids_list = [region_id[0] for region_id in region_ids]
rows = []
if not is_empty(region_ids):
regions = db_session.query(Region).filter(Region.id.in_(region_ids_list)). \
order_by(Region.name.asc()).all()
for region in regions:
rows.append({'region_id': region.id, 'region_name': region.name})
return jsonify(**{'data': rows})
def dao_find_page(self, page, error_out=False):
"""
分页条件查询
:param page:
:param error_out:
:return:
"""
# 条件查询
filter = []
if is_not_empty(self.type):
filter.append(SysDict.type == self.type)
if is_not_empty(self.description):
filter.append(
SysDict.description.like(
'%{description}%'.format(description=self.description)))
pagination = self.query.filter(*filter).\
order_by(SysDict.sort.asc(), SysDict.type.asc(), SysDict.create_date.asc()).\
paginate(page=page.page, per_page=page.page_size, error_out=error_out)
page.init_pagination(pagination)
# 数据序列化 json
data_dict, errors = SysDictSchema().dump(page.data, many=True)
Assert.is_true(is_empty(errors), errors)
page.data = data_dict
return page, pagination
def user_preferences():
db_session = DBSession()
form = PreferencesForm(request.form)
user = get_user_by_id(db_session, current_user.id)
if request.method == 'POST' and form.validate():
user.preferences[0].cco_username = form.cco_username.data
if len(form.cco_password.data) > 0:
user.preferences[0].cco_password = form.cco_password.data
# All the checked checkboxes (i.e. platforms and releases to exclude).
values = request.form.getlist('check')
excluded_platform_list = ','.join(values)
preferences = Preferences.get(db_session, current_user.id)
preferences.excluded_platforms_and_releases = excluded_platform_list
db_session.commit()
return redirect(url_for('home'))
else:
preferences = user.preferences[0]
form.cco_username.data = preferences.cco_username
if not is_empty(user.preferences[0].cco_password):
form.password_placeholder = 'Use Password on File'
else:
form.password_placeholder = 'No Password Specified'
return render_template(
'cco/preferences.html',
form=form,
platforms_and_releases=get_platforms_and_releases_dict(db_session))
def get_download_job_json_dict(db_session, download_jobs):
rows = []
for download_job in download_jobs:
if isinstance(download_job, DownloadJob) or isinstance(
download_job, DownloadJobHistory):
row = dict()
row['download_job_id'] = download_job.id
row['image_name'] = download_job.cco_filename
row['scheduled_time'] = download_job.scheduled_time
server = get_server_by_id(db_session, download_job.server_id)
if server is not None:
row['server_repository'] = server.hostname
if not is_empty(download_job.server_directory):
row['server_repository'] = row['server_repository'] + \
'<br><span style="color: Gray;"><b>Sub-directory:</b></span> ' + \
download_job.server_directory
else:
row['server_repository'] = UNKNOWN
row['status'] = download_job.status
row['status_time'] = download_job.status_time
row['created_by'] = download_job.created_by
if download_job.trace is not None:
row['trace'] = download_job.id
rows.append(row)
return {'data': rows}
def create_or_update_region(db_session, region_name, server_repositories, created_by, region=None):
"""
:param db_session:
:param name:
:param server_repositories:
assumes server_repositories is a comma-delimited string of valid server names that exist in CSM
:param region:
:return:
"""
region_name = check_acceptable_string(region_name)
if region is None:
region = Region(created_by=created_by)
db_session.add(region)
region.name = region_name
region.servers = []
if not is_empty(server_repositories):
for server_name in server_repositories.split(','):
valid_server = get_server(db_session, server_name.strip())
if valid_server is not None:
region.servers.append(valid_server)
else:
raise ValueNotFound("Server repository '{}' does not exist in the database.".format(server_name))
db_session.commit()
return region
def create_or_restore(path: Path):
"""Prepared IMDB datasets from raw files, or loads previously saved objects
into memory.
"""
datasets_dir = path / 'aclImdb' / 'datasets'
if datasets_dir.exists() and not is_empty(datasets_dir):
print('Loading data from %s' % datasets_dir)
datasets = {}
for filename in datasets_dir.glob('*.pickle'):
datasets[filename.stem] = IMDB.load(filename)
else:
print('Creating folder %s' % datasets_dir)
datasets_dir.mkdir(parents=True, exist_ok=True)
print('Tokenizing supervised data (sentiment classification)')
train_sup = IMDB(path,
supervised=True,
train=True,
tokenizer=tokenize_in_parallel,
make_vocab=Vocab.make_vocab)
test_sup = IMDB(path,
supervised=True,
train=False,
tokenizer=tokenize_in_parallel,
vocab=train_sup.vocab)
print('Tokenizing unsupervised data (language model)')
train_unsup = IMDB(path,
supervised=False,
train=True,
tokenizer=tokenize_in_parallel,
make_vocab=Vocab.make_vocab)
test_unsup = IMDB(path,
supervised=False,
train=False,
tokenizer=tokenize_in_parallel,
vocab=train_unsup.vocab)
datasets = {
'train_sup': train_sup,
'test_sup': test_sup,
'train_unsup': train_unsup,
'test_unsup': test_unsup
}
for name, dataset in datasets.items():
print(f'Saving dataset {name}')
dataset.save(datasets_dir / f'{name}.pickle')
for name, dataset in datasets.items():
print(f'{name} vocab size: {dataset.vocab.size}')
return datasets
def get_translations(text, src_lang):
# TODO fix dictionary map for all languages
dmap = {
'ru': 'english-russian',
'fr': 'english-french',
'de': 'english-german',
}
txt = text.replace(' ', '-')
for lang, dictionary in dmap.items():
url = f'{base}/dictionary/{dictionary}/{txt}'
resp = requests.get(url, headers=headers)
resp.raise_for_status()
soup = BeautifulSoup(resp.text, 'html.parser')
for sense in soup.find_all('div', class_='sense-body'):
phrase = sense.find('div', class_='phrase-block')
if phrase: continue
trans = sense.find('span', class_='trans')
if trans:
words = stripped_text(trans).split(',')
words = [w for w in words if not is_empty(w)]
for word in words:
term = Term(text=word, lang=lang, region=None)
yield ('translated_as', term)
def dao_find_page(self, page, error_out=False):
"""
分页条件查询
:param page:
:param error_out:
:return:
"""
# 条件查询
filter = []
if is_not_empty(self.img_data_id):
filter.append(ImgDetailModel.img_data_id == self.img_data_id)
if is_not_empty(self.is_handle):
filter.append(ImgDetailModel.is_handle == self.is_handle)
pagination = self.query.filter(*filter).\
order_by(ImgDetailModel.create_date.desc()).\
paginate(page=page.page, per_page=page.page_size, error_out=error_out)
page.init_pagination(pagination)
# 数据序列化 json
img_detail_dict, errors = ImgDetailSchema(
only=ImgDetailSchema().dump_only_page()).dump(page.data, many=True)
Assert.is_true(is_empty(errors), errors)
page.data = img_detail_dict
return page, pagination
def api_get_server_repositories(request):
validate_url_parameters(request, [KEY_HOSTNAME])
rows = []
db_session = DBSession()
hostname = request.args.get(KEY_HOSTNAME)
if hostname:
server = get_server(db_session, hostname)
if server is None:
raise ValueError("Server repository '{}' does not exist in the database.".format(hostname))
servers = [server]
else:
servers = get_server_list(db_session)
for server in servers:
if server is not None:
row = dict()
row[KEY_HOSTNAME] = server.hostname
row[KEY_SERVER_TYPE] = server.server_type
for req in params_dict[server.server_type]:
row[req] = server.__getattribute__(req) if server.__getattribute__(req) is not None else ''
row[server_url_dict[server.server_type]] = server.server_url
if not is_empty(server_directory_dict[server.server_type]):
row[server_directory_dict[server.server_type]] = server.server_directory
rows.append(row)
return jsonify(**{RESPONSE_ENVELOPE: {'server_repository_list': rows}})
def user_preferences():
db_session = DBSession()
form = PreferencesForm(request.form)
user = get_user_by_id(db_session, current_user.id)
if request.method == 'POST' and form.validate():
user.preferences[0].cco_username = form.cco_username.data
if len(form.cco_password.data) > 0:
user.preferences[0].cco_password = form.cco_password.data
# All the checked checkboxes (i.e. platforms and releases to exclude).
values = request.form.getlist('check')
excluded_platform_list = ','.join(values)
preferences = Preferences.get(db_session, current_user.id)
preferences.excluded_platforms_and_releases = excluded_platform_list
db_session.commit()
return redirect(url_for('home'))
else:
preferences = user.preferences[0]
form.cco_username.data = preferences.cco_username
if not is_empty(user.preferences[0].cco_password):
form.password_placeholder = 'Use Password on File'
else:
form.password_placeholder = 'No Password Specified'
return render_template('cco/preferences.html', form=form,
platforms_and_releases=get_platforms_and_releases_dict(db_session))
def create_or_update_region(db_session,
region_name,
server_repositories,
created_by,
region=None):
"""
:param db_session:
:param name:
:param server_repositories:
assumes server_repositories is a comma-delimited string of valid server names that exist in CSM
:param region:
:return:
"""
region_name = check_acceptable_string(region_name)
if region is None:
region = Region(created_by=created_by)
db_session.add(region)
region.name = region_name
region.servers = []
if not is_empty(server_repositories):
for server_name in server_repositories.split(','):
valid_server = get_server(db_session, server_name.strip())
if valid_server is not None:
region.servers.append(valid_server)
else:
raise ValueNotFound(
"Server repository '{}' does not exist in the database.".
format(server_name))
db_session.commit()
return region
def api_get_custom_command_profiles(request):
"""
GET:
http://localhost:5000/api/v1/custom_command_profiles
http://localhost:5000/api/v1/custom_command_profiles?profile_name=Profile_1
"""
validate_url_parameters(request, [KEY_PROFILE_NAME])
rows = []
db_session = DBSession
profile_name = request.args.get(KEY_PROFILE_NAME)
if profile_name:
ccp = get_custom_command_profile(db_session, profile_name)
if ccp is None:
raise ValueError("Custom command profile '{}' does not exist in the database.".format(profile_name))
ccps = [ccp]
else:
ccps = get_custom_command_profile_list(db_session)
for ccp in ccps:
if ccp is not None:
row = dict()
row[KEY_PROFILE_NAME] = ccp.profile_name
row[KEY_COMMAND_LIST] = [] if is_empty(ccp.command_list) else ccp.command_list.split(',')
row[KEY_CREATED_BY] = ccp.created_by
rows.append(row)
return jsonify(**{RESPONSE_ENVELOPE: {'custom_command_profile_list': rows}})
def api_get_reload_list():
"""
Given a software package/SMU/SP list, return those
that require router reload.
"""
# The software packages/SMUs/SPs selected by the user to install
package_list = request.args.get('package_list').split()
rows = []
if not is_empty(package_list):
# Identify the platform and release
platform, release = SMUInfoLoader.get_platform_and_release(package_list)
if platform != UNKNOWN and release != UNKNOWN:
smu_loader = SMUInfoLoader(platform, release)
if smu_loader.is_valid:
for package_name in package_list:
if 'mini' in package_name:
rows.append({'entry': package_name, 'description': ''})
else:
# Strip the suffix
smu_info = smu_loader.get_smu_info(package_name.replace('.' + smu_loader.file_suffix, ''))
if smu_info is not None:
if "Reload" in smu_info.impact or "Reboot" in smu_info.impact:
rows.append({'entry': package_name, 'description': smu_info.description})
return jsonify(**{'data': rows})
def write_header_info(self):
self.ws.write(0, 2, 'Software Conformance Report', self.style_title)
report_datetime = get_datetime_string(self.conformance_report.created_time) + \
' UTC' if self.locale_datetime is None else self.locale_datetime
self.ws.write(1, 2, report_datetime, self.style_center)
self.ws.write(4, 0, 'Summary: ', self.style_bold)
total_hosts = 0 if is_empty(self.conformance_report.hostnames) else \
len(self.conformance_report.hostnames.split(','))
self.ws.write(6, 0, 'Total Hosts: %d' % total_hosts, self.style_summary)
self.ws.write(7, 0, 'Match Criteria: ' + (self.conformance_report.match_criteria + ' packages').title(),
self.style_summary)
self.ws.write(8, 0, 'Results:', self.style_summary)
if self.conformance_report.host_not_in_conformance == 0:
self.ws.write(9, 0, " All hosts are in complete conformance", self.style_summary)
else:
self.ws.write(9, 0, " %d %s in complete conformance (see the 'Missing Packages' column)"
% (self.conformance_report.host_not_in_conformance,
"hosts are not" if self.conformance_report.host_not_in_conformance > 1 else "host is not"),
self.style_summary)
if self.conformance_report.host_out_dated_inventory > 0:
self.ws.write(10, 0, " %d %s failed last software inventory retrieval (see '*' in the 'Is Conformed' column)"
% (self.conformance_report.host_out_dated_inventory,
"hosts" if self.conformance_report.host_out_dated_inventory > 1 else "host"),
self.style_summary)
def api_get_reload_list():
"""
Given a software package/SMU/SP list, return those
that require router reload.
"""
# The software packages/SMUs/SPs selected by the user to install
package_list = request.args.get('package_list').split()
rows = []
if not is_empty(package_list):
# Identify the platform and release
platform, release = SMUInfoLoader.get_platform_and_release(
package_list)
if platform != UNKNOWN and release != UNKNOWN:
smu_loader = SMUInfoLoader(platform, release)
if smu_loader.is_valid:
for package_name in package_list:
if 'mini' in package_name:
rows.append({'entry': package_name, 'description': ''})
else:
# Strip the suffix
smu_info = smu_loader.get_smu_info(
package_name.replace('.' + smu_loader.file_suffix,
''))
if smu_info is not None:
if "Reload" in smu_info.impact or "Reboot" in smu_info.impact:
rows.append({
'entry': package_name,
'description': smu_info.description
})
return jsonify(**{'data': rows})
def _next_record(self):
'''
# Read and return the cropped samples corresponding to pixels for each mask.
# Input: envoked in a loop on an hsi_reader object.
# Output: -array of samples of size: number of masked pixels x crop_size x crop_size x bands
# -list of labels of size: 1 x pixels
# -number of read samples
# -index of read pixels
'''
if utils.is_empty(self.__cur_data) or \
(self.__mask_idx == self.__num_masks):
if not self._next_file():
return None
self.__mask_idx = 0
self.__data_idx == 0
if self.__npixels:
return self._loadbatch()
else:
if self.__balance:
return self._load_balanced_data()
else:
return self._load_data()
def check_reachability(self):
error = None
is_reachable = False
if not SFTP_SUPPORTED:
error = 'SFTP supported libraries have not been installed.'
else:
try:
with pysftp.Connection(self.server.server_url, username=self.server.username, password=self.server.password) as sftp:
if not is_empty(self.server.server_directory):
sftp.chdir(self.server.server_directory)
is_reachable = True
except Exception as e:
error = e.strerror if is_empty(e.message) else e.message
logger.exception('SFTPServer hit exception - ' + error)
return is_reachable, error
def make_urls(self, preferred_host_username=None, preferred_host_password=None):
urls = []
if len(self.host.connection_param) > 0:
connection = self.host.connection_param[0]
jump_host_url = ''
# Checks if there is a jump server
if connection.jump_host_id is not None:
try:
jump_host = self.db_session.query(JumpHost).filter(JumpHost.id == connection.jump_host_id).first()
if jump_host is not None:
jump_host_url = make_url(
connection_type=jump_host.connection_type,
host_username=jump_host.username,
host_password=jump_host.password,
host_or_ip=jump_host.host_or_ip,
port_number=jump_host.port_number)
except:
pass
host_username = connection.username
host_password = connection.password
if not is_empty(preferred_host_username) and not is_empty(preferred_host_password):
host_username = preferred_host_username
host_password = preferred_host_password
else:
system_option = SystemOption.get(self.db_session)
if system_option.enable_default_host_authentication:
if not is_empty(system_option.default_host_username) and not is_empty(system_option.default_host_password):
if system_option.default_host_authentication_choice == DefaultHostAuthenticationChoice.ALL_HOSTS or \
(system_option.default_host_authentication_choice ==
DefaultHostAuthenticationChoice.HOSTS_WITH_NO_SPECIFIED_USERNAME_AND_PASSWORD and
is_empty(host_username) and
is_empty(host_password)):
host_username = system_option.default_host_username
host_password = system_option.default_host_password
for host_or_ip in connection.host_or_ip.split(','):
for port_number in connection.port_number.split(','):
host_urls = []
if not is_empty(jump_host_url):
host_urls.append(jump_host_url)
host_urls.append(make_url(
connection_type=connection.connection_type,
host_username=host_username,
host_password=host_password,
host_or_ip=host_or_ip,
port_number=port_number,
enable_password=connection.enable_password))
urls.append(host_urls)
return urls
def server_repository_url(self):
"""
Return the server repository URL (TFTP/FTP) where the packages can be found.
tftp://223.255.254.254/auto/tftp-gud/sit;VRF
ftp://username:[email protected];VRF/remote/directory
"""
server_id = self.install_job.server_id
server = self.db_session.query(Server).filter(Server.id == server_id).first()
if server is not None:
server_type = server.server_type
if server_type == ServerType.TFTP_SERVER:
url = 'tftp://{}'.format(server.server_url.replace('tftp://',''))
if not is_empty(server.vrf):
url = url + ";{}".format(server.vrf)
server_sub_directory = self.install_job.server_directory
if not is_empty(server_sub_directory):
url += '/' + server_sub_directory
return url
elif server_type == ServerType.FTP_SERVER or server_type == ServerType.SFTP_SERVER:
protocol = 'ftp' if server_type == ServerType.FTP_SERVER else 'sftp'
url = protocol + "://{}:{}@{}".format(server.username, server.password, server.server_url)
if not is_empty(server.vrf):
url = url + ";{}".format(server.vrf)
remote_directory = concatenate_dirs(server.server_directory, self.install_job.server_directory)
if not is_empty(remote_directory):
url = url + "/{}".format(remote_directory)
return url
elif server_type == ServerType.LOCAL_SERVER:
return server.server_url
return None
def get_install_jobs(table_to_query, db_session, clauses):
if not is_empty(clauses):
if db_session.query(table_to_query.id).filter(and_(*clauses)).count() > 5000:
raise ValueError("Too many results; please refine your request.")
else:
return db_session.query(table_to_query).filter(and_(*clauses)).\
order_by(table_to_query.id.asc()).all()
else:
if db_session.query(table_to_query.id).count() > 5000:
raise ValueError("Too many results; please refine your request.")
else:
return db_session.query(table_to_query).order_by(table_to_query.id.asc()).all()
def api_get_conformance_report_summary(id):
db_session = DBSession()
conformance_report = get_conformance_report_by_id(db_session, id)
if conformance_report is not None:
return jsonify(**{'data': [
{'total_hosts': 0 if is_empty(conformance_report.hostnames) else len(conformance_report.hostnames.split(',')),
'host_not_in_conformance': conformance_report.host_not_in_conformance,
'host_out_dated_inventory': conformance_report.host_out_dated_inventory,
'match_criteria': (conformance_report.match_criteria + ' Packages').title()}
]})
else:
return jsonify({'status': 'Failed'})
def api_get_session_log_file_diff():
diff_file_path = request.args.get("diff_file_path")
if is_empty(diff_file_path):
return jsonify({'status': 'diff file is missing.'})
file_diff_contents = ''
with io.open(os.path.join(get_log_directory(), diff_file_path), "rt", encoding='latin-1') as fo:
file_diff_contents = fo.read()
data = [{'file_diff_contents': file_diff_contents}]
return jsonify(**{'data': data})
def get_doc_central_log_path(install_job):
"""
This method is used to support SIT Doc Central feature
:param install_job: must be an install job history instance
:return: The aggregated path
"""
doc_central_log_file_path = ''
if install_job.install_action == InstallAction.POST_UPGRADE and not is_empty(install_job.load_data('doc_central_log_file_path')):
path = os.path.join(get_doc_central_directory(), install_job.load_data('doc_central_log_file_path'))
if os.path.isfile(path):
doc_central_log_file_path = path
return doc_central_log_file_path
def check_reachability(self):
error = None
is_reachable = False
try:
ftp = ftplib.FTP(self.server.server_url, user=self.server.username, passwd=self.server.password)
if not is_empty(self.server.server_directory):
ftp.cwd(self.server.server_directory)
is_reachable = True
except Exception as e:
error = e.message
return is_reachable, error
def get_last_operation_id(db_session, install_activate_job, trace=None):
operation_id = -1
if install_activate_job.install_action == InstallAction.ACTIVATE:
install_add_job = get_last_successful_install_job(db_session, install_activate_job.host_id)
if install_add_job is not None:
# Check if Last Install Add and Activate have the same packages.
# If they have, then return the operation id.
install_add_packages = install_add_job.packages.split(',') if not is_empty(install_add_job.packages) else []
install_activate_packages = install_activate_job.packages.split(',') if not is_empty(install_activate_job.packages) else []
if len(install_add_packages) == len(install_activate_packages):
for install_activate_package in install_activate_packages:
if install_activate_package not in install_add_packages:
return operation_id
return install_add_job.operation_id
return operation_id
def get_smu_or_sp_list(hostname, hide_installed_packages, smu_info_list, file_suffix):
"""
Return the SMU/SP list. If hostname is given, compare its active packages.
"""
file_list = get_file_list(get_repository_directory(), '.' + file_suffix)
host_packages = [] if hostname is None else get_host_active_packages(hostname)
rows = []
for smu_info in smu_info_list:
# Verify if the package has already been installed.
installed = False
for host_package in host_packages:
if smu_info.name in host_package:
installed = True
break
include = False if (hide_installed_packages == 'true' and installed) else True
if include:
row = dict()
row['ST'] = 'True' if smu_info.name + '.' + file_suffix in file_list else 'False'
row['package_name'] = smu_info.name + '.' + file_suffix
row['posted_date'] = smu_info.posted_date.split()[0]
row['ddts'] = smu_info.ddts
row['ddts_url'] = BUG_SEARCH_URL + smu_info.ddts
row['type'] = smu_info.type
row['description'] = smu_info.description
row['impact'] = smu_info.impact
row['functional_areas'] = smu_info.functional_areas
row['id'] = smu_info.id
row['name'] = smu_info.name
row['status'] = smu_info.status
row['package_bundles'] = smu_info.package_bundles
row['compressed_image_size'] = smu_info.compressed_image_size
row['uncompressed_image_size'] = smu_info.uncompressed_image_size
row['is_installed'] = installed
if not is_empty(hostname) and SMU_INDICATOR in smu_info.name:
row['is_applicable'] = is_smu_applicable(host_packages, smu_info.package_bundles)
else:
row['is_applicable'] = True
rows.append(row)
return jsonify(**{'data': rows})
def get_last_operation_id(self, db_session, install_activate_job, trace=None):
if install_activate_job.install_action == InstallAction.INSTALL_ACTIVATE:
install_add_job = get_last_completed_install_job_for_install_action(db_session,
install_activate_job.host_id,
InstallAction.INSTALL_ADD)
if install_add_job is not None:
# Check if Last Install Add and Activate have the same packages.
# If they have, then return the operation id.
install_add_packages = install_add_job.packages.split(',') if not is_empty(install_add_job.packages) else []
install_activate_packages = install_activate_job.packages.split(',') if not is_empty(install_activate_job.packages) else []
if len(install_add_packages) == len(install_activate_packages):
for install_activate_package in install_activate_packages:
if install_activate_package not in install_add_packages:
return -1
return install_add_job.operation_id
return -1
def is_smu_applicable(host_packages, required_package_bundles):
"""
Only SMU should go through this logic
The package_bundles defined must be satisfied for the SMU to be applicable.
However,asr9k-fpd-px can be excluded.
"""
if not is_empty(required_package_bundles):
package_bundles = required_package_bundles.split(',')
package_bundles = [p for p in package_bundles if p != 'asr9k-fpd-px']
count = 0
for package_bundle in package_bundles:
for host_package in host_packages:
if package_bundle in host_package:
count += 1
break
if count != len(package_bundles):
return False
return True
def api_get_install_history(hostname):
if not can_retrieve_software(current_user):
abort(401)
rows = []
db_session = DBSession()
host = get_host(db_session, hostname)
if host is not None:
install_jobs = db_session.query(InstallJobHistory). \
filter((InstallJobHistory.host_id == host.id),
and_(InstallJobHistory.install_action == InstallAction.INSTALL_ADD,
InstallJobHistory.status == JobStatus.COMPLETED)).\
order_by(InstallJobHistory.status_time.desc())
for install_job in install_jobs:
if not is_empty(install_job.packages):
row = {}
row['packages'] = install_job.packages
row['status_time'] = install_job.status_time
row['created_by'] = install_job.created_by
rows.append(row)
return jsonify(**{'data': rows})
def get_smu_info(smu_info):
row = dict()
row['id'] = smu_info.id
row['name'] = smu_info.name
row['status'] = smu_info.status
row['type'] = smu_info.type
row['posted_date'] = smu_info.posted_date
row['ddts'] = smu_info.ddts
row['description'] = smu_info.description
row['functional_areas'] = [] if is_empty(smu_info.functional_areas) else smu_info.functional_areas.split(',')
row['impact'] = smu_info.impact
row['package_bundles'] = [] if is_empty(smu_info.package_bundles) else smu_info.package_bundles.split(',')
row['compressed_image_size'] = str(smu_info.compressed_image_size)
row['uncompressed_image_size'] = str(smu_info.uncompressed_image_size)
row['prerequisites'] = [] if is_empty(smu_info.prerequisites) else smu_info.prerequisites.split(',')
row['supersedes'] = [] if is_empty(smu_info.supersedes) else smu_info.supersedes.split(',')
row['superseded_by'] = [] if is_empty(smu_info.superseded_by) else smu_info.superseded_by.split(',')
row['composite_DDTS'] = [] if is_empty(smu_info.composite_DDTS) else smu_info.composite_DDTS.split(',')
return row
def home():
if current_user.privilege != UserPrivilege.ADMIN:
abort(401)
db_session = DBSession()
smtp_form = SMTPForm(request.form)
admin_console_form = AdminConsoleForm(request.form)
smtp_server = get_smtp_server(db_session)
system_option = SystemOption.get(db_session)
fill_user_privileges(admin_console_form.ldap_default_user_privilege.choices)
if request.method == 'POST' and \
smtp_form.validate() and \
admin_console_form.validate():
if smtp_server is None:
smtp_server = SMTPServer()
db_session.add(smtp_server)
smtp_server.server = smtp_form.server.data
smtp_server.server_port = smtp_form.server_port.data if len(smtp_form.server_port.data) > 0 else None
smtp_server.sender = smtp_form.sender.data
smtp_server.use_authentication = smtp_form.use_authentication.data
smtp_server.username = smtp_form.username.data
if len(smtp_form.password.data) > 0:
smtp_server.password = smtp_form.password.data
smtp_server.secure_connection = smtp_form.secure_connection.data
system_option.inventory_threads = admin_console_form.num_inventory_threads.data
system_option.install_threads = admin_console_form.num_install_threads.data
system_option.download_threads = admin_console_form.num_download_threads.data
system_option.can_schedule = admin_console_form.can_schedule.data
system_option.can_install = admin_console_form.can_install.data
system_option.enable_email_notify = admin_console_form.enable_email_notify.data
system_option.enable_inventory = admin_console_form.enable_inventory.data
# The LDAP UI may be hidden if it is not supported.
# In this case, the flag is not set.
if not is_empty(admin_console_form.enable_ldap_auth.data):
system_option.enable_ldap_auth = admin_console_form.enable_ldap_auth.data
system_option.ldap_server_url = admin_console_form.ldap_server_url.data
system_option.ldap_default_user_privilege = admin_console_form.ldap_default_user_privilege.data
system_option.ldap_server_distinguished_names = admin_console_form.ldap_server_distinguished_names.data.strip()
system_option.inventory_hour = admin_console_form.inventory_hour.data
system_option.inventory_history_per_host = admin_console_form.inventory_history_per_host.data
system_option.download_history_per_user = admin_console_form.download_history_per_user.data
system_option.install_history_per_host = admin_console_form.install_history_per_host.data
system_option.total_system_logs = admin_console_form.total_system_logs.data
system_option.enable_default_host_authentication = admin_console_form.enable_default_host_authentication.data
system_option.default_host_authentication_choice = admin_console_form.default_host_authentication_choice.data
system_option.enable_cco_lookup = admin_console_form.enable_cco_lookup.data
system_option.use_utc_timezone = admin_console_form.use_utc_timezone.data
system_option.default_host_username = admin_console_form.default_host_username.data
if len(admin_console_form.default_host_password.data) > 0:
system_option.default_host_password = admin_console_form.default_host_password.data
system_option.enable_user_credential_for_host = admin_console_form.enable_user_credential_for_host.data
db_session.commit()
return redirect(url_for('home'))
else:
admin_console_form.num_inventory_threads.data = system_option.inventory_threads
admin_console_form.num_install_threads.data = system_option.install_threads
admin_console_form.num_download_threads.data = system_option.download_threads
admin_console_form.can_schedule.data = system_option.can_schedule
admin_console_form.can_install.data = system_option.can_install
admin_console_form.enable_email_notify.data = system_option.enable_email_notify
admin_console_form.enable_ldap_auth.data = system_option.enable_ldap_auth
admin_console_form.ldap_server_url.data = system_option.ldap_server_url
admin_console_form.ldap_default_user_privilege.data = system_option.ldap_default_user_privilege
admin_console_form.ldap_server_distinguished_names.data = system_option.ldap_server_distinguished_names
admin_console_form.enable_inventory.data = system_option.enable_inventory
admin_console_form.inventory_hour.data = system_option.inventory_hour
admin_console_form.inventory_history_per_host.data = system_option.inventory_history_per_host
admin_console_form.download_history_per_user.data = system_option.download_history_per_user
admin_console_form.install_history_per_host.data = system_option.install_history_per_host
admin_console_form.total_system_logs.data = system_option.total_system_logs
admin_console_form.enable_default_host_authentication.data = system_option.enable_default_host_authentication
admin_console_form.default_host_authentication_choice.data = system_option.default_host_authentication_choice
admin_console_form.default_host_username.data = system_option.default_host_username
admin_console_form.enable_cco_lookup.data = system_option.enable_cco_lookup
admin_console_form.use_utc_timezone.data = system_option.use_utc_timezone
admin_console_form.cco_lookup_time.data = get_datetime_string(system_option.cco_lookup_time)
admin_console_form.enable_user_credential_for_host.data = system_option.enable_user_credential_for_host
if not is_empty(system_option.default_host_password):
admin_console_form.default_host_password_placeholder = 'Use Password on File'
else:
admin_console_form.default_host_password_placeholder = 'No Password Specified'
if smtp_server is not None:
smtp_form.server.data = smtp_server.server
smtp_form.server_port.data = smtp_server.server_port
smtp_form.sender.data = smtp_server.sender
smtp_form.use_authentication.data = smtp_server.use_authentication
smtp_form.username.data = smtp_server.username
smtp_form.secure_connection.data = smtp_server.secure_connection
if not is_empty(smtp_server.password):
smtp_form.password_placeholder = 'Use Password on File'
else:
smtp_form.password_placeholder = 'No Password Specified'
return render_template('admin/index.html',
admin_console_form=admin_console_form,
smtp_form=smtp_form,
system_option=SystemOption.get(db_session),
is_ldap_supported=is_ldap_supported())
def cco_filename(self):
# Somehow,PIMS did not fill in the cco_filename
if is_empty(self._cco_filename):
return self.name + '.tar'
return self._cco_filename
def handle_schedule_install_form(request, db_session, hostname, install_job=None):
host = get_host(db_session, hostname)
if host is None:
abort(404)
return_url = get_return_url(request, 'host_dashboard.home')
form = HostScheduleInstallForm(request.form)
# Retrieves all the install jobs for this host. This will allow
# the user to select which install job this install job can depend on.
install_jobs = db_session.query(InstallJob).filter(
InstallJob.host_id == host.id).order_by(InstallJob.scheduled_time.asc()).all()
region_servers = host.region.servers
# Returns all server repositories if the region does not have any server repository designated.
if is_empty(region_servers):
region_servers = get_server_list(db_session)
# Fills the selections
fill_servers(form.server_dialog_server.choices, region_servers)
fill_servers(form.server_modal_dialog_server.choices, region_servers)
fill_servers(form.cisco_dialog_server.choices, region_servers, False)
fill_dependency_from_host_install_jobs(form.dependency.choices, install_jobs,
(-1 if install_job is None else install_job.id))
fill_custom_command_profiles(db_session, form.custom_command_profile.choices)
if request.method == 'POST':
if install_job is not None:
# In Edit mode, the install_action UI on HostScheduleForm is disabled (not allow to change).
# Thus, there will be no value returned by form.install_action.data. So, re-use the existing ones.
install_action = [install_job.install_action]
else:
install_action = form.install_action.data
scheduled_time = form.scheduled_time_UTC.data
software_packages = form.software_packages.data.split()
server_id = form.hidden_server.data
server_directory = form.hidden_server_directory.data
pending_downloads = form.hidden_pending_downloads.data.split()
custom_command_profile_ids = [str(i) for i in form.custom_command_profile.data]
# install_action is a list object which may contain multiple install actions.
# If only one install_action, accept the selected dependency if any
if len(install_action) == 1:
dependency = int(form.dependency.data)
create_or_update_install_job(db_session=db_session, host_id=host.id, install_action=install_action[0],
scheduled_time=scheduled_time, software_packages=software_packages,
server_id=server_id, server_directory=server_directory,
pending_downloads=pending_downloads,
custom_command_profile_ids=custom_command_profile_ids, dependency=dependency,
created_by=current_user.username, install_job=install_job)
else:
# The dependency on each install action is already indicated in the implicit ordering in the selector.
# If the user selected Pre-Upgrade and Install Add, Install Add (successor) will
# have Pre-Upgrade (predecessor) as the dependency.
dependency = 0
for one_install_action in install_action:
new_install_job = create_or_update_install_job(db_session=db_session,
host_id=host.id,
install_action=one_install_action,
scheduled_time=scheduled_time,
software_packages=software_packages, server_id=server_id,
server_directory=server_directory,
pending_downloads=pending_downloads,
custom_command_profile_ids=custom_command_profile_ids,
dependency=dependency, created_by=current_user.username,
install_job=install_job)
dependency = new_install_job.id
return redirect(url_for(return_url, hostname=hostname))
elif request.method == 'GET':
# Initialize the hidden fields
form.hidden_server.data = -1
form.hidden_selected_hosts.data = ''
form.hidden_server_name.data = ''
form.hidden_server_directory.data = ''
form.hidden_pending_downloads.data = ''
form.hidden_edit.data = install_job is not None
# In Edit mode
if install_job is not None:
form.install_action.data = install_job.install_action
if install_job.server_id is not None:
form.hidden_server.data = install_job.server_id
server = get_server_by_id(db_session, install_job.server_id)
if server is not None:
form.hidden_server_name.data = server.hostname
form.hidden_server_directory.data = '' if install_job.server_directory is None else install_job.server_directory
form.hidden_pending_downloads.data = '' if install_job.pending_downloads is None else install_job.pending_downloads
# Form a line separated list for the textarea
if install_job.packages is not None:
form.software_packages.data = '\n'.join(install_job.packages.split(','))
form.dependency.data = str(install_job.dependency)
if install_job.scheduled_time is not None:
form.scheduled_time_UTC.data = get_datetime_string(install_job.scheduled_time)
if install_job.custom_command_profile_ids:
ids = [int(id) for id in install_job.custom_command_profile_ids.split(',')]
form.custom_command_profile.data = ids
return render_template('host/schedule_install.html', form=form, system_option=SystemOption.get(db_session),
host=host, server_time=datetime.datetime.utcnow(), install_job=install_job,
return_url=return_url)
