def add_slackconf(self):
"""
Add slack details into YAML.
- **parameters**, **types**, **return** and **return types**::
:return: Returns slack dictionary
:rtype: dictionary
"""
slacknotifications = (
"\nDo you want notifications to "
"Slack Channel [" +
self.prevdata('SlackNotifications', self.globalprevdata) +
"]:(Yes/No)")
slacknotifications = self.get_input(slacknotifications,
choices=["yes", "no"])
usrname = self.prevdata('Slack.username', self.userprevdata)
channelname = self.prevdata('Slack.channelname', self.globalprevdata)
token = self.prevdata('Slack.token', self.userprevdata)
prevtoken = token
if token:
token = AESCipher().decrypt(token)
prevtoken = token
if slacknotifications.lower() == 'yes':
if token:
token = AESCipher().decrypt(token)
prevtoken = token
usrname = "Enter username[" + usrname + "]:"
usrname = self.get_input(usrname)
channelname = "Enter slack channelname [" + channelname + "]: "
channelname = self.get_input(channelname)
while True:
token = "enter Slack token[" + prevtoken + "]: "
token = self.get_input(token)
if token:
token = AESCipher().encrypt(token)
break
else:
logger.warn("token cannot be empty. Please re-enter.")
else:
token = token
slack_dict = {'Slack': {'username': usrname, 'token': token}}
globalslack_dict = {
'SlackNotifications': slacknotifications,
'Slack': {
'channelname': channelname
}
}
return slack_dict, globalslack_dict
def __init__(self):
self.db = db()
filepath = os.path.join(os.path.expanduser('~'), "user_info.yaml")
globalfilepath = os.path.join(os.path.expanduser('~'),
"global_conf.yaml")
userdata = get_data_from_yaml(filepath)
glob_data = get_data_from_yaml(globalfilepath)
self.dbserver = glob_data['Database']['serverip']
self.username = userdata['Database']['serverusername']
self.password = AESCipher().decrypt(
userdata['Database']['serverpassword'])
self.servertype = glob_data['Database']['serverOStype']
def get_password(self, strng, prevpass):
while True:
pwd = getpass.getpass(strng)
if pwd:
password = AESCipher().encrypt(pwd)
break
else:
if prevpass:
password = prevpass
break
else:
logger.warn("No password in global conf to use."
"Please enter password.")
return password
def sys_decode():
'''{ "Description": "AES Decrypt ", "Methods":"GET, POST", "Content-Type":"application/json",
"Parameters":[
{"Description":"data", "Name":"data", "Required":true}
]
}'''
try:
req_params = {'data': ['required']}
_params = get_parameter(**req_params)
decrypt = AESCipher(Config.SYS_AES_KEY).decrypt(_params['data'])
result = {'result': decrypt}
rs = {'status': 200, 'message': 'OK', 'data': result}
return api_response(**rs)
except Exception as e:
rs = {'status': 400, 'message': str(e), 'data': []}
return api_response(**rs)
def encode():
'''{ "Description": "AES Encrypt", "Methods":"GET, POST", "Content-Type":"application/json",
"Parameters":[
{"Description":"key", "Name":"key", "Required":true},
{"Description":"data", "Name":"data", "Required":true}
]
}'''
try:
req_params = {}
req_params['key'] = ['required']
req_params['data'] = ['required']
_params = get_parameter(**req_params)
encrypt = AESCipher(_params['key']).encrypt(_params['data'])
result = {'result': encrypt}
rs = {'status': 200, 'message': 'OK', 'data': result}
return api_response(**rs)
except Exception as e:
rs = {'status': 400, 'message': str(e), 'data': []}
return api_response(**rs)
def __init__(self, logfilepath):
"""
Gets username,password and ipaddress of webserver
- **parameters**, **types**, **return** and **return types**::
param logfilepath: file path to be pushed to web server
type logfilepath: String
"""
#filepath is user_info.yaml file path
#globalfilepath is global_conf.yaml file path
filepath = os.path.join(os.path.expanduser('~'), "user_info.yaml")
globalfilepath = os.path.join(os.path.expanduser('~'),
"global_conf.yaml")
userdata = get_data_from_yaml(filepath)
self.glob_data = get_data_from_yaml(globalfilepath)
self.path = '/var/www/html/sutas-logs/'
#Eg:logfilepath "C:\Users\admin\Sutas_Logs\test_suite_980_2017Sep18_162033\log.html"
self.source = logfilepath
self.serverip = self.glob_data['TestArtifact']['serverip']
self.username = userdata['TestArtifact']['username']
if self.glob_data['EnableTestArtifacts'].lower() == "yes":
self.password = AESCipher().decrypt(
userdata['TestArtifact']['password'])
#3.[l]list all the files on ftp site
#4.[f]search a file on ftp site,return True or Flase
#5.[h]show help info
#add upload and download operations 20111210 version0.1
#add md5sum after ops 20120308 version0.2
import sys, os, ftplib, socket
from lib.utils import logger
from lib.AESCipher import AESCipher
from settings import Config
import io
NIS_TEMP_PATH = Config.NAS0_TEMP_PATH
__const_host = Config.NAS0_IP
__const_username = AESCipher(Config.SYS_AES_KEY).decrypt(Config.NAS0_USER_ID)
__const_pwd = AESCipher(Config.SYS_AES_KEY).decrypt(Config.NAS0_PASSWOED)
__const_buffer_size = 8192
def connect():
try:
ftp = ftplib.FTP(__const_host)
ftp.login(__const_username, __const_pwd)
return ftp
except Exception as e:
logger.error(str(e))
raise Exception(
"FTP is unavailable,please check the host,username and password!")
def dump_data(self):
"""
This will dump the data taken from commandline arguments
in to config files and validates the data.
"""
slacktoken = ''
jirapwd = ''
dbpassword = ''
dbserverpwd = ''
if self.prevdata('Slack.token', self.userprevdata):
slacktoken = AESCipher().decrypt(
self.prevdata('Slack.token', self.userprevdata))
if self.prevdata('Jira.password', self.userprevdata):
jirapwd = AESCipher().decrypt(
self.prevdata('Jira.password', self.userprevdata))
if self.prevdata('Database.pwd', self.userprevdata):
dbpassword = AESCipher().decrypt(
self.prevdata('Database.pwd', self.userprevdata))
if self.prevdata('Database.serverpassword', self.userprevdata):
dbserverpwd = AESCipher().decrypt(
self.prevdata('Database.serverpassword', self.userprevdata))
if self.prevdata('TestArtifact.password', self.userprevdata):
testartifactspwd = AESCipher().decrypt(
self.prevdata('TestArtifact.password', self.userprevdata))
else:
testartifactspwd = ''
userargs = {
'symmetrickey':
self.prevdata('symmetric_key', self.globalprevdata),
'raisebugs':
self.prevdata('Raise_Bugs', self.globalprevdata),
'jiraurl':
self.prevdata('Jira.url', self.globalprevdata),
'jirausr':
self.prevdata('Jira.username', self.userprevdata),
'jirapwd':
jirapwd,
'jira_affect_version':
self.prevdata('Jira.affects_version', self.globalprevdata),
'jira_watcher':
self.prevdata('Jira.watcher', self.globalprevdata),
'jiraenv':
self.prevdata('environment', self.globalprevdata),
'jiraproj':
self.prevdata('Jira.project', self.globalprevdata),
'jirabugpriority':
self.prevdata('Jira.bugpriority', self.globalprevdata),
'jirabugseverity':
self.prevdata('Jira.bugseverity', self.globalprevdata),
'slack':
self.prevdata('SlackNotifications', self.globalprevdata),
'slacktoken':
slacktoken,
'slackusr':
self.prevdata('Slack.username', self.userprevdata),
'slackchannel':
self.prevdata('Slack.channelname', self.globalprevdata),
'loglevel':
self.prevdata('LogLevel', self.globalprevdata),
'emailnotifications':
self.prevdata('EmailNotifications', self.globalprevdata),
'emails':
self.prevdata('Email.recipients', self.globalprevdata),
'validateemails':
self.prevdata('Email.ValidateEmails', self.globalprevdata),
'smtpip':
self.prevdata('Email.smtpip', self.globalprevdata),
'smtpport':
self.prevdata('Email.smtpport', self.globalprevdata),
'consolidatedmail':
self.prevdata('Consolidatedmail', self.globalprevdata),
'send_mail_only_if_failed':
self.prevdata('send_mail_only_if_failed', self.globalprevdata),
'teamsnotifications':
self.prevdata('TeamsNotifications', self.globalprevdata),
'teamsurl':
self.prevdata('Teams.url', self.globalprevdata),
'enabledatabase':
self.prevdata('EnableDatabase', self.globalprevdata),
'dbusername':
self.prevdata('Database.username', self.userprevdata),
'dbpassword':
dbpassword,
'databasename':
self.prevdata('Database.database_name', self.globalprevdata),
'dbserverip':
self.prevdata('Database.serverip', self.globalprevdata),
'dbserveruser':
self.prevdata('Database.serverusername', self.userprevdata),
'dbserverpwd':
dbserverpwd,
'serverostype':
self.prevdata('Database.serverOStype', self.globalprevdata),
'dbprune':
self.prevdata('Database.prune', self.userprevdata),
'enabletestmanagement':
self.prevdata('EnableTestManagement', self.globalprevdata),
'sprintnumber':
self.prevdata('sprint_number', self.globalprevdata),
'fixversion':
self.prevdata('fix_version', self.globalprevdata),
'tm_project':
self.prevdata('TM_Project', self.globalprevdata),
'enablepushtestartifacts':
self.prevdata('EnableTestArtifacts', self.globalprevdata),
'testaritfactsserverip':
self.prevdata('TestArtifact.serverip', self.globalprevdata),
'testaritfactsserveruser':
self.prevdata('TestArtifact.susername', self.userprevdata),
'testaritfactsserverpwd':
testartifactspwd
}
for key, value in list(vars(self.args).items()):
if value:
value = value.replace('"', '')
value = value.replace("'", '')
userargs[key] = value
for key, value in list(userargs.items()):
if str(userargs[key]).lower().strip() == 'none':
userargs[key] = None
passwordlist = [
'jirapwd', 'dbserverpwd', 'dbpassword', 'testaritfactsserverpwd'
]
flag = False
for key in userargs:
if key in passwordlist:
flag = True
break
if flag:
if not userargs['symmetrickey']:
raise Exception("--symmetrickey is mandatory when --jirapwd "
"or --dbserverpwd or --dbpassword or"
"--testaritfactsserverpwd is used")
glob_details = {
"symmetric_key": userargs['symmetrickey'],
'sprint_number': userargs['sprintnumber'],
'fix_version': userargs['fixversion'],
'TM_Project': userargs['tm_project'],
'environment': userargs['jiraenv']
}
self._update_dict(self.globalfilepath, glob_details)
password = AESCipher().encrypt(userargs['jirapwd'])
try:
project = eval(userargs['jiraproj'])
except SyntaxError as TypeError:
project = userargs['jiraproj']
global_dict = {
'Raise_Bugs': userargs['raisebugs'],
'EnableTestManagement': userargs['enabletestmanagement'],
'Jira': {
'url': userargs['jiraurl'],
'project': project,
'bugseverity': userargs['jirabugseverity'],
'bugpriority': userargs['jirabugpriority'],
'affects_version': userargs['jira_affect_version'],
'watcher': userargs['jira_watcher']
}
}
logger.warn(global_dict)
jira_dict = {
'Jira': {
'username': userargs['jirausr'],
'password': password
}
}
self._update_dict(self.filepath, jira_dict)
self._update_dict(self.globalfilepath, global_dict)
token = AESCipher().encrypt(userargs['slacktoken'])
slack_dict = {
'Slack': {
'username': userargs['slackusr'],
'token': token
}
}
globalslack_dict = {
'SlackNotifications': userargs['slack'],
'Slack': {
'channelname': userargs['slackchannel']
}
}
globalteams_dict = {
'TeamsNotifications': userargs['teamsnotifications'],
'Teams': {
'url': userargs['teamsurl']
}
}
email_dict = {
'EmailNotifications': userargs['emailnotifications'],
'Email': {
'recipients': userargs['emails'],
'ValidateEmails': userargs['validateemails'],
'smtpip': userargs['smtpip'],
'smtpport': userargs['smtpport']
},
'Consolidatedmail': userargs['consolidatedmail'],
'send_mail_only_if_failed': userargs['send_mail_only_if_failed']
}
dbpassword = AESCipher().encrypt(userargs['dbpassword'])
dbserverpwd = AESCipher().encrypt(userargs['dbserverpwd'])
db_dict = {
'Database': {
'username': userargs['dbusername'],
'pwd': dbpassword,
'serverusername': userargs['dbserveruser'],
'serverpassword': dbserverpwd
}
}
globdb_dict = {
'EnableDatabase': userargs['enabledatabase'],
'Database': {
'database_name': userargs['databasename'],
'serverip': userargs['dbserverip'],
'prune': userargs['dbprune'],
'serverOStype': userargs['serverostype']
}
}
globtestartifacts_dict = {
'EnableTestArtifacts': userargs['enablepushtestartifacts'],
'TestArtifact': {
'serverip': userargs['testaritfactsserverip']
},
}
testartifactspwd = AESCipher().encrypt(
userargs['testaritfactsserverpwd'])
testartifacts_dict = {
'TestArtifact': {
'username': userargs['testaritfactsserveruser'],
'password': testartifactspwd
}
}
'''
create and update dict for test environment variable
'''
self._update_dict(self.filepath, slack_dict)
self._update_dict(self.globalfilepath, globalslack_dict)
self._update_dict(self.globalfilepath, globalteams_dict)
self._update_dict(self.globalfilepath, email_dict)
self._update_dict(self.filepath, db_dict)
self._update_dict(self.globalfilepath, globdb_dict)
self._update_dict(self.globalfilepath, globtestartifacts_dict)
self._update_dict(self.filepath, testartifacts_dict)
if not vars(self.args)['loglevel']:
userargs['loglevel'] = 'warn'
log_dict = {"LogLevel": userargs['loglevel']}
self._update_dict(self.globalfilepath, log_dict)
val_obj = ValidateUserConfig()
val_obj.validate_jira()
val_obj.validate_database()
val_obj.ckeck_cronjob_in_appache_server()
val_obj.validate_email()
val_obj.validate_communication_channels()