buildtools/wafsamba/samba_install.py

   1 ###########################
   2 # this handles the magic we need to do for installing
   3 # with all the configure options that affect rpath and shared
   4 # library use
   5
   6 import Options
   7 from TaskGen import feature, before, after
   8 from samba_utils import *
   9
  10 @feature('install_bin')
  11 @after('apply_core')
  12 @before('apply_link', 'apply_obj_vars')
  13 def install_binary(self):
  14     '''install a binary, taking account of the different rpath varients'''
  15     bld = self.bld
  16
  17     # get the ldflags we will use for install and build
  18     install_ldflags = install_rpath(self)
  19     build_ldflags   = build_rpath(bld)
  20
  21     if not Options.is_install:
  22         # just need to set rpath if we are not installing
  23         self.env.RPATH = build_ldflags
  24         return
  25
  26     # work out the install path, expanding variables
  27     install_path = getattr(self, 'samba_inst_path', None) or '${BINDIR}'
  28     install_path = bld.EXPAND_VARIABLES(install_path)
  29
  30     orig_target = os.path.basename(self.target)
  31
  32     if install_ldflags != build_ldflags:
  33         # we will be creating a new target name, and using that for the
  34         # install link. That stops us from overwriting the existing build
  35         # target, which has different ldflags
  36         self.target += '.inst'
  37
  38     # setup the right rpath link flags for the install
  39     self.env.RPATH = install_ldflags
  40
  41     if not self.samba_install:
  42         # this binary is marked not to be installed
  43         return
  44
  45     # tell waf to install the right binary
  46     bld.install_as(os.path.join(install_path, orig_target),
  47                    os.path.join(self.path.abspath(bld.env), self.target),
  48                    chmod=MODE_755)
  49
  50
  51
  52 @feature('install_lib')
  53 @after('apply_core')
  54 @before('apply_link', 'apply_obj_vars')
  55 def install_library(self):
  56     '''install a library, taking account of the different rpath varients'''
  57     if getattr(self, 'done_install_library', False):
  58         return
  59
  60     bld = self.bld
  61
  62     default_env = bld.all_envs['default']
  63     if self.env['IS_EXTRA_PYTHON']:
  64         bld.all_envs['default'] = bld.all_envs['extrapython']
  65
  66     install_ldflags = install_rpath(self)
  67     build_ldflags   = build_rpath(bld)
  68
  69     if not Options.is_install or not getattr(self, 'samba_install', True):
  70         # just need to set the build rpath if we are not installing
  71         self.env.RPATH = build_ldflags
  72         return
  73
  74     # setup the install path, expanding variables
  75     install_path = getattr(self, 'samba_inst_path', None)
  76     if install_path is None:
  77         if getattr(self, 'private_library', False):
  78             install_path = '${PRIVATELIBDIR}'
  79         else:
  80             install_path = '${LIBDIR}'
  81     install_path = bld.EXPAND_VARIABLES(install_path)
  82
  83     target_name = self.target
  84
  85     if install_ldflags != build_ldflags:
  86         # we will be creating a new target name, and using that for the
  87         # install link. That stops us from overwriting the existing build
  88         # target, which has different ldflags
  89         self.done_install_library = True
  90         t = self.clone(self.env)
  91         t.posted = False
  92         t.target += '.inst'
  93         self.env.RPATH = build_ldflags
  94     else:
  95         t = self
  96
  97     t.env.RPATH = install_ldflags
  98
  99     dev_link     = None
 100
 101     # in the following the names are:
 102     # - inst_name is the name with .inst. in it, in the build
 103     #   directory
 104     # - install_name is the name in the install directory
 105     # - install_link is a symlink in the install directory, to install_name
 106
 107     if getattr(self, 'samba_realname', None):
 108         install_name = self.samba_realname
 109         install_link = None
 110         if getattr(self, 'soname', ''):
 111             install_link = self.soname
 112         if getattr(self, 'samba_type', None) == 'PYTHON':
 113             inst_name    = bld.make_libname(t.target, nolibprefix=True, python=True)
 114         else:
 115             inst_name    = bld.make_libname(t.target)
 116     elif self.vnum:
 117         vnum_base    = self.vnum.split('.')[0]
 118         install_name = bld.make_libname(target_name, version=self.vnum)
 119         install_link = bld.make_libname(target_name, version=vnum_base)
 120         inst_name    = bld.make_libname(t.target)
 121         if not self.private_library:
 122             # only generate the dev link for non-bundled libs
 123             dev_link     = bld.make_libname(target_name)
 124     elif getattr(self, 'soname', ''):
 125         install_name = bld.make_libname(target_name)
 126         install_link = self.soname
 127         inst_name    = bld.make_libname(t.target)
 128     else:
 129         install_name = bld.make_libname(target_name)
 130         install_link = None
 131         inst_name    = bld.make_libname(t.target)
 132
 133     if t.env.SONAME_ST:
 134         # ensure we get the right names in the library
 135         if install_link:
 136             t.env.append_value('LINKFLAGS', t.env.SONAME_ST % install_link)
 137         else:
 138             t.env.append_value('LINKFLAGS', t.env.SONAME_ST % install_name)
 139         t.env.SONAME_ST = ''
 140
 141     # tell waf to install the library
 142     bld.install_as(os.path.join(install_path, install_name),
 143                    os.path.join(self.path.abspath(bld.env), inst_name),
 144                    chmod=MODE_755)
 145     if install_link and install_link != install_name:
 146         # and the symlink if needed
 147         bld.symlink_as(os.path.join(install_path, install_link), os.path.basename(install_name))
 148     if dev_link:
 149         bld.symlink_as(os.path.join(install_path, dev_link), os.path.basename(install_name))
 150
 151     bld.all_envs['default'] = default_env
 152
 153
 154 @feature('cshlib')
 155 @after('apply_implib')
 156 @before('apply_vnum')
 157 def apply_soname(self):
 158     '''install a library, taking account of the different rpath varients'''
 159
 160     if self.env.SONAME_ST and getattr(self, 'soname', ''):
 161         self.env.append_value('LINKFLAGS', self.env.SONAME_ST % self.soname)
 162         self.env.SONAME_ST = ''
 163
 164 @feature('cshlib')
 165 @after('apply_implib')
 166 @before('apply_vnum')
 167 def apply_vscript(self):
 168     '''add version-script arguments to library build'''
 169
 170     if self.env.HAVE_LD_VERSION_SCRIPT and getattr(self, 'version_script', ''):
 171         self.env.append_value('LINKFLAGS', "-Wl,--version-script=%s" %
 172             self.version_script)
 173         self.version_script = None
 174
 175
 176 ##############################
 177 # handle the creation of links for libraries and binaries in the build tree
 178
 179 @feature('symlink_lib')
 180 @after('apply_link')
 181 def symlink_lib(self):
 182     '''symlink a shared lib'''
 183
 184     if self.target.endswith('.inst'):
 185         return
 186
 187     blddir = os.path.dirname(self.bld.srcnode.abspath(self.bld.env))
 188     libpath = self.link_task.outputs[0].abspath(self.env)
 189
 190     # calculat the link target and put it in the environment
 191     soext=""
 192     vnum = getattr(self, 'vnum', None)
 193     if vnum is not None:
 194         soext = '.' + vnum.split('.')[0]
 195
 196     link_target = getattr(self, 'link_name', '')
 197     if link_target == '':
 198         basename = os.path.basename(self.bld.make_libname(self.target, version=soext))
 199         if getattr(self, "private_library", False):
 200             link_target = '%s/private/%s' % (LIB_PATH, basename)
 201         else:
 202             link_target = '%s/%s' % (LIB_PATH, basename)
 203
 204     link_target = os.path.join(blddir, link_target)
 205
 206     if os.path.lexists(link_target):
 207         if os.path.islink(link_target) and os.readlink(link_target) == libpath:
 208             return
 209         os.unlink(link_target)
 210
 211     link_container = os.path.dirname(link_target)
 212     if not os.path.isdir(link_container):
 213         os.makedirs(link_container)
 214
 215     os.symlink(libpath, link_target)
 216
 217
 218 @feature('symlink_bin')
 219 @after('apply_link')
 220 def symlink_bin(self):
 221     '''symlink a binary into the build directory'''
 222
 223     if self.target.endswith('.inst'):
 224         return
 225
 226     blddir = os.path.dirname(self.bld.srcnode.abspath(self.bld.env))
 227     if not self.link_task.outputs or not self.link_task.outputs[0]:
 228         raise Utils.WafError('no outputs found for %s in symlink_bin' % self.name)
 229     binpath = self.link_task.outputs[0].abspath(self.env)
 230     bldpath = os.path.join(self.bld.env.BUILD_DIRECTORY, self.link_task.outputs[0].name)
 231
 232     if os.path.lexists(bldpath):
 233         if os.path.islink(bldpath) and os.readlink(bldpath) == binpath:
 234             return
 235         os.unlink(bldpath)
 236     os.symlink(binpath, bldpath)