Update nixpkgs-mozilla to NixOS 18.03-compatible version

master
Sven Slootweg 7 years ago
parent ea6791ecf9
commit 58cd496ef0

@ -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 <nixpkgs> { 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 <nixpkgs> { 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.<arch>.<cc>`` attribute of the ``release.nix`` file provided
in this repository.
The ``<arch>`` 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 ``<cc>`` 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``).

@ -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 <nixpkgs/pkgs/build-support/cc-wrapper> {
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;
}

@ -1,49 +1,16 @@
# This script extends nixpkgs with mozilla packages.
#
# First it imports the <nixpkgs> 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> {};
_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

@ -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:
# <hash> sha512 62733881 firefox-56.0a1.en-US.linux-x86_64.tar.bz2
# <hash> 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 { };
}

@ -0,0 +1,254 @@
-----BEGIN PGP PUBLIC KEY BLOCK-----
Version: SKS 1.1.5
Comment: Hostname: keyserver.mozilla.org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=YjV6
-----END PGP PUBLIC KEY BLOCK-----

@ -0,0 +1,5 @@
self: super:
{
lib = super.lib // (import ./pkgs/lib/default.nix { pkgs = self; });
}

@ -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;

@ -0,0 +1,37 @@
# This script extends nixpkgs with mozilla packages.
#
# First it imports the <nixpkgs> 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 <nixpkgs> {};
_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";
};
}

@ -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

@ -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");

@ -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";
}
];
}

@ -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 | \

@ -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 <<EOF
mk_add_options AUTOCONF=${autoconf213}/bin/autoconf
ac_add_options --with-libclang-path=${llvmPackages.clang.cc.lib}/lib
ac_add_options --with-clang-path=${llvmPackages.clang}/bin/clang
export BINDGEN_CFLAGS="-cxx-isystem $cxxLib -isystem $archLib"
export CC="${stdenv.cc}/bin/cc"
export CXX="${stdenv.cc}/bin/c++"
EOF
'';
shellHook = ''
export MOZCONFIG=$PWD/.mozconfig.nix-shell
export MOZBUILD_STATE_PATH=$PWD/.mozbuild
export CC="${stdenv.cc}/bin/cc";
export CXX="${stdenv.cc}/bin/c++";
${genMozConfig}
${builtins.getEnv "NIX_SHELL_HOOK"}
'';
# propagatedBuildInput should already have applied the "lib.chooseDevOutputs"
# on the propagated build inputs.
pullAllInputs = inputs:
inputs ++ lib.concatMap (i: pullAllInputs (i.propagatedNativeBuildInputs or [])) inputs;
fhs = buildFHSUserEnv {
name = "gecko-deps-fhs";
targetPkgs = _: pullAllInputs (lib.chooseDevOutputs (buildInputs ++ [ stdenv.cc ]));
multiPkgs = null;
extraOutputsToInstall = [ "share" ];
profile = ''
# build-fhs-userenv/env.nix adds it, but causes 'ls' to SEGV.
unset LD_LIBRARY_PATH;
export IN_NIX_SHELL=1
export PKG_CONFIG_PATH=/usr/lib/pkgconfig:/usr/share/pkgconfig
${shellHook}
'';
};
in
stdenv.mkDerivation {
name = "gecko-dev-${version}";
inherit src buildInputs shellHook;
# Useful for debugging this Nix expression.
tracePhases = true;
configurePhase = ''
export MOZBUILD_STATE_PATH=$(pwd)/.mozbuild
export MOZ_CONFIG=$(pwd)/.mozconfig
export MOZCONFIG=$(pwd)/.mozconfig
export builddir=$(pwd)/builddir
${genMozConfig}
mkdir -p $MOZBUILD_STATE_PATH $builddir
echo > $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
}

@ -1,120 +1,52 @@
let
_pkgs = import <nixpkgs> {};
_nixpkgs = _pkgs.fetchFromGitHub (_pkgs.lib.importJSON ./pkgs/nixpkgs.json);
in
{ nixpkgsSrc ? _nixpkgs
# To pin a specific version of nixpkgs, change the nixpkgsSrc argument.
{ nixpkgsSrc ? <nixpkgs>
, 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 <nixpkgs/pkgs/build-support/cc-wrapper> {
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

@ -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;
};
});
};
};
}

@ -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

@ -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"];
};
});
}

@ -0,0 +1,5 @@
self: super:
{
servo = super.callPackage ./pkgs/servo { };
}

@ -0,0 +1,5 @@
self: super:
{
VidyoDesktop = super.callPackage ./pkgs/VidyoDesktop { };
}
Loading…
Cancel
Save