355 lines
13 KiB
Python
Executable File
355 lines
13 KiB
Python
Executable File
#!/usr/bin/python
|
|
# -*- coding: utf-8 -*-
|
|
#
|
|
# $Id: make_rpmSVOnly.py 1382 2023-10-09 04:11:49Z fritsche_h $
|
|
# $HeadURL: svn://slssvn/admin/rpmbuild/make_rpmSVOnly.py $
|
|
# $Author: fritsche_h $
|
|
# Created by Christian Ehrlicher, SLSE, 20013-02-19
|
|
#
|
|
|
|
import datetime
|
|
import getopt
|
|
import os
|
|
import shutil
|
|
import subprocess
|
|
import sys
|
|
import time
|
|
import ConfigParser
|
|
import fnmatch
|
|
|
|
# helper functions
|
|
loc = os.path.dirname( sys.argv[0] )
|
|
loc = os.path.abspath( loc )
|
|
exec(compile(open('helpers.py').read(), 'helpers.py', 'exec'))
|
|
|
|
class build(object):
|
|
def __init__( self ):
|
|
self.project_name = 'ctc'
|
|
self.base_dir = os.getcwd()
|
|
self.cmake_build_flags = None
|
|
self.output_dir = "/shd/CTC/TOOLS/TDS-rpmbuild/"
|
|
self.version_maj = 1
|
|
self.version_min = 1
|
|
self.version_rev = 0
|
|
self.cmake_version_prefix = "TDS"
|
|
self.source_dir_rel = "legatus"
|
|
#self.svn_fullpath = None
|
|
self.build_hla_rpm = "false"
|
|
self.build_sv_rpm = "true"
|
|
self.build_lic_rpm = "false"
|
|
self.build_ws_rpm = "false"
|
|
self.build_bld_rpm = "false"
|
|
self.build_aar_rpm = "false"
|
|
|
|
|
|
self.buildtype = os.getenv( "CMAKE_BUILD_TYPE" )
|
|
if self.buildtype == None or self.buildtype == "":
|
|
self.buildtype = 'RelWithDebInfo'
|
|
|
|
self.cmake_generator = 'Unix Makefiles'
|
|
|
|
def init( self ):
|
|
self.extfw_dir = "%s/EXTFW-inst/opt/EXTFW" % self.base_dir
|
|
if not os.path.exists( self.extfw_dir ):
|
|
self.extfw_dir = '/opt/EXTFW'
|
|
os.environ["EXTFW"] = self.extfw_dir
|
|
os.environ["CMAKE_PREFIX_PATH"] = self.extfw_dir
|
|
|
|
def printOptions( self ):
|
|
print("Config options")
|
|
print("**************")
|
|
print(" Using base dir: %s" % self.base_dir)
|
|
print(" Using extfw dir: %s" % self.extfw_dir)
|
|
print(" Using buildtype: %s" % self.buildtype)
|
|
print(" Project name: %s" % self.project_name)
|
|
print(" Build HLA RPM: %s" % self.build_hla_rpm)
|
|
print(" Build SV RPM: %s" % self.build_sv_rpm)
|
|
print(" Build Licence RPM: %s" % self.build_lic_rpm)
|
|
print(" Build WS RPM: %s" % self.build_ws_rpm)
|
|
print(" Build Building RPM: %s" % self.build_bld_rpm)
|
|
print(" Build AAR RPM: %s" % self.build_aar_rpm)
|
|
# print(" SVN Path: %s" % self.svn_fullpath)
|
|
print(" Version: %s.%s-%s" % ( self.version_maj, self.version_min, self.version_rev ))
|
|
print(" Jenkins build number: %s" % os.getenv( "BUILD_NUMBER" ))
|
|
print(" Date: %s" % self.version_date)
|
|
print("")
|
|
time.sleep(2)
|
|
|
|
# does a svn export, returns True when it's a checkout or False when it's an update
|
|
def svn_export( self, svn_path, dest_dir, svn_revision = "HEAD", svn_user = None, svn_passwd = None ):
|
|
|
|
removeDirectory( dest_dir )
|
|
|
|
info( "--------------------------------" )
|
|
info( "Exporting %s to %s" % ( svn_path, dest_dir ) )
|
|
info( "--------------------------------" )
|
|
|
|
command = "svn export -r %s %s %s" % ( svn_revision, svn_path, dest_dir )
|
|
if svn_user:
|
|
command += "--username %s " % svn_user
|
|
if svn_passwd:
|
|
command += "--password %s " % svn_passwd
|
|
os.system( command ) and die( "while svn export. cmd: %s" % command )
|
|
|
|
def version_str( self ):
|
|
return "%s.%s" % ( self.version_maj, self.version_min )
|
|
|
|
def xzfilename( self ):
|
|
return self.project_name + '_' + self.repository + '_' + getOS_Name() + '-' + self.version_str() + '.tar.xz'
|
|
|
|
def specname( self, specdir ):
|
|
specname = 'ctc_%s_%s.spec' % ( self.repository, self.project_name )
|
|
debug( "specname: %s" % os.path.join( specdir, specname ) )
|
|
if os.path.exists( os.path.join( specdir, specname ) ):
|
|
return specname
|
|
specname = 'ctc_%s.spec' % ( self.repository )
|
|
debug( "specname: %s" % os.path.join( specdir, specname ) )
|
|
if os.path.exists( os.path.join( specdir, specname ) ):
|
|
return specname
|
|
specname = 'ltsHLAOnly.spec'
|
|
debug( "specname: %s" % os.path.join( specdir, specname ) )
|
|
if os.path.exists( os.path.join( specdir, specname ) ):
|
|
return specname
|
|
specname = 'ltsSVOnly.spec'
|
|
debug( "specname: %s" % os.path.join( specdir, specname ) )
|
|
if os.path.exists( os.path.join( specdir, specname ) ):
|
|
return specname
|
|
specname = 'ctc.spec'
|
|
debug( "specname: %s" % os.path.join( specdir, specname ) )
|
|
if os.path.exists( os.path.join( specdir, specname ) ):
|
|
return specname
|
|
specname = '%s.spec' % self.project_name
|
|
debug( "specname: %s" % os.path.join( specdir, specname ) )
|
|
if os.path.exists( os.path.join( specdir, specname ) ):
|
|
return specname
|
|
die( 'Unable to find a valid spec file in %s' % specdir )
|
|
|
|
def copy_spec( self, dest_dir, spec_fullpath ):
|
|
# copy spec to build
|
|
f = open( spec_fullpath, 'r' )
|
|
content = f.read()
|
|
f.close()
|
|
|
|
# Jenkins Build Tag (wird von Jenkins gesetzt wenn darüber gebaut wird)
|
|
jenkins_build_tag = os.getenv( "BUILD_TAG" )
|
|
if jenkins_build_tag == None or len(jenkins_build_tag) == 0:
|
|
jenkins_build_tag = 'Not build with jenkins job'
|
|
|
|
# Versionsinformationen übergeben
|
|
cmake_flags = ""
|
|
cmake_flags += '-D%s_VERSION_MAJOR:STRING="%s" ' % (self.cmake_version_prefix, self.version_maj)
|
|
cmake_flags += '-D%s_VERSION_MINOR:STRING="%s" ' % (self.cmake_version_prefix, self.version_min)
|
|
cmake_flags += '-D%s_VERSION_REV:STRING="%s" ' % (self.cmake_version_prefix, self.version_rev)
|
|
cmake_flags += '-D%s_VERSION_PATCH:STRING="%s" ' % (self.cmake_version_prefix, self.version_rev)
|
|
cmake_flags += '-D%s_VERSION_DATE:STRING="%s" ' % (self.cmake_version_prefix, self.version_date)
|
|
cmake_flags += '-D_pname:STRING="%s" ' % (self.project_name)
|
|
|
|
jenkins_build_number = os.getenv( "BUILD_NUMBER" )
|
|
if jenkins_build_number != None:
|
|
cmake_flags += '-DJENKINS_BUILD_NUMBER:STRING="%s" '% (jenkins_build_number)
|
|
|
|
if self.cmake_build_flags:
|
|
cmake_flags += ' %s ' % self.cmake_build_flags
|
|
|
|
# und den Buildtype
|
|
cmake_flags += '-DCMAKE_BUILD_TYPE="%s" ' % self.buildtype
|
|
|
|
filename = 'project.%s.cfg' % self.project_name
|
|
cmake_flags += '-DTDS_PROJECT_CONFIG_FILE=%s ' % filename
|
|
|
|
## auto add BuildFlags depending on the modules
|
|
if self.build_sv_rpm == "true":
|
|
cmake_flags += '-DBUILD_SV=ON '
|
|
if self.build_ws_rpm == "true":
|
|
cmake_flags += '-DBUILD_SV=WS '
|
|
if self.build_hla_rpm == "true":
|
|
cmake_flags += '-DBUILD_HLA=ON -DBUILD_SVC_HLA=ON '
|
|
if self.build_aar_rpm == "true":
|
|
cmake_flags += '-DBUILD_AAR=ON '
|
|
|
|
content = content.replace( "@PROJECT@", self.project_name )
|
|
content = content.replace( "@OS_SYSTEM@", getOS_Name() )
|
|
content = content.replace( "@PACKAGER@", getpass.getuser() )
|
|
content = content.replace( "@VERSION@", self.version_str() )
|
|
content = content.replace( "@RELEASE@", self.version_rev )
|
|
content = content.replace( "@SOURCE_DIR_REL@", self.source_dir_rel )
|
|
content = content.replace( "@SOURCES@", self.xzfilename() )
|
|
content = content.replace( "@APPLICATION@", self.repository )
|
|
content = content.replace( "@CMAKE_FLAGS@ ", cmake_flags )
|
|
content = content.replace( "@JENKINS_BUILD_TAG@", jenkins_build_tag )
|
|
content = content.replace( "@BUILDSVNRPM@", self.build_sv_rpm )
|
|
content = content.replace( "@BUILDRPMHLA@", self.build_hla_rpm )
|
|
content = content.replace( "@BUILDRPMLIC@", self.build_lic_rpm )
|
|
# content = content.replace( "@BUILDRPMWS@", self.build_ws_rpm )
|
|
# content = content.replace( "@BUILDRPMBLD@", self.build_bld_rpm )
|
|
# content = content.replace( "@BUILDRPMAAR@", self.build_aar_rpm )
|
|
|
|
|
|
if not os.path.exists( dest_dir ):
|
|
os.makedirs( dest_dir )
|
|
f = open( os.path.join( dest_dir, os.path.split( spec_fullpath )[1] ), 'w' )
|
|
f.write( content )
|
|
f.close()
|
|
|
|
def clean_lts_cc_conf(self, folder):
|
|
config_files = []
|
|
for root, dirs, files in os.walk(folder):
|
|
for name in files:
|
|
if fnmatch.fnmatch(name, 'lts-cc*conf'):
|
|
config_files.append(os.path.join(root, name))
|
|
|
|
for config_file in config_files:
|
|
config = ConfigParser.RawConfigParser()
|
|
config.optionxform = str
|
|
config.read(config_file)
|
|
|
|
for section in config.sections():
|
|
if len(config.items(section)) == 0:
|
|
config.remove_section(section)
|
|
|
|
with open(config_file, 'w') as file:
|
|
config.write(file)
|
|
|
|
def pack_sources( self, src_dir, dest_dir ):
|
|
xzfilename = self.xzfilename()
|
|
xzfilename = os.path.join( dest_dir, xzfilename )
|
|
|
|
info( "--------------------------------" )
|
|
info( "Packing sources in %s to %s" % ( src_dir, xzfilename ) )
|
|
info( "--------------------------------" )
|
|
|
|
removeDirectory( xzfilename ) # falls es ein directory ist
|
|
if os.path.exists( xzfilename ): # falls es eine datei ist
|
|
os.remove( xzfilename )
|
|
if not os.path.exists( dest_dir ):
|
|
os.makedirs( dest_dir )
|
|
|
|
os.chdir( os.path.split( src_dir )[0] )
|
|
cmd = "tar cJf %s %s" % ( xzfilename, os.path.split( src_dir )[1] )
|
|
system( cmd, sys.stdout ) and die( "while packing. cmd: %s" % command )
|
|
|
|
# svn export ${svn} ${base}
|
|
|
|
# fixup_rde_header ${base} "c"
|
|
# fixup_rde_header ${base} "h"
|
|
# fixup_rde_header ${base} "cpp"
|
|
# fixup_rde_header ${base} "hpp"
|
|
# fixup_rde_header ${base} "txt"
|
|
# fixup_rde_header ${base} "py"
|
|
|
|
# cp ${base}/specs/ctc.spec /usr/src/packages/SPECS/
|
|
|
|
|
|
def usage():
|
|
print >> sys.stdout, "Usage: %s [-b <base_dir> ] -f <filelist> -o <output_dir> -r <repository> -v <version> -s <svn_path>" % sys.argv[0]
|
|
|
|
def main():
|
|
b = build()
|
|
|
|
try:
|
|
opts, args = getopt.getopt(sys.argv[1:], "a:b:w:d:w:t:l:c:h:f:o:p:r:v:s:",
|
|
["base_dir=", "build_aar_rpm=", "build_hla_rpm=", "build_ws_rpm=", "build_sv_rpm=", "build_lic_rpm=", "build_bld_rpm=", "cmake_build_flags=", "cmake_version_prefix=", "filelist=", "output_dir=", "project_name=","build_only_hla=", "repository", "version=", "svn_path="])
|
|
except getopt.GetoptError as err:
|
|
print >> sys.stderr, err
|
|
usage()
|
|
sys.exit(2)
|
|
|
|
rpm_filelist = None
|
|
svn_path = "trunk"
|
|
b.repository = "TDS"
|
|
for o, a in opts:
|
|
if o == "--cmake_build_flags":
|
|
b.cmake_build_flags = a
|
|
print("build flags: ", b.cmake_build_flags)
|
|
if o in ("-b", "--base_dir"):
|
|
b.base_dir = a
|
|
if o in ("-f", "--filelist"):
|
|
rpm_filelist = a
|
|
if o in ("-o", "--output_dir"):
|
|
b.output_dir = a
|
|
if o in ("-c", "--cmake_version_prefix"):
|
|
b.cmake_version_prefix = a
|
|
if o in ("-p", "--project_name"):
|
|
b.project_name = a
|
|
if o in ("-h", "--build_hla_rpm"):
|
|
b.build_hla_rpm = a
|
|
if o in ("-w", "--build_ws_rpm"):
|
|
b.build_ws_rpm = a
|
|
if o in ("-t", "--build_sv_rpm"):
|
|
b.build_sv_rpm = a
|
|
if o in ("-l", "--build_lic_rpm"):
|
|
b.build_lic_rpm = a
|
|
if o in ("-d", "--build_bld_rpm"):
|
|
b.build_bld_rpm = a
|
|
if o in ("-a", "--build_aar_rpm"):
|
|
b.build_aar_rpm = a
|
|
if o in ("-r", "--repository"):
|
|
b.repository = a
|
|
if o in ("-v", "--version"):
|
|
version = a.split('.')
|
|
try:
|
|
b.version_maj = version[0]
|
|
b.version_min = version[1]
|
|
except:
|
|
die( "Invalid version format (maj.min): %s" % a )
|
|
if o in ("-s", "--svn_path"):
|
|
svn_path = a
|
|
|
|
|
|
# b.check_rpm("ctc_EXTFW_%s" % os_str)
|
|
|
|
#b.version_rev = getSvn_Release( b.svn_fullpath )
|
|
b.version_rev = os.getenv( "BUILD_NUMBER" )
|
|
# b.version_date = getSvn_Date( b.svn_fullpath )
|
|
b.version_date = os.getenv( "VERSION_DATE" )
|
|
b.init()
|
|
b.printOptions()
|
|
|
|
# rpmbase_dir = os.path.join( os.getenv( "HOME" ), 'rpmbuild' )
|
|
|
|
|
|
rpmbase_dir = '/shd/CTC/TOOLS/rpmbuild'
|
|
# project_base_dir = '/builds/projects-domain-live/tds'
|
|
# project_base_dir = os.getenv( "PROJECT_BASE_DIR" )
|
|
project_base_dir = os.getenv( "WORKSPACE" )
|
|
|
|
specdir = os.path.join( rpmbase_dir, "SPECS" )
|
|
|
|
|
|
#specdir = os.path.join( rpmbase_dir, "SPECS" )
|
|
if not os.path.exists(specdir):
|
|
os.makedirs(specdir)
|
|
|
|
# b.svn_export( b.svn_fullpath, svn_destdir )
|
|
b.clean_lts_cc_conf(os.path.join(project_base_dir, 'Lts', 'Projects'))
|
|
#specname = b.specname( os.path.join( svn_destdir, "specs" ) )
|
|
specname = b.specname(os.path.join(project_base_dir, 'specs'))
|
|
b.copy_spec( specdir, os.path.join(project_base_dir, "specs", specname ))
|
|
|
|
full_version = "%s.%s-%s" % ( b.version_maj, b.version_min, b.version_rev )
|
|
b.printOptions()
|
|
|
|
b.pack_sources( project_base_dir, os.path.join( rpmbase_dir, "SOURCES" ) )
|
|
exec_rpmbuild( specdir, specname )
|
|
|
|
# move rpms to FOO-1.2-345
|
|
dstdir = os.path.join( b.output_dir, "%s-%s-%s" % ( b.project_name, b.repository, full_version ) )
|
|
filter = re.compile( "^.*%s\..*\.rpm$" % full_version )
|
|
moved_files = moveFilesToDir( rpmbase_dir,
|
|
dstdir,
|
|
filter,
|
|
True
|
|
)
|
|
|
|
if rpm_filelist != None:
|
|
try:
|
|
f = open( rpm_filelist, 'w' )
|
|
for m in moved_files:
|
|
f.write( '%s\n' % m )
|
|
f.close()
|
|
except:
|
|
die( 'Error creating fileslist %s' % rpm_filelist )
|
|
|
|
if __name__ == "__main__":
|
|
main()
|