nordic-dev.net/nixpkgs
nordic-dev.net/nixpkgs
2
0
Fork 0
mirror of https://github.com/NixOS/nixpkgs.git synced 2025-01-29 16:24:10 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'master.upstream' into staging.upstream

Browse Source
This commit is contained in:
William A. Kennington III 2015-06-06 12:04:42 -07:00
commit 9d6555dc0a
282 changed files with 10934 additions and 4165 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

56
doc/coding-conventions.xml
View File

@ -620,33 +620,39 @@ evaluate correctly.</para>
fetchers from <literal>pkgs/build-support/</literal>. As an example going
from bad to good:
<itemizedlist>
<listitem><para>Uses <literal>git://</literal> which won't be proxied.
<programlisting>
src = fetchgit {
url = "git://github.com/NixOS/nix.git";
rev = "1f795f9f44607cc5bec70d1300150bfefcef2aae";
sha256 = "1cw5fszffl5pkpa6s6wjnkiv6lm5k618s32sp60kvmvpy7a2v9kg";
}
</programlisting></para>
<listitem>
<para>Uses <literal>git://</literal> which won't be proxied.
<programlisting>
src = fetchgit {
url = "git://github.com/NixOS/nix.git";
rev = "1f795f9f44607cc5bec70d1300150bfefcef2aae";
sha256 = "1cw5fszffl5pkpa6s6wjnkiv6lm5k618s32sp60kvmvpy7a2v9kg";
}
</programlisting>
</para>
</listitem>
<listitem><para>This is ok, but an archive fetch will still be faster.
<programlisting>
src = fetchgit {
url = "https://github.com/NixOS/nix.git";
rev = "1f795f9f44607cc5bec70d1300150bfefcef2aae";
sha256 = "1cw5fszffl5pkpa6s6wjnkiv6lm5k618s32sp60kvmvpy7a2v9kg";
}
</programlisting></para>
<listitem>
<para>This is ok, but an archive fetch will still be faster.
<programlisting>
src = fetchgit {
url = "https://github.com/NixOS/nix.git";
rev = "1f795f9f44607cc5bec70d1300150bfefcef2aae";
sha256 = "1cw5fszffl5pkpa6s6wjnkiv6lm5k618s32sp60kvmvpy7a2v9kg";
}
</programlisting>
</para>
</listitem>
<listitem><para>Fetches a snapshot archive and you get the rev you want.
<programlisting>
src = fetchFromGitHub {
owner = "NixOS";
repo = "nix";
rev = "1f795f9f44607cc5bec70d1300150bfefcef2aae";
sha256 = "04yri911rj9j19qqqn6m82266fl05pz98inasni0vxr1cf1gdgv9";
}
</programlisting></para>
<listitem>
<para>Fetches a snapshot archive and you get the rev you want.
<programlisting>
src = fetchFromGitHub {
owner = "NixOS";
repo = "nix";
rev = "1f795f9f44607cc5bec70d1300150bfefcef2aae";
sha256 = "04yri911rj9j19qqqn6m82266fl05pz98inasni0vxr1cf1gdgv9";
}
</programlisting>
</para>
</listitem>
</itemizedlist>
</para>

19
doc/contributing.xml
View File

@ -4,16 +4,17 @@
<title>Contributing</title>
<para>If you make modifications to the manual, it's important to build the manual before contributing:</para>
<para>The DocBook sources of the Nixpkgs manual are in the <filename
xlink:href="https://github.com/NixOS/nixpkgs/tree/master/doc">doc</filename>
subdirectory of the Nixpkgs repository. If you make modifications to
the manual, it's important to build it before committing. You can do that as follows:
<orderedlist>
<screen>
$ cd /path/to/nixpkgs
$ nix-build doc
</screen>
<listitem><para><command>$ git clone git://github.com/NixOS/nixpkgs.git</command></para></listitem>
<listitem><para><command>$ nix-build -A manual nixpkgs/pkgs/top-level/release.nix</command></para></listitem>
<listitem><para>Inside the built derivation you shall see <literal>manual/index.html</literal> file.</para></listitem>
</orderedlist>
If the build succeeds, the manual will be in
<filename>./result/share/doc/nixpkgs/manual.html</filename>.</para>
</chapter>

757
doc/haskell-users-guide.xml Normal file
View File

@ -0,0 +1,757 @@
<chapter xmlns="http://docbook.org/ns/docbook"
xmlns:xlink="http://www.w3.org/1999/xlink"
xml:id="users-guide-to-the-haskell-infrastructure">
<title>User's Guide to the Haskell Infrastructure</title>
<section xml:id="how-to-install-haskell-packages">
<title>How to install Haskell packages</title>
<para>
Nixpkgs distributes build instructions for all Haskell packages
registered on
<link xlink:href="http://hackage.haskell.org/">Hackage</link>, but
strangely enough normal Nix package lookups don't seem to discover
any of them:
</para>
<programlisting>
$ nix-env -qa cabal-install
error: selector ‘cabal-install’ matches no derivations
$ nix-env -i ghc
error: selector ‘ghc’ matches no derivations
</programlisting>
<para>
The Haskell package set is not registered in the top-level namespace
because it is <emphasis>huge</emphasis>. If all Haskell packages
were visible to these commands, then name-based search/install
operations would be much slower than they are now. We avoided that
by keeping all Haskell-related packages in a separate attribute set
called <literal>haskellPackages</literal>, which the following
command will list:
</para>
<programlisting>
$ nix-env -f &quot;&lt;nixpkgs&gt;&quot; -qaP -A haskellPackages
haskellPackages.a50 a50-0.5
haskellPackages.abacate haskell-abacate-0.0.0.0
haskellPackages.abcBridge haskell-abcBridge-0.12
haskellPackages.afv afv-0.1.1
haskellPackages.alex alex-3.1.4
haskellPackages.Allure Allure-0.4.101.1
haskellPackages.alms alms-0.6.7
[... some 8000 entries omitted ...]
</programlisting>
<para>
To install any of those packages into your profile, refer to them by
their attribute path (first column):
</para>
<programlisting>
$ nix-env -f &quot;&lt;nixpkgs&gt;&quot; -iA haskellPackages.Allure ...
</programlisting>
<para>
The attribute path of any Haskell packages corresponds to the name
of that particular package on Hackage: the package
<literal>cabal-install</literal> has the attribute
<literal>haskellPackages.cabal-install</literal>, and so on.
(Actually, this convention causes trouble with packages like
<literal>3dmodels</literal> and <literal>4Blocks</literal>, because
these names are invalid identifiers in the Nix language. The issue
of how to deal with these rare corner cases is currently
unresolved.)
</para>
<para>
Haskell packages who's Nix name (second column) begins with a
<literal>haskell-</literal> prefix are packages that provide a
library whereas packages without that prefix provide just
executables. Libraries may provide executables too, though: the
package <literal>haskell-pandoc</literal>, for example, installs
both a library and an application. You can install and use Haskell
executables just like any other program in Nixpkgs, but using
Haskell libraries for development is a bit trickier and we'll
address that subject in great detail in section
<link linkend="how-to-create-a-development-environment">How to
create a development environment</link>.
</para>
<para>
Attribute paths are deterministic inside of Nixpkgs, but the path
necessary to reach Nixpkgs varies from system to system. We dodged
that problem by giving <literal>nix-env</literal> an explicit
<literal>-f &quot;&lt;nixpkgs&gt;&quot;</literal> parameter, but if
you call <literal>nix-env</literal> without that flag, then chances
are the invocation fails:
</para>
<programlisting>
$ nix-env -iA haskellPackages.cabal-install
error: attribute ‘haskellPackages’ in selection path
‘haskellPackages.cabal-install’ not found
</programlisting>
<para>
On NixOS, for example, Nixpkgs does <emphasis>not</emphasis> exist
in the top-level namespace by default. To figure out the proper
attribute path, it's easiest to query for the path of a well-known
Nixpkgs package, i.e.:
</para>
<programlisting>
$ nix-env -qaP coreutils
nixos.pkgs.coreutils coreutils-8.23
</programlisting>
<para>
If your system responds like that (most NixOS installatios will),
then the attribute path to <literal>haskellPackages</literal> is
<literal>nixos.pkgs.haskellPackages</literal>. Thus, if you want to
use <literal>nix-env</literal> without giving an explicit
<literal>-f</literal> flag, then that's the way to do it:
</para>
<programlisting>
$ nix-env -qaP -A nixos.pkgs.haskellPackages
$ nix-env -iA nixos.pkgs.haskellPackages.cabal-install
</programlisting>
<para>
Our current default compiler is GHC 7.10.x and the
<literal>haskellPackages</literal> set contains packages built with
that particular version. Nixpkgs contains the latest major release
of every GHC since 6.10.4, however, and there is a whole family of
package sets available that defines Hackage packages built with each
of those compilers, too:
</para>
<programlisting>
$ nix-env -f &quot;&lt;nixpkgs&gt;&quot; -qaP -A haskell.packages.ghc6123
$ nix-env -f &quot;&lt;nixpkgs&gt;&quot; -qaP -A haskell.packages.ghc763
</programlisting>
<para>
The name <literal>haskellPackages</literal> is really just a synonym
for <literal>haskell.packages.ghc7101</literal>, because we prefer
that package set internally and recommend it to our users as their
default choice, but ultimately you are free to compile your Haskell
packages with any GHC version you please. The following command
displays the complete list of available compilers:
</para>
<programlisting>
$ nix-env -f &quot;&lt;nixpkgs&gt;&quot; -qaP -A haskell.compiler
haskell.compiler.ghc6104 ghc-6.10.4
haskell.compiler.ghc6123 ghc-6.12.3
haskell.compiler.ghc704 ghc-7.0.4
haskell.compiler.ghc722 ghc-7.2.2
haskell.compiler.ghc742 ghc-7.4.2
haskell.compiler.ghc763 ghc-7.6.3
haskell.compiler.ghc784 ghc-7.8.4
haskell.compiler.ghc7101 ghc-7.10.1
haskell.compiler.ghcHEAD ghc-7.11.20150402
haskell.compiler.ghcjs ghcjs-0.1.0
haskell.compiler.jhc jhc-0.8.2
haskell.compiler.uhc uhc-1.1.9.0
</programlisting>
<para>
We have no package sets for <literal>jhc</literal> or
<literal>uhc</literal> yet, unfortunately, but for every version of
GHC listed above, there exists a package set based on that compiler.
Also, the attributes <literal>haskell.compiler.ghcXYC</literal> and
<literal>haskell.packages.ghcXYC.ghc</literal> are synonymous for
the sake of convenience.
</para>
</section>
<section xml:id="how-to-create-a-development-environment">
<title>How to create a development environment</title>
<section xml:id="how-to-install-a-compiler">
<title>How to install a compiler</title>
<para>
A simple development environment consists of a Haskell compiler
and the tool <literal>cabal-install</literal>, and we saw in
section <link linkend="how-to-install-haskell-packages">How to
install Haskell packages</link> how you can install those programs
into your user profile:
</para>
<programlisting>
$ nix-env -f &quot;&lt;nixpkgs&gt;&quot; -iA haskellPackages.ghc haskellPackages.cabal-install
</programlisting>
<para>
Instead of the default package set
<literal>haskellPackages</literal>, you can also use the more
precise name <literal>haskell.compiler.ghc7101</literal>, which
has the advantage that it refers to the same GHC version
regardless of what Nixpkgs considers &quot;default&quot; at any
given time.
</para>
<para>
Once you've made those tools available in
<literal>$PATH</literal>, it's possible to build Hackage packages
the same way people without access to Nix do it all the time:
</para>
<programlisting>
$ cabal get lens-4.11 &amp;&amp; cd lens-4.11
$ cabal install -j --dependencies-only
$ cabal configure
$ cabal build
</programlisting>
<para>
If you enjoy working with Cabal sandboxes, then that's entirely
possible too: just execute the command
</para>
<programlisting>
$ cabal sandbox init
</programlisting>
<para>
before installing the required dependencies.
</para>
<para>
The <literal>nix-shell</literal> utility makes it easy to switch
to a different compiler version; just enter the Nix shell
environment with the command
</para>
<programlisting>
$ nix-shell -p haskell.compiler.ghc784
</programlisting>
<para>
to bring GHC 7.8.4 into <literal>$PATH</literal>. Re-running
<literal>cabal configure</literal> switches your build to use that
compiler instead. If you're working on a project that doesn't
depend on any additional system libraries outside of GHC, then
it's sufficient even to run the <literal>cabal configure</literal>
command inside of the shell:
</para>
<programlisting>
$ nix-shell -p haskell.compiler.ghc784 --command &quot;cabal configure&quot;
</programlisting>
<para>
Afterwards, all other commands like <literal>cabal build</literal>
work just fine in any shell environment, because the configure
phase recorded the absolute paths to all required tools like GHC
in its build configuration inside of the <literal>dist/</literal>
directory. Please note, however, that
<literal>nix-collect-garbage</literal> can break such an
environment because the Nix store paths created by
<literal>nix-shell</literal> aren't &quot;alive&quot; anymore once
<literal>nix-shell</literal> has terminated. If you find that your
Haskell builds no longer work after garbage collection, then
you'll have to re-run <literal>cabal configure</literal> inside of
a new <literal>nix-shell</literal> environment.
</para>
</section>
<section xml:id="how-to-install-a-compiler-with-libraries">
<title>How to install a compiler with libraries</title>
<para>
GHC expects to find all installed libraries inside of its own
<literal>lib</literal> directory. This approach works fine on
traditional Unix systems, but it doesn't work for Nix, because
GHC's store path is immutable once it's built. We cannot install
additional libraries into that location. As a consequence, our
copies of GHC don't know any packages except their own core
libraries, like <literal>base</literal>,
<literal>containers</literal>, <literal>Cabal</literal>, etc.
</para>
<para>
We can register additional libraries to GHC, however, using a
special build function called <literal>ghcWithPackages</literal>.
That function expects one argument: a function that maps from an
attribute set of Haskell packages to a list of packages, which
determines the libraries known to that particular version of GHC.
For example, the Nix expression
<literal>ghcWithPackages (pkgs: [pkgs.mtl])</literal> generates a
copy of GHC that has the <literal>mtl</literal> library registered
in addition to its normal core packages:
</para>
<programlisting>
$ nix-shell -p &quot;haskellPackages.ghcWithPackages (pkgs: [pkgs.mtl])&quot;
[nix-shell:~]$ ghc-pkg list mtl
/nix/store/zy79...-ghc-7.10.1/lib/ghc-7.10.1/package.conf.d:
mtl-2.2.1
</programlisting>
<para>
This function allows users to define their own development
environment by means of an override. After adding the following
snippet to <literal>~/.nixpkgs/config.nix</literal>,
</para>
<programlisting>
{
packageOverrides = super: let self = super.pkgs; in
{
myHaskellEnv = self.haskell.packages.ghc7101.ghcWithPackages
(haskellPackages: with haskellPackages; [
# libraries
arrows async cgi criterion
# tools
cabal-install haskintex
]);
};
}
</programlisting>
<para>
it's possible to install that compiler with
<literal>nix-env -f &quot;&lt;nixpkgs&gt;&quot; -iA myHaskellEnv</literal>.
If you'd like to switch that development environment to a
different version of GHC, just replace the
<literal>ghc7101</literal> bit in the previous definition with the
appropriate name. Of course, it's also possible to define any
number of these development environments! (You can't install two
of them into the same profile at the same time, though, because
that would result in file conflicts.)
</para>
<para>
The generated <literal>ghc</literal> program is a wrapper script
that re-directs the real GHC executable to use a new
<literal>lib</literal> directory --- one that we specifically
constructed to contain all those packages the user requested:
</para>
<programlisting>
$ cat $(type -p ghc)
#! /nix/store/xlxj...-bash-4.3-p33/bin/bash -e
export NIX_GHC=/nix/store/19sm...-ghc-7.10.1/bin/ghc
export NIX_GHCPKG=/nix/store/19sm...-ghc-7.10.1/bin/ghc-pkg
export NIX_GHC_DOCDIR=/nix/store/19sm...-ghc-7.10.1/share/doc/ghc/html
export NIX_GHC_LIBDIR=/nix/store/19sm...-ghc-7.10.1/lib/ghc-7.10.1
exec /nix/store/j50p...-ghc-7.10.1/bin/ghc &quot;-B$NIX_GHC_LIBDIR&quot; &quot;$@&quot;
</programlisting>
<para>
The variables <literal>$NIX_GHC</literal>,
<literal>$NIX_GHCPKG</literal>, etc. point to the
<emphasis>new</emphasis> store path
<literal>ghcWithPackages</literal> constructed specifically for
this environment. The last line of the wrapper script then
executes the real <literal>ghc</literal>, but passes the path to
the new <literal>lib</literal> directory using GHC's
<literal>-B</literal> flag.
</para>
<para>
The purpose of those environment variables is to work around an
impurity in the popular
<link xlink:href="http://hackage.haskell.org/package/ghc-paths">ghc-paths</link>
library. That library promises to give its users access to GHC's
installation paths. Only, the library can't possible know that
path when it's compiled, because the path GHC considers its own is
determined only much later, when the user configures it through
<literal>ghcWithPackages</literal>. So we
<link xlink:href="https://github.com/NixOS/nixpkgs/blob/master/pkgs/development/haskell-modules/ghc-paths-nix.patch">patched
ghc-paths</link> to return the paths found in those environment
variables at run-time rather than trying to guess them at
compile-time.
</para>
<para>
To make sure that mechanism works properly all the time, we
recommend that you set those variables to meaningful values in
your shell environment, too, i.e. by adding the following code to
your <literal>~/.bashrc</literal>:
</para>
<programlisting>
if type &gt;/dev/null 2&gt;&amp;1 -p ghc; then
eval &quot;$(egrep ^export &quot;$(type -p ghc)&quot;)&quot;
fi
</programlisting>
<para>
If you are certain that you'll use only one GHC environment which
is located in your user profile, then you can use the following
code, too, which has the advantage that it doesn't contain any
paths from the Nix store, i.e. those settings always remain valid
even if a <literal>nix-env -u</literal> operation updates the GHC
environment in your profile:
</para>
<programlisting>
if [ -e ~/.nix-profile/bin/ghc ]; then
export NIX_GHC=&quot;$HOME/.nix-profile/bin/ghc&quot;
export NIX_GHCPKG=&quot;$HOME/.nix-profile/bin/ghc-pkg&quot;
export NIX_GHC_DOCDIR=&quot;$HOME/.nix-profile/share/doc/ghc/html&quot;
export NIX_GHC_LIBDIR=&quot;$HOME/.nix-profile/lib/ghc-$($NIX_GHC --numeric-version)&quot;
fi
</programlisting>
</section>
<section xml:id="how-to-create-ad-hoc-environments-for-nix-shell">
<title>How to create ad hoc environments for
<literal>nix-shell</literal></title>
<para>
The easiest way to create an ad hoc development environment is to
run <literal>nix-shell</literal> with the appropriate GHC
environment given on the command-line:
</para>
<programlisting>
nix-shell -p &quot;haskellPackages.ghcWithPackages (pkgs: with pkgs; [mtl pandoc])&quot;
</programlisting>
<para>
For more sophisticated use-cases, however, it's more convenient to
save the desired configuration in a file called
<literal>shell.nix</literal> that looks like this:
</para>
<programlisting>
{ nixpkgs ? import &lt;nixpkgs&gt; {}, compiler ? &quot;ghc7101&quot; }:
let
inherit (nixpkgs) pkgs;
ghc = pkgs.haskell.packages.${compiler}.ghcWithPackages (ps: with ps; [
monad-par mtl
]);
in
pkgs.stdenv.mkDerivation {
name = &quot;my-haskell-env-0&quot;;
buildInputs = [ ghc ];
shellHook = &quot;eval $(egrep ^export ${ghc}/bin/ghc)&quot;;
}
</programlisting>
<para>
Now run <literal>nix-shell</literal> --- or even
<literal>nix-shell --pure</literal> --- to enter a shell
environment that has the appropriate compiler in
<literal>$PATH</literal>. If you use <literal>--pure</literal>,
then add all other packages that your development environment
needs into the <literal>buildInputs</literal> attribute. If you'd
like to switch to a different compiler version, then pass an
appropriate <literal>compiler</literal> argument to the
expression, i.e.
<literal>nix-shell --argstr compiler ghc784</literal>.
</para>
<para>
If you need such an environment because you'd like to compile a
Hackage package outside of Nix --- i.e. because you're hacking on
the latest version from Git ---, then the package set provides
suitable nix-shell environments for you already! Every Haskell
package has an <literal>env</literal> attribute that provides a
shell environment suitable for compiling that particular package.
If you'd like to hack the <literal>lens</literal> library, for
example, then you just have to check out the source code and enter
the appropriate environment:
</para>
<programlisting>
$ cabal get lens-4.11 &amp;&amp; cd lens-4.11
Downloading lens-4.11...
Unpacking to lens-4.11/
$ nix-shell &quot;&lt;nixpkgs&gt;&quot; -A haskellPackages.lens.env
[nix-shell:/tmp/lens-4.11]$
</programlisting>
<para>
At point, you can run <literal>cabal configure</literal>,
<literal>cabal build</literal>, and all the other development
commands. Note that you need <literal>cabal-install</literal>
installed in your <literal>$PATH</literal> already to use it here
--- the <literal>nix-shell</literal> environment does not provide
it.
</para>
</section>
</section>
<section xml:id="how-to-create-nix-builds-for-your-own-private-haskell-packages">
<title>How to create Nix builds for your own private Haskell
packages</title>
<para>
If your own Haskell packages have build instructions for Cabal, then
you can convert those automatically into build instructions for Nix
using the <literal>cabal2nix</literal> utility, which you can
install into your profile by running
<literal>nix-env -i cabal2nix</literal>.
</para>
<section xml:id="how-to-build-a-stand-alone-project">
<title>How to build a stand-alone project</title>
<para>
For example, let's assume that you're working on a private project
called <literal>foo</literal>. To generate a Nix build expression
for it, change into the project's top-level directory and run the
command:
</para>
<programlisting>
$ cabal2nix . &gt;foo.nix
</programlisting>
<para>
Then write the following snippet into a file called
<literal>default.nix</literal>:
</para>
<programlisting>
{ nixpkgs ? import &lt;nixpkgs&gt; {}, compiler ? &quot;ghc7101&quot; }:
nixpkgs.pkgs.haskell.packages.${compiler}.callPackage ./foo.nix { }
</programlisting>
<para>
Finally, store the following code in a file called
<literal>shell.nix</literal>:
</para>
<programlisting>
{ nixpkgs ? import &lt;nixpkgs&gt; {}, compiler ? &quot;ghc7101&quot; }:
(import ./default.nix { inherit nixpkgs compiler; }).env
</programlisting>
<para>
At this point, you can run <literal>nix-build</literal> to have
Nix compile your project and install it into a Nix store path. The
local directory will contain a symlink called
<literal>result</literal> after <literal>nix-build</literal>
returns that points into that location. Of course, passing the
flag <literal>--argstr compiler ghc763</literal> allows switching
the build to any version of GHC currently supported.
</para>
<para>
Furthermore, you can call <literal>nix-shell</literal> to enter an
interactive development environment in which you can use
<literal>cabal configure</literal> and
<literal>cabal build</literal> to develop your code. That
environment will automatically contain a proper GHC derivation
with all the required libraries registered as well as all the
system-level libraries your package might need.
</para>
<para>
If your package does not depend on any system-level libraries,
then it's sufficient to run
</para>
<programlisting>
$ nix-shell --command &quot;cabal configure&quot;
</programlisting>
<para>
once to set up your build. <literal>cabal-install</literal>
determines the absolute paths to all resources required for the
build and writes them into a config file in the
<literal>dist/</literal> directory. Once that's done, you can run
<literal>cabal build</literal> and any other command for that
project even outside of the <literal>nix-shell</literal>
environment. This feature is particularly nice for those of us who
like to edit their code with an IDE, like Emacs'
<literal>haskell-mode</literal>, because it's not necessary to
start Emacs inside of nix-shell just to make it find out the
necessary settings for building the project;
<literal>cabal-install</literal> has already done that for us.
</para>
<para>
If you want to do some quick-and-dirty hacking and don't want to
bother setting up a <literal>default.nix</literal> and
<literal>shell.nix</literal> file manually, then you can use the
<literal>--shell</literal> flag offered by
<literal>cabal2nix</literal> to have it generate a stand-alone
<literal>nix-shell</literal> environment for you. With that
feature, running
</para>
<programlisting>
$ cabal2nix --shell . &gt;shell.nix
$ nix-shell --command &quot;cabal configure&quot;
</programlisting>
<para>
is usually enough to set up a build environment for any given
Haskell package. You can even use that generated file to run
<literal>nix-build</literal>, too:
</para>
<programlisting>
$ nix-build shell.nix
</programlisting>
</section>
<section xml:id="how-to-build-projects-that-depend-on-each-other">
<title>How to build projects that depend on each other</title>
<para>
If you have multiple private Haskell packages that depend on each
other, then you'll have to register those packages in the Nixpkgs
set to make them visible for the dependency resolution performed
by <literal>callPackage</literal>. First of all, change into each
of your projects top-level directories and generate a
<literal>default.nix</literal> file with
<literal>cabal2nix</literal>:
</para>
<programlisting>
$ cd ~/src/foo &amp;&amp; cabal2nix . &gt;default.nix
$ cd ~/src/bar &amp;&amp; cabal2nix . &gt;default.nix
</programlisting>
<para>
Then edit your <literal>~/.nixpkgs/config.nix</literal> file to
register those builds in the default Haskell package set:
</para>
<programlisting>
{
packageOverrides = super: let self = super.pkgs; in
{
haskellPackages = super.haskellPackages.override {
overrides = self: super: {
foo = self.callPackage ../src/foo {};
bar = self.callPackage ../src/bar {};
};
};
};
}
</programlisting>
<para>
Once that's accomplished,
<literal>nix-env -f &quot;&lt;nixpkgs&gt;&quot; -qA haskellPackages</literal>
will show your packages like any other package from Hackage, and
you can build them
</para>
<programlisting>
$ nix-build &quot;&lt;nixpkgs&gt;&quot; -A haskellPackages.foo
</programlisting>
<para>
or enter an interactive shell environment suitable for building
them:
</para>
<programlisting>
$ nix-shell &quot;&lt;nixpkgs&gt;&quot; -A haskellPackages.bar.env
</programlisting>
</section>
</section>
<section xml:id="miscellaneous-topics">
<title>Miscellaneous Topics</title>
<section xml:id="how-to-build-with-profiling-enabled">
<title>How to build with profiling enabled</title>
<para>
Every Haskell package set takes a function called
<literal>overrides</literal> that you can use to manipulate the
package as much as you please. One useful application of this
feature is to replace the default <literal>mkDerivation</literal>
function with one that enables library profiling for all packages.
To accomplish that, add configure the following snippet in your
<literal>~/.nixpkgs/config.nix</literal> file:
</para>
<programlisting>
{
packageOverrides = super: let self = super.pkgs; in
{
profiledHaskellPackages = self.haskellPackages.override {
overrides = self: super: {
mkDerivation = args: super.mkDerivation (args // {
enableLibraryProfiling = true;
});
};
};
};
}
</programlisting>
</section>
<section xml:id="how-to-override-package-versions-in-a-compiler-specific-package-set">
<title>How to override package versions in a compiler-specific
package set</title>
<para>
Nixpkgs provides the latest version of
<link xlink:href="http://hackage.haskell.org/package/ghc-events"><literal>ghc-events</literal></link>,
which is 0.4.4.0 at the time of this writing. This is fine for
users of GHC 7.10.x, but GHC 7.8.4 cannot compile that binary.
Now, one way to solve that problem is to register an older version
of <literal>ghc-events</literal> in the 7.8.x-specific package
set. The first step is to generate Nix build instructions with
<literal>cabal2nix</literal>:
</para>
<programlisting>
$ cabal2nix cabal://ghc-events-0.4.3.0 &gt;~/.nixpkgs/ghc-events-0.4.3.0.nix
</programlisting>
<para>
Then add the override in <literal>~/.nixpkgs/config.nix</literal>:
</para>
<programlisting>
{
packageOverrides = super: let self = super.pkgs; in
{
haskell = super.haskell // {
packages = super.haskell.packages // {
ghc784 = super.haskell.packages.ghc784.override {
overrides = self: super: {
ghc-events = self.callPackage ./ghc-events-0.4.3.0.nix {};
};
};
};
};
};
}
</programlisting>
<para>
This code is a little crazy, no doubt, but it's necessary because
the intuitive version
</para>
<programlisting>
haskell.packages.ghc784 = super.haskell.packages.ghc784.override {
overrides = self: super: {
ghc-events = self.callPackage ./ghc-events-0.4.3.0.nix {};
};
};
</programlisting>
<para>
doesn't do what we want it to: that code replaces the
<literal>haskell</literal> package set in Nixpkgs with one that
contains only one entry,<literal>packages</literal>, which
contains only one entry <literal>ghc784</literal>. This override
loses the <literal>haskell.compiler</literal> set, and it loses
the <literal>haskell.packages.ghcXYZ</literal> sets for all
compilers but GHC 7.8.4. To avoid that problem, we have to perform
the convoluted little dance from above, iterating over each step
in hierarchy.
</para>
<para>
Once it's accomplished, however, we can install a variant of
<literal>ghc-events</literal> that's compiled with GHC 7.8.4:
</para>
<programlisting>
nix-env -f &quot;&lt;nixpkgs&gt;&quot; -iA haskell.packages.ghc784.ghc-events
</programlisting>
<para>
Unfortunately, it turns out that this build fails again while
executing the test suite! Apparently, the release archive on
Hackage is missing some data files that the test suite requires,
so we cannot run it. We accomplish that by re-generating the Nix
expression with the <literal>--no-check</literal> flag:
</para>
<programlisting>
$ cabal2nix --no-check cabal://ghc-events-0.4.3.0 &gt;~/.nixpkgs/ghc-events-0.4.3.0.nix
</programlisting>
<para>
Now the builds succeeds.
</para>
<para>
Of course, in the concrete example of
<literal>ghc-events</literal> this whole exercise is not an ideal
solution, because <literal>ghc-events</literal> can analyze the
output emitted by any version of GHC later than 6.12 regardless of
the compiler version that was used to build the `ghc-events'
executable, so strictly speaking there's no reason to prefer one
built with GHC 7.8.x in the first place. However, for users who
cannot use GHC 7.10.x at all for some reason, the approach of
downgrading to an older version might be useful.
</para>
</section>
<section xml:id="how-to-recover-from-ghcs-infamous-non-deterministic-library-id-bug">
<title>How to recover from GHC's infamous non-deterministic library
ID bug</title>
<para>
GHC and distributed build farms don't get along well:
</para>
<programlisting>
https://ghc.haskell.org/trac/ghc/ticket/4012
</programlisting>
<para>
When you see an error like this one
</para>
<programlisting>
package foo-0.7.1.0 is broken due to missing package
text-1.2.0.4-98506efb1b9ada233bb5c2b2db516d91
</programlisting>
<para>
then you have to download and re-install <literal>foo</literal>
and all its dependents from scratch:
</para>
<programlisting>
# nix-store -q --referrers /nix/store/*-haskell-text-1.2.0.4 \
| nix-store --repair-path --option binary-caches http://hydra.nixos.org
</programlisting>
<para>
If you're using additional Hydra servers other than
<literal>hydra.nixos.org</literal>, then it might be necessary to
purge the local caches that store data from those machines to
disable these binary channels for the duration of the previous
command, i.e. by running:
</para>
<programlisting>
rm /nix/var/nix/binary-cache-v3.sqlite
rm /nix/var/nix/manifests/*
rm /nix/var/nix/channel-cache/*
</programlisting>
</section>
<section xml:id="builds-on-darwin-fail-with-math.h-not-found">
<title>Builds on Darwin fail with <literal>math.h</literal> not
found</title>
<para>
Users of GHC on Darwin have occasionally reported that builds
fail, because the compiler complains about a missing include file:
</para>
<programlisting>
fatal error: 'math.h' file not found
</programlisting>
<para>
The issue has been discussed at length in
<link xlink:href="https://github.com/NixOS/nixpkgs/issues/6390">ticket
6390</link>, and so far no good solution has been proposed. As a
work-around, users who run into this problem can configure the
environment variables
</para>
<programlisting>
export NIX_CFLAGS_COMPILE=&quot;-idirafter /usr/include&quot;
export NIX_CFLAGS_LINK=&quot;-L/usr/lib&quot;
</programlisting>
<para>
in their <literal>~/.bashrc</literal> file to avoid the compiler
error.
</para>
</section>
</section>
</chapter>

6
doc/language-support.xml
View File

@ -257,7 +257,7 @@ are provided with all modules included.</para>
<term><varname>buildEnv</varname></term>
<listitem><para>
Function to build python interpreter environments with extra packages bundled together.
See <xref linkend="python-build-env" /> for usage and documentation.
See <xref linkend="ssec-python-build-env" /> for usage and documentation.
</para></listitem>
</varlistentry>
@ -587,7 +587,7 @@ sed -i '/ = data_files/d' setup.py</programlisting>
<listitem><para>
There is no need to have global site-packages in Nix. Each package has isolated
dependency tree and installing any python package will only populate <varname>$PATH</varname>
inside user environment. See <xref linkend="python-build-env" /> to create self-contained
inside user environment. See <xref linkend="ssec-python-build-env" /> to create self-contained
interpreter with a set of packages.
</para></listitem>
</varlistentry>
@ -876,7 +876,7 @@ Runtime) instead of the OpenJRE.</para>
in <link xlink:href="https://github.com/NixOS/nixpkgs/blob/master/pkgs/development/lua-modules/generic/default.nix">
<filename>pkgs/development/lua-modules/generic/default.nix</filename></link>
and works similarly to <varname>buildPerlPackage</varname>. (See
<xref linkend="ssec-language-perl"/> for details.)
<xref linkend="sec-language-perl"/> for details.)
</para>
<para>

1
doc/manual.xml
View File

@ -18,5 +18,6 @@
<xi:include href="package-notes.xml" />
<xi:include href="coding-conventions.xml" />
<xi:include href="contributing.xml" />
<xi:include href="haskell-users-guide.xml" />
</book>

2
doc/stdenv.xml
View File

@ -59,7 +59,7 @@ build. To make this easier, the standard environment breaks the
package build into a number of <emphasis>phases</emphasis>, all of
which can be overridden or modified individually: unpacking the
sources, applying patches, configuring, building, and installing.
(There are some others; see <xref linkend="ssec-stdenv-phases"/>.)
(There are some others; see <xref linkend="sec-stdenv-phases"/>.)
For instance, a package that doesn’t supply a makefile but instead has
to be compiled “manually” could be handled like this:

23
lib/customisation.nix
View File

@ -158,27 +158,4 @@ rec {
drv' = (lib.head outputsList).value;
in lib.deepSeq drv' drv';
/* Tests whether a derivation can be used by the current platform
Returns the derivation if true, otherwise null. */
shouldUsePkgSystem = system: pkg_: let pkg = (builtins.tryEval pkg_).value;
in if lib.any (x: x == system) (pkg.meta.platforms or [])
then pkg
else null;
/* Returns a configure flag string in an autotools format
trueStr: Prepended when cond is true
falseStr: Prepended when cond is false
cond: The condition for the prepended string type and value
name: The flag name
val: The value of the flag only set when cond is true */
mkFlag = trueStr: falseStr: cond: name: val:
if cond == null then null else
"--${if cond != false then trueStr else falseStr}${name}"
+ "${if val != null && cond != false then "=${val}" else ""}";
/* Flag setting helpers for autotools like packages */
mkEnable = mkFlag "enable-" "disable-";
mkWith = mkFlag "with-" "without-";
mkOther = mkFlag "" "" true;
}

3
lib/maintainers.nix
View File

@ -4,7 +4,6 @@
/* Add your name and email address here. Keep the list
alphabetically sorted. */
_1126 = "Christian Lask <mail@elfsechsundzwanzig.de>";
abaldeau = "Andreas Baldeau <andreas@baldeau.net>";
abbradar = "Nikolay Amiantov <ab@fmap.me>";
aforemny = "Alexander Foremny <alexanderforemny@googlemail.com>";
@ -93,8 +92,10 @@
goibhniu = "Cillian de Róiste <cillian.deroiste@gmail.com>";
gridaphobe = "Eric Seidel <eric@seidel.io>";
guibert = "David Guibert <david.guibert@gmail.com>";
havvy = "Ryan Scheel <ryan.havvy@gmail.com>";
hbunke = "Hendrik Bunke <bunke.hendrik@gmail.com>";
henrytill = "Henry Till <henrytill@gmail.com>";
hiberno = "Christian Lask <mail@elfsechsundzwanzig.de>";
hinton = "Tom Hinton <t@larkery.com>";
hrdinka = "Christoph Hrdinka <c.nix@hrdinka.at>";
iand675 = "Ian Duncan <ian@iankduncan.com>";

18
nixos/doc/manual/installation/installing.xml
View File

@ -120,7 +120,11 @@ $ nixos-generate-config --root /mnt</screen>
$ nano /mnt/etc/nixos/configuration.nix
</screen>
The <command>vim</command> text editor is also available.</para>
If you’re using the graphical ISO image, other editors may be
available (such as <command>vim</command>). If you have network
access, you can also install other editors — for instance, you can
install Emacs by running <literal>nix-env -i
emacs</literal>.</para>
<para>You <emphasis>must</emphasis> set the option
<option>boot.loader.grub.device</option> to specify on which disk
@ -189,11 +193,13 @@ $ reboot</screen>
<listitem>
<para>You should now be able to boot into the installed NixOS. The GRUB boot menu shows a list
of <emphasis>available configurations</emphasis> (initially just one). Every time
you change the NixOS configuration (see<link linkend="sec-changing-config">Changing
Configuration</link> ), a new item appears in the menu. This allows you to
easily roll back to another configuration if something goes wrong.</para>
<para>You should now be able to boot into the installed NixOS. The
GRUB boot menu shows a list of <emphasis>available
configurations</emphasis> (initially just one). Every time you
change the NixOS configuration (see <link
linkend="sec-changing-config">Changing Configuration</link> ), a
new item is added to the menu. This allows you to easily roll back
to a previous configuration if something goes wrong.</para>
<para>You should log in and change the <literal>root</literal>
password with <command>passwd</command>.</para>

85
nixos/doc/manual/release-notes/rl-unstable.xml
View File

@ -8,9 +8,32 @@
<para>In addition to numerous new and upgraded packages, this release has the following highlights:
<!--<itemizedlist>
<itemizedlist>
<listitem>
<para>
The Haskell packages infrastructure has been re-designed from the ground up.
NixOS now distributes the latest version of every single package registered on
<link xlink:href="http://hackage.haskell.org/">Hackage</link>, i.e. well over
8000 Haskell packages. Further information and usage instructions for the
improved infrastructure are available at <link
xlink:href="https://nixos.org/wiki/Haskell">https://nixos.org/wiki/Haskell</link>.
Users migrating from an earlier release will find also find helpful information
below, in the list of backwards-incompatible changes.
</para>
</listitem>
<listitem>
<para>
Users running an SSH server who worry about the quality of their
<literal>/etc/ssh/moduli</literal> file with respect to the <link
xlink:href="https://stribika.github.io/2015/01/04/secure-secure-shell.html">vulnerabilities
discovered in the Diffie-Hellman key exchange</link> can now replace OpenSSH's
default version with one they generated themselves using the new
<literal>services.openssh.moduliFile</literal> option.
</para>
</listitem>
</itemizedlist>
</itemizedlist>-->
</para>
<para>Following new services were added since the last release:
@ -71,6 +94,64 @@ was accordingly renamed to <literal>bomi</literal>
</para>
</listitem>
<listitem>
<para>
Haskell packages can no longer be found by name, i.e. the commands
<literal>nix-env -qa cabal-install</literal> and <literal>nix-env -i
ghc</literal> will fail, even though we <emphasis>do</emphasis> ship
both <literal>cabal-install</literal> and <literal>ghc</literal>.
The reason for this inconvenience is the sheer size of the Haskell
package set: name-based lookups such as these would become much
slower than they are today if we'd add the entire Hackage database
into the top level attribute set. Instead, the list of Haskell
packages can be displayed by
</para>
<programlisting>
nix-env -f &quot;&lt;nixpkgs&gt;&quot; -qaP -A haskellPackages
</programlisting>
<para>
and packages can be installed with:
</para>
<programlisting>
nix-env -f &quot;&lt;nixpkgs&gt;&quot; -iA haskellPackages.cabal-install
</programlisting>
</listitem>
<listitem>
<para>
Previous versions of NixOS come with a feature called
<literal>ghc-wrapper</literal>, a small wrapper script that allows
GHC to transparently pick up on libraries installed in the user's
profile. This feature has been deprecated;
<literal>ghc-wrapper</literal> was removed from the distribution.
The proper way to register Haskell libraries with the compiler now
is the <literal>haskellPackages.ghcWithPackages</literal>
function.
<link xlink:href="https://nixos.org/wiki/Haskell">https://nixos.org/wiki/Haskell</link>
provides much information about this subject.
</para>
</listitem>
<listitem>
<para>
All Haskell builds that have been generated with version 1.x of
the <literal>cabal2nix</literal> utility are now invalid and need
to be re-generated with a current version of
<literal>cabal2nix</literal> to function. The most recent version
of this tool can be installed by running
<literal>nix-env -i cabal2nix</literal>.
</para>
</listitem>
<listitem>
<para>
The <literal>haskellPackages</literal> set in Nixpkgs used to have a
function attribute called <literal>extension</literal> that users
could override in their <literal>~/.nixpkgs/config.nix</literal>
files to configure additional attributes, etc. That function still
exists, but it's now called <literal>overrides</literal>.
</para>
</listitem>
</itemizedlist>
</para>

8
nixos/modules/config/pulseaudio.nix
View File

@ -89,12 +89,12 @@ in {
package = mkOption {
type = types.package;
default = pulseaudioFull;
default = pulseaudioLight;
example = literalExample "pkgs.pulseaudioFull";
description = ''
The PulseAudio derivation to use. This can be used to disable
features (such as JACK support, Bluetooth) that are enabled in the
pulseaudioFull package in Nixpkgs.
The PulseAudio derivation to use. This can be used to enable
features (such as JACK support, Bluetooth) via the
<literal>pulseaudioFull</literal> package.
'';
};

17
nixos/modules/installer/cd-dvd/installation-cd-graphical.nix
View File

@ -11,9 +11,16 @@ with lib;
# Provide wicd for easy wireless configuration.
#networking.wicd.enable = true;
# Include gparted for partitioning disks
environment.systemPackages = [ pkgs.gparted ];
environment.systemPackages =
[ # Include gparted for partitioning disks.
pkgs.gparted
# Include some editors.
pkgs.vim
pkgs.bvi # binary editor
pkgs.joe
];
# Provide networkmanager for easy wireless configuration.
networking.networkmanager.enable = true;
networking.wireless.enable = mkForce false;
@ -67,7 +74,7 @@ with lib;
loadTemplate("org.kde.plasma-desktop.defaultPanel")
for (var i = 0; i < screenCount; ++i) {
var desktop = new Activity
var desktop = new Activity
desktop.name = i18n("Desktop")
desktop.screen = i
desktop.wallpaperPlugin = 'image'
@ -75,7 +82,7 @@ with lib;
var folderview = desktop.addWidget("folderview");
folderview.writeConfig("url", "desktop:/");
//Create more panels for other screens
if (i > 0){
var panel = new Panel

5
nixos/modules/installer/cd-dvd/installation-cd-minimal.nix
View File

@ -1,11 +1,14 @@
# This module defines a small NixOS installation CD. It does not
# contain any graphical stuff.
{ config, pkgs, ... }:
{ config, pkgs, lib, ... }:
{
imports =
[ ./installation-cd-base.nix
../../profiles/minimal.nix
];
# Enable in installer, even if minimal profile disables it
services.nixosManual.enable = lib.mkOverride 999 true;
}

5
nixos/modules/profiles/base.nix
View File

@ -44,11 +44,6 @@
pkgs.zip
pkgs.dar # disk archiver
pkgs.cabextract
# Some editors.
pkgs.vim
pkgs.bvi # binary editor
pkgs.joe
];
# Include support for various filesystems.

4
nixos/modules/security/ca.nix
View File

@ -22,7 +22,7 @@ in
security.pki.certificateFiles = mkOption {
type = types.listOf types.path;
default = [];
example = literalExample "[ \"\${pkgs.cacert}/ca-bundle.crt\" ]";
example = literalExample "[ \"\${pkgs.cacert}/etc/ssl/certs/ca-bundle.crt\" ]";
description = ''
A list of files containing trusted root certificates in PEM
format. These are concatenated to form
@ -53,7 +53,7 @@ in
config = {
security.pki.certificateFiles = [ "${pkgs.cacert}/ca-bundle.crt" ];
security.pki.certificateFiles = [ "${pkgs.cacert}/etc/ssl/certs/ca-bundle.crt" ];
# NixOS canonical location + Debian/Ubuntu/Arch/Gentoo compatibility.
environment.etc."ssl/certs/ca-certificates.crt".source = caBundle;

3
nixos/modules/services/misc/mwlib.nix
View File

@ -226,10 +226,11 @@ in
chmod -Rc u=rwX,go= '${cfg.nslave.cachedir}'
'';
path = with pkgs; [ imagemagick ];
environment = {
PYTHONPATH = concatMapStringsSep ":"
(m: "${pypkgs.${m}}/lib/${python.libPrefix}/site-packages")
[ "mwlib-rl" "mwlib-ext" "pygments" ];
[ "mwlib-rl" "mwlib-ext" "pygments" "pyfribidi" ];
};
serviceConfig = {

2
nixos/modules/services/misc/nix-daemon.nix
View File

@ -63,7 +63,7 @@ in
package = mkOption {
type = types.package;
default = pkgs.nix;
default = pkgs.nixUnstable;
description = ''
This option specifies the Nix package instance to use throughout the system.
'';

2
nixos/modules/services/monitoring/apcupsd.nix
View File

@ -39,7 +39,7 @@ let
shellCmdsForEventScript = eventname: commands: ''
echo "#!${pkgs.stdenv.shell}" > "$out/${eventname}"
echo "${commands}" >> "$out/${eventname}"
echo '${commands}' >> "$out/${eventname}"
chmod a+x "$out/${eventname}"
'';

33
nixos/modules/services/scheduling/marathon.nix
View File

@ -19,14 +19,6 @@ in {
'';
};
httpPort = mkOption {
type = types.int;
default = 8080;
description = ''
Marathon listening port for HTTP connections.
'';
};
master = mkOption {
type = types.str;
default = "zk://${concatStringsSep "," cfg.zookeeperHosts}/mesos";
@ -45,6 +37,25 @@ in {
'';
};
user = mkOption {
type = types.str;
default = "marathon";
example = "root";
description = ''
The user that the Marathon framework will be launched as. If the user doesn't exist it will be created.
If you want to run apps that require root access or you want to launch apps using arbitrary users, that
is using the `--mesos_user` flag then you need to change this to `root`.
'';
};
httpPort = mkOption {
type = types.int;
default = 8080;
description = ''
Marathon listening port for HTTP connections.
'';
};
extraCmdLineOptions = mkOption {
type = types.listOf types.str;
default = [ ];
@ -76,14 +87,12 @@ in {
serviceConfig = {
ExecStart = "${pkgs.marathon}/bin/marathon --master ${cfg.master} --zk zk://${concatStringsSep "," cfg.zookeeperHosts}/marathon --http_port ${toString cfg.httpPort} ${concatStringsSep " " cfg.extraCmdLineOptions}";
User = "marathon";
User = cfg.user;
Restart = "always";
RestartSec = "2";
};
};
users.extraUsers.marathon = {
description = "Marathon mesos framework user";
};
users.extraUsers.${cfg.user} = { };
};
}

12
nixos/modules/system/activation/top-level.nix
View File

@ -81,6 +81,8 @@ let
substituteAll ${./switch-to-configuration.pl} $out/bin/switch-to-configuration
chmod +x $out/bin/switch-to-configuration
echo -n "${toString config.system.extraDependencies}" > $out/extra-dependencies
${config.system.extraSystemBuilderCmds}
'';
@ -188,6 +190,16 @@ in
'';
};
system.extraDependencies = mkOption {
type = types.listOf types.package;
default = [];
description = ''
A list of packages that should be included in the system
closure but not otherwise made available to users. This is
primarily used by the installation tests.
'';
};
system.replaceRuntimeDependencies = mkOption {
default = [];
example = lib.literalExample "[ ({ original = pkgs.openssl; replacement = pkgs.callPackage /path/to/openssl { ... }; }) ]";

48
nixos/modules/virtualisation/google-compute-image.nix
View File

@ -137,40 +137,50 @@ in
after = [ "network-online.target" "ip-up.target" ];
wants = [ "network-online.target" "ip-up.target" ];
script = let wget = "${pkgs.wget}/bin/wget --retry-connrefused -t 15 --waitretry=10 --header='Metadata-Flavor: Google'"; in
script = let wget = "${pkgs.wget}/bin/wget --retry-connrefused -t 15 --waitretry=10 --header='Metadata-Flavor: Google'";
mktemp = "mktemp --tmpdir=/run"; in
''
# When dealing with cryptographic keys, we want to keep things private.
umask 077
# Don't download the SSH key if it has already been downloaded
if ! [ -e /root/.ssh/authorized_keys ]; then
echo "obtaining SSH key..."
mkdir -m 0700 -p /root/.ssh
${wget} -O /root/authorized-keys-metadata http://metadata.google.internal/0.1/meta-data/authorized-keys
if [ $? -eq 0 -a -e /root/authorized-keys-metadata ]; then
cat /root/authorized-keys-metadata | cut -d: -f2- > /root/key.pub
if ! grep -q -f /root/key.pub /root/.ssh/authorized_keys; then
cat /root/key.pub >> /root/.ssh/authorized_keys
echo "new key added to authorized_keys"
fi
chmod 600 /root/.ssh/authorized_keys
fi
rm -f /root/key.pub /root/authorized-keys-metadata
if ! [ -s /root/.ssh/authorized_keys ]; then
echo "obtaining SSH key..."
mkdir -m 0700 -p /root/.ssh
AUTH_KEYS=$(${mktemp})
${wget} -O $AUTH_KEYS http://metadata.google.internal/0.1/meta-data/authorized-keys
if [ -s $AUTH_KEYS ]; then
KEY_PUB=$(${mktemp})
cat $AUTH_KEYS | cut -d: -f2- > $KEY_PUB
if ! grep -q -f $KEY_PUB /root/.ssh/authorized_keys; then
cat $KEY_PUB >> /root/.ssh/authorized_keys
echo "New key added to authorized_keys."
fi
chmod 600 /root/.ssh/authorized_keys
rm -f $KEY_PUB
else
echo "Downloading http://metadata.google.internal/0.1/meta-data/authorized-keys failed."
false
fi
rm -f $AUTH_KEYS
fi
countKeys=0
${flip concatMapStrings config.services.openssh.hostKeys (k :
let kName = baseNameOf k.path; in ''
PRIV_KEY=$(${mktemp})
echo "trying to obtain SSH private host key ${kName}"
${wget} -O /root/${kName} http://metadata.google.internal/0.1/meta-data/attributes/${kName} && :
if [ $? -eq 0 -a -e /root/${kName} ]; then
${wget} -O $PRIV_KEY http://metadata.google.internal/0.1/meta-data/attributes/${kName} && :
if [ $? -eq 0 -a -s $PRIV_KEY ]; then
countKeys=$((countKeys+1))
mv -f /root/${kName} ${k.path}
echo "downloaded ${k.path}"
mv -f $PRIV_KEY ${k.path}
echo "Downloaded ${k.path}"
chmod 600 ${k.path}
${config.programs.ssh.package}/bin/ssh-keygen -y -f ${k.path} > ${k.path}.pub
chmod 644 ${k.path}.pub
else
echo "Downloading http://metadata.google.internal/0.1/meta-data/attributes/${kName} failed."
fi
rm -f /root/${kName}
rm -f $PRIV_KEY
''
)}

6
nixos/tests/installer.nix
View File

@ -98,12 +98,6 @@ let
channelContents = [ pkgs.rlwrap ];
efiBios = pkgs.runCommand "ovmf-bios" {} ''
mkdir $out
ln -s ${pkgs.OVMF}/FV/OVMF.fd $out/bios.bin
'';
# The test script boots the CD, installs NixOS on an empty hard
# disk, and then reboot from the hard disk. It's parameterized with
# a test script fragment `createPartitions', which must create

