def ready(self):
from . import signal_handlers
from kubeops_api.models.setting import Setting
try:
Setting.subscribe_setting_change()
except Exception:
pass
def send_work_weixin_msg(user_message):
workWeixin = Setting.get_settings("workWeixin")
weixin = WorkWeiXin(corp_id=workWeixin['WEIXIN_CORP_ID'],
corp_secret=workWeixin['WEIXIN_CORP_SECRET'],
agent_id=workWeixin['WEIXIN_AGENT_ID'])
text = get_msg_content(user_message)
content = {'content': text}
token = get_work_weixin_token(False)
res = weixin.send_markdown_msg(receivers=user_message.receive,
content=content,
token=token)
if res.success:
user_message.receive_status = UserMessage.MESSAGE_RECEIVE_STATUS_SUCCESS
user_message.save()
elif res.data['errcode'] == 40014:
token = get_work_weixin_token(True)
res = weixin.send_markdown_msg(receivers=user_message.receive,
content=content,
token=token)
if res.success:
user_message.receive_status = UserMessage.MESSAGE_RECEIVE_STATUS_SUCCESS
user_message.save()
else:
logger.error(msg="send workweixin error message_id=" +
str(user_message.message_id) + "reason:" + str(res.data),
exc_info=True)
def get_work_weixin_token(force):
redis_cli = redis.StrictRedis(host=kubeoperator.settings.REDIS_HOST, port=kubeoperator.settings.REDIS_PORT)
if redis_cli.exists('WORK_WEIXIN_TOKEN') == False or force == True:
workWeixin = Setting.get_settings("workWeixin")
weixin = WorkWeiXin(corp_id=workWeixin['WEIXIN_CORP_ID'], corp_secret=workWeixin['WEIXIN_CORP_SECRET'],
agent_id=workWeixin['WEIXIN_AGENT_ID'])
result = weixin.get_token()
redis_cli.set('WORK_WEIXIN_TOKEN', result.data['access_token'], result.data['expires_in'])
return result.data['access_token']
else:
return redis_cli.get('WORK_WEIXIN_TOKEN')
def deploy_nfs(self):
playbook = self.playbook_set.get(name="nfs")
Logger.info('开始部署 NFS 服务')
package = Package.objects.first()
port = package.repo_port
settings = Setting.get_settings()
extra_vars = {"repo_port": port, "nfs_name": self.name}
extra_vars.update(settings)
thread = threading.Thread(target=self.execute_playbook,
args=(playbook, extra_vars))
thread.start()
def send_email(user_message):
setting_email = Setting.get_settings("email")
email = Email(address=setting_email['SMTP_ADDRESS'], port=setting_email['SMTP_PORT'],
username=setting_email['SMTP_USERNAME'], password=setting_email['SMTP_PASSWORD'])
res = email.send_html_mail(receiver=user_message.receive, title=user_message.message.title,
content=get_email_content(user_message))
if res.success:
user_message.receive_status = UserMessage.MESSAGE_RECEIVE_STATUS_SUCCESS
user_message.save()
else:
logger.error(msg="send email error message_id=" + str(user_message.message_id) + "reason:" + str(res.data),
exc_info=True)
def __init__(self):
self._conn = None
settings = Setting.get_settings(tab='ldap')
self.ldap_enable = settings.get("AUTH_LDAP_ENABLE", False)
if not self.ldap_enable:
return
self.bind_dn = settings.get("AUTH_LDAP_BIND_DN")
self.bind_password = settings.get("AUTH_LDAP_BIND_PASSWORD")
self.search_ou = settings.get("AUTH_LDAP_SEARCH_OU")
self.search_filter = settings.get("AUTH_LDAP_SEARCH_FILTER")
self.server_uri = settings.get("AUTH_LDAP_SERVER_URI")
self.attr_map = json.loads(settings.get("AUTH_LDAP_USER_ATTR_MAP"))
def send_ding_talk_msg(user_message):
setting_dingTalk = Setting.get_settings("dingTalk")
ding_talk = DingTalk(webhook=setting_dingTalk['DINGTALK_WEBHOOK'], secret=setting_dingTalk['DINGTALK_SECRET'])
text = get_msg_content(user_message)
content = {"title": user_message.message.title, "text": text}
res = ding_talk.send_markdown_msg(receivers=user_message.receive.split(','), content=content)
if res.success:
user_message.receive_status = UserMessage.MESSAGE_RECEIVE_STATUS_SUCCESS
user_message.save()
else:
logger.error(msg="send dingtalk error message_id=" + str(user_message.message_id) + "reason:" + str(res.data),
exc_info=True)
def send_email(self, message_id):
user_message = UserMessage.objects.get(
message_id=message_id,
send_type=UserMessage.MESSAGE_SEND_TYPE_EMAIL)
setting_email = Setting.get_settings("email")
email = Email(address=setting_email['SMTP_ADDRESS'],
port=setting_email['SMTP_PORT'],
username=setting_email['SMTP_USERNAME'],
password=setting_email['SMTP_PASSWORD'])
res = email.send_message(receiver=user_message.receive,
title=user_message.message.title,
content=user_message.message.content)
if res.success:
user_message.receive_status = UserMessage.MESSAGE_RECEIVE_STATUS_SUCCESS
user_message.save()
def send_ding_talk_msg(message_id):
user_message = UserMessage.objects.get(
message_id=message_id,
send_type=UserMessage.MESSAGE_SEND_TYPE_DINGTALK)
setting_dingTalk = Setting.get_settings("dingTalk")
ding_talk = DingTalk(webhook=setting_dingTalk['DINGTALK_WEBHOOK'],
secret=setting_dingTalk['DINGTALK_SECRET'])
res = ding_talk.send_markdown_msg(
receivers=user_message.receive.split(','),
content=get_msg_content(user_message))
if res.success:
user_message.receive_status = UserMessage.MESSAGE_RECEIVE_STATUS_SUCCESS
user_message.save()
else:
logger.error(msg="send dingtalk error message_id=" +
str(user_message.message_id) + "reason:" + str(res.data),
exc_info=True)
def post(self, request, *args, **kwargs):
settings = request.data
Setting.set_settings(settings)
return Response(settings, status=status.HTTP_201_CREATED)
def get(self, request, *args, **kwargs):
return JsonResponse(Setting.get_settings())
def start(self):
result = {"raw": {}, "summary": {}}
pre_deploy_execution_start.send(self.__class__, execution=self)
cluster = self.get_cluster()
settings = Setting.get_settings()
extra_vars = {
"cluster_name": cluster.name,
}
extra_vars.update(settings)
extra_vars.update(cluster.configs)
ignore_errors = False
return_running = False
if self.operation == "install":
logger.info(
msg="cluster: {} exec: {} ".format(cluster, self.operation))
cluster.change_status(Cluster.CLUSTER_STATUS_INSTALLING)
result = self.on_install(extra_vars)
cluster.change_status(Cluster.CLUSTER_STATUS_RUNNING)
elif self.operation == 'uninstall':
logger.info(
msg="cluster: {} exec: {} ".format(cluster, self.operation))
cluster.change_status(Cluster.CLUSTER_STATUS_DELETING)
result = self.on_uninstall(extra_vars)
cluster_monitor = ClusterMonitor(cluster)
cluster_monitor.delete_cluster_redis_data()
cluster.change_status(Cluster.CLUSTER_STATUS_READY)
elif self.operation == 'bigip-config':
logger.info(
msg="cluster: {} exec: {} ".format(cluster, self.operation))
ignore_errors = True
result = self.on_f5_config(extra_vars)
elif self.operation == 'upgrade':
logger.info(
msg="cluster: {} exec: {} ".format(cluster, self.operation))
cluster.change_status(Cluster.CLUSTER_STATUS_UPGRADING)
package_name = self.params.get('package', None)
package = Package.objects.get(name=package_name)
extra_vars.update(package.meta.get('vars'))
result = self.on_upgrade(extra_vars)
cluster.upgrade_package(package_name)
cluster.change_status(Cluster.CLUSTER_STATUS_RUNNING)
elif self.operation == 'scale':
logger.info(
msg="cluster: {} exec: {} ".format(cluster, self.operation))
ignore_errors = True
return_running = True
cluster.change_status(Cluster.CLUSTER_DEPLOY_TYPE_SCALING)
result = self.on_scaling(extra_vars)
cluster.exit_new_node()
cluster.change_status(Cluster.CLUSTER_STATUS_RUNNING)
elif self.operation == 'add-worker':
logger.info(
msg="cluster: {} exec: {} ".format(cluster, self.operation))
ignore_errors = True
return_running = True
cluster.change_status(Cluster.CLUSTER_DEPLOY_TYPE_SCALING)
result = self.on_add_worker(extra_vars)
cluster.exit_new_node()
cluster.change_status(Cluster.CLUSTER_STATUS_RUNNING)
elif self.operation == 'remove-worker':
logger.info(
msg="cluster: {} exec: {} ".format(cluster, self.operation))
ignore_errors = True
return_running = True
cluster.change_status(Cluster.CLUSTER_DEPLOY_TYPE_SCALING)
result = self.on_remove_worker(extra_vars)
if not result.get('summary', {}).get('success', False):
cluster.exit_new_node()
else:
node_name = self.params.get('node', None)
cluster.change_to()
node = Node.objects.get(name=node_name)
node.delete()
cluster.change_status(Cluster.CLUSTER_STATUS_RUNNING)
elif self.operation == 'restore':
logger.info(
msg="cluster: {} exec: {} ".format(cluster, self.operation))
cluster.change_status(Cluster.CLUSTER_STATUS_RESTORING)
cluster_backup_id = self.params.get('clusterBackupId', None)
result = self.on_restore(extra_vars, cluster_backup_id)
cluster.change_status(Cluster.CLUSTER_STATUS_RUNNING)
elif self.operation == 'backup':
logger.info(
msg="cluster: {} exec: {} ".format(cluster, self.operation))
cluster.change_status(Cluster.CLUSTER_STATUS_BACKUP)
cluster_storage_id = self.params.get('backupStorageId', None)
result = self.on_backup(extra_vars)
self.on_upload_backup_file(cluster_storage_id)
cluster.change_status(Cluster.CLUSTER_STATUS_RUNNING)
if not result.get('summary', {}).get('success', False):
if not ignore_errors:
cluster.change_status(Cluster.CLUSTER_STATUS_ERROR)
if return_running:
cluster.change_status(Cluster.CLUSTER_STATUS_RUNNING)
logger.error(msg=":cluster {} exec {} error".format(
cluster, self.operation),
exc_info=True)
post_deploy_execution_start.send(self.__class__,
execution=self,
result=result,
ignore_errors=ignore_errors)
return result
def start(self):
result = {"raw": {}, "summary": {}}
pre_deploy_execution_start.send(self.__class__, execution=self)
cluster = self.get_cluster()
settings = Setting.get_db_settings()
extra_vars = {
"cluster_name": cluster.name,
"cluster_domain": cluster.cluster_doamin_suffix
}
extra_vars.update(settings)
extra_vars.update(cluster.configs)
ignore_errors = False
return_running = False
message_client = MessageClient()
message = {
"item_id": cluster.item_id,
"title": self.get_operation_name(),
"content": "",
"level": "INFO",
"type": "SYSTEM"
}
try:
if self.operation == "install":
logger.info(msg="cluster: {} exec: {} ".format(cluster, self.operation))
cluster.change_status(Cluster.CLUSTER_STATUS_INSTALLING)
result = self.on_install(extra_vars)
cluster.change_status(Cluster.CLUSTER_STATUS_RUNNING)
elif self.operation == 'uninstall':
logger.info(msg="cluster: {} exec: {} ".format(cluster, self.operation))
cluster.change_status(Cluster.CLUSTER_STATUS_DELETING)
result = self.on_uninstall(extra_vars)
cluster.change_status(Cluster.CLUSTER_STATUS_READY)
kubeops_api.cluster_monitor.delete_cluster_redis_data(cluster.name)
elif self.operation == 'bigip-config':
logger.info(msg="cluster: {} exec: {} ".format(cluster, self.operation))
ignore_errors = True
result = self.on_f5_config(extra_vars)
elif self.operation == 'upgrade':
logger.info(msg="cluster: {} exec: {} ".format(cluster, self.operation))
cluster.change_status(Cluster.CLUSTER_STATUS_UPGRADING)
package_name = self.params.get('package', None)
package = Package.objects.get(name=package_name)
extra_vars.update(package.meta.get('vars'))
result = self.on_upgrade(extra_vars)
if result.get('summary', {}).get('success', False):
cluster.upgrade_package(package_name)
cluster.change_status(Cluster.CLUSTER_STATUS_RUNNING)
elif self.operation == 'scale':
logger.info(msg="cluster: {} exec: {} ".format(cluster, self.operation))
ignore_errors = True
return_running = True
cluster.change_status(Cluster.CLUSTER_DEPLOY_TYPE_SCALING)
result = self.on_scaling(extra_vars)
cluster.exit_new_node()
cluster.change_status(Cluster.CLUSTER_STATUS_RUNNING)
elif self.operation == 'add-worker':
logger.info(msg="cluster: {} exec: {} ".format(cluster, self.operation))
ignore_errors = True
return_running = True
cluster.change_status(Cluster.CLUSTER_DEPLOY_TYPE_SCALING)
result = self.on_add_worker(extra_vars)
cluster.exit_new_node()
cluster.change_status(Cluster.CLUSTER_STATUS_RUNNING)
elif self.operation == 'remove-worker':
logger.info(msg="cluster: {} exec: {} ".format(cluster, self.operation))
ignore_errors = True
return_running = True
cluster.change_status(Cluster.CLUSTER_DEPLOY_TYPE_SCALING)
result = self.on_remove_worker(extra_vars)
if not result.get('summary', {}).get('success', False):
cluster.exit_new_node()
else:
node_name = self.params.get('node', None)
cluster.change_to()
node = Node.objects.get(name=node_name)
node.delete()
cluster.change_status(Cluster.CLUSTER_STATUS_RUNNING)
elif self.operation == 'restore':
logger.info(msg="cluster: {} exec: {} ".format(cluster, self.operation))
cluster.change_status(Cluster.CLUSTER_STATUS_RESTORING)
cluster_backup_id = self.params.get('clusterBackupId', None)
result = self.on_restore(extra_vars, cluster_backup_id)
cluster.change_status(Cluster.CLUSTER_STATUS_RUNNING)
elif self.operation == 'backup':
logger.info(msg="cluster: {} exec: {} ".format(cluster, self.operation))
cluster.change_status(Cluster.CLUSTER_STATUS_BACKUP)
cluster_storage_id = self.params.get('backupStorageId', None)
result = self.on_backup(extra_vars)
self.on_upload_backup_file(cluster_storage_id)
cluster.change_status(Cluster.CLUSTER_STATUS_RUNNING)
if not result.get('summary', {}).get('success', False):
message['content'] = self.get_content(False)
message['level'] = 'WARNING'
if not ignore_errors:
cluster.change_status(Cluster.CLUSTER_STATUS_ERROR)
if return_running:
cluster.change_status(Cluster.CLUSTER_STATUS_RUNNING)
logger.error(msg=":cluster {} exec {} error".format(cluster, self.operation), exc_info=True)
else:
message['content'] = self.get_content(True)
message_client.insert_message(message)
except Exception as e:
logger.error(msg=":cluster {} exec {} error".format(cluster, self.operation), exc_info=True)
cluster.change_status(Cluster.CLUSTER_STATUS_ERROR)
message['content'] = self.get_content(False)
message['level'] = 'WARNING'
message_client.insert_message(message)
post_deploy_execution_start.send(self.__class__, execution=self, result=result, ignore_errors=ignore_errors)
return result
def post(self, request, *args, **kwargs):
params = request.query_params
tab = params.get("tab", None)
settings = request.data
Setting.set_settings(settings, tab)
return Response(settings, status=status.HTTP_201_CREATED)
def get(self, request, *args, **kwargs):
params = request.query_params
tab = params.get("tab", None)
return JsonResponse(Setting.get_settings(tab))
def ready(self):
from . import signal_handlers
from kubeops_api.models.setting import Setting
Setting.apply_settings()
