def get(self, project_name):
project = project_name
build_ids = BuildInfo(project, -1).builds()
builds = []
for bid in build_ids[-10:]:
build = BuildInfo(project, bid)
builds.append({
'build': int(bid),
'log': os.path.basename(build.log()),
'version': build.version(),
'release': build.release(),
'date': build.time()
})
self.write(cyclone.escape.json_encode(builds))
def processCodeBuild(event):
event_id = event['detail']['build-id'].split('/')[1]
build_status = codebuild_client.batch_get_builds(ids=[event_id])
pid = event_id.split(':')[1] or None
if not pid:
return
pipeline_name = event_id.split(':')[0]
cbi = CodeBuildInfo(build_status['builds'][0]['initiator'][13:], event_id)
(stage, pid, actionStates) = pipelineFromBuild(cbi)
buildInfo = BuildInfo(pid, pipeline_name)
existing_msg = find_message_for_build(buildInfo)
builder = MessageBuilder(buildInfo, existing_msg)
phases = build_status['builds'][0]['phases']
builder.updateBuildStageInfo(stage, phases, actionStates)
logs = build_status['builds'][0].get('logs', {})
try:
if logs['streamName']:
builder.attachLogs(logs)
except KeyError:
pass
post_build_msg(builder)
def process_code_build(event):
if 'additional-information' not in event['detail']:
logger.debug("Skipping due to no additional-information")
return
cbi = CodeBuildInfo.from_event(event)
logger.debug(vars(cbi))
(stage, pid, actionStates) = pipeline_from_build(cbi)
logger.debug(stage, pid, actionStates)
if not pid:
return
build_info = BuildInfo(pid, cbi.pipeline)
existing_msg = find_message_for_build(build_info)
builder = MessageBuilder(build_info, existing_msg)
if 'phases' in event['detail']['additional-information']:
phases = event['detail']['additional-information']['phases']
builder.update_build_stage_info(stage, phases, actionStates)
logs = event['detail'].get('additional-information', {}).get('logs')
post_build_msg(builder)
def processCodeBuild(event):
# logger.info("processCodeBuild")
if is_skip_codebuild_notice(event['detail'].get('eventName')):
return
cbi = CodeBuildInfo.from_event(event)
(stage, pid, actionStates) = pipelineFromBuild(cbi)
if not pid:
return
build_info = BuildInfo(pid, cbi.pipeline, actionStates)
existing_msg = find_message_for_build(build_info)
builder = MessageBuilder(build_info, existing_msg)
if 'phases' in event['detail']['additional-information']:
phases = event['detail']['additional-information']['phases']
builder.updateBuildStageInfo(stage, phases, actionStates)
logs = event['detail'].get('additional-information', {}).get('logs')
if logs:
builder.attachLogs(event['detail']['additional-information']['logs'])
post_build_msg(builder)
def processCodeBuild(event):
cbi = CodeBuildInfo.fromEvent(event)
(stage, pid, actionStates) = pipelineFromBuild(cbi)
if not pid:
return
buildInfo = BuildInfo(pid, cbi.pipeline)
existing_msg = find_message_for_build(buildInfo)
builder = MessageBuilder(buildInfo, existing_msg)
if 'phases' in event['detail']['additional-information']:
phases = event['detail']['additional-information']['phases']
builder.updateBuildStageInfo(stage, phases, actionStates)
# logs = event['detail'].get('additional-information', {}).get('logs')
# if logs:
# builder.attachLogs(event['detail']['additional-information']['logs'])
post_build_msg(builder)
except Exception as e:
if daos_server is None:
print("No PID was found for the DAOS server")
elif "No such process" in e:
print("The daos_server process is no longer available"
" and could not be killed.")
else:
print("Unable to shut down DAOS server: {}".format(e))
if __name__ == "__main__":
"""
Start a DAOS server and then run the four stages of the client.
"""
print("Running rdb tests")
rc = 0
binfo = BuildInfo(os.path.join(build_root, ".build_vars.json"));
debug_cmds = "-x D_LOG_MASK=DEBUG,RPC=ERR,MEM=ERR " + \
"-x DD_SUBSYS=all -x DD_MASK=all"
try:
# Server operations
p = start_server(binfo)
counter = 0
daos_server = daos_server_pid()
while daos_server is None:
if counter >= 120:
raise ServerTimedOut("No DAOS server process detected before "\
"timeout")
counter += 1
time.sleep(1)
def get(self, project, bid):
build_info = BuildInfo(project, bid)
if os.path.isfile(build_info.log()):
self.write(open(build_info.log()).read())
def build(self, branch, last_tag=None, force_version=None, force_release=None):
templates = {}
templates_dir = os.path.join(self.builder.templates_dir, 'deb')
control_data_new = None
self.build_info = BuildInfo(self.project.name)
logfile = os.path.join(
BrickConfig().get("workspace", "dir"), 'log', '%s.%s.log' % (
self.project.name, self.build_info.build_id
)
)
log.info("build log file: %s" % logfile)
self.build_info.log(logfile)
self.stdout = open(logfile, 'a+')
self.stderr = self.stdout
self.debian_dir = os.path.join(self.builder.workdir, 'debian')
if last_tag is not None:
os.environ.update({'BRICKLAYER_RELEASE': last_tag.split('_')[0]})
os.environ.update({'BRICKLAYER_TAG': last_tag})
# Not now
#self.build_install_deps()
if self.project.install_prefix is None:
self.project.install_prefix = 'opt'
if not self.project.install_cmd :
self.project.install_cmd = 'cp -r \`ls | grep -v debian\` debian/tmp/%s' % (
self.project.install_prefix
)
changelog_entry, changelog_data = self.configure_changelog(branch)
if changelog_entry and changelog_data:
if last_tag != None and last_tag.startswith('stable'):
self.project.version('stable', last_tag.split('_')[1])
changelog_data.update({'version': self.project.version('stable'), 'branch': 'stable'})
self.build_info.version(self.project.version('stable'))
self.build_info.release('stable')
elif last_tag != None and last_tag.startswith('testing'):
self.project.version('testing', last_tag.split('_')[1])
changelog_data.update({'version': self.project.version('testing'), 'branch': 'testing'})
self.build_info.version(self.project.version('testing'))
self.build_info.release('testing')
elif last_tag != None and last_tag.startswith('unstable'):
self.project.version('unstable', last_tag.split('_')[1])
changelog_data.update({'version': self.project.version('unstable'), 'branch': 'unstable'})
self.build_info.version(self.project.version('unstable'))
self.build_info.release('unstable')
else:
"""
otherwise it should change the distribution to experimental
"""
version_list = self.project.version(branch).split('.')
version_list[len(version_list) - 1] = str(int(version_list[len(version_list) - 1]) + 1)
self.project.version(branch, '.'.join(version_list))
changelog_data.update({'version': self.project.version(branch), 'branch': 'experimental'})
self.build_info.version(self.project.version(branch))
self.build_info.release('experimental:%s' % branch)
with file(os.path.join(self.builder.workdir, 'debian', 'changelog'), 'w') as fh:
fh.write(changelog_entry % changelog_data)
else:
self.build_info.version(force_version)
self.build_info.release(force_release)
self.project.version(branch, force_version)
self.project.version(force_release, force_version)
rvm_env = {}
rvm_rc = os.path.join(self.builder.workdir, '.rvmrc')
rvm_rc_example = rvm_rc + ".example"
has_rvm = False
if os.path.isfile(rvm_rc):
has_rvm = True
elif os.path.isfile(rvm_rc_example):
has_rvm = True
rvm_rc = rvm_rc_example
if has_rvm:
with open(rvm_rc) as tmpfh:
rvmexec = tmpfh.read()
log.info("RVMRC: %s" % rvmexec)
# I need the output not to log on file
rvm_cmd = subprocess.Popen('/usr/local/rvm/bin/rvm info %s' % rvmexec.split()[1],
shell=True, stdout=subprocess.PIPE)
rvm_cmd.wait()
for line in rvm_cmd.stdout.readlines():
if 'PATH' in line or 'HOME' in line:
name, value = line.split()
rvm_env[name.strip(':')] = value.strip('"')
rvm_env['HOME'] = os.environ['HOME']
if len(rvm_env.keys()) < 1:
rvm_env = os.environ
else:
os_env = dict(os.environ)
for k in ("PATH", "GEM_HOME", "BUNDLER_PATH"):
if (k in os_env):
del(os_env[k])
rvm_env.update(os_env)
log.info(rvm_env)
os.chmod(os.path.join(self.debian_dir, 'rules'), stat.S_IRWXU|stat.S_IRWXG|stat.S_IROTH|stat.S_IXOTH)
dpkg_cmd = self.builder._exec(
['dpkg-buildpackage',
'-rfakeroot', '-tc', '-k%s' % BrickConfig().get('gpg', 'keyid')],
cwd=self.builder.workdir, env=rvm_env, stdout=self.stdout, stderr=self.stderr, close_fds=True)
dpkg_cmd.wait()
clean_cmd = self.builder._exec(['dh', 'clean'],
cwd=self.builder.workdir,
stdout=self.stdout, stderr=self.stderr, close_fds=True)
clean_cmd.wait()
def build(self, branch, last_tag=None):
templates_dir = os.path.join(self.builder.templates_dir, 'rpm')
rpm_dir = os.path.join(self.builder.workdir, 'redhat')
spec_filename = os.path.join(rpm_dir, 'SPECS',
"%s.spec" % self.project.name)
self.build_info = BuildInfo(self.project.name)
logfile = os.path.join(
self.builder.workspace, 'log',
'%s.%s.log' % (self.project.name, self.build_info.build_id))
self.build_info.log(logfile)
self.stdout = open(logfile, 'a+')
self.stderr = self.stdout
if last_tag != None and last_tag.startswith('stable'):
self.project.version('stable', last_tag.split('_')[1])
self.build_info.version(self.project.version('stable'))
self.version = self.project.version('stable')
self.distribution = 'stable'
elif last_tag != None and last_tag.startswith('testing'):
self.project.version('testing', last_tag.split('_')[1])
self.build_info.version(self.project.version('testing'))
self.version = self.project.version('testing')
self.distribution = 'testing'
elif last_tag != None and last_tag.startswith('unstable'):
self.project.version('unstable', last_tag.split('_')[1])
self.build_info.version(self.project.version('unstable'))
self.version = self.project.version('unstable')
self.distribution = 'unstable'
else:
"""
otherwise it should change the distribution to unstable
"""
if self.project.version(branch):
version_list = self.project.version(branch).split('.')
version_list[len(version_list) - 1] = str(
int(version_list[len(version_list) - 1]) + 1)
self.project.version(branch, '.'.join(version_list))
self.build_info.version(self.project.version(branch))
self.version = self.project.version(branch)
self.distribution = 'experimental'
dir_prefix = "%s-%s" % (self.project.name, self.version)
for dir in ('SOURCES', 'SPECS', 'RPMS', 'SRPMS', 'BUILD', 'TMP'):
if os.path.isdir(os.path.join(rpm_dir, dir)):
shutil.rmtree(os.path.join(rpm_dir, dir))
os.makedirs(os.path.join(rpm_dir, dir))
build_dir = os.path.join(rpm_dir, 'TMP', self.project.name)
os.makedirs(build_dir)
if os.path.isdir(os.path.join(rpm_dir, dir_prefix)):
shutil.rmtree(os.path.join(rpm_dir, dir_prefix))
os.makedirs(os.path.join(rpm_dir, dir_prefix))
subprocess.call([
"cp -rP `ls -a | grep -Ev '\.$|\.\.$|debian$|redhat$'` %s" %
os.path.join(rpm_dir, dir_prefix)
],
cwd=self.builder.workdir,
shell=True)
cur_dir = os.getcwd()
os.chdir(rpm_dir)
source_file = os.path.join(rpm_dir, 'SOURCES',
'%s.tar.gz' % dir_prefix)
tar = tarfile.open(source_file, 'w:gz')
tar.add(dir_prefix)
tar.close()
shutil.rmtree(dir_prefix)
os.chdir(cur_dir)
if self.project.install_prefix is None:
self.project.install_prefix = 'opt'
if not self.project.install_cmd:
self.project.install_cmd = 'cp -r \`ls -a | grep -Ev "\.$|\.\.$|debian$"\` %s/%s/%s' % (
build_dir, self.project.install_prefix, self.project.name)
template_data = {
'name': self.project.name,
'version': self.version,
'build_dir': build_dir,
'build_cmd': self.project.build_cmd,
'install_cmd': self.builder.mod_install_cmd,
'username': self.project.username,
'email': self.project.email,
'date': time.strftime("%a %h %d %Y"),
'git_url': self.project.git_url,
'source': source_file,
}
rvm_rc = os.path.join(self.builder.workdir, '.rvmrc')
rvm_rc_example = rvm_rc + ".example"
has_rvm = False
environment = None
if os.path.isfile(rvm_rc):
has_rvm = True
elif os.path.isfile(rvm_rc_example):
has_rvm = True
rvm_rc = rvm_rc_example
if has_rvm:
rvmexec = open(rvm_rc).read()
log.info("RVMRC: %s" % rvmexec)
# I need the output not to log on file
rvm_cmd = subprocess.Popen('/usr/local/rvm/bin/rvm info %s' %
rvmexec.split()[1],
shell=True,
stdout=subprocess.PIPE)
rvm_cmd.wait()
rvm_env = {}
for line in rvm_cmd.stdout.readlines():
if 'PATH' in line or 'HOME' in line:
name, value = line.split()
rvm_env[name.strip(':')] = value.strip('"')
rvm_env['HOME'] = os.environ['HOME']
if len(rvm_env.keys()) < 1:
rvm_env = os.environ
else:
try:
os.environ.pop('PATH')
os.environ.pop('GEM_HOME')
os.environ.pop('BUNDLER_PATH')
except Exception, e:
pass
for param in os.environ.keys():
if param.find('PROXY') != -1:
rvm_env[param] = os.environ[param]
rvm_env.update(os.environ)
environment = rvm_env
log.info(environment)
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
"""A simple script to exercise the BuildInfo module"""
from __future__ import print_function
import sys
import os
SCRIPT_DIR = os.path.dirname(os.path.realpath(__file__))
sys.path.insert(0, os.path.dirname(SCRIPT_DIR))
from build_info import BuildInfo
FILENAME = os.path.join(SCRIPT_DIR, "sl_test.info")
INFO = BuildInfo(FILENAME)
PREFIX = INFO.get("PREFIX")
if not os.path.exists(PREFIX):
print("PREFIX doesn't exist")
os.unlink(FILENAME)
sys.exit(-1)
if SCRIPT_DIR not in PREFIX:
print("PREFIX not at expected location")
os.unlink(FILENAME)
sys.exit(-1)
SH_SCRIPT = os.path.join(SCRIPT_DIR, "sl_test.sh")
INFO.gen_script(SH_SCRIPT)
os.system("source %s" % SH_SCRIPT)
def build(self, branch, last_tag=None, force_version=None, force_release=None):
templates = {}
templates_dir = os.path.join(self.builder.templates_dir, 'deb')
debian_dir = os.path.join(self.builder.workdir, 'debian')
control_data_new = None
self.build_info = BuildInfo(self.project.name)
logfile = os.path.join(
self.builder.workspace, 'log', '%s.%s.log' % (
self.project.name, self.build_info.build_id
)
)
self.build_info.log(logfile)
self.stdout = open(logfile, 'a+')
self.stderr = self.stdout
if self.project.install_prefix is None:
self.project.install_prefix = 'opt'
if not self.project.install_cmd :
self.project.install_cmd = 'cp -r \`ls | grep -v debian\` debian/tmp/%s' % (
self.project.install_prefix
)
template_data = {
'name': self.project.name,
'version': "%s" % (self.project.version(branch)),
'build_cmd': self.project.build_cmd,
'install_cmd': self.builder.mod_install_cmd,
'username': self.project.username,
'email': self.project.email,
'date': time.strftime("%a, %d %h %Y %T %z"),
}
changelog = os.path.join(self.builder.workdir, 'debian', 'changelog')
if hasattr(self.builder.build_options, 'changelog') and self.builder.build_options.changelog:
if os.path.isfile(changelog):
os.rename(changelog, "%s.save" % changelog)
def read_file_data(f):
template_fd = open(os.path.join(templates_dir, f))
templates[f] = pystache.template.Template(template_fd.read()).render(context=template_data)
template_fd.close()
if not os.path.isdir(debian_dir):
map(read_file_data, ['changelog', 'control', 'rules'])
os.makedirs( os.path.join( debian_dir, self.project.name, self.project.install_prefix))
for filename, data in templates.iteritems():
open(os.path.join(debian_dir, filename), 'w').write(data)
changelog_entry = """%(name)s (%(version)s) %(branch)s; urgency=low
* Latest commits
%(commits)s
-- %(username)s <%(email)s> %(date)s
"""
changelog_data = {
'name': self.project.name,
'version': self.project.version(branch),
'branch': branch,
'commits': ' '.join(self.builder.git.log()),
'username': self.project.username,
'email': self.project.email,
'date': time.strftime("%a, %d %h %Y %T %z"),
}
if last_tag != None and last_tag.startswith('stable'):
self.project.version('stable', last_tag.split('_')[1])
changelog_data.update({'version': self.project.version('stable'), 'branch': 'stable'})
self.build_info.version(self.project.version('stable'))
self.build_info.release('stable')
elif last_tag != None and last_tag.startswith('testing'):
self.project.version('testing', last_tag.split('_')[1])
changelog_data.update({'version': self.project.version('testing'), 'branch': 'testing'})
self.build_info.version(self.project.version('testing'))
self.build_info.release('testing')
elif last_tag != None and last_tag.startswith('unstable'):
self.project.version('unstable', last_tag.split('_')[1])
changelog_data.update({'version': self.project.version('unstable'), 'branch': 'unstable'})
self.build_info.version(self.project.version('unstable'))
self.build_info.release('unstable')
else:
"""
otherwise it should change the distribution to experimental
"""
if self.project.version(branch):
version_list = self.project.version(branch).split('.')
version_list[len(version_list) - 1] = str(int(version_list[len(version_list) - 1]) + 1)
self.project.version(branch, '.'.join(version_list))
changelog_data.update({'version': self.project.version(branch), 'branch': 'experimental'})
self.build_info.version(self.project.version(branch))
self.build_info.release('experimental:%s' % branch)
open(os.path.join(self.builder.workdir, 'debian', 'changelog'), 'w').write(changelog_entry % changelog_data)
else:
self.build_info.version(force_version)
self.build_info.release(force_release)
rvm_env = {}
rvm_rc = os.path.join(self.builder.workdir, '.rvmrc')
rvm_rc_example = rvm_rc + ".example"
has_rvm = False
if os.path.isfile(rvm_rc):
has_rvm = True
elif os.path.isfile(rvm_rc_example):
has_rvm = True
rvm_rc = rvm_rc_example
if has_rvm:
rvmexec = open(rvm_rc).read()
log.info("RVMRC: %s" % rvmexec)
# I need the output not to log on file
rvm_cmd = subprocess.Popen('/usr/local/bin/rvm info %s' % rvmexec.split()[1],
shell=True, stdout=subprocess.PIPE)
rvm_cmd.wait()
for line in rvm_cmd.stdout.readlines():
if 'PATH' in line or 'HOME' in line:
name, value = line.split()
rvm_env[name.strip(':')] = value.strip('"')
rvm_env['HOME'] = os.environ['HOME']
if len(rvm_env.keys()) < 1:
rvm_env = os.environ
else:
try:
os.environ.pop('PATH')
os.environ.pop('GEM_HOME')
os.environ.pop('BUNDLER_PATH')
except Exception, e:
pass
rvm_env.update(os.environ)
