From 58cd496ef0f80c353a056d8b28fe667f9996da9b Mon Sep 17 00:00:00 2001 From: Sven Slootweg Date: Tue, 19 Jun 2018 14:02:40 +0200 Subject: [PATCH] Update nixpkgs-mozilla to NixOS 18.03-compatible version --- nixpkgs-mozilla/README.rst | 111 +++++++- nixpkgs-mozilla/compilers-overlay.nix | 96 +++++++ nixpkgs-mozilla/default.nix | 57 +--- nixpkgs-mozilla/firefox-overlay.nix | 166 ++++++++++++ nixpkgs-mozilla/firefox.key | 254 ++++++++++++++++++ nixpkgs-mozilla/lib-overlay.nix | 5 + nixpkgs-mozilla/lib/parseTOML.nix | 152 +++++++---- nixpkgs-mozilla/pinned.nix | 37 +++ nixpkgs-mozilla/pkgs/VidyoDesktop/default.nix | 24 +- .../pkgs/firefox-nightly-bin/default.nix | 2 +- .../pkgs/firefox-nightly-bin/sources.nix | 6 +- .../pkgs/firefox-nightly-bin/update.nix | 5 +- nixpkgs-mozilla/pkgs/gecko/default.nix | 121 +++++++-- nixpkgs-mozilla/release.nix | 155 ++++------- nixpkgs-mozilla/rr-overlay.nix | 14 + nixpkgs-mozilla/rust-overlay.nix | 45 +++- nixpkgs-mozilla/rust-src-overlay.nix | 18 ++ nixpkgs-mozilla/servo-overlay.nix | 5 + nixpkgs-mozilla/vidyo-overlay.nix | 5 + 19 files changed, 1012 insertions(+), 266 deletions(-) create mode 100644 nixpkgs-mozilla/compilers-overlay.nix create mode 100644 nixpkgs-mozilla/firefox-overlay.nix create mode 100644 nixpkgs-mozilla/firefox.key create mode 100644 nixpkgs-mozilla/lib-overlay.nix create mode 100644 nixpkgs-mozilla/pinned.nix create mode 100644 nixpkgs-mozilla/rr-overlay.nix create mode 100644 nixpkgs-mozilla/rust-src-overlay.nix create mode 100644 nixpkgs-mozilla/servo-overlay.nix create mode 100644 nixpkgs-mozilla/vidyo-overlay.nix diff --git a/nixpkgs-mozilla/README.rst b/nixpkgs-mozilla/README.rst index 235b9e3..e98db9b 100644 --- a/nixpkgs-mozilla/README.rst +++ b/nixpkgs-mozilla/README.rst @@ -20,20 +20,123 @@ Rust overlay A nixpkgs overlay is provided to contains all of the latest rust releases. To use the rust overlay run the ``./rust-overlay-install.sh`` command. It will -link the current ``./rust-overlay.nix`` into you ``~/.config/nixpkgs/overlays`` folders. +link the current ``./rust-overlay.nix`` into your ``~/.config/nixpkgs/overlays`` folder. -Once this is done, use ``nix-env -iA nixpkgs.rustChannels.nightly.rust`` for +Once this is done, use ``nix-env -iA nixpkgs.latest.rustChannels.nightly.rust`` for example. Replace the ``nixpkgs.`` prefix with ``nixos.`` on NixOS. +Using in nix expressions +------------------------ + +Example of using in ```shell.nix```: + +.. code:: nix + + let + moz_overlay = import (builtins.fetchTarball https://github.com/mozilla/nixpkgs-mozilla/archive/master.tar.gz); + nixpkgs = import { overlays = [ moz_overlay ]; }; + in + with nixpkgs; + stdenv.mkDerivation { + name = "moz_overlay_shell"; + buildInputs = [ + nixpkgs.latest.rustChannels.nightly.rust + ]; + } + +Or to retrieve a specific nightly version: + +.. code:: nix + + let + moz_overlay = import (builtins.fetchTarball https://github.com/mozilla/nixpkgs-mozilla/archive/master.tar.gz); + nixpkgs = import { overlays = [ moz_overlay ]; }; + in + with nixpkgs; + stdenv.mkDerivation { + name = "moz_overlay_shell"; + buildInputs = [ + (nixpkgs.rustChannelOf { date = "2018-04-11"; channel = "nightly"; }).rust + ]; + } + +Gecko Development Environment +----------------------------- + +The ``firefox-overlay.nix`` provides a development environment to build Firefox +from its sources, also known as Gecko. + +To build Gecko from its sources, it is best to have a local checkout of Gecko, +and to build it with a ``nix-shell``. You can checkout Gecko, either using +mercurial, or git. + +Once you have finished the checkout gecko, you should enter the ``nix-shell`` +using the ``gecko..`` attribute of the ``release.nix`` file provided +in this repository. + +The ```` attribute is either ``x86_64-linux`` or ``i686-linux``. The first +one would create a native toolchain for compiling on x64, while the second one +would give a native toolchain for compiling on x86. Note that due to the size of +the compilation units on x86, the compilation might not be able to complete, but +some sub part of Gecko, such as SpiderMonkey would compile fine. + +The ```` attribute is either ``gcc`` or ``clang``, or any specific version +of the compiler available in the ``compiler-overlay.nix`` file which is repeated +in ``release.nix``. This compiler would only be used for compiling Gecko, and +the rest of the toolchain is compiled against the default ``stdenv`` of the +architecture. + +When first enterring the ``nix-shell``, the toolchain will pull and build all +the dependencies necessary to build Gecko, this includes might take some time. +This work will not be necessary the second time, unless you use a different +toolchain or architecture. + +.. code:: sh + + ~/$ cd mozilla-central + ~/mozilla-central$ nix-shell ../nixpkgs-mozilla/release.nix -A gecko.x86_64-linux.gcc --pure + ... pull the rust compiler + ... compile the toolchain + [~/mozilla-central] python ./mach build + ... build firefox desktop + [~/mozilla-central] python ./mach run + ... run firefox + +When enterring the ``nix-shell``, the ``MOZCONFIG`` environment variable is set +to a local file, named ``.mozconfig.nix-shell``, created each time you enter the +``nix-shell``. You can create your own ``.mozconfig`` file which extends the +default one, with your own options. + +.. code:: sh + + ~/mozilla-central$ nix-shell ../nixpkgs-mozilla/release.nix -A gecko.x86_64-linux.gcc --pure + [~/mozilla-central] cat .mozconfig + # Import current nix-shell config. + . .mozconfig.nix-shell + + ac_add_options --enable-js-shell + ac_add_options --disable-tests + [~/mozilla-central] export MOZCONFIG=$(pwd)/.mozconfig + [~/mozilla-central] python ./mach build + +To avoid repeating your-self, you can also rely on the ``NIX_SHELL_HOOK`` +environment variable, to reset the ``MOZCONFIG`` environment variable for you. + +.. code:: sh + + ~/mozilla-central$ export NIX_SHELL_HOOK="export MOZCONFIG=$(pwd)/.mozconfig;" + ~/mozilla-central$ nix-shell ../nixpkgs-mozilla/release.nix -A gecko.x86_64-linux.gcc --pure + [~/mozilla-central] python ./mach build + TODO ---- -- setup hydra and have to have binary channels +- setup hydra to have binary channels - make sure pinned revisions get updated automatically (if build passes we should update revisions in default.nix) -- pin to specific (working) nixpkgs revision (as we do for other sources +- pin to specific (working) nixpkgs revision (as we do for other sources) - servo can currently only be used with nix-shell. its build system tries to dowload quite few things (it is doing ``pip install`` and ``cargo install``). diff --git a/nixpkgs-mozilla/compilers-overlay.nix b/nixpkgs-mozilla/compilers-overlay.nix new file mode 100644 index 0000000..a9b4682 --- /dev/null +++ b/nixpkgs-mozilla/compilers-overlay.nix @@ -0,0 +1,96 @@ +# This overlays add a customStdenv attribute which provide an stdenv with +# different versions of the compilers. This can be used to test Gecko builds +# against different compiler settings, or different compiler versions. +# +# See release.nix "builder" function, to understand how these different stdenv +# are used. +self: super: + +let + noSysDirs = (super.stdenv.system != "x86_64-darwin" + && super.stdenv.system != "x86_64-freebsd" + && super.stdenv.system != "i686-freebsd" + && super.stdenv.system != "x86_64-kfreebsd-gnu"); + crossSystem = null; + + gcc473 = super.wrapCC (super.callPackage ./pkgs/gcc-4.7 (with self; { + inherit noSysDirs; + texinfo = texinfo4; + # I'm not sure if profiling with enableParallelBuilding helps a lot. + # We can enable it back some day. This makes the *gcc* builds faster now. + profiledCompiler = false; + + # When building `gcc.crossDrv' (a "Canadian cross", with host == target + # and host != build), `cross' must be null but the cross-libc must still + # be passed. + cross = null; + libcCross = if crossSystem != null then libcCross else null; + libpthreadCross = + if crossSystem != null && crossSystem.config == "i586-pc-gnu" + then gnu.libpthreadCross + else null; + })); + + # By default wrapCC keep the same header files, but NixOS is using the + # latest header files from GCC, which are not supported by clang, because + # clang implement a different set of locking primitives than GCC. This + # expression is used to wrap clang with a matching verion of the libc++. + maybeWrapClang = cc: + if cc ? clang + then clangWrapCC cc + else cc; + + clangWrapCC = llvmPackages: + let libcxx = + super.lib.overrideDerivation llvmPackages.libcxx (drv: { + # https://bugzilla.mozilla.org/show_bug.cgi?id=1277619 + # https://llvm.org/bugs/show_bug.cgi?id=14435 + patches = drv.patches ++ [ ./pkgs/clang/bug-14435.patch ]; + }); + in + super.callPackage { + cc = llvmPackages.clang-unwrapped or llvmPackages.clang; + isClang = true; + stdenv = self.clangStdenv; + libc = self.glibc; + # cc-wrapper pulls gcc headers, which are not compatible with features + # implemented in clang. These packages are used to override that. + extraPackages = [ self.libcxx llvmPackages.libcxxabi ]; + nativeTools = false; + nativeLibc = false; + }; + + buildWithCompiler = cc: + super.stdenvAdapters.overrideCC self.stdenv (maybeWrapClang cc); + chgCompilerSource = cc: name: src: + cc.override (conf: + if conf ? gcc then # Nixpkgs 14.12 + { gcc = super.lib.overrideDerivation conf.gcc (old: { inherit name src; }); } + else # Nixpkgs 15.05 + { cc = super.lib.overrideDerivation conf.cc (old: { inherit name src; }); } + ); + + compilersByName = with self; { + clang = llvmPackages; + clang36 = llvmPackages_36; + clang37 = llvmPackages_37; + clang38 = llvmPackages_38; # not working yet. + gcc = gcc; + gcc49 = gcc49; + gcc48 = gcc48; + gcc474 = chgCompilerSource gcc473 "gcc-4.7.4" (fetchurl { + url = "mirror://gnu/gcc/gcc-4.7.4/gcc-4.7.4.tar.bz2"; + sha256 = "10k2k71kxgay283ylbbhhs51cl55zn2q38vj5pk4k950qdnirrlj"; + }); + gcc473 = gcc473; + # Version used on Linux slaves, except Linux x64 ASAN. + gcc472 = chgCompilerSource gcc473 "gcc-4.7.2" (fetchurl { + url = "mirror://gnu/gcc/gcc-4.7.2/gcc-4.7.2.tar.bz2"; + sha256 = "115h03hil99ljig8lkrq4qk426awmzh0g99wrrggxf8g07bq74la"; + }); + }; + +in { + customStdenvs = + super.lib.mapAttrs (name: value: buildWithCompiler value) compilersByName; +} diff --git a/nixpkgs-mozilla/default.nix b/nixpkgs-mozilla/default.nix index d2fc31a..1580ca0 100644 --- a/nixpkgs-mozilla/default.nix +++ b/nixpkgs-mozilla/default.nix @@ -1,49 +1,16 @@ -# This script extends nixpkgs with mozilla packages. -# -# First it imports the in the environment and depends on it -# providing fetchFromGitHub and lib.importJSON. -# -# After that it loads a pinned release of nixos-unstable and uses that as the -# base for the rest of packaging. One can pass it's own pkgs attribute if -# desired, probably in the context of hydra. -let - _pkgs = import {}; - _nixpkgs = _pkgs.fetchFromGitHub (_pkgs.lib.importJSON ./pkgs/nixpkgs.json); -in +# Nixpkgs overlay which aggregates overlays for tools and products, used and +# published by Mozilla. +self: super: -{ pkgs ? import _nixpkgs {} -, geckoSrc ? null -, servoSrc ? null -}: +with super.lib; -let - callPackage = (extra: pkgs.lib.callPackageWith - ({ inherit geckoSrc servoSrc; } // self // extra)) {}; +(foldl' (flip extends) (_: super) [ - self = { + (import ./lib-overlay.nix) + (import ./rust-overlay.nix) + (import ./rr-overlay.nix) + (import ./firefox-overlay.nix) + (import ./vidyo-overlay.nix) + (import ./servo-overlay.nix) - lib = callPackage ./pkgs/lib/default.nix { }; - - rustPlatform = pkgs.rustUnstable; - - pkgs = pkgs // { - name = "nixpkgs"; - updateScript = self.lib.updateFromGitHub { - owner = "NixOS"; - repo = "nixpkgs-channels"; - branch = "nixos-unstable-small"; - path = "pkgs/nixpkgs.json"; - }; - }; - - gecko = callPackage ./pkgs/gecko { }; - - servo = callPackage ./pkgs/servo { }; - - firefox-nightly-bin = _pkgs.lowPrio (callPackage ./pkgs/firefox-nightly-bin/default.nix { }); - - VidyoDesktop = callPackage ./pkgs/VidyoDesktop { }; - - }; - -in self +]) self diff --git a/nixpkgs-mozilla/firefox-overlay.nix b/nixpkgs-mozilla/firefox-overlay.nix new file mode 100644 index 0000000..cfa111a --- /dev/null +++ b/nixpkgs-mozilla/firefox-overlay.nix @@ -0,0 +1,166 @@ +# This file provide the latest binary versions of Firefox published by Mozilla. +self: super: + +# firefo.key file is downloaded from: +# https://gpg.mozilla.org/pks/lookup?search=Mozilla+Software+Releases+%3Crelease%40mozilla.com%3E&op=get + +let + # This file is currently maintained manually, if this Nix expression attempt + # to download the wrong version, this is likely to be the problem. + # + # Open a pull request against https://github.com/mozilla-releng/ship-it/ to + # update the version, as done in + # https://github.com/mozilla-releng/ship-it/pull/182 + firefox_versions = with builtins; + fromJSON (readFile (fetchurl https://product-details.mozilla.org/1.0/firefox_versions.json)); + + arch = if self.stdenv.system == "i686-linux" + then "linux-i686" + else "linux-x86_64"; + + yearOf = with super.lib; yyyymmddhhmmss: + head (splitString "-" yyyymmddhhmmss); + monthOf = with super.lib; yyyymmddhhmmss: + head (tail (splitString "-" yyyymmddhhmmss)); + + # Given SHA512SUMS file contents and file name, extract matching sha512sum. + extractSha512Sum = sha512sums: file: + with builtins; + # Nix 1.x do not have `builtins.split`. + # Nix 2.0 have an bug in `builtins.match` (see https://github.com/NixOS/nix/issues/2147). + # So I made separate logic for Nix 1.x and Nix 2.0. + if builtins ? split then + substring 0 128 (head + (super.lib.filter + (s: isString s && substring 128 (stringLength s) s == " ${file}") + (split "\n" sha512sums))) + else + head (match ".*[\n]([0-9a-f]*) ${file}.*" sha512sums); + + # The timestamp argument is a yyyy-mm-dd-hh-mm-ss date, which corresponds to + # one specific version. This is used mostly for bisecting. + versionInfo = { name, version, release, system ? arch, timestamp ? null }: with builtins; + if release then + # For versions such as Beta & Release: + # http://download.cdn.mozilla.net/pub/firefox/releases/55.0b3/SHA256SUMS + let + dir = "http://download.cdn.mozilla.net/pub/firefox/releases/${version}"; + file = "${system}/en-US/firefox-${version}.tar.bz2"; + in rec { + chksum = "${dir}/SHA512SUMS"; + chksumSig = "${chksum}.asc"; + url = "${dir}/${file}"; + sha512 = extractSha512Sum (readFile (fetchurl chksum)) file; + } + else + # For Nightly versions: + # http://download.cdn.mozilla.net/pub/firefox/nightly/latest-mozilla-central/firefox-56.0a1.en-US.linux-x86_64.checksums + let + dir = + if timestamp == null then "http://download.cdn.mozilla.net/pub/firefox/nightly/latest-mozilla-central" + else "http://download.cdn.mozilla.net/pub/firefox/nightly/${yearOf timestamp}/${monthOf timestamp}/${timestamp}-mozilla-central" ; + file = "firefox-${version}.en-US.${system}.tar.bz2"; + in rec { + chksum = "${dir}/firefox-${version}.en-US.${system}.checksums"; + chksumSig = "${chksum}.asc"; + # file content: + # sha512 62733881 firefox-56.0a1.en-US.linux-x86_64.tar.bz2 + # sha256 62733881 firefox-56.0a1.en-US.linux-x86_64.tar.bz2 + url = "${dir}/${file}"; + sha512 = head (match ".*[\n]([0-9a-f]*) sha512 [0-9]* ${file}[\n].*" (readFile (fetchurl chksum))); + }; + + # From the version info, check the authenticity of the check sum file, such + # that we guarantee that we have + verifyAuthenticity = info: + super.runCommandNoCC "check-firefox-signature" { + buildInputs = [ self.gnupg ]; + CHKSUM_FILE = builtins.fetchurl info.chksum; + CHKSUM_ASC = builtins.fetchurl info.chksumSig; + } '' + HOME=`mktemp -d` + set -eux + cat ${./firefox.key} | gpg --import + gpgv --keyring=$HOME/.gnupg/pubring.kbx $CHKSUM_ASC $CHKSUM_FILE + mkdir $out + ''; + + # From the version info, create a fetchurl derivation which will get the + # sources from the remote. + fetchVersion = info: + super.fetchurl { + inherit (info) url sha512; + + # This is a fixed derivation, but we still add as a dependency the + # verification of the checksum. Thus, this fetch script can only be + # executed once the verifyAuthenticity script finished successfully. + postFetch = '' + : # Authenticity Check (${verifyAuthenticity info}) + ''; + }; + + firefoxVersion = version: + let info = versionInfo version; in + super.wrapFirefox ((self.firefox-bin-unwrapped.override { + generated = { + version = version.version; + sources = { inherit (info) url sha512; }; + }; + }).overrideAttrs (old: { + # Add a dependency on the signature check. + src = fetchVersion info; + })) { + browserName = "firefox"; + name = "firefox-bin-${version.version}"; + desktopName = "Firefox"; + }; +in + +{ + lib = super.lib // { + firefoxOverlay = { + inherit firefoxVersion; + }; + }; + + # Set of packages which are automagically updated. Do not rely on these for + # reproducible builds. + latest = (super.latest or {}) // { + firefox-nightly-bin = firefoxVersion { + name = "Firefox Nightly"; + version = firefox_versions.FIREFOX_NIGHTLY; + release = false; + }; + firefox-beta-bin = firefoxVersion { + name = "Firefox Beta"; + version = firefox_versions.LATEST_FIREFOX_DEVEL_VERSION; + release = true; + }; + firefox-bin = firefoxVersion { + name = "Firefox"; + version = firefox_versions.LATEST_FIREFOX_VERSION; + release = true; + }; + firefox-esr-bin = firefoxVersion { + name = "Firefox Esr"; + version = firefox_versions.FIREFOX_ESR; + release = true; + }; + }; + + # Set of packages which used to build developer environment + devEnv = (super.shell or {}) // { + gecko = super.callPackage ./pkgs/gecko { + inherit (self.python3Packages) setuptools; + pythonFull = self.python3Full; + + # Due to std::ascii::AsciiExt changes in 1.23, Gecko does not compile, so + # use the latest Rust version before 1.23. + # rust = (super.rustChannelOf { channel = "stable"; date = "2017-11-22"; }).rust; + inherit (self.latest.rustChannels.stable) rust; + }; + }; + + # Set of packages which are frozen at this given revision of nixpkgs-mozilla. + firefox-nightly-bin = super.callPackage ./pkgs/firefox-nightly-bin/default.nix { }; +} diff --git a/nixpkgs-mozilla/firefox.key b/nixpkgs-mozilla/firefox.key new file mode 100644 index 0000000..bd27ce8 --- /dev/null +++ b/nixpkgs-mozilla/firefox.key @@ -0,0 +1,254 @@ +-----BEGIN PGP PUBLIC KEY BLOCK----- +Version: SKS 1.1.5 +Comment: Hostname: keyserver.mozilla.org + +mQINBFWpQAQBEAC+9wVlwGLy8ILCybLesuB3KkHHK+Yt1F1PJaI30X448ttGzxCzPQpH6BoA +73uzcTReVjfCFGvM4ij6qVV2SNaTxmNBrL1uVeEUsCuGduDUQMQYRGxRtWq5rCH48LnltKPa +mPiEBzrgFL3i5bYEUHO7M0lATEknG7Iaz697K/ssHREZfuucB4GNxXMgswZ7GTZO3VBDVEw5 +GwU3sUvww93TwMC29lIPCux445AxZPKr5sOVEsEndUB2oDMsSAoS/dZcl8F4otqfR1pXg618 +cU06omvq5yguWLDRV327BLmezYK0prD3P+7qwEp8MTVmxlbkrClS5j5pR47FrJGdyupNKqLz +K+7hok5kBxhsdMsdTZLd4tVRjXf04isVO3iFFf/GKuwscOi1+ZYeB3l3sAqgFUWnjbpbHxfs +lTmo7BgvmjZvAH5ZasaewF3wA06biCDJdcSkC9GmFPmN5DS5/Dkjwfj8+dZAttuSKfmQQnyp +UPaJ2sBublnJ6INpvYgsEZjV6CFG1EiDJDPu2Zxap8ep0iRMbBBZnpfZTn7SKAcurDJptxin +CRclTcdOdi1iSZ35LZW0R2FKNnGL33u1IhxU9HRLw3XuljXCOZ84RLn6M+PBc1eZsuv1TA+M +n111yD3uDv/u/edZ/xeJccF6bYcMvUgRRZh0sgZ0ZT4b0Q6YcQARAQABtC9Nb3ppbGxhIFNv +ZnR3YXJlIFJlbGVhc2VzIDxyZWxlYXNlQG1vemlsbGEuY29tPohGBBARAgAGBQJVrP9LAAoJ +EHYlQD1/DRWxU2QAoOOFRbkbIU1zKP2i3jy/6VKHkYEgAJ9N6f9Gmjm1/vtSrvjjlxWzzQQr +kIhGBBARAgAGBQJVrTrjAAoJEMNOV0fiPdZ3BbkAoJUNHEqNv9dioaGMEIpiFtDjEm44AJ9U +inMTfAYsL9yb15SdJWe/56VCcoheBBARCAAGBQJWBldjAAoJEAJasBBrF+oerNYA/13MQehk +3AfkljGi252/cU6i1VOFpCuOeT7lK2c5unGcAP0WZjIDJgaHijtrF4MKCZbUnz37Vxm0OcU8 +qcGkYUwHi4heBBARCgAGBQJVrSz+AAoJEPCp59zTnkUulAYA/31nYhIpb7sVigone8OvFO19 +xtkR9/vy5+iKeYCVlvZtAP9rZ85ymuNYNqX06t+ruDqG2RfdUhJ6aD5IND+KD5ve7IkBHAQQ +AQIABgUCVaz9fgAKCRCzxalYUIpD8muMB/sH58bMSzzF9zTXRropldw7Vbj9VrRD7NyoX4Ol +DArtvdLqgPm0JUoP2gXINeSuVPpOfC676yVnBEMjIfqEjq09vcbwayS+Ncx4vQh2BmzDUNLE +3SlnRn2bEWr9SQL/pOYUDUgmY5a0UIf/WKtBapsPE+Zan51ezYSEfxDNfUpA4T2/9iWwJ2ZO +y0yIfLdHyvumuyiekJrfrMaF4L9Q0OnJwp1PwkvN4IVwhZeYDtIJN4nRcJK5LrwU7B97uef2 +hqBBll7/qCHl5y4Khb0csFanIg+pQLPUJdIiYtzoFtlgykB61pxqtU9rqGKW02JzEUT8DdPU +XxmMBy6A8oGeBRH/iQEcBBABAgAGBQJVrRdcAAoJEGVzgtv/JREKQJgH/3nD/3/SumL7nG2g +7Y1HQqWphUbn40XWvjZcHq3uBUn1QYXeZ5X56SANLM2t+uirGnNaZXW3cxEl5IyZVLbmcLWE +BlVAcp2Bf3FXFbdJK59f+M+y2+jZT9feTyrw+EtLoiGTxgkLdJyMyI0xGmQhMx5V1ex1CxhZ +K2JPjzCVYriBI0wIbmKi90YNMQoSsdMhYmX9bHl6XWS9TCDWsqj25FLYJL+WeVXpjO0NjRwE +E6pc/qldeJYG5Vbf0snGxIerXe+l5D8Yd4PEAnpj58+5pXeoGYZn3WjX8eTFMAEU+QhLKWQ+ +j/Y8Kijge7fUxnSNBZ2KEnuDN/4Hv/DrCFLv14CJARwEEAECAAYFAlWtZVoACgkQ5DJ8bD4C +mcBzsAf/RMqDdVHggQHc0/YLt1f/vY9Y7QQ6HwnDrtcNxxErSVcMguD8K6Oxir0TMSh+/YuZ +AW8K4KSgEURwZqz4na8/eOxj8bluNmlcAseQDHswqU6CyB95Woy3BocihH7L0eDXZOMzsa33 +vRQHBMioLxIbpnVtVbFR1z7tmyfjcOrzP32xo5QoPoczKX26luMBjAvbw1FC0is2INnmUSYM +4uH7iFZuXGPFYxcAqODqy5ys3MoPa4oZ71d0HoiRil1+s0Y+2ByddZ19pE2TXp4ZXNYNUj/2 +aRj8b4sTjR4rqhHIx/vfoK+VCNy/skFUZOyPdbbymE0stTRSJ1gr9CZLcBWYF4kBHAQQAQIA +BgUCVcFZcAAKCRCJFz+VfFX5XqApB/938p+CJiDRnh2o7eDWnjSyAu7FWmWGkOQnjI/kraKx +1vojsYnKRXD6mjq1QJ8Hsp4taJnLQjcokNTUiST4m/e4ZJExPWuJKkwlralWGH6NpqYcgWPa +jSYb0eYQC4YqS0kfyzolrHdKI8Y4NGEU7yy5zsHwWkHt/mpNQMrYnXwyWdIrc03X/OXo51dJ +yshJDRw3InREyBblFJcLvArNHz219wMrXAicPytw4wfPpVrmDx6GrZcI8q8ECWCjwSXXv7hR +pEuFLSy5XPhMc+wYBJjNlUoiFBAF/7zENd3rMn9SCQLiIFYe0ubmO+bpeGy7TizbxOaCIfgU +ouyy0BQXNuJBiQEcBBABAgAGBQJV0hrqAAoJEK18uZ+CSLoPzEIH/1D6sJMNAJtZCRGhJXvv +6SYhv4pUVNyDF9FnUvRsovliojoe4IkuBTWKhPGrxbiD5IO/izr38shqNhhm9JE2/SQZHObY +Pi+lyfDKbJgImTNxmS4F7JHnRLr37VxK1sVvuNkynJnqvCcp1g5xwNIx1rKcka3iuqJj6toM +8XQfgsTHH1rUkWHbUV3QwNzXm+yhFm2s6QzxBooPzmFn8AY7CXD4pvcMR+M0Zy+e42nngd8l +zRnmTBVig4pRq0GCMulFG+XjeVQZFpoIIxo2k1lczbRmGttONdGWSjxBUxReoTbSwM3C/50N +robycGQgY0gd6LGtWtU8/uEfklEy2NluxYWJARwEEAEIAAYFAlWtAUYACgkQVu5xjc4OFUs0 +OAf+LM0dyyvUFGdXfJDpP2xMknXzsHAXWFEtH5jein58mv6dD3fTVcCouo1vMQH3WFFSLYZv +wtNnHGrSBqFbNKqZ0ATQ5tcYaWsSZ+MVJJMXJDXFG/Oihg1nNOM33VdfV0RGPKP1I4cEROxm +s3TUFkHW3cSCgMzs8I1OxfSoLrm6da8EN+2ct2InqzdQL2yisyTyrdmXoNpwXDxApKYkvVHQ +4+9eJI5m0ZAr0mBjIeJdATcw4/lIVKTrV7UhrChxiffYJcz4SSC1crmr+2Fzw53CyAsAmYal +UHep3Yr05oQ4oJRX9X3VrY/yELHwwxXaxCAdwwHbbXAMhZsPk9Mc20J6BokBHAQQAQgABgUC +Va0isQAKCRCj1lIXO3Y+j6ZeB/91Q9/qr5oMWgOMsix8kflBLw2f/t+tRR0SWDw90bG1npJB +6nq5Hl+Bz4/A4SWFTFrrrlZi1Enjn1FYBiZuHaSQ/+loYF/2dbQDbBKShfIk3J0lxqfKPAfK +opRsEuxckC8YW1thGxt5eQQ8zkJoqBFTBzwiXOj3/ncJkX9q9krgUlfTSVmrT9nx0hjyNQQX +rghsmBtpR7WCS7G7vNRGCNUorhtviUvL+ze1F7TTSGspVsVxo2ghmz5WT/cD9MV1gcVjojYm +ksh5JIl39jCHr9hl8aRId/OfzsN+TKuBcpAxDkm9BCAps7oY8FlLKDFZTtHa000AkodKHT88 +nwnvKuqPiQEcBBABCAAGBQJVrTkDAAoJEPbQ92HczOykK9YH/0MARo3HlYXeS2bDqM/lwK/r +QcPCCyYke6wbICjncbCOjgXHqG/lBhClNs7hp/7gqkUaR7H5tmeI4lalP40mSHHnnFvMD3Tc +yhn350igK0bgrjWQDaYxhKlHT3vIXd/C24/vRSAxmqIKbP+IoXOyt2GMTQq8GOm2dgYRaTkw +yHnGWnMaibctX8D4oCYR0/D4YJqPkfqobf8+1ZfP5GaMbSxE/Jwdo0kJa4vPjEzFXbygAbnc +apzdwN6zgel2zh885rz7B7vIpMr/Y7eV85Q68qdyyhLe8cL8Y18YPzpFf+/PZNbgYxouafvn +FwBhPQwg0gUF/+1eM3UE2ua+saSTGduJARwEEAEKAAYFAlWtCVsACgkQM0LhtmejiGMovwf8 +CfYJHNbwiwSMUoP4n7FrmElhBtxvlbnCMZKz08v+lFsfS3wU1LUN69GqirfF0vkQRSlSBp7n +iCLHQCfSoqHMLgxF0P2xgXLjaYM/t/rxXDawJmW18G04dqFrtCPZTbwMT2PsPHTiWQdaN0e5 +0lXk9Vo+l6VbwQMg4zH7icZadeJgQooxFalHYFVXUVeex9t8/YdanFVrHFa3tao6azBTSUkJ +vZtIu14SfxigDWIIwsx0xpVfJf3a/xC6HY3Q1a3NeBz3i6DwaK5wYqijZKl0WVdULKyqU98o +F6y0mUv3d2o/p07Cqgeo6xxMkHqu83OLa2a0C7tYPLgL4EFc2FtikYkCHAQQAQIABgUCVaz7 +KAAKCRCWO3gxCjexfKxrD/4npm1rB7+pPlotbqK37Mur7egPbVSAzVNU/zUKPAuGUeP3C64Y +N77ETx1kDuS+meAqMDHFc9Bf8HivPbtj6QcK96U5KstbmSh1Ow9YiQtxJgxGjg/CzREgZAFc +jy0MhoklyPsFhv07s6MLOJMSM/krEN5nqjifQ0WdmTk02FLoHVWcLdjfgMiPiSjGbU3k7luv +jPyRNzk831szE5mfa74rEYh4TBklse+2uB4DFQ/3oHZ1Sj6OBK6ujmNKQjIP7Cl+jmjr7+QK +0OJcRaj/8AckDA5qXTZACh1S2syCDDMnX0V+dTxGCIoWOK+tt9mLohMzpEeD4NIX4qdpbbCR +zeYZMHSomyBIsbA6B+/ftDE7W1N0/FtJ9adkkCynKULvh2CH5c5hgOOL22M+2spnywRoeJRU +WU7hBM5OUH3JjA4Tu4j/cwp7dD7QzZrzmC9f5LQJ3OelejvVowWPQd3/tky4o1q6wlmFqAcA +gtu97UwgBOSR9sJPGDlt1iC91UYAiBQQAA7ya8uXUS84mCQwTlr8j+YrowvEHK4IxpPREytT +1LzzV/4Am4ndDFtujy83QjL0qaIIim1xIwoEosd4yidhpczw7f3b9dQpuBIFeQuhM7JsxP4t +mE7S6k6GlEmqa3INPVaPGnsUGS7+xSMlcJXLtimPCSQvFma9YiGV5vtLy4kCHAQQAQIABgUC +Vaz8uAAKCRASy06X4H5n0dg0D/9QoxIh9LRt1jor7OHG4xKUjKiXxn/KeQNlJnxI55dlWIvJ +EJGheFjaDomzKBYuxmm2Ejx+eV5CHDLUYsLFYwWf8+JGOP75Ueglgr8A0/bdsL63KX6NP2DC +g8XR4Z1aeei3WMY7p/qMWpqbQoAv9c3p49Ss2jSNuthWsRR6vbQ9iwze2oaUaA44WKQyhhbC +wBU4SHYjlKCLqIBh/HXZFhZ4rDfuWgPBKvYU1nnOPF0jJRCco3Vgx3T9F+LZ3zo5UPt1Xapr +3hMVS9iaJyl1w4z2miApUaZuHPuWKuO4CJ1GF1mS5T6vG8gB3Ts5zdtBF2xQIkCz+SM7vW/2 +i/82oq6P8EuLHEhrQPR4oTjXIvXdEJ9kgbjqcj8Xk+8teEOnuwh6iEhay9i/bf0D3Jd+roFN +5dnWPxhOVjzrI3fwlK1/ylsZYqUYBEzt7Wj0MdhjeKssI5YICcqYXXjBttMw4B7DZXPFXzz3 +kHB56jZ/II4YUjpLO85Jo5A9SV+aIqa0mvCt6DvVWy/rhfxfoUdqNlhX11gkVLaA7xxgn/Nq +POf+h5hVO2mwWkmart9YHKMZ3ukCdke65ITL/nsYSm2ZhG7OYjaCfu9jPWtkBstOEWyT9q4J +TdViR7wN3eMefEG6rb49rxOYvGJu+cTVkp3SCpl0w1j+tPj4tkj7ENzPMXdnuYkCHAQQAQIA +BgUCVa0s4gAKCRCKsTKWOgZTeuMyEACKOySKAd/xDcPcHg7Prvdws04Z8DIR0dY2qUlbRVx2 +jTmIXyry63CqbOJFbDg9uk5x0+lSotvrWtZ+NKSrg9VM6vyV4cc2P9rhqIBi3wO2elzAmpOa +S2KKOjQ+2fS/xqh91ElJUu09xXQXJ0vMrqgui+zN1YBDiJV0WOmm90Mm2NPiihcWZmBmDorO +qMQabwbjBLi0yUVHgAlkilY3mAB4tmEKDeN+4pYSAAhXAll9U+nyoVMgwMJscZyazOp4MqMb +mFjyr4p5AGzv+OOJtjtCNKT6oW9Y+URLY0YKeOsPk0v5PlbQCVBlLeSBsNZudKav/Gvo7Mvz +5uLTcneBFb+haYIiXO/FQm4uBHkzdNFLgaph81Wzh62AhbtBlfBOj/lbzN3k/xRwo64QU+2Z +9GOhFlhjfROquY70FCQcspwNuqCdZybnkdpF2Qrr6Pi0qKR/Xb9Vd7PW0/gKQdwwlYTiDemg +A21mYeJrYw873/7U/+kLFRvmPAEX4IOIOEN6XVjxvu78REi6CmXxOoYnH4aRSXDRyi1nsGjB +43AtfAMMNCUigDgFP4sUsZAG1RAoxBhOsO/g9S5wx8H3rKITCXDjQh2SYeBwHFcU03EMcyzE +QhbZNighN+aRKGIibteRxISiKU+kcWaHolemeo6wGF87QXEpJaQ2OwIoIxQYvDDmQokCHAQQ +AQgABgUCVaz/8QAKCRA/8xuvEEv54t06D/9n1Nyn2QSUN1mXd7pomoaka+I2ogDbQpu9iuFq +bkqfcH3UuG8yTKlPp9lYDBs0IEfG85Js6iVxJIultocrcDmOyDkyEsnYbdel/tn3X4yqD8eI +6ImRoCE+gnQ3LoEIHuODfJoosM/jAHANs4fsla4/u5CZDXaaq7pYXGiTt7ndsfmLiCa7dAg7 +bVFfJagsnL/VjlfeWM9nW01rDL9LPxSN4tq7ZKXWZDonFZYJ4unsK/Cn6Pqco4Wb+FUOWCcW +t8in1pgeNHZ9WnAgXG999/3iCbbQTLB6uVwY4Ax5P7VApnLVXV6QFVf7bN1DxE8kZk+pfLGc +uD1LJSF0skE80M17kAt+iV+fam8EYzeGdG6cY6w+srndaMaq9ddiHIiQkR35SjJAGnrNRj8o +oUr/vKOBnFfuwJLA2MOUVPZ8HWB+WXW8qhihw9CXa38Hdt4o5knMGRIyTWEF0TQDtRGQ6his +VBN3OxJRXBj7/QgCG/GoYpweGKcsMU43p57TzbnXVVUytJsLFyexOGNzrUIxgDVPEvTUnNvd +AihNZPdbW3YdFkP9pdwOyDpQwebXELUx1kp4ql0laueex4L1v+0a6rDYQeK1gOq5UGY+THRS +gB2xsHl5zeryfgnjlUkUlxKuumz+9FI2fRtSpxmWllJkRF2oFMGRuLPGAWe8nHvfgkuGVokC +HAQQAQgABgUCVa0bowAKCRCVY0f2+/OkFWKREACZ9TOmzvY6mrfWVEdldcYPj8cU/1LJhGdb +No5YYMx+A72nchxGXepHA65OEK+f6rFMeZFPwpQPy6Sj3MhT623H/PECfeG87WcLOyJbfc3i +9T5jvxS+ztG6abYI2J/50oMvjUWdWkDX3VvdPc0ZZ+KC+oHvx9a/9Yki48m4CEKglgVsrRW/ +b9AXZQCj07bB0GjQQtkqY/m1Z8m4ttzxfO7OBo/jHNF2An4/4gUDirXNDj0UdB5FYFJaTEUC +neIj2x0fk1r4u6na8tINhiZ0M7IgjnDlBD5jwzvwG+3kYE6TnYp9Mfeg2MPC13tp7jrJatLL +utrOzvmSVLGLXbkh9w+v+vx7qO3TxZUNlFqTmYs+vI2V/9j7KYV7Ttoind6Io7X9ImnYrvd8 +JOyVcO3867MplKnrnqHJvFStE+JcHEcw5aRw+WVmoFd/obGc34V3K62T977QQGOkrTYDEdje +KADfjXXZkZMZc0IvzLBOJ1XB45+PKqJYCcJJS8Xr55+NGCDaaUPWDpkNGIqmX2n9kYROMKG6 +uWkZIqG0JlZkga3THSJIvLiy6uoOvDC4GoQ9JnTwpGv6r1Hwcg+4DCOrYKOoPKMMU24vHx2F +tRRUgCXtr2cmi2ymHlUrtz8EXS4tblic8lixcbvPUqLEvbJ2gfWQvjXNd1whYE/wfvI9WBTE +IokCHAQQAQgABgUCVa0b3wAKCRC8FzAbSRs/IQhXEADiKbCnsN/+Plllxn6SQHACEU75ackx ++Q02XiD/u+wUptYUGmJi4aaW9f6mgzedOxYK4S+/dCiFtkcYlL+FjaR0C7G6tMjrDgW+8nQC +TPUNQA0gX2B8n06a7Zmdv3EbV/PIJJwTNSBp/dqKbvPKnRquOOpH+ayZ3awKOq/LlWBErbW1 +gB+FabN0lCe0iUIQTF9OH3GC4QsMtIrePueBmVrVPcHATV2Vw9UPqX1uX/tlXm5eai06oVT7 +V0FwUbg0o1eacblNXvHciHpe33zZIKkGBWwSjDVcU9/SN+U8GfoMYmyCma4iN3KaCklpzBkJ +iQZtNKPAB5KJti8LDUxFi2sJd3sqWaZDGFhO+/PKhBKpqIhAzx1ppd11zLgh0eg6gQlXN8D8 +ELISRvQqGGNNZdChEFdzGElg5SMfmeEd37OaX4wceLLV0v7EA0doHMVo0enFhSwU3Ywtwxbi +ukKc7H/ylG7+jvntjY+z7KktRsY/FkklrbrNhddMBQMMSAQUUz1GJ+6NUKmzXjqxFuuh3OAh +qNzhJyABZWQcNMph+rogEslkenwoHV9gWRWtS3CMybJkKkbsWpYhMZNY6hFtgCwida7NPs83 +69v+yTTE6TU/NIlXUKYIf2LMqtOpEBTjaN3jKpUi5DeE3zBeh6iVKUrfCXbt8O0rYQPNWGSW ++MZ2t4kCHAQQAQgABgUCVvA4GwAKCRBE9G4UbQI5XfS9D/9XPK7jg0lmsNZ2sDIyeAw5n6oh +SR5F20ocTMAVeXqN7VkvJdNpIqHJa13EP408DgTy9BsSptym/OQGE6B82BU7FZTEL6eMHnGG +Dg+5ktx9+b73xLedzK75ti6ED+QuA4kDYcvW8hASht0zRcmFUzwbtuEopJ1Lk1R3oFLwCAov +lhduC45nANWrTK5U+D1U2obl5PAvx+9mEfgvojlGH/C/WD74W+cQZFH7t4+muRzamckLyPft +nTxjNF/lpYIm7z0QOwvzBYj+PJ09wYueK00RE5+i9Ff8DrjtVSXsziQvSjJuUlv0kVvM8r3t +h4zBBNRhA4cinwqxhgqO4G+r2r9Gv0M2nKKOnWmyF+MSIRnhgONOQZe5a7kQxKVWkLicS2IG +UpPeQyTWaqZzYXsD+Dm6DXD57vYTURtUkwO0CDONzT5XiS1HG1MZrw+V/Jai4HAvpF5WkTJX +Pc1Lv75BxJj3wOAw4MzEWCCdr/N/dt5/+ULpEaSQfIg4L4iEj6rvabQyN0KbOxIDx+pPQ81i +zfj36wIrDqhyCNIdmVH/yARltkL4XDEl/pt7Y3t6jqFhy057lektowClWcPeq3DoL0LFYnjN +PpYvIjRIAXdhaYiAu2ViF8WdGzQ5tFeI7u3PQUG5NcPe+WOPOru3wMMrUhLgLHkCdNkjivP7 +9qIPSTkCGYkCHAQQAQgABgUCVvA48gAKCRC3hu8lqKOJoLRMEACmlyePsyE5CH7JALOWPDjT +f+ERbn+JUTKF+QS0XyWclA/BIK8qmGWfgH38T9nocFnkw17D3GP8msv8ll+T4TzW9Kz9+GCU +JcHzdsWj99npyeqG5tw+VfJctIBjsnX3mf4N0idvNrkAG5olbpR5UdsYYz62HstLqxibOg4z +WhTyYvO6CjnszZrRJk0TYZON4cXN14WYq2OTrMaElx0My8o1qVBnK58pIRzv72PmvQqUk5Zj +hUyp9gxjqqCJDz0hVK61ZuGP6iKK8KCLTfSxeat05LAbz8aC58qlg5DVktevHOjBgnTa8B7B +gJ7bQ9PLMa3lF4H1eSiR9+8ecpzEfGHILoeIDIYH7z7J/S0mTgV3u5brOMYO+mE9CEfps85t +VVoyJrIR8mGEdtE2YmdQpdFzYIYvRfq9tnXZjVsAAsC20Smw0LnjhYzAt9QJwZ9pFMXUTg6l +C5xT+6LNrEY+JR3wC16q36bcbCNj0cBv1A3x6OI5OQfpexhLPDgoDiI+qozJIdj8MzJ8W6KU +1Z3yb3dqACk77yv37rGO6uduSHnSti26c/cUIy6XZBbXBdobE9O3tr8hwvTQ1FXBmYnBrdiz +U6tgxEA5czRC9HOkdk6y6ocbjmONpF6MxkpJAvTMk7IqC2/hisbV9x4utla+7tmNZU137QGc +aK2AGQablVAy4YkCHAQQAQgABgUCVvCMigAKCRCkhaDtUbi3xAU7D/9gUPZSJ8pbZV9TLaKD +57Bc7B78HNV/B438ib4dI33iihMTBHnCB1giPE9X54QoV8ASxrO/xveS1kkj78jERqUcED6Z +HhMLb9SWs6CxUKdMdgovnIlFUc+t05D5mb6STi+zNihwO0JI+n79qhETy73WLpC7RR0aMx7z +Ycbqp3NWPptcf1kVGJZGx+QbEHfVye98T5pkH5Wp+7LSlup6AldQT/oifxdGxLXbECTnwozR +vyMpAaphoEHrET1YOmKnmw/Jyi6DLpTb3XvSf5Tntzr7HklCEcL9FvYCoHxiXWawLhuPhSyr +FYeYtF1ypmzTgaJWyuTZ8sN9J+y7Tbchk/I6FpX+3YoTgPCcC7hv1Krs803N/3KuyBEvhzg7 +NYRikzO3fxXlBG0RMm+662E7KlERU24izbWhGiYwl34+MaxrIO4oDvF79LEN7y0+SjL4V0B9 +689d+HI1ZfS9O1xkOlW6y0QyagOzsTOUF12s2mWydFmipbYnIwsSsu6Nzk3yO4M+qYABJXJ3 +tIFQPTd7xqmPNlJ8mFtmzHDhb3Pv6sRNFLLujYM9cJpuNMbAHWdohz1bjBT9pZQ3zWpll5wo +tUvGmJd6hTAXdUgmZ7lh7Uq6axClMmiLe1WYntcNpb04PyyEm2+GU5x123UTiSX2LGKa4t+H +NSM8nJL8BJiGk80xVIkCHAQQAQoABgUCVa0OAwAKCRDDvTXkbdRdpVR+D/4/37e8WqKOHNPt +eQu42sj0ZOfcqyVMA9TQ578F0s9MwoQuqfVhXGSWevOctuMv2qTBjBfFjkdPrKR5L4LNAgMs +u1epHU0DPcRZUCbh1P7GpolmZ8KgnjT5Wpl1AcuOCaP08VMrt/e/JndTHp6btn6HsLVtryNh +lL7oaeYbDr6/ovHNGHVIVSZgGP9f4Y8FiDpyfKav71vYLBMxtzM7lc3eFT1S10XhSW6k+8S5 +XldYWkLDriRXDE85C+9QndpOoQaIICp3ye3JVnUxa1qhvsYj9uPt1M6hKiBSoXdplrB+hQc+ +nqLNN3jxpGdmGmwrjtjqMhocMIguEqgARJOek3XKOppEhu+IcnJgU4edARJNLsBauiVBWY/6 +mZOFlZq6H48tVyziS2n/oIpi+aCc/fQeGs9zMTtFUohPfYtTcy9PecXMOYpSu4p4tQ07oucn +xfBkRUgTdM5VwX7YwTcRwp9XhHACUEGBhrwMH8Iz+sK2jLF3FhJGkef1vFs0vqSf4I8DBFkY +AKF848YyEcGHeINQloi3v0Kr2PpBxlRh+GPWwi++QPKXQFzlTiyVtMzoo/lpmAWUJwj0dbAb +H/mohtvWtA1WPHC2JRZ52JLThhpDrK3t//Jdt2WHE91cMx7/2B0PK4O8/j7UVlsOJXpVPsGX +5SFCeTB/iS4JtIwWN275zIkCMwQQAQgAHRYhBFnKni0qMx3iUaokJ18Dx2fCR6TVBQJZDvZC +AAoJEF8Dx2fCR6TVoGkQAIjqaQ7tpdhDJ6ORNtLIt0TsWg0jg2rpoq+9Au36+UYBMuBJ3Py/ +tAsZ3cqQlig7lJiQqOuQZkbg1vcY4Kdad7AGa8Kq3sLn8h2XUlNU90X0KAwdCTA/YXxODlfU +CD2hl4vJEoH/FZtfUsaLNHLmz0brKGrWvChq00j5bPfp90KYKqamGb3a4/LG4DHL4lmEBtP+ ++YA0YqUQ3laOvKune2YwSGe4nKRarZnFiIn2OnH9w0vKN/x9IMGEtc5MbQVgGtmT5km3DUuX +MDforshue6c7ao4nMOC96ajkWYZhybqHJgLOrEGPVUkOaEe7s1kx4ye9Ph3w/LXEE8Y8VFiZ +orkA/8PTtx0M9hrCVkDp0w8YTzFJ9DFutrImuPT6+mNIk+0NQeuDsv492m/JXGLw/LRl97Tm +HpKME+vDd5NBLo4OShlDKHwPszYcpSJTG9+5++csR95al3tWnuGX9V0/dO1s7Mv0f/z07nLB +/tL+hEpqqA5aRiGzdx/KOrPZuhCTyfA3b2wvOblwf4A/E1yO7uzPTuSWnx1E14iZuaCPyZPX +Eh3XSYCLEnQ05jy50uGXCDVR+xiE/5i/L3IxyhJk6zn5GOW5b8Taq5s/dFS3zWiFS6l0zQ1V +QmJH8jdGLoBFvdVLZoAa1bihLo+nJVPR2RauWnxWoWk1NQoT3l02Lk6DiQI4BBMBAgAiBQJV +qUAEAhsDBgsJCAcDAgYVCAIJCgsEFgIDAQIeAQIXgAAKCRBht7Um2Y8DU1CqD/9Gvr9Xu4uq +sjDHRQWSfI0lqxElmFSRjF0awsPXzM7Q1rxV7dCxik4LeiOmpoVTOmqboo2/x5d938q7uPdY +av2Q+RuNk2CG/LpXku9rgmTE7oszEqQliqKoXajUZ91rw19wrTwYXLgLQvzM3CUAO+Z0yjjf +za2Yc0ZtNN+3sF5VpGsT3Fb14aYZDaNg6yPFvkyxp0B1lS4rwgL3lkeVQNHeAf0qqF9tBank +Gj3bgqK/5/YlTM2usb3x46bVBvwX2t4/NnYM5hEnI57inwamX6SiMJc2e2QmBzAnVrXJETrD +L1HOl4GUJ6hC4tL3Yw2d7515BlSyRNkWhhdRp1/q9t1+ovSe48Ip2X2WF5/VA3ATfQhHKa3p ++EkIV98VCMZ14x9KIIeBwjyJyFBuvOEEIYZHdsAdqf1zYRtD6m6obcBrRiNfoNsYmNY4joDr +VupI96ksIxVpepXaZkQhplZ1mQ4eOdGtToIl1cb/4PibVgFnBgzrR4mQ27h4wzAwWdGweJZ/ +tuGoqm3C6TwfIganajiPyKqsVFUkRsr9y12EDcfUCUq6D182t/AJ+qE0JIGO73tXTdTbqPTg +kyf2etnZQQZum3L7w41NvfxZfn+gLrUGDBXwqLjovDJvt8iZTPPyMTzemOHuzf40Iq+9sf5V +9PXZ/5X9+ymE3cTAbAk9MLd9fbkCDQRVqUD0ARAAr/Prvt+mhVSPjNDPSDrTBVZ/7XLaUZvy +IVggKa+snJoStrlJGTKKFgDVaYTOE3hP/+0fDdQh97rjr4aRjd4hBbaNj0MzZdoSWYw3yT+/ +nidufmgPus0TIJMVO8I6rl3vgcfW/D3ovNrLW/LjkTuM9a+p+D1J7woCfMSWiFMmOLPKFT7R +BuY8edCVjyA6RP9K9Gj1sURSeqNaHR9Gr4rW10s+FwUHWxxzbmIWqH0gApQYO6vyND5IMcKO +BCWQU6Detuq1pQ6dUc+iF+sEz3Rk3C6d4WBBjtkVJSJ0KKan8Q3gJefOCMNhdRQDjZLwbzr4 +bgoAkLbaBFCjiZxWZ6HAdMfSCV8uZQrtMS7b0DUpY0vdH9Htl3JqOOkK9RorYDQBuPdkTYFI +NsmtWVsFV/LmR891mOF3fBRaoVoMeJVwiZyNlFY+dyWWFzLp+GoTLcQtmuR7OkmOcBGxWSKP +cZfPqhf4dVQud7bDR2RNfJ1Hqa5kj8Z422sseYDwHf/T9OWWYvLwKGZhlUgpnzO3WCGrd/6E +VNeC1mKXt4F7BmADov4Rdcrp1mPXiVt7oIxLaS6eBNf2y1TWzjYj5ZFuKqIukDEJfqpwsE5a +snCw56nae+7luGs8em1J9GEXhWzXG15UVyQJaFwuB1iL8l7VcEQz4ABVrSTUWLLAKDsyqUbq +2gsAEQEAAYkERAQYAQIADwUCValA9AIbAgUJA8JnAAIpCRBht7Um2Y8DU8FdIAQZAQIABgUC +ValA9AAKCRAcacTlXpkF2y/FD/oDrZm143Rv9NV9InnVJ0brpqbB7aulFfhR1LDuJ/GjeqGA +QgJCZdHlzT2pfCXXswUlYzcWEatvGcDkoaB5Ya2qs+6nhBk8pT6XYRrZAtIlKIGrlCqoSBm9 +HXguGv+EIaEECr2z/Funx9so0mP+5aJn65M9u3lPmuAonj6DcHoM07WsfsXvQ4ut3fabFmzi +lLGeAdEDKIw8Hn3JBUOxUyFrQlOoL4/3qK1TO+cidz/2bATQQyIG2kNOSgHBslU+e6/7sWOQ +4ufmzm7dEsf197zPXGdXR88LT+d2uU2K4GkCffNUKxZqy9bXxXPwr4JBjxLDQnDvl50GAWjP +ZAwXEd8Okwl5+8xp0HuZ217WUqT8ib0oUUfwh2H1vrMPRr/46i6O6THpCkV8BWF7axPYIiba +eYwC4BkjZwK3tIL5ESf2f0xK4hbE3xhMTeqABQHoXd5rQ7SEaUuX7PlQ59fRs0Cz55vH8/o9 +zMm0PN6qmZFvRBeqjnklZcu+ZdP9+CMXt81NMuzIK1X7EfpkUoam8YkYkwcCkRvPZrSHLXZF +kfnx4jW543dPOfycjnv6hhKyoXD9CBx0ZcOicsYmw9XMilBGD3b8ZdK6RYX4ywKNU6KUdFJj +XB88+Ynv6QxDit1emMCHA1glzV9/k36iYLEIqgWBiwJeUUIcUqzgnBFtN13cyS6oEACUGUiP +Kbw3IkgGW19ZyS6FBNfgGIGW0Y82Br0KlCyaXnX0R4+4u2h7kfR9NSnhRhsvRnPIkiZATa7D ++Ew1nfpsDTnti0c6g/gVw9TC/rCyXkkLztRHVcWEBdvnFJTSp2LeFaHSGbvvZfoIGUzyUzoa +1P98NmRIY1cxBoizVf8729/zAaD4fAslxoK/JsjjDvDUrRHtaNZmUle60Jl/yFFzR3zxb+pJ +liigoP2rZLt+ipomHJIhoXXWwfkRO9U/egJ8ZUhWEpZvROnaNc9eVct5EBADxL7gHWjlceIz +4ndI1eE9AdEZDdUZwOfjmK2DcXjFBfZC+jhJXjY0xh3pPKQz90h9DIkM5WDcJPf6ep+MKSd/ +3hI2/JmmscQ+alwN6x6g8zDySMo3APA9cUvEFGe0+CepVcNw03jU4faSrHiMXsUuVGbA2kHa +YVUfzF5W5GbuHZZlGxoSiq+K+HNG0RJUDa6bkSDvrcJVNw1iUrowP+LLwnNsy5kGuU4evnwc +oN1w7LVbTPaq4RIaiqvAD33kiA9q//UNKnK4k81z+hRNaWGliyGpgqh+V7MDIqPfT5TMLdH+ +ZjTeuLrNS8KBcc2BmUpSwzdUReTqHmgO5peeIcsvO7GNMFWsgucZiAdIVE/zQv+SfP6jhS+r +jCPs0eeu5zl8/V+gXFE2wy3jTJEl9bkCDQRZS9m1ARAAvh1Nh4GgjpTFZy7uQRFz5PPXdZTB +I+Y4hTpF2heoFzZDI6SLyz64Ooglum3ZglQ9ac+ChTSsO36aw4b22kCM9WDmkcl7wf21fG9o +8gJDVjFjDWbwTWREaKjgS6s/Yb8f9gje/BGySojxynTi3zyTUN94q9dhVjfiQ79UzXZdN9Fy +yIx2YO5tOo09hTWSZg16oxP47Mj1ATaS6UIrQMcMnOp0kuc6SufXPSWsUA+g2lW0dmHgPvIH +wUfcjWqT2elF01e9KOFe7im29G6zOS2MRx8cr6KRg/eNWpHh5aI4quRUhYk4Kw4ohQTbs9ed +0YttS4PMK+sq6xHpb28X6ZgrWnelPY9hfwcR4m7Ot3VQUG8JY9/aTlFCoeTgkhop+MCUI+dJ +eY8depIa0PTzdEmEWRvPhTTv+CUdZ6v4z5LD6FhP+/5c6FCbcIb89Rp5fa53oYV5/KZf+0DU +VgmpXFU7J7ZrGgDeU7vIzmwr8kcx0vtsVm1dVwYLACpTaaQPbISQUDM8sEcqKAqD7hWKaxNs +b2M85L6q2/rnHq4g46yJzdR3b8EH+V9u+mUi9DIljDwcpvw7ReRQ9wPdDWLynnglIeGImbjY +fr324yaIl4vNORAkbsoCkS/qc5v6MvKvYNle5fzb9S9kCbNZmD9c5/bHPjj9ENeQvzrl2pFh +6dc1o5cAEQEAAYkEcgQYAQgAJhYhBBTyZoLQkWzdgeN7bWG3tSbZjwNTBQJZS9m1AhsCBQkD +wmcAAkAJEGG3tSbZjwNTwXQgBBkBCAAdFiEE3OrF2WE1uRxOpnKru769uyTG81UFAllL2bUA +CgkQu769uyTG81UFUw//bW5T7w2k8ukGfpIcm0gB98VgxKenSCmU6N+Ii0DwcNtzW+pmVWl2 +TbHIXDpvuD69ODWBDMXu6gBkrVzNEsK3uhzGe0tWA+5I7Vke3iEkbll7VRQlIOrw+n5NMvje +uDqKsMt1gMEEdgRKddYApEAi49vV7XnqkB2lLKfAnf6o/KqPm8MuQ+u0xYanupZCldwdpcx5 +rybj79Es0iO9Gh/+3qOtR6ubOz3Vn78Lc3y6AP9pmtdOI2QX8foGK4hNmgHSP6uPLh/ERC9N +ir0Lc2hoEhHEkQ8CnEaccp70r03VkEQuMJQJPUyRsGZ/gIm0SAm9JJxWHXJk2/5NUN83pHAX +0LA4zxtWs4fVW5f8v9eIhFFPTZ4au+/cS9D4GFx4mlY34awcpAzrny2tntGEejY9HSJv4PuF +ZCmtyS2q61N9EU8yuBwVM9cp5HntzG+OT4HYugtI6ibehM0S1Roy4ETwT+Ns41ffhCwdYMp8 +tzdeksQ35s7rkB9OJHj+q2dkGaV0FQb3FutbSpxbP4zk/dLqyxuivdUPHGtf4W/qklxzCWBg +0VDFA7PwatmEXRxTjx77RelTY0V7K54dDyVv3Jh2+FzuaQZzzuIhv4gtqHntaqLnYl3h/QNL +bOTE3ppvn9RUSR983Bd+M3QhbbwZrgG1m+hdUZUmji+wbK0wV0xHNEH+4BAAjbVzdNOs7hMv +jY1wVDRFjvICVorNdNdU3ELy/9BAoiwOs2+zjDXmsX+3YtdzwKvdpQ24O0TvH4Vo3BkvKkJ7 +5EU7LroAbYQ2423m1MY3eaBslmX7TUJ3XE+k7OZF8AmcftgP4nhC4IQSCtoBc9+ncyGN4da1 +BpYO7b19tO0/HST8GHSrEcU9bGGdimS2eNkSgybA8wF6K0K9yvrpTNSZ7OBVlzQfEn8s70Gy +zs/d6C/rTA+defnv3AMaciuINSEdFyfYq4wjt5PikvgceMAAkH/z69xTNg+6q3FQt/lyK7xX +5qPMe2oFyDA1H+Cb/uL7ioo+jXh9gF+0fk8OP2IPzxYhBfulpVtgclmOuaekzaKeIv8NFW7G +oA9OghziExePxg95OpL/VyQ7PJiAUj1pFovFk5HS6ejVZNEGJ/A5zLc1PBIcr/phu0luqhXA +hImsZS6858GWQllWULNWw8bX5Blo8AvcfFVdq9iAK7aHN7g45ZR7Ze6qKHDyFv4XWuE/rj9C +2mM/GAstvU0gGmbo6B1mNGMJuX3Gd3dG8fqFjE77OB2feJyfZ8UeF1nvG1hxlmuD1A5e6/os +O9V7kjhXKzM2zSO11zHQ/5PlUisoUBjJ/QIK4v9RBNGtbRKso5X9Fke692lVgrdggDJ3j2Qq +MuTo71rAVDLtxerc+GNq0GI= +=YjV6 +-----END PGP PUBLIC KEY BLOCK----- diff --git a/nixpkgs-mozilla/lib-overlay.nix b/nixpkgs-mozilla/lib-overlay.nix new file mode 100644 index 0000000..23d6b39 --- /dev/null +++ b/nixpkgs-mozilla/lib-overlay.nix @@ -0,0 +1,5 @@ +self: super: + +{ + lib = super.lib // (import ./pkgs/lib/default.nix { pkgs = self; }); +} diff --git a/nixpkgs-mozilla/lib/parseTOML.nix b/nixpkgs-mozilla/lib/parseTOML.nix index b8202fd..07a9369 100644 --- a/nixpkgs-mozilla/lib/parseTOML.nix +++ b/nixpkgs-mozilla/lib/parseTOML.nix @@ -1,78 +1,130 @@ with builtins; + +# Tokenizer. let layout_pat = "[ \n]+"; layout_pat_opt = "[ \n]*"; - token_pat = ''=|[[][[][a-zA-Z0-9_."*-]+[]][]]|[[][a-zA-Z0-9_."*-]+[]]|[a-zA-Z0-9_-]+|"[^"]*"''; - tokenizer_rec = len: prevTokens: patterns: str: + token_pat = ''=|[[][[][a-zA-Z0-9_."*-]+[]][]]|[[][a-zA-Z0-9_."*-]+[]]|[a-zA-Z0-9_-]+|"[^"]*"''; #" + + tokenizer_1_11 = str: let - pattern = head patterns; - layoutAndTokens = match pattern str; - matchLength = stringLength (head layoutAndTokens); - tokens = prevTokens ++ tail layoutAndTokens; + tokenizer_rec = len: prevTokens: patterns: str: + let + pattern = head patterns; + layoutAndTokens = match pattern str; + matchLength = stringLength (head layoutAndTokens); + tokens = prevTokens ++ tail layoutAndTokens; + in + if layoutAndTokens == null then + # if we cannot reduce the pattern, return the list of token + if tail patterns == [] then prevTokens + # otherwise, take the next pattern, which only captures half the token. + else tokenizer_rec len prevTokens (tail patterns) str + else tokenizer_rec len tokens patterns (substring matchLength len str); + + avgTokenSize = 100; + ceilLog2 = v: + let inner = n: i: if i < v then inner (n + 1) (i * 2) else n; in + inner 1 1; + + # The builtins.match function match the entire string, and generate a list of all captured + # elements. This is the most efficient way to make a tokenizer, if we can make a pattern which + # capture all token of the file. Unfortunately C++ std::regex does not support captures in + # repeated patterns. As a work-around, we generate patterns which are matching tokens in multiple + # of 2, such that we can avoid iterating too many times over the content. + generatePatterns = str: + let + depth = ceilLog2 (stringLength str / avgTokenSize); + inner = depth: + if depth == 0 then [ "(${token_pat})" ] + else + let next = inner (depth - 1); in + [ "${head next}${layout_pat}${head next}" ] ++ next; + in + map (pat: "(${layout_pat_opt}${pat}).*" ) (inner depth); + in - if layoutAndTokens == null then - # if we cannot reduce the pattern, return the list of token - if tail patterns == [] then prevTokens - # otherwise, take the next pattern, which only captures half the token. - else tokenizer_rec len prevTokens (tail patterns) str - else tokenizer_rec len tokens patterns (substring matchLength len str); - - avgTokenSize = 100; - ceilLog2 = v: - let inner = n: i: if i < v then inner (n + 1) (i * 2) else n; in - inner 1 1; - - # The builtins.match function match the entire string, and generate a list of all captured - # elements. This is the most efficient way to make a tokenizer, if we can make a pattern which - # capture all token of the file. Unfortunately C++ std::regex does not support captures in - # repeated patterns. As a work-around, we generate patterns which are matching tokens in multiple - # of 2, such that we can avoid iterating too many times over the content. - generatePatterns = str: + tokenizer_rec (stringLength str) [] (generatePatterns str) str; + + tokenizer_1_12 = str: let - depth = ceilLog2 (stringLength str / avgTokenSize); - inner = depth: - if depth == 0 then [ "(${token_pat})" ] - else - let next = inner (depth - 1); in - [ "${head next}${layout_pat}${head next}" ] ++ next; + # Nix 1.12 has the builtins.split function which allow to tokenize the + # file quickly. by iterating with a simple regexp. + layoutTokenList = split "(${token_pat})" str; + isLayout = s: match layout_pat_opt s != null; + filterLayout = list: + filter (s: + if isString s then + if isLayout s then false + else throw "Error: Unexpected token: '${s}'" + else true) list; + removeTokenWrapper = list: + map (x: assert tail x == []; head x) list; in - map (pat: "(${layout_pat_opt}${pat}).*" ) (inner depth); + removeTokenWrapper (filterLayout layoutTokenList); - tokenizer = str: tokenizer_rec (stringLength str) [] (generatePatterns str) str; + tokenizer = + if builtins ? split + then tokenizer_1_12 + else tokenizer_1_11; +in +# Parse entry headers +let unescapeString = str: # Let's ignore any escape character for the moment. - assert match ''"[^"]*"'' str != null; + assert match ''"[^"]*"'' str != null; #" substring 1 (stringLength str - 2) str; - - tokenToValue = token: - if token == "true" then true - else if token == "false" then false - else unescapeString token; - # Match the content of TOML format section names, and add the grouping such that: - # match header_pat "a.b.c" == [ "a" ".b" "b" ".c" "c" ] - # + # Match the content of TOML format section names. + ident_pat = ''[a-zA-Z0-9_-]+|"[^"]*"''; #" + + removeBraces = token: wrapLen: + substring wrapLen (stringLength token - 2 * wrapLen) token; + # Note, this implementation is limited to 11 identifiers. - ident_pat = ''[a-zA-Z0-9_-]+|"[^"]*"''; - header_pat = - foldl' (pat: n: "(${ident_pat})([.]${pat})?") - "(${ident_pat})" (genList (n: 0) 10); + matchPathFun_1_11 = token: + let + # match header_pat "a.b.c" == [ "a" ".b" "b" ".c" "c" ] + header_pat = + foldl' (pat: n: "(${ident_pat})([.]${pat})?") + "(${ident_pat})" (genList (n: 0) 10); + matchPath = match header_pat token; + filterDot = filter (s: substring 0 1 s != ".") matchPath; + in + filterDot; + + matchPathFun_1_12 = token: + map (e: head e) + (filter (s: isList s) + (split "(${ident_pat})" token)); + + matchPathFun = + if builtins ? split + then matchPathFun_1_12 + else matchPathFun_1_11; headerToPath = token: wrapLen: let - token' = substring wrapLen (stringLength token - 2 * wrapLen) token; - matchPath = match header_pat token'; - filterDot = filter (s: substring 0 1 s != ".") matchPath; + token' = removeBraces token wrapLen; + matchPath = matchPathFun token'; path = map (s: - if substring 0 1 s != ''"'' then s + if substring 0 1 s != ''"'' then s #" else unescapeString s - ) filterDot; + ) matchPath; in assert matchPath != null; # assert trace "Path: ${token'}; match as ${toString path}" true; path; +in + +# Reconstruct the equivalent attribute set. +let + tokenToValue = token: + if token == "true" then true + else if token == "false" then false + else unescapeString token; parserInitState = { idx = 0; diff --git a/nixpkgs-mozilla/pinned.nix b/nixpkgs-mozilla/pinned.nix new file mode 100644 index 0000000..44fd78a --- /dev/null +++ b/nixpkgs-mozilla/pinned.nix @@ -0,0 +1,37 @@ +# This script extends nixpkgs with mozilla packages. +# +# First it imports the in the environment and depends on it +# providing fetchFromGitHub and lib.importJSON. +# +# After that it loads a pinned release of nixos-unstable and uses that as the +# base for the rest of packaging. One can pass it's own pkgsPath attribute if +# desired, probably in the context of hydra. + +{ pkgsPath ? null +, overlays ? [] +, system ? null +, geckoSrc ? null +, servoSrc ? null +}: + +# Pin a specific version of Nixpkgs. +let + _pkgs = import {}; + _pkgsPath = + if pkgsPath != null then pkgsPath + else _pkgs.fetchFromGitHub (_pkgs.lib.importJSON ./pkgs/nixpkgs.json); + nixpkgs = import _pkgsPath ({ + overlays = import ./default.nix ++ overlays; + } // (if system != null then { inherit system; } else {})); +in + nixpkgs // { + # Do not add a name attribute attribute in an overlay !!! As this will cause + # tons of recompilations. + name = "nixpkgs"; + updateScript = nixpkgs.lib.updateFromGitHub { + owner = "NixOS"; + repo = "nixpkgs-channels"; + branch = "nixos-unstable-small"; + path = "pkgs/nixpkgs.json"; + }; + } diff --git a/nixpkgs-mozilla/pkgs/VidyoDesktop/default.nix b/nixpkgs-mozilla/pkgs/VidyoDesktop/default.nix index c9d76ee..50b9590 100644 --- a/nixpkgs-mozilla/pkgs/VidyoDesktop/default.nix +++ b/nixpkgs-mozilla/pkgs/VidyoDesktop/default.nix @@ -1,31 +1,31 @@ -{ pkgs +{ stdenv, fetchurl, buildFHSUserEnv, makeWrapper, dpkg, alsaLib, + alsaUtils, alsaOss, alsaTools, alsaPlugins, libidn, utillinux, mesa_glu, qt4, + zlib, patchelf, xorg, libpulseaudio }: let - - inherit (pkgs) fetchurl buildFHSUserEnv makeWrapper dpkg alsaLib - alsaUtils alsaOss alsaTools alsaPlugins libidn utillinux mesa_glu qt4 - zlib patchelf xorg; - inherit (pkgs.stdenv) mkDerivation; - - VidyoDesktopDeb = mkDerivation { - name = "VidyoDesktopDeb-123"; + vidyoVersion = "3.6.3"; + vidyoBuild = "017"; + vidyoVersionUnderscore = builtins.replaceStrings ["."] ["_"] vidyoVersion; + VidyoDesktopDeb = stdenv.mkDerivation { + name = "VidyoDesktopDeb-${vidyoVersion}"; builder = ./builder.sh; inherit dpkg; src = fetchurl { - url = "https://v.mozilla.com/upload/VidyoDesktopInstaller-ubuntu64-TAG_VD_3_3_0_027.deb"; - sha256 = "045f9z421qpcm45bmh98f3h7bd46rdjvcbdpv4rlw9ribncv66dc"; + url = "https://v.mozilla.com/upload/VidyoDesktopInstaller-ubuntu64-TAG_VD_${vidyoVersionUnderscore}_${vidyoBuild}.deb"; + sha256 = "01spq6r49myv82fdimvq3ykwb1lc5bymylzcydfdp9xz57f5a94x"; }; buildInputs = [ makeWrapper ]; }; in buildFHSUserEnv { - name = "VidyoDesktop-123"; + name = "VidyoDesktop"; targetPkgs = pkgs: [ VidyoDesktopDeb ]; multiPkgs = pkgs: [ patchelf dpkg alsaLib alsaUtils alsaOss alsaTools alsaPlugins libidn utillinux mesa_glu qt4 zlib xorg.libXext xorg.libXv xorg.libX11 xorg.libXfixes xorg.libXrandr xorg.libXScrnSaver + libpulseaudio ]; extraBuildCommands = '' ln -s ${VidyoDesktopDeb}/opt $out/opt diff --git a/nixpkgs-mozilla/pkgs/firefox-nightly-bin/default.nix b/nixpkgs-mozilla/pkgs/firefox-nightly-bin/default.nix index fb6264b..6ec3b0a 100644 --- a/nixpkgs-mozilla/pkgs/firefox-nightly-bin/default.nix +++ b/nixpkgs-mozilla/pkgs/firefox-nightly-bin/default.nix @@ -3,7 +3,7 @@ let - unwrapped = pkgs.callPackage "${pkgs.path}/pkgs/applications/networking/browsers/firefox-bin" { + unwrapped = pkgs.firefox-bin-unwrapped.override { inherit (pkgs) stdenv; channel = "nightly"; generated = import (./. + "/sources.nix"); diff --git a/nixpkgs-mozilla/pkgs/firefox-nightly-bin/sources.nix b/nixpkgs-mozilla/pkgs/firefox-nightly-bin/sources.nix index b09f75d..9366623 100644 --- a/nixpkgs-mozilla/pkgs/firefox-nightly-bin/sources.nix +++ b/nixpkgs-mozilla/pkgs/firefox-nightly-bin/sources.nix @@ -1,10 +1,10 @@ { - version = "56.0a1" + "-" + "20170717100212"; + version = "57.0a1" + "-" + "20170829"; sources = [ - { url = "http://archive.mozilla.org/pub/firefox/nightly/latest-mozilla-central/firefox-56.0a1.en-US.linux-x86_64.tar.bz2"; + { url = "https://download-installer.cdn.mozilla.net/pub/firefox/nightly/latest-mozilla-central/firefox-57.0a1.en-US.linux-x86_64.tar.bz2"; locale = "en-US"; arch = "linux-x86_64"; - sha512 = "389ada65229fa6225a918041f77eed26cff321d649b8e9206835364e967fe3312dba9f7de9fbea52daf934265b804de447dddee60932d5019f8361884c9f3bde"; + sha512 = "1ggz8rl7n6j6qx7sira5dmqfy769swxh0dpi4mn6fdc7ppbrbyz58g4a47f6g1ng04y646h75yxdhqjp55nxqcp7v861b004bzf9b88"; } ]; } diff --git a/nixpkgs-mozilla/pkgs/firefox-nightly-bin/update.nix b/nixpkgs-mozilla/pkgs/firefox-nightly-bin/update.nix index 9f8f694..21fbac4 100644 --- a/nixpkgs-mozilla/pkgs/firefox-nightly-bin/update.nix +++ b/nixpkgs-mozilla/pkgs/firefox-nightly-bin/update.nix @@ -17,9 +17,10 @@ in writeScript "update-firefox-nightly-bin" '' pushd pkgs/firefox-nightly-bin tmpfile=`mktemp` - url=http://archive.mozilla.org/pub/firefox/nightly/latest-mozilla-central/ + url=https://archive.mozilla.org/pub/firefox/nightly/latest-mozilla-central/ - nightly_file=`xidel -q $url --extract //a | \ + nightly_file=`curl $url | \ + xidel - --extract //a | \ grep firefox | \ grep linux-x86_64.json | \ tail -1 | \ diff --git a/nixpkgs-mozilla/pkgs/gecko/default.nix b/nixpkgs-mozilla/pkgs/gecko/default.nix index 56778c3..ed6fcb5 100644 --- a/nixpkgs-mozilla/pkgs/gecko/default.nix +++ b/nixpkgs-mozilla/pkgs/gecko/default.nix @@ -1,20 +1,23 @@ -{ geckoSrc ? null -, lib -, pkgs +{ geckoSrc ? null, lib +, stdenv, fetchFromGitHub, pythonFull, which, autoconf213 +, perl, unzip, zip, gnumake, yasm, pkgconfig, xlibs, gnome2, pango, freetype, fontconfig, cairo +, dbus, dbus_glib, alsaLib, libpulseaudio, gstreamer, gst_plugins_base +, gtk3, glib, gobjectIntrospection, gdk_pixbuf, atk, gtk2 +, git, mercurial, openssl, cmake, procps +, libnotify +, valgrind, gdb, rr +, setuptools +, rust # rust & cargo bundled. (otheriwse use pkgs.rust.{rustc,cargo}) +, buildFHSUserEnv # Build a FHS environment with all Gecko dependencies. +, llvmPackages +, ccache }: let - inherit (lib) updateFromGitHub; - inherit (pkgs) fetchFromGitHub pythonFull which autoconf213 - perl unzip zip gnumake yasm pkgconfig xlibs gnome2 pango dbus dbus_glib - alsaLib libpulseaudio gstreamer gst_plugins_base gtk3 glib - gobjectIntrospection git mercurial openssl cmake; - inherit (pkgs) valgrind gdb rr; - inherit (pkgs.pythonPackages) setuptools; - inherit (pkgs.stdenv) mkDerivation; - inherit (pkgs.lib) importJSON optionals inNixShell; - inherit (pkgs.rust) rustc cargo; + inherit (lib) updateFromGitHub importJSON optionals inNixShell; + + gcc = if stdenv.cc.isGNU then stdenv.cc.cc else stdenv.cc.cc.gcc; # Gecko sources are huge, we do not want to import them in the nix-store when # we use this expression for making a build environment. @@ -28,9 +31,6 @@ let version = "HEAD"; # XXX: builtins.readFile "${src}/browser/config/version.txt"; -in mkDerivation { - name = "gecko-dev-${version}"; - inherit src; buildInputs = [ # Expected by "mach" @@ -49,16 +49,27 @@ in mkDerivation { gnome2.libgnome gnome2.libgnomecanvas gnome2.libgnomeui gnome2.libIDL - pango + pango freetype fontconfig cairo dbus dbus_glib alsaLib libpulseaudio gstreamer gst_plugins_base - gtk3 glib gobjectIntrospection + gtk3 glib gobjectIntrospection gdk_pixbuf atk + gtk2 gnome2.GConf + + rust + + # For building bindgen + # Building bindgen is now done with the extra options added by genMozConfig + # shellHook, do not include clang directly in order to avoid messing up with + # the choices of the compilers. - rustc cargo + # clang + + # mach mochitest + procps # "mach vendor rust" wants to list modified files by using the vcs. git mercurial @@ -66,28 +77,78 @@ in mkDerivation { # needed for compiling cargo-vendor and its dependencies openssl cmake + # Useful for getting notification at the end of the build. + libnotify + ] ++ optionals inNixShell [ - valgrind gdb rr + valgrind gdb rr ccache ]; + genMozConfig = '' + cxxLib=$( echo -n ${gcc}/include/c++/* ) + archLib=$cxxLib/$( ${gcc}/bin/gcc -dumpmachine ) + + cat - > $MOZCONFIG < $MOZ_CONFIG " - . $src/build/mozconfig.common + echo >> $MOZCONFIG " + # . $src/build/mozconfig.common + + ac_add_options --enable-application=browser mk_add_options MOZ_OBJDIR=$builddir - mk_add_options AUTOCONF=${autoconf213}/bin/autoconf ac_add_options --prefix=$out - ac_add_options --enable-application=browser ac_add_options --enable-official-branding - export AUTOCONF=${autoconf213}/bin/autoconf " ''; @@ -107,13 +168,15 @@ in mkDerivation { doCheck = false; doInstallCheck = false; - shellHook = '' - export MOZBUILD_STATE_PATH=$PWD/.mozbuild - ''; + # This is for debugging purposes, go to hell damn wrapper which are removing + # all I need for debugging. + hardeningDisable = [ "all" ]; + passthru.updateScript = updateFromGitHub { owner = "mozilla"; repo = "gecko-dev"; branch = "master"; path = "pkgs/gecko/source.json"; }; + passthru.fhs = fhs; # gecko.x86_64-linux.gcc.fhs.env } diff --git a/nixpkgs-mozilla/release.nix b/nixpkgs-mozilla/release.nix index 5b6e302..77adf5f 100644 --- a/nixpkgs-mozilla/release.nix +++ b/nixpkgs-mozilla/release.nix @@ -1,120 +1,52 @@ -let - _pkgs = import {}; - _nixpkgs = _pkgs.fetchFromGitHub (_pkgs.lib.importJSON ./pkgs/nixpkgs.json); -in - -{ nixpkgsSrc ? _nixpkgs +# To pin a specific version of nixpkgs, change the nixpkgsSrc argument. +{ nixpkgsSrc ? , supportedSystems ? [ "x86_64-linux" "i686-linux" /* "x86_64-darwin" */ ] }: let + lib = (import nixpkgsSrc {}).lib; + # Make an attribute set for each system, the builder is then specialized to # use the selected system. - forEachSystem = systems: builder: - _pkgs.lib.genAttrs systems (system: - builder (import _nixpkgs { inherit system; }) - ); + forEachSystem = systems: builder /* system -> stdenv -> pkgs */: + lib.genAttrs systems builder; # Make an attribute set for each compiler, the builder is then be specialized # to use the selected compiler. - forEachCompiler = compilers: builder: pkgs: - with pkgs; - let + forEachCompiler = compilers: builder: system: + builtins.listToAttrs (map (compiler: { + name = compiler; + value = builder compiler system; + }) compilers); - # Override, in a non-recursive matter to avoid recompilations, the standard - # environment used for building packages. - builderWithStdenv = stdenv: builder (pkgs // { inherit stdenv; }); - - noSysDirs = (system != "x86_64-darwin" - && system != "x86_64-freebsd" && system != "i686-freebsd" - && system != "x86_64-kfreebsd-gnu"); - crossSystem = null; - - gcc473 = wrapCC (callPackage ./pkgs/gcc-4.7 { - inherit noSysDirs; - texinfo = texinfo4; - # I'm not sure if profiling with enableParallelBuilding helps a lot. - # We can enable it back some day. This makes the *gcc* builds faster now. - profiledCompiler = false; - - # When building `gcc.crossDrv' (a "Canadian cross", with host == target - # and host != build), `cross' must be null but the cross-libc must still - # be passed. - cross = null; - libcCross = if crossSystem != null then libcCross else null; - libpthreadCross = - if crossSystem != null && crossSystem.config == "i586-pc-gnu" - then gnu.libpthreadCross - else null; - }); - # By default wrapCC keep the same header files, but NixOS is using the - # latest header files from GCC, which are not supported by clang, because - # clang implement a different set of locking primitives than GCC. This - # expression is used to wrap clang with a matching verion of the libc++. - maybeWrapClang = cc: - if cc ? clang then clangWrapCC cc - else cc; - clangWrapCC = llvmPackages: - let libcxx = - pkgs.lib.overrideDerivation llvmPackages.libcxx (drv: { - # https://bugzilla.mozilla.org/show_bug.cgi?id=1277619 - # https://llvm.org/bugs/show_bug.cgi?id=14435 - patches = drv.patches ++ [ ./pkgs/clang/bug-14435.patch ]; - }); - in - callPackage { - cc = llvmPackages.clang-unwrapped or llvmPackages.clang; - isClang = true; - stdenv = clangStdenv; - libc = glibc; - # cc-wrapper pulls gcc headers, which are not compatible with features - # implemented in clang. These packages are used to override that. - extraPackages = [ libcxx llvmPackages.libcxxabi ]; - nativeTools = false; - nativeLibc = false; - }; + # Overide the previous derivation, with a different stdenv. + builder = path: compiler: system: + lib.getAttrFromPath path (import nixpkgsSrc { + inherit system; + overlays = [ + # Add all packages from nixpkgs-mozilla. + (import ./default.nix) - buildWithCompiler = cc: builderWithStdenv - (stdenvAdapters.overrideCC stdenv (maybeWrapClang cc)); - chgCompilerSource = cc: name: src: - cc.override (conf: - if conf ? gcc then # Nixpkgs 14.12 - { gcc = lib.overrideDerivation conf.gcc (old: { inherit name src; }); } - else # Nixpkgs 15.05 - { cc = lib.overrideDerivation conf.cc (old: { inherit name src; }); } - ); + # Define customStdenvs, which is a set of various compilers which can be + # used to compile the given package against. + (import ./compilers-overlay.nix) - compilersByName = { - clang = llvmPackages; - clang36 = llvmPackages_36; - clang37 = llvmPackages_37; - clang38 = llvmPackages_38; # not working yet. - gcc = gcc; - gcc49 = gcc49; - gcc48 = gcc48; - gcc474 = chgCompilerSource gcc473 "gcc-4.7.4" (fetchurl { - url = "mirror://gnu/gcc/gcc-4.7.4/gcc-4.7.4.tar.bz2"; - sha256 = "10k2k71kxgay283ylbbhhs51cl55zn2q38vj5pk4k950qdnirrlj"; - }); - gcc473 = gcc473; - # Version used on Linux slaves, except Linux x64 ASAN. - gcc472 = chgCompilerSource gcc473 "gcc-4.7.2" (fetchurl { - url = "mirror://gnu/gcc/gcc-4.7.2/gcc-4.7.2.tar.bz2"; - sha256 = "115h03hil99ljig8lkrq4qk426awmzh0g99wrrggxf8g07bq74la"; - }); - }; - - in builtins.listToAttrs (map (x: { name = x; value = buildWithCompiler (builtins.getAttr x compilersByName); }) compilers); + # Use the following overlay to override the requested package from + # nixpkgs, with a custom stdenv taken from the compilers-overlay. + (self: super: + if compiler == null then {} + else lib.setAttrByPath path ((lib.getAttrFromPath path super).override { + stdenv = self.customStdenvs."${compiler}"; + })) + ]; + }); - build = name: { systems ? supportedSystems, compilers ? null }: + build = path: { systems ? supportedSystems, compilers ? null }: forEachSystem systems ( - let - builder = pkgs: builtins.getAttr name (import ./default.nix { inherit pkgs; }); - in - if compilers == null - then builder - else forEachCompiler compilers builder + if compilers == null + then builder path null + else forEachCompiler compilers (builder path) ); geckoCompilers = [ @@ -145,12 +77,23 @@ let # and pull the the dependencies needed for building firefox with this # environment. # - # $ nix-shell release.nix -A gecko.i686-linux.gcc472 --pure --command 'gcc --version' + # $ nix-shell release.nix -A gecko.i686-linux.gcc --pure --command '$CC --version' # $ nix-shell release.nix -A gecko.x86_64-linux.clang --pure # - gecko = build "gecko" { compilers = geckoCompilers; }; - servo = build "servo"; - VidyoDesktop = build "VidyoDesktop"; + # As some of the test script of Gecko are checking against absolute path, a + # fake-FHS is provided for Gecko. It can be accessed by appending + # ".fhs.env" behind the previous commands: + # + # $ nix-shell release.nix -A gecko.x86_64-linux.gcc.fhs.env + # + # Which will spawn a new shell where the closure of everything used to build + # Gecko would be part of the fake-root. + gecko = build [ "devEnv" "gecko" ] { compilers = geckoCompilers; }; + servo = build [ "servo" ]; + VidyoDesktop = build [ "VidyoDesktop" ]; + latest = { + "firefox-nightly-bin" = build [ "latest" "firefox-nightly-bin" ]; + }; }; in jobs diff --git a/nixpkgs-mozilla/rr-overlay.nix b/nixpkgs-mozilla/rr-overlay.nix new file mode 100644 index 0000000..30405a8 --- /dev/null +++ b/nixpkgs-mozilla/rr-overlay.nix @@ -0,0 +1,14 @@ +self: super: + +{ + # Add i686-linux platform as a valid target. + rr = super.rr.override { + stdenv = self.stdenv // { + mkDerivation = args: self.stdenv.mkDerivation (args // { + meta = args.meta // { + platforms = self.stdenv.lib.platforms.linux; + }; + }); + }; + }; +} diff --git a/nixpkgs-mozilla/rust-overlay.nix b/nixpkgs-mozilla/rust-overlay.nix index ddf38bc..39f7a85 100644 --- a/nixpkgs-mozilla/rust-overlay.nix +++ b/nixpkgs-mozilla/rust-overlay.nix @@ -86,7 +86,7 @@ let pkg = pkgs.${pkgname}; srcInfo = pkg.target.${target}; in - (fetchurl { url = srcInfo.url; sha256 = srcInfo.hash; }); + (super.fetchurl { url = srcInfo.xz_url; sha256 = srcInfo.xz_hash; }); checkMissingExtensions = pkgs: pkgname: stdenv: extensions: let @@ -127,6 +127,8 @@ let # available = true; # hash = "abce..."; # sha256 # url = "https://static.rust-lang.org/dist/....tar.gz"; + # xz_hash = "abce..."; # sha256 + # xz_url = "https://static.rust-lang.org/dist/....tar.xz"; # }; # } # @@ -234,6 +236,14 @@ let popd fi ''; + + # Add the compiler as part of the propagated build inputs in order + # to run: + # + # $ nix-shell -p rustChannels.stable.rust + # + # And get a fully working Rust compiler, with the stdenv linker. + propagatedBuildInputs = [ stdenv.cc ]; } ) { extensions = []; targets = []; targetExtensions = []; } ); @@ -241,9 +251,9 @@ let fromManifest = manifest: { stdenv, fetchurl, patchelf }: fromManifestFile (builtins.fetchurl manifest) { inherit stdenv fetchurl patchelf; }; -in rec +in -{ +rec { lib = super.lib // { inherit fromTOML; rustLib = { @@ -256,20 +266,27 @@ in rec { inherit (self) stdenv fetchurl patchelf; } ; - rustChannels = { - nightly = rustChannelOf { channel = "nightly"; }; - beta = rustChannelOf { channel = "beta"; }; - stable = rustChannelOf { channel = "stable"; }; + # Set of packages which are automagically updated. Do not rely on these for + # reproducible builds. + latest = (super.latest or {}) // { + rustChannels = { + nightly = rustChannelOf { channel = "nightly"; }; + beta = rustChannelOf { channel = "beta"; }; + stable = rustChannelOf { channel = "stable"; }; + }; }; + # For backward compatibility + rustChannels = latest.rustChannels; + # For each channel: - # rustChannels.nightly.cargo - # rustChannels.nightly.rust # Aggregate all others. (recommended) - # rustChannels.nightly.rustc - # rustChannels.nightly.rust-analysis - # rustChannels.nightly.rust-docs - # rustChannels.nightly.rust-src - # rustChannels.nightly.rust-std + # latest.rustChannels.nightly.cargo + # latest.rustChannels.nightly.rust # Aggregate all others. (recommended) + # latest.rustChannels.nightly.rustc + # latest.rustChannels.nightly.rust-analysis + # latest.rustChannels.nightly.rust-docs + # latest.rustChannels.nightly.rust-src + # latest.rustChannels.nightly.rust-std # For a specific date: # rustChannelOf { date = "2017-06-06"; channel = "beta"; }.rust diff --git a/nixpkgs-mozilla/rust-src-overlay.nix b/nixpkgs-mozilla/rust-src-overlay.nix new file mode 100644 index 0000000..05cb613 --- /dev/null +++ b/nixpkgs-mozilla/rust-src-overlay.nix @@ -0,0 +1,18 @@ +# Overlay that builds on top of rust-overlay.nix. +# Adds rust-src component to all channels which is helpful for racer, intellij, ... + +self: super: + +let mapAttrs = super.stdenv.lib.mapAttrs; + flip = super.stdenv.lib.flip; +in { + # install stable rust with rust-src: + # "nix-env -i -A nixos.latest.rustChannels.stable.rust" + + latest.rustChannels = + flip mapAttrs super.latest.rustChannels (name: value: value // { + rust = value.rust.override { + extensions = ["rust-src"]; + }; + }); +} diff --git a/nixpkgs-mozilla/servo-overlay.nix b/nixpkgs-mozilla/servo-overlay.nix new file mode 100644 index 0000000..e7d843f --- /dev/null +++ b/nixpkgs-mozilla/servo-overlay.nix @@ -0,0 +1,5 @@ +self: super: + +{ + servo = super.callPackage ./pkgs/servo { }; +} diff --git a/nixpkgs-mozilla/vidyo-overlay.nix b/nixpkgs-mozilla/vidyo-overlay.nix new file mode 100644 index 0000000..691db5c --- /dev/null +++ b/nixpkgs-mozilla/vidyo-overlay.nix @@ -0,0 +1,5 @@ +self: super: + +{ + VidyoDesktop = super.callPackage ./pkgs/VidyoDesktop { }; +}