Exemplo n.º 1
0
 def _get_make_env(self, build: targets.Build, wd: str) -> str:
     openssl_pkg = build.get_package("openssl")
     libffi_pkg = build.get_package("libffi")
     uuid_pkg = build.get_package("uuid")
     zlib_pkg = build.get_package("zlib")
     env = build.get_ld_env([openssl_pkg, libffi_pkg, uuid_pkg, zlib_pkg],
                            wd)
     return " ".join(env)
Exemplo n.º 2
0
    def get_build_script(self, build: targets.Build) -> str:
        # Run edgedb-server --bootstrap to produce stdlib cache
        # for the benefit of faster bootstrap in the package.
        common_script = super().get_build_script(build)

        pg_pkg = build.get_package("postgresql-edgedb")
        icu_pkg = build.get_package("icu")
        openssl_pkg = build.get_package("openssl")
        uuid_pkg = build.get_package("uuid")

        build_python = build.sh_get_command("python")
        temp_dir = build.get_temp_dir(self, relative_to="pkgbuild")
        cachedir = temp_dir / "_datacache"
        pg_temp_install_path = (
            build.get_build_dir(pg_pkg, relative_to="pkgbuild") / "_install")
        bindir = build.get_install_path("bin").relative_to("/")
        libdir = build.get_install_path("lib").relative_to("/")
        pg_config = pg_temp_install_path / bindir / "pg_config"
        pg_libpath = pg_temp_install_path / libdir

        temp_install_dir = build.get_temp_root(
            relative_to="pkgbuild") / build.get_full_install_prefix(
            ).relative_to("/")
        sitescript = (
            f"import site; "
            f'print(site.getsitepackages(["{temp_install_dir}"])[0])')
        runstatescript = "import tempfile; " "print(tempfile.mkdtemp())"
        abspath = (
            "import pathlib, sys; print(pathlib.Path(sys.argv[1]).resolve())")

        ld_env = " ".join(
            build.get_ld_env(
                deps=[icu_pkg, openssl_pkg, uuid_pkg],
                wd="${_wd}",
                extra=["${_ldlibpath}"],
            ))

        if platform.system() == "Darwin":
            # Workaround SIP madness on macOS and allow popen() calls
            # in postgres to inherit DYLD_LIBRARY_PATH.
            extraenv = "PGOVERRIDESTDSHELL=1"
        else:
            extraenv = ""

        data_cache_script = textwrap.dedent(f"""\
            mkdir -p "{cachedir}"
            _tempdir=$("{build_python}" -c '{runstatescript}')
            if [ "$(whoami)" = "root" ]; then
                chown nobody "{cachedir}"
                chown nobody "${{_tempdir}}"
                _sudo="sudo -u nobody"
            else
                _sudo=""
            fi
            _pythonpath=$("{build_python}" -c '{sitescript}')
            _pythonpath=$("{build_python}" -c '{abspath}' "${{_pythonpath}}")
            _cachedir=$("{build_python}" -c '{abspath}' "{cachedir}")
            _pg_config=$("{build_python}" -c '{abspath}' "{pg_config}")
            _ldlibpath=$("{build_python}" -c '{abspath}' "{pg_libpath}")
            _build_python=$("{build_python}" -c '{abspath}' "{build_python}")
            _wd=$("{build_python}" -c '{abspath}' "$(pwd)")

            (
                cd ../;
                ${{_sudo}} env \\
                    {ld_env} {extraenv} \\
                    PYTHONPATH="${{_pythonpath}}" \\
                    _EDGEDB_BUILDMETA_PG_CONFIG_PATH="${{_pg_config}}" \\
                    _EDGEDB_WRITE_DATA_CACHE_TO="${{_cachedir}}" \\
                    "${{_build_python}}" \\
                        -m edb.server.main \\
                        --data-dir="${{_tempdir}}" \\
                        --runstate-dir="${{_tempdir}}" \\
                        --bootstrap-only
                    rm -rf "${{_tempdir}}"
            )

            mkdir ./share/
            cp "${{_cachedir}}"/* ./share/
            pwd
            ls -al ./share/
        """)

        return f"{common_script}\n{data_cache_script}"
