[关闭]
@lupnfer 2016-12-19T13:17:03.000000Z 字数 16714 阅读 779

OpenSource

工作

  1. .
  2. ├── build_opensource.py                          F主编译脚本
  3. ├── build_scripts                                D子库编译脚本
  4. │   ├── build_boost.py
  5. │   ├── build_curl.py 
  6. │   ├── build_gflags.py
  7. │   ├── build_glog.py
  8. │   ├── build_googletest.py
  9. │   ├── build_gperftools.py
  10. │   ├── build_jsoncpp.py
  11. │   ├── build_libevent.py
  12. │   ├── build_libodb_boost.py
  13. │   ├── build_libodb_pgsql.py
  14. │   ├── build_libodb.py
  15. │   ├── build_libodb_sqlite.py
  16. │   ├── build_libpq.py
  17. │   ├── build_openssl.py
  18. │   ├── build_protobuf.py
  19. │   ├── build_sqlite.py
  20. │   ├── build_thrift.py
  21. │   ├── build_zeromq.py
  22. │   ├── build_zlib.py
  23. │   └── common.py                                 F基础函数  
  24. ├── makefiles 
  25. │   ├── boost-common
  26. │   ├── boost-cygwin
  27. │   ├── boost-linux
  28. │   ├── boost-windows
  29. │   ├── libevent-windows
  30. │   ├── libodb-windows
  31. │   ├── sqlite-windows
  32. │   ├── thrift-cpp-windows
  33. │   ├── zeromq-windows
  34. │   └── zlib-windows
  35. ├── packages                                       D基础库第三方库源
  36. │   ├── boost_1_61_0.tar.bz2
  37. │   ├── curl-7.46.0.tar.bz2
  38. │   ├── gflags
  39. │   ├── glog
  40. │   ├── googletest
  41. │   ├── gperftools
  42. │   ├── jsoncpp
  43. │   ├── libevent-2.0.22-stable.tar.gz
  44. │   ├── libodb-2.4.0.tar.bz2
  45. │   ├── libodb-boost-2.4.0.tar.bz2
  46. │   ├── libodb-pgsql-2.4.0.tar.bz2
  47. │   ├── libodb-sqlite-2.4.0.tar.bz2
  48. │   ├── openssl-1.0.2h.tar.gz
  49. │   ├── postgresql-9.4.5.tar.bz2
  50. │   ├── protobuf-cpp-3.1.0.tar.gz
  51. │   ├── sqlite-autoconf-3100200.tar.gz
  52. │   ├── thrift-0.9.3.tar.gz
  53. │   ├── zeromq-4.1.3.tar.gz
  54. │   └── zlib-1.2.8.tar.gz
  55. ├── README.md
  56. └── source_include
  57.     └── boost

