github.phpd.cn/thought-machine/please@v12.2.0+incompatible/build_defs/fpm.build_defs

"""Contains build rules for using fpm to package files.

See https://github.com/jordansissel/fpm for more details about the excellent fpm tool.
"""


def fpm_package(name, version, package_type, files=None, dirs=None, links=None, package_name=None,
                options='', post_cmds=None, srcs=None, deps=None, visibility=None,
                labels=None, _apply_deb_deps=False):
    """Defines a rule to build a package using fpm.

    Args:
      name (str): Rule name
      files (dict): Dict of locations -> files to include, for example:
             {
                 '/usr/bin/plz': '//src:please',
                 '/usr/share/plz/junit_runner': '//src/build/java:junit_runner',
                 '/usr/share/plz/some_file': 'some_file',  # file in this package
             }
      dirs (dict): Dict of directories -> rules to move into that directory, for example:
             {
                 '/usr/bin': ['//src:please'],
                 '/usr/share/plz': ['//src/build/java:junit_runner', 'some_file'],
             }
      links (dict): Dict of locations -> file to link to, for example:
             {
                 '/usr/bin/plz': '/opt/please',
             }
      version (str): Version of the package.
      package_type (str): Type of package to build (deb, rpm, etc)
      package_name (str): Name of package. Defaults to rule name.
      options (str): Extra options to pass to fpm.
      post_cmds (list): Additional commands to run after the .deb is built.
      srcs (list): Extra sources (it's not necessary to mention entries in 'files' here)
      deps (list): Dependencies
      visibility (list): Visibility specification.
      labels (list): Labels associated with this rule.
    """
    package_name = package_name or name
    cmds = ['mkdir _tmp']
    srcs = srcs or []
    if files:
        cmds.extend(['mkdir -p _tmp/$(dirname %s) && cp -r $(location %s) _tmp/%s' %
                     (k.lstrip('/'), v, k.lstrip('/')) for k, v in sorted(files.items())])
        srcs.extend(sorted(files.values()))
    if dirs:
        cmds.extend(['mkdir -p _tmp/%s && cp -r %s _tmp/%s' %
                     (k, ' '.join(['$(locations %s)' % x for x in v]), k)
                     for k, v in sorted(dirs.items())])
        for v in sorted(dirs.values()):
            srcs.extend(v)
    cmds.append('cd _tmp')
    if links:
        cmds.extend(['mkdir -p $(dirname %s) && ln -s %s %s' %
                     (k.lstrip('/'), v, k.lstrip('/')) for k, v in sorted(links.items())])
    cmds.append('fpm -s dir -t %s -n "%s" -v "%s" %s -p $OUT .' % (package_type, package_name,
                                                                   version, options))
    if post_cmds:
        cmds.extend(post_cmds)
    cmd = ' && '.join(cmds)
    return build_rule(
        name=name,
        srcs=srcs,
        outs=['%s_%s_%s.deb' % (package_name, version, CONFIG.ARCH)],
        cmd=cmd,
        deps=deps,
        visibility=visibility,
        building_description='Packaging...',
        requires=['fpm'],
        labels=labels,
        pre_build=_deb_deps(cmd, package_name) if _apply_deb_deps else None,
        output_is_complete=True,
    )


def fpm_deb(name, version, files=None, dirs=None, links=None, package_name=None, options='',
            post_cmds=None, srcs=None, deps=None, visibility=None, labels=None):
    """Convenience wrapper around fpm_package that always builds a .deb package.

    Args:
      name (str): Rule name
      files (dict): Dict of locations -> files to include, for example:
             {
                 '/usr/bin/plz': '//src:please',
                 '/usr/share/plz/junit_runner': '//src/build/java:junit_runner',
                 '/usr/share/plz/some_file': 'some_file',  # file in this package
             }
      dirs (dict): Dict of directories -> rules to move into that directory, for example:
             {
                 '/usr/bin': ['//src:please'],
                 '/usr/share/plz': ['//src/build/java:junit_runner', 'some_file'],
             }
      links (dict): Dict of locations -> file to link to, for example:
             {
                 '/usr/bin/plz': '/opt/please',
             }
      version (str): Version of the package.
      package_name (str): Name of package. Defaults to rule name.
      options (str): Extra options to pass to fpm.
      post_cmds (list): Additional commands to run after the .deb is built.
      srcs (list): Extra sources (it's not necessary to mention entries in 'files' here)
      deps (list): Dependencies
      visibility (list): Visibility specification.
      labels (list): Labels associated with this rule.
    """
    return fpm_package(
        name=name,
        files=files,
        dirs=dirs,
        version=version,
        package_type='deb',
        links=links,
        package_name=package_name,
        options=options,
        post_cmds=post_cmds,
        srcs=srcs,
        deps=deps,
        visibility=visibility,
        labels=(labels or []) + [
            'deb',
            'deb_pkg:%s' % (package_name or name),
        ],
        _apply_deb_deps=True,
    )


def _deb_deps(cmd, current_label):
    """Returns a pre-build function that updates the fpm command to add .deb dependencies."""
    def _find_deb_deps(name):
        deps = ' '.join(['-d ' + label for label in get_labels(name, 'deb_pkg:')
                         if label != current_label])
        # Insert immediately after fpm, because it doesn't honour flags after positional arguments.
        set_command(name, cmd.replace(' && fpm ', ' && fpm %s ' % deps))
    return _find_deb_deps