def do_build(self,socket_id,data):
projects = data.get("projects")
put_console_log1 = data.get("put_console_log")
deploy = data.get("deploy")
startMsg = "start build project <span style='color:green;'> {project_name} </span>"
endMsg = "build jenkins project <span style='color:green;'> {project_name} </span> {status}"
server = Jenkins(jenkins_url, username, password)
for project_name in projects:
ChatSocketHandler.client_map[socket_id].try_write_message(startMsg.format(project_name=project_name))
server.build_job(project_name)
job = server[project_name]
while not job.is_running():
ChatSocketHandler.client_map[socket_id].try_write_message("........")
time.sleep(1)
ChatSocketHandler.client_map[socket_id].try_write_message("waiting jenkins start building")
if put_console_log1:
self.put_console_log(socket_id,data)
else:
ChatSocketHandler.client_map[socket_id].try_write_message("wait build finish not put logs")
while job.is_running():
time.sleep(1)
last_build = job.get_last_build()
build_status = last_build.get_status()
ChatSocketHandler.client_map[socket_id].try_write_message(endMsg.format(project_name=project_name,status=build_status))
if build_status == "SUCCESS" and deploy:
self.do_deploy(self.socket_id,project_name)
def jenkins_build (job_name):
"""Builds jenkins job. If job has not started (queued) it will check every 30 seconds
once it runs it will wait 10 minutes to build and go on to EDIMapper
"""
jenkins_url = 'http://hq-build3:8080'
logging_message('attempting to build %s' % job_name)
server = Jenkins(jenkins_url, username='******', password=decrypt_key('jenkins'))
if job_name in server.keys():
job = server.get_job(job_name)
if not is_debug:
server.build_job(job_name)
else:
print("would have built Jenkins ", job_name)
print("is job queued? ", job.is_queued())
print("this is the job: ", job)
while(job.is_queued_or_running()):
print("job is queued")
print("job in queued: ", job)
time.sleep(60)
time.sleep(10)
try:
if not job.is_queued_or_running():
if job.get_last_failed_buildnumber() == job.get_last_buildnumber():
print ('build failed')
logging_message('build failed')
sys.exit()
except:
pass
logging_message('started build %s' % job_name)
else:
logging_message('unable to find build %s' % job_name)
print("should not have displayed this line 148")
sys.exit()
def rollback_sync_code_job_cluster(project_name):
"""
集群机器代码同步任务, def check_status方法中判断当项目部署完成后并且是success成功状态则调用本方法
:param project_name: 项目名称
:param task_id: 任务编号
:return:
"""
sync_job_name = config('SYNC_JOB_NAME').split(',')
server_2 = Jenkins(config('JENKINS_URL'),
username=config('JENKINS_USER'),
password=config('JENKINS_PASS'))
if project_name in sync_job_name:
time.sleep(120)
logger.info(
"回滚-->开始同步集群代码：params={'sync_project': %s, 'code': 'class', 'slb': True, 'is_restart_tomcat': True}"
% project_name)
server_2.build_job('trip-sbox-sync',
params={
'sync_project': project_name,
'code': 'class',
'slb': True,
'is_restart_tomcat': True
})
build_id = JenkinsStauts.jenkins_task_id('trip-sbox-sync')
sync_cluster_result = JenkinsStauts.jenkins_rollback_status(
project_name='trip-sbox-sync', build_id=build_id)
else:
logger.info('回滚任务：%s, 属于单机项目无集群机器, 跳过同步。' % (project_name))
def main():
m = AnsibleModule(
argument_spec = dict(
project_key = dict(required=True),
repo_name = dict(required=True),
scm_host = dict(required=True),
scm_port = dict(required=True),
api_url = dict(required=True),
api_username = dict(required=True),
api_password = dict(required=True),
))
p = m.params
p['repo_name'] = p['repo_name'].lower()
job_name = "{0}-{1}".format(p['project_key'], p["repo_name"])
view_name = p['project_key']
jenkins = Jenkins(p['api_url'],
p['api_username'],
p['api_password'])
if jenkins.has_job(job_name):
m.exit_json(changed=False, status="Job already exists: {0}".format(job_name))
cfg = job_config % p
job = jenkins.create_job(job_name, cfg)
if job is None:
m.fail_json(msg="Failed to create job: {0}".format(cfg))
# create view
# if view_name not in jenkins.views:
# view = jenkins.views.create(view_name)
# view.add(job_name)
jenkins.build_job(job_name)
m.exit_json(changed=True, status="DSL Job created: {0}".format(job_name))
def run_jenkins_jobs(major, tag):
print(str.format('starting jenkins jobs for {0}: {1}...', major, tag))
if 'JENKINS_CREDENTIALS' not in os.environ:
return
jenkins_url = 'https://ci.sapmachine.io'
jenkins_user = os.environ['JENKINS_CREDENTIALS_USR']
jenkins_password = os.environ['JENKINS_CREDENTIALS_PSW']
server = Jenkins(jenkins_url,
username=jenkins_user,
password=jenkins_password,
requester=CrumbRequester(baseurl=jenkins_url,
username=jenkins_user,
password=jenkins_password))
# strange, but with that one I got a 403: https://ci.sapmachine.io/view/Infrastructure/job/repository-tags/191/
# server.use_auth_cookie()
build_jobs = [
str.format('build-{0}-release-linux_x86_64', major),
str.format('build-{0}-release-linux_ppc64le', major),
str.format('build-{0}-release-linux_ppc64', major),
str.format('build-{0}-release-linux_aarch64', major),
str.format('build-{0}-release-macos_x86_64', major),
str.format('build-{0}-release-windows_x86_64', major)
]
job_params = {'PUBLISH': 'true', 'RELEASE': 'false', 'GIT_TAG_NAME': tag}
for job in build_jobs:
print(str.format('starting jenkins job "{0}" ...', job))
server.build_job(job, job_params)
class JenkinsServer:
def __init__(self, url, username, password):
self.J = Jenkins(url, username=username, password=password)
def start_build(self, job_name):
if job_name in self.J.keys():
self.J.build_job(job_name)
return True
else:
return False
def get_running_jobs(self):
jobs = self.J.get_jobs()
running = []
for job, job_instance in jobs:
if job_instance.is_running():
n = self.J[job].get_next_build_number()
job_info = {job: n-1}
running.append(job_info)
return running
def build_jenkin_job(user_name, api_token, build):
server = Jenkins(jenkins_url, user_name, api_token)
if server.has_job(build):
server.build_job(build)
click.echo('Jenkins Job %s build' %build)
else:
click.echo("Job doesn't exist")
def run_jenkins_jobs(major, tag):
if 'JENKINS_CREDENTIALS' not in os.environ:
return
jenkins_url = 'https://ci.sapmachine.io'
jenkins_user = os.environ['JENKINS_CREDENTIALS_USR']
jenkins_password = os.environ['JENKINS_CREDENTIALS_PSW']
server = Jenkins(jenkins_url,
username=jenkins_user,
password=jenkins_password,
requester=CrumbRequester(baseurl=jenkins_url,
username=jenkins_user,
password=jenkins_password))
build_jobs = [
str.format('build-{0}-release-linux_x86_64', major),
str.format('build-{0}-release-linux_ppc64le', major),
str.format('build-{0}-release-linux_ppc64', major),
str.format('build-{0}-release-macos_x86_64', major),
str.format('build-{0}-release-windows_x86_64', major)
]
job_params = {
'PUBLISH': 'true',
'RELEASE': 'false',
'RUN_TESTS': 'true',
'GIT_TAG_NAME': tag
}
for job in build_jobs:
print(str.format('starting jenkins job "{0}" ...', job))
server.build_job(job, job_params)
def MessageStatus(self, Message, Status):
""" Event handler for Skype chats """
print "status is "+Status
if Status == Skype4Py.cmsReceived:
print "Message '%s' received from user %s", Message.Body, Message.FromHandle
if Message.Body=='build':
j = Jenkins('http://10.42.0.123:8080/jenkins/')
j.build_job('Build')
print 'command jenkins received'
class JenkinsBuild(object):
def __init__(self, job_name):
self.j = Jenkins('http://192.168.3.44:8085', 'halicea', 'arman1')
def build(self):
self.j.build_job(self.jobame, )
def overwrite_vars(self, **kwargs):
pass
def invoke(self):
self.j.build_job('InboundLogistics', params = {"PlatformType":"MonoTouch", "OutputDir":"builds", "version":"test", "CONFIGS_ROOT":"/Developer/Mediawire/MediawireConfigurations", "config":"InboundLogistics", "branch_name":"ios_012400_locked", "BuildTarget":"Live:Testing"})
def free_job():
job_id = request.json['job_id']
print job_id
ret = {'message': 'Failed'}
if not job_id:
ret['message'] = 'Job Id not found!'
return jsonify(ret)
jenkins_url = 'http://jenkins.qa1.eucalyptus-systems.com'
server = Jenkins(jenkins_url, username='******', password="******")
server.build_job('Free Reservation', params={'JOB_ID': job_id})
ret['message'] = 'success'
return jsonify(ret)
class JenkinsBuild(object):
def __init__(self, job_name):
self.j = Jenkins('http://*********', '*****', '*****')
def build(self):
self.j.build_job(self.jobame, )
def overwrite_vars(self, **kwargs):
pass
def invoke(self):
self.j.build_job('InboundLogistics', params = {"PlatformType":"MonoTouch", "OutputDir":"builds", "version":"test", "CONFIGS_ROOT":"/Developer/Mediawire/MediawireConfigurations", "config":"InboundLogistics", "branch_name":"ios_012400_locked", "BuildTarget":"Live:Testing"})
def postUrl(jobname, parameter):
loadjenkins()
crumb = CrumbRequester(username=jenkins_username,
password=jenkins_token,
baseurl=jenkins_url)
logging.debug("Jobname " + jobname)
logging.debug("Parameter List " + json.dumps(parameter))
jenkins = Jenkins(jenkins_url,
username=jenkins_username,
password=jenkins_token,
requester=crumb,
timeout=30)
jenkins.build_job(jobname, parameter)
class BaseJenkinsAPI:
def __init__(self, server_url, username=None, password=None):
self.url = server_url
self.username = username
self.password = password
if self.username and self.password:
self.instance = Jenkins(self.url, self.username, self.password)
else:
self.instance = Jenkins(self.url)
# JJ group
def copy_job(self, job_name, new_job_name):
self.instance.copy_job(job_name, new_job_name)
def get_jobs(self):
return self.instance.get_jobs()
def has_job(self, job_name):
return self.instance.has_job(job_name)
def get_number_jobs(self):
return len(self.instance.keys())
def create_job(self, job_name, config_xml):
"""
Create a job
:param str config_xml: XML configuration of new job
"""
if not config_xml:
raise JenkinsAPIException('Job XML config cannot be empty')
params = {'name': job_name}
self.instance.requester.post_xml_and_confirm_status(
self.instance.get_create_url(), data=config_xml, params=params)
print("The job {} has been successfully created".format(job_name))
def build_job(self, job_name):
self.instance.build_job(job_name)
# JJ /group
def get_name(self):
return self.url
def get_version(self):
return self.instance.version
def get_api_version(self):
return jenkinsapi.__version__
class JenkinsManager():
def __init__(self, url, username, password):
self.server = Jenkins(url, username='******', password='******',
requester=CrumbRequester(baseurl=url, username='******', password='******'))
def trigger_job(self, job_name, params=None):
if self.server.has_job(job_name, params):
self.server.build_job(job_name)
def get_latest_build_info(self, job_name):
job_instance = self.server.get_job(job_name)
latest_build = job_instance.get_last_build()
print latest_build, latest_build.get_status()
def get_buil_msg(jobName):
url = 'http://jenkins.ops.huihuang200.com/'
user = '******'
pwd = '1177e62132b6aa23f5445b878dc5d23e24'
dict_var = {'action_name': 'deploy'}
server = Jenkins(url, username=user, password=pwd)
server.build_job(jobName, dict_var)
last_build_number = server.get_job(
jobName).get_last_completed_buildnumber()
build_info = server.get_job(jobName).get_build(last_build_number)
build_url = build_info.get_build_url() + 'console'
build_result = build_info.get_status()
if build_result == 'SUCCESS':
print('build successfully \n %s \n %s') % (jobName, build_url)
else:
print('build Error\n %s \n %s') % (jobName, build_url)
class JenkinsStatus(object):
def __init__(self,
host_ip='127.0.0.1',
username=None,
password=None,
job=None):
self.host_ip = host_ip
self.username = username
self.password = password
self.job = job
self.jenkinsAPI = Jenkins('http://%s:8080' % self.host_ip,
username=self.username,
password=self.password)
@property
def get_lastbuild_status(self):
if self.jenkinsAPI.has_job(self.job):
job = self.jenkinsAPI.get_job(self.job)
last_build = job.get_last_build()
return last_build.get_status()
@property
def job_running(self):
if self.jenkinsAPI.has_job(self.job):
job = self.jenkinsAPI.get_job(self.job)
return job.is_running()
@property
def build_job(self):
if self.jenkinsAPI.has_job(self.job):
return self.jenkinsAPI.build_job(self.job)
class Job(object):
"""
deal with job
"""
def __init__(self, ip, uname, pwd, port="8080"):
self.url = "http://" + ip + ":" + port + "/"
self.server = Jenkins(self.url, username=uname, password=pwd)
def getVersion(self):
return json.dumps(self.server.version)
def getJobList(self):
return json.dumps(self.server.keys())
def getConfig(self, jobname):
return json.dumps(xmltodict.parse(self.server[jobname].get_config(),
encoding='utf-8'),
indent=4)
def getJobStatus(self, jobname):
infolist = {}
infolist['name'] = self.server[jobname].name
infolist['description'] = self.server[jobname].get_description()
infolist['running'] = self.server[jobname].is_running()
infolist['enabled'] = self.server[jobname].is_enabled()
return json.dumps(infolist)
def setConfig(self, config):
jsdict = json.loads(config)
print(xmltodict.unparse(jsdict, encoding='utf-8'))
return
def paramBuild(self, jobname, params):
buildnum = self.server.build_job(jobname, params)
return buildnum
def build_packages_from_jenkins(jenkins_url, job_name, file_path, username,
password):
j_server = Jenkins(jenkins_url, username, password)
next_build_number = j_server.get_job(job_name).get_next_build_number()
print "Next Package Verdsion ID is: %s\nStart Pack ,please wait..." % next_build_number
get_new_build = j_server.build_job(job_name)
time.sleep(8 * 60) # wait 8 minutes until new packages build finished
if j_server.get_job(job_name).is_running():
print "Need more time to pack..."
time.sleep(3 *
60) # if stil in build status, then wait another 3 minutes
last_complete_build = j_server.get_job(
job_name).get_last_completed_build().get_number()
if last_complete_build == next_build_number:
new_apk_build = j_server.get_job(
job_name).get_last_completed_build().get_artifact_dict().items()
apk_name = "app_%s.apk" % last_complete_build # this is use the defined apk name in jenkins
for line in new_apk_build:
if apk_name in line:
new_apk_url = line[1]
print "The new success pack ID is: %s\n" % last_complete_build
print "Download URL is: %s\nDownloading..." % new_apk_url
new_apk_url._do_download(file_path)
print "Success!"
else:
print 'Pack Failed,please check!'
exit()
def run_job(job_name: str, params: dict):
jenkins_api_token = os.getenv('JENKINS_API_TOKEN')
crumb = CrumbRequester(username='******',
password=jenkins_api_token,
baseurl=jenkins_url)
jenkins = Jenkins(jenkins_url,
username='******',
password=jenkins_api_token,
requester=crumb,
timeout=60)
jenkins.build_job(job_name, params)
job = jenkins[job_name]
qi = job.invoke(build_params=params)
tries = 0
while not qi.is_queued():
if tries > 10:
break
time.sleep(1)
tries += 1
if qi.is_queued() or qi.is_running():
qi.block_until_complete(delay=3)
build = qi.get_build()
while build.is_running():
print('.')
time.sleep(5)
is_build_good = build.is_good()
if is_build_good is not True:
print("build faild")
print(build.get_console())
sys.exit(1)
if is_build_good is True:
print(job_name + " is successful")
class JenkinsConnector:
def __init__(self, args):
self.jenkins = Jenkins(args['url'],args['username'],args['password'])
def getJenkins(self):
return self.jenkins
def start_job_with_params(self, job_name, params):
self.jenkins.build_job(job_name, params)
def query_build(self, job_name):
job = self.jenkins.get_job(job_name)
build = job.get_last_build()
return build
def query_job(self, job_name):
job = self.jenkins.get_job(job_name)
return job
class ltz(object):
def __init__(self, jobname, chose='jenkins'):
self.jobname = jobname
config = get_jk_config(chose)
self.server = Jenkins(*config, useCrumb=True) # 使用碎片
self.job = self.server[self.jobname]
def buildJob(self): # 新构建项目 name
self.server.build_job(self.jobname)
def get_next_build_number(self): # 获取下一次构建号
return self.job.get_job_info['nextBuildNumber']
def getJobStatus(self): # 查看job是否正在执行
if self.job.is_running():
return True
elif self.job.is_queued_or_running():
print("jon is queue")
else:
return False
def getLastBuildNumber(self): # 得到最后一次的job的序列号
return self.job.get_last_buildnumber()
def getStatus(self, jobno): # 构建状态
try:
myBuild = self.server[self.jobname].get_build(jobno)
print(myBuild.get_status())
except KeyError:
print("Build number: %s is not existed" % jobno)
return False
def getBuildTime(self, jobno): # 最后构建时间
myBuild = self.server[self.jobname].get_build(jobno)
print(myBuild.get_timestamp())
return myBuild.get_timestamp()
def getConsole(self, jobno): # 控制台日志
myBuild = self.server[self.jobname].get_build(jobno)
return myBuild.get_console()
def sync_code_job_cluster(project_name, task_id):
"""
集群机器代码同步任务, def check_status方法中判断当项目部署完成后并且是success成功状态则调用本方法
:param project_name: 项目名称
:param task_id: 任务编号
:return:
"""
sync_job_name = config('SYNC_JOB_NAME').split(',')
server_2 = Jenkins(config('JENKINS_URL'),
username=config('JENKINS_USER'),
password=config('JENKINS_PASS'))
if project_name in sync_job_name:
time.sleep(120)
logger.info(
"开始同步集群代码：params={'sync_project': %s, 'code': 'class', 'slb': True, 'is_restart_tomcat': True}"
% project_name)
server_2.build_job('trip-sbox-sync',
params={
'sync_project': project_name,
'code': 'class',
'slb': True,
'is_restart_tomcat': True
})
build_id = JenkinsStauts.jenkins_task_id('trip-sbox-sync')
Sync_Model = SyncJobHistory()
Sync_Model.sync_id = build_id
Sync_Model.sync_project = project_name
Sync_Model.sync_code_type = 'class'
Sync_Model.created_time = time.strftime("%Y-%m-%d %H:%M:%S",
time.gmtime())
Sync_Model.build_status = 'BUILD_ING'
Sync_Model.off_slb = True
Sync_Model.is_restart_tomcat = True
Sync_Model.save()
sync_cluster_result = JenkinsStauts.jenkins_sync_status(
project_name='trip-sbox-sync', build_id=build_id, task_id=task_id)
else:
logger.info('任务：%s, 属于单机项目无集群机器, 跳过同步。' % (project_name))
class Myjenkins():
def __init__(self,url,username,password):
self.server=Jenkins(url, username=username, password=password)
def get_job_details(self):
for job_name,job_instance in self.server.get_jobs():
print(job_instance.name)
print(job_instance.get_description())
print(job_instance.is_running())
print(job_instance.is_enabled())
print("######")
def create_job(self,**config):
curr_con=open(config['xml'],'r+',encoding='utf-8')
cc=curr_con.read()
self.server.create_job(config["jobname"],cc.encode('utf-8'))
def create_job_str(self,**config):
cc=jkconfig.base
self.server.create_job(config["jobname"],cc.encode('utf-8'))
def build_job(self,jobname,params=None):
self.server.build_job(jobname,params)
class JenkinsJob(object):
""""POST请求必须关闭Jenkins的CSRF，或者提供Jenkins-Crumb（http://192.168.37.100:8080/crumbIssuer/api/xml）"""
def __init__(self, url, username, password):
self.server = Jenkins(url, username=username, password=password)
def job_build(self, job_name, params=None):
if params is None:
params = {}
ret = self.server.build_job(job_name, params)
return ret
def job_query(self, job_name):
try:
job = self.server.get_job(job_name)
last_build = job.get_last_stable_build()
build_num = last_build.get_number()
build_status = last_build.get_status()
tzutc_8 = timezone(timedelta(hours=8))
build_time = last_build.get_timestamp()
build_time = build_time.astimezone(tzutc_8).strftime(
'%Y-%m-%d %H:%M:%S')
build_duration = last_build.get_duration().total_seconds()
ret = {
'job_name': job_name,
'build_num': build_num,
'build_status': build_status,
'build_time': build_time,
'build_duration': build_duration
}
except Exception:
traceback.print_exc()
ret = {}
return ret
def job_console(self, job_name):
job = self.server.get_job(job_name)
last_build = job.get_last_stable_build()
ret = last_build.get_console()
return ret
def job_list(self):
ret = self.server.get_jobs_list()
return ret
def populateDashboard(self):
if request.method == 'POST':
job = Jenkins('http://10.2.162.80:9090')
env = request.form.get('sel1')
chromeChecked = request.form.get("chrome") != None
firefoxChecked = request.form.get("firefox") != None
ieChecked = request.form.get("ie") != None
edgeChecked = request.form.get("edge") != None
if chromeChecked:
job.build_job('ChromeJob')
if firefoxChecked:
job.build_job('FirefoxJob')
if edgeChecked:
job.build_job('EdgeJob')
if ieChecked:
job.build_job('IEJob')
return redirect(url_for('age'))
return render_template('index.html')
class JenkinsJob(object):
def __init__(self, url, username, password):
self.server = Jenkins(url, username=username, password=password)
def job_build(self, job_name):
params = {'Branch': 'oriin/master', 'host': '192.168.1.100'}
ret = self.server.build_job(job_name, params)
return ret
def job_query(self, job_name):
try:
job = self.server.get_job(job_name)
last_build = job.get_last_stable_build()
build_num = last_build.get_number()
build_status = last_build.get_status()
tzutc_8 = timezone(timedelta(hours=8))
build_time = last_build.get_timestamp()
build_time = build_time.astimezone(tzutc_8).strftime('%Y-%m-%d %H:%M:%S')
build_duration = last_build.get_duration().total_seconds()
ret = {
'job_name': job_name,
'build_num': build_num,
'build_status': build_status,
'build_time': build_time,
'build_duration': build_duration
}
except Exception:
traceback.print_exc()
ret = {}
return ret
def job_console(self, job_name):
job = self.server.get_job(job_name)
last_build = job.get_last_stable_build()
ret = last_build.get_console()
return ret
def job_list(self):
ret = self.server.get_jobs_list()
return ret
class GithubEventHandler(object):
def __init__(self, config=None, jenkins=None):
self.__config = config
self.__jenkins = jenkins
self._logger = logging.getLogger(__name__)
# read the config and setup Jenkins API
if self.__config is None:
config_file = resource_filename(__package__, 'config.yaml')
self.__config = Config.from_yaml(config_file)
if self.__jenkins is None:
requester = PersistentRequester(
self.__config.get_jenkins_user(),
self.__config.get_jenkins_pass(),
baseurl=self.__config.get_jenkins_url(),
)
self.__jenkins = Jenkins(
baseurl=self.__config.get_jenkins_url(),
username=self.__config.get_jenkins_user(),
password=self.__config.get_jenkins_pass(),
requester=requester
)
@staticmethod
def get_metadata(event_type, payload):
# decode the payload
# @see examples/*.json
# @see https://developer.github.com/v3/activity/events/types/#pushevent
meta = {}
if event_type == "push":
meta = {
'owner': payload['repository']['owner'].get('name'),
'repo': payload['repository']['full_name'],
'branch': payload['ref'].replace('refs/heads/', ''),
'target_branch': '',
'author': payload['head_commit']['author']['name'],
'email': payload['head_commit']['author']['email'],
'commit': payload['head_commit']['id']
}
if event_type == "pull_request":
meta = {
'owner': payload['repository']['owner'].get('name'),
'repo': payload['repository']['full_name'],
'branch': payload['pull_request']['head']['ref'],
'commit': payload['pull_request']['head']['sha'],
'target_branch': payload['pull_request']['base']['ref'],
'comment': payload['pull_request']['body'],
'pull_num': payload['pull_request']['number'],
}
if event_type == "pull_request_review_comment":
meta = {
'owner': payload['repository']['owner'].get('name'),
'repo': payload['repository']['full_name'],
'branch': payload['pull_request']['head']['ref'],
'commit': payload['pull_request']['head']['sha'],
'target_branch': payload['pull_request']['base']['ref'],
'comment': payload['comment']['body'],
'pull_num': payload['pull_request']['number'],
}
return meta
def process_github_event(self, event_type, payload):
# delete branch events are missing crucial information, skip throwing an error in such cases
if payload.get('deleted') is True:
return 0
meta = self.get_metadata(event_type, payload)
job_param_keys = 'repo branch commit author email pull_num'.split(' ')
self._logger.info("Event received: %s", json.dumps(meta))
# try to match the push with list of rules from the config file
matches = self.__config.get_matches(meta['repo'], meta['branch'], meta['target_branch'], event_type, meta.get('comment'))
job_default_params = dict([
(k, v.encode('utf-8') if isinstance(v, basestring) else v)
for k, v in meta.items()
if k in job_param_keys
])
jobs_started = []
for match in matches:
self._logger.info("Event matches: %s", json.dumps(match))
job_params = job_default_params.copy()
if 'job_params' in match:
job_params.update(match['job_params'])
if 'jobs' in match:
try:
for job_name in match['jobs']:
self._logger.info("Running %s with params: %s", job_name, job_params)
# prevent "BadParams: This job does not support parameters"
job = self.__jenkins.jobs[job_name]
self.__jenkins.build_job(job_name, job_params if job.has_params() else None)
self._logger.info("Run of %s job scheduled", job_name)
jobs_started.append({'name': job_name, 'params': job_params})
except NotFound as e:
self._logger.info("Jenkins job was not found", exc_info=True)
raise GithubEventException("Jenkins job was not found: {}".format(e.message))
except JenkinsAPIException as e:
self._logger.info("Jenkins refused to queue a job: {}".format(e.message), exc_info=True)
pass
else:
raise GithubEventException("No match found")
return jobs_started
import speech_recognition as sr
from jenkinsapi.jenkins import Jenkins
user_command = ""
r = sr.Recognizer()
with sr.Microphone() as source:
print "Listening....."
audio = r.listen(source)
try:
print("You said " + r.recognize(audio))
user_command = r.recognize(audio)
except LookupError:
print("Could not understand audio")
jenkins_instance = Jenkins('http://65.50.13.61:8080')
jenkins_instance.build_job(user_command)
#!/usr/bin/env python
import logging
from jenkinsapi.jenkins import Jenkins
log_level = getattr(logging, 'DEBUG')
logging.basicConfig(level=log_level)
logger = logging.getLogger()
jenkins_url = "http://docker:8080/"
api = Jenkins(jenkins_url)
logger.info('trigger the [cd-seed] job')
api.build_job('cd-seed')
class JenkinsDemo:
def __init__(self, job_name, chose='jenkins'):
self.job_name = job_name
config = get_jk_config(chose)
self.jk = Jenkins(*config, useCrumb=True)
def __get_job_from_keys(self):
choose_list = []
print(self.jk.keys())
for my_job_name in self.jk.keys():
if self.job_name in my_job_name:
choose_list.append(my_job_name)
return choose_list
def __job_build(self, my_job_name):
if self.jk.has_job(my_job_name):
my_job = self.jk.get_job(my_job_name)
if not my_job.is_queued_or_running():
try:
last_build = my_job.get_last_buildnumber()
except:
last_build = 0
build_num = last_build + 1
# 开始打包
try:
self.jk.build_job(my_job_name)
except Exception as e:
log.error(str(e))
# 循环判断Jenkins是否打包完成
while True:
if not my_job.is_queued_or_running():
# 获取最新一次打包信息
count_build = my_job.get_build(build_num)
# 获取打包开始时间
start_time = count_build.get_timestamp(
) + datetime.timedelta(hours=8)
# 获取打包日志
console_out = count_build.get_console()
# 获取状态
status = count_build.get_status()
# 获取变更内容
change = count_build.get_changeset_items()
log.info(" " + str(start_time) + " 发起的" + my_job_name +
"构建已经完成，构建的状态为： " + status)
p2 = re.compile(r".*ERROR.*")
err_list = p2.findall(console_out)
log.info("打包日志为：" + str(console_out))
if status == "SUCCESS":
if len(change) > 0:
for data in change:
for file_list in data["affectedPaths"]:
log.info(" 发起的" + my_job_name +
" 变更的类： " + file_list)
log.info(" 发起的" + my_job_name +
" 变更的备注： " + data["msg"])
log.info(" 发起的" + my_job_name +
" 变更的提交人： " +
data["author"]["fullName"])
else:
log.info(" 发起的" + my_job_name + " 构建没有变更内容！")
if len(err_list) > 0:
log.warning(" 构建的" + my_job_name +
"构建状态为成功，但包含了以下错误：")
for error in err_list:
log.error(error)
else:
if len(err_list) > 0:
log.warning(" 构建的" + my_job_name + "包含了以下错误：")
for error in err_list:
log.error(error)
break
else:
log.warning(" 发起的" + my_job_name + ' Jenkins is running')
else:
log.warning(" 发起的" + my_job_name + ' 没有该服务')
def run(self):
my_job_name = self.__get_job_from_keys()
if len(my_job_name) == 1:
self.__job_build(my_job_name[0])
elif len(my_job_name) == 0:
log.error(" 输入的job名不正确！")
class EXPbot:
def __init__(self, telegram):
self.updater = Updater(telegram)
self.j = self.updater.job_queue
self.alert = {}
self.currissue = {}
self.curmsg = {}
self.current_work = {}
dp = self.updater.dispatcher
dp.add_handler(CommandHandler('redmine', self.redmine))
dp.add_handler(CommandHandler('jenkins', self.jenkins))
dp.add_handler(CommandHandler('auth', self.auth, pass_args=True))
dp.add_handler(CallbackQueryHandler(self.filter_for_buttons))
#dp.add_handler(CallbackQueryHandler(self.filter_for_inline))
#dp.add_handler(InlineQueryHandler(self.inline_search))
#dp.add_handler(ChosenInlineResultHandler(self.inline_picture))
#dp.add_handler(MessageHandler([Filters.text], self.command_filter))
#dp.add_handler(MessageHandler([Filters.command], self.unknow))
def logger_wrap(self, message, command):
user = message.from_user
logger.info(u'%s from %s @%s %s' %
(message.text[0:20], user.first_name, user.username,
user.last_name))
@staticmethod
def put_user(user, key, value):
user.__setattr__(key, value)
db.session.commit()
def auth(self, bot, update, args):
user = db.query(User).filter_by(
user_id=str(update.message.from_user.id)).first()
if user.user_auth == 1:
return True
elif args == ['123']:
EXPbot.put_user(user, 'user_auth', 1)
bot.sendMessage(update.message.chat_id,
text='Ok',
parse_mode=ParseMode.MARKDOWN)
return True
else:
bot.sendMessage(update.message.chat_id,
text=u'Необходима авторизация',
parse_mode=ParseMode.MARKDOWN)
return False
def redmine(self, bot, update):
try:
db.add(
User(str(update.message.from_user.id),
update.message.from_user.name, 0))
db.commit()
except:
db.rollback()
self.logger_wrap(update.message, 'redmine')
self.alert[str(update.message.from_user.id)] = 0
if not self.auth(bot, update, args=None):
return
chat_id = str(update.message.chat_id)
try:
bot.editMessageReplyMarkup(chat_id=chat_id, message_id=self.curmsg)
except:
pass
text = EXPbot.redmine_info()
self.currissue[str(update.message.from_user.id)] = text
keyboard = EXPbot.do_keyboard('redmine')
bot.sendMessage(chat_id,
text=text,
parse_mode=ParseMode.MARKDOWN,
reply_markup=keyboard)
@staticmethod
def redmine_info():
t_time = datetime.date.today()
redmine = Redmine('http://help.heliosoft.ru', key='')
issues_open_prov = redmine.issue.filter(project_id='experium',
status_id='3',
cf_19='me')
issues_open_me = redmine.issue.filter(assigned_to_id='me')
issues_open_all_totay = redmine.issue.filter(project_id='experium',
created_on=str(t_time))
issues_open_all_totay_up = redmine.issue.filter(project_id='experium',
updated_on=str(t_time))
text = ''
text += u'*НА ПРОВЕРКУ!!!*\n'
for t in issues_open_prov:
text += (
u'[%s](http://help.heliosoft.ru/issues/%s) %s %s\n' %
(str(t.id), str(t.id), str(t.status), str(t).decode('utf8')))
text += u'*\n\nЗАДАЧИ НА МНЕ!!!*\n'
for t in issues_open_me:
text += (
u'[%s](http://help.heliosoft.ru/issues/%s) %s %s\n' %
(str(t.id), str(t.id), str(t.status), str(t).decode('utf8')))
text += (u'\n\n*Тикеты, добавленные за %s:*\n' %
str(t_time.strftime('%d %b %Y')))
for t in issues_open_all_totay:
text += (
u'[%s](http://help.heliosoft.ru/issues/%s) %s %s\n' %
(str(t.id), str(t.id), str(t.status), str(t).decode('utf8')))
text += (u'\n\n*Тикеты, обновленные за %s:*\n' %
str(t_time.strftime('%d %b %Y')))
for t in issues_open_all_totay_up:
text += (
u'[%s](http://help.heliosoft.ru/issues/%s) %s %s\n' %
(str(t.id), str(t.id), str(t.status), str(t).decode('utf8')))
return text
def jenkins(self, bot, update):
try:
db.add(
User(str(update.message.from_user.id),
update.message.from_user.name, 0))
db.commit()
except:
db.rollback()
try:
chat_id = str(update.message.chat_id)
if not self.auth(bot, update, args=None):
return
try:
bot.editMessageReplyMarkup(chat_id=chat_id,
message_id=self.curmsg)
except:
pass
self.curmsg[str(
update.message.from_user.id)] = str(update.message.message_id +
1)
callback = 0
except:
chat_id = str(update.callback_query.message.chat_id)
self.curmsg[str(update.callback_query.from_user.id
)] = update.callback_query.message.message_id
callback = 1
self.J = Jenkins('http://buildsrv.experium.ru/',
username="",
password="")
text = u'*Список доступных работ:*\n'
buttons = []
for t in self.J.keys():
if 'Experium' in t:
buttons.append([
telegram.InlineKeyboardButton(text=str(t),
callback_data=str(t))
])
keyboard = telegram.InlineKeyboardMarkup(buttons)
if callback == 0:
bot.sendMessage(chat_id,
text=text,
parse_mode=ParseMode.MARKDOWN,
reply_markup=keyboard)
else:
bot.editMessageText(text=text,
chat_id=chat_id,
message_id=self.curmsg[str(
update.callback_query.from_user.id)],
parse_mode=ParseMode.MARKDOWN,
reply_markup=keyboard)
def jenkins_work_info(self, cur_job):
text = ''
j = self.J.get_job(cur_job)
try:
q = j.get_last_good_build()
text = u'*%s*\n\n*Последняя удачная сборка:*\n%s SVN REV - %s' % (
cur_job, str(q), str(q._get_svn_rev()))
changes = q.get_changeset_items()
text += u'\n\n*Изменения:*'
for t in range(len(changes)):
text += re.sub(
r'#?(\d{4,}\b)',
r'[#\1](http://help.heliosoft.ru/issues/\1)',
u'\n*%s)*%s' %
(str(t + 1), str(changes[t]['msg']).decode('utf8')))
except:
pass
if j.is_running():
text += u'\n\n*Текущее состояние:* идет сборка'
else:
text += u'\n\n*Текущее состояние:* сборка не выполняется'
return text
def filter_for_buttons(self, bot, update):
query = update.callback_query
if query.data == 'jenkins_build':
j = self.J.get_job(self.current_work[str(query.from_user.id)])
if not j.is_queued_or_running():
self.J.build_job(self.current_work[str(query.from_user.id)])
self.job_jenkins_build = Job(self.build_monitor,
10.0,
repeat=True,
context=[
query.message.chat_id,
self.current_work[str(
query.from_user.id)]
])
self.j.put(self.job_jenkins_build)
bot.answerCallbackQuery(callback_query_id=str(query.id),
text=u'Сборка запущена')
elif query.data == 'jenkins_close':
self.jenkins(bot, update)
elif query.data == 'redmine_alert':
if self.alert[str(query.from_user.id)] == 0:
bot.answerCallbackQuery(callback_query_id=str(query.id),
text=u'Уведомления включены')
self.alert[str(query.from_user.id)] = 1
self.job_redmine_alert = Job(
self.issue_monitor,
60.0,
repeat=True,
context=[query.message.chat_id, query.from_user.id])
self.j.put(self.job_redmine_alert)
else:
bot.answerCallbackQuery(callback_query_id=str(query.id),
text=u'Уведомления выключены')
self.alert[str(query.from_user.id)] = 0
else:
text = self.jenkins_work_info(query.data)
self.current_work[str(query.from_user.id)] = query.data
keyboard = EXPbot.do_keyboard('jenkins')
bot.editMessageText(text=text,
chat_id=query.message.chat_id,
message_id=self.curmsg[str(
query.from_user.id)],
parse_mode=ParseMode.MARKDOWN,
reply_markup=keyboard)
@staticmethod
def do_keyboard(flag):
if flag == 'jenkins':
keyboard = telegram.InlineKeyboardMarkup([[
telegram.InlineKeyboardButton(text=u'⚒',
callback_data='jenkins_build'),
#telegram.InlineKeyboardButton(text=u'📢', callback_data='jenkins_update'),
telegram.InlineKeyboardButton(text=u'❌',
callback_data='jenkins_close')
]])
if flag == 'redmine':
keyboard = telegram.InlineKeyboardMarkup([[
telegram.InlineKeyboardButton(text=u'📢',
callback_data='redmine_alert')
]])
return keyboard
def build_monitor(self, bot, job):
j = self.J.get_job(job.context[1])
if j.is_running():
return
else:
bot.sendMessage(
chat_id=job.context[0],
text=u'Сборка %s завершена\n\n%s' %
(job.context[1], self.jenkins_work_info(job.context[1])),
parse_mode=ParseMode.MARKDOWN)
self.job_jenkins_build.schedule_removal()
def issue_monitor(self, bot, job):
if self.alert[str(job.context[1])] == 1:
try:
new_text = EXPbot.redmine_info()
if self.currissue[str(job.context[1])] != new_text:
cd = difflib.ndiff(
u''.join(self.currissue[str(
job.context[1])]).splitlines(),
u''.join(new_text).splitlines())
final = '\n'.join(list(cd))
bot.sendMessage(chat_id=job.context[0],
text=u'📢\n%s' % final,
parse_mode=ParseMode.MARKDOWN)
self.currissue[str(job.context[1])] = new_text
except:
pass
else:
self.job_redmine_alert.schedule_removal()
def unknow(self, bot, update):
self.logger_wrap(update.message, 'unknow')
def error(self, bot, update, error):
self.logger_wrap(update.message, 'error')
logger.warn('Update "%s" caused error "%s"' % (update, error))
def idle(self):
self.updater.start_polling()
self.updater.idle()
def run_jenkins_job(job_name):
job = Jenkins('http://172.30.205.179:9090')
#job = Jenkins('http://10.2.162.80:9090')
job.build_job(job_name)
def buildJob(self, baseUrl, jobName, parameter=None):
job = Jenkins(baseUrl)
job.build_job(jobname, params)
"""
Start a Parameterized Build
"""
from __future__ import print_function
from jenkinsapi.jenkins import Jenkins
jenkins = Jenkins('http://localhost:8080')
params = {'VERSION': '1.2.3', 'PYTHON_VER': '2.7'}
# This will start the job in non-blocking manner
jenkins.build_job('foo', params)
# This will start the job and will return a QueueItem object which
# can be used to get build results
job = jenkins['foo']
qi = job.invoke(build_params=params)
# Block this script until build is finished
if qi.is_queued() or qi.is_running():
qi.block_until_complete()
build = qi.get_build()
print(build)
class ltz(object):
def __init__(self, job_name, chose='jenkins'):
self.job_name = job_name
config = get_server_config(chose)
self.server = Jenkins(*config, useCrumb=True) # 使用碎片
self.job = self.server[self.job_name]
def buildJob(self): # 构建项目 name
self.server.build_job(self.job_name)
def get_next_build_number(self): # 获取下一次构建号
return self.job.get_job_info['nextBuildNumber']
def getJobStatus(self): # 查看job是否正在执行
if self.job.is_running():
return True
elif self.job.is_queued_or_running():
print("jon is queue")
else:
return False
def getLastBuildNumber(self): # 得到最后一次的job的序列号
return self.job.get_last_buildnumber()
def getStatus(self, jobno): # 构建状态
try:
myBuild = self.server[self.job_name].get_build(jobno)
print(myBuild.get_status())
except KeyError:
print("Build number: %s is not existed" % jobno)
return False
def getBuildTime(self, jobno): # 最后构建时间
myBuild = self.server[self.job_name].get_build(jobno)
print(myBuild.get_timestamp())
return myBuild.get_timestamp()
def getConsole(self, jobno): # 控制台日志
myBuild = self.server[self.job_name].get_build(jobno)
return myBuild.get_console()
# todo 其他
def __get_job_from_keys(self):
choose_list = []
print(self.server.keys())
for my_job_name in self.server.keys():
if self.job_name in my_job_name:
choose_list.append(my_job_name)
return choose_list # 获取所有的job的信息
def __job_build(self, my_job_name):
if self.server.has_job(my_job_name):
# my_job = self.job
my_job = self.server.get_job(my_job_name)
if not my_job.is_queued_or_running():
try: # 如果没有执行得到最后序列号
last_build = my_job.get_last_buildnumber()
except:
last_build = 0
build_num = last_build + 1 # 序列号加1 成为下一次构建号
# 开始打包
try:
self.server.build_job(my_job_name)
except Exception as e:
logging.error(str(e)) # 构建项目失败打印日志
# 循环判断门jenkins是否打包完成
while True:
if not my_job.is_queued_or_running():
# 获取最新一次打包信息
count_build = my_job.get_build(build_num)
# 获取打包开始时间
# start_time = count_build.get_timestamp() + datetime.timedelta(hours=8)
start_time = count_build.get_timestamp() #时区加上8小时
# 获取打包日志
console_out = count_build.get_console()
# 获取状态
status = count_build.get_status()
# 获取变更内容
change = count_build.get_changeset_items()
logging.info("已经构建完成" + start_time)
p2 = re.compile(r".*ERROR.*")
err_list = p2.findall(console_out) # 寻找日志中错误的列表信息
logging.info("打包日志为:%s", str(console_out))
if status == "success":
if len(change) > 0:
for data in change:
for file_list in data["affectedPaths"]:
logging.info("发起的" + my_job_name +
"变更的类：" + file_list)
logging.info("发起的" + my_job_name +
"变更的备注：" + data["msg"])
logging.info("发起的" + my_job_name +
"变更的提交人：" +
data["author"]["fullName"])
else:
logging.info("发起的" + my_job_name +
"构建没有变更的内容！")
if len(err_list) > 0: # 没有变更
logging.warning("构建的" + my_job_name +
"构建状态成功，但包含了以下错误")
for error in err_list:
logging.info(error)
else:
if len(err_list) > 0:
logging.warning("构建的" + my_job_name +
"包含了以下错误:")
for error in err_list:
logging.error(error)
break
else:
logging.warning("发起的" + my_job_name + "jenkins is running")
def run(self):
my_job_name = self.__get_job_from_keys()
if len(my_job_name) == 1:
self.__job_build(my_job_name[0])
elif len(my_job_name) == 0:
logging.error("输入job名称不对,次任务无法构建")
def post(self, request, *args, **kwargs):
"""
创建部署回滚任务
:param request:
:param args: {'id': 1}
:param kwargs:
:return:
"""
if not request.user.is_superuser:
return JsonResponse({
"errcode": 403,
"msg": "您当前无权操作！",
"data": []
},
json_dumps_params={'ensure_ascii': False})
data = json.loads(request.body)['params']
project_name = data['project_name']
package_name = data['package_name']
backup_type = data['backup_type']
namespace = data['namespace']
server = Jenkins(config('JENKINS_URL'),
username=config('JENKINS_USER'),
password=config('JENKINS_PASS'))
if backup_type == "增量更新" or backup_type == "全量更新":
lock = conn_redis.get(project_name + "_lock")
logger.info("获取任务锁: %s" % lock)
if lock is not None and lock.decode('utf-8') == "True":
logger.info("有其他任务正在进行中, 请稍后再试! {%s}" % project_name)
return JsonResponse(data={
"msg": "有其他任务正在进行中, 请稍后再试!",
"errcode": -1
})
else:
try:
deploy_params = {
'Deploy': 'rollback',
'SLB': True,
'Inc_update': False,
'on_slb': True,
'rollback_version': package_name
}
logger.info(
'开始回滚项目: %s, 版本: %s, 操作人: %s' %
(project_name, package_name, request.user.name))
build_id = JenkinsStauts.jenkins_task_id(project_name)
server.build_job(project_name, params=deploy_params)
# todo 写入回滚日志表
async_result = check_rollback_status.delay(
project_name, build_id)
logger.info('回滚的项目:%s 构建状态异步任务返回ID: %s, 状态: %s' %
(project_name, str(
async_result.id), str(async_result.state)))
logger.info('回滚的项目正在部署中, 稍后请注意钉钉通知: %s' %
str(deploy_params))
return JsonResponse(data={
"msg": "项目版本回退中, 稍后请注意钉钉通知",
"errcode": 0
})
except BaseException as e:
logger.error(
'回滚失败, 请及时检查失败原因 %s' % str(traceback.format_exc()), e)
else:
lock = conn_redis.get(project_name + "_lock")
logger.info("获取任务锁: %s" % lock)
if lock is not None and lock.decode('utf-8') == "True":
logger.info("有其他任务正在进行中, 请稍后再试! {%s}" % project_name)
return JsonResponse(data={
"msg": "有其他任务正在进行中, 请稍后再试!",
"errcode": -1
})
else:
if project_name is not None and package_name is not None and namespace is not None:
try:
# 加锁，回滚历史版本
logger.info(
'开始回滚项目: %s, 版本: %s, 操作人: %s' %
(project_name, package_name, request.user.name))
conn_redis.set(project_name + "_lock", 'True')
logger.info('回滚操作已加锁，等待下一步操作')
# todo 调用kubernetes api接口, 对deloyment回滚
logger.info(
"开始回滚项目：%s, 命名空间：%s, 镜像版本：%s" %
(project_name, namespace, data['registry']))
from api.utils.k8s_deployment_rollback import KubernetesApi
deployment_rollback_status = KubernetesApi.update_deployment(
project_name, namespace, data['registry'])
if deployment_rollback_status.get('errcode') != 0:
return JsonResponse(
{
"errcode": 500,
"msg": "回滚异常",
"data": []
},
json_dumps_params={'ensure_ascii': False})
return JsonResponse(
{
"errcode": 0,
"msg": "回滚任务已开始，稍后请注意钉钉通知",
"data": []
},
json_dumps_params={'ensure_ascii': False})
except BaseException as e:
logger.error(
'回滚失败, 请及时检查失败原因 %s' % str(traceback.format_exc()),
e)
return JsonResponse(
data={
"errcode": 404,
"msg": "回滚版本信息出错, 或namespace未关联应用！",
"data": "null"
})
def trigger_job(param):
j = Jenkins("http://qa.sc.couchbase.com/")
job = j.build_job("test_suite_dispatcher", param)
print("job started: {}".format(job))
import jenkinsapi
from jenkinsapi.jenkins import Jenkins
J = Jenkins('http://localhost:8080')
J.build_job("test_job")
}
r = requests.post("http://git.anvil8.com/api/v3/projects?private_token={}".format(config.get('gitlab_token'),), data=create_project_data)
response = r.json()
print("Create git repo on http://git.anvil8.com")
config['git_url'] = '[email protected]:{}.git'.format(response.get('path_with_namespace'),)
"""
Add jenkins user as reporter to repo
"""
add_member_data = {
'id': response.get('id'),
'user_id': 28,
'access_level': 20
}
r = requests.post("http://git.anvil8.com/api/v3/projects/{}/members?private_token={}".format(response.get('id'), config.get('gitlab_token')), data=add_member_data)
"""
Init git repo and push project
"""
subprocess.call(['git', 'init'])
subprocess.call(['git', 'remote', 'add', 'origin', config.get('git_url')])
subprocess.call(['git', 'add', '.'])
subprocess.call(['git', 'commit', '-am', '"Initial commit"'])
subprocess.call(['git', 'push', 'origin', 'master'])
print('Create project on Jenkins')
new_job = J.copy_job('template_project_python3', config.get('repo_name'))
new_job.modify_scm_url(config.get('git_url'))
J.build_job(config.get('repo_name'))
shutil.rmtree('./config')
def post(self, request, *args, **kwargs):
"""
部署代码到服务器, 只允许管理员部署 (IsAdminUser)
:param request:
:param args:
:param kwargs:
:return:
"""
data = json.loads(request.body)['params']
task_id = data['taskId']
global LOCK_PROJECT
try:
query_deploy_task = DeployTask.objects.filter(
task_id=task_id).first()
project_id = query_deploy_task.project_id
query_project = Project.objects.filter(pk=project_id).first()
project_name = query_project.title
code_version = str(query_deploy_task.version).lower()
deploy_type = query_deploy_task.deploy_type
server = Jenkins(config('JENKINS_URL'),
username=config('JENKINS_USER'),
password=config('JENKINS_PASS'))
build_history = BuildHistory()
# 判断job是否存在， 0为容器化应用，1为普通应用
if server.has_job(project_name):
lock_value = conn_redis.get(project_name + "_lock")
LOCK_PROJECT = project_name + "_lock"
if lock_value is not None and lock_value.decode(
'utf-8') == "True":
logger.warning("上一个任务正在进行中, 请等待任务结束后再试. 操作人: %s" %
request.user.name)
return JsonResponse(
data={
"errcode": 5001,
"msg": "上一个任务正在进行中, 请稍后再试! ",
"data": "null"
})
else:
conn_redis.set(project_name + "_lock", 'True')
logger.info("没有获取到锁, 进行加锁{%s} 操作防止业务部署异常" % project_name)
if query_deploy_task.deploy_type == "CONTAINER":
try:
# 截取版本号CONTAINER 正则提取1000
# version = re.findall('^CONTAINER_(?P<version>[0-9]+)', str(code_version).lower(), re.IGNORECASE)[0]
build_id = JenkinsStauts.jenkins_task_id(project_name)
server.build_job(project_name,
params={'APP_NUMBER': code_version})
logger.info(
'%s开始部署应用: %s, 任务ID: %s, 版本: %s, 发布类型: %s' %
(request.user.name, project_name, task_id,
code_version, deploy_type))
query_deploy_task.status = 3
query_deploy_task.save()
# 写入操作日志表
DeployLogs.objects.create(
task_id=data['taskId'],
project_id=query_deploy_task.project_id,
status=3,
message='%s已开始部署应用 ' % request.user.name)
# 插入构建记录到历史表
build_history.build_id = build_id
build_history.task_id = task_id
build_history.app_name = project_name
build_history.save()
async_result = check_status.delay(
project_name, build_id, task_id)
logger.info(
'已开始部署应用, 异步任务返回ID: %s, 状态: %s' %
(str(async_result.id), str(async_result.state)))
logger.info(
'项目部署大概需要5~15分钟, 稍后请注意钉钉通知, 应用名:%s, 版本号:%s' %
(str(project_name), str(code_version)))
return JsonResponse(
data={
"errcode": 0,
"msg": "项目部署中,稍后请注意钉钉通知!",
"data": {
"appliction": project_name,
"version": code_version
}
})
except BaseException as e:
conn_redis.delete(LOCK_PROJECT)
logger.error('部署异常, 开始释放锁%s 异常原因: %s' %
(LOCK_PROJECT, str(e)))
logger.error('部署异常, 异常原因: %s' %
str(traceback.format_exc()))
# 写入操作日志表
DeployLogs.objects.create(
task_id=data['taskId'],
project_id=query_deploy_task.project_id,
status=5,
message='版本发布出现异常 ')
return JsonResponse(
data={
"errcode": "4001",
"msg": "发布异常, 请联系运维处理!",
"data": e
},
status=status.HTTP_500_INTERNAL_SERVER_ERROR,
json_dumps_params={'ensure_ascii': False})
elif query_deploy_task.deploy_type == "INC":
lock = conn_redis.get(project_name + "_lock")
logger.info(f'获取锁{lock}， 部署类型INC')
if code_version.split('.')[-1] == "zip":
deploy_params = {
'Deploy': 'deploy',
'SLB': True,
'Inc_update': True,
'on_slb': True,
'svn_version': code_version
}
logger.info(
'%s开始部署应用: %s, 任务ID: %s, 版本: %s, 发布类型: %s' %
(request.user.name, project_name, task_id,
code_version, deploy_type))
build_id = JenkinsStauts.jenkins_task_id(project_name)
server.build_job(project_name, params=deploy_params)
query_deploy_task.status = 3
query_deploy_task.save()
# 写入操作日志表
DeployLogs.objects.create(
task_id=data['taskId'],
project_id=query_deploy_task.project_id,
status=6,
message='%s已开始部署应用 ' % request.user.name)
# 插入构建记录到历史表
build_history.build_id = build_id
build_history.task_id = task_id
build_history.app_name = project_name
build_history.save()
async_result = check_status.delay(
project_name, build_id, task_id)
logger.info('项目%s 构建状态异步任务返回ID: %s, 状态: %s' %
(project_name, str(async_result.id),
str(async_result.state)))
logger.info('项目增量部署中, 稍后请注意钉钉通知: %s' %
str(deploy_params))
return JsonResponse(data={
"msg": "项目部署中,稍后请注意钉钉通知",
"errcode": 0
})
else:
lock_value = conn_redis.delete(project_name + "_lock")
return JsonResponse(data={
"errcode": 404,
"msg": "升级包格式不正确"
})
elif query_deploy_task.deploy_type == 'FULL':
# todo 构建common包
from api.utils.jenkins_trip_common import TripCommon
from api.tasks import check_trip_common_status
common_params = {"AppName": project_name}
common_package = "trip-common"
build_id = TripCommon.jenkins_task_id(common_package)
server.build_job(common_package, params=common_params)
query_deploy_task.status = 3
query_deploy_task.save()
# 写入操作日志表
DeployLogs.objects.create(
task_id=task_id,
project_id=query_deploy_task.project_id,
status=6,
message='正在拉取基础包，此过程可能耗时较长。')
# 插入构建记录到历史表
build_history.build_id = build_id
build_history.task_id = task_id
build_history.app_name = common_package
build_history.save()
check_trip_common_status.delay(common_package, build_id,
task_id, request.user.name,
deploy_type, project_name)
return JsonResponse(data={
"msg": "项目全量部署中,稍后请注意钉钉通知",
"errcode": 0
})
else:
lock_value = conn_redis.delete(project_name + "_lock")
logger.info('发布类型不支持, 允许的范围(INC, CONTAINER)')
return JsonResponse(
data={
"errcode": "4003",
"msg": "不支持的操作, 请联系运维处理!",
"data": "null"
})
else:
logger.error('%s项目不存在, 请前往Jenkins配置' % project_name)
return JsonResponse(data={
"errcode": "4004",
"msg": "项目不存在,请联系运维添加项目！",
"data": "null"
})
except BaseException as e:
conn_redis.delete(LOCK_PROJECT)
logger.error('系统出现未知的错误, 开始释放锁%s 原因: %s' % (LOCK_PROJECT, str(e)))
logger.error('系统出现未知的错误, 异常原因: %s' % str(traceback.format_exc()))
return JsonResponse(data={
"errcode": "1006",
"msg": "系统异常, 请刷新重试!",
"data": e
},
status=status.HTTP_500_INTERNAL_SERVER_ERROR,
json_dumps_params={'ensure_ascii': False})
for k,v in j.get_jobs():
print k,v
for i in j.get_jobs():
job_instance = j.get_job(i[0])
#print dir(job_instance)
print 'Job Name:%s' %(job_instance.name)
print 'Job Description:%s' %(job_instance.get_description())
print 'Is Job running:%s' %(job_instance.is_running())
print 'Is Job enabled:%s' %(job_instance.is_enabled())
print "============================="
#print j.poll(tree='jobs[name,color,url]')
print j.get_folders()
create_job(jenkinshandle=j, jobname="senyang", jobxmlconfig="jon_config_template.xml")
j.build_job(jobname="senyang")
# time.sleep(10)
#update config.xml
xmlhandle=xml.dom.minidom.parse(job_config_template)
commands = xmlhandle.documentElement.getElementsByTagName('command')
commands[0].childNodes[0].nodeValue = "uname -a;df -h;"
custom_configxml_content = xmlhandle.toxml('UTF-8')
# j.create_job(jobname="senyang", xml=custom_configxml_content)
# j.build_job(jobname="senyang")
print j.get_job("senyang").get_last_build()
class MainWindow(QMainWindow):
"""MainWindow inherits QMainWindow"""
def __init__(self, parent=None):
QMainWindow.__init__(self, parent)
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.DB = shelve.open('DB.txt')
self.DB['HRM_Trunk'] = [r'C:\ProgramData\Experium_DB_TRUNK_HRM', r'C:\Program Files\EXPERIUM_DB_TRUNK_HRM','0','0']
self.DB['HRM_Release'] = [r'C:\ProgramData\Experium_DB_RELEASE_HRM', r'C:\Program Files\EXPERIUM_DB_RELEASE_HRM','0','1']
self.DB['AGN_Trunk'] = [r'C:\ProgramData\Experium_DB_TRUNK_KA', r'C:\Program Files\EXPERIUM_DB_TRUNK','1','0']
self.DB['AGN_Release'] = [r'C:\ProgramData\Experium_DB_RELEASE_KA', r'C:\Program Files\EXPERIUM_DB_RELEASE_RA','1','1']
self.trunk_expcl_path = r'X:\ExperiumTrunk'
self.release_expcl_path = r'X:\ExperiumRelease'
self.cl_exp_path = r'C:\Program Files\Experium'
self.ui.lineEdit_7.setText(self.cl_exp_path)
self.ui.lineEdit_3.setText(self.DB['HRM_Trunk'][0])
self.ui.lineEdit_6.setText(self.DB['HRM_Trunk'][1])
self.type_flag = (self.DB['HRM_Trunk'][2])
self.trunk_flag = (self.DB['HRM_Trunk'][3])
self.ui.comboBox.currentIndexChanged.connect(self.db_change)
self.cl_localdata_path = r'C:\Users\win7_test\AppData\Roaming\Experium\Client'
self.data_trunk_path = r'X:\ExperiumTrunk\DB'
self.data_release_path = r'X:\ExperiumRelease\DB'
self.X_serv_release_path = r'X:\winserverexe\newexe'
self.X_serv_trunk_path = r'X:\winserverexe\newexe\trunkexe'
self.clientupd = [r'\Experium.exe',r'\expenu.dll',r'\exprus.dll',r'\GCalDav.dll',r'\MailEngine.dll',r'\SMSEngine.dll',r'\Telephony.dll']
self.srvupd = [r'\exp_srv.exe',r'\sdatacnv.exe',r'\sdatasrv.exe',r'\sexpsrv.exe',r'\smetasrch.exe',r'\smetasrv.exe',r'\srmeta.exe',r'\wcnvnode.exe',r'\wdatacnv.exe',r'\wdatasrv.exe',r'\wmetasrch.exe',r'\wmetasrv.exe',r'\wrmeta.exe']
self.localdatas = [r'C:\Users\win7_test\AppData\Roaming\Experium\Client']
self.J = Jenkins('http://buildsrv.experium.ru/', username="******", password="******")
self.ui.comboBox_2.addItems(self.J.keys())
self.ui.calendarWidget.setWindowFlags(QtCore.Qt.Dialog | QtCore.Qt.MSWindowsFixedSizeDialogHint)
self.ui.calendarWidget.setWindowTitle('Calendar for Redmine')
self.ui.widget.setWindowFlags(QtCore.Qt.Dialog | QtCore.Qt.MSWindowsFixedSizeDialogHint)
self.ui.widget.setWindowTitle('Database Info')
self.ui.widget.setWindowModality(QtCore.Qt.WindowModal)
self.ui.widget_2.setWindowFlags(QtCore.Qt.Dialog | QtCore.Qt.MSWindowsFixedSizeDialogHint)
self.ui.widget_2.setWindowTitle('API Options')
self.ui.widget_2.setWindowModality(QtCore.Qt.WindowModal)
self.ui.pushButton.clicked.connect(self.enumver)
self.ui.pushButton_7.clicked.connect(self.clrlocal_cl)
self.ui.pushButton_11.clicked.connect(self.jenkins_build)
self.ui.pushButton_9.clicked.connect(self.ui.textBrowser.clear)
self.ui.pushButton_3.clicked.connect(lambda: self.start_thread(self.start))
self.ui.pushButton_4.clicked.connect(lambda: self.start_thread(self.stop))
self.ui.pushButton_6.clicked.connect(lambda: self.start_thread(self.update_cl))
self.ui.pushButton_5.clicked.connect(lambda: self.start_thread(self.start_cl))
self.ui.pushButton_2.clicked.connect(lambda: self.start_thread(self.update))
self.ui.pushButton_10.clicked.connect(self.jenkins)
self.ui.pushButton_8.clicked.connect(self.redmine)
self.ui.pushButton_12.clicked.connect(lambda: self.start_thread(self.update_db))
self.ui.pushButton_13.clicked.connect(lambda: self.start_thread(self.stop_cl))
self.ui.pushButton_14.clicked.connect(self.jenkins_queue)
self.ui.pushButton_18.clicked.connect(lambda: self.start_thread(self.ess))
self.ui.pushButton_19.clicked.connect(self.ui.widget_2.show)
self.ui.pushButton_17.clicked.connect(self.calendar)
self.ui.pushButton_15.clicked.connect(self.prep_deploy_databases)
self.ui.pushButton_22.clicked.connect(self.deploy_database)
self.ui.pushButton_16.clicked.connect(self.uninstall_databases)
self.ui.pushButton_24.clicked.connect(self.clear_opt)
self.ui.comboBox_4.customContextMenuRequested.connect(self.openMenu)
try:
self.ui.comboBox_4.addItems(self.DB['SConfig'])
if self.ui.comboBox_4.currentText() == '':
self.ui.comboBox_4.addItem('127.0.0.1')
except:
self.ui.comboBox_4.addItem('127.0.0.1')
self.logger = Logger(self.ui.textBrowser)
sys.stdout = self.logger
for k in self.DB.keys():
if not k in ['HRM_Trunk','HRM_Release','AGN_Trunk','AGN_Release']:
self.ui.comboBox.addItem(k)
self.DB.close()
self.t_time = None
self.ui.calendarWidget.selectionChanged.connect(lambda: self.start_thread(self.redmine_anyday))
self.movie = QMovie("exp.gif", QByteArray(), self)
self.movie.setCacheMode(QMovie.CacheAll)
self.movie.setSpeed(100)
self.ui.label_8.setMovie(self.movie)
#self.movie.start()
def mstart(self):
"""sart animnation"""
self.movie.start()
def mstop(self):
"""stop the animation"""
self.movie.stop()
def openMenu(self, position):
menu = QMenu()
deleteAction = menu.addAction("Delete")
clearAction = menu.addAction("ClearAll")
savetoDBAction = menu.addAction("SaveToDB")
action = menu.exec_(self.ui.comboBox_4.mapToGlobal(position))
if action == deleteAction:
self.ui.comboBox_4.removeItem(self.ui.comboBox_4.currentIndex())
elif action == clearAction:
self.ui.comboBox_4.clear()
elif action == savetoDBAction:
DB = shelve.open('DB.txt')
DB['SConfig'] = [self.ui.comboBox_4.itemText(i) for i in range(self.ui.comboBox_4.count())]
DB.close()
def output_to_box(self, text):
print(text.toUtf8())
def prep_deploy_databases(self):
self.ui.widget.show()
self.ui.pushButton_22.setEnabled(False)
self.DB_name, ok = QtGui.QInputDialog.getText(self, 'DBName', 'Enter DB name:')
self.ui.lineEdit_9.setText(str(self.DB_name))
self.DB_serv_path = QtGui.QFileDialog.getExistingDirectory(self, 'Select DB Server Path','/')
self.ui.lineEdit_4.setText(str(self.DB_serv_path))
self.DB_data_path = QtGui.QFileDialog.getExistingDirectory(self, 'Select DB Data Path','/')
self.ui.lineEdit_5.setText(str(self.DB_data_path))
if str(self.DB_name) !='' and str(self.DB_data_path) !='' and str(self.DB_serv_path) !='':
self.ui.pushButton_22.setEnabled(True)
def deploy_database(self):
if self.ui.radioButton.isChecked():
type_flag = '0'
elif self.ui.radioButton_2.isChecked():
type_flag = '1'
else: return(0)
if self.ui.radioButton_4.isChecked():
trunk_flag = '0'
elif self.ui.radioButton_3.isChecked():
trunk_flag = '1'
else: return(0)
self.DB = shelve.open('DB.txt')
self.DB[str(self.DB_name)] = [str(self.DB_data_path),str(self.DB_serv_path),type_flag,trunk_flag]
self.DB.close()
self.ui.widget.hide()
self.ui.comboBox.addItem(str(self.DB_name))
wdatasrv = open('wdatasrv.par','r')
wdatasrv1 = open('wdatasrv1.par','w')
wmetasrv1 = open('wmetasrv1.par','w')
wmetasrv = open('wmetasrv.par','r')
srvini = open('exp_srv.ini','r')
srvini1 = open('exp_srv1.ini','w')
text = wdatasrv.read()
wdatasrv1.write(text.replace('DB_data_path',str(self.DB_data_path)))
text = wmetasrv.read()
wmetasrv1.write(text.replace('DB_data_path',str(self.DB_data_path)))
text = srvini.read()
srvini1.write(text.replace('DB_serv_path',str(self.DB_serv_path)))
srvini.close()
srvini1.close()
wdatasrv.close()
wdatasrv1.close()
wmetasrv.close()
wmetasrv1.close()
self.wid_write('copy /Y "wdatasrv1.par" "%s\wdatasrv.par"') % str(self.DB_serv_path)
self.wid_write('copy /Y "wmetasrv1.par" "%s\wmetasrv.par"') % str(self.DB_serv_path)
self.wid_write('copy /Y "exp_srv1.ini" "%s\exp_srv.ini"') % str(self.DB_serv_path)
def uninstall_databases(self):
self.DB = shelve.open('DB.txt')
if not self.ui.comboBox.currentText() in ['HRM_Trunk','HRM_Release','AGN_Trunk','AGN_Release']:
self.DB.pop(str(self.ui.comboBox.currentText()))
self.ui.comboBox.removeItem(self.ui.comboBox.currentIndex())
def wid_write(self, cmd):
PIPE = subprocess.PIPE
p = subprocess.Popen(cmd, shell=True, stdin=PIPE, stdout=PIPE, stderr=subprocess.STDOUT)
print p.stdout.read()
def start_thread(self, meth):
threading.Thread(target=meth).start()
def clrlocal_cl(self):
for f in self.localdatas:
self.wid_write('RMDIR /s /Q '+f)
def jenkins(self):
self.thread2 = Thread2(self)
self.thread2.message2[str].connect(self.output_to_box)
self.thread2.start()
def redmine(self):
self.thread1 = Thread1(self)
self.thread1.message1[str].connect(self.output_to_box)
self.thread1.start()
def ess(self):
import requests
url = 'http://msmeta6.experium.ru/SupportSrv/SupportSrv.svc/Support/control'
payload = {'command':'grep'}
ess = ''
win32clipboard.OpenClipboard()
ess = win32clipboard.GetClipboardData()
win32clipboard.CloseClipboard()
print('***'+ess+'***')
r = requests.post(url, auth=('support', 'c5128437'), params=payload, json={'id': ''+str(ess)+''})
print(r.text.encode('latin1'))
print(r.status_code)
def jenkins_build(self):
j = self.J.get_job(self.ui.comboBox_2.currentText())
if not j.is_queued_or_running():
self.J.build_job(self.ui.comboBox_2.currentText())
def jenkins_queue(self):
self.thread4 = Thread4(self)
self.thread4.message4[str].connect(self.output_to_box)
self.thread4.signal_start[str].connect(self.mstart)
self.thread4.signal_stop[str].connect(self.mstop)
self.thread4.start()
def calendar(self):
self.ui.calendarWidget.show()
def redmine_anyday(self):
self.thread3 = Thread3(self)
self.thread3.message3[str].connect(self.output_to_box)
self.thread3.start()
def update_cl(self):
if self.ui.checkBox_4.isChecked():
if self.ui.checkBox_2.isChecked():
self.wid_write("taskkill /im experium.exe")
time.sleep(3)
for f in self.clientupd:
self.wid_write('copy /Y "'+self.trunk_expcl_path+f+'" "'+self.cl_exp_path+f+'"')
else:
self.wid_write("taskkill /im experium.exe")
time.sleep(3)
for f in self.clientupd:
self.wid_write('copy /Y "'+self.release_expcl_path+f+'" "'+self.cl_exp_path+f+'"')
for f in self.localdatas:
self.wid_write('RMDIR /s /Q '+f)
if self.ui.checkBox_3.isChecked():
self.wid_write("taskkill /t /im exp_srv.exe")
time.sleep(15)
self.wid_write("taskkill /t /im wdatacnv.exe")
if self.ui.checkBox_2.isChecked():
for f in self.srvupd:
self.wid_write('copy /Y "'+self.X_serv_trunk_path+f+'" "'+self.cl_exp_path+f+'"')
else:
for f in self.srvupd:
self.wid_write('copy /Y "'+self.X_serv_release_path+f+'" "'+self.cl_exp_path+f+'"')
print('DONE!!!')
def start_cl(self):
config = open(self.cl_exp_path + '\config.ini', 'r')
regex = re.compile(r"^.*Server.*$")
text2 = []
for line in config.readlines():
text2.append(regex.sub('Server=' + str(re.findall('[^ ()]+', str(self.ui.comboBox_4.currentText()))[0]), line))
config.close()
config = open(self.cl_exp_path + '\config.ini', 'w')
config.writelines(text2)
config.close()
for i in range(int(self.ui.comboBox_3.currentIndex())+1):
os.startfile(self.cl_exp_path+'\experium.exe')
if self.ui.checkBox_3.isChecked():
os.startfile(self.cl_exp_path+'\exp_srv.exe')
time.sleep(10)
self.wid_write("taskkill /im wdatacnv.exe")
time.sleep(3)
os.startfile(self.cl_exp_path+'\wdatacnv.exe')
def stop_cl(self):
self.wid_write("taskkill /im experium.exe")
if self.ui.checkBox_3.isChecked():
self.wid_write("taskkill /t /im exp_srv.exe")
time.sleep(15)
self.wid_write("taskkill /t /im wdatacnv.exe")
print('DONE!!!')
def start(self):
self.server = str(self.ui.lineEdit_6.displayText())
self.wid_write('RMDIR /s /Q '+self.cl_localdata_path)
self.stop()
self.ui.pushButton_3.setEnabled(False)
self.ui.comboBox.setEnabled(False)
self.wid_write('sc create SDataSrv binPath= "'+self.server+'\sdatasrv.exe" type= own start= demand error= normal"')
self.wid_write('sc create SMetaSrch binPath= "'+self.server+'\smetasrch.exe" type= own start= demand error= normal"')
self.wid_write('sc create SMetaSrv binPath= "'+self.server+'\smetasrv.exe" type= own start= demand error= normal"')
self.wid_write('sc create SDataCnv binPath= "'+self.server+'\sdatacnv.exe" type= own start= demand error= normal"')
self.wid_write('sc create ExperiumLauncherService binPath= "'+self.server+'\sexpsrv.exe" type= own start= auto error= normal"')
self.wid_write('sc start "ExperiumLauncherService"')
print('DONE!!!')
def stop(self):
self.server = str(self.ui.lineEdit_6.displayText())
self.wid_write('sc stop "ExperiumLauncherService"')
self.wid_write('sc delete "SDataSrv"')
self.wid_write('sc delete "SDataCnv"')
self.wid_write('sc delete "SMetaSrch"')
self.wid_write('sc delete "SMetaSrv"')
self.wid_write('sc delete "ExperiumLauncherService"')
self.ui.pushButton_3.setEnabled(True)
self.ui.comboBox.setEnabled(True)
print('DONE!!!')
def update(self):
self.server = str(self.ui.lineEdit_6.displayText())
self.stop()
print(str(self.trunk_flag))
print(str(self.type_flag))
if str(self.trunk_flag) == '0':
for f in self.srvupd:
self.wid_write('copy /Y "'+self.X_serv_trunk_path+f+'" "'+self.server+f+'"')
if str(self.trunk_flag) == '1':
for f in self.srvupd:
self.wid_write('copy /Y "'+self.X_serv_release_path+f+'" "'+self.server+f+'"')
if self.ui.checkBox.isChecked():
for f in self.srvupd:
self.wid_write('copy /Y "'+self.X_serv_trunk_path+f+'" "'+self.server+f+'"')
print('DONE!!!')
def update_db(self):
data_path = str(self.ui.lineEdit_3.displayText())
self.server = str(self.ui.lineEdit_6.displayText())
self.stop()
if str(self.trunk_flag) == '0':
X_path = self.data_trunk_path
if str(self.type_flag) == '0':
base1 = 'db0hr.zip'
if str(self.type_flag) == '1':
base1 = 'db0ra.zip'
if str(self.trunk_flag) == '1':
X_path = self.data_release_path
if str(self.type_flag) == '0':
base1 = 'db0hr.zip'
if str(self.type_flag) == '1':
base1 = 'db0ra.zip'
base = r'\\'+base1
self.wid_write('RMDIR /s /Q '+data_path+'\BACKUPDATA')
self.wid_write('RMDIR /s /Q '+data_path+'\DATASERVERDATA')
self.wid_write('RMDIR /s /Q '+data_path+'\METASERVERDATA')
self.wid_write('copy /Y "'+X_path+base+'" "'+data_path+base+'"')
z = ZipFile(data_path+base,'r')
z.extractall(data_path)
z.close()
self.wid_write('DEL /Q '+data_path+base)
print('DONE!!!')
def db_change(self):
self.DB = shelve.open('DB.txt')
DB_name = str(self.ui.comboBox.currentText())
self.ui.lineEdit_3.setText(self.DB[DB_name][0])
self.ui.lineEdit_6.setText(self.DB[DB_name][1])
self.type_flag = str(self.DB[DB_name][2])
self.trunk_flag = str(self.DB[DB_name][3])
self.DB.close()
def enumver(self):
versions = [re.findall(r'\d{4,}',f) for f in os.listdir(self.trunk_expcl_path)]
self.ui.lineEdit.setText("TRUNK "+str(max(versions)))
versions = [re.findall(r'\d{4,}',f) for f in os.listdir(self.release_expcl_path)]
self.ui.lineEdit_2.setText("RELEASE "+str(max(versions)))
def clear_opt(self):
self.ui.lineEdit_10.clear()
self.ui.lineEdit_11.clear()
self.ui.lineEdit_12.clear()
self.ui.lineEdit_13.clear()
self.ui.lineEdit_14.clear()
self.test = QtGui.QFileDialog.getOpenFileName(self, 'Выберите файл для отправки')
print (self.test)
def save_opt(self):
"""TODO"""
def __del__(self):
self.ui = None
def check_text(self, text,FromUserName):
text = text.strip()
try:
db = web.database(dbn='mysql',db='wx',host='pi.iccapp.com',port=8306,user='******',pw='',)
except:
return 'Cannot connect to database'
if text == 'test':
msg = 'test too！!'
elif re.findall(re.compile(r'addURL:'),text):
expression = r'addURL:\s*([a-zA-z]+://[^s]*)'
expc = re.compile(expression)
result = re.findall(expc,text)
if result:
try:
if not db.select('wx_user_url',where='openId = $FromUserName',vars=locals()):
try:
db.insert('wx_user_url',openId=FromUserName,URL=result[0])
except:
msg = 'Database Error'
else:
try:
db.update('wx_user_url', where='openId = $FromUserName',vars=locals(),URL = result[0])
msg = 'The default Jenkins URL is set to ' + result[0]
except:
msg = 'Database Error'
except:
msg = 'Database Error'
elif re.findall(re.compile(r'addTask:'),text):
complexexp = r'addTask:\s*([^\s]+)\s*([^\s]+):([^\s]+)@([a-zA-z]+://[^s]*)'
expc = re.compile(complexexp)
result = expc.findall(text)
if result:
if len(result[0]) == 4:
try:
db.insert('wx_user',openId=FromUserName,taskName=result[0][0],JenkinsURL=result[0][3],username=result[0][1],pw=result[0][2])
msg = 'Task name is ' + result[0][0] + '\nURL is ' + result[0][3]
return msg
except:
msg = 'Insert error'
return msg
expression = r'addTask:\s*([^\s]+)\s*([a-zA-z]+://[^s]*)*'
expc = re.compile(expression)
result = re.findall(expc,text)
if result:
if result[0][1]:
try:
db.insert('wx_user',openId=FromUserName,taskName=result[0][0], JenkinsURL=result[0][1])
msg = 'Task name is ' + result[0][0] +'\n URL is ' + result[0][1]
except:
msg = 'Insert error'
else:
try:
url = list(db.select('wx_user_url',what='URL',where='openId = $FromUserName',vars=locals()))
db.insert('wx_user',openId=FromUserName,taskName=result[0][0],JenkinsURL=url[0].URL)
msg = 'Task name is ' + result[0][0] + '\n URL is ' + url[0].URL
except:
msg = 'Insert error'
elif re.findall(re.compile(r'build:'),text):
expression = r'build:\s*([^\s]+)'
expc = re.compile(expression)
result = re.findall(expc,text)
if result:
taskName = result[0]
try:
res = db.select('wx_user',where='openId = $FromUserName and taskName = $taskName',vars=locals())
j = Jenkins('http://pi.iccapp.com:58082')
for item in res:
j.build_job(jobname=item.taskName)
except:
msg = 'select error'
elif text == 'query':
try:
res = db.select('wx_user',where='openId = $FromUserName',vars = locals())
msg = 'Here is your task:\n'
for item in res:
msg = msg + '%d'%item.taskId + ' ' + item.taskName + ' ' + item.JenkinsURL + '\n'
except:
msg = 'Error'
elif text == '#help#':
msg = 'is this true'
elif text.startswith('#漏洞') and text.endswith('#'):
msg = self.get_woobug(text)
elif self.ifurl(text):
result = self.scanv(text.strip())
msg = '网址:[%s]\n标题:%s\n检测分数:%s\n安全检测:%s\n该检测结果由安全联盟(http://www.anquan.org)提供技术支持\n'%(text.strip(),result['title'],result['score'],result['safe'])
else:
ret = self.simshttp(text)
if ret:
msg = ret['response']
else:
msg = '输入#help#查看帮助\n'+helpstr
return msg
"""
Start a Parameterized Build
"""
from __future__ import print_function
from jenkinsapi.jenkins import Jenkins
J = Jenkins('http://localhost:8080')
params = {'VERSION': '1.2.3', 'PYTHON_VER': '2.7'}
J.build_job('foo', params)