build_opensource.py

  1. #!/usr/bin/env python
  2. #encoding: utf-8
  4. #
  5. # opensource build scripts for IA10K project
  6. # Author: jibin 00081
  7. #
  9. import os
  10. import sys
  11. import glob
  12. import shutil
  13. import tarfile
  14. import platform
  15. import subprocess
  16. import logging
  17. import time
  18. import re
  19. import optparse
  21. sys.path.append(os.path.join(os.path.dirname(__file__), 'build_scripts'))
  22. from common import *
  24. if __name__ == '__main__':
  25.     parser = optparse.OptionParser()
  26.     parser.add_option('-D', '--debug', 
  27.                       help='show debug when build.', 
  28.                       dest='debug', 
  29.                       action='store_true', 
  30.                       default=False) 
  31.     parser.add_option('-q', '--quiet', 
  32.                       help='not show verbose when build.', 
  33.                       dest='verbose', 
  34.                       action='store_false', 
  35.                       default=True) 
  36.     parser.add_option('-f', '--force', 
  37.                       help='force to rebuild.', 
  38.                       dest='force', 
  39.                       action='store_true', 
  40.                       default=False) 
  41.     parser.add_option('-c', '--compiler', 
  42.                       help='compiler to build. valid: %s' % ','.join(get_compiler_list()), 
  43.                       dest='compiler',
  44.                       default=get_default_compiler())
  45.     parser.add_option('-p', '--package',
  46.                       help='module to build. valid: %s' % ','.join(get_package_list()),
  47.                       dest='package',
  48.                       default=get_package_default())
  49.     parser.add_option('-a', '--arch',
  50.                       help='arch to build. valid: %s' % ','.join(get_arch_list()),
  51.                       dest='arch',
  52.                       default=get_arch_default())
  53.     parser.add_option('-t', '--target',
  54.                       help='target to build. valid: %s' % ','.join(get_target_list()),
  55.                       dest='target',
  56.                       default=get_target_default())
  57.     parser.add_option('-m', '--no-yum',
  58.                       help='compile all source, default is using yum devel package instead of compile it self',
  59.                       dest='yum',
  60.                       action='store_false',
  61.                       default=True)
  63.     (options, args) = parser.parse_args()
  65.     # set logging level
  66.     logging_level = logging.WARN
  68.     if options.verbose:
  69.         logging_level=logging.INFO
  70.     if options.debug:
  71.         logging_level=logging.DEBUG
  73.     logging.basicConfig(
  74.         level=logging_level,
  75.         format='[%(asctime)s] [%(filename)s:%(lineno)d] [%(levelname)s] %(message)s',
  76.         datefmt='%Y-%m-%d %H:%M:%S',
  77.     )
  79.     c = options.compiler
  81.     ps = options.package.split(',')
  82.     ar = options.arch.split(',')
  83.     ts = options.target.split(',')
  85.     if options.package == 'all':
  86.         ps = get_package_list()
  87.     if options.arch == 'all':
  88.         ar = get_arch_list()
  89.     if options.target == 'all':
  90.         ts = get_target_list()
  92.     for p in ps:
  93.         for a in ar:
  94.             for t in ts:
  95.                 logging.info('build %s %s %s using %s', p, a, t, c) 
  96.                 bc = BuilderFactory(p)
  97.                 b = bc(a, t, c, options.force)
  98.                 b.verbose = options.verbose
  99.                 b.debug = options.debug
  100.                 b.yum = options.yum
  101.                 try:
  102.                     b.build()
  103.                 except Exception, ex:
  104.                     logging.error('build %s %s %s using %s failed.', p, a, t, c)
  105.                     import traceback
  106.                     traceback.print_exc(ex)
  107.                     sys.exit(1)