42
pkgs/applications/audio/ardour/ardour3.nix
View File

@ -1,9 +1,9 @@
{ stdenv, fetchgit, alsaLib, aubio, boost, cairomm, curl, fftw
, fftwSinglePrec, flac, glibc, glibmm, gtk, gtkmm, jack2
{ stdenv, fetchgit, alsaLib, aubio, boost, cairomm, curl, doxygen, dbus, fftw
, fftwSinglePrec, flac, glibc, glibmm, graphviz, gtk, gtkmm, jack2
, libgnomecanvas, libgnomecanvasmm, liblo, libmad, libogg, librdf
, librdf_raptor, librdf_rasqal, libsamplerate, libsigcxx, libsndfile
, libusb, libuuid, libxml2, libxslt, lilv, lv2, makeWrapper, pango
, perl, pkgconfig, python, serd, sord, sratom, suil }:
, libusb, libuuid, libxml2, libxslt, lilv-svn, lv2, makeWrapper, pango
, perl, pkgconfig, python, rubberband, serd, sord-svn, sratom, suil, taglib, vampSDK }:
let
@ -15,49 +15,49 @@ let
# "git describe" when _not_ on an annotated tag(!): MAJOR.MINOR-REV-HASH.
# Version to build.
tag = "3.5.403";
#tag = "3.5.403";
# Version info that is built into the binary. Keep in sync with 'tag'. The
# last 8 digits is a (fake) commit id.
revision = "3.5-403-00000000";
revision = "3.5-4539-g7024232";
# temporarily use a non tagged version, because 3.5.403 has a bug that
# causes loss of audio-files, and it was decided that there won't be a
# hotfix release, and we should use 4.0 when it comes out.
# more info: http://comments.gmane.org/gmane.comp.audio.ardour.user/13665
version = "2015-02-20";
in
stdenv.mkDerivation rec {
name = "ardour-${tag}";
name = "ardour3-git-${version}";
src = fetchgit {
url = git://git.ardour.org/ardour/ardour.git;
rev = "refs/tags/${tag}";
sha256 = "0k1z8sbjf88dqn12kf9cykrqj38vkr879n2g6b4adk6cghn8wz3x";
rev = "7024232855d268633760674d34c096ce447b7240";
sha256 = "ede3730455c3c91b2fd612871fa7262bdacd3dff4ba77c5dfbc3c1f0de9b8a36";
};
buildInputs =
[ alsaLib aubio boost cairomm curl fftw fftwSinglePrec flac glibc
glibmm gtk gtkmm jack2 libgnomecanvas libgnomecanvasmm liblo
[ alsaLib aubio boost cairomm curl doxygen dbus fftw fftwSinglePrec flac glibc
glibmm graphviz gtk gtkmm jack2 libgnomecanvas libgnomecanvasmm liblo
libmad libogg librdf librdf_raptor librdf_rasqal libsamplerate
libsigcxx libsndfile libusb libuuid libxml2 libxslt lilv lv2
makeWrapper pango perl pkgconfig python serd sord sratom suil
libsigcxx libsndfile libusb libuuid libxml2 libxslt lilv-svn lv2
makeWrapper pango perl pkgconfig python rubberband serd sord-svn sratom suil taglib vampSDK
];
patchPhase = ''
printf '#include "libs/ardour/ardour/revision.h"\nnamespace ARDOUR { const char* revision = \"${revision}\"; }\n' > libs/ardour/revision.cc
sed 's|/usr/include/libintl.h|${glibc}/include/libintl.h|' -i wscript
sed -e 's|^#!/usr/bin/perl.*$|#!${perl}/bin/perl|g' -i tools/fmt-bindings
sed -e 's|^#!/usr/bin/env.*$|#!${perl}/bin/perl|g' -i tools/*.pl
patchShebangs ./tools/
'';
configurePhase = "python waf configure --optimize --prefix=$out";
configurePhase = "python waf configure --optimize --docs --with-backends=jack,alsa --prefix=$out";
buildPhase = "python waf";
# For the custom ardour clearlooks gtk-engine to work, it must be
# moved to a directory called "engines" and added to GTK_PATH
installPhase = ''
python waf install
mkdir -pv $out/gtk2/engines
cp build/libs/clearlooks-newer/libclearlooks.so $out/gtk2/engines/
wrapProgram $out/bin/ardour3 --prefix GTK_PATH : $out/gtk2
# Install desktop file
mkdir -p "$out/share/applications"

35
pkgs/applications/audio/ardour/default.nix
View File

@ -1,11 +1,9 @@
{ stdenv, fetchgit, alsaLib, aubio, boost, cairomm, curl, dbus, fftw
, fftwSinglePrec, flac, glibc, glibmm, gtk, gtkmm, jack2
{ stdenv, fetchgit, alsaLib, aubio, boost, cairomm, curl, doxygen, dbus, fftw
, fftwSinglePrec, flac, glibc, glibmm, graphviz, gtk, gtkmm, jack2
, libgnomecanvas, libgnomecanvasmm, liblo, libmad, libogg, librdf
, librdf_raptor, librdf_rasqal, libsamplerate, libsigcxx, libsndfile
, libusb, libuuid, libxml2, libxslt, lilv, lv2, makeWrapper, pango
, perl, pkgconfig, python, rubberband, serd, sord, sratom, suil, taglib
, vampSDK
}:
, libusb, libuuid, libxml2, libxslt, lilv-svn, lv2, makeWrapper, pango
, perl, pkgconfig, python, rubberband, serd, sord-svn, sratom, suil, taglib, vampSDK }:
let
@ -34,33 +32,26 @@ stdenv.mkDerivation rec {
sha256 = "396668fb9116a68f5079f0d880930e890fd0cdf7ee5f3b97fcf44b88cf840b4c";
};
buildInputs = [
alsaLib aubio boost cairomm curl dbus fftw fftwSinglePrec flac
glibc glibmm gtk gtkmm jack2 libgnomecanvas libgnomecanvasmm liblo
libmad libogg librdf librdf_raptor librdf_rasqal libsamplerate
libsigcxx libsndfile libusb libuuid libxml2 libxslt lilv lv2
makeWrapper pango perl pkgconfig python rubberband serd sord
sratom suil taglib vampSDK
];
buildInputs =
[ alsaLib aubio boost cairomm curl doxygen dbus fftw fftwSinglePrec flac glibc
glibmm graphviz gtk gtkmm jack2 libgnomecanvas libgnomecanvasmm liblo
libmad libogg librdf librdf_raptor librdf_rasqal libsamplerate
libsigcxx libsndfile libusb libuuid libxml2 libxslt lilv-svn lv2
makeWrapper pango perl pkgconfig python rubberband serd sord-svn sratom suil taglib vampSDK
];
patchPhase = ''
printf '#include "libs/ardour/ardour/revision.h"\nnamespace ARDOUR { const char* revision = \"${revision}\"; }\n' > libs/ardour/revision.cc
sed 's|/usr/include/libintl.h|${glibc}/include/libintl.h|' -i wscript
sed -e 's|^#!/usr/bin/perl.*$|#!${perl}/bin/perl|g' -i tools/fmt-bindings
sed -e 's|^#!/usr/bin/env.*$|#!${perl}/bin/perl|g' -i tools/*.pl
patchShebangs ./tools/
'';
configurePhase = "python waf configure --with-backend=alsa,jack --optimize --prefix=$out";
configurePhase = "python waf configure --optimize --docs --with-backends=jack,alsa --prefix=$out";
buildPhase = "python waf";
# For the custom ardour clearlooks gtk-engine to work, it must be
# moved to a directory called "engines" and added to GTK_PATH
installPhase = ''
python waf install
mkdir -pv $out/gtk2/engines
cp build/libs/clearlooks-newer/libclearlooks.so $out/gtk2/engines/
wrapProgram $out/bin/ardour4 --prefix GTK_PATH : $out/gtk2
# Install desktop file
mkdir -p "$out/share/applications"

2
pkgs/applications/audio/caudec/default.nix
View File

@ -34,6 +34,6 @@ stdenv.mkDerivation rec {
description = "A multiprocess audio converter that supports many formats (FLAC, MP3, Ogg Vorbis, Windows codecs and many more)";
license = licenses.gpl3;
platforms = platforms.linux ++ platforms.darwin;
maintainers = with maintainers; [ _1126 ];
maintainers = with maintainers; [ hiberno ];
};
}

2
pkgs/applications/audio/dirt/default.nix
View File

@ -1,7 +1,7 @@
{ stdenv, fetchFromGitHub, libsndfile, libsamplerate, liblo, jack2 }:
stdenv.mkDerivation rec {
name = "dirt-git";
name = "dirt-2015-04-28";
src = fetchFromGitHub {
repo = "Dirt";
owner = "tidalcycles";

15
pkgs/applications/audio/google-musicmanager/default.nix
View File

@ -2,10 +2,11 @@
, libvorbis }:
assert stdenv.system == "x86_64-linux" || stdenv.system == "1686-linux";
let
archUrl = name: arch: "http://dl.google.com/linux/musicmanager/deb/pool/main/g/google-musicmanager-beta/${name}_${arch}.deb";
in
stdenv.mkDerivation rec {
debversion = "beta_1.0.129.6633-r0";
version = "beta_1.0.129.6633-r0"; # friendly to nix-env version sorting algo
version = "beta_1.0.182.3607-r0"; # friendly to nix-env version sorting algo
product = "google-musicmanager";
name = "${product}-${version}";
@ -16,12 +17,12 @@ stdenv.mkDerivation rec {
src = if stdenv.system == "x86_64-linux"
then fetchurl {
url = "http://dl.google.com/linux/musicmanager/deb/pool/main/g/google-musicmanager-beta/google-musicmanager-${version}_amd64.deb";
sha256 = "1fq2p721mzv8nd4dq6i9xiqvvqd5ak3v142vsxchg6yn14a9kbvr";
url = archUrl name "amd64";
sha256 = "141x986haxg3r72ggh8prz0qg298jkad1ys8sdvsac92p4adcqx4";
}
else fetchurl {
url = "http://dl.google.com/linux/musicmanager/deb/pool/main/g/google-musicmanager-beta/google-musicmanager-${version}_i386.deb";
sha256 = "7914e3e6e2adb2e952ebaf383db5e04727c29cfa83401007f29977f6c5ff6873";
url = archUrl name "i386";
sha256 = "076iaa7pxhj8b1hlg5ah9jfm4qgzgjc9ivvg2l18wp045gnycv1l";
};
unpackPhase = ''

14
pkgs/applications/audio/jaaa/default.nix
View File

@ -13,18 +13,6 @@ stdenv.mkDerivation rec {
alsaLib libclthreads libclxclient libX11 libXft libXrender fftwFloat jack2 zita-alsa-pcmi
];
NIX_CFLAGS_COMPILE = [
"-I${xlibs.xproto}/include"
"-I${libX11}/include"
"-I${libXft}/include"
"-I${freetype}/include"
"-I${fontconfig}/include"
"-I${libXrender}/include"
"-I${xlibs.renderproto}/include"
"-I${alsaLib}/include"
"-I${zita-alsa-pcmi}/include"
];
makeFlags = [
"PREFIX=$(out)"
"SUFFIX=''"
@ -38,7 +26,7 @@ stdenv.mkDerivation rec {
homepage = http://kokkinizita.linuxaudio.org/linuxaudio/index.html;
description = "JACK and ALSA Audio Analyser";
license = licenses.gpl2;
maintainers = with maintainers; [ magnetophon ];
maintainers = [ maintainers.magnetophon ];
platforms = platforms.linux;
};
}

9
pkgs/applications/audio/keyfinder/default.nix
View File

@ -1,17 +1,18 @@
{ stdenv, fetchFromGitHub, libav_0_8, libkeyfinder, qt5, taglib }:
stdenv.mkDerivation rec {
version = "1.25-17-gf670607";
let version = "1.26"; in
stdenv.mkDerivation {
name = "keyfinder-${version}";
src = fetchFromGitHub {
sha256 = "1sfnywc6jdpm03344i6i4pz13mqa4i5agagj4k6252m63cqmjkrc";
rev = version;
repo = "is_KeyFinder";
owner = "ibsh";
rev = "f6706074435ac14c5238ee3f0dd22ac22d72af9c";
sha256 = "1sfnywc6jdpm03344i6i4pz13mqa4i5agagj4k6252m63cqmjkrc";
};
meta = with stdenv.lib; {
inherit version;
description = "Musical key detection for digital audio (graphical UI)";
longDescription = ''
KeyFinder is an open source key detection tool, for DJs interested in

5
pkgs/applications/audio/mopidy-moped/default.nix
View File

@ -2,12 +2,11 @@
pythonPackages.buildPythonPackage rec {
name = "mopidy-moped-${version}";
version = "0.5.0";
version = "0.6.0";
src = fetchurl {
url = "https://github.com/martijnboland/moped/archive/v${version}.tar.gz";
sha256 = "1bkx0c4yi48nxm1vzacdil9scn0ilwkbd1rgiga34p77lcg16qb2";
sha256 = "0xff8y1kc7rwwsd7ppgbvywf6i8lchjwbxjisfl1kmilwsb166yr";
};
propagatedBuildInputs = [ mopidy ];

4
pkgs/applications/audio/mopidy-mopify/default.nix
View File

@ -3,11 +3,11 @@
pythonPackages.buildPythonPackage rec {
name = "mopidy-mopify-${version}";
version = "1.4.1";
version = "1.5.1";
src = fetchurl {
url = "https://github.com/dirkgroenen/mopidy-mopify/archive/${version}.tar.gz";
sha256 = "1i752vnkgqfps5vym63rbsh1xm141z8r68d80bi076zr6zbzdjj9";
sha256 = "0hhdss4i5436dj37pndxk81a4g3g8f6zqjyv04lhpqcww01290as";
};
propagatedBuildInputs = [ mopidy ];

5
pkgs/applications/audio/mopidy-spotify/default.nix
View File

@ -2,12 +2,11 @@
pythonPackages.buildPythonPackage rec {
name = "mopidy-spotify-${version}";
version = "1.3.0";
version = "1.4.0";
src = fetchurl {
url = "https://github.com/mopidy/mopidy-spotify/archive/v${version}.tar.gz";
sha256 = "0pwgg9xw86sjhv6w735fm0k81v0lv3gqlidgw90hr47hc4wajnzx";
sha256 = "0cf97z9vnnp5l77xhwvmkbkqgpj5gwnm1pipiy66lbk4gn6va4z4";
};
propagatedBuildInputs = [ mopidy pythonPackages.pyspotify ];

4
pkgs/applications/audio/mopidy/default.nix
View File

@ -5,11 +5,11 @@
pythonPackages.buildPythonPackage rec {
name = "mopidy-${version}";
version = "1.0.0";
version = "1.0.5";
src = fetchurl {
url = "https://github.com/mopidy/mopidy/archive/v${version}.tar.gz";
sha256 = "15cz6mqw8ihqxhlssnbbssl3bi1xxbmq7krf3hv0zmmdj73ilsd6";
sha256 = "0lhmm2w2djf6mb3acw1yq1k4j74v1lf4kgx24dsdnpkgsycrv5q6";
};
propagatedBuildInputs = with pythonPackages; [

40
pkgs/applications/audio/musescore/default.nix
View File

@ -1,27 +1,47 @@
{ stdenv, fetchurl, makeWrapper, cmake, qt5, pkgconfig, alsaLib, portaudio, jack2
, lame, libsndfile, libvorbis }:
{ stdenv, fetchurl, cmake, pkgconfig
, alsaLib, freetype, jack2, lame, libogg, libpulseaudio, libsndfile, libvorbis
, portaudio, qt5 #, tesseract
}:
stdenv.mkDerivation rec {
name = "musescore-${version}";
version = "2.0.0";
version = "2.0.1";
src = fetchurl {
url = "https://github.com/musescore/MuseScore/archive/v${version}.tar.gz";
sha256 = "1a4fz9pqwz59brfa7qn61364hyd07lsq3lflkzn1w2q21d7xd20w";
sha256 = "0n4xk35jggdq2dcizqjq1kdpclih4scpl93ymmxahvfa1vvwn5iw";
};
buildInputs = [
makeWrapper cmake qt5.base pkgconfig alsaLib portaudio jack2 lame libsndfile libvorbis
makeFlags = [
"PREFIX=$(out)"
];
patchPhase = ''
sed s,"/usr/local",$out, -i Makefile
cmakeFlags = [
"-DAEOLUS=OFF"
"-DZERBERUS=ON"
"-DOSC=ON=ON"
"-DOMR=OFF" # TODO: add OMR support, CLEF_G not declared error
"-DOCR=OFF" # Not necessary without OMR
"-DSOUNDFONT3=ON"
"-DHAS_AUDIOFILE=ON"
"-DBUILD_JACK=ON"
];
preBuild = ''
make lupdate
make lrelease
'';
preBuild = "make lrelease";
nativeBuildInputs = [ cmake pkgconfig ];
buildInputs = [
alsaLib jack2 freetype lame libogg libpulseaudio libsndfile libvorbis
portaudio qt5.base qt5.declarative qt5.enginio qt5.script qt5.svg qt5.tools
qt5.webkit qt5.xmlpatterns #tesseract
];
meta = with stdenv.lib; {
description = "Qt-based score editor";
description = "Music notation and composition software";
homepage = http://musescore.org/;
license = licenses.gpl2;
platforms = platforms.linux;

2
pkgs/applications/audio/ncmpc/default.nix
View File

@ -23,7 +23,7 @@ stdenv.mkDerivation rec {
description = "Curses-based interface for MPD (music player daemon)";
homepage = http://www.musicpd.org/clients/ncmpc/;
license = licenses.gpl2Plus;
maintainers = with maintainers; [ _1126 ];
maintainers = with maintainers; [ hiberno ];
platforms = platforms.all;
};
}

2
pkgs/applications/audio/pamixer/default.nix
View File

@ -30,7 +30,7 @@ stdenv.mkDerivation rec {
'';
homepage = https://github.com/cdemoulins/pamixer;
license = licenses.gpl3;
maintainers = with maintainers; [ _1126 ];
maintainers = with maintainers; [ hiberno ];
platforms = platforms.linux;
};
}

2
pkgs/applications/audio/pd-plugins/puremapping/default.nix
View File

@ -1,7 +1,7 @@
{ stdenv, fetchurl, unzip, puredata }:
stdenv.mkDerivation rec {
name = "puremapping";
name = "puremapping-1.01";
src = fetchurl {
url = "http://www.chnry.net/ch/IMG/zip/puremapping-libdir-generic.zip";

22
pkgs/applications/audio/wavegain/default.nix Normal file
View File

@ -0,0 +1,22 @@
{ stdenv, fetchgit }:
stdenv.mkDerivation {
name = "wavegain-1.3.1";
src = fetchgit {
url = "https://github.com/MestreLion/wavegain.git";
sha256 = "1h886xijc9d7h4p6qx12c6kgwmp6s1bdycnyylkayfncczzlbi24";
};
installPhase = ''
strip -s wavegain
install -vD wavegain "$out/bin/wavegain"
'';
meta = {
description = "ReplayGain for wave files";
homepage = https://github.com/MestreLion/wavegain;
license = stdenv.lib.licenses.lgpl21;
platforms = stdenv.lib.platforms.linux;
maintainers = [ stdenv.lib.maintainers.devhell ];
};
}

68
pkgs/applications/editors/textadept/default.nix Normal file
View File

@ -0,0 +1,68 @@
{stdenv, fetchhg, fetchurl, fetchzip, gtk, glib, pkgconfig, unzip, ncurses, zip}:
let
buildInputs = [
gtk glib pkgconfig unzip ncurses zip
];
cached_url = url: sha256: fetchurl {
inherit sha256 url;
};
get_url = url: sha256: ''
cp ${(cached_url url sha256)} $(basename ${(cached_url url sha256)} | sed -e 's@^[0-9a-z]\+-@@')
touch $(basename ${(cached_url url sha256)} | sed -e 's@^[0-9a-z]\+-@@')
'';
cached_url_zip = url: sha256: fetchzip {
inherit sha256 url;
};
get_url_zip = url: sha256: let zipdir = (cached_url_zip url sha256); in ''
( d=$PWD; cd $TMPDIR; name=$(basename ${zipdir} .zip | sed -e 's/^[a-z0-9]*-//');
cp -r ${zipdir} $name; chmod u+rwX -R $name; zip -r $d/$name.zip $name )
touch $name
'';
in
stdenv.mkDerivation rec{
version = "8.0";
scintillua_version = "3.5.5-1";
name = "textadept-${version}";
inherit buildInputs;
src = fetchhg {
url = http://foicica.com/hg/textadept;
rev = "textadept_${version}";
sha256 = "18kcphqkn0l77dbcyvywy3wh13ib280bb0qsffaqy439gk5zr7ql";
};
preConfigure = ''
cd src
mkdir wget
echo '#! ${stdenv.shell}' > wget/wget
chmod a+x wget/wget
export PATH="$PATH:$PWD/wget"
${get_url http://prdownloads.sourceforge.net/scintilla/scintilla355.tgz "11n49h58xh35vj1j85cxasl93rjiv699c5cs5lpv19skfsgs3sb4"}
${get_url http://foicica.com/scinterm/download/scinterm_1.6.zip "0ixwj9il6ri1xl4nvb6f108z4qhrahysza6frbbaqmbdz21hnmcl"}
${get_url http://foicica.com/scintillua/download/scintillua_3.5.5-1.zip "0bpz5rmgaisbimhm6rpn961mbv30cwqid7kh9lad94v3y9ppvf35"}
${get_url http://www.lua.org/ftp/lua-5.3.0.tar.gz "00fv1p6dv4701pyjrlvkrr6ykzxqy9hy1qxzj6qmwlb0ssr5wjmf"}
${get_url http://www.inf.puc-rio.br/~roberto/lpeg/lpeg-0.12.2.tar.gz "01002avq90yc8rgxa5z9a1768jm054iid3pnfpywdcfij45jgbba"}
${get_url_zip http://github.com/keplerproject/luafilesystem/archive/v_1_6_3.zip "1hxcnqj53540ysyw8fzax7f09pl98b8f55s712gsglcdxp2g2pri"}
${get_url http://foicica.com/lspawn/download/lspawn_1.2.zip "1fhfi274bxlsdvva5q5j0wv8hx68cmf3vnv9spllzad4jdvz82xv"}
${get_url http://luajit.org/download/LuaJIT-2.0.3.tar.gz "0ydxpqkmsn2c341j4r2v6r5r0ig3kbwv3i9jran3iv81s6r6rgjm"}
${get_url http://foicica.com/gtdialog/download/gtdialog_1.2.zip "0nvcldyhj8abr8jny9pbyfjwg8qfp9f2h508vjmrvr5c5fqdbbm0"}
${get_url http://invisible-island.net/datafiles/release/cdk.tar.gz "00s87kq5x10x22azr6q17b663syk169y3dk3kaj8z6dlk2b8vknp"}
${get_url_zip http://foicica.com/hg/bombay/archive/d704272c3629.zip "19dg3ky87rfy0a3319vmv18hgn9spplpznvlqnk3djh239ddpplw"}
mv d704*.zip bombay.zip
${get_url http://www.leonerd.org.uk/code/libtermkey/libtermkey-0.17.tar.gz "12gkrv1ldwk945qbpprnyawh0jz7rmqh18fyndbxiajyxmj97538"}
make deps
'';
postBuild = ''
make curses
'';
postInstall = ''
make curses install PREFIX=$out MAKECMDGOALS=curses
'';
makeFlags = ["PREFIX=$(out)"];
meta = {
inherit version;
description = "An extensible text editor based on Scintilla with Lua scripting";
license = stdenv.lib.licenses.mit ;
maintainers = [stdenv.lib.maintainers.raskin];
platforms = stdenv.lib.platforms.linux;
homepage = "http://foicica.com/textadept";
};
}

68
pkgs/applications/graphics/ImageMagick/default.nix
View File

@ -17,6 +17,10 @@ let
else if stdenv.system == "x86_64-linux" || stdenv.system == "x86_64-darwin" then "x86-64"
else throw "ImageMagick is not supported on this platform.";
mkFlag = trueStr: falseStr: cond: val: "--${if cond then trueStr else falseStr}-${val}";
mkWith = mkFlag "with" "without";
mkEnable = mkFlag "enable" "disable";
hasX11 = libX11 != null && libXext != null && libXt != null;
in
@ -33,38 +37,38 @@ stdenv.mkDerivation rec {
enableParallelBuilding = true;
configureFlags = [
(mkEnable (libcl != null) "opencl" null)
(mkWith true "modules" null)
(mkWith true "gcc-arch" arch)
#(mkEnable true "hdri" null) This breaks some dependencies
(mkWith (perl != null) "perl" null)
(mkWith (jemalloc != null) "jemalloc" null)
(mkWith true "frozenpaths" null)
(mkWith (bzip2 != null) "bzlib" null)
(mkWith hasX11 "x" null)
(mkWith (zlib != null) "zlib" null)
(mkWith false "dps" null)
(mkWith (fftw != null) "fftw" null)
(mkWith (libfpx != null) "fpx" null)
(mkWith (djvulibre != null) "djvu" null)
(mkWith (fontconfig != null) "fontconfig" null)
(mkWith (freetype != null) "freetype" null)
(mkWith (ghostscript != null) "gslib" null)
(mkWith (graphviz != null) "gvc" null)
(mkWith (jbigkit != null) "jbig" null)
(mkWith (libjpeg != null) "jpeg" null)
(mkWith (lcms2 != null) "lcms2" null)
(mkWith false "lcms" null)
(mkWith (openjpeg != null) "openjp2" null)
(mkWith (liblqr1 != null) "lqr" null)
(mkWith (xz != null) "lzma" null)
(mkWith (openexr != null) "openexr" null)
(mkWith (pango != null) "pango" null)
(mkWith (libpng != null) "png" null)
(mkWith (librsvg != null) "rsvg" null)
(mkWith (libtiff != null) "tiff" null)
(mkWith (libwebp != null) "webp" null)
(mkWith (libxml2 != null) "xml" null)
(mkEnable (libcl != null) "opencl")
(mkWith true "modules")
(mkWith true "gcc-arch=${arch}")
#(mkEnable true "hdri") This breaks some dependencies
(mkWith (perl != null) "perl")
(mkWith (jemalloc != null) "jemalloc")
(mkWith true "frozenpaths")
(mkWith (bzip2 != null) "bzlib")
(mkWith hasX11 "x")
(mkWith (zlib != null) "zlib")
(mkWith false "dps")
(mkWith (fftw != null) "fftw")
(mkWith (libfpx != null) "fpx")
(mkWith (djvulibre != null) "djvu")
(mkWith (fontconfig != null) "fontconfig")
(mkWith (freetype != null) "freetype")
(mkWith (ghostscript != null) "gslib")
(mkWith (graphviz != null) "gvc")
(mkWith (jbigkit != null) "jbig")
(mkWith (libjpeg != null) "jpeg")
(mkWith (lcms2 != null) "lcms2")
(mkWith false "lcms")
(mkWith (openjpeg != null) "openjp2")
(mkWith (liblqr1 != null) "lqr")
(mkWith (xz != null) "lzma")
(mkWith (openexr != null) "openexr")
(mkWith (pango != null) "pango")
(mkWith (libpng != null) "png")
(mkWith (librsvg != null) "rsvg")
(mkWith (libtiff != null) "tiff")
(mkWith (libwebp != null) "webp")
(mkWith (libxml2 != null) "xml")
] ++ optional (dejavu_fonts != null) "--with-dejavu-font-dir=${dejavu_fonts}/share/fonts/truetype/"
++ optional (ghostscript != null) "--with-gs-font-dir=${ghostscript}/share/ghostscript/fonts/";

6
pkgs/applications/graphics/digikam/default.nix
View File

@ -6,11 +6,11 @@
}:
stdenv.mkDerivation rec {
name = "digikam-4.6.0";
name = "digikam-4.10.0";
src = fetchurl {
url = "http://download.kde.org/stable/digikam/${name}.tar.bz2";
sha256 = "0id3anikki8c3rzqzapdbg00h577qwybknvkbz1kdq0348bs6ixh";
sha256 = "4207e68b6221307111b66bb69485d3e88150df95dae014a99f6f161a3da0c725";
};
nativeBuildInputs = [ cmake automoc4 pkgconfig ];
@ -26,7 +26,7 @@ stdenv.mkDerivation rec {
KDEDIRS="${marble}:${qjson}";
# Help digiKam find libusb, otherwise gphoto2 support is disabled
cmakeFlags = "-DLIBUSB_LIBRARIES=${libusb1}/lib -DLIBUSB_INCLUDE_DIR=${libusb1}/include/libusb-1.0";
cmakeFlags = "-DLIBUSB_LIBRARIES=${libusb1}/lib -DLIBUSB_INCLUDE_DIR=${libusb1}/include/libusb-1.0 -DDIGIKAMSC_COMPILE_LIBKFACE=ON";
enableParallelBuilding = true;

2
pkgs/applications/graphics/shotwell/default.nix
View File

@ -13,7 +13,7 @@ let
sha256 = "0fmg7fq5fx0jg3ryk71kwdkspsvj42acxy9imk7vznkqj29a9zqn";
};
configureFlags = "--with-ca-certificates=${cacert}/ca-bundle.crt";
configureFlags = "--with-ca-certificates=${cacert}/etc/ssl/certs/ca-bundle.crt";
buildInputs = [ pkgconfig glib libsoup ];
};

6
pkgs/applications/kde-apps-15.04/default.nix
View File

@ -350,6 +350,12 @@ let
++ [ pkgs.libotr ]; # needed for ktp-text-ui
};
ktp-text-ui = super.ktp-text-ui // {
buildInputs =
super.ktp-text-ui.buildInputs
++ (with kf5; [ kdbusaddons ]);
};
lokalize = super.lokalize // {
buildInputs =
super.lokalize.buildInputs

2043
pkgs/applications/kde-apps-15.04/manifest.nix
View File

File diff suppressed because it is too large Load Diff

1
pkgs/applications/kde-apps-15.04/manifest.sh
View File

@ -10,6 +10,7 @@ if [ $# -eq 0 ]; then
$(nix-build ../../.. -A autonix.manifest) \
"${KDE_MIRROR}/stable/applications/15.04.0/" \
"${KDE_MIRROR}/stable/applications/15.04.1/" \
"${KDE_MIRROR}/stable/applications/15.04.2/" \
$MANIFEST_EXTRA_ARGS -A '*.tar.xz'
else

2
pkgs/applications/misc/cortex/default.nix
View File

@ -1,7 +1,7 @@
{ stdenv, fetchgit, python3 }:
stdenv.mkDerivation {
name = "cortex";
name = "cortex-2014-08-01";
src = fetchgit {
url = "https://github.com/gglucas/cortex";

14
pkgs/applications/misc/dunst/default.nix
View File

@ -1,6 +1,7 @@
{ stdenv, fetchurl, coreutils , unzip, which, pkgconfig , dbus
, freetype, xdg_utils , libXext, glib, pango , cairo, libX11, libnotify
, libxdg_basedir , libXScrnSaver, xproto, libXinerama , perl, gdk_pixbuf
{ stdenv, fetchurl, coreutils, unzip, which, pkgconfig, dbus
, freetype, xdg_utils, libXext, glib, pango, cairo, libX11, libnotify
, libxdg_basedir, libXScrnSaver, xproto, libXinerama, perl, gdk_pixbuf
, dbus_daemon, makeWrapper
}:
stdenv.mkDerivation rec {
@ -15,7 +16,7 @@ stdenv.mkDerivation rec {
buildInputs =
[ coreutils unzip which pkgconfig dbus freetype libnotify gdk_pixbuf
xdg_utils libXext glib pango cairo libX11 libxdg_basedir
libXScrnSaver xproto libXinerama perl];
libXScrnSaver xproto libXinerama perl dbus_daemon makeWrapper ];
buildPhase = ''
export VERSION=${version};
@ -23,6 +24,11 @@ stdenv.mkDerivation rec {
make dunst;
'';
postFixup = ''
wrapProgram "$out/bin/dunst" \
--prefix PATH : '${dbus_daemon}/bin'
'';
meta = {
description = "lightweight and customizable notification daemon";
homepage = http://www.knopwob.org/dunst/;

37
pkgs/applications/misc/loxodo/default.nix Normal file
View File

@ -0,0 +1,37 @@
{ stdenv, python27Packages, fetchgit }:
let
py = python27Packages;
python = py.python;
in
py.buildPythonPackage rec {
name = "loxodo-0.20150124";
src = fetchgit {
url = "https://github.com/sommer/loxodo.git";
rev = "6c56efb4511fd6f645ad0f8eb3deafc8071c5795";
sha256 = "02whmv4am8cz401rplplqzbipkyf0wd69z43sd3yw05rh7f3xbs2";
};
propagatedBuildInputs = with py; [ wxPython python.modules.readline ];
postInstall = ''
mv $out/bin/loxodo.py $out/bin/loxodo
mkdir -p $out/share/applications
cat > $out/share/applications/loxodo.desktop <<EOF
[Desktop Entry]
Type=Application
Exec=$out/bin/loxodo
Icon=$out/lib/${python.libPrefix}/site-packages/resources/loxodo-icon.png
Name=Loxodo
GenericName=Password Vault
Categories=Application;Other;
EOF
'';
meta = with stdenv.lib; {
description = "A Password Safe V3 compatible password vault";
homepage = http://www.christoph-sommer.de/loxodo/;
license = licenses.gpl2Plus;
platforms = platforms.linux;
};
}

31
pkgs/applications/misc/pdfpc/default.nix Normal file
View File

@ -0,0 +1,31 @@
{ stdenv, fetchurl, cmake, makeWrapper, pkgconfig, vala, gtk3, libgee, poppler
, libpthreadstubs, gstreamer, gst-plugins-base, librsvg }:
stdenv.mkDerivation rec {
name = "${product}-${version}";
product = "pdfpc";
version = "4.0.0";
src = fetchurl {
url = "https://github.com/pdfpc/pdfpc/releases/download/v${version}/${product}-v${version}.tar.gz";
sha256 = "0qksci11pgvabfdnynkpj2av0iww8m9m41a0vwsqgvg3yiacb4f0";
};
nativeBuildInputs = [ cmake pkgconfig ];
buildInputs = [ gstreamer gst-plugins-base vala gtk3 libgee poppler
libpthreadstubs makeWrapper librsvg ];
postInstall = ''
wrapProgram $out/bin/pdfpc \
--set GDK_PIXBUF_MODULE_FILE "$GDK_PIXBUF_MODULE_FILE"
'';
meta = with stdenv.lib; {
description = "A presenter console with multi-monitor support for PDF files";
homepage = https://pdfpc.github.io/;
license = licenses.gpl2Plus;
maintainers = with maintainers; [ pSub ];
platforms = platforms.linux;
};
}

2
pkgs/applications/misc/rofi/pass.nix
View File

@ -25,6 +25,6 @@ stdenv.mkDerivation rec {
meta = {
description = "A script to make rofi work with password-store";
homepage = https://github.com/carnager/rofi-pass;
maintainers = [stdenv.lib.maintainers._1126];
maintainers = [stdenv.lib.maintainers.hiberno];
};
}

2
pkgs/applications/misc/rxvt_unicode-plugins/urxvt-perls/default.nix
View File

@ -1,7 +1,7 @@
{ stdenv, fetchgit }:
stdenv.mkDerivation {
name = "urxvt-perls";
name = "urxvt-perls-2015-03-28";
src = fetchgit {
url = "git://github.com/muennich/urxvt-perls";

2
pkgs/applications/misc/rxvt_unicode-plugins/urxvt-tabbedex/default.nix
View File

@ -1,7 +1,7 @@
{ stdenv, fetchgit }:
stdenv.mkDerivation {
name = "urxvt-tabbedex";
name = "urxvt-tabbedex-2015-03-03";
src = fetchgit {
url = "https://github.com/mina86/urxvt-tabbedex";

358
pkgs/applications/networking/browsers/firefox-bin/sources.nix
View File

@ -4,185 +4,185 @@
# ruby generate_source.rb > source.nix
{
version = "38.0.1";
version = "38.0.5";
sources = [
{ locale = "ach"; arch = "linux-i686"; sha1 = "912fff124863aba8189cdb2f22a2c1cf96c5057a"; }
{ locale = "ach"; arch = "linux-x86_64"; sha1 = "72d9bf343fac24312faf42272553b37e7cb5df5e"; }
{ locale = "af"; arch = "linux-i686"; sha1 = "c266d1ce84018e55f239c0cf692feab0b3d2bb58"; }
{ locale = "af"; arch = "linux-x86_64"; sha1 = "28df7ec17c9008e59af3ba50225e2e6b53f9722a"; }
{ locale = "an"; arch = "linux-i686"; sha1 = "2d254b3818afcc0510efba99fe469754076b8841"; }
{ locale = "an"; arch = "linux-x86_64"; sha1 = "6428c38cd5c00c2a9c02e26b71945831c3c102d2"; }
{ locale = "ar"; arch = "linux-i686"; sha1 = "5477725a61b9479a90e76727eb9f69d19e282f83"; }
{ locale = "ar"; arch = "linux-x86_64"; sha1 = "e663608972b44aca2b08abcc2d92a3f8e8c92ed9"; }
{ locale = "as"; arch = "linux-i686"; sha1 = "101da7d20a72980cdc5db7c4b2755edc3e0a5d66"; }
{ locale = "as"; arch = "linux-x86_64"; sha1 = "9e6b94146534ec11d00ecd4f1e06680f0fd918b8"; }
{ locale = "ast"; arch = "linux-i686"; sha1 = "b5e195606434b4dd90818877e5aea05fa995f136"; }
{ locale = "ast"; arch = "linux-x86_64"; sha1 = "851276e8a86b27ad7b92e075e6e20a527284dd4e"; }
{ locale = "az"; arch = "linux-i686"; sha1 = "48ed44ab60ca16fc39abce13a630d997dd5099c1"; }
{ locale = "az"; arch = "linux-x86_64"; sha1 = "fb6b4ca689670a3d994e3c524490e46636a8cd59"; }
{ locale = "be"; arch = "linux-i686"; sha1 = "6c4d9cdb9fb8aa0fb3ed8042306268600e3c385a"; }
{ locale = "be"; arch = "linux-x86_64"; sha1 = "0795a804507837821fed591849169c13bf193302"; }
{ locale = "bg"; arch = "linux-i686"; sha1 = "3423b59b472eff5bdd0d16994a777c06de734b2b"; }
{ locale = "bg"; arch = "linux-x86_64"; sha1 = "5571d632e5dc7efea9fccae5035ed070542adc52"; }
{ locale = "bn-BD"; arch = "linux-i686"; sha1 = "c9724715fa1036e872b09b4bc453c9ff9344831a"; }
{ locale = "bn-BD"; arch = "linux-x86_64"; sha1 = "f99413c5716c4d45eee22cf1f547138b1ba3d044"; }
{ locale = "bn-IN"; arch = "linux-i686"; sha1 = "76d5752e8bc131ece1a43a3376b99280545861bc"; }
{ locale = "bn-IN"; arch = "linux-x86_64"; sha1 = "b9ea600f884e50afc31d096697b54366186b1331"; }
{ locale = "br"; arch = "linux-i686"; sha1 = "e72e62a49ebda9cadf032e2e90c14adb5a7db1c4"; }
{ locale = "br"; arch = "linux-x86_64"; sha1 = "7c64d69d3510d06ccdf98fbf85f41d3b7f4b532f"; }
{ locale = "bs"; arch = "linux-i686"; sha1 = "c69f54bd537c9d16ce4ccf5169646c6f7dde98a5"; }
{ locale = "bs"; arch = "linux-x86_64"; sha1 = "abe0137bb0cb8536b6bdaf03246bfc97e7cba4bc"; }
{ locale = "ca"; arch = "linux-i686"; sha1 = "3c914e3f26a61568a220b8eed2742c70ee879fd5"; }
{ locale = "ca"; arch = "linux-x86_64"; sha1 = "b3aa2e0caa2b145df9b3c099bb5158eb6c21402d"; }
{ locale = "cs"; arch = "linux-i686"; sha1 = "bfc8733ee396bfa0dedfdffb5aa11bb4c8816be0"; }
{ locale = "cs"; arch = "linux-x86_64"; sha1 = "6de8e3bb0038676a906b75a9603b9f057251538a"; }
{ locale = "cy"; arch = "linux-i686"; sha1 = "125c53350f599e975b177db3e11ce367b2250fd8"; }
{ locale = "cy"; arch = "linux-x86_64"; sha1 = "4535f608f78f91014371b4b49ca5d73ba369e5be"; }
{ locale = "da"; arch = "linux-i686"; sha1 = "860baa240c24453b55bb3c3273eee85821ab4a7f"; }
{ locale = "da"; arch = "linux-x86_64"; sha1 = "2078e23dbeeeaad80ef55a07888a94958a8bce85"; }
{ locale = "de"; arch = "linux-i686"; sha1 = "d3d6fbcfc622a303b932c6f9fed134d26fa3a32f"; }
{ locale = "de"; arch = "linux-x86_64"; sha1 = "1e7e7608ad79337212d73fd72df189bcfbc08be5"; }
{ locale = "dsb"; arch = "linux-i686"; sha1 = "aadd04915c3dd07b4fa257071382081531e910cb"; }
{ locale = "dsb"; arch = "linux-x86_64"; sha1 = "ab57a27336d9b2b379dd9370781cbe38fb34f274"; }
{ locale = "el"; arch = "linux-i686"; sha1 = "a96898e37be58096490ce26313760e9595eab0cb"; }
{ locale = "el"; arch = "linux-x86_64"; sha1 = "fd83ef7ac7b6b44ca61737b85f4b2aa9e297566b"; }
{ locale = "en-GB"; arch = "linux-i686"; sha1 = "923e977c4a53e91ff0299271bfacf675d1c9f047"; }
{ locale = "en-GB"; arch = "linux-x86_64"; sha1 = "6250c59ec325ce9f2a6520cc326a500fe8a61106"; }
{ locale = "en-US"; arch = "linux-i686"; sha1 = "11647b846463af53eebc70e5000c1b2072bcb08e"; }
{ locale = "en-US"; arch = "linux-x86_64"; sha1 = "c65084273a4684898d1bd265714bcd2a577939a0"; }
{ locale = "en-ZA"; arch = "linux-i686"; sha1 = "cbe33f717d3548913cc316adc4163824f63301dd"; }
{ locale = "en-ZA"; arch = "linux-x86_64"; sha1 = "ddaa35f6f054184484856254927bb4b0c7009ec1"; }
{ locale = "eo"; arch = "linux-i686"; sha1 = "d8c0d5adbebac214be559354e6f83efc6c01c874"; }
{ locale = "eo"; arch = "linux-x86_64"; sha1 = "e2deaaea97169a50e50c7a3cd7963b7627fd0271"; }
{ locale = "es-AR"; arch = "linux-i686"; sha1 = "cee1c800c773dd784900e8e1d9efc7ae59764907"; }
{ locale = "es-AR"; arch = "linux-x86_64"; sha1 = "38efb3a002d3ffafd825b24d0aa5c55617f0a198"; }
{ locale = "es-CL"; arch = "linux-i686"; sha1 = "419ca07f1d5bb1d460ce22a7bf8488611b3efee3"; }
{ locale = "es-CL"; arch = "linux-x86_64"; sha1 = "4ccd1423a7840b9bc696dbe9f1edc1e1629e664e"; }
{ locale = "es-ES"; arch = "linux-i686"; sha1 = "9398c4714f01ce1a2420ad879fc710a84c19f666"; }
{ locale = "es-ES"; arch = "linux-x86_64"; sha1 = "79e8fff4b9390f3258a7ed78995759d0005e167e"; }
{ locale = "es-MX"; arch = "linux-i686"; sha1 = "c3b4d3496c08ec12f3dc96d2600b327f8d326377"; }
{ locale = "es-MX"; arch = "linux-x86_64"; sha1 = "d5ee06667437b1d2f56de89b5f5e5f2f007c4eb1"; }
{ locale = "et"; arch = "linux-i686"; sha1 = "1c9a8326ca27152a4a8554c62d69784ad4f07ac6"; }
{ locale = "et"; arch = "linux-x86_64"; sha1 = "f4002b8fa6734353d02e605bf870aa51d67940a8"; }
{ locale = "eu"; arch = "linux-i686"; sha1 = "39bf95af55156896df07a2a5f77909987095f567"; }
{ locale = "eu"; arch = "linux-x86_64"; sha1 = "99a70da03d31e8209e2818ef07d8d380c1521164"; }
{ locale = "fa"; arch = "linux-i686"; sha1 = "1346de9715783742fcafe60df6d1c37460c6db93"; }
{ locale = "fa"; arch = "linux-x86_64"; sha1 = "d2e0b04bbc4617e35a1d46f22801ecebdb6e873f"; }
{ locale = "ff"; arch = "linux-i686"; sha1 = "2ec4e8bd9cdaefe06c390a5e41b5a234a2b1d7e2"; }
{ locale = "ff"; arch = "linux-x86_64"; sha1 = "293dad19f7278909b216107c229e20a79bcfa1fd"; }
{ locale = "fi"; arch = "linux-i686"; sha1 = "15c2fe0d7c6a53ee5bc7d8284ff414dd6da6b883"; }
{ locale = "fi"; arch = "linux-x86_64"; sha1 = "09222ca13bc199c8c32fad00a638f335276ff44b"; }
{ locale = "fr"; arch = "linux-i686"; sha1 = "10a45fab960d898d65f0dc45a6d0e6368f6bde8e"; }
{ locale = "fr"; arch = "linux-x86_64"; sha1 = "e6ed3e2d6d8e272d6a82bd39a0986afe9f9d5b00"; }
{ locale = "fy-NL"; arch = "linux-i686"; sha1 = "0222d1158829d06f3fee3314296ebe9126e0d9ab"; }
{ locale = "fy-NL"; arch = "linux-x86_64"; sha1 = "a0c5529c5439c4a4ac29578dd0df6801310b1279"; }
{ locale = "ga-IE"; arch = "linux-i686"; sha1 = "95e9d1636243553b72c8d5a6a653f5cd12539ca0"; }
{ locale = "ga-IE"; arch = "linux-x86_64"; sha1 = "c525824667f8fe9225fafd1c1bbe6d84413d3e30"; }
{ locale = "gd"; arch = "linux-i686"; sha1 = "d29e93647a906856033607ef15e88307cf98fab7"; }
{ locale = "gd"; arch = "linux-x86_64"; sha1 = "5473877025c6a4e57c286a7dc8c7550b71d4e156"; }
{ locale = "gl"; arch = "linux-i686"; sha1 = "350847f8853219234edb68b9316cbcf486191f2a"; }
{ locale = "gl"; arch = "linux-x86_64"; sha1 = "7e4c444870d24d9b5ce283bbbf0e2ecdd5ed4d85"; }
{ locale = "gu-IN"; arch = "linux-i686"; sha1 = "6aa7416aeb84000778df3ff354f4efd2cd805d70"; }
{ locale = "gu-IN"; arch = "linux-x86_64"; sha1 = "262b35a170b39750dc19579caa05df19c98cac94"; }
{ locale = "he"; arch = "linux-i686"; sha1 = "e6a798072a9fb01e947e5d40e431d3e71256d3e3"; }
{ locale = "he"; arch = "linux-x86_64"; sha1 = "6674ba9cad77bbc912f94084f8fd2403f0ce42fb"; }
{ locale = "hi-IN"; arch = "linux-i686"; sha1 = "d10a236c1e8bc425cd8077b87816fe0a28405274"; }
{ locale = "hi-IN"; arch = "linux-x86_64"; sha1 = "d67449c5cfe939ab5531cf5a27e1da6e5b9335d7"; }
{ locale = "hr"; arch = "linux-i686"; sha1 = "f5e151299b3da7788e40dadf1c1d0fab6e409a00"; }
{ locale = "hr"; arch = "linux-x86_64"; sha1 = "6f6b79f283f11414ba2344e83cfb1f0197011c2e"; }
{ locale = "hsb"; arch = "linux-i686"; sha1 = "a56600d80d772d4009c8feeca7dc6d63c344c199"; }
{ locale = "hsb"; arch = "linux-x86_64"; sha1 = "40a7724e59e002446c0a9cfd35de948fc5311e54"; }
{ locale = "hu"; arch = "linux-i686"; sha1 = "d1e68650ec713a0d24e159fe967b73b26198d33c"; }
{ locale = "hu"; arch = "linux-x86_64"; sha1 = "abac7894c98a55bb3f7f2ca02a439575c241ea7c"; }
{ locale = "hy-AM"; arch = "linux-i686"; sha1 = "d45c305cb676c7456d8e8f4f803089d82077a8fa"; }
{ locale = "hy-AM"; arch = "linux-x86_64"; sha1 = "473b7beca08bcbf8d443f6efbe3ac8752a6773c8"; }
{ locale = "id"; arch = "linux-i686"; sha1 = "084dd83725e94a557e73d11f78633e1bf98e5d69"; }
{ locale = "id"; arch = "linux-x86_64"; sha1 = "e173e4f47878070a98afde349d2fb93a6ae1c342"; }
{ locale = "is"; arch = "linux-i686"; sha1 = "65b89daf623810a94bbaaaad301a2c3e9e6d4d5f"; }
{ locale = "is"; arch = "linux-x86_64"; sha1 = "f108f862dafe32a047c08c6fe1135611728d3f4f"; }
{ locale = "it"; arch = "linux-i686"; sha1 = "ba049d6eb3b455674caf424745607f49675a8ed6"; }
{ locale = "it"; arch = "linux-x86_64"; sha1 = "006f094f2966358ec685b00033e640a94d809d53"; }
{ locale = "ja"; arch = "linux-i686"; sha1 = "95f6d91f882d9d0ab8ff5d4b7654a102d973543f"; }
{ locale = "ja"; arch = "linux-x86_64"; sha1 = "e2a70547561a1fed87e3308ebf857df6cc3a315e"; }
{ locale = "kk"; arch = "linux-i686"; sha1 = "c0d239c2220979dc0daa15ab1e9af510d7c09706"; }
{ locale = "kk"; arch = "linux-x86_64"; sha1 = "d23bdcacb5714b10f773381fb9c8e3d628d2e278"; }
{ locale = "km"; arch = "linux-i686"; sha1 = "d9119536b4295fea892afd8ee1b46fd5eb881314"; }
{ locale = "km"; arch = "linux-x86_64"; sha1 = "1c7eb6d62b050769634fb487c0161c5748b8e4a2"; }
{ locale = "kn"; arch = "linux-i686"; sha1 = "491269cc3bbd577d24cfe898b862cad008d2da41"; }
{ locale = "kn"; arch = "linux-x86_64"; sha1 = "9043341ce5c84064aa80f95545404f5415bea782"; }
{ locale = "ko"; arch = "linux-i686"; sha1 = "13cad5dea192e57b03a26c09254e6fb7cc4022d3"; }
{ locale = "ko"; arch = "linux-x86_64"; sha1 = "8b2f6551415637ff8c9d2de1e1643aa5cd721d48"; }
{ locale = "lij"; arch = "linux-i686"; sha1 = "b57d7e89e0cf548ab016867d468d5fa2e3b429aa"; }
{ locale = "lij"; arch = "linux-x86_64"; sha1 = "3246755855f5d869ddf5724cbd2fb6c237d3ad35"; }
{ locale = "lt"; arch = "linux-i686"; sha1 = "804ee921241432208c83bdf70986628c5fc1ce1d"; }
{ locale = "lt"; arch = "linux-x86_64"; sha1 = "c2bd411ddf33382afd091cda7f2f6c4cf3dfb5d4"; }
{ locale = "lv"; arch = "linux-i686"; sha1 = "89dfa9f319c1d6681deea122a3f23e8ea4bf6248"; }
{ locale = "lv"; arch = "linux-x86_64"; sha1 = "8b209580ff83965ebc27aa3f97eac1180fb82ffd"; }
{ locale = "mai"; arch = "linux-i686"; sha1 = "ff727fe52dac2468d430c5d8d734dca133693e9c"; }
{ locale = "mai"; arch = "linux-x86_64"; sha1 = "21844cd80358d5ac24bd9d9ea2a6daadd296e760"; }
{ locale = "mk"; arch = "linux-i686"; sha1 = "cbc4cb34957fde341affa780ea743fb30aa13aad"; }
{ locale = "mk"; arch = "linux-x86_64"; sha1 = "4e395325fd1550710197822495c8873a89ff014c"; }
{ locale = "ml"; arch = "linux-i686"; sha1 = "19f538b937a9f4a3ef2ee498c64de69b214b87d4"; }
{ locale = "ml"; arch = "linux-x86_64"; sha1 = "ebc164cd9cf4c3993270949a13c9cb1123379093"; }
{ locale = "mr"; arch = "linux-i686"; sha1 = "a942c265bedf537e59fcde8bff39c3addb4a2963"; }
{ locale = "mr"; arch = "linux-x86_64"; sha1 = "8967615af2f2efe359f0babe614d282569e44691"; }
{ locale = "ms"; arch = "linux-i686"; sha1 = "89f8a2bd49ff4793b2d69efb48aaa93b031dfa69"; }
{ locale = "ms"; arch = "linux-x86_64"; sha1 = "d2be6c9f62cc0615f9041470bae3b139b69ef55c"; }
{ locale = "nb-NO"; arch = "linux-i686"; sha1 = "99afd0b77d350df671acbe403b9b19d975bcb91a"; }
{ locale = "nb-NO"; arch = "linux-x86_64"; sha1 = "b14f1b45617773a0e010d81ce83b493dd93dc03a"; }
{ locale = "nl"; arch = "linux-i686"; sha1 = "9a043691524087b9968aaac1b5d19a212ddffebb"; }
{ locale = "nl"; arch = "linux-x86_64"; sha1 = "f22f09a85bdd943c874a0b321ae1ec017200d0b4"; }
{ locale = "nn-NO"; arch = "linux-i686"; sha1 = "1cdbd8319688ccd0af636e71568d7f2244ca0d1a"; }
{ locale = "nn-NO"; arch = "linux-x86_64"; sha1 = "bf660208d072b92f4d961d63f6bfadf5d2848e97"; }
{ locale = "or"; arch = "linux-i686"; sha1 = "fe1edc33462f5b31d76b7b39ef7de459b2260658"; }
{ locale = "or"; arch = "linux-x86_64"; sha1 = "679eb537bd4007ef14b09dd705a0eaf5de6c29ff"; }
{ locale = "pa-IN"; arch = "linux-i686"; sha1 = "cfa52529dcb953c5448d589845bf22343fc6339f"; }
{ locale = "pa-IN"; arch = "linux-x86_64"; sha1 = "a603ec800745b17d7ef31ee4008b2ccfc6515a51"; }
{ locale = "pl"; arch = "linux-i686"; sha1 = "09e02683fa6fc34ff152533026824205f976b866"; }
{ locale = "pl"; arch = "linux-x86_64"; sha1 = "94ed7980eb737171e6d9a428a99cc1cbcfa98daa"; }
{ locale = "pt-BR"; arch = "linux-i686"; sha1 = "2a73ca16724778da05aca6284b50f8ce6b2855c9"; }
{ locale = "pt-BR"; arch = "linux-x86_64"; sha1 = "0c0fc357264ed7ef806729cf5f3a636829740c47"; }
{ locale = "pt-PT"; arch = "linux-i686"; sha1 = "02a6ce278285830a1d9a2f092321d73755fc6b71"; }
{ locale = "pt-PT"; arch = "linux-x86_64"; sha1 = "0bcf7133711b812d55e4c4f824f6cd53b83ce3ef"; }
{ locale = "rm"; arch = "linux-i686"; sha1 = "e314ce94c7f7f72882e4b2671f8a52488e293adc"; }
{ locale = "rm"; arch = "linux-x86_64"; sha1 = "878d2fa1fb737963bb93296d4e0f2e67cd58cb04"; }
{ locale = "ro"; arch = "linux-i686"; sha1 = "e4643626b93bacd2f2dae152228287aa0d84acf3"; }
{ locale = "ro"; arch = "linux-x86_64"; sha1 = "6e99ce189e18f7056720500cfa596c8caf8f5a17"; }
{ locale = "ru"; arch = "linux-i686"; sha1 = "cffab960763f296586e4bbbbc671409323844464"; }
{ locale = "ru"; arch = "linux-x86_64"; sha1 = "7455db46a81f99ba21d7a3ed0ae5a97246fae822"; }
{ locale = "si"; arch = "linux-i686"; sha1 = "ba2a4ddaf8f8978d01f996b599f26801ce3c3a5b"; }
{ locale = "si"; arch = "linux-x86_64"; sha1 = "8e5cf5885fe5e12e1cf28e7b77171ed23c4fd1c3"; }
{ locale = "sk"; arch = "linux-i686"; sha1 = "423e824526557309cb2ec007c41c57daf69e8b42"; }
{ locale = "sk"; arch = "linux-x86_64"; sha1 = "8205ce31e27a6595f2384a85f35f48610cd8b187"; }
{ locale = "sl"; arch = "linux-i686"; sha1 = "8766cf70ffd089e79d1eac1211bcc3255c86146d"; }
{ locale = "sl"; arch = "linux-x86_64"; sha1 = "f49ae94b77df1f038bae64f47f3ded0e4f10f349"; }
{ locale = "son"; arch = "linux-i686"; sha1 = "dd07bb545505ce0251760d7960ddcfb235856b79"; }
{ locale = "son"; arch = "linux-x86_64"; sha1 = "aa660969f12a316dd85f7e69678f583430e084aa"; }
{ locale = "sq"; arch = "linux-i686"; sha1 = "ea498b08ae2dceb0a103a7980ca086bc5ce94cb2"; }
{ locale = "sq"; arch = "linux-x86_64"; sha1 = "4e2d7c6098c3cc48cc7a3e5b1557b75e1a9c1958"; }
{ locale = "sr"; arch = "linux-i686"; sha1 = "e03a369d834c2a2a0a5bc9e539f2a007fa78641f"; }
{ locale = "sr"; arch = "linux-x86_64"; sha1 = "b8cc41734b718deb50654ccc24c20e5be0b767fd"; }
{ locale = "sv-SE"; arch = "linux-i686"; sha1 = "358efd06a28a9ad43703335d190f4bea9b5ef95a"; }
{ locale = "sv-SE"; arch = "linux-x86_64"; sha1 = "e63d4ad88ad45e1e4ed43906c4525a24c1b1cd1b"; }
{ locale = "ta"; arch = "linux-i686"; sha1 = "ce0fb4901e621dea2330cf80df632d9424ea46b6"; }
{ locale = "ta"; arch = "linux-x86_64"; sha1 = "5910ddf0f1bee1ae3e2ce5c2882ce93732edf586"; }
{ locale = "te"; arch = "linux-i686"; sha1 = "367816038ddfbd11b7ad6cc2bae41fe4d82b132b"; }
{ locale = "te"; arch = "linux-x86_64"; sha1 = "6e6c46db9e45bbe20861fc8d6f971daaaa63d181"; }
{ locale = "th"; arch = "linux-i686"; sha1 = "0d4859a54ae11c114cb449b150373465d92b795b"; }
{ locale = "th"; arch = "linux-x86_64"; sha1 = "16d95125a4c51df9ebd587df16cb428f560cb8e9"; }
{ locale = "tr"; arch = "linux-i686"; sha1 = "6bab2ad51c7cf6e761c147d0a0f748573b1683a2"; }
{ locale = "tr"; arch = "linux-x86_64"; sha1 = "ba660dbe60c4e95ac82f536313989933e1edddb6"; }
{ locale = "uk"; arch = "linux-i686"; sha1 = "1e1e5dd54da8e3b94da831909149721dd2766267"; }
{ locale = "uk"; arch = "linux-x86_64"; sha1 = "1f32f890d4a1ba2a672d25a005ef5daa76040e33"; }
{ locale = "uz"; arch = "linux-i686"; sha1 = "49b36171729e3e0924d8398b62c22d5a02b36b8c"; }
{ locale = "uz"; arch = "linux-x86_64"; sha1 = "2336db0769fa921f2a50774791174565e6828978"; }
{ locale = "vi"; arch = "linux-i686"; sha1 = "2b40d9003eca218d235574d1ee7d6da73244d614"; }
{ locale = "vi"; arch = "linux-x86_64"; sha1 = "517d6269f4c2a98f4817be8a926b82c261a8d1f5"; }
{ locale = "xh"; arch = "linux-i686"; sha1 = "9d24460c7bcd1e8b36d900a130bb88ecda967678"; }
{ locale = "xh"; arch = "linux-x86_64"; sha1 = "e70d742aa94bb4678446a4b94edd915033a640fb"; }
{ locale = "zh-CN"; arch = "linux-i686"; sha1 = "3eb4e076fc42e9cbd97dd82af8eb77d3ea6bb068"; }
{ locale = "zh-CN"; arch = "linux-x86_64"; sha1 = "bdbf6abd8e86f6811d032b302818f15f343e8883"; }
{ locale = "zh-TW"; arch = "linux-i686"; sha1 = "b7e4cf9bf9db13f3e2d92bdb91ede3f243232a0a"; }
{ locale = "zh-TW"; arch = "linux-x86_64"; sha1 = "411cfc0033ac8edeb30d9d371738864e9401200c"; }
{ locale = "ach"; arch = "linux-i686"; sha1 = "71e7e8194190bebcdde40a0e265b7dcb3d6173d1"; }
{ locale = "ach"; arch = "linux-x86_64"; sha1 = "eda799cc394838cf2a5eea4a182149ff2616bc00"; }
{ locale = "af"; arch = "linux-i686"; sha1 = "9162c87b2d1f420ccc5475b59bca72d45918fed3"; }
{ locale = "af"; arch = "linux-x86_64"; sha1 = "4f1d9f1bebea6a9adb085191b4bdb7b3367c4b9b"; }
{ locale = "an"; arch = "linux-i686"; sha1 = "537e6ea08c546d1ed704b1e9dd28b1219e1e5e8a"; }
{ locale = "an"; arch = "linux-x86_64"; sha1 = "34b9e09b3f29e1263105b713e743038b3a166cec"; }
{ locale = "ar"; arch = "linux-i686"; sha1 = "17b25623c086778caffd7ed45e10870a3d17baa1"; }
{ locale = "ar"; arch = "linux-x86_64"; sha1 = "4e35d4704dfd1218b783156d0a97340480eabe30"; }
{ locale = "as"; arch = "linux-i686"; sha1 = "596d66e6b3a8818ddd07ea285c08ca6ad508e4f6"; }
{ locale = "as"; arch = "linux-x86_64"; sha1 = "80b92c1881e2841dee4f955156237aadfdf37a33"; }
{ locale = "ast"; arch = "linux-i686"; sha1 = "7f6b67bbf751fb55419bb3893e121b50f4d5e34b"; }
{ locale = "ast"; arch = "linux-x86_64"; sha1 = "4705cda1e366b2be2be5164fedf22f5724454101"; }
{ locale = "az"; arch = "linux-i686"; sha1 = "5fa3021fcb1c0f7317738dcdd95f0f76ca70eb55"; }
{ locale = "az"; arch = "linux-x86_64"; sha1 = "b16d8a1e56ba3818f590952c19463b4eb08bb4a4"; }
{ locale = "be"; arch = "linux-i686"; sha1 = "300fca8783d59df6b4459760d0aaa5ac6af2a6cc"; }
{ locale = "be"; arch = "linux-x86_64"; sha1 = "d8d56febf53ed513628dc1604f65c60ac8460a37"; }
{ locale = "bg"; arch = "linux-i686"; sha1 = "4aad8ed44d69c3aecb9c629168f62d0e4711eea6"; }
{ locale = "bg"; arch = "linux-x86_64"; sha1 = "9eaddf470789ca0574ea07bbfdfbbcaca635c69d"; }
{ locale = "bn-BD"; arch = "linux-i686"; sha1 = "873db2012724c313f956ee0aca72341d443ff201"; }
{ locale = "bn-BD"; arch = "linux-x86_64"; sha1 = "3192ab016485d10abfb0dd7bccdbd94f3d33a706"; }
{ locale = "bn-IN"; arch = "linux-i686"; sha1 = "bb7b5dee4134546ce341e324a53c77e35e95b627"; }
{ locale = "bn-IN"; arch = "linux-x86_64"; sha1 = "057e4c7bc2a06c53209e87804516cb12a644be12"; }
{ locale = "br"; arch = "linux-i686"; sha1 = "d3a08e420b46d17f702c5b4bf1ed52160e8532c8"; }
{ locale = "br"; arch = "linux-x86_64"; sha1 = "e18d7a198b0bd1c08a3b0ef5ab453daacc7528a2"; }
{ locale = "bs"; arch = "linux-i686"; sha1 = "5ccfa1e2e8058707c6d0428bab370f8517c4e231"; }
{ locale = "bs"; arch = "linux-x86_64"; sha1 = "98e7ae1ca507e58b297acb39b7aa026530b75974"; }
{ locale = "ca"; arch = "linux-i686"; sha1 = "ff54c24002b0b1161a859771497f9a31013c265b"; }
{ locale = "ca"; arch = "linux-x86_64"; sha1 = "781161113c8719d8932365f113c1bfa1994caa63"; }
{ locale = "cs"; arch = "linux-i686"; sha1 = "f697723873da7961159ef17318b1b64c2d021a7c"; }
{ locale = "cs"; arch = "linux-x86_64"; sha1 = "44d20f198bbeca2c69fccbfc8d21c2861145102e"; }
{ locale = "cy"; arch = "linux-i686"; sha1 = "8ae202815c3c60aef0287f18b857ba432f122a84"; }
{ locale = "cy"; arch = "linux-x86_64"; sha1 = "c06b25151929540760d2d10dcdb0f4087a9f531a"; }
{ locale = "da"; arch = "linux-i686"; sha1 = "02690ab49d10976d5176c95f0cbc72509908fc1f"; }
{ locale = "da"; arch = "linux-x86_64"; sha1 = "0a4733b4e56e99976a53d99e209f84527c2a3059"; }
{ locale = "de"; arch = "linux-i686"; sha1 = "e3e067f028a018e4ae61542da9ae4e43c736f65b"; }
{ locale = "de"; arch = "linux-x86_64"; sha1 = "8161109d11373b07626b563c4ca494feca3abd41"; }
{ locale = "dsb"; arch = "linux-i686"; sha1 = "01fc9ebe4ac4a86a2bd4fedb6b07a9a832980a57"; }
{ locale = "dsb"; arch = "linux-x86_64"; sha1 = "7de40c35552ce74b66bdcf56a5e4edb75995f8d5"; }
{ locale = "el"; arch = "linux-i686"; sha1 = "f53b5bb439e882701dfe1efdcb7fb42ba15cc72d"; }
{ locale = "el"; arch = "linux-x86_64"; sha1 = "05843b9324fc255a4123a70d460e6db421cf55a7"; }
{ locale = "en-GB"; arch = "linux-i686"; sha1 = "c93568ad64a96235aec83ff8740335b07191d2ef"; }
{ locale = "en-GB"; arch = "linux-x86_64"; sha1 = "536b58997a39aed71a985d9eb9ab96602c9ab057"; }
{ locale = "en-US"; arch = "linux-i686"; sha1 = "8bfc35a45e9d0f2a2d4359ccaaee54c564d3b5e3"; }
{ locale = "en-US"; arch = "linux-x86_64"; sha1 = "b86e07f455da243f1236b8044aeccf41c4ade1b0"; }
{ locale = "en-ZA"; arch = "linux-i686"; sha1 = "cd3722feaebc63944e927ab244a95deb2a55aced"; }
{ locale = "en-ZA"; arch = "linux-x86_64"; sha1 = "0daf7c897bf695338310050374d29c2acdaea553"; }
{ locale = "eo"; arch = "linux-i686"; sha1 = "d79ecbf48f47a3e34e0bcf897d37d2a2abbf466a"; }
{ locale = "eo"; arch = "linux-x86_64"; sha1 = "95c616e21fe9d948d363db89c0a6a1a4e31301db"; }
{ locale = "es-AR"; arch = "linux-i686"; sha1 = "5ab97d5aebbde63477cf1868bf0cb5f1b79ee820"; }
{ locale = "es-AR"; arch = "linux-x86_64"; sha1 = "02d49650094d336e17f57fa43c9969d0b3221ca3"; }
{ locale = "es-CL"; arch = "linux-i686"; sha1 = "e8d10a3465e7efd01ee03e57316d60176710b124"; }
{ locale = "es-CL"; arch = "linux-x86_64"; sha1 = "f40a1ec33e5018d423b65bd26563ac8db100e50d"; }
{ locale = "es-ES"; arch = "linux-i686"; sha1 = "66a1bc0c31061d5738bc80e9254262ada65bfb71"; }
{ locale = "es-ES"; arch = "linux-x86_64"; sha1 = "8f22bab29fb4e7359aa1261f2333faecbafe4c08"; }
{ locale = "es-MX"; arch = "linux-i686"; sha1 = "34f60fef14360b754510a5378d4b5d6855d49326"; }
{ locale = "es-MX"; arch = "linux-x86_64"; sha1 = "9d024945473b55373c155dbbec8880f79ee2de5e"; }
{ locale = "et"; arch = "linux-i686"; sha1 = "2fd526c6fd23e5b0e7b292d99a60cf1530bb84e1"; }
{ locale = "et"; arch = "linux-x86_64"; sha1 = "15628af429866cac3a1604f587b08d4bbeccb7e9"; }
{ locale = "eu"; arch = "linux-i686"; sha1 = "ea55480fd572173c1461a9e41c2080af890c4667"; }
{ locale = "eu"; arch = "linux-x86_64"; sha1 = "1e7f8cd86df1cf74525f8d07d13bcd8ea2a22b87"; }
{ locale = "fa"; arch = "linux-i686"; sha1 = "24982ebb6d6cac67673a9c39c91da7adc4c825c2"; }
{ locale = "fa"; arch = "linux-x86_64"; sha1 = "02f221c5526e03edadb2c36bfa5d9e35557d03a3"; }
{ locale = "ff"; arch = "linux-i686"; sha1 = "f3b8962106a9a4bc5b4f1d2928255cfaaa9094b0"; }
{ locale = "ff"; arch = "linux-x86_64"; sha1 = "3a8ebe66407e6369ebc26757562b4f48a6773cdd"; }
{ locale = "fi"; arch = "linux-i686"; sha1 = "c8a838618b2a8d267e24596c6cbc25f539676762"; }
{ locale = "fi"; arch = "linux-x86_64"; sha1 = "3382937e58f6e244d3c6dcef1051aa6bdd38692c"; }
{ locale = "fr"; arch = "linux-i686"; sha1 = "6fefc6e8548fa8fcc7182a05b06b00a3b50bb5d6"; }
{ locale = "fr"; arch = "linux-x86_64"; sha1 = "5b58fe2c383d4d43d1731f25dc52754712bc207d"; }
{ locale = "fy-NL"; arch = "linux-i686"; sha1 = "118c326cdedbc4e5a1bac1ff6b1bb92f5d054847"; }
{ locale = "fy-NL"; arch = "linux-x86_64"; sha1 = "384e13b51d09e99b2abce566d06d7cd522a532a7"; }
{ locale = "ga-IE"; arch = "linux-i686"; sha1 = "ae6002a1a9b1be4f29a56176aa4dfd2fee543bdd"; }
{ locale = "ga-IE"; arch = "linux-x86_64"; sha1 = "c87ac5ff79b4dbf3d8738cc3309c882d7573eb3b"; }
{ locale = "gd"; arch = "linux-i686"; sha1 = "2bfd0ccec6d84b22d3f6f471f4ad096e6dc1edd3"; }
{ locale = "gd"; arch = "linux-x86_64"; sha1 = "cc919edd60169de8167c9e9fcf32f94fe9df4f52"; }
{ locale = "gl"; arch = "linux-i686"; sha1 = "70cdf62012d3d98b028d6b9fb9adf077c37e7c0c"; }
{ locale = "gl"; arch = "linux-x86_64"; sha1 = "a090ce8a36f3182aba809823ba171a0702bf17b5"; }
{ locale = "gu-IN"; arch = "linux-i686"; sha1 = "5698a36c3f1372446e38ada59e45468f07fd5d19"; }
{ locale = "gu-IN"; arch = "linux-x86_64"; sha1 = "18b49c1004778b8b11d2f3961dfed29ba562430a"; }
{ locale = "he"; arch = "linux-i686"; sha1 = "9edddef1ce1361d76917ce255f348e208bb16697"; }
{ locale = "he"; arch = "linux-x86_64"; sha1 = "64136eeab22a5150a95bdc916ce81e2f1b42a6df"; }
{ locale = "hi-IN"; arch = "linux-i686"; sha1 = "314f99e05cf58ec8a2c50f8fe93ebe648a62a570"; }
{ locale = "hi-IN"; arch = "linux-x86_64"; sha1 = "2e9245f46a28c70aa5451011bd2c59e8100a1804"; }
{ locale = "hr"; arch = "linux-i686"; sha1 = "4cc1112e81ec7f8df2ef95bbab3b3eb398ea67eb"; }
{ locale = "hr"; arch = "linux-x86_64"; sha1 = "e9d643c799542b118ce8cf274ab36aaec89850b3"; }
{ locale = "hsb"; arch = "linux-i686"; sha1 = "e525b1c0a77274c851417c1d3af887657d9dcb18"; }
{ locale = "hsb"; arch = "linux-x86_64"; sha1 = "016e3fcbaeb7844e3639e1c2599172de5c3f7b2f"; }
{ locale = "hu"; arch = "linux-i686"; sha1 = "2234cff2bb19e849d1a6ace38dd63258a54c192f"; }
{ locale = "hu"; arch = "linux-x86_64"; sha1 = "9498c156b33d8a9f90ccef6ccc202c69e4ee6c3d"; }
{ locale = "hy-AM"; arch = "linux-i686"; sha1 = "49e7923e60daea2e0df4c27d1f6baad70b24b030"; }
{ locale = "hy-AM"; arch = "linux-x86_64"; sha1 = "c9bed347d74b399901ee3f8e745ed1832462357e"; }
{ locale = "id"; arch = "linux-i686"; sha1 = "7fecad428f80346a6333aa6cdc912cec0644b306"; }
{ locale = "id"; arch = "linux-x86_64"; sha1 = "7370cb725b9087e5bff8943208762bc5bf4d01d9"; }
{ locale = "is"; arch = "linux-i686"; sha1 = "c1139da81e8e581e7ddd511d0ce16c0b169d46f0"; }
{ locale = "is"; arch = "linux-x86_64"; sha1 = "63c64558cd22ac170b39e186c1dd0e77a09c3200"; }
{ locale = "it"; arch = "linux-i686"; sha1 = "4eb39e3fc5c3847a85a618100d3a9edc9d3bfe78"; }
{ locale = "it"; arch = "linux-x86_64"; sha1 = "37fa87367363d7e337e75da89f8e5ce8f762c755"; }
{ locale = "ja"; arch = "linux-i686"; sha1 = "47b6d53050cf10535a5f7d6a8cee78ab15ad36b7"; }
{ locale = "ja"; arch = "linux-x86_64"; sha1 = "48b20dd2a743a1b887d15179c87b266dbe89a1ae"; }
{ locale = "kk"; arch = "linux-i686"; sha1 = "4046e0f75d4657d7423b4a0da53778348442ee5e"; }
{ locale = "kk"; arch = "linux-x86_64"; sha1 = "039f3c025f562e9278b16fb065d07511a3ca1f54"; }
{ locale = "km"; arch = "linux-i686"; sha1 = "7baebf01741af616e69520f4bc95dd56187c12a2"; }
{ locale = "km"; arch = "linux-x86_64"; sha1 = "f1a0557ac698f79bf926756cca2c33bd12a8ae83"; }
{ locale = "kn"; arch = "linux-i686"; sha1 = "1d2c2f8d9f455e0b6c793749f2298436167c25e4"; }
{ locale = "kn"; arch = "linux-x86_64"; sha1 = "473abeac7637b82d910427cac7e6da8ece20a4e5"; }
{ locale = "ko"; arch = "linux-i686"; sha1 = "41fe278dc963a7464679f4ec8a9e586666e7ceb3"; }
{ locale = "ko"; arch = "linux-x86_64"; sha1 = "58563ea60e40b73d1d5c9b10797d05aba5d13c95"; }
{ locale = "lij"; arch = "linux-i686"; sha1 = "dfa1c12416a9e7e6d04e5f4aaed3a03731d98372"; }
{ locale = "lij"; arch = "linux-x86_64"; sha1 = "75f9fb66b6610b65b402d3c8664096b4194ce1b0"; }
{ locale = "lt"; arch = "linux-i686"; sha1 = "667f035cb58c56967ed28f9cde44864cb15d5afa"; }
{ locale = "lt"; arch = "linux-x86_64"; sha1 = "d5709105b8255ee94c96358d2ac447dc5e4acc2d"; }
{ locale = "lv"; arch = "linux-i686"; sha1 = "b090761ded023ed465fc9629873e08ecdbaf924b"; }
{ locale = "lv"; arch = "linux-x86_64"; sha1 = "529312d4e7109472bf5b97ed4a9fff58bb8adbd5"; }
{ locale = "mai"; arch = "linux-i686"; sha1 = "d2ced083aefcdcd5aca84471bc382be8247e8745"; }
{ locale = "mai"; arch = "linux-x86_64"; sha1 = "be7a808a391a4fd1dde215834756bc61ae5e85fa"; }
{ locale = "mk"; arch = "linux-i686"; sha1 = "8a079d8ee62e3bf8fb37f81385a270af5e474aef"; }
{ locale = "mk"; arch = "linux-x86_64"; sha1 = "c644e5c7a6506ab203d1be61264f6bcf9fa52946"; }
{ locale = "ml"; arch = "linux-i686"; sha1 = "d3bd6308643ae805c69eeee8b716b97dc844ed9c"; }
{ locale = "ml"; arch = "linux-x86_64"; sha1 = "33f0f47e125f8a67a30d807775c7d0743135da84"; }
{ locale = "mr"; arch = "linux-i686"; sha1 = "9d38caee6d6c0baa8a7ea6148c65e7a28362a0fe"; }
{ locale = "mr"; arch = "linux-x86_64"; sha1 = "3c3f93fd22c8ae7d7056bbfae3df0ecaa7d7dcaf"; }
{ locale = "ms"; arch = "linux-i686"; sha1 = "8486b9a81265430e876410a6040e09f0bf6d4eed"; }
{ locale = "ms"; arch = "linux-x86_64"; sha1 = "6cd3c0ab1c33d8eb3de6f68ce7c7a219e80f49f9"; }
{ locale = "nb-NO"; arch = "linux-i686"; sha1 = "bcd8e685a023c9919479ffe0f77c16df4fe3e2e8"; }
{ locale = "nb-NO"; arch = "linux-x86_64"; sha1 = "8052c43680c9720783b6e1947c949030f1cfa51a"; }
{ locale = "nl"; arch = "linux-i686"; sha1 = "c0ae9e1fb361a7d085ef296f5afcc61a5b106c94"; }
{ locale = "nl"; arch = "linux-x86_64"; sha1 = "246213bd7baa7bb32b15c39237c0eece624a8dae"; }
{ locale = "nn-NO"; arch = "linux-i686"; sha1 = "f5f7b590544228f110ddb1153f1c5354bea58656"; }
{ locale = "nn-NO"; arch = "linux-x86_64"; sha1 = "c62e1e681736dbdf19d1a8c6a7f3eff01764d050"; }
{ locale = "or"; arch = "linux-i686"; sha1 = "8008fd2095b86bd05daee4e48f95aa9003982ebf"; }
{ locale = "or"; arch = "linux-x86_64"; sha1 = "a52d6d27d9612fe9b1aa3dac377d783bcc53baa1"; }
{ locale = "pa-IN"; arch = "linux-i686"; sha1 = "a819a01f2968030cc2102640f50e31cb340e5044"; }
{ locale = "pa-IN"; arch = "linux-x86_64"; sha1 = "2b8e58cf70e8cc841e720706a511e0626439b8ac"; }
{ locale = "pl"; arch = "linux-i686"; sha1 = "db1bb9bbf35166ba760274dd4c813bf4b52db2da"; }
{ locale = "pl"; arch = "linux-x86_64"; sha1 = "1a97efa01142188d282743bd3f97dec2bf51067a"; }
{ locale = "pt-BR"; arch = "linux-i686"; sha1 = "d3b3f3de01e6970909d6083a2164eb840897d46e"; }
{ locale = "pt-BR"; arch = "linux-x86_64"; sha1 = "e842275df31fa1202a6e5214424b870ed8e04789"; }
{ locale = "pt-PT"; arch = "linux-i686"; sha1 = "86001510f93e7063442415325cea1772a8fe04e8"; }
{ locale = "pt-PT"; arch = "linux-x86_64"; sha1 = "7090a6adb110be77527bca5a40ea5c44515e07d3"; }
{ locale = "rm"; arch = "linux-i686"; sha1 = "42087d61aed17ce567503cc944bbada7d5bc77a4"; }
{ locale = "rm"; arch = "linux-x86_64"; sha1 = "7b3a8078235ca307dc75b931b060d46a7b3e8e95"; }
{ locale = "ro"; arch = "linux-i686"; sha1 = "1ff6eb3feef71d37f943667945f4547fe9daca37"; }
{ locale = "ro"; arch = "linux-x86_64"; sha1 = "acf3f0c0ad5bd9b3c2edcafe7dd7b6e8e45a7ec4"; }
{ locale = "ru"; arch = "linux-i686"; sha1 = "3e9b32187704caec231fce83e5519d2b2fc066a7"; }
{ locale = "ru"; arch = "linux-x86_64"; sha1 = "065fee4f21ff6ebdc21a81aadc86a20ab3281dad"; }
{ locale = "si"; arch = "linux-i686"; sha1 = "d742e451a73195d0445b393b0f1127835ad4684b"; }
{ locale = "si"; arch = "linux-x86_64"; sha1 = "6341e742bfab7379d8a9de9545a126efa9f129ba"; }
{ locale = "sk"; arch = "linux-i686"; sha1 = "c714445df861c7073e8c840d904c91578c08db7a"; }
{ locale = "sk"; arch = "linux-x86_64"; sha1 = "a8fbdfa4c68092ff5258f88b7413d64fd0729ce6"; }
{ locale = "sl"; arch = "linux-i686"; sha1 = "dc4ef7a8aedbebcd3b9a0e6701c8b2fb245f784a"; }
{ locale = "sl"; arch = "linux-x86_64"; sha1 = "6165e3a1ef198eae25d56fa5b8dde4e37b037b9f"; }
{ locale = "son"; arch = "linux-i686"; sha1 = "2dd5909759dc85ae7a9401eb4c759748805b0729"; }
{ locale = "son"; arch = "linux-x86_64"; sha1 = "d09741294a24d80ddacb80676a2824cbd51a5585"; }
{ locale = "sq"; arch = "linux-i686"; sha1 = "1f2e3fa864c7c8f7f2d0ecca7812bfdfe7991d29"; }
{ locale = "sq"; arch = "linux-x86_64"; sha1 = "db5c95f01d258db2dfc04b7efecd1d7826663db8"; }
{ locale = "sr"; arch = "linux-i686"; sha1 = "54c0f91e41622e8263f7897d0b5a385870ae0d7a"; }
{ locale = "sr"; arch = "linux-x86_64"; sha1 = "b8b9c9001ed87429ce868144a50e6ab1ac7ccd5f"; }
{ locale = "sv-SE"; arch = "linux-i686"; sha1 = "667ed9f21997fc79e9ce40b8bf5e607258292699"; }
{ locale = "sv-SE"; arch = "linux-x86_64"; sha1 = "cb5abaca549b30ba5385ea3ef0a57be0bf446d44"; }
{ locale = "ta"; arch = "linux-i686"; sha1 = "13fdda06ab9a36a24128e12651a06f0499fbe581"; }
{ locale = "ta"; arch = "linux-x86_64"; sha1 = "95cd3149f404cfd0beadcdece8dfd5c102dbc72a"; }
{ locale = "te"; arch = "linux-i686"; sha1 = "4ec9f9b30078e70451bbf5bb06cc1c07530ed5a8"; }
{ locale = "te"; arch = "linux-x86_64"; sha1 = "1d5cbfee0731dfe10e3eb3aafe102e73c9e9eede"; }
{ locale = "th"; arch = "linux-i686"; sha1 = "a6809b082761293aca28b456b1489f270234f8bf"; }
{ locale = "th"; arch = "linux-x86_64"; sha1 = "77dba4a3eec1474be026dfc9021420af889172ad"; }
{ locale = "tr"; arch = "linux-i686"; sha1 = "eaa7a43b155ffbfc23e72b48fe0e150695a779e7"; }
{ locale = "tr"; arch = "linux-x86_64"; sha1 = "dfc241131ef4e46801e86bfe10e80b4c2bb5fdb3"; }
{ locale = "uk"; arch = "linux-i686"; sha1 = "fa5346d0c36f88a6a50259f0e170bbe5167f2393"; }
{ locale = "uk"; arch = "linux-x86_64"; sha1 = "bb5d61d9c14997958af850d663d48b607aa3e43e"; }
{ locale = "uz"; arch = "linux-i686"; sha1 = "d634d94bc28779757535d05295db33e186c15abc"; }
{ locale = "uz"; arch = "linux-x86_64"; sha1 = "0f469e0d5f2d92b4b3f2b47efef3aa44cd25803f"; }
{ locale = "vi"; arch = "linux-i686"; sha1 = "639aa1abebe1b670ecef9df6e9d06841124ddf0b"; }
{ locale = "vi"; arch = "linux-x86_64"; sha1 = "16f1319cb63cc4634a215a1c9b3e0e65c1833003"; }
{ locale = "xh"; arch = "linux-i686"; sha1 = "960338fec19485c733ebd7fbacd9b55ebd1b9981"; }
{ locale = "xh"; arch = "linux-x86_64"; sha1 = "3a795ffee6d119741fceaa0a4825e72f5cc4e0f2"; }
{ locale = "zh-CN"; arch = "linux-i686"; sha1 = "63dbb0328ea991b827fd5747d99aa3075486fce0"; }
{ locale = "zh-CN"; arch = "linux-x86_64"; sha1 = "a1d047de7685d70750850cfb0084259041d33cd4"; }
{ locale = "zh-TW"; arch = "linux-i686"; sha1 = "6f56944d2e31ab714d648bfd9262d39731e167b9"; }
{ locale = "zh-TW"; arch = "linux-x86_64"; sha1 = "d3cd71c2ceeb1856bea66de8d7220a8529888e86"; }
];
}

4
pkgs/applications/networking/browsers/firefox/default.nix
View File

@ -15,14 +15,14 @@
assert stdenv.cc ? libc && stdenv.cc.libc != null;
let version = "38.0.1"; in
let version = "38.0.5"; in
stdenv.mkDerivation rec {
name = "firefox-${version}";
src = fetchurl {
url = "http://ftp.mozilla.org/pub/mozilla.org/firefox/releases/${version}/source/firefox-${version}.source.tar.bz2";
sha1 = "20f52c37e099cb2b21f3a76c6e39fe698e1e79e8";
sha1 = "74da3e225d5b542e784549be63475802c45e1b02";
};
buildInputs =

6
pkgs/applications/networking/browsers/mozilla-plugins/flashplayer-11/default.nix
View File

@ -36,7 +36,7 @@
let
# -> http://get.adobe.com/flashplayer/
version = "11.2.202.457";
version = "11.2.202.460";
src =
if stdenv.system == "x86_64-linux" then
@ -47,7 +47,7 @@ let
else rec {
inherit version;
url = "http://fpdownload.macromedia.com/get/flashplayer/pdc/${version}/install_flash_player_11_linux.x86_64.tar.gz";
sha256 = "0nkr6p4h5l03ywsj1sbap359cl1x9rq3m12j9gvwvbvn935rmyr2";
sha256 = "152hhxismgvz6hkh5m8z5x1drpwflymd2zk3v96nszpkb2xxirnr";
}
else if stdenv.system == "i686-linux" then
if debug then
@ -60,7 +60,7 @@ let
else rec {
inherit version;
url = "http://fpdownload.macromedia.com/get/flashplayer/pdc/${version}/install_flash_player_11_linux.i386.tar.gz";
sha256 = "0qil5rb61bkn80fij31nv29q2wa7bxiwwxgy5zlkm2hsyrz3y4kc";
sha256 = "15655c3kzk1mk00737wgc52i4zz5jh9fkjgjs747qwiik5pnh7x1";
}
else throw "Flash Player is not supported on this platform";

2
pkgs/applications/networking/browsers/vimb/default.nix
View File

@ -13,7 +13,7 @@ stdenv.mkDerivation rec {
# Nixos default ca bundle
patchPhase = ''
sed -i s,/etc/ssl/certs/ca-certificates.crt,${cacert}/ca-bundle.crt, src/config.def.h
sed -i s,/etc/ssl/certs/ca-certificates.crt,${cacert}/etc/ssl/certs/ca-bundle.crt, src/config.def.h
'';
buildInputs = [ makeWrapper gtk libsoup pkgconfig webkit gsettings_desktop_schemas ];

2
pkgs/applications/networking/browsers/vimprobable2/default.nix
View File

@ -11,7 +11,7 @@ stdenv.mkDerivation rec {
# Nixos default ca bundle
patchPhase = ''
sed -i s,/etc/ssl/certs/ca-certificates.crt,${cacert}/ca-bundle.crt, config.h
sed -i s,/etc/ssl/certs/ca-certificates.crt,${cacert}/etc/ssl/certs/ca-bundle.crt, config.h
'';
buildInputs = [ makeWrapper gtk libsoup libX11 perl pkgconfig webkit gsettings_desktop_schemas ];

2
pkgs/applications/networking/cluster/panamax/api/default.nix
View File

@ -62,7 +62,7 @@ stdenv.mkDerivation rec {
--prefix "PATH" : "$out/share/panamax-api/bin:${env.ruby}/bin:$PATH" \
--prefix "HOME" : "$out/share/panamax-api" \
--prefix "GEM_HOME" : "${env}/${env.ruby.gemPath}" \
--prefix "SSL_CERT_FILE" : "${cacert}/ca-bundle.crt" \
--prefix "SSL_CERT_FILE" : "${cacert}/etc/ssl/certs/ca-bundle.crt" \
--prefix "GEM_PATH" : "$out/share/panamax-api:${bundler}/${env.ruby.gemPath}"
'';

6
pkgs/applications/networking/feedreaders/rsstail/default.nix
View File

@ -1,12 +1,12 @@
{ stdenv, fetchFromGitHub, cppcheck, libmrss }:
let version = "1.9"; in
let version = "1.9.1"; in
stdenv.mkDerivation rec {
name = "rsstail-${version}";
src = fetchFromGitHub {
sha256 = "0igkkhwzhi2cxbfirmq5xgaidnv0gdhmh2w7052xqpyvzg069faf";
rev = "aab4fbcc5cdf82e439ea6abe562e9b648fc1a6ef";
sha256 = "0jhf7vr7y56r751wy4ix80iwhgxhk6mbbin8gnx59i457gf6sjl1";
rev = "1220d63aaa233961636f859d9a406536fffb64f4";
repo = "rsstail";
owner = "flok99";
};

2
pkgs/applications/networking/instant-messengers/fuze/default.nix
View File

@ -6,7 +6,7 @@ assert stdenv.system == "x86_64-linux";
let
curl_custom =
stdenv.lib.overrideDerivation curl (args: {
configureFlags = args.configureFlags ++ ["--with-ca-bundle=${cacert}/ca-bundle.crt"] ;
configureFlags = args.configureFlags ++ ["--with-ca-bundle=${cacert}/etc/ssl/certs/ca-bundle.crt"] ;
} );
in
stdenv.mkDerivation {

5
pkgs/applications/networking/instant-messengers/jitsi/default.nix
View File

@ -3,13 +3,14 @@
stdenv.mkDerivation rec {
name = "jitsi-${version}";
version = "2.4.4997";
version = "2.8.5426";
src = fetchurl {
url = "https://download.jitsi.org/jitsi/src/jitsi-src-${version}.zip";
sha256 = "f1c2688d7d6bf1916fed3b8b105a785662980c5b297dcab3c9e7d272647ef825";
sha256 = "0v7k16in2i57z5amr7k5c3fc8f0azrzrs5dvn729bwbc31z8cjg6";
};
patches = [ ./jitsi.patch ];
jitsiItem = makeDesktopItem {

2
pkgs/applications/networking/instant-messengers/telegram-cli/default.nix
View File

@ -2,7 +2,7 @@
}:
stdenv.mkDerivation rec {
name = "telegram-cli";
name = "telegram-cli-2014-03-04";
src = fetchgit {
url = "https://github.com/vysheng/tg.git";

2
pkgs/applications/networking/instant-messengers/telepathy/gabble/default.nix
View File

@ -13,7 +13,7 @@ stdenv.mkDerivation rec {
buildInputs = [ libxml2 dbus_glib sqlite libsoup libnice telepathy_glib gnutls ]
++ stdenv.lib.optional doCheck dbus_daemon;
configureFlags = "--with-ca-certificates=${cacert}/ca-bundle.crt";
configureFlags = "--with-ca-certificates=${cacert}/etc/ssl/certs/ca-bundle.crt";
enableParallelBuilding = true;
doCheck = true;

2
pkgs/applications/networking/irc/weechat/default.nix
View File

@ -18,7 +18,7 @@ stdenv.mkDerivation rec {
cacert cmake ]
++ extraBuildInputs;
NIX_CFLAGS_COMPILE = "-I${python}/include/${python.libPrefix} -DCA_FILE=${cacert}/ca-bundle.crt";
NIX_CFLAGS_COMPILE = "-I${python}/include/${python.libPrefix} -DCA_FILE=${cacert}/etc/ssl/certs/ca-bundle.crt";
postInstall = ''
NIX_PYTHONPATH="$out/lib/${python.libPrefix}/site-packages"

4
pkgs/applications/networking/p2p/opentracker/default.nix
View File

@ -1,7 +1,7 @@
{ stdenv, fetchgit, libowfat, zlib }:
stdenv.mkDerivation {
name = "opentracker";
name = "opentracker-2014-08-03";
src = fetchgit {
url = "https://github.com/masroore/opentracker.git";
rev = "9a26b3d203755577879315ecc2b515d0e22793cb";
@ -21,4 +21,4 @@ stdenv.mkDerivation {
platforms = platforms.linux;
description = "Bittorrent tracker project aiminf for minimal resource usage and is intended to run at your wlan router";
};
}
}

4
pkgs/applications/science/logic/hol_light/default.nix
View File

@ -10,12 +10,12 @@ in
stdenv.mkDerivation rec {
name = "hol_light-${version}";
version = "218";
version = "232";
src = fetchsvn {
url = http://hol-light.googlecode.com/svn/trunk;
rev = version;
sha256 = "0lidcadyjpyqd2iw90gfrm8hb6g9gpabp54c0ps6z0lb6hdzln74";
sha256 = "1cips2cb5wqxb6n2qi28af2ap1vhklqbhjy7pnifgz4dilkz10m8";
};
buildInputs = [ ocaml findlib camlp5 ];

8
pkgs/applications/science/logic/why3/default.nix
View File

@ -2,15 +2,15 @@
stdenv.mkDerivation rec {
name = "why3-${version}";
version = "0.85";
version = "0.86.1";
src = fetchurl {
url = "https://gforge.inria.fr/frs/download.php/34074/why3-0.85.tar.gz";
sha256 = "0sj1pd50lqvnvyss1f8ysgigdi64s91rrpdrmp7crmcy1npa8apf";
url = https://gforge.inria.fr/frs/download.php/file/34797/why3-0.86.1.tar.gz;
sha256 = "129kzq79n8h480zrlphgh1ixvwp3wm18nbcky9bp4wdnr6zaibd7";
};
buildInputs = with ocamlPackages;
[ coq coq.camlp5 ocaml findlib lablgtk ocamlgraph zarith ];
[ coq coq.camlp5 ocaml findlib lablgtk ocamlgraph zarith menhir ];
meta = with stdenv.lib; {
description = "A platform for deductive program verification";

2
pkgs/applications/version-management/bazaar/default.nix
View File

@ -19,7 +19,7 @@ stdenv.mkDerivation rec {
patches = [ ./add_certificates.patch ];
postPatch = ''
substituteInPlace bzrlib/transport/http/_urllib2_wrappers.py \
--subst-var-by "certPath" "${cacert}/ca-bundle.crt"
--subst-var-by "certPath" "${cacert}/etc/ssl/certs/ca-bundle.crt"
'';

39
pkgs/applications/version-management/git-and-tools/git-hub/default.nix Normal file
View File

@ -0,0 +1,39 @@
{ stdenv, fetchFromGitHub, docutils, python }:
let version = "0.9.0"; in
stdenv.mkDerivation {
name = "git-hub-${version}";
src = fetchFromGitHub {
sha256 = "0c4kq4a906lr8nzway7qh0560n2ydvidh9rlffh44902rd48kp0h";
rev = "v${version}";
repo = "git-hub";
owner = "sociomantic";
};
meta = with stdenv.lib; {
inherit version;
description = "Git command line interface to GitHub";
longDescription = ''
A simple command line interface to GitHub, enabling most useful GitHub
tasks (like creating and listing pull request or issues) to be accessed
directly through the Git command line.
'';
homepage = https://github.com/sociomantic/git-hub;
license = licenses.gpl3Plus;
platforms = with platforms; linux;
maintainers = with maintainers; [ nckx ];
};
buildInputs = [ python ];
nativeBuildInputs = [ docutils ];
postPatch = ''
substituteInPlace Makefile --replace rst2man rst2man.py
patchShebangs .
'';
enableParallelBuilding = true;
installFlags = "prefix=$(out)";
}

2
pkgs/applications/version-management/mercurial/default.nix
View File

@ -44,7 +44,7 @@ stdenv.mkDerivation {
mkdir -p $out/etc/mercurial
cat >> $out/etc/mercurial/hgrc << EOF
[web]
cacerts = ${cacert}/ca-bundle.crt
cacerts = ${cacert}/etc/ssl/certs/ca-bundle.crt
EOF
# copy hgweb.cgi to allow use in apache

12
pkgs/applications/video/kodi/default.nix
View File

@ -21,7 +21,7 @@
, samba ? null, sambaSupport ? true
, libmicrohttpd, bash
# TODO: would be nice to have nfsSupport (needs libnfs library)
# TODO: librtmp
, rtmpdump ? null, rtmpSupport ? true
, libvdpau ? null, vdpauSupport ? true
, libpulseaudio ? null, pulseSupport ? true
, libcec ? null, cecSupport ? true
@ -34,6 +34,7 @@ assert sambaSupport -> samba != null;
assert vdpauSupport -> libvdpau != null;
assert pulseSupport -> libpulseaudio != null;
assert cecSupport -> libcec != null;
assert rtmpSupport -> rtmpdump != null;
let
rel = "Helix";
@ -75,7 +76,8 @@ in stdenv.mkDerivation rec {
++ lib.optional sambaSupport samba
++ lib.optional vdpauSupport libvdpau
++ lib.optional pulseSupport libpulseaudio
++ lib.optional cecSupport libcec;
++ lib.optional cecSupport libcec
++ lib.optional rtmpSupport rtmpdump;
dontUseCmakeConfigure = true;
@ -96,7 +98,8 @@ in stdenv.mkDerivation rec {
]
++ lib.optional (!sambaSupport) "--disable-samba"
++ lib.optional vdpauSupport "--enable-vdpau"
++ lib.optional pulseSupport "--enable-pulse";
++ lib.optional pulseSupport "--enable-pulse"
++ lib.optional rtmpSupport "--enable-rtmp";
postInstall = ''
for p in $(ls $out/bin/) ; do
@ -108,7 +111,8 @@ in stdenv.mkDerivation rec {
--prefix LD_LIBRARY_PATH ":" "${systemd}/lib" \
--prefix LD_LIBRARY_PATH ":" "${libmad}/lib" \
--prefix LD_LIBRARY_PATH ":" "${libvdpau}/lib" \
--prefix LD_LIBRARY_PATH ":" "${libcec}/lib"
--prefix LD_LIBRARY_PATH ":" "${libcec}/lib" \
--prefix LD_LIBRARY_PATH ":" "${rtmpdump}/lib"
done
'';

251
pkgs/applications/virtualization/qemu/default.nix
View File

@ -1,229 +1,70 @@
{ stdenv, fetchurl, pkgconfig, libtool, python, perl, texinfo, flex, bison
, gettext, makeWrapper, glib, zlib, pixman
# Optional Arguments
, SDL2 ? null, gtk ? null, gnutls ? null, cyrus_sasl ? null, libjpeg ? null
, libpng ? null, ncurses ? null, curl ? null, libcap ? null, attr ? null
, bluez ? null, libibverbs ? null, librdmacm ? null, libuuid ? null, vde2 ? null
, libaio ? null, libcap_ng ? null, spice ? null, spice_protocol ? null
, libceph ? null, libxfs ? null, nss ? null, nspr ? null, libusb ? null
, usbredir ? null, mesa ? null, lzo ? null, snappy ? null, bzip2 ? null
, libseccomp ? null, glusterfs ? null, libssh2 ? null, numactl ? null
# Audio libraries
, libpulseaudio ? null, alsaLib ? null
# Extra options
, type ? ""
{ stdenv, fetchurl, python, zlib, pkgconfig, glib, ncurses, perl, pixman
, attr, libcap, vde2, alsaLib, texinfo, libuuid, flex, bison, lzo, snappy
, libseccomp, libaio, libcap_ng, gnutls
, makeWrapper
, pulseSupport ? true, libpulseaudio
, sdlSupport ? true, SDL
, vncSupport ? true, libjpeg, libpng
, spiceSupport ? true, spice, spice_protocol, usbredir
, x86Only ? false
}:
with stdenv;
with stdenv.lib;
let
n = "qemu-2.3.0";
isKvmOnly = type == "kvm-only";
isNix = type == "nix";
optSDL2 = if isNix then null else shouldUsePkg SDL2;
optGtk = if isNix then null else shouldUsePkg gtk;
optLibcap = if isNix then null else shouldUsePkg libcap;
optAttr = if isNix then null else shouldUsePkg attr;
optGnutls = if isNix then null else shouldUsePkg gnutls;
optCyrus_sasl = if isNix then null else shouldUsePkg cyrus_sasl;
optLibjpeg = if isNix then null else shouldUsePkg libjpeg;
optLibpng = if isNix then null else shouldUsePkg libpng;
optNcurses = if isNix then null else shouldUsePkg ncurses;
optCurl = if isNix then null else shouldUsePkg curl;
optBluez = if isNix then null else shouldUsePkg bluez;
optLibibverbs = if isNix then null else shouldUsePkg libibverbs;
optLibrdmacm = if isNix then null else shouldUsePkg librdmacm;
optLibuuid = if isNix then null else shouldUsePkg libuuid;
optVde2 = if isNix then null else shouldUsePkg vde2;
optLibaio = shouldUsePkg libaio;
optLibcap_ng = if isNix then null else shouldUsePkg libcap_ng;
optSpice = if isNix then null else shouldUsePkg spice;
optSpice_protocol = if isNix then null else shouldUsePkg spice_protocol;
optLibceph = if isNix then null else shouldUsePkg libceph;
optLibxfs = if isNix then null else shouldUsePkg libxfs;
optNss = if isNix then null else shouldUsePkg nss;
optNspr = if isNix then null else shouldUsePkg nspr;
optLibusb = if isNix then null else shouldUsePkg libusb;
optUsbredir = if isNix then null else shouldUsePkg usbredir;
optMesa = if isNix then null else shouldUsePkg mesa;
optLzo = if isNix then null else shouldUsePkg lzo;
optSnappy = if isNix then null else shouldUsePkg snappy;
optBzip2 = if isNix then null else shouldUsePkg bzip2;
optLibseccomp = if isNix then null else shouldUsePkg libseccomp;
optGlusterfs = if isNix then null else shouldUsePkg glusterfs;
optLibssh2 = if isNix then null else shouldUsePkg libssh2;
optNumactl = if isNix then null else shouldUsePkg numactl;
hasSDLAbi = if optSDL2 != null then true else null;
hasVirtfs = stdenv.isLinux && optLibcap != null && optAttr != null;
hasVnc = !isNix;
hasVncTls = hasVnc && optGnutls != null;
hasVncSasl = hasVnc && optCyrus_sasl != null;
hasVncJpeg = hasVnc && optLibjpeg != null;
hasVncPng = hasVnc && optLibpng != null;
hasVncWs = hasVnc && optGnutls != null;
hasFdt = !isNix;
hasRdma = optLibibverbs != null && optLibrdmacm != null;
hasLinuxAio = stdenv.isLinux && optLibaio != null;
hasSpice = optSpice != null && optSpice_protocol != null;
hasNss = optNss != null && optNspr != null;
optLibpulseaudio = if isNix then null else shouldUsePkg libpulseaudio;
optAlsaLib = if isNix then null else shouldUsePkg alsaLib;
audio = concatStringsSep "," (
optional (optSDL2 != null) "sdl"
++ optional (optLibpulseaudio != null) "pa"
++ optional (optAlsaLib != null) "alsa"
);
systemBinary = if stdenv.system == "x86_64-linux" then "x86_64"
else if stdenv.system == "i686-linux" then "i386"
else null;
targetList = if stdenv.system == "x86_64-linux" then "x86_64-softmmu,i386-softmmu"
else if stdenv.system == "i686-linux" then "i386-softmmu"
else null;
hasModules = if isNix then null else true;
n = "qemu-2.2.1";
audio = optionalString (hasSuffix "linux" stdenv.system) "alsa,"
+ optionalString pulseSupport "pa,"
+ optionalString sdlSupport "sdl,";
in
stdenv.mkDerivation rec {
name = "${n}${optionalString (type != null && type != "") "-${type}"}";
name = n + (if x86Only then "-x86-only" else "");
src = fetchurl {
url = "http://wiki.qemu.org/download/${n}.tar.bz2";
sha256 = "120m53c3p28qxmfzllicjzr8syjv6v4d9rsyrgkp7gnmcgvvgfmn";
sha256 = "181m2ddsg3adw8y5dmimsi8x678imn9f6i5p20zbhi7pdr61a5s6";
};
nativeBuildInputs = [ pkgconfig libtool perl texinfo flex bison gettext makeWrapper ];
buildInputs = [
python glib zlib pixman optSDL2 optGtk optNcurses optCurl optBluez optVde2
optLibcap_ng optAttr optLibuuid optLibceph optLibxfs optLibusb optUsbredir
optMesa optLzo optSnappy optBzip2 optLibseccomp optGlusterfs optLibssh2
optNumactl optLibpulseaudio optAlsaLib
] ++ optionals (hasVncTls || hasVncWs) [
optGnutls
] ++ optionals hasVncSasl [
optCyrus_sasl
] ++ optionals hasVncJpeg [
optLibjpeg
] ++ optionals hasVncPng [
optLibpng
] ++ optionals hasVirtfs [
optLibcap
] ++ optionals hasRdma [
optLibibverbs optLibrdmacm
] ++ optionals hasLinuxAio [
optLibaio
] ++ optionals hasSpice [
optSpice optSpice_protocol
] ++ optionals hasNss [
optNss optNspr
];
buildInputs =
[ python zlib pkgconfig glib ncurses perl pixman attr libcap
vde2 texinfo libuuid flex bison makeWrapper lzo snappy libseccomp
libcap_ng gnutls
]
++ optionals pulseSupport [ libpulseaudio ]
++ optionals sdlSupport [ SDL ]
++ optionals vncSupport [ libjpeg libpng ]
++ optionals spiceSupport [ spice_protocol spice usbredir ]
++ optionals (hasSuffix "linux" stdenv.system) [ alsaLib libaio ];
enableParallelBuilding = true;
configureFlags = [
(mkOther "smbd" "smbd")
(mkOther "sysconfdir" "/etc")
(mkOther "localstatedir" "/var")
(mkEnable hasModules "modules" null)
(mkEnable false "debug-tcg" null)
(mkEnable false "debug-info" null)
(mkEnable false "sparse" null)
(mkEnable false "werror" null)
(mkEnable (optSDL2 != null) "sdl" null)
(mkWith hasSDLAbi "sdlabi" "2.0")
(mkEnable (optGtk != null) "gtk" null)
(mkEnable hasVirtfs "virtfs" null)
(mkEnable hasVnc "vnc" null)
(mkEnable stdenv.isDarwin "cocoa" null)
(mkOther "audio-drv-list" audio)
(mkEnable false "xen" null)
(mkEnable false "xen-pci-passthrough" null)
(mkEnable false "brlapi" null)
(mkEnable hasVncTls "vnc-tls" null)
(mkEnable hasVncSasl "vnc-sasl" null)
(mkEnable hasVncJpeg "vnc-jpeg" null)
(mkEnable hasVncPng "vnc-png" null)
(mkEnable hasVncWs "vnc-ws" null)
(mkEnable (optNcurses != null) "curses" null)
(mkEnable (optCurl != null) "curl" null)
(mkEnable hasFdt "fdt" null)
(mkEnable (optBluez != null) "bluez" null)
(mkEnable stdenv.isLinux "kvm" null)
(mkEnable hasRdma "rdma" null)
(mkEnable (!isNix) "system" null)
(mkEnable (!isKvmOnly) "user" null)
(mkEnable (!isKvmOnly) "guest-base" null)
(mkEnable (!isNix) "pie" null)
(mkEnable (optLibuuid != null) "uuid" null)
(mkEnable (optVde2 != null) "vde" null)
(mkEnable false "netmap" null) # TODO(wkennington): Add Support
(mkEnable hasLinuxAio "linux-aio" null)
(mkEnable (optLibcap_ng != null) "cap-ng" null)
(mkEnable (optAttr != null) "attr" null)
(mkEnable (!isNix) "docs" null)
(mkEnable stdenv.isLinux "vhost-net" null)
(mkEnable hasSpice "spice" null)
(mkEnable (optLibceph != null) "rbd" null)
(mkEnable false "libiscsi" null) # TODO(wkennington): Add support
(mkEnable false "libnfs" null) # TODO(wkennington): Add support
(mkEnable (optLibxfs != null) "xfsctl" null)
(mkEnable hasNss "smartcard-nss" null)
(mkEnable (optLibusb != null) "libusb" null)
(mkEnable (optUsbredir != null) "usb-redir" null)
(mkEnable (optMesa != null) "opengl" null)
(mkEnable (optLzo != null) "lzo" null)
(mkEnable (optSnappy != null) "snappy" null)
(mkEnable (optBzip2 != null) "bzip2" null)
(mkEnable true "guest-agent" null)
(mkEnable (optLibseccomp != null) "seccomp" null)
(mkEnable (optGlusterfs != null) "glusterfs" null)
(mkEnable false "archipelago" null)
(mkEnable true "tpm" null)
(mkEnable (optLibssh2 != null) "libssh2" null)
(mkEnable (optLibuuid != null) "vhdx" null)
(mkEnable (optGnutls != null) "quorum" null)
(mkEnable (optNumactl != null) "numa" null)
] ++ optionals isKvmOnly [
(mkOther "target-list" targetList)
] ++ optionals isNix [
"--static"
];
patches = [ ./no-etc-install.patch ];
installFlags = [
"sysconfdir=\${out}/etc"
"qemu_confdir=\${out}/etc/qemu"
"qemu_localstatedir=\${TMPDIR}"
];
configureFlags =
[ "--enable-seccomp"
"--smbd=smbd" # use `smbd' from $PATH
"--audio-drv-list=${audio}"
"--sysconfdir=/etc"
"--localstatedir=/var"
]
++ optional spiceSupport "--enable-spice"
++ optional x86Only "--target-list=i386-softmmu,x86_64-softmmu"
++ optional (hasSuffix "linux" stdenv.system) "--enable-linux-aio";
postInstall = optionalString (systemBinary != null) ''
# Add a ‘qemu-kvm’ wrapper for compatibility/convenience.
p="$out/bin/qemu-system-${systemBinary}"
if [ -e "$p" ]; then
makeWrapper "$p" $out/bin/qemu-kvm --add-flags "\$([ -e /dev/kvm ] && echo -enable-kvm)"
fi
'';
postInstall =
''
# Add a ‘qemu-kvm’ wrapper for compatibility/convenience.
p="$out/bin/qemu-system-${if stdenv.system == "x86_64-linux" then "x86_64" else "i386"}"
if [ -e "$p" ]; then
makeWrapper "$p" $out/bin/qemu-kvm --add-flags "\$([ -e /dev/kvm ] && echo -enable-kvm)"
fi
'';
meta = with stdenv.lib; {
homepage = http://www.qemu.org/;
description = "A generic and open source machine emulator and virtualizer";
license = licenses.gpl2Plus;
maintainers = with maintainers; [ viric shlevy eelco wkennington ];
platforms = if isKvmOnly then platforms.linux else platforms.all;
maintainers = with maintainers; [ viric shlevy eelco ];
platforms = platforms.linux;
};
}

2
pkgs/applications/window-managers/stumpwm/default.nix
View File

@ -69,7 +69,7 @@ stdenv.mkDerivation rec {
description = "A tiling window manager for X11";
homepage = https://github.com/stumpwm/;
license = licenses.gpl2Plus;
maintainers = with maintainers; [ _1126 the-kenny ];
maintainers = with maintainers; [ hiberno the-kenny ];
platforms = platforms.linux;
};
}

2
pkgs/build-support/fetchgit/default.nix
View File

@ -54,7 +54,7 @@ stdenv.mkDerivation {
inherit url rev leaveDotGit fetchSubmodules deepClone branchName;
GIT_SSL_CAINFO = "${cacert}/ca-bundle.crt";
GIT_SSL_CAINFO = "${cacert}/etc/ssl/certs/ca-bundle.crt";
impureEnvVars = [
# We borrow these environment variables from the caller to allow

2
pkgs/build-support/rust/fetch-cargo-deps
View File

@ -24,10 +24,12 @@ export CARGO_HOME=$out
cd $src
if [[ ! -f Cargo.lock ]]; then
echo
echo "ERROR: The Cargo.lock file doesn't exist"
echo
echo "Cargo.lock is needed to make sure that depsSha256 doesn't change"
echo "when the registry is updated."
echo
exit 1
fi

2
pkgs/build-support/rust/fetchcargo.nix
View File

@ -16,7 +16,7 @@ stdenv.mkDerivation {
outputHashMode = "recursive";
outputHash = sha256;
SSL_CERT_FILE = "${cacert}/ca-bundle.crt";
SSL_CERT_FILE = "${cacert}/etc/ssl/certs/ca-bundle.crt";
impureEnvVars = [ "http_proxy" "https_proxy" "ftp_proxy" "all_proxy" "no_proxy" ];
preferLocalBuild = true;

1
pkgs/build-support/vm/default.nix
View File

@ -187,6 +187,7 @@ rec {
# then don't start the build again, but instead drop the user into
# an interactive shell.
if test -n "$origBuilder" -a ! -e /.debug; then
exec < /dev/null
${coreutils}/bin/touch /.debug
$origBuilder $origArgs
echo $? > /tmp/xchg/in-vm-exit

6
pkgs/data/documentation/zeal/default.nix
View File

@ -1,4 +1,4 @@
{ stdenv, fetchFromGitHub, pkgconfig, qt5, libarchive }:
{ stdenv, fetchFromGitHub, pkgconfig, qt5, libarchive, xlibs }:
stdenv.mkDerivation rec {
version = "0.1.1";
@ -11,7 +11,9 @@ stdenv.mkDerivation rec {
sha256 = "172wf50fq1l5p8hq1irvpwr7ljxkjaby71afrm82jz3ixl6dg2ii";
};
buildInputs = [ pkgconfig qt5.base qt5.webkit qt5.imageformats libarchive ];
buildInputs = [
xlibs.xcbutilkeysyms pkgconfig qt5.base qt5.webkit qt5.imageformats libarchive
];
configurePhase = ''
qmake PREFIX=/

8
pkgs/data/misc/cacert/default.nix
View File

@ -1,4 +1,4 @@
{ stdenv, nss, curl-full, perl, perlPackages }:
{ stdenv, nss, curl, perl, perlPackages }:
stdenv.mkDerivation rec {
name = "nss-cacert-${nss.version}";
@ -6,7 +6,7 @@ stdenv.mkDerivation rec {
src = nss.src;
postPatch = ''
unpackFile ${curl-full.src};
unpackFile ${curl.src};
'';
nativeBuildInputs = [ perl ] ++ (with perlPackages; [ LWP ]);
@ -16,8 +16,8 @@ stdenv.mkDerivation rec {
'';
installPhase = ''
mkdir -pv $out
cp -v ca-bundle.crt $out
mkdir -pv $out/etc/ssl/certs
cp -v ca-bundle.crt $out/etc/ssl/certs
'';
meta = with stdenv.lib; {

14
pkgs/data/misc/geolite-legacy/default.nix
View File

@ -8,23 +8,23 @@ let
# Annoyingly, these files are updated without a change in URL. This means that
# builds will start failing every month or so, until the hashes are updated.
version = "2015-05-20";
version = "2015-06-03";
in
stdenv.mkDerivation {
name = "geolite-legacy-${version}";
srcGeoIP = fetchDB "GeoLiteCountry/GeoIP.dat.gz"
"15p8is7jml8xsy7a8afsjq7q20pkisbk5b7nj465ljaz5svq6rgv";
"1cd25xsw214bdmc657q3a1dcivjnh6ravdsgia2w7q8bq8g61yfp";
srcGeoIPv6 = fetchDB "GeoIPv6.dat.gz"
"0apiypf500k9k89x6zm1109gw6j9xs83c80iyl17rxlik1hhqf8g";
"1vi82p41vas18yp17yk236pn1xamsi9662aav79fa0hm43i3ydx3";
srcGeoLiteCity = fetchDB "GeoLiteCity.dat.xz"
"12j44586jmvk1jnxs345lgdgl9izn51xgh1m2jm7lklsyw13b2nk";
"1z87ng2a2zmqnvxhcmapnarc9w2ycb18vpivvzx893y7fh39h34s";
srcGeoLiteCityv6 = fetchDB "GeoLiteCityv6-beta/GeoLiteCityv6.dat.gz"
"1jlxd60l7ic7md0d93fhiyd2vqms1fcirp6wkm0glh347j64srsb";
"0xjzg76vdsayxyy1yyw64w781vad4c9nbhw61slh2qmazdr360g9";
srcGeoIPASNum = fetchDB "asnum/GeoIPASNum.dat.gz"
"09vv3jg6gnz2k30pkwgcakvfvklfrkwsj0xq5q2awcw6ik0vkfcm";
"0zccfd1wsny3n1f3wgkb071pp6z01nmk0p6nngha0gwnywchvbx4";
srcGeoIPASNumv6 = fetchDB "asnum/GeoIPASNumv6.dat.gz"
"1qdprh1idxa1l4s23lcjg33hi4i8qzlk4fjril2zcd3prff1xkz2";
"0asnmmirridiy57zm0kccb7g8h7ndliswfv3yfk7zm7dk98njnxs";
meta = with stdenv.lib; {
inherit version;

4
pkgs/desktops/gnome-3/3.16/core/gnome-control-center/default.nix
View File

@ -2,7 +2,7 @@
, libcanberra, libcanberra_gtk3, accountsservice, libpwquality, libpulseaudio, fontconfig
, gdk_pixbuf, hicolor_icon_theme, librsvg, libxkbfile, libnotify
, libxml2, polkit, libxslt, libgtop, libsoup, colord, colord-gtk
, cracklib, python, libkrb5, networkmanagerapplet, networkmanager
, cracklib, python, krb5, networkmanagerapplet, networkmanager
, libwacom, samba, shared_mime_info, tzdata, icu, libtool, udev
, docbook_xsl, docbook_xsl_ns, modemmanager, clutter, clutter_gtk }:
@ -25,7 +25,7 @@ stdenv.mkDerivation rec {
[ pkgconfig intltool ibus gtk glib upower libcanberra gsettings_desktop_schemas
libxml2 gnome_desktop gnome_settings_daemon polkit libxslt libgtop gnome-menus
gnome_online_accounts libsoup colord libpulseaudio fontconfig colord-gtk libpwquality
accountsservice libkrb5 networkmanagerapplet libwacom samba libnotify libxkbfile
accountsservice krb5 networkmanagerapplet libwacom samba libnotify libxkbfile
shared_mime_info icu libtool docbook_xsl docbook_xsl_ns gnome3.grilo
gdk_pixbuf gnome3.defaultIconTheme librsvg clutter clutter_gtk
gnome3.vino udev libcanberra_gtk3

2
pkgs/desktops/gnome-3/3.16/core/gnome-keyring/default.nix
View File

@ -22,7 +22,7 @@ in stdenv.mkDerivation rec {
nativeBuildInputs = [ pkgconfig intltool docbook_xsl_ns docbook_xsl ];
configureFlags = [
"--with-ca-certificates=${cacert}/ca-bundle.crt" # NixOS hardcoded path
"--with-ca-certificates=${cacert}/etc/ssl/certs/ca-bundle.crt" # NixOS hardcoded path
"--with-pkcs11-config=$$out/etc/pkcs11/" # installation directories
"--with-pkcs11-modules=$$out/lib/pkcs11/"
];

2
pkgs/desktops/gnome-3/3.16/core/rest/default.nix
View File

@ -10,7 +10,7 @@ stdenv.mkDerivation rec {
buildInputs = [ pkgconfig glib libsoup gobjectIntrospection];
configureFlags = "--with-ca-certificates=${cacert}/ca-bundle.crt";
configureFlags = "--with-ca-certificates=${cacert}/etc/ssl/certs/ca-bundle.crt";
meta = with stdenv.lib; {
platforms = platforms.linux;

360
pkgs/desktops/plasma-5.3/manifest.nix
View File

@ -2,327 +2,327 @@
{ stdenv, fetchurl, mirror }:
[
{
name = stdenv.lib.nameFromURL "kscreen-5.3.0.tar.xz" ".tar";
store = "/nix/store/hjhbxv0vrv64r22z5zr15av8c6kpa2q3-kscreen-5.3.0.tar.xz";
name = stdenv.lib.nameFromURL "breeze-5.3.1.tar.xz" ".tar";
store = "/nix/store/wksay8grc0ihprrjkvfwaa5n0v1dsn7p-breeze-5.3.1.tar.xz";
src = fetchurl {
url = "${mirror}/stable/plasma/5.3.0/kscreen-5.3.0.tar.xz";
sha256 = "1d9qlqszrkz8ia1k20xy645mngg3jwyc9mjvc27z5yx3l2bjdisq";
name = "kscreen-5.3.0.tar.xz";
url = "${mirror}/stable/plasma/5.3.1/breeze-5.3.1.tar.xz";
sha256 = "0sh7vgg3dz0cs6mqs4c3ygw5qg4lcjm0vdh4mm4xfxnizagkqrr5";
name = "breeze-5.3.1.tar.xz";
};
}
{
name = stdenv.lib.nameFromURL "kde-cli-tools-5.3.0.tar.xz" ".tar";
store = "/nix/store/di83lwabjyf21g6bbww68xf3k89zdih5-kde-cli-tools-5.3.0.tar.xz";
name = stdenv.lib.nameFromURL "baloo-5.9.1.tar.xz" ".tar";
store = "/nix/store/yljbiij3svkkmmqpwqxyc5gf8p4gz9zl-baloo-5.9.1.tar.xz";
src = fetchurl {
url = "${mirror}/stable/plasma/5.3.0/kde-cli-tools-5.3.0.tar.xz";
sha256 = "12i74cq9kghcj7sfhxqdlqjd5n4lpxr8nvlzkh4n8pjrz1w3g9n7";
name = "kde-cli-tools-5.3.0.tar.xz";
url = "${mirror}/stable/plasma/5.3.1/baloo-5.9.1.tar.xz";
sha256 = "0wx9n3l4f1ibddvhbiharhgd20s8hzs64b2c0686bm82qmbkkl7n";
name = "baloo-5.9.1.tar.xz";
};
}
{
name = stdenv.lib.nameFromURL "bluez-qt-5.3.0.tar.xz" ".tar";
store = "/nix/store/7lpwpw24aahx81dq78vbk203w6xpapar-bluez-qt-5.3.0.tar.xz";
name = stdenv.lib.nameFromURL "ksshaskpass-5.3.1.tar.xz" ".tar";
store = "/nix/store/8p1spxbb4iv5wrccipby7khh6r5pj4gb-ksshaskpass-5.3.1.tar.xz";
src = fetchurl {
url = "${mirror}/stable/plasma/5.3.0/bluez-qt-5.3.0.tar.xz";
sha256 = "0zcqb8fiawprl2qz1lnf875dnkg7nlb6hghqqzp4l5hby20kxnq5";
name = "bluez-qt-5.3.0.tar.xz";
url = "${mirror}/stable/plasma/5.3.1/ksshaskpass-5.3.1.tar.xz";
sha256 = "0ids7vbi46bdd5dbjgv0wfv4rfv03kpln5vr3rwavah892q1dad2";
name = "ksshaskpass-5.3.1.tar.xz";
};
}
{
name = stdenv.lib.nameFromURL "plasma-nm-5.3.0.tar.xz" ".tar";
store = "/nix/store/hbvm05kcmpc7fncx4padzqx2gqvra88p-plasma-nm-5.3.0.tar.xz";
name = stdenv.lib.nameFromURL "kscreen-5.3.1.tar.xz" ".tar";
store = "/nix/store/0gf4avv67cspclipvs1934fa9vn5bday-kscreen-5.3.1.tar.xz";
src = fetchurl {
url = "${mirror}/stable/plasma/5.3.0/plasma-nm-5.3.0.tar.xz";
sha256 = "1zldjrdr331shl4xk4yypr22lkav47bjsw4nzdia16x6nsh32yra";
name = "plasma-nm-5.3.0.tar.xz";
url = "${mirror}/stable/plasma/5.3.1/kscreen-5.3.1.tar.xz";
sha256 = "008ys3glpvpcvjh7n2gls3m13q9qswmnc5l2lz4zs1dvcrk5z7yr";
name = "kscreen-5.3.1.tar.xz";
};
}
{
name = stdenv.lib.nameFromURL "libkscreen-5.3.0.tar.xz" ".tar";
store = "/nix/store/cr0gg8a4asd3yyy5p0rx6r1m9ngww2f7-libkscreen-5.3.0.tar.xz";
name = stdenv.lib.nameFromURL "kwayland-5.3.1.tar.xz" ".tar";
store = "/nix/store/fqs8y8fmkk23biqlicq50m281jf45qbj-kwayland-5.3.1.tar.xz";
src = fetchurl {
url = "${mirror}/stable/plasma/5.3.0/libkscreen-5.3.0.tar.xz";
sha256 = "1hdgj3l51i277ar9af02sz27bb811amr6b6n4fmcym7ss1r3vljd";
name = "libkscreen-5.3.0.tar.xz";
url = "${mirror}/stable/plasma/5.3.1/kwayland-5.3.1.tar.xz";
sha256 = "1vsdsf00py6i16zwbwpplq1v7m3fy1j0dskvkb080wm0fskz1r8f";
name = "kwayland-5.3.1.tar.xz";
};
}
{
name = stdenv.lib.nameFromURL "powerdevil-5.3.0.tar.xz" ".tar";
store = "/nix/store/zjanbhr6ynx98sra3ibg86ajf2mxpw4v-powerdevil-5.3.0.tar.xz";
name = stdenv.lib.nameFromURL "muon-5.3.1.tar.xz" ".tar";
store = "/nix/store/glhhnkdnn4sancq176mwd3pdw51xg58s-muon-5.3.1.tar.xz";
src = fetchurl {
url = "${mirror}/stable/plasma/5.3.0/powerdevil-5.3.0.tar.xz";
sha256 = "1pr53yzmra17h7vhp7h9ywsbgk7cm7f2srbdg3ikp2i8a1gzkchm";
name = "powerdevil-5.3.0.tar.xz";
url = "${mirror}/stable/plasma/5.3.1/muon-5.3.1.tar.xz";
sha256 = "0k2c625d9i5gyyvdzlajkb0kcvss60lhs7qssil1a4w34ch3zfmk";
name = "muon-5.3.1.tar.xz";
};
}
{
name = stdenv.lib.nameFromURL "libksysguard-5.3.0.tar.xz" ".tar";
store = "/nix/store/k4ccrcbd33iknvamm1v56n2kz86hmcca-libksysguard-5.3.0.tar.xz";
name = stdenv.lib.nameFromURL "khelpcenter-5.3.1.tar.xz" ".tar";
store = "/nix/store/s676r82b3lpr3fzrqcw0srl8zx9mj57l-khelpcenter-5.3.1.tar.xz";
src = fetchurl {
url = "${mirror}/stable/plasma/5.3.0/libksysguard-5.3.0.tar.xz";
sha256 = "16b8xrkm1b53nwhcr91hiz0nc1bj9yjz3k4ccfmc6nhyjma3n24v";
name = "libksysguard-5.3.0.tar.xz";
url = "${mirror}/stable/plasma/5.3.1/khelpcenter-5.3.1.tar.xz";
sha256 = "0dik353w6ri6mfkvkz3v5xva6x59zlbz1sj522li0gbd73x4bzf2";
name = "khelpcenter-5.3.1.tar.xz";
};
}
{
name = stdenv.lib.nameFromURL "plasma-workspace-wallpapers-5.3.0.tar.xz" ".tar";
store = "/nix/store/yws33kggkdqd5xpq065cbp0lzvgnn749-plasma-workspace-wallpapers-5.3.0.tar.xz";
name = stdenv.lib.nameFromURL "kdeplasma-addons-5.3.1.tar.xz" ".tar";
store = "/nix/store/his4ak4djxslvmrdznyzf3v6mr3aq40s-kdeplasma-addons-5.3.1.tar.xz";
src = fetchurl {
url = "${mirror}/stable/plasma/5.3.0/plasma-workspace-wallpapers-5.3.0.tar.xz";
sha256 = "0kci4f445624x93k521zva08kggffxqwcg5safzhxxrwyfw65nja";
name = "plasma-workspace-wallpapers-5.3.0.tar.xz";
url = "${mirror}/stable/plasma/5.3.1/kdeplasma-addons-5.3.1.tar.xz";
sha256 = "1myk3508jqgalyqa1rlx1dq5afppvhvsnd7irf4wywpgls20nwnv";
name = "kdeplasma-addons-5.3.1.tar.xz";
};
}
{
name = stdenv.lib.nameFromURL "plasma-sdk-5.3.0.tar.xz" ".tar";
store = "/nix/store/p02z3bzwd2zh62n9hj2mypvvsb0z0396-plasma-sdk-5.3.0.tar.xz";
name = stdenv.lib.nameFromURL "systemsettings-5.3.1.tar.xz" ".tar";
store = "/nix/store/8fyfslw9ip7fsn6gb55v6i1cxajgxmjb-systemsettings-5.3.1.tar.xz";
src = fetchurl {
url = "${mirror}/stable/plasma/5.3.0/plasma-sdk-5.3.0.tar.xz";
sha256 = "1vbi45f8clpzx2hqpnzw4wamwzm4016mzh4q6yhwgappqsgn3x9f";
name = "plasma-sdk-5.3.0.tar.xz";
url = "${mirror}/stable/plasma/5.3.1/systemsettings-5.3.1.tar.xz";
sha256 = "06m3r31dr0ivhn25fg0sg8pbxyzvm8slsmqkqsm4cbypg028axx0";
name = "systemsettings-5.3.1.tar.xz";
};
}
{
name = stdenv.lib.nameFromURL "plasma-desktop-5.3.0.tar.xz" ".tar";
store = "/nix/store/livypzdcyjjiqs50varb9m2fbky6gwhm-plasma-desktop-5.3.0.tar.xz";
name = stdenv.lib.nameFromURL "kinfocenter-5.3.1.tar.xz" ".tar";
store = "/nix/store/flpcnl0mn3mma12nkgymabjgzm1yc4kf-kinfocenter-5.3.1.tar.xz";
src = fetchurl {
url = "${mirror}/stable/plasma/5.3.0/plasma-desktop-5.3.0.tar.xz";
sha256 = "0f8rs3p1cbvryg6z386kb9pb0ygbw7jqf63hnpcjkbg33rq14q9p";
name = "plasma-desktop-5.3.0.tar.xz";
url = "${mirror}/stable/plasma/5.3.1/kinfocenter-5.3.1.tar.xz";
sha256 = "02gqlidh9pb924vhhaxnidpjz3cb32r6icikhcv7csrll13wgp1a";
name = "kinfocenter-5.3.1.tar.xz";
};
}
{
name = stdenv.lib.nameFromURL "kinfocenter-5.3.0.tar.xz" ".tar";
store = "/nix/store/w3dl539dn5jczrc50dmsywv79m3iyqxx-kinfocenter-5.3.0.tar.xz";
name = stdenv.lib.nameFromURL "libkscreen-5.3.1.tar.xz" ".tar";
store = "/nix/store/3i82s0x8hsi0q9hyp8m42m8nxcm6cwx5-libkscreen-5.3.1.tar.xz";
src = fetchurl {
url = "${mirror}/stable/plasma/5.3.0/kinfocenter-5.3.0.tar.xz";
sha256 = "02znnw11j37f084bcjp160sm5fs7kc251w07rxly49jdjyy6ddiw";
name = "kinfocenter-5.3.0.tar.xz";
url = "${mirror}/stable/plasma/5.3.1/libkscreen-5.3.1.tar.xz";
sha256 = "00g401yfiyqh09ajkinlkzhfpb7lsy0wpnrk1ba8vm4wmcvkp63l";
name = "libkscreen-5.3.1.tar.xz";
};
}
{
name = stdenv.lib.nameFromURL "polkit-kde-agent-1-5.3.0.tar.xz" ".tar";
store = "/nix/store/v6wgn4l8brv3v4mdjgy0hfqxynwncy2p-polkit-kde-agent-1-5.3.0.tar.xz";
name = stdenv.lib.nameFromURL "libksysguard-5.3.1.tar.xz" ".tar";
store = "/nix/store/8jaxispzwkpdy6kazyhdy6k00f0s7dla-libksysguard-5.3.1.tar.xz";
src = fetchurl {
url = "${mirror}/stable/plasma/5.3.0/polkit-kde-agent-1-5.3.0.tar.xz";
sha256 = "0z1c354sjm218w30x2whiij43jamfh4lclwcr14bqk2s8i9njhir";
name = "polkit-kde-agent-1-5.3.0.tar.xz";
url = "${mirror}/stable/plasma/5.3.1/libksysguard-5.3.1.tar.xz";
sha256 = "115iwqq4y6pnhqsa5yn30q6wdpad5v48m7hjrn7jbpm3gsiwq1ym";
name = "libksysguard-5.3.1.tar.xz";
};
}
{
name = stdenv.lib.nameFromURL "kdecoration-5.3.0.tar.xz" ".tar";
store = "/nix/store/8zx7y39rrcnmfdjkp7g5xrb7xkwn6mp7-kdecoration-5.3.0.tar.xz";
name = stdenv.lib.nameFromURL "kmenuedit-5.3.1.tar.xz" ".tar";
store = "/nix/store/p6x58nfjkml2125rpvkr7zcvrv11fn1l-kmenuedit-5.3.1.tar.xz";
src = fetchurl {
url = "${mirror}/stable/plasma/5.3.0/kdecoration-5.3.0.tar.xz";
sha256 = "1abwqd8cxf6gabc74pvhnqhwqkn8a7zszwf031ndicl3n3f93x3d";
name = "kdecoration-5.3.0.tar.xz";
url = "${mirror}/stable/plasma/5.3.1/kmenuedit-5.3.1.tar.xz";
sha256 = "0vyy3xb32nb2qxfv3qvrrzlnck6gas0gwyncbn4rzimaygm2vzqz";
name = "kmenuedit-5.3.1.tar.xz";
};
}
{
name = stdenv.lib.nameFromURL "kde-gtk-config-5.3.0.tar.xz" ".tar";
store = "/nix/store/6hivcczg1gp31ayfz802dxdr89zpaqym-kde-gtk-config-5.3.0.tar.xz";
name = stdenv.lib.nameFromURL "plasma-mediacenter-5.3.1.tar.xz" ".tar";
store = "/nix/store/g9r436iff0714c2ya9xbm0sgd4gdiaq5-plasma-mediacenter-5.3.1.tar.xz";
src = fetchurl {
url = "${mirror}/stable/plasma/5.3.0/kde-gtk-config-5.3.0.tar.xz";
sha256 = "1s7jkrb3750aw0cn5v0g7pdsbkb5ncxfhfclw8lr1nqgi03lphcf";
name = "kde-gtk-config-5.3.0.tar.xz";
url = "${mirror}/stable/plasma/5.3.1/plasma-mediacenter-5.3.1.tar.xz";
sha256 = "0h8dpyszn7hk7b1y1m9qb83gzjnp8ymslpranxdan36r5bm2ayd8";
name = "plasma-mediacenter-5.3.1.tar.xz";
};
}
{
name = stdenv.lib.nameFromURL "systemsettings-5.3.0.tar.xz" ".tar";
store = "/nix/store/vzxxqpvapq8fnbf88ljhhnrpzl7vl6wf-systemsettings-5.3.0.tar.xz";
name = stdenv.lib.nameFromURL "plasma-sdk-5.3.1.tar.xz" ".tar";
store = "/nix/store/mifrpgvf29kzr7n4lk1xq8s1b3a1d29q-plasma-sdk-5.3.1.tar.xz";
src = fetchurl {
url = "${mirror}/stable/plasma/5.3.0/systemsettings-5.3.0.tar.xz";
sha256 = "0ryhm9d46r5691alnrrg88qxbdwm10y1k7jdk7czrnjm5jkg86vh";
name = "systemsettings-5.3.0.tar.xz";
url = "${mirror}/stable/plasma/5.3.1/plasma-sdk-5.3.1.tar.xz";
sha256 = "157742d7wm21y4g7gs0483jd4sd6q2a0ppyk3mr544nagydvpqfs";
name = "plasma-sdk-5.3.1.tar.xz";
};
}
{
name = stdenv.lib.nameFromURL "muon-5.3.0.tar.xz" ".tar";
store = "/nix/store/46mqwn6l763jq9qgvp9d6lg184760ff8-muon-5.3.0.tar.xz";
name = stdenv.lib.nameFromURL "kwrited-5.3.1.tar.xz" ".tar";
store = "/nix/store/agrv0yx7fzkjyx8b4bl0anbhi99v6l6y-kwrited-5.3.1.tar.xz";
src = fetchurl {
url = "${mirror}/stable/plasma/5.3.0/muon-5.3.0.tar.xz";
sha256 = "0f9bnp2pf0npil189a0g3pn6bnb9nwqdclrk7scrk4xck7c66v0r";
name = "muon-5.3.0.tar.xz";
url = "${mirror}/stable/plasma/5.3.1/kwrited-5.3.1.tar.xz";
sha256 = "0qivfycr4ak5zsplnzv968sya2rc3vz9z6h8gv4b2scf99zjp2g8";
name = "kwrited-5.3.1.tar.xz";
};
}
{
name = stdenv.lib.nameFromURL "milou-5.3.0.tar.xz" ".tar";
store = "/nix/store/zdx8hxf5w0yqypjk08w5hfhkzngdy6pm-milou-5.3.0.tar.xz";
name = stdenv.lib.nameFromURL "khotkeys-5.3.1.tar.xz" ".tar";
store = "/nix/store/m1v47sjjn9hz8pdfzql5xx9r0j1zpd4q-khotkeys-5.3.1.tar.xz";
src = fetchurl {
url = "${mirror}/stable/plasma/5.3.0/milou-5.3.0.tar.xz";
sha256 = "089dvxpwiwa3sasah27n4yk8l3jbmi71p4080q8pslx6j4dhhmsq";
name = "milou-5.3.0.tar.xz";
url = "${mirror}/stable/plasma/5.3.1/khotkeys-5.3.1.tar.xz";
sha256 = "11mzrjzk2j9x32mg77d2al19b4iin0rfxs710mhsjbgriq144smv";
name = "khotkeys-5.3.1.tar.xz";
};
}
{
name = stdenv.lib.nameFromURL "kmenuedit-5.3.0.tar.xz" ".tar";
store = "/nix/store/1hjwhla1d23gbmmigxmm4w2ahkayyfr8-kmenuedit-5.3.0.tar.xz";
name = stdenv.lib.nameFromURL "plasma-nm-5.3.1.tar.xz" ".tar";
store = "/nix/store/r8sbla68dniy9snbni1g4h9rwwm5bghh-plasma-nm-5.3.1.tar.xz";
src = fetchurl {
url = "${mirror}/stable/plasma/5.3.0/kmenuedit-5.3.0.tar.xz";
sha256 = "0jzzl043jq9afknj1pc75ywmbs5ff4rjnbqgim5xgrbr08bsam9j";
name = "kmenuedit-5.3.0.tar.xz";
url = "${mirror}/stable/plasma/5.3.1/plasma-nm-5.3.1.tar.xz";
sha256 = "0jgrz9j2228aya7n1dg4npicsbgv93f8n80b9yjax8mrd6qhq55k";
name = "plasma-nm-5.3.1.tar.xz";
};
}
{
name = stdenv.lib.nameFromURL "plasma-workspace-5.3.0.tar.xz" ".tar";
store = "/nix/store/sji2iki8crvy81q6mrc1dd3gibv88mrn-plasma-workspace-5.3.0.tar.xz";
name = stdenv.lib.nameFromURL "kdecoration-5.3.1.tar.xz" ".tar";
store = "/nix/store/g9163zl8sjxnr32mmy70cbw0a0arsm8c-kdecoration-5.3.1.tar.xz";
src = fetchurl {
url = "${mirror}/stable/plasma/5.3.0/plasma-workspace-5.3.0.tar.xz";
sha256 = "05kk8vnhsny3k8pn27pjawdfxcjf4c6pcl2k7s43zim0khqv5xcm";
name = "plasma-workspace-5.3.0.tar.xz";
url = "${mirror}/stable/plasma/5.3.1/kdecoration-5.3.1.tar.xz";
sha256 = "19qxz5ivrjq9a1shk7mjin0r9v37g33l762nf7lb1xf29y13mhsn";
name = "kdecoration-5.3.1.tar.xz";
};
}
{
name = stdenv.lib.nameFromURL "oxygen-fonts-5.3.0.tar.xz" ".tar";
store = "/nix/store/70mkx8jw7dhs1lvqgdjhcvr6y5y4bfck-oxygen-fonts-5.3.0.tar.xz";
name = stdenv.lib.nameFromURL "oxygen-5.3.1.tar.xz" ".tar";
store = "/nix/store/8z7cjvfh9bw6402ccipzpgfh4a5rwvmd-oxygen-5.3.1.tar.xz";
src = fetchurl {
url = "${mirror}/stable/plasma/5.3.0/oxygen-fonts-5.3.0.tar.xz";
sha256 = "0wiqn91m5b421c46fbicmzhkp7lgzck0mrqn7ng0daw8aj6am94y";
name = "oxygen-fonts-5.3.0.tar.xz";
url = "${mirror}/stable/plasma/5.3.1/oxygen-5.3.1.tar.xz";
sha256 = "03b8rxgspkv5p8mfb53v92bi62cqp7rcma2fjarmgw4ri5w6cwx9";
name = "oxygen-5.3.1.tar.xz";
};
}
{
name = stdenv.lib.nameFromURL "kio-extras-5.3.0.tar.xz" ".tar";
store = "/nix/store/g889cng2b9pwz2yhp3qyjyqzhs6h5jvx-kio-extras-5.3.0.tar.xz";
name = stdenv.lib.nameFromURL "kde-gtk-config-5.3.1.tar.xz" ".tar";
store = "/nix/store/safa43z9955m484jnfagz4rxby5jhn9l-kde-gtk-config-5.3.1.tar.xz";
src = fetchurl {
url = "${mirror}/stable/plasma/5.3.0/kio-extras-5.3.0.tar.xz";
sha256 = "0n6fb4cadp16m1ck11d2zp6lrsjmj1q4iav5gydg3i7bds9kwlhf";
name = "kio-extras-5.3.0.tar.xz";
url = "${mirror}/stable/plasma/5.3.1/kde-gtk-config-5.3.1.tar.xz";
sha256 = "1frykdckgrfbiyjshdkjv6hp8mrpfz3g461w6snb65yly02qjb5l";
name = "kde-gtk-config-5.3.1.tar.xz";
};
}
{
name = stdenv.lib.nameFromURL "oxygen-5.3.0.tar.xz" ".tar";
store = "/nix/store/3hdjzpgy699qpfxj17dq913nf8qw2wgg-oxygen-5.3.0.tar.xz";
name = stdenv.lib.nameFromURL "bluez-qt-5.3.1.tar.xz" ".tar";
store = "/nix/store/s8k9h017za3z3j3h046ialysxxna2avs-bluez-qt-5.3.1.tar.xz";
src = fetchurl {
url = "${mirror}/stable/plasma/5.3.0/oxygen-5.3.0.tar.xz";
sha256 = "0a55zncpa156rlkpg26j2gwl8ibc1fjb014sm4j07c3q85zd7n73";
name = "oxygen-5.3.0.tar.xz";
url = "${mirror}/stable/plasma/5.3.1/bluez-qt-5.3.1.tar.xz";
sha256 = "13i5ybmkf6xg49jh5fbbayxg3gp5h8g1gayc0mdc4cwzx1v6g70l";
name = "bluez-qt-5.3.1.tar.xz";
};
}
{
name = stdenv.lib.nameFromURL "kdeplasma-addons-5.3.0.tar.xz" ".tar";
store = "/nix/store/qrhvjbik2vzxrln457kyl80yhpsk2byx-kdeplasma-addons-5.3.0.tar.xz";
name = stdenv.lib.nameFromURL "polkit-kde-agent-1-5.3.1.tar.xz" ".tar";
store = "/nix/store/z9hb5dcjbvnrrkhba58vbhism9djavh9-polkit-kde-agent-1-5.3.1.tar.xz";
src = fetchurl {
url = "${mirror}/stable/plasma/5.3.0/kdeplasma-addons-5.3.0.tar.xz";
sha256 = "10h68sqm536j972mqn216b0304r2gpy76klgdr2d2pzqs0vwywll";
name = "kdeplasma-addons-5.3.0.tar.xz";
url = "${mirror}/stable/plasma/5.3.1/polkit-kde-agent-1-5.3.1.tar.xz";
sha256 = "01ragaa1r144g25kqdc157d7lbq69cclanaljgwkvs2mn0ib031c";
name = "polkit-kde-agent-1-5.3.1.tar.xz";
};
}
{
name = stdenv.lib.nameFromURL "ksshaskpass-5.3.0.tar.xz" ".tar";
store = "/nix/store/23bkyxca8ydz1g1zj8rlyd14xn073jlw-ksshaskpass-5.3.0.tar.xz";
name = stdenv.lib.nameFromURL "kde-cli-tools-5.3.1.tar.xz" ".tar";
store = "/nix/store/gfah83qmrzhfjxjvgaczz4bggyvxqq2l-kde-cli-tools-5.3.1.tar.xz";
src = fetchurl {
url = "${mirror}/stable/plasma/5.3.0/ksshaskpass-5.3.0.tar.xz";
sha256 = "1f7kn163hnxh47q6h73lqhzkzpjhlbhq670lkr89s5i7kxjnla54";
name = "ksshaskpass-5.3.0.tar.xz";
url = "${mirror}/stable/plasma/5.3.1/kde-cli-tools-5.3.1.tar.xz";
sha256 = "0x4k3yi4qccvfp4ia75alihcivk4slwsx8i0wdb00qjl1nj7jbc1";
name = "kde-cli-tools-5.3.1.tar.xz";
};
}
{
name = stdenv.lib.nameFromURL "plasma-mediacenter-5.3.0.tar.xz" ".tar";
store = "/nix/store/f3bwrgk52fj27b3bpgix8zy1vmwryh5f-plasma-mediacenter-5.3.0.tar.xz";
name = stdenv.lib.nameFromURL "sddm-kcm-5.3.1.tar.xz" ".tar";
store = "/nix/store/mhvhgh8n3a6dzjsxzgp8ynsryv3y54kv-sddm-kcm-5.3.1.tar.xz";
src = fetchurl {
url = "${mirror}/stable/plasma/5.3.0/plasma-mediacenter-5.3.0.tar.xz";
sha256 = "1iw6v35mg6p8g7pxnqqm1sqs75kmk04jzaakmfs6xjn8h34s0kmp";
name = "plasma-mediacenter-5.3.0.tar.xz";
url = "${mirror}/stable/plasma/5.3.1/sddm-kcm-5.3.1.tar.xz";
sha256 = "16viwz7b8s77g5fqw7g7asrrk44fif4fmmif7g3bkmq7rncd3hw9";
name = "sddm-kcm-5.3.1.tar.xz";
};
}
{
name = stdenv.lib.nameFromURL "breeze-5.3.0.tar.xz" ".tar";
store = "/nix/store/3d28b0pqh4qjgbff556q475fgkhx0f5r-breeze-5.3.0.tar.xz";
name = stdenv.lib.nameFromURL "powerdevil-5.3.1.tar.xz" ".tar";
store = "/nix/store/y571p4chd574qvzjbc7pbbixsb7g4g45-powerdevil-5.3.1.tar.xz";
src = fetchurl {
url = "${mirror}/stable/plasma/5.3.0/breeze-5.3.0.tar.xz";
sha256 = "12drbw4j7bk0yd7g45j1w70v3jnm4z323zsad3lnnzw448lm9vck";
name = "breeze-5.3.0.tar.xz";
url = "${mirror}/stable/plasma/5.3.1/powerdevil-5.3.1.tar.xz";
sha256 = "07kcqd7qzblapxnwczfdj4vwb8s6s8mp7qhl4mb663f2a0z6fn8l";
name = "powerdevil-5.3.1.tar.xz";
};
}
{
name = stdenv.lib.nameFromURL "bluedevil-5.3.0.tar.xz" ".tar";
store = "/nix/store/9wq45x6vk9kf9c01ba2xhsdibhaqq7hc-bluedevil-5.3.0.tar.xz";
name = stdenv.lib.nameFromURL "plasma-workspace-5.3.1.tar.xz" ".tar";
store = "/nix/store/kxn9mq9hrqzwpw8ldxqjdaxm5zqnq1jb-plasma-workspace-5.3.1.tar.xz";
src = fetchurl {
url = "${mirror}/stable/plasma/5.3.0/bluedevil-5.3.0.tar.xz";
sha256 = "0bw03kkfzpcq6s2kx8zi66f308zc153m4ddknlvf5cnm7wvykx4q";
name = "bluedevil-5.3.0.tar.xz";
url = "${mirror}/stable/plasma/5.3.1/plasma-workspace-5.3.1.tar.xz";
sha256 = "1cjg8rhwhm015fg36idn4shddcy6sjnb4y0x9vmxbsdvfx2nnhr1";
name = "plasma-workspace-5.3.1.tar.xz";
};
}
{
name = stdenv.lib.nameFromURL "kfilemetadata-5.9.0.tar.xz" ".tar";
store = "/nix/store/whv1mw43461l69j1qa2dp95953si4mcy-kfilemetadata-5.9.0.tar.xz";
name = stdenv.lib.nameFromURL "milou-5.3.1.tar.xz" ".tar";
store = "/nix/store/02qx55q40iwpwwdr5dmnpdg5hhzcdb7a-milou-5.3.1.tar.xz";
src = fetchurl {
url = "${mirror}/stable/plasma/5.3.0/kfilemetadata-5.9.0.tar.xz";
sha256 = "0rgcdpys13qpv11sqrfjxxp75dlchnffvvz7bi7vps1xypnvk4jw";
name = "kfilemetadata-5.9.0.tar.xz";
url = "${mirror}/stable/plasma/5.3.1/milou-5.3.1.tar.xz";
sha256 = "17xw62pngq3bb7vkbkn8c099ivsf1xmns0f65v7j112yqpz33b8a";
name = "milou-5.3.1.tar.xz";
};
}
{
name = stdenv.lib.nameFromURL "khelpcenter-5.3.0.tar.xz" ".tar";
store = "/nix/store/7x373jrlqhj9jq6j3qcz9vimzzr3za5z-khelpcenter-5.3.0.tar.xz";
name = stdenv.lib.nameFromURL "ksysguard-5.3.1.tar.xz" ".tar";
store = "/nix/store/m8q2mc88168lkh4j3jxqjyshf0h5d7gs-ksysguard-5.3.1.tar.xz";
src = fetchurl {
url = "${mirror}/stable/plasma/5.3.0/khelpcenter-5.3.0.tar.xz";
sha256 = "1zk70bc2zmnh37qp2w7rh6lzid5hmavm7amyzllsksakj6ba40ki";
name = "khelpcenter-5.3.0.tar.xz";
url = "${mirror}/stable/plasma/5.3.1/ksysguard-5.3.1.tar.xz";
sha256 = "1z1qgf5qskzf4r524lf75pdyw7gdwrx2yr8nac9622hvgrfh7yhj";
name = "ksysguard-5.3.1.tar.xz";
};
}
{
name = stdenv.lib.nameFromURL "khotkeys-5.3.0.tar.xz" ".tar";
store = "/nix/store/ml95kbmiczriikch5jgk6iwljinsb28b-khotkeys-5.3.0.tar.xz";
name = stdenv.lib.nameFromURL "plasma-desktop-5.3.1.tar.xz" ".tar";
store = "/nix/store/bilfn2r9akz2mxyl03q1a9i8nndbabhg-plasma-desktop-5.3.1.tar.xz";
src = fetchurl {
url = "${mirror}/stable/plasma/5.3.0/khotkeys-5.3.0.tar.xz";
sha256 = "19dy7v67l2xb1x1fqjwljg940gcc9jrvywx2xxvv2lfxgc1i0da4";
name = "khotkeys-5.3.0.tar.xz";
url = "${mirror}/stable/plasma/5.3.1/plasma-desktop-5.3.1.tar.xz";
sha256 = "079v2pbpgn1gr03l3qcxk3rsgbip318xpjbni4vxf08fhsh1ixlp";
name = "plasma-desktop-5.3.1.tar.xz";
};
}
{
name = stdenv.lib.nameFromURL "kwrited-5.3.0.tar.xz" ".tar";
store = "/nix/store/rfhx33pghmghr0kxlwijc6lfwpzs8a91-kwrited-5.3.0.tar.xz";
name = stdenv.lib.nameFromURL "kwin-5.3.1.tar.xz" ".tar";
store = "/nix/store/0b3mjqqacgl23xqkhimqpgswwvsqz7bc-kwin-5.3.1.tar.xz";
src = fetchurl {
url = "${mirror}/stable/plasma/5.3.0/kwrited-5.3.0.tar.xz";
sha256 = "0mv7nrlgwrb10dcf91mrnpjmrzwgdsylnd4b4grccc13c2f55lad";
name = "kwrited-5.3.0.tar.xz";
url = "${mirror}/stable/plasma/5.3.1/kwin-5.3.1.tar.xz";
sha256 = "04bxf45lcbmnl8fks1k6j6i0sk7x5abzhmyrziliz2yx5kyi4m36";
name = "kwin-5.3.1.tar.xz";
};
}
{
name = stdenv.lib.nameFromURL "kwayland-5.3.0.tar.xz" ".tar";
store = "/nix/store/0bnhdabiq55i43gwcvpj52ysi2w0zvw0-kwayland-5.3.0.tar.xz";
name = stdenv.lib.nameFromURL "plasma-workspace-wallpapers-5.3.1.tar.xz" ".tar";
store = "/nix/store/mfn2ga4yr0v8pgknsxsgnvxayn6p7sal-plasma-workspace-wallpapers-5.3.1.tar.xz";
src = fetchurl {
url = "${mirror}/stable/plasma/5.3.0/kwayland-5.3.0.tar.xz";
sha256 = "1ghxwhnk68nadj48r9cxl250ryylwqrarw26jvv7k7kxs6gqlncr";
name = "kwayland-5.3.0.tar.xz";
url = "${mirror}/stable/plasma/5.3.1/plasma-workspace-wallpapers-5.3.1.tar.xz";
sha256 = "1y6gdzs0qxiw4hl9r6v3blcm8gq61wapagn6sj5ixagvwlhf2w5y";
name = "plasma-workspace-wallpapers-5.3.1.tar.xz";
};
}
{
name = stdenv.lib.nameFromURL "sddm-kcm-5.3.0.tar.xz" ".tar";
store = "/nix/store/wfp80cwqkxifmdgqv8p6mgc1k6gf5shd-sddm-kcm-5.3.0.tar.xz";
name = stdenv.lib.nameFromURL "kfilemetadata-5.9.1.tar.xz" ".tar";
store = "/nix/store/pshcx9qvc0z4w486q4a51ygm86p7w06a-kfilemetadata-5.9.1.tar.xz";
src = fetchurl {
url = "${mirror}/stable/plasma/5.3.0/sddm-kcm-5.3.0.tar.xz";
sha256 = "15x0ad6zlpdnc4z398ydpr5w0bfla3r5x6mkgakis0mx6vpyzwcc";
name = "sddm-kcm-5.3.0.tar.xz";
url = "${mirror}/stable/plasma/5.3.1/kfilemetadata-5.9.1.tar.xz";
sha256 = "02gffgwbic4h8zdknp32cczplw3cc9ahg483aa3frhhgvgvrq8hs";
name = "kfilemetadata-5.9.1.tar.xz";
};
}
{
name = stdenv.lib.nameFromURL "kwin-5.3.0.tar.xz" ".tar";
store = "/nix/store/3mzgg28m89a0g0wlysil39g8lzzip46p-kwin-5.3.0.tar.xz";
name = stdenv.lib.nameFromURL "kio-extras-5.3.1.tar.xz" ".tar";
store = "/nix/store/gy53gcnhk83ab62a2w1x0lm7lxxkn9wh-kio-extras-5.3.1.tar.xz";
src = fetchurl {
url = "${mirror}/stable/plasma/5.3.0/kwin-5.3.0.tar.xz";
sha256 = "1mvgmjmxjmv0vl0xfxyqa43rh5n65p3z5zz1ban7lbp16sn6qkqn";
name = "kwin-5.3.0.tar.xz";
url = "${mirror}/stable/plasma/5.3.1/kio-extras-5.3.1.tar.xz";
sha256 = "1m1gc0m9xhapnchiicsn93spylczkggj8c79ixgk99b1ha7vbc87";
name = "kio-extras-5.3.1.tar.xz";
};
}
{
name = stdenv.lib.nameFromURL "baloo-5.9.0.tar.xz" ".tar";
store = "/nix/store/kz17030nf6rifv84p2y08wrygbsl66xg-baloo-5.9.0.tar.xz";
name = stdenv.lib.nameFromURL "bluedevil-5.3.1.tar.xz" ".tar";
store = "/nix/store/v3k1px6zx4dqz77s0l48lky1zh22c2ps-bluedevil-5.3.1.tar.xz";
src = fetchurl {
url = "${mirror}/stable/plasma/5.3.0/baloo-5.9.0.tar.xz";
sha256 = "1n6k6mznnjccqirr8371z0n0h2cpg6lk50n6dcx0cbqc5mfsckyn";
name = "baloo-5.9.0.tar.xz";
url = "${mirror}/stable/plasma/5.3.1/bluedevil-5.3.1.tar.xz";
sha256 = "050hpiifrhm2vzab527anfncdf04cikz5149iabz3aflxcvabqpl";
name = "bluedevil-5.3.1.tar.xz";
};
}
{
name = stdenv.lib.nameFromURL "ksysguard-5.3.0.tar.xz" ".tar";
store = "/nix/store/ixm26iv7hhgkss8carpln178df1p56xv-ksysguard-5.3.0.tar.xz";
name = stdenv.lib.nameFromURL "oxygen-fonts-5.3.1.tar.xz" ".tar";
store = "/nix/store/lbvr2fw8361mmd8gpqk9m917qmg8h381-oxygen-fonts-5.3.1.tar.xz";
src = fetchurl {
url = "${mirror}/stable/plasma/5.3.0/ksysguard-5.3.0.tar.xz";
sha256 = "0pz2v2lxcgn2jp0nzci1yrnxlcs3sf3a2bipaz31w5bhz128k7wi";
name = "ksysguard-5.3.0.tar.xz";
url = "${mirror}/stable/plasma/5.3.1/oxygen-fonts-5.3.1.tar.xz";
sha256 = "0zp81c4s0xvr1d0nvlssk3k3456farz157sqnjvgbsarxnzmgppv";
name = "oxygen-fonts-5.3.1.tar.xz";
};
}
]

2
pkgs/desktops/plasma-5.3/manifest.sh
View File

@ -6,5 +6,5 @@ KDE_MIRROR="${KDE_MIRROR:-http://download.kde.org}"
# The extra slash at the end of the URL is necessary to stop wget
# from recursing over the whole server! (No, it's not a bug.)
$(nix-build ../../.. -A autonix.manifest) \
"${KDE_MIRROR}/stable/plasma/5.3.0/" \
"${KDE_MIRROR}/stable/plasma/5.3.1/" \
$MANIFEST_EXTRA_ARGS -A '*.tar.xz'

42
pkgs/desktops/plasma-5.3/plasma-workspace/0001-startkde-NixOS-patches.patch
View File

@ -1,23 +1,25 @@
From 9aa37de6cd887c6cdd7ea2356cbb6aecdb988b75 Mon Sep 17 00:00:00 2001
From 37abdee4e25f6aff55da838864d1a67a7be758ad Mon Sep 17 00:00:00 2001
From: Thomas Tuegel <ttuegel@gmail.com>
Date: Sun, 3 May 2015 14:51:04 -0500
Date: Tue, 2 Jun 2015 11:21:43 -0500
Subject: [PATCH] startkde: NixOS patches
---
startkde/startkde.cmake | 212 +++++++++++++++++++-----------------------------
1 file changed, 85 insertions(+), 127 deletions(-)
startkde/startkde.cmake | 214 ++++++++++++++++++++----------------------------
1 file changed, 87 insertions(+), 127 deletions(-)
diff --git a/startkde/startkde.cmake b/startkde/startkde.cmake
index 24e5c1b..d8642d3 100644
index 24e5c1b..787d719 100644
--- a/startkde/startkde.cmake
+++ b/startkde/startkde.cmake
@@ -1,8 +1,29 @@
@@ -1,8 +1,31 @@
-#!/bin/sh
+#!@bash@/bin/bash
#
# DEFAULT KDE STARTUP SCRIPT ( @PROJECT_VERSION@ )
#
+set -x
+
+# The KDE icon cache is supposed to update itself
+# automatically, but it uses the timestamp on the icon
+# theme directory as a trigger. Since in Nix the
@ -42,7 +44,7 @@ index 24e5c1b..d8642d3 100644
if test "x$1" = x--failsafe; then
KDE_FAILSAFE=1 # General failsafe flag
KWIN_COMPOSE=N # Disable KWin's compositing
@@ -16,29 +37,16 @@ trap 'echo GOT SIGHUP' HUP
@@ -16,29 +39,16 @@ trap 'echo GOT SIGHUP' HUP
# we have to unset this for Darwin since it will screw up KDE's dynamic-loading
unset DYLD_FORCE_FLAT_NAMESPACE
@ -75,7 +77,7 @@ index 24e5c1b..d8642d3 100644
fi
# Boot sequence:
@@ -56,13 +64,8 @@ fi
@@ -56,13 +66,8 @@ fi
# * Then ksmserver is started which takes control of the rest of the startup sequence
# We need to create config folder so we can write startupconfigkeys
@ -91,7 +93,7 @@ index 24e5c1b..d8642d3 100644
#This is basically setting defaults so we can use them with kstartupconfig5
cat >$configDir/startupconfigkeys <<EOF
@@ -106,53 +109,19 @@ toolBarFont=Oxygen-Sans,9,-1,5,50,0,0,0,0,0
@@ -106,53 +111,19 @@ toolBarFont=Oxygen-Sans,9,-1,5,50,0,0,0,0,0
EOF
}
@ -148,7 +150,7 @@ index 24e5c1b..d8642d3 100644
kapplymousetheme "$kcminputrc_mouse_cursortheme" "$kcminputrc_mouse_cursorsize"
if test $? -eq 10; then
@@ -168,15 +137,33 @@ if test -n "$kcminputrc_mouse_cursortheme" -o -n "$kcminputrc_mouse_cursorsize"
@@ -168,15 +139,33 @@ if test -n "$kcminputrc_mouse_cursortheme" -o -n "$kcminputrc_mouse_cursorsize"
fi
fi
@ -187,7 +189,7 @@ index 24e5c1b..d8642d3 100644
ksplash_pid=
if test -z "$dl"; then
# the splashscreen and progress indicator
@@ -205,8 +192,7 @@ fi
@@ -205,8 +194,7 @@ fi
# For anything else (that doesn't set env vars, or that needs a window manager),
# better use the Autostart folder.
@ -197,7 +199,7 @@ index 24e5c1b..d8642d3 100644
# Add /env/ to the directory to locate the scripts to be sourced
for prefix in `echo $scriptpath`; do
@@ -216,7 +202,7 @@ for prefix in `echo $scriptpath`; do
@@ -216,7 +204,7 @@ for prefix in `echo $scriptpath`; do
done
# Set the path for Qt plugins provided by KDE
@ -206,7 +208,7 @@ index 24e5c1b..d8642d3 100644
# TODO: Do we really need this?
QT_PLUGIN_PATH=$QT_PLUGIN_PATH:$kdehome/lib/kde5/plugins/
export QT_PLUGIN_PATH
@@ -242,7 +228,7 @@ usr_odir=$HOME/.fonts/kde-override
@@ -242,7 +230,7 @@ usr_odir=$HOME/.fonts/kde-override
usr_fdir=$HOME/.fonts
if test -n "$KDEDIRS"; then
@ -215,7 +217,7 @@ index 24e5c1b..d8642d3 100644
sys_odir=$kdedirs_first/share/fonts/override
sys_fdir=$kdedirs_first/share/fonts
else
@@ -255,23 +241,13 @@ fi
@@ -255,23 +243,13 @@ fi
# add the user's dirs to the font path, as they might simply have been made
# read-only by the administrator, for whatever reason.
@ -244,7 +246,7 @@ index 24e5c1b..d8642d3 100644
# Get Ghostscript to look into user's KDE fonts dir for additional Fontmap
if test -n "$GS_LIB" ; then
@@ -284,30 +260,6 @@ fi
@@ -284,30 +262,6 @@ fi
echo 'startkde: Starting up...' 1>&2
@ -275,7 +277,7 @@ index 24e5c1b..d8642d3 100644
# Mark that full KDE session is running (e.g. Konqueror preloading works only
# with full KDE running). The KDE_FULL_SESSION property can be detected by
# any X client connected to the same X session, even if not launched
@@ -332,11 +284,11 @@ fi
@@ -332,11 +286,11 @@ fi
#
KDE_FULL_SESSION=true
export KDE_FULL_SESSION
@ -289,7 +291,7 @@ index 24e5c1b..d8642d3 100644
KDE_SESSION_UID=`id -ru`
export KDE_SESSION_UID
@@ -346,30 +298,36 @@ export XDG_CURRENT_DESKTOP
@@ -346,30 +300,36 @@ export XDG_CURRENT_DESKTOP
# At this point all the environment is ready, let's send it to kwalletd if running
if test -n "$PAM_KWALLET_LOGIN" ; then
@ -331,7 +333,7 @@ index 24e5c1b..d8642d3 100644
# finally, give the session control to the session manager
# see kdebase/ksmserver for the description of the rest of the startup sequence
# if the KDEWM environment variable has been set, then it will be used as KDE's
@@ -385,27 +343,27 @@ test -n "$KDEWM" && KDEWM="--windowmanager $KDEWM"
@@ -385,27 +345,27 @@ test -n "$KDEWM" && KDEWM="--windowmanager $KDEWM"
# lock now and do the rest of the KDE startup underneath the locker.
KSMSERVEROPTIONS=""
test -n "$dl" && KSMSERVEROPTIONS=" --lockscreen"
@ -366,7 +368,7 @@ index 24e5c1b..d8642d3 100644
done
break
fi
@@ -417,21 +375,21 @@ echo 'startkde: Shutting down...' 1>&2
@@ -417,21 +377,21 @@ echo 'startkde: Shutting down...' 1>&2
test -n "$ksplash_pid" && kill "$ksplash_pid" 2>/dev/null
# Clean up
@ -393,5 +395,5 @@ index 24e5c1b..d8642d3 100644
echo 'startkde: Done.' 1>&2
--
2.3.6
2.4.1

4
pkgs/development/compilers/hhvm/default.nix
View File

@ -1,6 +1,6 @@
{ stdenv, fetchgit, cmake, pkgconfig, boost, libunwind, libmemcached, pcre
, libevent, gd, curl, libxml2, icu, flex, bison, openssl, zlib, php, re2c
, expat, libcap, oniguruma, libdwarf, libmcrypt, tbb, gperftools, glog, libkrb5
, expat, libcap, oniguruma, libdwarf, libmcrypt, tbb, gperftools, glog, krb5
, bzip2, openldap, readline, libelf, uwimap, binutils, cyrus_sasl, pam, libpng
, libxslt, ocaml, freetype, gdb, git, perl, mariadb, gmp, libyaml, libedit
, libvpx, imagemagick, fribidi
@ -22,7 +22,7 @@ stdenv.mkDerivation rec {
[ cmake pkgconfig boost libunwind mariadb libmemcached pcre gdb git perl
libevent gd curl libxml2 icu flex bison openssl zlib php expat libcap
oniguruma libdwarf libmcrypt tbb gperftools bzip2 openldap readline
libelf uwimap binutils cyrus_sasl pam glog libpng libxslt ocaml libkrb5
libelf uwimap binutils cyrus_sasl pam glog libpng libxslt ocaml krb5
gmp libyaml libedit libvpx imagemagick fribidi
];

2
pkgs/development/compilers/icedtea/default.nix
View File

@ -135,7 +135,7 @@ let
# Generate certificates.
pushd $jre/lib/icedtea/jre/lib/security
rm cacerts
perl ${./generate-cacerts.pl} $jre/lib/icedtea/jre/bin/keytool ${cacert}/ca-bundle.crt
perl ${./generate-cacerts.pl} $jre/lib/icedtea/jre/bin/keytool ${cacert}/etc/ssl/certs/ca-bundle.crt
popd
ln -s $out/lib/icedtea/bin $out/bin

2
pkgs/development/compilers/openjdk/default.nix
View File

@ -142,7 +142,7 @@ let
# Generate certificates.
pushd $jre/lib/openjdk/jre/lib/security
rm cacerts
perl ${./generate-cacerts.pl} $jre/lib/openjdk/jre/bin/keytool ${cacert}/ca-bundle.crt
perl ${./generate-cacerts.pl} $jre/lib/openjdk/jre/bin/keytool ${cacert}/etc/ssl/certs/ca-bundle.crt
popd
ln -s $out/lib/openjdk/bin $out/bin

2
pkgs/development/compilers/openjdk/openjdk8.nix
View File

@ -136,7 +136,7 @@ let
# Generate certificates.
pushd $jre/lib/openjdk/jre/lib/security
rm cacerts
perl ${./generate-cacerts.pl} $jre/lib/openjdk/jre/bin/keytool ${cacert}/ca-bundle.crt
perl ${./generate-cacerts.pl} $jre/lib/openjdk/jre/bin/keytool ${cacert}/etc/ssl/certs/ca-bundle.crt
popd
ln -s $out/lib/openjdk/bin $out/bin

9
pkgs/development/coq-modules/tlc/default.nix
View File

@ -13,6 +13,15 @@ stdenv.mkDerivation {
buildInputs = [ coq.ocaml coq.camlp5 ];
propagatedBuildInputs = [ coq ];
preConfigure = ''
patch Makefile <<EOF
105c105
< \$(COQC) \$<
---
> \$(COQC) -R . Tlc \$<
EOF
'';
installPhase = ''
COQLIB=$out/lib/coq/${coq.coq-version}/
mkdir -p $COQLIB/user-contrib/Tlc

27
pkgs/development/haskell-modules/configuration-common.nix
View File

@ -121,6 +121,7 @@ self: super: {
# The Haddock phase fails for one reason or another.
attoparsec-conduit = dontHaddock super.attoparsec-conduit;
base-noprelude = dontHaddock super.base-noprelude;
blaze-builder-conduit = dontHaddock super.blaze-builder-conduit;
BNFC-meta = dontHaddock super.BNFC-meta;
bytestring-progress = dontHaddock super.bytestring-progress;
@ -401,7 +402,7 @@ self: super: {
http-client-openssl = dontCheck super.http-client-openssl;
http-client-tls = dontCheck super.http-client-tls;
ihaskell = dontCheck super.ihaskell;
influxdb = dontCheck (dontJailbreak super.influxdb);
influxdb = dontCheck super.influxdb;
itanium-abi = dontCheck super.itanium-abi;
katt = dontCheck super.katt;
language-slice = dontCheck super.language-slice;
@ -779,11 +780,12 @@ self: super: {
# https://github.com/goldfirere/singletons/issues/116
# https://github.com/goldfirere/singletons/issues/117
# https://github.com/goldfirere/singletons/issues/118
singletons = markBroken super.singletons;
singleton-nats = dontDistribute super.singleton-nats;
clash-lib = dontDistribute super.clash-lib;
clash-verilog = dontDistribute super.clash-verilog;
hgeometry = dontDistribute super.hgeometry;
hipe = dontDistribute super.hipe;
clash-lib = dontDistribute super.clash-lib;
singleton-nats = dontDistribute super.singleton-nats;
singletons = markBroken super.singletons;
# https://github.com/anton-k/temporal-music-notation/issues/1
temporal-music-notation = markBroken super.temporal-music-notation;
@ -809,9 +811,6 @@ self: super: {
# https://github.com/yaccz/saturnin/issues/3
Saturnin = dontCheck super.Saturnin;
# https://github.com/kolmodin/binary/issues/74
binary_0_7_4_0 = dontCheck super.binary_0_7_4_0;
# https://github.com/kkardzis/curlhs/issues/6
curlhs = dontCheck super.curlhs;
@ -830,6 +829,16 @@ self: super: {
# FPCO's fork of Cabal won't succeed its test suite.
Cabal-ide-backend = dontCheck super.Cabal-ide-backend;
# https://github.com/vincenthz/hs-cipher-aes/issues/35
cipher-aes = dontCheck super.cipher-aes;
# https://github.com/DanielG/cabal-helper/issues/2
cabal-helper = overrideCabal super.cabal-helper (drv: { preCheck = "export HOME=$TMPDIR"; });
# https://github.com/jgm/gitit/issues/494
gitit = markBroken super.gitit;
# https://github.com/ekmett/comonad/issues/25
comonad = dontCheck super.comonad;
# https://github.com/ekmett/semigroupoids/issues/35
semigroupoids = disableCabalFlag super.semigroupoids "doctests";
}

2
pkgs/development/haskell-modules/configuration-ghc-6.12.x.nix
View File

@ -41,7 +41,7 @@ self: super: {
unix = null;
# binary is not a core library for this compiler.
binary = self.binary_0_7_4_0;
binary = self.binary_0_7_5_0;
# deepseq is not a core library for this compiler.
deepseq_1_3_0_1 = dontJailbreak super.deepseq_1_3_0_1;

2
pkgs/development/haskell-modules/configuration-ghc-7.0.x.nix
View File

@ -35,7 +35,7 @@ self: super: {
unix = null;
# binary is not a core library for this compiler.
binary = self.binary_0_7_4_0;
binary = self.binary_0_7_5_0;
# deepseq is not a core library for this compiler.
deepseq = self.deepseq_1_4_1_1;

9
pkgs/development/haskell-modules/configuration-ghc-7.10.x.nix
View File

@ -92,9 +92,6 @@ self: super: {
# https://bitbucket.org/FlorianHartwig/attobencode/issue/1
AttoBencode = dontCheck super.AttoBencode;
# bos/attoparsec#92
attoparsec = dontCheck super.attoparsec;
# Test suite fails with some (seemingly harmless) error.
# https://code.google.com/p/scrapyourboilerplate/issues/detail?id=24
syb = dontCheck super.syb;
@ -281,10 +278,4 @@ self: super: {
# Won't work with LLVM 3.5.
llvm-general = markBrokenVersion "3.4.5.3" super.llvm-general;
# Ugly hack to trigger a rebuild to fix the broken package on Hydra.
crypto-api = appendConfigureFlag super.crypto-api "-fignore-me-1";
# Fix compilation under GHC 7.10, patch has been sent upstream.
iconv = appendPatch super.iconv ./iconv-fix-ghc710.patch;
}

2
pkgs/development/haskell-modules/configuration-ghc-7.2.x.nix
View File

@ -41,7 +41,7 @@ self: super: {
transformers = self.transformers_0_4_3_0;
# https://github.com/haskell/cabal/issues/2322
Cabal_1_22_3_0 = super.Cabal_1_22_3_0.override { binary = self.binary_0_7_4_0; process = self.process_1_2_3_0; };
Cabal_1_22_3_0 = super.Cabal_1_22_3_0.override { binary = self.binary_0_7_5_0; process = self.process_1_2_3_0; };
# Newer versions don't compile.
Cabal_1_18_1_6 = dontJailbreak super.Cabal_1_18_1_6;

4
pkgs/development/haskell-modules/configuration-ghc-7.4.x.nix
View File

@ -38,10 +38,10 @@ self: super: {
transformers = self.transformers_0_4_3_0;
# https://github.com/haskell/cabal/issues/2322
Cabal_1_22_3_0 = super.Cabal_1_22_3_0.override { binary = self.binary_0_7_4_0; };
Cabal_1_22_3_0 = super.Cabal_1_22_3_0.override { binary = dontCheck self.binary_0_7_5_0; };
# Avoid inconsistent 'binary' versions from 'text' and 'Cabal'.
cabal-install = super.cabal-install.overrideScope (self: super: { binary = self.binary_0_7_4_0; });
cabal-install = super.cabal-install.overrideScope (self: super: { binary = dontCheck self.binary_0_7_5_0; });
# https://github.com/tibbe/hashable/issues/85
hashable = dontCheck super.hashable;

4
pkgs/development/haskell-modules/configuration-ghc-7.6.x.nix
View File

@ -40,10 +40,10 @@ self: super: {
xhtml = self.xhtml_3000_2_1;
# https://github.com/haskell/cabal/issues/2322
Cabal_1_22_3_0 = super.Cabal_1_22_3_0.override { binary = self.binary_0_7_4_0; };
Cabal_1_22_3_0 = super.Cabal_1_22_3_0.override { binary = dontCheck self.binary_0_7_5_0; };
# Avoid inconsistent 'binary' versions from 'text' and 'Cabal'.
cabal-install = super.cabal-install.overrideScope (self: super: { binary = self.binary_0_7_4_0; });
cabal-install = super.cabal-install.overrideScope (self: super: { binary = dontCheck self.binary_0_7_5_0; });
# https://github.com/tibbe/hashable/issues/85
hashable = dontCheck super.hashable;

7
pkgs/development/haskell-modules/configuration-ghc-7.8.x.nix
View File

@ -86,8 +86,8 @@ self: super: {
seqid-streams = super.seqid-streams_0_1_0;
# Need binary >= 0.7.2, but our compiler has only 0.7.1.0.
hosc = super.hosc.overrideScope (self: super: { binary = self.binary_0_7_4_0; });
tidal-midi = super.tidal-midi.overrideScope (self: super: { binary = self.binary_0_7_4_0; });
hosc = super.hosc.overrideScope (self: super: { binary = self.binary_0_7_5_0; });
tidal-midi = super.tidal-midi.overrideScope (self: super: { binary = self.binary_0_7_5_0; });
# These packages need mtl 2.2.x directly or indirectly via dependencies.
amazonka = markBroken super.amazonka;
@ -131,4 +131,7 @@ self: super: {
patchPhase = "sed -i -e 's|base ==4.8.*,|base,|' sandi.cabal"; }
);
# Overriding mtl 2.2.x is fine here because ghc-events is an stand-alone executable.
ghc-events = super.ghc-events.override { mtl = self.mtl_2_2_1; };
}

5
pkgs/development/haskell-modules/generic-builder.nix
View File

@ -72,7 +72,10 @@ let
hasActiveLibrary = isLibrary && (enableStaticLibraries || enableSharedLibraries || enableLibraryProfiling);
enableParallelBuilding = versionOlder "7.10" ghc.version || (versionOlder "7.8" ghc.version && !hasActiveLibrary);
# We cannot enable -j<n> parallelism for libraries because GHC is far more
# likely to generate a non-determistic library ID in that case. Further
# details are at <https://github.com/peti/ghc-library-id-bug>.
enableParallelBuilding = versionOlder "7.8" ghc.version && !hasActiveLibrary;
defaultConfigureFlags = [
"--verbose" "--prefix=$out" "--libdir=\\$prefix/lib/\\$compiler" "--libsubdir=\\$pkgid"

Some files were not shown because too many files have changed in this diff Show More