def code_rollback_process(request,
template_name='saltstack/code_rollback_form.html'):
global status
form = RollBackForm(request.POST or None)
if form.is_valid():
project = form.cleaned_data['repository_name'].repo_tag
zone_name = form.cleaned_data['zones'].name
deploy_path = form.cleaned_data['deploy_path'].path_value
backup_package = form.cleaned_data['backup_package'].backup_path
print backup_package
rollback_script = '/data/agent_scripts/rollback.sh'
if form.cleaned_data['use_zone']:
deploy_abs_path = os.path.join(deploy_path,
(project + '_' + zone_name))
else:
deploy_abs_path = os.path.join(deploy_path, project)
shell_command = "sh %s %s %s" % (rollback_script, backup_package,
deploy_abs_path)
data = {
'expr_form': 'list',
'client': form.cleaned_data['client'],
'tgt': [server.host_name for server in form.cleaned_data['tgt']],
'fun': 'cmd.run',
'arg': shell_command,
}
print data
salt = SaltApi()
salt.get_token()
header = salt.get_header()
context = process(header, **data)
# print context
for item in form.cleaned_data['tgt']:
if regex_match_error(
yaml.load(context)['return'][0][item.host_name]):
status = True
else:
status = False
new_form = form.save(commit=False)
new_form.context = context
new_form.rollback_package = backup_package
new_form.fun = 'cmd.run'
new_form.operate = request.session['username']
new_form.status = status
new_form.save()
form.save()
return redirect('code_rollback_list')
return render(
request, template_name, {
'highlight12': 'active',
'username': request.session['username'],
'form': form,
'var7': 'active',
})
def running_command(command):
shell_command = '%s' % command
try:
result = subprocess.check_output(shell_command,
stderr=subprocess.STDOUT,
shell=True)
if regex_match_error(result):
return True
except subprocess.CalledProcessError:
return False
def system_user_add(request, template_name='saltstack/system_user_form.html'):
form = SystemUserAddForm(request.POST or None)
hosts = []
if form.is_valid():
for item in form.cleaned_data['tgt']:
print item.host_name
hosts.append(item.host_name)
data = {
'expr_form': 'list',
'client': form.cleaned_data['client'],
'tgt': hosts,
'fun': form.cleaned_data['fun'],
'arg': [form.cleaned_data['user'], 'home=%s' %
os.path.join(form.cleaned_data['home'], form.cleaned_data['user']),
'shell=%s' % dict(form.fields['shell'].choices)[form.cleaned_data['shell']]]
}
print data
salt = SaltApi()
salt.get_token()
header = salt.get_header()
context = process(header, **data)
if regex_match_error(context):
status = True
else:
status = False
new_form = form.save(commit=False)
new_form.context = context
new_form.status = status
new_form.operate = request.session['username']
new_form.home = os.path.join(form.cleaned_data['home'], form.cleaned_data['user'])
new_form.save()
form.save()
for item in form.cleaned_data['tgt']:
# print form.cleaned_data['user']
user_info = SysUser.objects.filter(sys_user=form.cleaned_data['user'])
if not user_info:
user_object = SysUser(sys_user=form.cleaned_data['user'], servers_id=item.id)
user_object.save()
# get_sys_user = SysUser.objects.get(sys_user=form.cleaned_data['user'])
# Assets.objects.filter(host_name=item.host_name).update(sys_users=get_sys_user)
else:
return HttpResponse("user already exist.")
# get_sys_user = SysUser.objects.get(sys_user=form.cleaned_data['user'], servers=item)
# Assets.objects.filter(host_name=item.host_name).update(sys_users=get_sys_user)
return redirect('system_user_list')
return render(request, template_name, {'form': form,
'username': request.session['username'],
'var7': 'active',
'highlight8': 'active'})
def services_handle_process(request,
template_name='saltstack/services_handle_form.html'
):
servers = Assets.objects.all()
departments = Department.objects.all()
services = Services.objects.all()
form = ServicesHandleForm(request.POST or None)
if form.is_valid():
data = {
'expr_form': 'list',
'client': form.cleaned_data['client'],
'fun': form.cleaned_data['fun'],
'tgt': [item.host_name for item in form.cleaned_data['tgt'].all()],
'arg': form.cleaned_data['services'].name,
}
salt = SaltApi()
salt.get_token()
header = salt.get_header()
context = process(header, **data)
if regex_match_error(context):
status = True
else:
status = False
new_form = form.save(commit=False)
new_form.context = context
new_form.status = status
new_form.operate = request.session['username']
new_form.save()
form.save()
return redirect('services_handle_list')
return render(
request, template_name, {
'highlight4': 'active',
'username': request.session['username'],
'form': form,
'servers': servers,
'departments': departments,
'services': services,
'var7': 'active'
})
def system_user_del(request, template_name='saltstack/system_user_form.html'):
form = SystemUserDelForm(request.POST or None)
hosts = []
if form.is_valid():
for item in form.cleaned_data['tgt']:
hosts.append(item.host_name)
data = {
'expr_form': 'list',
'client': form.cleaned_data['client'],
'tgt': hosts,
'fun': form.cleaned_data['fun'],
'arg': [form.cleaned_data['user'], 'remove=True', 'force=True']
}
print data
salt = SaltApi()
salt.get_token()
header = salt.get_header()
context = process(header, **data)
print context
if regex_match_error(context):
status = True
else:
status = False
new_form = form.save(commit=False)
new_form.context = context
new_form.status = status
new_form.operate = request.session['username']
new_form.home = os.path.join(form.cleaned_data['home'], form.cleaned_data['user'])
new_form.save()
form.save()
for item in form.cleaned_data['tgt']:
# server_info = Assets.objects.get(host_name=item.host_name)
# server_info.sys_users.remove(SysUser.objects.get(sys_user=form.cleaned_data['user']))
SysUser.objects.filter(servers_id=item.id, sys_user=form.cleaned_data['user']).delete()
return redirect('system_user_list')
return render(request, template_name, {'form': form,
'username': request.session['username'],
'var7': 'active',
'highlight8': 'active'})
def yum_install_soft_process(request, template_name='saltstack/yum_install_soft_form.html'):
form = PackageInstallForm(request.POST or None)
server_list = []
if form.is_valid():
skip_verify = 'False'
refresh = 'False'
for item in form.cleaned_data['tgt']:
server_list.append(item.host_name)
data = {
'expr_form': 'list',
'client': 'local',
'fun': form.cleaned_data['fun'],
'tgt': server_list,
'arg': [form.cleaned_data['yum_package_name'], refresh, skip_verify]
}
print data
salt = SaltApi()
salt.get_token()
header = salt.get_header()
context = process(header, **data)
if regex_match_error(json.dumps(context)):
status = True
else:
status = False
new_form = form.save(commit=False)
new_form.status = status
new_form.context = context
new_form.operate = request.session['username']
new_form.save()
form.save()
return redirect('yum_install_soft_record')
return render(request, template_name, {'form': form,
'var7': 'active',
'highlight10': 'active',
'username': request.session['username'],
})
def push_process(request, template_name='saltstack/file_push_form.html'):
form = PushForm(request.POST or None)
servers = Assets.objects.all().order_by('alias_name')
departments = Department.objects.all()
zones = Zone.objects.all()
files = Produce.objects.all()
if form.is_valid():
# department = form.cleaned_data['departments'].name
zone = form.cleaned_data['zones'].name
domain = form.cleaned_data['domains'].name
service = form.cleaned_data['service_name']
service_name = dict(form.fields['service_name'].choices)[service]
file_name = form.cleaned_data['file_name']
source_path = form.cleaned_data['source_path']
target_path = form.cleaned_data['target_path'].path_value
generate_file = zone + '_' + file_name
conf_templates_path = os.path.join('/srv/salt/service_config/templates', service_name)
conf_generate_path = os.path.join('/srv/salt/service_config/', zone, service_name)
if not os.path.exists(conf_generate_path):
makedir_p(conf_generate_path)
commands = "sh /data/deploy/OMS/saltstack/scripts/shell/replace_service_conf.sh %s %s %s %s %s %s" % \
(file_name, generate_file, domain, zone, conf_templates_path, conf_generate_path)
# 生成新配置文件
running_command(commands)
salt_file_storage = os.path.join(source_path, zone, service_name, generate_file)
print salt_file_storage
target_abs_path = os.path.join(target_path, generate_file)
print target_abs_path
template = 'jinja'
env = 'base'
makedirs = False
data = {
'expr_form': 'list',
'client': form.cleaned_data['client'],
'fun': 'cp.get_template',
'tgt': [item.host_name for item in form.cleaned_data['tgt'].all()],
'arg': [salt_file_storage, target_abs_path, template, env, makedirs],
}
print data
salt = SaltApi()
salt.get_token()
header = salt.get_header()
context = process(header, **data)
print context
if regex_match_error(context):
status = True
else:
status = False
print status
new_form = form.save(commit=False)
new_form.context = context
new_form.source_path = salt_file_storage
new_form.file_name = target_abs_path
new_form.status = status
new_form.operate = request.session['username']
new_form.save()
form.save()
return redirect('file_push_list')
return render(request, template_name, {'highlight3': 'active',
'username': request.session['username'],
'form': form,
'servers': servers,
'departments': departments,
'zones': zones,
'files': files,
'var7': 'active',
})
def merge_server_process(request,
template_name='saltstack/merge_server_form.html'):
departments = Department.objects.all()
zones = Zone.objects.all()
# repo_object = Repository.objects.filter(repo_tag=u'war_data')
repo_object = Repository.objects.all()
assets = Assets.objects.all()
war_object = Assets.objects.filter(tag__name='War')
chat_object = Assets.objects.filter(tag__name='Chat')
web_object = Assets.objects.filter(tag__name='Web')
zone_list = []
form = MergeServersForm(request.POST or None)
if form.is_valid():
information = {}
context = {}
war_server_id = form.cleaned_data['data_server']
chat_server_id = form.cleaned_data['chat_server']
war_servers = Assets.objects.filter(id=war_server_id)
for item in war_servers:
information['{{WAR_DATA_HOST}}'] = item.alias_name
information['{{WAR_DATA_ADDR}}'] = item.networks.private_address
information['{{REDIS_ADDR}}'] = item.networks.private_address
chat_servers = Assets.objects.filter(id=chat_server_id)
for item in chat_servers:
information['{{CHAT_PUBLIC_ADDR}}'] = item.networks.public_address
information[
'{{CHAT_PRIVATE_ADDR}}'] = item.networks.private_address
information['{{CHAT_HOST}}'] = item.alias_name
project_list = ['war_data', 'pxqb_base', 'pxqb_login']
merge_path = form.cleaned_data['merge_path']
# print merge_path
if not os.path.exists(merge_path):
makedir_p(merge_path)
merge_zones = form.cleaned_data['merge_zones']
for zone in merge_zones:
zone_list.append(zone.name)
zone_shell_array = ' '.join(zone_list)
# print zone_shell_array
merge_name = '_'.join(zone_list)
# print merge_name
deploy_path = '/data/deploy'
source_path = '/srv/salt/app_config'
# 合并、复制、生成新配置
for project_name in project_list:
if project_name == 'war_data':
script = "sh /data/deploy/OMS/saltstack/scripts/shell/merge_config_file.sh '%s' '%s' '%s' '%s' '%s'" \
% (source_path, merge_path, zone_shell_array, merge_name, project_name)
# print script
running_command(script)
if project_name == 'pxqb_base':
project_abs_path = os.path.join(merge_path, merge_name,
project_name, 'config')
if not os.path.exists(project_abs_path):
makedir_p(project_abs_path)
# 合并conf.allserver.php文件
file_list = []
for zone in zone_list:
file_list.append('%s/%s/%s/config/conf.allserver.php' %
(source_path, zone, project_name))
# print file_list
one_file = file_list[0]
do_copy_new_file(one_file, merge_name)
file_list.pop(0)
# print file_list
merge_all_server(file_list, merge_name)
# 生成新dataserver.php文件
dataserver_file = '/data/deploy/OMS/media/Upload/conf.dataserver.php'
merge_target_file = '/srv/salt/merge_config/%s/pxqb_base/config/conf.dataserver.php' % merge_name
execute_replace(information, dataserver_file,
merge_target_file)
if project_name == 'pxqb_login':
for zone in zone_list:
full_project_name = project_name + '_' + zone
copy_target_path = os.path.join(merge_path, merge_name)
if not os.path.exists(copy_target_path):
makedir_p(copy_target_path)
script = "sh /data/deploy/OMS/saltstack/scripts/shell/copy_pxqb_login_config.sh %s %s %s" \
% (full_project_name, copy_target_path, zone)
# print script
running_command(script)
# 同步配置
project_tmp = project_list
for project_name in project_list:
if project_name == 'pxqb_login':
for zone in zone_list:
project_tmp.append(project_name + '_' + zone)
project_tmp.remove('pxqb_login')
for project_name in project_tmp:
salt_abs_url = 'salt://merge_config/%s/%s' % (merge_name,
project_name)
data = {
'expr_form': 'list',
'client': 'local',
'fun': 'cp.get_dir',
'tgt':
[item.host_name for item in form.cleaned_data['tgt'].all()],
'arg': [salt_abs_url, deploy_path],
}
# print data
salt = SaltApi()
salt.get_token()
header = salt.get_header()
context['%s' % project_name] = process(header, **data)
print context['%s' % project_name]
print context
if regex_match_error(json.dumps(context)):
status = True
else:
status = False
new_form = form.save(commit=False)
new_form.operate = request.session['username']
new_form.status = status
new_form.chat_server = information['{{CHAT_HOST}}']
new_form.data_server = information['{{WAR_DATA_HOST}}']
new_form.context = json.dumps(context)
new_form.save()
form.save()
return redirect('merge_server_list')
return render(
request, template_name, {
'highlight13': 'active',
'username': request.session['username'],
'form': form,
'var7': 'active',
'repo_object': repo_object,
'assets': assets,
'zones': zones,
'departments': departments,
'war_object': war_object,
'web_object': web_object,
'chat_object': chat_object,
})
def code_release(request, template_name='saltstack/code_release_form.html'):
form = ReleaseForm(request.POST or None)
servers = Assets.objects.all()
departments = Department.objects.all()
zones = Zone.objects.all()
repo = Repository.objects.all()
deploy_path = Path.objects.all()
global status
if form.is_valid():
repo_name = form.cleaned_data['repository_name']
result = Repository.objects.filter(repo_name__contains=repo_name)[0]
if result.repo_protocol == '3':
repository_url = 'https://%s:%s@%s' % (result.repo_user, result.repo_pass, result.repo_address)
elif result.repo_protocol == '2':
repository_url = 'http://%s:%s@%s' % (result.repo_user, result.repo_pass, result.repo_address)
else:
repository_url = '%s@%s' % (result.repo_user, result.repo_address)
project_name = form.cleaned_data['repository_name'].repo_tag
zone_name = form.cleaned_data['zones'].name
deploy_path = form.cleaned_data['deploy_path'].path_value
release_path = form.cleaned_data['release_path'].path_value
# versions = form.cleaned_data['versions']
# version = versions.version
# version_id = versions.id
print project_name, zone_name, release_path
if form.cleaned_data['use_zone']:
deploy_abs_path = os.path.join(deploy_path, (project_name + '_' + zone_name))
release_abs_path = release_path + '_' + zone_name
else:
deploy_abs_path = os.path.join(deploy_path, project_name)
release_abs_path = release_path
fun_value = dict(RELEASE_FUN_CHOICES).get(form.cleaned_data['fun'])
data = {
'expr_form': 'list',
'client': form.cleaned_data['client'],
'tgt': [item.host_name for item in form.cleaned_data['tgt']],
'fun': fun_value,
'arg': [deploy_abs_path, repository_url],
}
print data
salt = SaltApi()
salt.get_token()
header = salt.get_header()
context = process(header, **data)
print context
if form.cleaned_data['fun'] == u'1':
shell = 'rm -rf %s && ln -s %s %s' % (release_abs_path, deploy_abs_path, release_abs_path)
data = {
'expr_form': 'list',
'client': form.cleaned_data['client'],
'tgt': [item.host_name for item in form.cleaned_data['tgt']],
'fun': 'cmd.run',
'arg': shell,
}
# print data
release_context = process(header, **data)
else:
release_context = "symlink not change."
for item in form.cleaned_data['tgt']:
result = yaml.load(context)['return'][0][item.host_name]
if result is True or result == "Already up-to-date." and regex_match_error(release_context) is True:
status = True
else:
status = False
new_form = form.save(commit=False)
new_form.context = context
new_form.deploy_path = deploy_abs_path
new_form.release_path = release_abs_path
new_form.operate = request.session['username']
new_form.status = status
new_form.save()
form.save()
return redirect('code_release_list')
return render(request, template_name, {'highlight2': 'active',
'username': request.session['username'],
'form': form,
'servers': servers,
'departments': departments,
'zones': zones,
'deploy_path': deploy_path,
'repo': repo,
'var7': 'active',
})
def sync_config_process(request,
template_name='saltstack/sync_config_form.html'):
form = SyncConfigForm(request.POST or None)
if form.is_valid():
project_name = form.cleaned_data['repository'].repo_tag
zone = form.cleaned_data['zones'].name
salt_url = os.path.join('salt://app_config', zone)
print salt_url
dest_path = form.cleaned_data['dest_path'].path_value
if form.cleaned_data['use_zone']:
salt_abs_url = os.path.join(salt_url, (project_name + '_' + zone))
else:
salt_abs_url = os.path.join(salt_url, project_name)
data = {
'expr_form': 'list',
'client': 'local',
'fun': 'cp.get_dir',
'tgt': [item.host_name for item in form.cleaned_data['tgt'].all()],
'arg': [salt_abs_url, dest_path],
}
print data
salt = SaltApi()
salt.get_token()
header = salt.get_header()
context = process(header, **data)
print context
if project_name == 'pxqb_login':
info = Information.objects.filter(zones=form.cleaned_data['zones'],
key__contains="SERVER_ID")
if info:
for item in info:
server_id = item.value
filename = os.path.join(dest_path,
project_name + '_' + zone,
'server.php')
command = "sh /data/agent_scripts/enable_entrance.sh %s %s" % (
server_id, filename)
data = {
'expr_form':
'list',
'client':
'local',
'fun':
'cmd.run',
'tgt': [
item.host_name
for item in form.cleaned_data['tgt'].all()
],
'arg':
command,
}
print data
salt = SaltApi()
salt.get_token()
header = salt.get_header()
result = process(header, **data)
print result
if regex_match_error(context):
status = True
else:
status = False
new_form = form.save(commit=False)
new_form.operate = request.session['username']
new_form.dest_path = dest_path
new_form.salt_url = salt_abs_url
new_form.status = status
new_form.context = context
new_form.save()
form.save()
return redirect('sync_config_list')
return render(
request, template_name, {
'highlight14': 'active',
'username': request.session['username'],
'form': form,
'var7': 'active',
})
def cron_jobs(request, template_name='saltstack/cron_form.html'):
data = {}
servers = Assets.objects.all()
s = .objects.all()
zones = Zone.objects.all()
form = CronForm(request.POST or None)
if form.is_valid():
# print form
if form.cleaned_data['fun'] == 'cron.rm_job':
data = {
'expr_form': 'list',
'client': form.cleaned_data['client'],
'fun': form.cleaned_data['fun'],
'tgt': [item.host_name for item in form.cleaned_data['tgt'].all()],
'arg': [form.cleaned_data['sys_user'],
form.cleaned_data['arg']]
}
if form.cleaned_data['fun'] == 'cron.set_job':
data = {
'expr_form': 'list',
'client': form.cleaned_data['client'],
'fun': form.cleaned_data['fun'],
'tgt': [item.host_name for item in form.cleaned_data['tgt'].all()],
'arg': [form.cleaned_data['sys_user'],
form.cleaned_data['minute'],
form.cleaned_data['hour'],
form.cleaned_data['day'],
form.cleaned_data['month'],
form.cleaned_data['day_week'],
form.cleaned_data['arg']]
}
if form.cleaned_data['fun'] == 'cron.raw_cron':
data = {
'expr_form': 'list',
'client': form.cleaned_data['client'],
'fun': form.cleaned_data['fun'],
'tgt': [item.host_name for item in form.cleaned_data['tgt'].all()],
'arg': [form.cleaned_data['sys_user']]
}
print data
salt = SaltApi()
salt.get_token()
header = salt.get_header()
context = process(header, **data)
print context
if regex_match_error(context):
status = True
else:
status = False
new_form = form.save(commit=False)
new_form.context = context
new_form.operate = request.session['username']
new_form.status = status
new_form.save()
form.save()
return redirect('cron_list')
return render(request, template_name, {'highlight6': 'active',
'username': request.session['username'],
'form': form,
'servers': servers,
'zones': zones,
's': s,
'var7': 'active'
})
def all_zone_update_process(request, template_name='saltstack/all_zone_update_form.html'):
departments = Department.objects.all()
zones = Zone.objects.all()
path_object = Path.objects.filter(path_key__contains=u'部署')
repo_object = Repository.objects.all()
global status
global commands
global assets
context = {}
cmds = {}
form = UpdatesForm(request.POST or None)
if form.is_valid():
# print form
zone_list = form.cleaned_data['zones']
repo_name = form.cleaned_data['repository_name']
project_name = repo_name.repo_tag
for zone in zone_list:
host_list = []
# print form.cleaned_data['use_zone']
if form.cleaned_data['use_zone']:
abs_path = os.path.join(form.cleaned_data['deploy_path'].path_value, (project_name + '_' + zone.name))
else:
abs_path = os.path.join(form.cleaned_data['deploy_path'].path_value, project_name)
print abs_path
commands = '%s %s' % (form.cleaned_data['commands'], abs_path)
print commands
cmds['%s' % zone] = commands
assets = Assets.objects.filter(departments=form.cleaned_data['departments'], game_zone=zone)
for item in assets:
host_list.append(item.host_name)
print host_list
data = {
'expr_form': 'list',
'client': form.cleaned_data['client'],
'fun': form.cleaned_data['fun'],
'arg': commands,
'tgt': host_list,
}
# print data
if host_list:
salt = SaltApi()
salt.get_token()
header = salt.get_header()
context['%s' % zone] = process(header, **data)
else:
context['%s' % zone] = "not found servers"
if regex_match_error(json.dumps(context)):
status = True
else:
status = False
new_form = form.save(commit=False)
new_form.context = json.dumps(context, encoding='UTF-8', ensure_ascii=False)
new_form.operate = request.session['username']
new_form.status = status
new_form.save()
form.save()
# updates = Updates(departments=form.cleaned_data['departments'],
# operate=request.session['username'], client=form.cleaned_data['client'],
# use_zone=form.cleaned_data['use_zone'], fun=form.cleaned_data['fun'],
# commands=commands, deploy_path=form.cleaned_data['deploy_path'].path_value,
# status=status, content=form.cleaned_data['content'], context=json.dumps(context),
# repository_name_id=repo_name.id)
# updates.save()
# updates.tgt = assets
# updates.zones = form.cleaned_data['zones']
# updates.save()
return redirect('all_zone_update_list')
return render(request, template_name, {'form': form,
'highlight7': 'active',
'username': request.session['username'],
'var7': 'active',
'departments': departments,
'zones': zones,
'path_object': path_object,
'repo_object': repo_object,
})
def change_sys_password(
request, template_name='saltstack/change_sys_password_process.html'):
departments = Department.objects.all()
tgt = Assets.objects.filter(is_online=True)
form = PasswordFrom(request.POST or None)
gen_string = {}
hash_string = {}
context = {}
if form.is_valid():
for item in form.cleaned_data['tgt']:
password_charset = string.ascii_letters + string.digits
gen_string['%s' % item.host_name] = gen_random_string(
password_charset, 16)
data = {
'expr_form': 'list',
'client': form.cleaned_data['client'],
'tgt': item.host_name,
'fun': 'shadow.gen_password',
'arg': gen_string[item.host_name]
}
print data
salt = SaltApi()
salt.get_token()
header = salt.get_header()
result = change_password(header, **data)
hash_string[item.host_name] = result[item.host_name]
data = {
'expr_form': 'list',
'client': form.cleaned_data['client'],
'tgt': item.host_name,
'fun': 'shadow.set_password',
'arg':
[form.cleaned_data['user'], hash_string[item.host_name]]
}
print data
context[item.host_name] = process(header, **data)
if form.cleaned_data['user'] == 'root':
Assets.objects.filter(host_name=item.host_name).update(
superuser_pass=gen_string[item.host_name])
else:
SysUser.objects.filter(
servers__host_name=item.host_name,
sys_user=form.cleaned_data['user']).update(
sys_pass=gen_string[item.host_name])
# for assets in Assets.objects.filter(host_name=item.host_name):
# assets.sys_users.filter(sys_user=form.cleaned_data['user']).\
# update(sys_pass=gen_string[item.host_name])
if regex_match_error(json.dumps(context)):
status = True
else:
status = False
new_form = form.save(commit=False)
new_form.operate = request.session['username']
new_form.status = status
new_form.context = json.dumps(context)
# new_form.context = context
new_form.save()
form.save()
return redirect('change_password_record')
return render(
request, template_name, {
'form': form,
'var7': 'active',
'highlight9': 'active',
'username': request.session['username'],
'departments': departments,
'tgt': tgt
})
def p2p_scp_process(request, template_name='saltstack/code_release_form.html'):
global status
status = False
form = P2PForm(request.POST or None)
if form.is_valid():
operate = request.session['username']
# 项目名
project = form.cleaned_data['repository_name'].repo_tag
zones = form.cleaned_data['zones']
# 归档路径
archive_path = request.POST['archive_path']
# 如果路径不存在，则创建
if os.path.exists(archive_path):
makedir_p(archive_path)
# versions = form.cleaned_data['versions']
get_deploy_path = form.cleaned_data['deploy_path'].path_value
release_path = form.cleaned_data['release_path'].path_value
# 部署路径 发布路径拼接
if form.cleaned_data['use_zone']:
deploy_path = os.path.join(get_deploy_path,
(project + '_' + zones.name))
release_abs_path = release_path + '_' + zones.name
else:
deploy_path = os.path.join(get_deploy_path, project)
release_abs_path = release_path
# 获取仓库地址
repo_name = form.cleaned_data['repository_name']
result = Repository.objects.filter(repo_name__contains=repo_name)[0]
repository_url = get_repo_url(result)
compress_file = os.path.join(archive_path, '%s.zip' % project)
# 获取最新版并压缩
git_checkout(archive_path, project, repository_url)
archive_compress(archive_path, project, compress_file)
# 获取md5码
command = 'md5sum %s' % compress_file
md5sum = get_md5sum(command)
servers = form.cleaned_data['tgt']
get_destination_list(servers)
SOURCE.append(
Assets.objects.filter(
networks__private_address__icontains=MASTER_IP))
source_server = SOURCE[0][0]
do_copy_control(source_server, archive_path, compress_file,
deploy_path, release_abs_path, md5sum)
# print return_result
for item in return_result:
for key in item:
if regex_match_error(item[key]) is True:
status = True
else:
status = False
# print status
# store to mysql
# Version.objects.filter(Q(vernier=u'1') | Q(vernier=u'2') | Q(vernier=u'3')).update(vernier=u'0')
# if status:
# Version.objects.filter(id=versions.id).update(vernier=1)
new_form = form.save(commit=False)
new_form.fun = 'P2P_SCP'
new_form.deploy_path = deploy_path
new_form.release_path = release_abs_path
new_form.operate = operate
new_form.status = status
new_form.context = json.dumps(return_result)
new_form.save()
form.save()
return redirect('code_release_list')
return render(request, template_name, {
'form': form,
'highlight2': 'active',
'var7': 'active',
})
def code_backup_process(request,
template_name='saltstack/code_backup_form.html'):
global status
form = BackupForm(request.POST or None)
if form.is_valid():
zone_name = form.cleaned_data['zones'].name
deploy_path = form.cleaned_data['deploy_path'].path_value
# versions = form.cleaned_data['versions']
project_name = form.cleaned_data['repository_name'].repo_tag
backup_path = form.cleaned_data['backup_path'].path_value
if form.cleaned_data['use_zone']:
deploy_abs_path = os.path.join(deploy_path,
(project_name + '_' + zone_name))
code_backup_package = project_name + '_' + zone_name + '_' + datetime.now(
).strftime("%Y%m%d%H") + '.tar.gz'
else:
deploy_abs_path = os.path.join(deploy_path, project_name)
code_backup_package = project_name + '_' + datetime.now().strftime(
"%Y%m%d%H") + '.tar.gz'
shell_command = 'sh /data/agent_scripts/backup_code.sh %s %s %s' % (
backup_path, deploy_abs_path, code_backup_package)
code_backup_abs_path = os.path.join(backup_path, code_backup_package)
data = {
'expr_form': 'list',
'client': form.cleaned_data['client'],
'tgt': [item.host_name for item in form.cleaned_data['tgt']],
'fun': 'cmd.run',
'arg': shell_command,
}
print data
salt = SaltApi()
salt.get_token()
header = salt.get_header()
context = process(header, **data)
print context
for item in form.cleaned_data['tgt']:
print yaml.load(context)['return'][0][item.host_name]
if regex_match_error(context) is True:
status = True
else:
status = False
# Version.objects.filter(id=versions.id).update(vernier=u'2')
new_form = form.save(commit=False)
new_form.context = context
new_form.deploy_path = deploy_abs_path
new_form.backup_path = code_backup_abs_path
new_form.fun = 'cmd.run'
new_form.operate = request.session['username']
new_form.status = status
new_form.save()
form.save()
return redirect('code_backup_list')
return render(
request, template_name, {
'highlight11': 'active',
'username': request.session['username'],
'form': form,
'var7': 'active',
})