Exemplo n.º 3
0
    def get_build_script(self, build: targets.Build) -> str:
        sdir = build.get_source_dir(self, relative_to="pkgbuild")
        src_python = build.sh_get_command("python",
                                          package=self,
                                          relative_to="pkgsource")
        build_python = build.sh_get_command("python")
        dest = build.get_temp_root(
            relative_to="pkgbuild") / build.get_full_install_prefix(
            ).relative_to("/")

        sitescript = (f"import site; "
                      f'print(site.getsitepackages(["{dest}"])[0])')

        src_dest = build.get_temp_root(
            relative_to="pkgsource") / build.get_full_install_prefix(
            ).relative_to("/")

        src_sitescript = (f"import site; "
                          f'print(site.getsitepackages(["{src_dest}"])[0])')

        wheeldir_script = 'import pathlib; print(pathlib.Path(".").resolve())'

        abspath = (
            "import pathlib, sys; print(pathlib.Path(sys.argv[1]).resolve())")

        pkgname = getattr(self, "dist_name", None)
        if pkgname is None:
            pkgname = self.name
            if pkgname.startswith("pypkg-"):
                pkgname = pkgname[len("pypkg-"):]

        env = build.sh_append_global_flags({
            "SETUPTOOLS_SCM_PRETEND_VERSION":
            self.pretty_version,
            "PIP_DISABLE_PIP_VERSION_CHECK":
            "1",
        })

        dep_names = [dep.name for dep in self.build_requires]
        build_deps = build.get_packages(dep_names)

        if pkgname == "wheel":
            build_command = f'"{src_python}" setup.py sdist -d ${{_wheeldir}}'
            binary = False
        else:
            args = [
                src_python,
                "-m",
                "pip",
                "wheel",
                "--verbose",
                "--wheel-dir",
                "${_wheeldir}",
                "--no-binary=:all:",
                "--no-build-isolation",
                "--use-feature=in-tree-build",
                "--no-deps",
                ".",
            ]
            build_command = " ".join(
                shlex.quote(c) if c[0] != "$" else c for c in args)
            env.update(
                self.sh_get_build_wheel_env(
                    build, site_packages_var="${_sitepkg_from_src}"))

            cflags = build.sh_get_bundled_shlibs_cflags(
                build_deps,
                relative_to="pkgsource",
            )

            if cflags:
                build.sh_append_flags(env, "CFLAGS", cflags)

            ldflags = build.sh_get_bundled_shlibs_ldflags(
                build_deps,
                relative_to="pkgsource",
            )

            if ldflags:
                build.sh_append_flags(env, "LDFLAGS", ldflags)

            binary = True

        all_build_deps = build.get_packages(dep_names, recursive=True)
        env_str = build.sh_format_command("env", env, force_args_eq=True)
        env_str += " " + " ".join(build.get_ld_env(all_build_deps, "${_wd}"))

        return textwrap.dedent(f"""\
            _wheeldir=$("{build_python}" -c '{wheeldir_script}')
            _target=$("{build_python}" -c '{sitescript}')
            _sitepkg_from_src=$("{build_python}" -c '{src_sitescript}')
            _wd=$("{build_python}" -c '{abspath}' "$(pwd)")
            (cd "{sdir}"; \\
             {env_str} \\
                 {build_command})
            "{build_python}" -m pip install \\
                --no-build-isolation \\
                --no-warn-script-location \\
                --no-index \\
                --no-deps \\
                --upgrade \\
                -f "file://${{_wheeldir}}" \\
                {'--only-binary' if binary else '--no-binary'} :all: \\
                --target "${{_target}}" \\
                "{pkgname}"
        """)