common.py

  1. #!/usr/bin/env python
  2. #encoding: utf-8
  3. import sys
  4. import os
  5. import glob
  6. import logging
  7. import shutil
  8. import time
  9. import subprocess
  10. import re
  11. import multiprocessing
  13. _vc_lists_ = ['vc14', 'vc12', 'vc11', 'vc10']
  15. def get_vcvarsall(ver):
  16.     """
  17.     get where vc is installed, return the full-path of vcvarsall.bat
  18.     """
  19.     try:
  20.         import _winreg
  21.         rp = ''
  22.         if sys.maxsize > 2**32:
  23.             rp = 'Software\Wow6432Node\Microsoft\VisualStudio\%.1f\Setup\VC' % float(ver)
  24.         else:
  25.             rp = 'Software\Microsoft\VisualStudio\%.1f\Setup\VC' % float(ver)
  27.         key = _winreg.OpenKey(_winreg.HKEY_LOCAL_MACHINE, rp)
  28.         vs = _winreg.QueryValueEx(key, 'ProductDir')
  29.         if os.path.isfile(os.path.join(vs[0], 'vcvarsall.bat')):
  30.             return os.path.join(vs[0], 'vcvarsall.bat')
  31.     except Exception, ex:
  32.         pass
  33.     return None
  35. def get_gcc_march():
  36.     return 'core2'
  38. def get_compiler_list():
  39.     if sys.platform.startswith('linux'):
  40.         return ['gcc']
  41.     elif sys.platform == 'cygwin':
  42.         return ['gcc']
  43.     elif sys.platform == 'win32':
  44.         return _vc_lists_
  46. def get_default_compiler():
  47.     if sys.platform.startswith('linux'):
  48.         return 'gcc'
  49.     elif sys.platform == 'cygwin':
  50.         return 'gcc'
  51.     elif sys.platform == 'win32':
  52.         for vc in _vc_lists_:
  53.             ver = vc.replace('vc', '')
  54.             if get_vcvarsall(ver):
  55.                 return vc
  56.     return 'NONE'
  59. def get_package_list():
  60.     ret = []
  61.     for x in os.listdir(os.path.dirname(__file__)):
  62.         if x.endswith('.py') and x.startswith('build_'):
  63.             mx = x.replace('.py', '').replace('build_', '')
  64.             ret.append(mx)
  65.     return ret
  67. def get_package_default():
  68.     return ','.join(get_package_list())
  70. def get_target_list():
  71.     return ['Debug', 'RelWithDebInfo']
  73. def get_target_default():
  74.     return 'RelWithDebInfo'
  76. def get_arch_list():
  77.     if sys.platform == 'cygwin':
  78.         return ['x64']
  79.     else:
  80.         return ['x86', 'x64']
  82. def get_arch_default():
  83.     return 'x64'
  85. def patch_textfile_(filename, pattern, replace):
  86.     content = None
  87.     with open(filename) as fp:
  88.         content = fp.read()
  89.     if content:
  90.         content = re.sub(pattern, replace, content)
  91.         with open(filename, 'w') as fp:
  92.             fp.write(content)
  94. def cleanup_build_(build_parent, pattern):
  95.     for x in glob.glob(os.path.join(build_parent, pattern)):
  96.         logging.info('cleanup deleting %s' % x)
  97.         try:
  98.             shutil.rmtree(x)
  99.         except Exception:
  100.             pass
  101.     time.sleep(1)
  104. def BuilderFactory(package):
  105.     try:
  106.         exec('from build_%s import %sBuilder' % (package, package))
  107.         exec('x=%sBuilder' % package)
  108.         return x
  109.     except Exception:
  110.         logging.error('no class %sBuilder found' % package)
  111.         return None
  113. class BasicBuilder():
  114.     def __init__(self, package, arch, target, compiler, force):
  115.         self.package = package
  116.         self.arch = arch
  117.         self.target = target
  118.         self.compiler = compiler
  119.         self.force = force    
  120.         self.build_parent = os.path.realpath(os.path.join('build', compiler, arch, target))
  121.         self.build_touch = os.path.join(self.build_parent, 'buildstamp_%s' % package)
  122.         self.windows = False
  123.         self.linux = False
  124.         self.cygwin = False
  125.         self.vc_ver = 0
  126.         self.verbose = True
  127.         self.debug = False
  128.         self.cpu = multiprocessing.cpu_count()
  130.         if self.compiler.startswith('vc'):
  131.             self.vc_ver = int(self.compiler.replace('vc', ''))        
  133.         self.platform = ''
  134.         if sys.platform.startswith('linux'):
  135.             self.linux = True
  136.             self.platform = 'linux'
  137.             os.environ['BUILD_TOOL_CMAKE'] = os.path.realpath('../tools/cmake/bin/cmake')
  138.         elif sys.platform == 'cygwin':
  139.             self.cygwin = True
  140.             self.platform = 'cygwin'
  141.             os.environ['BUILD_TOOL_CMAKE'] = 'cmake'
  142.         elif sys.platform == 'win32':
  143.             self.windows = True
  144.             self.platform = 'windows'
  145.             os.environ['BUILD_TOOL_CMAKE'] = os.path.realpath('../tools/cmake/bin/cmake.exe')
  147.         self.install_dir = os.path.realpath(os.path.join('dest', self.platform, arch, compiler, target))
  148.         self.install_inc_dir = os.path.join(self.install_dir, 'include')
  149.         self.install_lib_dir = os.path.join(self.install_dir, 'lib')
  151.         if self.linux or self.cygwin:
  152.             os.environ['PKG_CONFIG_PATH'] = os.path.join(self.install_lib_dir, 'pkgconfig')
  154.     def depends(self):
  155.         raise Exception('not impl!')
  157.     def build(self):
  158.         if self.package not in get_package_list():
  159.             logging.warn('package %s is not valid', self.package)
  160.             return
  161.         if self.arch not in get_arch_list():
  162.             logging.warn('arch %s is not valid', sefl.arch)
  163.             return
  164.         if self.target not in get_target_list():
  165.             logging.warn('target %s is not valid', self.target)
  166.             return
  168.         # do build depends
  169.         for p in self.depends():
  170.             BC = BuilderFactory(p)
  171.             pb = BC(self.arch, self.target, self.compiler, False)
  172.             pb.verbose = self.verbose
  173.             pb.debug = self.debug
  174.             pb.yum = self.yum
  175.             pb.build()
  177.         do_build = True
  178.         if not self.force:
  179.             if os.path.isfile(self.build_touch):
  180.                 st0 = os.stat(self.build_touch)
  181.                 mts = []
  182.                 # mts.append(os.stat(__file__).st_mtime)
  183.                 # mts.append(os.stat(sys.argv[0]).st_mtime)
  184.                 mts.append(os.stat(os.path.join('build_scripts', 'build_%s.py' % self.package)).st_mtime)
  185.                 for p in self.depends():
  186.                     ptouch = os.path.join(self.build_parent, 'buildstamp_%s' % p)
  187.                     mts.append(os.stat(ptouch).st_mtime)
  188.                 do_build = False
  189.                 for mt in mts:
  190.                     if st0.st_mtime < mt:
  191.                         do_build = True
  192.                         break
  194.         if do_build:
  195.             if not os.path.isdir(self.build_parent):
  196.                 os.makedirs(self.build_parent)
  198.             oldllp = None
  199.             if os.environ.has_key('LD_LIBRARY_PATH'):
  200.                 oldllp = os.environ['LD_LIBRARY_PATH']    
  202.             oldpath = None
  203.             if os.environ.has_key('PATH'):
  204.                 oldpath = os.environ['PATH']   
  206.             os.environ['LD_LIBRARY_PATH'] = os.path.join(self.install_lib_dir)
  207.             os.environ['PATH'] = '%s:%s' % (os.path.join(self.install_dir, 'bin'), oldpath)
  208.             self.prebuild()
  209.             self.compile()
  210.             self.install()
  211.             self.postbuild()
  213.             del os.environ['LD_LIBRARY_PATH']
  214.             if oldllp: 
  215.                 os.environ['LD_LIBRARY_PATH'] = oldllp
  217.             del os.environ['PATH']
  218.             if oldpath: 
  219.                 os.environ['PATH'] = oldpath
  221.             with open(self.build_touch, 'w') as fp:
  222.                 fp.write('ok')
  223.         else:
  224.             logging.warn('build %s %s %s using %s skipped.', self.package, self.arch, self.target, self.compiler)
  227.     def prebuild(self):
  228.         raise Exception('not impl')
  230.     def compile(self):
  231.         raise Exception('not impl')
  233.     def install(self):
  234.         raise Exception('not impl')
  236.     def postbuild(self):
  237.         raise Exception('not impl')
  239.     def find_build_(self, pattern):
  240.         fd = glob.glob(os.path.join(self.build_parent, pattern))
  241.         if len(fd) != 1 or (not os.path.isdir(fd[0])):
  242.             return None
  243.         else:
  244.             logging.info('find build dir %s', fd[0])
  245.             return fd[0]
  247.     def find_package_(self, pattern):
  248.         fs = glob.glob(os.path.join('packages', pattern))
  249.         if len(fs) != 1:
  250.             raise Exception('unexpected source packages got: %s', fs)
  251.         return fs[0]
  253.     def extract_(self, pattern, dest_pattern):
  255.         fs = glob.glob(os.path.join('packages', pattern))
  256.         if len(fs) != 1:
  257.             raise Exception('unexpected source packages got: %s', fs)
  259.         logging.info('extracting source %s -> %s', fs[0], self.build_parent)
  261.         tool7za = None
  262.         if self.cygwin or self.windows:
  263.             tool7za = os.path.realpath('../tools/7z/7za.exe')
  265.         bp = self.build_parent
  266.         np = fs[0]
  267.         if self.cygwin:
  268.             # translate to windows path
  269.             fp = subprocess.Popen(['cygpath', '-d', self.build_parent], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
  270.             bp = fp.stdout.read().strip().replace('\\', '/')
  271.             fp = subprocess.Popen(['cygpath', '-d', fs[0]], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
  272.             np = fp.stdout.read().strip().replace('\\', '/')
  274.         if self.linux:
  275.             if np.endswith('tar') or np.endswith('tar.gz') or np.endswith('tar.bz2'):
  276.                 os.system('tar xf %s -C %s' % (np, bp))
  277.         else:
  278.             if np.endswith('tar.gz') or np.endswith('tar.bz2'):
  279.                 os.system('%s x -mmt -so %s | %s x -si -aoa -ttar -o%s' % (tool7za, np, tool7za, bp))
  280.             elif np.endswith('tar') or np.endswith('zip'):
  281.                 os.system('%s x -mmt -aoa -o%s %s' % (tool7za, bp, np))
  283.         fd = glob.glob(os.path.join(self.build_parent, dest_pattern))
  284.         if len(fd) != 1 or (not os.path.isdir(fd[0])):
  285.             raise Exception('unexpected source build dirs got: %s', fd)
  287.         logging.info('extract success %s -> %s', fs[0], fd[0])
  288.         return fd[0]
  290.     def cleanup_build_(self, pattern):
  291.         for x in glob.glob(os.path.join(self.build_parent, pattern)):
  292.             logging.info('cleanup deleting %s' % x)
  293.             try:
  294.                 shutil.rmtree(x)
  295.             except Exception:
  296.                 pass
  297.         time.sleep(1)
  299.     def install_(self, dest_dir, patterns):
  300.         """
  301.         install files from build_dir -> dest_dir, match patterns(using glob)
  302.         pattern is glob based, and base dir is build dir
  303.         """
  304.         if type(patterns) == type(''):
  305.             patterns = [patterns]
  307.         for pattern in patterns:
  308.             fs = glob.glob(os.path.join(self.build_dir, pattern))
  309.             for f in fs:
  310.                 if not os.path.isdir(dest_dir):
  311.                     os.makedirs(dest_dir)
  312.                 if os.path.isfile(f):
  313.                     logging.info('install %s -> %s', f, dest_dir)
  314.                     dest_file = os.path.join(dest_dir, os.path.basename(f))
  315.                     try:
  316.                         os.unlink(dest_file)
  317.                     except Exception:
  318.                         pass
  319.                     if os.path.islink(f):
  320.                         os.symlink(os.readlink(f), dest_file)
  321.                     else:
  322.                         shutil.copy2(f, dest_dir)
  324.                 elif os.path.isdir(f):
  325.                     logging.info('install %s -> %s', f, dest_dir)
  326.                     d2 = os.path.join(dest_dir, os.path.basename(f))
  327.                     if os.path.isdir(d2):
  328.                         # need to remove first
  329.                         logging.info('delete %s', d2)
  330.                         shutil.rmtree(d2)
  331.                     logging.info('copy %s -> %s', f, dest_dir)
  332.                     shutil.copytree(f, d2)
  335.     def get_cmake_generator_(self):
  336.         gtable = {
  337.             14: "Visual Studio 14 2015",
  338.             12: "Visual Studio 12 2013",
  339.             11: "Visual Studio 11 2012",
  340.             10: "Visual Studio 10 2010",
  341.             9: "Visual Studio 9 2008",
  342.         }
  344.         if self.windows:
  345.             generator = gtable[self.vc_ver]
  346.             if self.arch.find('64') >= 0:
  347.                 generator += ' Win64'
  348.             return generator
  349.         elif self.linux or self.cygwin:
  350.             return 'Unix Makefiles'
  352.     def cmake_(self, defines={}):
  353.         old_pwd = os.getcwd()
  354.         os.chdir(self.build_dir)
  355.         throw_ex = None
  356.         try:
  357.             cmake_cmd = ['cmake', '-G', self.get_cmake_generator_()]
  358.             if os.environ.has_key('BUILD_TOOL_CMAKE'):
  359.                 cmake_cmd = [os.environ['BUILD_TOOL_CMAKE'], '-G', self.get_cmake_generator_()]
  361.             for d in defines:
  362.                 cmake_cmd.append('-D')
  363.                 cmake_cmd.append('%s=%s' % (d, defines[d]))
  365.             cmake_cmd.append('.')
  367.             logging.info('starting cmake using: %s', cmake_cmd)
  369.             fd = None
  370.             if self.debug or self.verbose:
  371.                 fd = subprocess.Popen(cmake_cmd)
  372.             else:
  373.                 fd = subprocess.Popen(cmake_cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
  375.             fd.wait()
  376.             if fd.returncode != 0:
  377.                 raise Exception('cmake return failed, ret=%d' % fd.returncode)
  378.         except Exception, ex:
  379.             throw_ex = ex
  380.         finally:
  381.             os.chdir(old_pwd)
  383.         if throw_ex:
  384.             raise throw_ex
  385.         logging.info('cmake success')
  388.     def msbuild_(self, sln, proj):
  389.         vcvarsall = get_vcvarsall(self.vc_ver)
  390.         if not vcvarsall:
  391.             raise Exception('vc%d is not found' % vc_ver)
  393.         old_pwd = os.getcwd()
  394.         os.chdir(self.build_dir)
  395.         throw_ex = None
  396.         try:
  397.             cmd = 'msbuild %s' % sln
  398.             cmd += ' /p:Configuration=%s' % self.target
  399.             if proj:
  400.                 cmd += ' /t:%s' % proj
  402.             logging.info('starting msbuild using: %s', cmd)
  403.             fd = None
  404.             if self.debug or self.verbose:
  405.                 fd = subprocess.Popen('"%s" x86 & %s' % (vcvarsall, cmd))
  406.             else:
  407.                 fd = subprocess.Popen('"%s" x86 & %s' % (vcvarsall, cmd), stdout=subprocess.PIPE, stderr=subprocess.PIPE)
  408.             fd.wait()
  409.             if fd.returncode != 0:
  410.                 raise Exception('msbuild return failed, ret=%d' % fd.returncode)
  411.         except Exception, ex:
  412.             throw_ex = ex
  413.         finally:
  414.             os.chdir(old_pwd)
  416.         if throw_ex:
  417.             raise throw_ex
  419.         logging.info('msbuild success')
  422.     def build_shell_(self, cmd):
  423.         old_pwd = os.getcwd()
  424.         os.chdir(self.build_dir)
  425.         throw_ex = None
  426.         try:
  427.             logging.info('starting run: %s', cmd)
  428.             fd = None
  429.             if self.windows:
  430.                 if self.debug or self.verbose:
  431.                     fd = subprocess.Popen('cmd.exe /c %s' % cmd)
  432.                 else:
  433.                     fd = subprocess.Popen('cmd.exe /c %s' % cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
  435.             elif self.linux or self.cygwin:
  436.                 if self.debug or self.verbose:
  437.                     fd = subprocess.Popen(['bash', '-c', '%s' % cmd])
  438.                 else:
  439.                     fd = subprocess.Popen(['bash', '-c', '%s' % cmd], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
  440.             fd.wait()
  441.             if fd.returncode != 0:
  442.                 raise Exception('run cmd failed, ret=%d' % fd.returncode)
  443.         except Exception, ex:
  444.             throw_ex = ex
  445.         finally:
  446.             os.chdir(old_pwd)
  448.         if throw_ex:
  449.             raise throw_ex
  452.     def nmake_(self, makefile=None, options=None, target=None):
  453.         """
  454.         call nmake to build on windows system
  455.         makefile: makefile filename, if not given, using default(Makefile)
  456.         options: make options
  457.         target: build target, if not given, using default.
  458.         """
  459.         arch = 'x86'
  460.         if self.arch.find('64') >= 0:
  461.             arch = 'amd64'
  462.         vcvarsall = get_vcvarsall(self.vc_ver)
  463.         if not vcvarsall:
  464.             raise Exception('vc%d is not found' % self.vc_ver)
  466.         old_pwd = os.getcwd()
  467.         os.chdir(self.build_dir)
  468.         throw_ex = None
  469.         try:
  470.             make_cmd = 'nmake /nologo'
  471.             if makefile:
  472.                 make_cmd += ' /f %s' % makefile
  473.             if options:
  474.                 for o in options:
  475.                     make_cmd += ' %s' % o
  476.             if target:
  477.                 make_cmd += ' %s' % target
  479.             logging.info('starting nmake using: %s', make_cmd)
  480.             fd = subprocess.Popen('"%s" %s & %s' % (vcvarsall, self.arch, make_cmd))
  481.             fd.wait()
  482.             if fd.returncode != 0:
  483.                 raise Exception('nmake return failed, ret=%d' % fd.returncode)
  484.         except Exception, ex:
  485.             throw_ex = ex
  486.         finally:
  487.             os.chdir(old_pwd)
  489.         if throw_ex:
  490.             raise throw_ex
  491.         logging.info('nmake success')

build_curl.py

  1. #!/usr/bin/env python
  2. #encoding: utf-8
  4. from common import *
  6. class curlBuilder(BasicBuilder):
  8.     def __init__(self, arch, target, compiler, force):
  9.         BasicBuilder.__init__(self, 'curl', arch, target, compiler, force)
  11.     def depends(self):
  12.         return ['zlib', 'openssl']
  14.     def prebuild(self):
  15.         if self.yum:
  16.             return
  17.         self.cleanup_build_('curl-*')
  18.         self.build_dir = self.extract_('curl-*.tar.*', 'curl-*')
  21.         options = {}
  22.         options['BUILD_CURL_EXE'] = 'OFF'
  23.         options['BUILD_CURL_TESTS'] = 'OFF'
  24.         options['CURL_DISABLE_GOPHER'] = 'ON'
  25.         options['CURL_DISABLE_IMAP'] = 'ON'
  26.         options['CURL_DISABLE_LDAP'] = 'ON'
  27.         options['CURL_DISABLE_LDAPS'] = 'ON'
  28.         options['CURL_DISABLE_POP3'] = 'ON'
  29.         options['CURL_DISABLE_RTSP'] = 'ON'
  30.         options['CURL_DISABLE_SMTP'] = 'ON'
  31.         options['CURL_DISABLE_TELNET'] = 'ON'
  32.         options['CURL_DISABLE_TFTP'] = 'ON'
  33.         options['CURL_STATICLIB'] = 'ON'
  34.         options['ENABLE_THREADED_RESOLVER'] = 'ON'
  35.         options['ENABLE_MANUAL'] = 'OFF'
  37.         options['CMAKE_BUILD_TYPE'] = 'RelWithDebInfo'
  38.         if self.target == 'Debug':
  39.             options['CMAKE_BUILD_TYPE'] = 'Debug'
  41.         options['OPENSSL_INCLUDE_DIR'] = self.install_inc_dir
  42.         options['ZLIB_INCLUDE_DIR'] = self.install_inc_dir
  44.         if self.windows:
  45.             options['OPENSSL_CRYPTO_LIBRARY'] = os.path.join(self.install_lib_dir, 'libeay32.lib')
  46.             options['OPENSSL_SSL_LIBRARY'] = os.path.join(self.install_lib_dir, 'ssleay32.lib')
  47.             options['ZLIB_LIBRARY'] = os.path.join(self.install_lib_dir, 'zlib.lib')
  49.         elif self.linux or self.cygwin:
  50.             options['OPENSSL_CRYPTO_LIBRARY'] = os.path.join(self.install_lib_dir, 'libcrypto.a')
  51.             options['OPENSSL_SSL_LIBRARY'] = os.path.join(self.install_lib_dir, 'libssl.a')
  52.             options['ZLIB_LIBRARY'] = os.path.join(self.install_lib_dir, 'libz.a')
  54.             if self.arch == 'x86':
  55.                 options['CMAKE_C_FLAGS']  = '-m32'
  56.             else:
  57.                 options['CMAKE_C_FLAGS']  = '-m64'
  59.             options['CMAKE_C_FLAGS'] +=  ' -march=%s -g' % get_gcc_march()
  61.             options['CMAKE_INSTALL_PREFIX'] = self.install_dir
  63.         # cmake generate
  64.         self.cmake_(defines=options)
  66.         if self.windows:
  67.             # patch using /Z7 for debug 
  68.             patch_textfile_(
  69.                 os.path.join(self.build_dir, 'lib', 'libcurl.vcxproj'), 
  70.                 r'<DebugInformationFormat>.+</DebugInformationFormat>', 
  71.                 r'<DebugInformationFormat>OldStyle</DebugInformationFormat>'
  72.             )
  74.     def compile(self):
  75.         if self.yum:
  76.             return
  77.         if self.windows:
  78.             self.msbuild_('CURL.sln', 'libcurl')
  79.         elif self.linux or self.cygwin:
  80.             self.build_shell_('make -j %d' % self.cpu)
  82.     def install(self):
  83.         if self.yum:
  84.             return
  85.         if self.windows:
  86.             self.install_(self.install_lib_dir, 'lib\\%s\\*.lib' % self.target)
  87.             self.install_(os.path.join(self.install_inc_dir, 'curl'), 'include\\curl\\*.h')
  88.         elif self.linux or self.cygwin:
  89.             self.build_shell_('make install')
  91.     def postbuild(self):
  92.         if self.yum:
  93.             os.system('yum -y install libcurl libcurl-devel')
添加新批注
在作者公开此批注前，只有你和作者可见。
回复批注