ilyakooo0/nixpkgs
1
0
Fork 0
mirror of https://github.com/ilyakooo0/nixpkgs.git synced 2024-12-28 14:22:50 +03:00
Code Issues Projects Releases Wiki Activity

Merge branch 'master' into staging

Browse Source
This commit is contained in:
Nikolay Amiantov 2016-03-31 15:46:52 +03:00
commit 5199176b65
165 changed files with 8892 additions and 2280 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
doc/default.nix
View File

@ -47,6 +47,10 @@ stdenv.mkDerivation {
outputFile = "introduction.xml";
useChapters = true;
}
+ toDocbook {
inputFile = ./languages-frameworks/python.md;
outputFile = "./languages-frameworks/python.xml";
}
+ toDocbook {
inputFile = ./haskell-users-guide.md;
outputFile = "haskell-users-guide.xml";
@ -63,9 +67,9 @@ stdenv.mkDerivation {
+ ''
echo ${nixpkgsVersion} > .version
xmllint --noout --nonet --xinclude --noxincludenode \
--relaxng ${docbook5}/xml/rng/docbook/docbook.rng \
manual.xml
# validate against relaxng schema
xmllint --nonet --xinclude --noxincludenode manual.xml --output manual-full.xml
${jing}/bin/jing ${docbook5}/xml/rng/docbook/docbook.rng manual-full.xml
dst=$out/share/doc/nixpkgs
mkdir -p $dst

244
doc/languages-frameworks/bower.xml Normal file
View File

@ -0,0 +1,244 @@
<section xmlns="http://docbook.org/ns/docbook"
xmlns:xlink="http://www.w3.org/1999/xlink"
xml:id="sec-bower">
<title>Bower</title>
<para>
<link xlink:href="http://bower.io">Bower</link> is a package manager
for web site front-end components. Bower packages (comprising of
build artefacts and sometimes sources) are stored in
<command>git</command> repositories, typically on Github. The
package registry is run by the Bower team with package metadata
coming from the <filename>bower.json</filename> file within each
package.
</para>
<para>
The end result of running Bower is a
<filename>bower_components</filename> directory which can be included
in the web app's build process.
</para>
<para>
Bower can be run interactively, by installing
<varname>nodePackages.bower</varname>. More interestingly, the Bower
components can be declared in a Nix derivation, with the help of
<varname>nodePackages.bower2nix</varname>.
</para>
<section xml:id="ssec-bower2nix-usage">
<title><command>bower2nix</command> usage</title>
<para>
Suppose you have a <filename>bower.json</filename> with the following contents:
<example xml:id="ex-bowerJson"><title><filename>bower.json</filename></title>
<programlisting language="json">
<![CDATA[{
"name": "my-web-app",
"dependencies": {
"angular": "~1.5.0",
"bootstrap": "~3.3.6"
}
}]]>
</programlisting>
</example>
</para>
<para>
Running <command>bower2nix</command> will produce something like the
following output:
<programlisting language="nix">
<![CDATA[{ fetchbower, buildEnv }:
buildEnv { name = "bower-env"; ignoreCollisions = true; paths = [
(fetchbower "angular" "1.5.3" "~1.5.0" "1749xb0firxdra4rzadm4q9x90v6pzkbd7xmcyjk6qfza09ykk9y")
(fetchbower "bootstrap" "3.3.6" "~3.3.6" "1vvqlpbfcy0k5pncfjaiskj3y6scwifxygfqnw393sjfxiviwmbv")
(fetchbower "jquery" "2.2.2" "1.9.1 - 2" "10sp5h98sqwk90y4k6hbdviwqzvzwqf47r3r51pakch5ii2y7js1")
]; }]]>
</programlisting>
</para>
<para>
Using the <command>bower2nix</command> command line arguments, the
output can be redirected to a file. A name like
<filename>bower-packages.nix</filename> would be fine.
</para>
<para>
The resulting derivation is a union of all the downloaded Bower
packages (and their dependencies). To use it, they still need to be
linked together by Bower, which is where
<varname>buildBowerComponents</varname> is useful.
</para>
</section>
<section xml:id="ssec-build-bower-components"><title><varname>buildBowerComponents</varname> function</title>
<para>
The function is implemented in <link xlink:href="https://github.com/NixOS/nixpkgs/blob/master/pkgs/development/bower-modules/generic/default.nix">
<filename>pkgs/development/bower-modules/generic/default.nix</filename></link>.
Example usage:
<example xml:id="ex-buildBowerComponents"><title>buildBowerComponents</title>
<programlisting language="nix">
bowerComponents = buildBowerComponents {
name = "my-web-app";
generated = ./bower-packages.nix; <co xml:id="ex-buildBowerComponents-1" />
src = myWebApp; <co xml:id="ex-buildBowerComponents-2" />
};
</programlisting>
</example>
</para>
<para>
In <xref linkend="ex-buildBowerComponents" />, the following arguments
are of special significance to the function:
<calloutlist>
<callout arearefs="ex-buildBowerComponents-1">
<para>
<varname>generated</varname> specifies the file which was created by <command>bower2nix</command>.
</para>
</callout>
<callout arearefs="ex-buildBowerComponents-2">
<para>
<varname>src</varname> is your project's sources. It needs to
contain a <filename>bower.json</filename> file.
</para>
</callout>
</calloutlist>
</para>
<para>
<varname>buildBowerComponents</varname> will run Bower to link
together the output of <command>bower2nix</command>, resulting in a
<filename>bower_components</filename> directory which can be used.
</para>
<para>
Here is an example of a web frontend build process using
<command>gulp</command>. You might use <command>grunt</command>, or
anything else.
</para>
<example xml:id="ex-bowerGulpFile"><title>Example build script (<filename>gulpfile.js</filename>)</title>
<programlisting language="javascript">
<![CDATA[var gulp = require('gulp');
gulp.task('default', [], function () {
gulp.start('build');
});
gulp.task('build', [], function () {
console.log("Just a dummy gulp build");
gulp
.src(["./bower_components/**/*"])
.pipe(gulp.dest("./gulpdist/"));
});]]>
</programlisting>
</example>
<example xml:id="ex-buildBowerComponentsDefaultNix">
<title>Full example — <filename>default.nix</filename></title>
<programlisting language="nix">
{ myWebApp ? { outPath = ./.; name = "myWebApp"; }
, pkgs ? import &lt;nixpkgs&gt; {}
}:
pkgs.stdenv.mkDerivation {
name = "my-web-app-frontend";
src = myWebApp;
buildInputs = [ pkgs.nodePackages.gulp ];
bowerComponents = pkgs.buildBowerComponents { <co xml:id="ex-buildBowerComponentsDefault-1" />
name = "my-web-app";
generated = ./bower-packages.nix;
src = myWebApp;
};
buildPhase = ''
cp --reflink=auto --no-preserve=mode -R $bowerComponents/bower_components . <co xml:id="ex-buildBowerComponentsDefault-2" />
export HOME=$PWD <co xml:id="ex-buildBowerComponentsDefault-3" />
${pkgs.nodePackages.gulp}/bin/gulp build <co xml:id="ex-buildBowerComponentsDefault-4" />
'';
installPhase = "mv gulpdist $out";
}
</programlisting>
</example>
<para>
A few notes about <xref linkend="ex-buildBowerComponentsDefaultNix" />:
<calloutlist>
<callout arearefs="ex-buildBowerComponentsDefault-1">
<para>
The result of <varname>buildBowerComponents</varname> is an
input to the frontend build.
</para>
</callout>
<callout arearefs="ex-buildBowerComponentsDefault-2">
<para>
Whether to symlink or copy the
<filename>bower_components</filename> directory depends on the
build tool in use. In this case a copy is used to avoid
<command>gulp</command> silliness with permissions.
</para>
</callout>
<callout arearefs="ex-buildBowerComponentsDefault-3">
<para>
<command>gulp</command> requires <varname>HOME</varname> to
refer to a writeable directory.
</para>
</callout>
<callout arearefs="ex-buildBowerComponentsDefault-4">
<para>
The actual build command. Other tools could be used.
</para>
</callout>
</calloutlist>
</para>
</section>
<section xml:id="ssec-bower2nix-troubleshooting">
<title>Troubleshooting</title>
<variablelist>
<varlistentry>
<term>
<literal>ENOCACHE</literal> errors from
<varname>buildBowerComponents</varname>
</term>
<listitem>
<para>
This means that Bower was looking for a package version which
doesn't exist in the generated
<filename>bower-packages.nix</filename>.
</para>
<para>
If <filename>bower.json</filename> has been updated, then run
<command>bower2nix</command> again.
</para>
<para>
It could also be a bug in <command>bower2nix</command> or
<command>fetchbower</command>. If possible, try reformulating
the version specification in <filename>bower.json</filename>.
</para>
</listitem>
</varlistentry>
</variablelist>
</section>
</section>

1
doc/languages-frameworks/index.xml
View File

@ -24,6 +24,7 @@ such as Perl or Haskell. These are described in this chapter.</para>
<xi:include href="r.xml" /> <!-- generated from ../../pkgs/development/r-modules/README.md -->
<xi:include href="qt.xml" />
<xi:include href="texlive.xml" />
<xi:include href="bower.xml" />
</chapter>

714
doc/languages-frameworks/python.md Normal file
View File

@ -0,0 +1,714 @@
# Python
## User Guide
Several versions of Python are available on Nix as well as a high amount of
packages. The default interpreter is CPython 2.7.
### Using Python
#### Installing Python and packages
It is important to make a distinction between Python packages that are
used as libraries, and applications that are written in Python.
Applications on Nix are installed typically into your user
profile imperatively using `nix-env -i`, and on NixOS declaratively by adding the
package name to `environment.systemPackages` in `/etc/nixos/configuration.nix`.
Dependencies such as libraries are automatically installed and should not be
installed explicitly.
The same goes for Python applications and libraries. Python applications can be
installed in your profile, but Python libraries you would like to use to develop
cannot. If you do install libraries in your profile, then you will end up with
import errors.
#### Python environments using `nix-shell`
The recommended method for creating Python environments for development is with
`nix-shell`. Executing
```sh
$ nix-shell -p python35Packages.numpy python35Packages.toolz
```
opens a Nix shell which has available the requested packages and dependencies.
Now you can launch the Python interpreter (which is itself a dependency)
```sh
[nix-shell:~] python3
```
If the packages were not available yet in the Nix store, Nix would download or
build them automatically. A convenient option with `nix-shell` is the `--run`
option, with which you can execute a command in the `nix-shell`. Let's say we
want the above environment and directly run the Python interpreter
```sh
$ nix-shell -p python35Packages.numpy python35Packages.toolz --run "python3"
```
This way you can use the `--run` option also to directly run a script
```sh
$ nix-shell -p python35Packages.numpy python35Packages.toolz --run "python3 myscript.py"
```
In fact, for this specific use case there is a more convenient method. You can
add a [shebang](https://en.wikipedia.org/wiki/Shebang_(Unix)) to your script
specifying which dependencies Nix shell needs. With the following shebang, you
can use `nix-shell myscript.py` and it will make available all dependencies and
run the script in the `python3` shell.
```py
#! /usr/bin/env nix-shell
#! nix-shell -i python3 -p python3Packages.numpy
import numpy
print(numpy.__version__)
```
Likely you do not want to type your dependencies each and every time. What you
can do is write a simple Nix expression which sets up an environment for you,
requiring you only to type `nix-shell`. Say we want to have Python 3.5, `numpy`
and `toolz`, like before, in an environment. With a `shell.nix` file
containing
```nix
with import <nixpkgs> {};
(pkgs.python35.buildEnv.override {
extraLibs = with pkgs.python35Packages; [ numpy toolz ];
}).env
```
executing `nix-shell` gives you again a Nix shell from which you can run Python.
What's happening here?
1. We begin with importing the Nix Packages collections. `import <nixpkgs>` import the `<nixpkgs>` function, `{}` calls it and the `with` statement brings all attributes of `nixpkgs` in the local scope. Therefore we can now use `pkgs`.
2. Then we create a Python 3.5 environment with `pkgs.buildEnv`. Because we want to use it with a custom set of Python packages, we override it.
3. The `extraLibs` argument of the original `buildEnv` function can be used to specify which packages should be included. We want `numpy` and `toolz`. Again, we use the `with` statement to bring a set of attributes into the local scope.
4. And finally, for in interactive use we return the environment.
### Developing with Python
Now that you know how to get a working Python environment on Nix, it is time to go forward and start actually developing with Python.
We will first have a look at how Python packages are packaged on Nix. Then, we will look how you can use development mode with your code.
#### Python packaging on Nix
On Nix all packages are built by functions. The main function in Nix for building Python packages is [`buildPythonPackage`](https://github.com/NixOS/nixpkgs/blob/master/pkgs/development/python-modules/generic/default.nix).
Let's see how we would build the `toolz` package. According to [`python-packages.nix`](https://raw.githubusercontent.com/NixOS/nixpkgs/master/pkgs/top-level/python-packages.nix) `toolz` is build using
```nix
toolz = buildPythonPackage rec{
name = "toolz-${version}";
version = "0.7.4";
src = pkgs.fetchurl{
url = "https://pypi.python.org/packages/source/t/toolz/toolz-${version}.tar.gz";
sha256 = "43c2c9e5e7a16b6c88ba3088a9bfc82f7db8e13378be7c78d6c14a5f8ed05afd";
};
meta = {
homepage = "http://github.com/pytoolz/toolz/";
description = "List processing tools and functional utilities";
license = licenses.bsd3;
maintainers = with maintainers; [ fridh ];
};
};
```
What happens here? The function `buildPythonPackage` is called and as argument
it accepts a set. In this case the set is a recursive set ([`rec`](http://nixos.org/nix/manual/#sec-constructs)).
One of the arguments is the name of the package, which consists of a basename
(generally following the name on PyPi) and a version. Another argument, `src`
specifies the source, which in this case is fetched from an url. `fetchurl` not
only downloads the target file, but also validates its hash. Furthermore, we
specify some (optional) [meta information](http://nixos.org/nixpkgs/manual/#chap-meta).
The output of the function is a derivation, which is an attribute with the name
`toolz` of the set `pythonPackages`. Actually, sets are created for all interpreter versions,
so `python27Packages`, `python34Packages`, `python35Packages` and `pypyPackages`.
The above example works when you're directly working on
`pkgs/top-level/python-packages.nix` in the Nixpkgs repository. Often though,
you will want to test a Nix expression outside of the Nixpkgs tree. If you
create a `shell.nix` file with the following contents
```nix
with import <nixpkgs> {};
pkgs.python35Packages.buildPythonPackage rec {
name = "toolz-${version}";
version = "0.7.4";
src = pkgs.fetchurl{
url = "https://pypi.python.org/packages/source/t/toolz/toolz-${version}.tar.gz";
sha256 = "43c2c9e5e7a16b6c88ba3088a9bfc82f7db8e13378be7c78d6c14a5f8ed05afd";
};
meta = {
homepage = "http://github.com/pytoolz/toolz/";
description = "List processing tools and functional utilities";
license = licenses.bsd3;
maintainers = with maintainers; [ fridh ];
};
}
```
and then execute `nix-shell` will result in an environment in which you can use
Python 3.5 and the `toolz` package. As you can see we had to explicitly mention
for which Python version we want to build a package.
The above example considered only a single package. Generally you will want to use multiple packages.
If we create a `shell.nix` file with the following contents
```nix
with import <nixpkgs> {};
( let
toolz = pkgs.python35Packages.buildPythonPackage rec {
name = "toolz-${version}";
version = "0.7.4";
src = pkgs.fetchurl{
url = "https://pypi.python.org/packages/source/t/toolz/toolz-${version}.tar.gz";
sha256 = "43c2c9e5e7a16b6c88ba3088a9bfc82f7db8e13378be7c78d6c14a5f8ed05afd";
};
meta = {
homepage = "http://github.com/pytoolz/toolz/";
description = "List processing tools and functional utilities";
license = licenses.bsd3;
maintainers = with maintainers; [ fridh ];
};
};
in pkgs.python35.buildEnv.override rec {
extraLibs = [ pkgs.python35Packages.numpy toolz ];
}
).env
```
and again execute `nix-shell`, then we get a Python 3.5 environment with our
locally defined package as well as `numpy` which is build according to the
definition in Nixpkgs. What did we do here? Well, we took the Nix expression
that we used earlier to build a Python environment, and said that we wanted to
include our own version of `toolz`. To introduce our own package in the scope of
`buildEnv.override` we used a
[`let`](http://nixos.org/nix/manual/#sec-constructs) expression.
### Handling dependencies
Our example, `toolz`, doesn't have any dependencies on other Python
packages or system libraries. According to the manual, `buildPythonPackage`
uses the arguments `buildInputs` and `propagatedBuildInputs` to specify dependencies. If something is
exclusively a build-time dependency, then the dependency should be included as a
`buildInput`, but if it is (also) a runtime dependency, then it should be added
to `propagatedBuildInputs`. Test dependencies are considered build-time dependencies.
The following example shows which arguments are given to `buildPythonPackage` in
order to build [`datashape`](https://github.com/blaze/datashape).
```nix
datashape = buildPythonPackage rec {
name = "datashape-${version}";
version = "0.4.7";
src = pkgs.fetchurl {
url = "https://pypi.python.org/packages/source/D/DataShape/${name}.tar.gz";
sha256 = "14b2ef766d4c9652ab813182e866f493475e65e558bed0822e38bf07bba1a278";
};
buildInputs = with self; [ pytest ];
propagatedBuildInputs = with self; [ numpy multipledispatch dateutil ];
meta = {
homepage = https://github.com/ContinuumIO/datashape;
description = "A data description language";
license = licenses.bsd2;
maintainers = with maintainers; [ fridh ];
};
};
```
We can see several runtime dependencies, `numpy`, `multipledispatch`, and
`dateutil`. Furthermore, we have one `buildInput`, i.e. `pytest`. `pytest` is a
test runner and is only used during the `checkPhase` and is therefore not added
to `propagatedBuildInputs`.
In the previous case we had only dependencies on other Python packages to consider.
Occasionally you have also system libraries to consider. E.g., `lxml` provides
Python bindings to `libxml2` and `libxslt`. These libraries are only required
when building the bindings and are therefore added as `buildInputs`.
```nix
lxml = buildPythonPackage rec {
name = "lxml-3.4.4";
src = pkgs.fetchurl {
url = "http://pypi.python.org/packages/source/l/lxml/${name}.tar.gz";
sha256 = "16a0fa97hym9ysdk3rmqz32xdjqmy4w34ld3rm3jf5viqjx65lxk";
};
buildInputs = with self; [ pkgs.libxml2 pkgs.libxslt ];
meta = {
description = "Pythonic binding for the libxml2 and libxslt libraries";
homepage = http://lxml.de;
license = licenses.bsd3;
maintainers = with maintainers; [ sjourdois ];
};
};
```
In this example `lxml` and Nix are able to work out exactly where the relevant
files of the dependencies are. This is not always the case.
The example below shows bindings to The Fastest Fourier Transform in the West, commonly known as
FFTW. On Nix we have separate packages of FFTW for the different types of floats
(`"single"`, `"double"`, `"long-double"`). The bindings need all three types,
and therefore we add all three as `buildInputs`. The bindings don't expect to
find each of them in a different folder, and therefore we have to set `LDFLAGS`
and `CFLAGS`.
```nix
pyfftw = buildPythonPackage rec {
name = "pyfftw-${version}";
version = "0.9.2";
src = pkgs.fetchurl {
url = "https://pypi.python.org/packages/source/p/pyFFTW/pyFFTW-${version}.tar.gz";
sha256 = "f6bbb6afa93085409ab24885a1a3cdb8909f095a142f4d49e346f2bd1b789074";
};
buildInputs = [ pkgs.fftw pkgs.fftwFloat pkgs.fftwLongDouble];
propagatedBuildInputs = with self; [ numpy scipy ];
# Tests cannot import pyfftw. pyfftw works fine though.
doCheck = false;
LDFLAGS="-L${pkgs.fftw}/lib -L${pkgs.fftwFloat}/lib -L${pkgs.fftwLongDouble}/lib"
CFLAGS="-I${pkgs.fftw}/include -I${pkgs.fftwFloat}/include -I${pkgs.fftwLongDouble}/include"
'';
meta = {
description = "A pythonic wrapper around FFTW, the FFT library, presenting a unified interface for all the supported transforms";
homepage = http://hgomersall.github.com/pyFFTW/;
license = with licenses; [ bsd2 bsd3 ];
maintainer = with maintainers; [ fridh ];
};
};
```
Note also the line `doCheck = false;`, we explicitly disabled running the test-suite.
#### Develop local package
As a Python developer you're likely aware of [development mode](http://pythonhosted.org/setuptools/setuptools.html#development-mode) (`python setup.py develop`);
instead of installing the package this command creates a special link to the project code.
That way, you can run updated code without having to reinstall after each and every change you make.
Development mode is also available on Nix as [explained](http://nixos.org/nixpkgs/manual/#ssec-python-development) in the Nixpkgs manual.
Let's see how you can use it.
In the previous Nix expression the source was fetched from an url. We can also refer to a local source instead using
```nix
src = ./path/to/source/tree;
```
If we create a `shell.nix` file which calls `buildPythonPackage`, and if `src`
is a local source, and if the local source has a `setup.py`, then development
mode is activated.
In the following example we create a simple environment that
has a Python 3.5 version of our package in it, as well as its dependencies and
other packages we like to have in the environment, all specified with `propagatedBuildInputs`.
Indeed, we can just add any package we like to have in our environment to `propagatedBuildInputs`.
```nix
with import <nixpkgs>;
with pkgs.python35Packages;
buildPythonPackage rec {
name = "mypackage";
src = ./path/to/package/source;
propagatedBuildInputs = [ pytest numpy pkgs.libsndfile ];
};
```
It is important to note that due to how development mode is implemented on Nix it is not possible to have multiple packages simultaneously in development mode.
### Organising your packages
So far we discussed how you can use Python on Nix, and how you can develop with
it. We've looked at how you write expressions to package Python packages, and we
looked at how you can create environments in which specified packages are
available.
At some point you'll likely have multiple packages which you would
like to be able to use in different projects. In order to minimise unnecessary
duplication we now look at how you can maintain yourself a repository with your
own packages. The important functions here are `import` and `callPackage`.
### Including a derivation using `callPackage`
Earlier we created a Python environment using `buildEnv`, and included the
`toolz` package via a `let` expression.
Let's split the package definition from the environment definition.
We first create a function that builds `toolz` in `~/path/to/toolz/release.nix`
```nix
{ pkgs, buildPythonPackage }:
buildPythonPackage rec {
name = "toolz-${version}";
version = "0.7.4";
src = pkgs.fetchurl{
url = "https://pypi.python.org/packages/source/t/toolz/toolz-${version}.tar.gz";
sha256 = "43c2c9e5e7a16b6c88ba3088a9bfc82f7db8e13378be7c78d6c14a5f8ed05afd";
};
meta = {
homepage = "http://github.com/pytoolz/toolz/";
description = "List processing tools and functional utilities";
license = licenses.bsd3;
maintainers = with maintainers; [ fridh ];
};
};
```
It takes two arguments, `pkgs` and `buildPythonPackage`.
We now call this function using `callPackage` in the definition of our environment
```nix
with import <nixpkgs> {};
( let
toolz = pkgs.callPackage ~/path/to/toolz/release.nix { pkgs=pkgs; buildPythonPackage=pkgs.python35Packages.buildPythonPackage; };
in pkgs.python35.buildEnv.override rec {
extraLibs = [ pkgs.python35Packages.numpy toolz ];
}
).env
```
Important to remember is that the Python version for which the package is made
depends on the `python` derivation that is passed to `buildPythonPackage`. Nix
tries to automatically pass arguments when possible, which is why generally you
don't explicitly define which `python` derivation should be used. In the above
example we use `buildPythonPackage` that is part of the set `python35Packages`,
and in this case the `python35` interpreter is automatically used.
## Reference
### Interpreters
Versions 2.6, 2.7, 3.3, 3.4 and 3.5 of the CPython interpreter are available on
Nix and are available as `python26`, `python27`, `python33`, `python34` and
`python35`. The PyPy interpreter is also available as `pypy`. Currently, the
aliases `python` and `python3` correspond to respectively `python27` and
`python35`. The Nix expressions for the interpreters can be found in
`pkgs/development/interpreters/python`.
#### Missing modules standard library
The interpreters `python26` and `python27` do not include modules that
require external dependencies. This is done in order to reduce the closure size.
The following modules need to be added as `buildInput` explicitly:
* `python.modules.bsddb`
* `python.modules.curses`
* `python.modules.curses_panel`
* `python.modules.crypt`
* `python.modules.gdbm`
* `python.modules.sqlite3`
* `python.modules.tkinter`
* `python.modules.readline`
For convenience `python27Full` and `python26Full` are provided with all
modules included.
All packages depending on any Python interpreter get appended
`out/{python.sitePackages}` to `$PYTHONPATH` if such directory
exists.
#### Attributes on interpreters packages
Each interpreter has the following attributes:
- `libPrefix`. Name of the folder in `${python}/lib/` for corresponding interpreter.
- `interpreter`. Alias for `${python}/bin/${executable}`.
- `buildEnv`. Function to build python interpreter environments with extra packages bundled together. See section *python.buildEnv function* for usage and documentation.
- `sitePackages`. Alias for `lib/${libPrefix}/site-packages`.
- `executable`. Name of the interpreter executable, ie `python3.4`.
### Building packages and applications
Python packages (libraries) and applications that use `setuptools` or
`distutils` are typically built with respectively the `buildPythonPackage` and
`buildPythonApplication` functions.
All Python packages reside in `pkgs/top-level/python-packages.nix` and all
applications elsewhere. Some packages are also defined in
`pkgs/development/python-modules`. It is important that these packages are
called in `pkgs/top-level/python-packages.nix` and not elsewhere, to guarantee
the right version of the package is built.
Based on the packages defined in `pkgs/top-level/python-packages.nix` an
attribute set is created for each available Python interpreter. The available
sets are
* `pkgs.python26Packages`
* `pkgs.python27Packages`
* `pkgs.python33Packages`
* `pkgs.python34Packages`
* `pkgs.python35Packages`
* `pkgs.pypyPackages`
and the aliases
* `pkgs.pythonPackages` pointing to `pkgs.python27Packages`
* `pkgs.python3Packages` pointing to `pkgs.python35Packages`
#### `buildPythonPackage` function
The `buildPythonPackage` function is implemented in
`pkgs/development/python-modules/generic/default.nix`
and can be used as:
twisted = buildPythonPackage {
name = "twisted-8.1.0";
src = pkgs.fetchurl {
url = http://tmrc.mit.edu/mirror/twisted/Twisted/8.1/Twisted-8.1.0.tar.bz2;
sha256 = "0q25zbr4xzknaghha72mq57kh53qw1bf8csgp63pm9sfi72qhirl";
};
propagatedBuildInputs = [ self.ZopeInterface ];
meta = {
homepage = http://twistedmatrix.com/;
description = "Twisted, an event-driven networking engine written in Python";
license = stdenv.lib.licenses.mit; };
};
The `buildPythonPackage` mainly does four things:
* In the `buildPhase`, it calls `${python.interpreter} setup.py bdist_wheel` to build a wheel binary zipfile.
* In the `installPhase`, it installs the wheel file using `pip install *.whl`.
* In the `postFixup` phase, the `wrapPythonPrograms` bash function is called to wrap all programs in the `$out/bin/*` directory to include `$PYTHONPATH` and `$PATH` environment variables.
* In the `installCheck` phase, `${python.interpreter} setup.py test` is ran.
As in Perl, dependencies on other Python packages can be specified in the
`buildInputs` and `propagatedBuildInputs` attributes. If something is
exclusively a build-time dependency, use `buildInputs`; if it’s (also) a runtime
dependency, use `propagatedBuildInputs`.
By default tests are run because `doCheck = true`. Test dependencies, like
e.g. the test runner, should be added to `buildInputs`.
By default `meta.platforms` is set to the same value
as the interpreter unless overriden otherwise.
##### `buildPythonPackage` parameters
All parameters from `mkDerivation` function are still supported.
* `namePrefix`: Prepended text to `${name}` parameter. Defaults to `"python3.3-"` for Python 3.3, etc. Set it to `""` if you're packaging an application or a command line tool.
* `disabled`: If `true`, package is not build for particular python interpreter version. Grep around `pkgs/top-level/python-packages.nix` for examples.
* `setupPyBuildFlags`: List of flags passed to `setup.py build_ext` command.
* `pythonPath`: List of packages to be added into `$PYTHONPATH`. Packages in `pythonPath` are not propagated (contrary to `propagatedBuildInputs`).
* `preShellHook`: Hook to execute commands before `shellHook`.
* `postShellHook`: Hook to execute commands after `shellHook`.
* `makeWrapperArgs`: A list of strings. Arguments to be passed to `makeWrapper`, which wraps generated binaries. By default, the arguments to `makeWrapper` set `PATH` and `PYTHONPATH` environment variables before calling the binary. Additional arguments here can allow a developer to set environment variables which will be available when the binary is run. For example, `makeWrapperArgs = ["--set FOO BAR" "--set BAZ QUX"]`.
* `installFlags`: A list of strings. Arguments to be passed to `pip install`. To pass options to `python setup.py install`, use `--install-option`. E.g., `installFlags=["--install-option='--cpp_implementation'"].
#### `buildPythonApplication` function
The `buildPythonApplication` function is practically the same as `buildPythonPackage`.
The difference is that `buildPythonPackage` by default prefixes the names of the packages with the version of the interpreter.
Because with an application we're not interested in multiple version the prefix is dropped.
#### python.buildEnv function
Python environments can be created using the low-level `pkgs.buildEnv` function.
This example shows how to create an environment that has the Pyramid Web Framework.
Saving the following as `default.nix`
with import {};
python.buildEnv.override {
extraLibs = [ pkgs.pythonPackages.pyramid ];
ignoreCollisions = true;
}
and running `nix-build` will create
/nix/store/cf1xhjwzmdki7fasgr4kz6di72ykicl5-python-2.7.8-env
with wrapped binaries in `bin/`.
You can also use the `env` attribute to create local environments with needed
packages installed. This is somewhat comparable to `virtualenv`. For example,
running `nix-shell` with the following `shell.nix`
with import {};
(python3.buildEnv.override {
extraLibs = with python3Packages; [ numpy requests ];
}).env
will drop you into a shell where Python will have the
specified packages in its path.
##### `python.buildEnv` arguments
* `extraLibs`: List of packages installed inside the environment.
* `postBuild`: Shell command executed after the build of environment.
* `ignoreCollisions`: Ignore file collisions inside the environment (default is `false`).
### Development mode
Development or editable mode is supported. To develop Python packages
`buildPythonPackage` has additional logic inside `shellPhase` to run `pip
install -e . --prefix $TMPDIR/`for the package.
Warning: `shellPhase` is executed only if `setup.py` exists.
Given a `default.nix`:
with import {};
buildPythonPackage { name = "myproject";
buildInputs = with pkgs.pythonPackages; [ pyramid ];
src = ./.; }
Running `nix-shell` with no arguments should give you
the environment in which the package would be build with
`nix-build`.
Shortcut to setup environments with C headers/libraries and python packages:
$ nix-shell -p pythonPackages.pyramid zlib libjpeg git
Note: There is a boolean value `lib.inNixShell` set to `true` if nix-shell is invoked.
### Tools
Packages inside nixpkgs are written by hand. However many tools exist in
community to help save time. No tool is preferred at the moment.
- [python2nix](https://github.com/proger/python2nix) by Vladimir Kirillov
- [pypi2nix](https://github.com/garbas/pypi2nix) by Rok Garbas
- [pypi2nix](https://github.com/offlinehacker/pypi2nix) by Jaka Hudoklin
## FAQ
### How to solve circular dependencies?
Consider the packages `A` and `B` that depend on each other. When packaging `B`,
a solution is to override package `A` not to depend on `B` as an input. The same
should also be done when packaging `A`.
### How to override a Python package?
Recursively updating a package can be done with `pkgs.overridePackages` as explained in the Nixpkgs manual.
Python attribute sets are created for each interpreter version. We will therefore override the attribute set for the interpreter version we're interested.
In the following example we change the name of the package `pandas` to `foo`.
```
newpkgs = pkgs.overridePackages(self: super: rec {
python35Packages = super.python35Packages.override {
self = python35Packages // { pandas = python35Packages.pandas.override{name="foo";};};
};
});
```
This can be tested with
```
with import <nixpkgs> {};
(let
newpkgs = pkgs.overridePackages(self: super: rec {
python35Packages = super.python35Packages.override {
self = python35Packages // { pandas = python35Packages.pandas.override{name="foo";};};
};
});
in newpkgs.python35.buildEnv.override{
extraLibs = [newpkgs.python35Packages.blaze ];
}).env
```
A typical use case is to switch to another version of a certain package. For example, in the Nixpkgs repository we have multiple versions of `django` and `scipy`.
In the following example we use a different version of `scipy`. All packages in `newpkgs` will now use the updated `scipy` version.
```
with import <nixpkgs> {};
(let
newpkgs = pkgs.overridePackages(self: super: rec {
python35Packages = super.python35Packages.override {
self = python35Packages // { scipy = python35Packages.scipy_0_16;};
};
});
in pkgs.python35.buildEnv.override{
extraLibs = [newpkgs.python35Packages.blaze ];
}).env
```
The requested package `blaze` depends upon `pandas` which itself depends on `scipy`.
### `install_data` / `data_files` problems
If you get the following error:
could not create '/nix/store/6l1bvljpy8gazlsw2aw9skwwp4pmvyxw-python-2.7.8/etc':
Permission denied
This is a [known bug](https://bitbucket.org/pypa/setuptools/issue/130/install_data-doesnt-respect-prefix) in setuptools.
Setuptools `install_data` does not respect `--prefix`. An example of such package using the feature is `pkgs/tools/X11/xpra/default.nix`.
As workaround install it as an extra `preInstall` step:
${python.interpreter} setup.py install_data --install-dir=$out --root=$out
sed -i '/ = data\_files/d' setup.py
### Rationale of non-existent global site-packages
On most operating systems a global `site-packages` is maintained. This however
becomes problematic if you want to run multiple Python versions or have multiple
versions of certain libraries for your projects. Generally, you would solve such
issues by creating virtual environments using `virtualenv`.
On Nix each package has an isolated dependency tree which, in the case of
Python, guarantees the right versions of the interpreter and libraries or
packages are available. There is therefore no need to maintain a global `site-packages`.
If you want to create a Python environment for development, then the recommended
method is to use `nix-shell`, either with or without the `python.buildEnv`
function.
## Contributing
### Contributing guidelines
Following rules are desired to be respected:
* Make sure package builds for all python interpreters. Use `disabled` argument to `buildPythonPackage` to set unsupported interpreters.
* If tests need to be disabled for a package, make sure you leave a comment about reasoning.
* Packages in `pkgs/top-level/python-packages.nix` are sorted quasi-alphabetically to avoid merge conflicts.
* Python libraries are supposed to be in `python-packages.nix` and packaged with `buildPythonPackage`. Python applications live outside of `python-packages.nix` and are packaged with `buildPythonApplication`.

447
doc/languages-frameworks/python.xml
View File

@ -1,447 +0,0 @@
<section xmlns="http://docbook.org/ns/docbook"
xmlns:xlink="http://www.w3.org/1999/xlink"
xml:id="sec-python">
<title>Python</title>
<para>
Currently supported interpreters are <varname>python26</varname>, <varname>python27</varname>,
<varname>python33</varname>, <varname>python34</varname>, <varname>python35</varname>
and <varname>pypy</varname>.
</para>
<para>
<varname>python</varname> is an alias to <varname>python27</varname> and <varname>python3</varname> is an alias to <varname>python34</varname>.
</para>
<para>
<varname>python26</varname> and <varname>python27</varname> do not include modules that require
external dependencies (to reduce dependency bloat). Following modules need to be added as
<varname>buildInput</varname> explicitly:
</para>
<itemizedlist>
<listitem><para><varname>python.modules.bsddb</varname></para></listitem>
<listitem><para><varname>python.modules.curses</varname></para></listitem>
<listitem><para><varname>python.modules.curses_panel</varname></para></listitem>
<listitem><para><varname>python.modules.crypt</varname></para></listitem>
<listitem><para><varname>python.modules.gdbm</varname></para></listitem>
<listitem><para><varname>python.modules.sqlite3</varname></para></listitem>
<listitem><para><varname>python.modules.tkinter</varname></para></listitem>
<listitem><para><varname>python.modules.readline</varname></para></listitem>
</itemizedlist>
<para>For convenience <varname>python27Full</varname> and <varname>python26Full</varname>
are provided with all modules included.</para>
<para>
Python packages that
use <link xlink:href="http://pypi.python.org/pypi/setuptools/"><literal>setuptools</literal></link> or <literal>distutils</literal>,
can be built using the <varname>buildPythonPackage</varname> function as documented below.
</para>
<para>
All packages depending on any Python interpreter get appended <varname>$out/${python.sitePackages}</varname>
to <literal>$PYTHONPATH</literal> if such directory exists.
</para>
<variablelist>
<title>
Useful attributes on interpreters packages:
</title>
<varlistentry>
<term><varname>libPrefix</varname></term>
<listitem><para>
Name of the folder in <literal>${python}/lib/</literal> for corresponding interpreter.
</para></listitem>
</varlistentry>
<varlistentry>
<term><varname>interpreter</varname></term>
<listitem><para>
Alias for <literal>${python}/bin/${executable}.</literal>
</para></listitem>
</varlistentry>
<varlistentry>
<term><varname>buildEnv</varname></term>
<listitem><para>
Function to build python interpreter environments with extra packages bundled together.
See <xref linkend="ssec-python-build-env" /> for usage and documentation.
</para></listitem>
</varlistentry>
<varlistentry>
<term><varname>sitePackages</varname></term>
<listitem><para>
Alias for <literal>lib/${libPrefix}/site-packages</literal>.
</para></listitem>
</varlistentry>
<varlistentry>
<term><varname>executable</varname></term>
<listitem><para>
Name of the interpreter executable, ie <literal>python3.4</literal>.
</para></listitem>
</varlistentry>
</variablelist>
<section xml:id="ssec-build-python-package"><title><varname>buildPythonPackage</varname> function</title>
<para>
The function is implemented in <link xlink:href="https://github.com/NixOS/nixpkgs/blob/master/pkgs/development/python-modules/generic/default.nix">
<filename>pkgs/development/python-modules/generic/default.nix</filename></link>.
Example usage:
<programlisting language="nix">
twisted = buildPythonPackage {
name = "twisted-8.1.0";
src = pkgs.fetchurl {
url = http://tmrc.mit.edu/mirror/twisted/Twisted/8.1/Twisted-8.1.0.tar.bz2;
sha256 = "0q25zbr4xzknaghha72mq57kh53qw1bf8csgp63pm9sfi72qhirl";
};
propagatedBuildInputs = [ self.ZopeInterface ];
meta = {
homepage = http://twistedmatrix.com/;
description = "Twisted, an event-driven networking engine written in Python";
license = stdenv.lib.licenses.mit;
};
};
</programlisting>
Most of Python packages that use <varname>buildPythonPackage</varname> are defined
in <link xlink:href="https://github.com/NixOS/nixpkgs/blob/master/pkgs/top-level/python-packages.nix"><filename>pkgs/top-level/python-packages.nix</filename></link>
and generated for each python interpreter separately into attribute sets <varname>python26Packages</varname>,
<varname>python27Packages</varname>, <varname>python35Packages</varname>, <varname>python33Packages</varname>,
<varname>python34Packages</varname> and <varname>pypyPackages</varname>.
</para>
<para>
<function>buildPythonPackage</function> mainly does four things:
<orderedlist>
<listitem><para>
In the <varname>buildPhase</varname>, it calls
<literal>${python.interpreter} setup.py bdist_wheel</literal> to build a wheel binary zipfile.
</para></listitem>
<listitem><para>
In the <varname>installPhase</varname>, it installs the wheel file using
<literal>pip install *.whl</literal>.
</para></listitem>
<listitem><para>
In the <varname>postFixup</varname> phase, <literal>wrapPythonPrograms</literal>
bash function is called to wrap all programs in <filename>$out/bin/*</filename>
directory to include <literal>$PYTHONPATH</literal> and <literal>$PATH</literal>
environment variables.
</para></listitem>
<listitem><para>
In the <varname>installCheck</varname> phase, <literal>${python.interpreter} setup.py test</literal>
is ran.
</para></listitem>
</orderedlist>
</para>
<para>By default <varname>doCheck = true</varname> is set</para>
<para>
As in Perl, dependencies on other Python packages can be specified in the
<varname>buildInputs</varname> and
<varname>propagatedBuildInputs</varname> attributes. If something is
exclusively a build-time dependency, use
<varname>buildInputs</varname>; if it’s (also) a runtime dependency,
use <varname>propagatedBuildInputs</varname>.
</para>
<para>
By default <varname>meta.platforms</varname> is set to the same value
as the interpreter unless overriden otherwise.
</para>
<variablelist>
<title>
<varname>buildPythonPackage</varname> parameters
(all parameters from <varname>mkDerivation</varname> function are still supported)
</title>
<varlistentry>
<term><varname>namePrefix</varname></term>
<listitem><para>
Prepended text to <varname>${name}</varname> parameter.
Defaults to <literal>"python3.3-"</literal> for Python 3.3, etc. Set it to
<literal>""</literal>
if you're packaging an application or a command line tool.
</para></listitem>
</varlistentry>
<varlistentry>
<term><varname>disabled</varname></term>
<listitem><para>
If <varname>true</varname>, package is not build for
particular python interpreter version. Grep around
<filename>pkgs/top-level/python-packages.nix</filename>
for examples.
</para></listitem>
</varlistentry>
<varlistentry>
<term><varname>setupPyBuildFlags</varname></term>
<listitem><para>
List of flags passed to <command>setup.py build_ext</command> command.
</para></listitem>
</varlistentry>
<varlistentry>
<term><varname>pythonPath</varname></term>
<listitem><para>
List of packages to be added into <literal>$PYTHONPATH</literal>.
Packages in <varname>pythonPath</varname> are not propagated
(contrary to <varname>propagatedBuildInputs</varname>).
</para></listitem>
</varlistentry>
<varlistentry>
<term><varname>preShellHook</varname></term>
<listitem><para>
Hook to execute commands before <varname>shellHook</varname>.
</para></listitem>
</varlistentry>
<varlistentry>
<term><varname>postShellHook</varname></term>
<listitem><para>
Hook to execute commands after <varname>shellHook</varname>.
</para></listitem>
</varlistentry>
<varlistentry>
<term><varname>makeWrapperArgs</varname></term>
<listitem><para>
A list of strings. Arguments to be passed to
<varname>makeWrapper</varname>, which wraps generated binaries. By
default, the arguments to <varname>makeWrapper</varname> set
<varname>PATH</varname> and <varname>PYTHONPATH</varname> environment
variables before calling the binary. Additional arguments here can
allow a developer to set environment variables which will be
available when the binary is run. For example,
<varname>makeWrapperArgs = ["--set FOO BAR" "--set BAZ QUX"]</varname>.
</para></listitem>
</varlistentry>
</variablelist>
</section>
<section xml:id="ssec-python-build-env"><title><function>python.buildEnv</function> function</title>
<para>
Create Python environments using low-level <function>pkgs.buildEnv</function> function. Example <filename>default.nix</filename>:
<programlisting language="nix">
<![CDATA[with import <nixpkgs> {};
python.buildEnv.override {
extraLibs = [ pkgs.pythonPackages.pyramid ];
ignoreCollisions = true;
}]]>
</programlisting>
Running <command>nix-build</command> will create
<filename>/nix/store/cf1xhjwzmdki7fasgr4kz6di72ykicl5-python-2.7.8-env</filename>
with wrapped binaries in <filename>bin/</filename>.
</para>
<para>
You can also use <varname>env</varname> attribute to create local
environments with needed packages installed (somewhat comparable to
<literal>virtualenv</literal>). For example, with the following
<filename>shell.nix</filename>:
<programlisting language="nix">
<![CDATA[with import <nixpkgs> {};
(python3.buildEnv.override {
extraLibs = with python3Packages;
[ numpy
requests
];
}).env]]>
</programlisting>
Running <command>nix-shell</command> will drop you into a shell where
<command>python</command> will have specified packages in its path.
</para>
<variablelist>
<title>
<function>python.buildEnv</function> arguments
</title>
<varlistentry>
<term><varname>extraLibs</varname></term>
<listitem><para>
List of packages installed inside the environment.
</para></listitem>
</varlistentry>
<varlistentry>
<term><varname>postBuild</varname></term>
<listitem><para>
Shell command executed after the build of environment.
</para></listitem>
</varlistentry>
<varlistentry>
<term><varname>ignoreCollisions</varname></term>
<listitem><para>
Ignore file collisions inside the environment (default is <varname>false</varname>).
</para></listitem>
</varlistentry>
</variablelist>
</section>
<section xml:id="ssec-python-tools"><title>Tools</title>
<para>Packages inside nixpkgs are written by hand. However many tools
exist in community to help save time. No tool is preferred at the moment.
</para>
<itemizedlist>
<listitem><para>
<link xlink:href="https://github.com/proger/python2nix">python2nix</link>
by Vladimir Kirillov
</para></listitem>
<listitem><para>
<link xlink:href="https://github.com/garbas/pypi2nix">pypi2nix</link>
by Rok Garbas
</para></listitem>
<listitem><para>
<link xlink:href="https://github.com/offlinehacker/pypi2nix">pypi2nix</link>
by Jaka Hudoklin
</para></listitem>
</itemizedlist>
</section>
<section xml:id="ssec-python-development"><title>Development</title>
<para>
To develop Python packages <function>buildPythonPackage</function> has
additional logic inside <varname>shellPhase</varname> to run
<command>pip install -e . --prefix $TMPDIR/</command> for the package.
</para>
<warning><para><varname>shellPhase</varname> is executed only if <filename>setup.py</filename>
exists.</para></warning>
<para>
Given a <filename>default.nix</filename>:
<programlisting language="nix">
<![CDATA[with import <nixpkgs> {};
buildPythonPackage {
name = "myproject";
buildInputs = with pkgs.pythonPackages; [ pyramid ];
src = ./.;
}]]>
</programlisting>
Running <command>nix-shell</command> with no arguments should give you
the environment in which the package would be build with
<command>nix-build</command>.
</para>
<para>
Shortcut to setup environments with C headers/libraries and python packages:
<programlisting language="bash">$ nix-shell -p pythonPackages.pyramid zlib libjpeg git</programlisting>
</para>
<note><para>
There is a boolean value <varname>lib.inNixShell</varname> set to
<varname>true</varname> if nix-shell is invoked.
</para></note>
</section>
<section xml:id="ssec-python-faq"><title>FAQ</title>
<variablelist>
<varlistentry>
<term>How to solve circular dependencies?</term>
<listitem><para>
If you have packages <varname>A</varname> and <varname>B</varname> that
depend on each other, when packaging <varname>B</varname> override package
<varname>A</varname> not to depend on <varname>B</varname> as input
(and also the other way around).
</para></listitem>
</varlistentry>
<varlistentry>
<term><varname>install_data / data_files</varname> problems resulting into <literal>error: could not create '/nix/store/6l1bvljpy8gazlsw2aw9skwwp4pmvyxw-python-2.7.8/etc': Permission denied</literal></term>
<listitem><para>
<link xlink:href="https://bitbucket.org/pypa/setuptools/issue/130/install_data-doesnt-respect-prefix">
Known bug in setuptools <varname>install_data</varname> does not respect --prefix</link>. Example of
such package using the feature is <filename>pkgs/tools/X11/xpra/default.nix</filename>. As workaround
install it as an extra <varname>preInstall</varname> step:
<programlisting>${python.interpreter} setup.py install_data --install-dir=$out --root=$out
sed -i '/ = data_files/d' setup.py</programlisting>
</para></listitem>
</varlistentry>
<varlistentry>
<term>Rationale of non-existent global site-packages</term>
<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="ssec-python-build-env" /> to create self-contained
interpreter with a set of packages.
</para></listitem>
</varlistentry>
</variablelist>
</section>
<section xml:id="ssec-python-contrib"><title>Contributing guidelines</title>
<para>
Following rules are desired to be respected:
</para>
<itemizedlist>
<listitem><para>
Make sure package builds for all python interpreters. Use <varname>disabled</varname> argument to
<function>buildPythonPackage</function> to set unsupported interpreters.
</para></listitem>
<listitem><para>
If tests need to be disabled for a package, make sure you leave a comment about reasoning.
</para></listitem>
<listitem><para>
Packages in <link xlink:href="https://github.com/NixOS/nixpkgs/blob/master/pkgs/top-level/python-packages.nix"><filename>pkgs/top-level/python-packages.nix</filename></link>
are sorted quasi-alphabetically to avoid merge conflicts.
</para></listitem>
</itemizedlist>
</section>
</section>

1
lib/maintainers.nix
View File

@ -51,6 +51,7 @@
bdimcheff = "Brandon Dimcheff <brandon@dimcheff.com>";
benley = "Benjamin Staffin <benley@gmail.com>";
bennofs = "Benno Fünfstück <benno.fuenfstueck@gmail.com>";
benwbooth = "Ben Booth <benwbooth@gmail.com>";
berdario = "Dario Bertini <berdario@gmail.com>";
bergey = "Daniel Bergey <bergey@teallabs.org>";
bjg = "Brian Gough <bjg@gnu.org>";

82
nixos/doc/manual/release-notes/rl-1603.xml
View File

@ -12,14 +12,44 @@ has the following highlights:</para>
<itemizedlist>
<listitem>
<para>Firefox and similar browsers are now <emphasis>wrapped by default</emphasis>.
The package and attribute names are plain <literal>firefox</literal>
or <literal>midori</literal>, etc. Backward-compatibility attributes were set up,
but note that <command>nix-env -u</command> will <emphasis>not</emphasis> update
your current <literal>firefox-with-plugins</literal>;
you have to uninstall it and install <literal>firefox</literal> instead.
More discussion is <link xlink:href="https://github.com/NixOS/nixpkgs/pull/12299">
on the PR</link>. </para>
<para>Systemd 229, bringing <link
xlink:href="https://github.com/systemd/systemd/blob/v229/NEWS">numerous
improvements</link> over 217.</para>
</listitem>
<listitem>
<para>Linux 4.4 (was 3.18).</para>
</listitem>
<listitem>
<para>GCC 5.3 (was 4.9). Note that GCC 5 <link
xlink:href="https://gcc.gnu.org/onlinedocs/libstdc++/manual/using_dual_abi.html">changes
the C++ ABI in an incompatible way</link>; this may cause problems
if you try to link objects compiled with different versions of
GCC.</para>
</listitem>
<listitem>
<para>Glibc 2.23 (was 2.21).</para>
</listitem>
<listitem>
<para>Improved support for ensuring <link
xlink:href="https://reproducible-builds.org/">bitwise reproducible
builds</link>. For example, <literal>stdenv</literal> now sets the
environment variable <envar
xlink:href="https://reproducible-builds.org/specs/source-date-epoch/">SOURCE_DATE_EPOCH</envar>
to a deterministic value, and Nix has <link
xlink:href="http://nixos.org/nix/manual/#ssec-relnotes-1.11">gained
an option</link> to repeat a build a number of times to test
determinism. An ongoing project, the goal of exact reproducibility
is to allow binaries to be verified independently (e.g., a user
might only trust binaries that appear in three independent binary
caches).</para>
</listitem>
<listitem>
<para>Perl 5.22.</para>
</listitem>
</itemizedlist>
@ -39,6 +69,22 @@ has the following highlights:</para>
following incompatible changes:</para>
<itemizedlist>
<listitem>
<para>We no longer produce graphical ISO images and VirtualBox
images for <literal>i686-linux</literal>. A minimal ISO image is
still provided.</para>
</listitem>
<listitem>
<para>Firefox and similar browsers are now <emphasis>wrapped by default</emphasis>.
The package and attribute names are plain <literal>firefox</literal>
or <literal>midori</literal>, etc. Backward-compatibility attributes were set up,
but note that <command>nix-env -u</command> will <emphasis>not</emphasis> update
your current <literal>firefox-with-plugins</literal>;
you have to uninstall it and install <literal>firefox</literal> instead.</para>
</listitem>
<listitem>
<para><command>wmiiSnap</command> has been replaced with
<command>wmii_hg</command>, but
@ -274,18 +320,36 @@ services.syncthing = {
</para>
</listitem>
<listitem>
<para>
Systems with some broadcom cards used to result into a generated config
that is no longer accepted. If you get errors like
<screen>error: path ‘/nix/store/*-broadcom-sta-*’ does not exist and cannot be created</screen>
you should either re-run <command>nixos-generate-config</command> or manually replace
<literal>"${config.boot.kernelPackages.broadcom_sta}"</literal>
by
<literal>config.boot.kernelPackages.broadcom_sta</literal>
in your <filename>/etc/nixos/hardware-configuration.nix</filename>.
More discussion is on <link xlink:href="https://github.com/NixOS/nixpkgs/pull/12595">
the github issue</link>.
</para>
</listitem>
</itemizedlist>
<para>Other notable improvements:
<itemizedlist>
<!--
<listitem>
<para>The <command>command-not-found</command> hook was extended.
Apart from <literal>$NIX_AUTO_INSTALL</literal> variable,
it newly also checks for <literal>$NIX_AUTO_RUN</literal>
which causes it to directly run the missing commands via
<command>nix-shell</command> (without installing anything). </para>
<command>nix-shell</command> (without installing anything).</para>
</listitem>
-->
<listitem>
<para><literal>ejabberd</literal> module is brought back and now works on

4
nixos/lib/build-vms.nix
View File

@ -1,6 +1,6 @@
{ system, minimal ? false }:
{ system, minimal ? false, config ? {} }:
let pkgs = import ../.. { config = {}; inherit system; }; in
let pkgs = import ../.. { inherit system config; }; in
with pkgs.lib;
with import ../lib/qemu-flags.nix;

6
nixos/lib/make-disk-image.nix
View File

@ -23,6 +23,8 @@
postVM ? ""
, name ? "nixos-disk-image"
, format ? "raw"
}:
with lib;
@ -32,8 +34,8 @@ pkgs.vmTools.runInLinuxVM (
{ preVM =
''
mkdir $out
diskImage=$out/nixos.img
${pkgs.vmTools.qemu}/bin/qemu-img create -f raw $diskImage "${toString diskSize}M"
diskImage=$out/nixos.${if format == "qcow2" then "qcow2" else "img"}
${pkgs.vmTools.qemu}/bin/qemu-img create -f ${format} $diskImage "${toString diskSize}M"
mv closure xchg/
'';
buildInputs = [ pkgs.utillinux pkgs.perl pkgs.e2fsprogs pkgs.parted ];

4
nixos/lib/testing.nix
View File

@ -1,6 +1,6 @@
{ system, minimal ? false }:
{ system, minimal ? false, config ? {} }:
with import ./build-vms.nix { inherit system minimal; };
with import ./build-vms.nix { inherit system minimal config; };
with pkgs;
rec {

4
nixos/maintainers/scripts/ec2/amazon-image.nix
View File

@ -10,9 +10,11 @@ with lib;
];
system.build.amazonImage = import ../../../lib/make-disk-image.nix {
inherit pkgs lib config;
inherit lib config;
pkgs = import ../../../.. { inherit (pkgs) system; }; # ensure we use the regular qemu-kvm package
partitioned = config.ec2.hvm;
diskSize = if config.ec2.hvm then 2048 else 8192;
format = "qcow2";
configFile = pkgs.writeText "configuration.nix"
''
{

4
nixos/modules/installer/tools/nixos-rebuild.sh
View File

@ -257,9 +257,9 @@ fi
prebuiltNix() {
machine="$1"
if [ "$machine" = x86_64 ]; then
return /nix/store/xryr9g56h8yjddp89d6dw12anyb4ch7c-nix-1.10
echo /nix/store/xryr9g56h8yjddp89d6dw12anyb4ch7c-nix-1.10
elif [[ "$machine" =~ i.86 ]]; then
return /nix/store/2w92k5wlpspf0q2k9mnf2z42prx3bwmv-nix-1.10
echo /nix/store/2w92k5wlpspf0q2k9mnf2z42prx3bwmv-nix-1.10
else
echo "$0: unsupported platform"
exit 1

2
nixos/modules/module-list.nix
View File

@ -77,6 +77,7 @@
./programs/shell.nix
./programs/ssh.nix
./programs/ssmtp.nix
./programs/tmux.nix
./programs/venus.nix
./programs/wvdial.nix
./programs/xfs_quota.nix
@ -542,4 +543,5 @@
./virtualisation/virtualbox-host.nix
./virtualisation/vmware-guest.nix
./virtualisation/xen-dom0.nix
./virtualisation/xe-guest-utilities.nix
]

3
nixos/modules/profiles/headless.nix
View File

@ -20,4 +20,7 @@ with lib;
# Don't allow emergency mode, because we don't have a console.
systemd.enableEmergencyMode = false;
# Being headless, we don't need a GRUB splash image.
boot.loader.grub.splashImage = null;
}

35
nixos/modules/programs/tmux.nix Normal file
View File

@ -0,0 +1,35 @@
{ config, pkgs, lib, ... }:
let
inherit (lib) mkOption mkEnableOption mkIf mkMerge types;
cfg = config.programs.tmux;
in
{
###### interface
options = {
programs.tmux = {
enable = mkEnableOption "<command>tmux</command> - a <command>screen</command> replacement.";
tmuxconf = mkOption {
default = "";
description = ''
The contents of /etc/tmux.conf
'';
type = types.lines;
};
};
};
###### implementation
config = mkIf cfg.enable {
environment = {
systemPackages = [ pkgs.tmux ];
etc."tmux.conf".text = cfg.tmuxconf;
};
};
}

4
nixos/modules/programs/virtualbox.nix
View File

@ -1,8 +1,8 @@
let
msg = "Importing <nixpkgs/nixos/modules/programs/virtualbox.nix> is "
+ "deprecated, please use `services.virtualboxHost.enable = true' "
+ "deprecated, please use `virtualisation.virtualbox.host.enable = true' "
+ "instead.";
in {
config.warnings = [ msg ];
config.services.virtualboxHost.enable = true;
config.virtualisation.virtualbox.host.enable = true;
}

2
nixos/modules/services/networking/wpa_supplicant.nix
View File

@ -125,10 +125,12 @@ in {
# FIXME: start a separate wpa_supplicant instance per interface.
systemd.services.wpa_supplicant = let
ifaces = cfg.interfaces;
deviceUnit = interface: [ "sys-subsystem-net-devices-${interface}.device" ];
in {
description = "WPA Supplicant";
after = [ "network-interfaces.target" ];
requires = lib.concatMap deviceUnit ifaces;
wantedBy = [ "network.target" ];
path = [ pkgs.wpa_supplicant ];

6
nixos/modules/services/x11/xserver.nix
View File

@ -13,9 +13,9 @@ let
# Map video driver names to driver packages. FIXME: move into card-specific modules.
knownVideoDrivers = {
virtualbox = { modules = [ kernelPackages.virtualboxGuestAdditions ]; driverName = "vboxvideo"; };
ati = { modules = [ pkgs.xorg.xf86videoati pkgs.xorg.glamoregl ]; };
intel-testing = { modules = with pkgs.xorg; [ xf86videointel-testing glamoregl ]; driverName = "intel"; };
virtualbox = { modules = [ kernelPackages.virtualboxGuestAdditions ]; driverName = "vboxvideo"; };
ati = { modules = with pkgs.xorg; [ xf86videoati glamoregl ]; };
intel = { modules = with pkgs.xorg; [ xf86videointel glamoregl ]; };
};
fontsForXServer =

30
nixos/modules/virtualisation/amazon-grow-partition.nix
View File

@ -4,37 +4,13 @@
{ config, lib, pkgs, ... }:
with lib;
let
growpart = pkgs.stdenv.mkDerivation {
name = "growpart";
src = pkgs.fetchurl {
url = "https://launchpad.net/cloud-utils/trunk/0.27/+download/cloud-utils-0.27.tar.gz";
sha256 = "16shlmg36lidp614km41y6qk3xccil02f5n3r4wf6d1zr5n4v8vd";
};
patches = [ ./growpart-util-linux-2.26.patch ];
buildPhase = ''
cp bin/growpart $out
sed -i 's|awk|gawk|' $out
sed -i 's|sed|gnused|' $out
'';
dontInstall = true;
dontPatchShebangs = true;
};
in
{
config = mkIf config.ec2.hvm {
config = lib.mkIf config.ec2.hvm {
boot.initrd.extraUtilsCommands = ''
copy_bin_and_libs ${pkgs.gawk}/bin/gawk
copy_bin_and_libs ${pkgs.gnused}/bin/sed
copy_bin_and_libs ${pkgs.utillinux}/sbin/sfdisk
cp -v ${growpart} $out/bin/growpart
cp -v ${pkgs.cloud-utils}/bin/growpart $out/bin/growpart
ln -s sed $out/bin/gnused
'';
@ -44,7 +20,5 @@ in
udevadm settle
fi
'';
};
}

3
nixos/modules/virtualisation/amazon-image.nix
View File

@ -65,8 +65,7 @@ let cfg = config.ec2; in
fi
if ! [ -e "$metaDir/user-data" ]; then
wget -q -O "$metaDir/user-data" http://169.254.169.254/1.0/user-data
chmod 600 "$metaDir/user-data"
wget -q -O "$metaDir/user-data" http://169.254.169.254/1.0/user-data && chmod 600 "$metaDir/user-data"
fi
if ! [ -e "$metaDir/hostname" ]; then

92
nixos/modules/virtualisation/ec2-amis.nix Normal file
View File

@ -0,0 +1,92 @@
{
"14.04".ap-northeast-1.hvm-ebs = "ami-71c6f470";
"14.04".ap-northeast-1.pv-ebs = "ami-4dcbf84c";
"14.04".ap-northeast-1.pv-s3 = "ami-8fc4f68e";
"14.04".ap-southeast-1.hvm-ebs = "ami-da280888";
"14.04".ap-southeast-1.pv-ebs = "ami-7a9dbc28";
"14.04".ap-southeast-1.pv-s3 = "ami-c4290996";
"14.04".ap-southeast-2.hvm-ebs = "ami-ab523e91";
"14.04".ap-southeast-2.pv-ebs = "ami-6769055d";
"14.04".ap-southeast-2.pv-s3 = "ami-15533f2f";
"14.04".eu-central-1.hvm-ebs = "ami-ba0234a7";
"14.04".eu-west-1.hvm-ebs = "ami-96cb63e1";
"14.04".eu-west-1.pv-ebs = "ami-b48c25c3";
"14.04".eu-west-1.pv-s3 = "ami-06cd6571";
"14.04".sa-east-1.hvm-ebs = "ami-01b90e1c";
"14.04".sa-east-1.pv-ebs = "ami-69e35474";
"14.04".sa-east-1.pv-s3 = "ami-61b90e7c";
"14.04".us-east-1.hvm-ebs = "ami-58ba3a30";
"14.04".us-east-1.pv-ebs = "ami-9e0583f6";
"14.04".us-east-1.pv-s3 = "ami-9cbe3ef4";
"14.04".us-west-1.hvm-ebs = "ami-0bc3d74e";
"14.04".us-west-1.pv-ebs = "ami-8b1703ce";
"14.04".us-west-1.pv-s3 = "ami-27ccd862";
"14.04".us-west-2.hvm-ebs = "ami-3bf1bf0b";
"14.04".us-west-2.pv-ebs = "ami-259bd515";
"14.04".us-west-2.pv-s3 = "ami-07094037";
"14.12".ap-northeast-1.hvm-ebs = "ami-24435f25";
"14.12".ap-northeast-1.pv-ebs = "ami-b0425eb1";
"14.12".ap-northeast-1.pv-s3 = "ami-fed3c6ff";
"14.12".ap-southeast-1.hvm-ebs = "ami-6c765d3e";
"14.12".ap-southeast-1.pv-ebs = "ami-6a765d38";
"14.12".ap-southeast-1.pv-s3 = "ami-d1bf9183";
"14.12".ap-southeast-2.hvm-ebs = "ami-af86f395";
"14.12".ap-southeast-2.pv-ebs = "ami-b386f389";
"14.12".ap-southeast-2.pv-s3 = "ami-69c5ae53";
"14.12".eu-central-1.hvm-ebs = "ami-4a497a57";
"14.12".eu-central-1.pv-ebs = "ami-4c497a51";
"14.12".eu-central-1.pv-s3 = "ami-60f2c27d";
"14.12".eu-west-1.hvm-ebs = "ami-d126a5a6";
"14.12".eu-west-1.pv-ebs = "ami-0126a576";
"14.12".eu-west-1.pv-s3 = "ami-deda5fa9";
"14.12".sa-east-1.hvm-ebs = "ami-2d239e30";
"14.12".sa-east-1.pv-ebs = "ami-35239e28";
"14.12".sa-east-1.pv-s3 = "ami-81e3519c";
"14.12".us-east-1.hvm-ebs = "ami-0c463a64";
"14.12".us-east-1.pv-ebs = "ami-ac473bc4";
"14.12".us-east-1.pv-s3 = "ami-00e18a68";
"14.12".us-west-1.hvm-ebs = "ami-ca534a8f";
"14.12".us-west-1.pv-ebs = "ami-3e534a7b";
"14.12".us-west-1.pv-s3 = "ami-2905196c";
"14.12".us-west-2.hvm-ebs = "ami-fb9dc3cb";
"14.12".us-west-2.pv-ebs = "ami-899dc3b9";
"14.12".us-west-2.pv-s3 = "ami-cb7f2dfb";
"15.09".ap-northeast-1.hvm-ebs = "ami-58cac236";
"15.09".ap-northeast-1.hvm-s3 = "ami-39c8c057";
"15.09".ap-northeast-1.pv-ebs = "ami-5ac9c134";
"15.09".ap-northeast-1.pv-s3 = "ami-03cec66d";
"15.09".ap-southeast-1.hvm-ebs = "ami-2fc2094c";
"15.09".ap-southeast-1.hvm-s3 = "ami-9ec308fd";
"15.09".ap-southeast-1.pv-ebs = "ami-95c00bf6";
"15.09".ap-southeast-1.pv-s3 = "ami-bfc00bdc";
"15.09".ap-southeast-2.hvm-ebs = "ami-996c4cfa";
"15.09".ap-southeast-2.hvm-s3 = "ami-3f6e4e5c";
"15.09".ap-southeast-2.pv-ebs = "ami-066d4d65";
"15.09".ap-southeast-2.pv-s3 = "ami-cc6e4eaf";
"15.09".eu-central-1.hvm-ebs = "ami-3f8c6b50";
"15.09".eu-central-1.hvm-s3 = "ami-5b836434";
"15.09".eu-central-1.pv-ebs = "ami-118c6b7e";
"15.09".eu-central-1.pv-s3 = "ami-2c977043";
"15.09".eu-west-1.hvm-ebs = "ami-9cf04aef";
"15.09".eu-west-1.hvm-s3 = "ami-2bea5058";
"15.09".eu-west-1.pv-ebs = "ami-c9e852ba";
"15.09".eu-west-1.pv-s3 = "ami-c6f64cb5";
"15.09".sa-east-1.hvm-ebs = "ami-6e52df02";
"15.09".sa-east-1.hvm-s3 = "ami-1852df74";
"15.09".sa-east-1.pv-ebs = "ami-4368e52f";
"15.09".sa-east-1.pv-s3 = "ami-f15ad79d";
"15.09".us-east-1.hvm-ebs = "ami-84a6a0ee";
"15.09".us-east-1.hvm-s3 = "ami-06a7a16c";
"15.09".us-east-1.pv-ebs = "ami-a4a1a7ce";
"15.09".us-east-1.pv-s3 = "ami-5ba8ae31";
"15.09".us-west-1.hvm-ebs = "ami-22c8bb42";
"15.09".us-west-1.hvm-s3 = "ami-a2ccbfc2";
"15.09".us-west-1.pv-ebs = "ami-10cebd70";
"15.09".us-west-1.pv-s3 = "ami-fa30429a";
"15.09".us-west-2.hvm-ebs = "ami-ce57b9ae";
"15.09".us-west-2.hvm-s3 = "ami-2956b849";
"15.09".us-west-2.pv-ebs = "ami-005fb160";
"15.09".us-west-2.pv-s3 = "ami-cd55bbad";
}

52
nixos/modules/virtualisation/xe-guest-utilities.nix Normal file
View File

@ -0,0 +1,52 @@
{ config, lib, pkgs, ... }:
with lib;
let
cfg = config.services.xe-guest-utilities;
in {
options = {
services.xe-guest-utilities = {
enable = mkEnableOption "Whether to enable the Xen guest utilities daemon.";
};
};
config = mkIf cfg.enable {
services.udev.packages = [ pkgs.xe-guest-utilities ];
systemd.tmpfiles.rules = [ "d /run/xenstored 0755 - - -" ];
systemd.services.xe-daemon = {
description = "xen daemon file";
wantedBy = [ "multi-user.target" ];
after = [ "xe-linux-distribution.service" ];
requires = [ "proc-xen.mount" ];
path = [ pkgs.coreutils pkgs.iproute ];
serviceConfig = {
PIDFile = "/run/xe-daemon.pid";
ExecStart = "${pkgs.xe-guest-utilities}/bin/xe-daemon -p /run/xe-daemon.pid";
ExecStop = "${pkgs.procps}/bin/pkill -TERM -F /run/xe-daemon.pid";
};
};
systemd.services.xe-linux-distribution = {
description = "xen linux distribution service";
wantedBy = [ "multi-user.target" ];
before = [ "xend.service" ];
path = [ pkgs.xe-guest-utilities pkgs.coreutils pkgs.gawk pkgs.gnused ];
serviceConfig = {
Type = "simple";
RemainAfterExit = "yes";
ExecStart = "${pkgs.xe-guest-utilities}/bin/xe-linux-distribution /var/cache/xe-linux-distribution";
};
};
systemd.mounts = [
{ description = "Mount /proc/xen files";
what = "xenfs";
where = "/proc/xen";
type = "xenfs";
unitConfig = {
ConditionPathExists = "/proc/xen";
RefuseManualStop = "true";
};
}
];
};
}

1
nixos/release.nix
View File

@ -219,6 +219,7 @@ in rec {
tests.ipv6 = callTest tests/ipv6.nix {};
tests.jenkins = callTest tests/jenkins.nix {};
tests.kde4 = callTest tests/kde4.nix {};
tests.keymap = callSubTests tests/keymap.nix {};
tests.initrdNetwork = callTest tests/initrd-network.nix {};
tests.kubernetes = hydraJob (import tests/kubernetes.nix { system = "x86_64-linux"; });
tests.latestKernel.login = callTest tests/login.nix { latestKernel = true; };

19
nixos/tests/ec2.nix
View File

@ -11,7 +11,6 @@ let
modules = [
../maintainers/scripts/ec2/amazon-image.nix
../modules/testing/test-instrumentation.nix
../modules/profiles/minimal.nix
../modules/profiles/qemu-guest.nix
{ ec2.hvm = true;
@ -21,6 +20,14 @@ let
ln -s vda /dev/xvda
ln -s vda1 /dev/xvda1
'';
# Needed by nixos-rebuild due to the lack of network
# access. Mostly copied from
# modules/profiles/installation-device.nix.
system.extraDependencies =
[ pkgs.stdenv pkgs.busybox pkgs.perlPackages.ArchiveCpio
pkgs.unionfs-fuse pkgs.mkinitcpio-nfs-utils
];
}
];
}).config.system.build.amazonImage;
@ -30,9 +37,8 @@ let
metaData = pkgs.stdenv.mkDerivation {
name = "metadata";
buildCommand = ''
mkdir -p $out/2011-01-01
ln -s ${pkgs.writeText "userData" userData} $out/2011-01-01/user-data
mkdir -p $out/1.0/meta-data
ln -s ${pkgs.writeText "userData" userData} $out/1.0/user-data
echo "${hostname}" > $out/1.0/meta-data/hostname
echo "(unknown)" > $out/1.0/meta-data/ami-manifest-path
'' + optionalString (sshPublicKey != null) ''
@ -48,7 +54,7 @@ let
my $imageDir = ($ENV{'TMPDIR'} // "/tmp") . "/vm-state-machine";
mkdir $imageDir, 0700;
my $diskImage = "$imageDir/machine.qcow2";
system("qemu-img create -f qcow2 -o backing_file=${image}/nixos.img $diskImage") == 0 or die;
system("qemu-img create -f qcow2 -o backing_file=${image}/nixos.qcow2 $diskImage") == 0 or die;
system("qemu-img resize $diskImage 10G") == 0 or die;
# Note: we use net=169.0.0.0/8 rather than
@ -91,7 +97,7 @@ in {
'';
script = ''
$machine->start;
$machine->waitForFile("/root/user-data");
$machine->waitForFile("/etc/ec2-metadata/user-data");
$machine->waitForUnit("sshd.service");
$machine->succeed("grep unknown /etc/ec2-metadata/ami-manifest-path");
@ -121,7 +127,7 @@ in {
# Just to make sure resizing is idempotent.
$machine->shutdown;
$machine->start;
$machine->waitForFile("/root/user-data");
$machine->waitForFile("/etc/ec2-metadata/user-data");
'';
};
@ -135,6 +141,7 @@ in {
imports = [
<nixpkgs/nixos/modules/virtualisation/amazon-image.nix>
<nixpkgs/nixos/modules/testing/test-instrumentation.nix>
<nixpkgs/nixos/modules/profiles/qemu-guest.nix>
];
environment.etc.testFile = {
text = "whoa";

4
nixos/tests/installer.nix
View File

@ -366,8 +366,8 @@ in {
"mkdir /mnt/boot",
"mount LABEL=boot /mnt/boot",
"udevadm settle",
"mdadm -W /dev/md0", # wait for sync to finish; booting off an unsynced device tends to fail
"mdadm -W /dev/md1",
"mdadm --verbose -W /dev/md0", # wait for sync to finish; booting off an unsynced device tends to fail
"mdadm --verbose -W /dev/md1",
);
'';
};

160
nixos/tests/keymap.nix Normal file
View File

@ -0,0 +1,160 @@
{ system ? builtins.currentSystem }:
with import ../lib/testing.nix { inherit system; };
let
testReader = pkgs.writeScript "test-input-reader" ''
#!${pkgs.stdenv.shell}
readInput() {
touch /tmp/reader.ready
echo "Waiting for '$1' to be typed"
read -r -n1 c
if [ "$c" = "$2" ]; then
echo "SUCCESS: Got back '$c' as expected."
echo 0 >&2
else
echo "FAIL: Expected '$2' but got '$c' instead."
echo 1 >&2
fi
}
main() {
error=0
while [ $# -gt 0 ]; do
ret="$((readInput "$2" "$3" | systemd-cat -t "$1") 2>&1)"
if [ $ret -ne 0 ]; then error=1; fi
shift 3
done
return $error
}
main "$@"; echo -n $? > /tmp/reader.exit
'';
mkReaderInput = testname: { qwerty, expect }: with pkgs.lib; let
lq = length qwerty;
le = length expect;
msg = "`qwerty' (${lq}) and `expect' (${le}) lists"
+ " need to be of the same length!";
result = flatten (zipListsWith (a: b: [testname a b]) qwerty expect);
in if lq != le then throw msg else result;
mkKeyboardTest = layout: { extraConfig ? {}, tests }: with pkgs.lib; let
readerInput = flatten (mapAttrsToList mkReaderInput tests);
perlStr = val: "'${escape ["'" "\\"] val}'";
perlReaderInput = concatMapStringsSep ", " perlStr readerInput;
in makeTest {
name = "keymap-${layout}";
machine.i18n.consoleKeyMap = mkOverride 900 layout;
machine.services.xserver.layout = mkOverride 900 layout;
machine.imports = [ ./common/x11.nix extraConfig ];
testScript = ''
sub waitCatAndDelete ($) {
return $machine->succeed(
"for i in \$(seq 600); do if [ -e '$_[0]' ]; then ".
"cat '$_[0]' && rm -f '$_[0]' && exit 0; ".
"fi; sleep 0.1; done; echo timed out after 60 seconds >&2; exit 1"
);
};
sub mkTest ($$) {
my ($desc, $cmd) = @_;
my @testdata = (${perlReaderInput});
my $shellTestdata = join ' ', map { "'".s/'/'\\'''/gr."'" } @testdata;
subtest $desc, sub {
$machine->succeed("$cmd ${testReader} $shellTestdata &");
while (my ($testname, $qwerty, $expect) = splice(@testdata, 0, 3)) {
waitCatAndDelete "/tmp/reader.ready";
$machine->sendKeys($qwerty);
};
my $exitcode = waitCatAndDelete "/tmp/reader.exit";
die "tests for $desc failed" if $exitcode ne 0;
};
}
$machine->waitForX;
mkTest "VT keymap", "openvt -sw --";
mkTest "Xorg keymap", "DISPLAY=:0 xterm -fullscreen -e";
'';
};
in pkgs.lib.mapAttrs mkKeyboardTest {
azerty = {
tests = {
azqw.qwerty = [ "q" "w" ];
azqw.expect = [ "a" "z" ];
altgr.qwerty = [ "alt_r-2" "alt_r-3" "alt_r-4" "alt_r-5" "alt_r-6" ];
altgr.expect = [ "~" "#" "{" "[" "|" ];
};
extraConfig.i18n.consoleKeyMap = "azerty/fr";
extraConfig.services.xserver.layout = "fr";
};
colemak = {
tests = {
homerow.qwerty = [ "a" "s" "d" "f" "j" "k" "l" "semicolon" ];
homerow.expect = [ "a" "r" "s" "t" "n" "e" "i" "o" ];
};
extraConfig.i18n.consoleKeyMap = "en-latin9";
extraConfig.services.xserver.layout = "us";
extraConfig.services.xserver.xkbVariant = "colemak";
};
dvorak = {
tests = {
homerow.qwerty = [ "a" "s" "d" "f" "j" "k" "l" "semicolon" ];
homerow.expect = [ "a" "o" "e" "u" "h" "t" "n" "s" ];
symbols.qwerty = [ "q" "w" "e" "minus" "equal" ];
symbols.expect = [ "'" "," "." "[" "]" ];
};
};
dvp = {
tests = {
homerow.qwerty = [ "a" "s" "d" "f" "j" "k" "l" "semicolon" ];
homerow.expect = [ "a" "o" "e" "u" "h" "t" "n" "s" ];
numbers.qwerty = map (x: "shift-${x}")
[ "1" "2" "3" "4" "5" "6" "7" "8" "9" "0" "minus" ];
numbers.expect = [ "%" "7" "5" "3" "1" "9" "0" "2" "4" "6" "8" ];
symbols.qwerty = [ "1" "2" "3" "4" "5" "6" "7" "8" "9" "0" "minus" ];
symbols.expect = [ "&" "[" "{" "}" "(" "=" "*" ")" "+" "]" "!" ];
};
extraConfig.services.xserver.layout = "us";
extraConfig.services.xserver.xkbVariant = "dvp";
};
neo = {
tests = {
layer1.qwerty = [ "f" "j" ];
layer1.expect = [ "e" "n" ];
layer2.qwerty = [ "shift-f" "shift-j" "shift-6" ];
layer2.expect = [ "E" "N" "$" ];
layer3.qwerty = [ "caps_lock-d" "caps_lock-f" ];
layer3.expect = [ "{" "}" ];
};
extraConfig.services.xserver.layout = "de";
extraConfig.services.xserver.xkbVariant = "neo";
};
qwertz = {
tests = {
zy.qwerty = [ "z" "y" ];
zy.expect = [ "y" "z" ];
altgr.qwerty = map (x: "alt_r-${x}")
[ "q" "less" "7" "8" "9" "0" ];
altgr.expect = [ "@" "|" "{" "[" "]" "}" ];
};
extraConfig.i18n.consoleKeyMap = "de";
extraConfig.services.xserver.layout = "de";
};
}

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

@ -10,7 +10,7 @@ stdenv.mkDerivation rec {
sha256 = "0jb6g3kbfyr5yf8mvblnciva2bmc01ijpr51m21r27rqmgi8gj5k";
};
patches = [ ./buf_rect.patch ];
patches = [ ./buf_rect.patch ./fix_build_with_gcc-5.patch];
buildInputs =
[ pkgconfig SDL SDL_image libjack2

31
pkgs/applications/audio/meterbridge/fix_build_with_gcc-5.patch Normal file
View File

@ -0,0 +1,31 @@
Description: Fix build with gcc-5
Bug-Debian: https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=778003
Author: Jaromír Mikeš <mira.mikes@seznam.cz>
Forwarded: No
Index: meterbridge/src/linedraw.h
===================================================================
--- meterbridge.orig/src/linedraw.h
+++ meterbridge/src/linedraw.h
@@ -1,7 +1,7 @@
#ifndef LINEDRAW_H
#define LINEDRAW_H
-inline void set_rgba(SDL_Surface *surface, Uint32 x, Uint32 y, Uint32 col);
+void set_rgba(SDL_Surface *surface, Uint32 x, Uint32 y, Uint32 col);
void draw_ptr(SDL_Surface *surface, int x1, int y1, int x2, int y2, Uint32 nedle_col, Uint32 aa_col);
Index: meterbridge/src/linedraw.c
===================================================================
--- meterbridge.orig/src/linedraw.c
+++ meterbridge/src/linedraw.c
@@ -4,7 +4,7 @@
/* set a pixel on an SDL_Surface, assumes that the surface is 32bit RGBA,
* ordered ABGR (I think), probably wont work on bigendian systems */
-inline void set_rgba(SDL_Surface *surface, Uint32 x, Uint32 y, Uint32 col)
+void set_rgba(SDL_Surface *surface, Uint32 x, Uint32 y, Uint32 col)
{
Uint32 *bufp = (Uint32 *)surface->pixels + y*surface->pitch/4 + x;
*bufp = col;

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

@ -5,7 +5,7 @@
assert stdenv.system == "x86_64-linux";
let
version = "1.0.25.127.g58007b4c-22";
version = "1.0.26.125.g64dc8bc6-14";
deps = [
alsaLib
@ -50,7 +50,7 @@ stdenv.mkDerivation {
src =
fetchurl {
url = "http://repository-origin.spotify.com/pool/non-free/s/spotify-client/spotify-client_${version}_amd64.deb";
sha256 = "1fxps0ls0g4idw10la3qrpmp2jn85lkm3xj4nam4ycx0jj8g1v2p";
sha256 = "09wanpml2a6k8asfc0pd56n7fia37amgsplsan1qdh6dwdzr3rv5";
};
buildInputs = [ dpkg makeWrapper ];

12
pkgs/applications/editors/idea/default.nix
View File

@ -195,6 +195,18 @@ in
};
};
idea15-ultimate = buildIdea rec {
name = "idea-ultimate-${version}";
version = "15.0.5";
build = "IU-143.2332.3";
description = "Integrated Development Environment (IDE) by Jetbrains, requires paid license";
license = stdenv.lib.licenses.unfree;
src = fetchurl {
url = "https://download.jetbrains.com/idea/ideaIU-${version}.tar.gz";
sha256 = "1hvc5cmbfpp0qad0236ffh3g7zwfk64rh5bkkb750h3387jz7nr2";
};
};
idea-ultimate = buildIdea rec {
name = "idea-ultimate-${version}";
version = "2016.1";

27
pkgs/applications/graphics/giv/build.patch
View File

@ -15,30 +15,3 @@ index 16eccd9..603e931 100644
env['SBOX'] = False
diff --git a/giv/SConstruct b/giv/SConstruct
index 047839a..2c267aa 100644
--- a/giv/SConstruct
+++ b/giv/SConstruct
@@ -3,8 +3,9 @@
import sys
import re
+import os
-env = Environment()
+env = Environment(ENV = os.environ)
src = ["giv.c",
"giv-backstore.c",
diff --git a/src/plugins/dcmtk/SConstruct.standalone b/src/plugins/dcmtk/SConstruct.standalone
index ffce001..74246f8 100644
--- a/src/plugins/dcmtk/SConstruct.standalone
+++ b/src/plugins/dcmtk/SConstruct.standalone
@@ -1,4 +1,6 @@
-env = Environment()
+import os
+
+env = Environment(ENV = os.environ)
variant = "Debug"

12
pkgs/applications/graphics/giv/default.nix
View File

@ -1,12 +1,14 @@
{ stdenv, fetchurl, gdk_pixbuf, scons, pkgconfig, gtk, glib,
{ stdenv, fetchFromGitHub, gdk_pixbuf, scons, pkgconfig, gtk, glib,
pcre, cfitsio, perl, gob2, vala, libtiff, json_glib }:
stdenv.mkDerivation rec {
name = "giv-0.9.22";
name = "giv-20150811-git";
src = fetchurl {
url = "mirror://sourceforge/giv/${name}.tar.gz";
sha256 = "1q0806b66ajppxbv1i71wx5d3ydc1h3hsz23m6g4g80dhiai7dly";
src = fetchFromGitHub {
owner = "dov";
repo = "giv";
rev = "64648bfbbf10ec4a9adfbc939c96c7d1dbdce57a";
sha256 = "1sz2n7jbmg3g97bs613xxjpzqbsl5rvpg6v7g3x3ycyd35r8vsfp";
};
# It built code to be put in a shared object without -fPIC

19
pkgs/applications/graphics/wings/default.nix
View File

@ -1,29 +1,34 @@
{ fetchurl, stdenv, erlang, esdl }:
{ fetchurl, stdenv, erlang, esdl, cl }:
stdenv.mkDerivation rec {
name = "wings-1.4.1";
name = "wings-1.5.4";
src = fetchurl {
url = "mirror://sourceforge/wings/${name}.tar.bz2";
sha256 = "16kqy92rapmbvkc58mc50cidp1pm8nlwlwx69riyadc9w4qs9bji";
sha256 = "0qz6rmmkqgk3p0d3v2ikkf22n511bq0m7xp3kkradwrp28fcl15x";
};
ERL_LIBS = "${esdl}/lib/erlang/addons";
ERL_LIBS = "${esdl}/lib/erlang/lib:${cl}/lib/erlang/lib";
patchPhase = ''
sed -i 's,include("sdl_keyboard.hrl"),include_lib("esdl/include/sdl_keyboard.hrl"),' \
src/wings_body.erl plugins_src/commands/wpc_constraints.erl
# Fix reference
sed -i 's,wings/e3d/,,' plugins_src/import_export/wpc_lwo.erl
'';
buildInputs = [ erlang esdl ];
buildInputs = [ erlang esdl cl ];
# I did not test the *cl* part. I added the -pa just by imitation.
installPhase = ''
mkdir -p $out/bin $out/lib/${name}/ebin
cp ebin/* $out/lib/${name}/ebin
cp -R fonts textures shaders plugins $out/lib/$name
cat << EOF > $out/bin/wings
#!/bin/sh
export ROOTDIR=$out/lib/erlang/addons/${name}
${erlang}/bin/erl -smp disable -pa ${esdl}/lib/erlang/addons/${esdl.name}/ebin \
${erlang}/bin/erl -smp disable \
-pa ${esdl}/lib/erlang/lib/${cl.name}/ebin \
-pa ${esdl}/lib/erlang/lib/${esdl.name}/ebin \
-pa $out/lib/${name}/ebin -run wings_start start_halt "$@"
EOF
chmod +x $out/bin/wings

18
pkgs/applications/misc/cbatticon/default.nix
View File

@ -1,21 +1,25 @@
{ stdenv, fetchzip, gtk, libnotify, unzip, glib, pkgconfig }:
{ stdenv, fetchFromGitHub, pkgconfig, gettext, glib, gtk3, libnotify }:
stdenv.mkDerivation rec {
name = "cbatticon-${version}";
version = "1.4.2";
version = "1.6.4";
src = fetchzip {
url = "https://github.com/valr/cbatticon/archive/${version}.zip";
sha256 = "0ixkxvlrn84b8nh75c9s2gvxnycis89mf047iz8j38814979di5l";
src = fetchFromGitHub {
owner = "valr";
repo = "cbatticon";
rev = version;
sha256 = "0m3bj408mbini97kq0cdf048lnfkdn7bd8ikbfijd7dwfdzv27i5";
};
makeFlags = "PREFIX=$(out)";
buildInputs = [ gtk libnotify unzip glib pkgconfig ];
nativeBuildInputs = [ pkgconfig gettext ];
buildInputs = [ glib gtk3 libnotify ];
meta = with stdenv.lib; {
description = "A lightweight and fast battery icon that sits in your system tray";
description = "Lightweight and fast battery icon that sits in the system tray";
homepage = https://github.com/valr/cbatticon;
license = licenses.gpl2;
maintainers = [ maintainers.iElectric ];

4
pkgs/applications/misc/librecad/default.nix
View File

@ -1,13 +1,13 @@
{ stdenv, fetchurl, qt4, muparser, which, boost, pkgconfig }:
stdenv.mkDerivation rec {
version = "2.0.8";
version = "2.0.9";
name = "librecad-${version}";
src = fetchurl {
url = "https://github.com/LibreCAD/LibreCAD/tarball/${version}";
name = name + ".tar.gz";
sha256 = "110vn1rvzidg8k6ifz1zws2wsn4cd05xl5ha0hbff2ln7izy84zc";
sha256 = "0npr2nxwmx1qil7lqhkh6yvkw7dwym0nfashxjglxspjallqjya7";
};
patchPhase = ''

32
pkgs/applications/misc/opencpn/default.nix Normal file
View File

@ -0,0 +1,32 @@
{ stdenv, fetchFromGitHub, pkgconfig, cmake, gtk2, wxGTK30, libpulseaudio, curl,
gettext, glib, portaudio }:
stdenv.mkDerivation rec {
name = "opencpn-${version}";
version = "4.2.0";
src = fetchFromGitHub {
owner = "OpenCPN";
repo = "OpenCPN";
rev = "v${version}";
sha256 = "1m6fp9lf9ki9444h0dq6bj0vr7d0pcxkbjv3j2v76p0ksk2l8kw3";
};
buildInputs = [ pkgconfig cmake gtk2 wxGTK30 libpulseaudio curl gettext
glib portaudio ];
cmakeFlags = [
"-DGTK2_GDKCONFIG_INCLUDE_DIR=${gtk2}/lib/gtk-2.0/include"
"-DGTK2_GLIBCONFIG_INCLUDE_DIR=${glib}/lib/glib-2.0/include"
];
enableParallelBuilding = true;
meta = {
description = "A concise ChartPlotter/Navigator";
maintainers = [ stdenv.lib.maintainers.kragniz ];
platforms = stdenv.lib.platforms.all;
license = stdenv.lib.licenses.gpl2;
homepage = "http://opencpn.org/";
};
}

4
pkgs/applications/misc/spacefm/default.nix
View File

@ -4,13 +4,13 @@
stdenv.mkDerivation rec {
name = "spacefm-${version}";
version = "1.0.4";
version = "1.0.5";
src = fetchFromGitHub {
owner = "IgnorantGuru";
repo = "spacefm";
rev = "${version}";
sha256 = "1jywsb5yjrq4w9m94m4mbww36npd1jk6s0b59liz6965hv3xp2sy";
sha256 = "06askkrwls09d1x382zjrmnvcm0ghfgz4cms2qbhdkazfyy0ff65";
};
configureFlags = [

23
pkgs/applications/misc/weather/default.nix
View File

@ -1,4 +1,4 @@
{ stdenv, fetchurl, pkgs }:
{ stdenv, fetchurl, pythonPackages }:
stdenv.mkDerivation rec {
version = "2.0";
@ -9,15 +9,26 @@ stdenv.mkDerivation rec {
sha256 = "0yil363y9iyr4mkd7xxq0p2260wh50f9i5p0map83k9i5l0gyyl0";
};
nativeBuildInputs = [ pythonPackages.wrapPython ];
buildInputs = [ pythonPackages.python ];
phases = [ "unpackPhase" "installPhase" ];
installPhase = ''
mkdir $out/{share,man,bin} -p
cp weather{,.py} $out/bin/
cp {airports,overrides.{conf,log},places,slist,stations,weatherrc,zctas,zlist,zones} $out/share/
site_packages=$out/${pythonPackages.python.sitePackages}
mkdir -p $out/{share/{man,weather-util},bin,etc} $site_packages
cp weather $out/bin/
cp weather.py $site_packages/
chmod +x $out/bin/weather
cp ./weather.1 $out/man/
cp ./weatherrc.5 $out/man/
cp airports overrides.{conf,log} places slist stations zctas zlist zones $out/share/weather-util/
cp weatherrc $out/etc
cp weather.1 weatherrc.5 $out/share/man/
sed -i \
-e "s|/etc|$out/etc|g" \
-e "s|else: default_setpath = \".:~/.weather|&:$out/share/weather-util|" \
$site_packages/weather.py
wrapPythonPrograms
'';
meta = {

66
pkgs/applications/misc/yakuake/3.0.nix Normal file
View File

@ -0,0 +1,66 @@
{ stdenv
, lib
, fetchurl
, cmake
, extra-cmake-modules
, karchive
, kcrash
, kdbusaddons
, ki18n
, kiconthemes
, knewstuff
, knotifications
, knotifyconfig
, konsole
, kparts
, kwindowsystem
, makeQtWrapper
}:
let
pname = "yakuake";
version = "3.0.2";
in
stdenv.mkDerivation rec {
name = "${pname}-${version}";
src = fetchurl {
url = "http://download.kde.org/stable/${pname}/${version}/src/${name}.tar.xz";
sha256 = "0vcdji1k8d3pz7k6lkw8ighkj94zff2l2cf9v1avf83f4hjyfhg5";
};
buildInputs = [
cmake
extra-cmake-modules
karchive
kcrash
kdbusaddons
ki18n
kiconthemes
knewstuff
knotifications
knotifyconfig
kparts
kwindowsystem
];
nativeBuildInputs = [
extra-cmake-modules
makeQtWrapper
];
propagatedUserEnvPkgs = [
konsole
];
postInstall = ''
wrapQtProgram "$out/bin/yakuake"
'';
meta = {
homepage = https://yakuake.kde.org;
description = "Quad-style terminal emulator for KDE";
maintainers = with lib.maintainers; [ fridh ];
};
}

24
pkgs/applications/networking/browsers/chromium/common.nix
View File

@ -5,7 +5,7 @@
, libevent, expat, libjpeg, snappy
, libpng, libxml2, libxslt, libcap
, xdg_utils, yasm, minizip, libwebp
, libusb1, libexif, pciutils, nss
, libusb1, pciutils, nss
, python, pythonPackages, perl, pkgconfig
, nspr, udev, kerberos
@ -17,6 +17,7 @@
# optional dependencies
, libgcrypt ? null # gnomeSupport || cupsSupport
, libexif ? null # only needed for Chromium before version 51
# package customization
, enableSELinux ? false, libselinux ? null
@ -55,9 +56,8 @@ let
use_system_flac = true;
use_system_libevent = true;
use_system_libexpat = true;
use_system_libexif = true;
use_system_libjpeg = true;
use_system_libpng = true;
use_system_libpng = versionOlder upstream-info.version "51.0.0.0";
use_system_libwebp = true;
use_system_libxml = true;
use_system_opus = true;
@ -86,7 +86,7 @@ let
libevent expat libjpeg snappy
libpng libxml2 libxslt libcap
xdg_utils yasm minizip libwebp
libusb1 libexif
libusb1
];
# build paths and release info
@ -123,7 +123,8 @@ let
++ optionals gnomeSupport [ gnome.GConf libgcrypt ]
++ optional enableSELinux libselinux
++ optionals cupsSupport [ libgcrypt cups ]
++ optional pulseSupport libpulseaudio;
++ optional pulseSupport libpulseaudio
++ optional (versionOlder version "51.0.0.0") libexif;
patches = [
./patches/build_fixes_46.patch
@ -140,15 +141,20 @@ let
-e "/python_arch/s/: *'[^']*'/: '""'/" \
build/common.gypi chrome/chrome_tests.gypi
sed -i -e '/module_path *=.*libexif.so/ {
s|= [^;]*|= base::FilePath().AppendASCII("${libexif}/lib/libexif.so")|
}' chrome/utility/media_galleries/image_metadata_extractor.cc
${optionalString (versionOlder version "51.0.0.0") ''
sed -i -e '/module_path *=.*libexif.so/ {
s|= [^;]*|= base::FilePath().AppendASCII("${libexif}/lib/libexif.so")|
}' chrome/utility/media_galleries/image_metadata_extractor.cc
''}
sed -i -e '/lib_loader.*Load/s!"\(libudev\.so\)!"${udev}/lib/\1!' \
device/udev_linux/udev?_loader.cc
sed -i -e '/libpci_loader.*Load/s!"\(libpci\.so\)!"${pciutils}/lib/\1!' \
gpu/config/gpu_info_collector_linux.cc
'' + optionalString (!versionOlder version "51.0.0.0") ''
sed -i -re 's/([^:])\<(isnan *\()/\1std::\2/g' \
chrome/browser/ui/webui/engagement/site_engagement_ui.cc
'';
gypFlags = mkGypFlags (gypFlagsUseSystemLibs // {
@ -180,6 +186,8 @@ let
google_default_client_id = "404761575300.apps.googleusercontent.com";
google_default_client_secret = "9rIFQjfnkykEmqb6FfjJQD1D";
} // optionalAttrs (versionOlder version "51.0.0.0") {
use_system_libexif = true;
} // optionalAttrs proprietaryCodecs {
# enable support for the H.264 codec
proprietary_codecs = true;

18
pkgs/applications/networking/browsers/chromium/upstream-info.nix
View File

@ -1,18 +1,18 @@
# This file is autogenerated from update.sh in the same directory.
{
beta = {
sha256 = "1lgpjnjhy3idha5b6wp31kdk6knic96dmajyrgn1701q3mq81g1i";
sha256bin64 = "1yb3rk38zfgjzka0aim1xc4r0qaz2qkwaq06mjifpkszmfffhyd0";
version = "50.0.2661.26";
sha256 = "1jwk0x5hjpah0bl4dpirxwyfxv0d0wnkvfgyja91kkbh8471gzmk";
sha256bin64 = "10sl3ddd77i1gl3l4yvhkpavfq2bygv7gwql0jnhchmrvyax1cjh";
version = "50.0.2661.49";
};
dev = {
sha256 = "0z9m1mv6pv43y3ccd0nzqg5f9q8qxc8mlmy9y3dc9kqpvmqggnvp";
sha256bin64 = "0khsxci970vclfg24b7m8w1jqfkv5rzswgwa62b4r7jzrglx1azj";
version = "50.0.2661.18";
sha256 = "042h6klyijnhkb4m9lsnfi3qss6pbs4p4981rm4cbc86rsyppkhl";
sha256bin64 = "1p6lhd3n9q93fkydxksgfv68vz26yj8i2zx1kqby2z9yc0pdcniq";
version = "51.0.2693.2";
};
stable = {
sha256 = "0kbph3l964bh7cb9yf8nydjaxa20yf8ls5a2vzsj8phz7n20z3f9";
sha256bin64 = "1k6nhccdqzzzicwi07nldqfsdlic65i2xfyb7dbasbbg9zl3s9yw";
version = "49.0.2623.87";
sha256 = "1lmv6nmbqhxmr4340s5i4ypgz2b7vkh0wy5x9v75b5bnscjhk121";
sha256bin64 = "1djd2i9phym1d8afv4vfajb7l1bz0ny2wmihwi6jaz712vil4a13";
version = "49.0.2623.110";
};
}

12
pkgs/applications/networking/google-drive-ocamlfuse/default.nix
View File

@ -1,14 +1,12 @@
{ stdenv, fetchFromGitHub, ocamlPackages, zlib }:
{ stdenv, fetchurl, ocamlPackages, zlib }:
stdenv.mkDerivation rec {
name = "google-drive-ocamlfuse-${version}";
version = "0.5.18";
version = "0.5.22";
src = fetchFromGitHub {
owner = "astrada";
repo = "google-drive-ocamlfuse";
rev = "v${version}";
sha256 = "0a545zalsqw3jndrvkc0bsn4aab74cf8lwnsw09b5gjm8pm79b9r";
src = fetchurl {
url = "https://forge.ocamlcore.org/frs/download.php/1587/${name}.tar.gz";
sha256 = "1hjm6hyva9sl6lddb0372wsy7f76105iaxh976yyzfn3b4ran6ab";
};
buildInputs = [ zlib ] ++ (with ocamlPackages; [ocaml ocamlfuse findlib gapi_ocaml ocaml_sqlite3 camlidl]);

9
pkgs/applications/networking/instant-messengers/bitlbee/default.nix
View File

@ -2,21 +2,16 @@
with stdenv.lib;
stdenv.mkDerivation rec {
name = "bitlbee-3.4.1";
name = "bitlbee-3.4.2";
src = fetchurl {
url = "mirror://bitlbee/src/${name}.tar.gz";
sha256 = "1qf0ypa9ba5jvsnpg9slmaran16hcc5fnfzbb1sdch1hjhchn2jh";
sha256 = "0mza8lnfwibmklz8hdzg4f7p83hblf4h6fbf7d732kzpvra5bj39";
};
buildInputs = [ gnutls glib pkgconfig libotr python ]
++ optional doCheck check;
patches = [(fetchpatch {
url = "https://github.com/bitlbee/bitlbee/commit/34d16d5b4b5265990125894572a90493284358cd.patch";
sha256 = "05in9kxabb6s2c1l4b9ry58ppfciwmwzrkaq33df2zv0pr3z7w33";
})];
configureFlags = [
"--gcov=1"
"--otr=1"

24
pkgs/applications/networking/instant-messengers/blink/default.nix
View File

@ -1,13 +1,13 @@
{ stdenv, fetchurl, pythonPackages, pyqt4, cython, libvncserver, zlib, twisted
, gnutls, libvpx }:
, gnutls, libvpx, makeDesktopItem }:
pythonPackages.buildPythonApplication rec {
name = "blink-${version}";
version = "1.4.2";
version = "2.0.0";
src = fetchurl {
url = "http://download.ag-projects.com/BlinkQt/${name}.tar.gz";
sha256 = "0ia5hgwyg6cm393ik4ggzhcmc957ncswycs07ilwj6vrrzraxfk7";
sha256 = "07hvy45pavgkvdlh4wbz3shsxh4fapg96qlqmfymdi1nfhwghb05";
};
patches = [ ./pythonpath.patch ];
@ -20,16 +20,30 @@ pythonPackages.buildPythonApplication rec {
buildInputs = [ cython zlib libvncserver libvpx ];
desktopItem = makeDesktopItem {
name = "Blink";
exec = "blink";
comment = meta.description;
desktopName = "Blink";
icon = "blink";
genericName = "Instant Messaging";
categories = "Application;Internet;";
};
postInstall = ''
wrapProgram $out/bin/blink \
--prefix LD_LIBRARY_PATH ":" ${gnutls}/lib
mkdir -p "$out/share/applications"
mkdir -p "$out/share/pixmaps"
cp "$desktopItem"/share/applications/* "$out/share/applications"
cp "$out"/share/blink/icons/blink.* "$out/share/pixmaps"
'';
meta = with stdenv.lib; {
homepage = http://icanblink.com/;
description = "A state of the art, easy to use SIP client";
description = "A state of the art, easy to use SIP client for Voice, Video and IM";
platforms = platforms.linux;
license = licenses.mit;
license = licenses.gpl3;
maintainers = with maintainers; [ pSub ];
};
}

45
pkgs/applications/networking/instant-messengers/blink/pythonpath.patch
View File

@ -1,14 +1,44 @@
diff -rupN a/blink/resources.py b/blink/resources.py
--- a/blink/resources.py 2015-03-17 03:24:06.000000000 -0600
+++ b/blink/resources.py 2015-04-07 22:52:06.101096413 -0600
@@ -60,14 +60,7 @@ class Resources(object):
--- blink-2.0.0/blink/resources.py 2016-03-09 14:39:07.000000000 +0100
+++ blink-2.0.0/blink/resources-patched.py 2016-03-12 21:34:14.965476623 +0100
@@ -1,7 +1,10 @@
+# Copyright (C) 2010-2013 AG Projects. See LICENSE for details.
+#
"""Provide access to Blink's resources"""
-import __main__
+__all__ = ['ApplicationData', 'Resources', 'IconManager']
+
import imghdr
import os
import platform
@@ -19,14 +22,10 @@
from blink.util import run_in_gui_thread
-__all__ = ['ApplicationData', 'Resources', 'IconManager']
-
-
class DirectoryContextManager(unicode):
def __enter__(self):
self.directory = os.getcwdu()
os.chdir(self)
-
def __exit__(self, type, value, traceback):
os.chdir(self.directory)
@@ -61,18 +60,7 @@
@classproperty
def directory(cls):
if cls._cached_directory is None:
- if sys.path[0] == '':
- application_directory = os.path.realpath('') # executed in interactive interpreter
- try:
- binary_directory = os.path.dirname(os.path.realpath(__main__.__file__))
- except AttributeError:
- if hasattr(sys, 'frozen'):
- application_directory = os.path.dirname(os.path.realpath(sys.executable))
- else:
- application_directory = os.path.realpath('') # executed in interactive interpreter
- else:
- binary_directory = os.path.dirname(os.path.realpath(sys.argv[0]))
- if os.path.basename(binary_directory) == 'bin':
- application_directory = os.path.dirname(binary_directory)
- else:
@ -17,4 +47,3 @@ diff -rupN a/blink/resources.py b/blink/resources.py
if os.path.exists(os.path.join(application_directory, 'resources', 'blink.ui')):
cls._cached_directory = os.path.join(application_directory, 'resources').decode(sys.getfilesystemencoding())
else:
Binary files a/blink/.resources.py.swp and b/blink/.resources.py.swp differ

164
pkgs/applications/networking/instant-messengers/telegram/tdesktop/default.nix Normal file
View File

@ -0,0 +1,164 @@
{ stdenv, lib, fetchFromGitHub, fetchgit, qtbase, qtimageformats
, breakpad, ffmpeg, openalSoft, openssl, zlib, libexif, lzma, libopus
, gtk2, glib, cairo, pango, gdk_pixbuf, atk, libappindicator-gtk2
, libunity, dee, libdbusmenu-glib, libva
, pkgconfig, libxcb, xcbutilwm, xcbutilimage, xcbutilkeysyms
, libxkbcommon, libpng, libjpeg, freetype, harfbuzz, pcre16
, xproto, libX11, inputproto, sqlite, dbus
}:
let
system-x86_64 = lib.elem stdenv.system lib.platforms.x86_64;
in stdenv.mkDerivation rec {
name = "telegram-desktop-${version}";
version = "0.9.33";
qtVersion = lib.replaceStrings ["."] ["_"] qtbase.version;
src = fetchFromGitHub {
owner = "telegramdesktop";
repo = "tdesktop";
rev = "v${version}";
sha256 = "020vwm7h22951v9zh457d82qy5ifp746vwishkvb16h1vwr1qx4s";
};
tgaur = fetchgit {
url = "https://aur.archlinux.org/telegram-desktop.git";
rev = "df47a864282959b103a08b65844e9088e012fdb3";
sha256 = "1v1dbi8yiaf2hgghniykm5qbnda456xj3zfjnbqysn41f5cn40h4";
};
buildInputs = [
breakpad ffmpeg openalSoft openssl zlib libexif lzma libopus
gtk2 glib libappindicator-gtk2 libunity cairo pango gdk_pixbuf atk
dee libdbusmenu-glib libva
# Qt dependencies
libxcb xcbutilwm xcbutilimage xcbutilkeysyms libxkbcommon
libpng libjpeg freetype harfbuzz pcre16 xproto libX11
inputproto sqlite dbus
];
nativeBuildInputs = [ pkgconfig ];
enableParallelBuilding = true;
qmakeFlags = [
"CONFIG+=release"
"DEFINES+=TDESKTOP_DISABLE_AUTOUPDATE"
"DEFINES+=TDESKTOP_DISABLE_REGISTER_CUSTOM_SCHEME"
"INCLUDEPATH+=${gtk2}/include/gtk-2.0"
"INCLUDEPATH+=${glib}/include/glib-2.0"
"INCLUDEPATH+=${glib}/lib/glib-2.0/include"
"INCLUDEPATH+=${cairo}/include/cairo"
"INCLUDEPATH+=${pango}/include/pango-1.0"
"INCLUDEPATH+=${gtk2}/lib/gtk-2.0/include"
"INCLUDEPATH+=${gdk_pixbuf}/include/gdk-pixbuf-2.0"
"INCLUDEPATH+=${atk}/include/atk-1.0"
"INCLUDEPATH+=${libappindicator-gtk2}/include/libappindicator-0.1"
"INCLUDEPATH+=${libunity}/include/unity"
"INCLUDEPATH+=${dee}/include/dee-1.0"
"INCLUDEPATH+=${libdbusmenu-glib}/include/libdbusmenu-glib-0.4"
"INCLUDEPATH+=${breakpad}/include/breakpad"
"LIBS+=-lcrypto"
"LIBS+=-lssl"
"LIBS+=-lz"
"LIBS+=-lgobject-2.0"
"LIBS+=-lxkbcommon"
"LIBS+=-lX11"
"LIBS+=${breakpad}/lib/libbreakpad_client.a"
"LIBS+=./../../../Libraries/QtStatic/qtbase/plugins/platforms/libqxcb.a"
"LIBS+=./../../../Libraries/QtStatic/qtimageformats/plugins/imageformats/libqwebp.a"
];
qtSrcs = qtbase.srcs ++ [ qtimageformats.src ];
qtPatches = qtbase.patches;
buildCommand = ''
# We don't use nativeBuildInputs to avoid adding system Qt 5 libraries to various paths.
export PATH="${qtbase}/bin:$PATH"
unpackPhase
cd "$sourceRoot"
patchPhase
sed -i 'Telegram/Telegram.pro' \
-e 's/CUSTOM_API_ID//g' \
-e 's,/usr,/does-not-exist,g' \
-e '/LIBS += .*libxkbcommon.a/d' \
-e '/LIBS += .*libz.a/d' \
-e '/LIBS += .*libbreakpad_client.a/d' \
-e 's,-flto ,,g'
echo "Q_IMPORT_PLUGIN(QXcbIntegrationPlugin)" >> Telegram/SourceFiles/stdafx.cpp
( mkdir -p ../Libraries
cd ../Libraries
for i in $qtSrcs; do
tar -xaf $i
done
mv qt-everywhere-opensource-src-* QtStatic
mv qtbase-opensource-src-* ./QtStatic/qtbase
mv qtimageformats-opensource-src-* ./QtStatic/qtimageformats
cd QtStatic/qtbase
patch -p1 < ../../../$sourceRoot/Telegram/_qtbase_${qtVersion}_patch.diff
cd ..
for i in $qtPatches; do
patch -p1 < $i
done
${qtbase.postPatch}
export configureFlags="-prefix "../../qt" -release -opensource -confirm-license -system-zlib \
-system-libpng -system-libjpeg -system-freetype -system-harfbuzz -system-pcre -system-xcb \
-system-xkbcommon-x11 -no-opengl -static -nomake examples -nomake tests \
-openssl-linked -dbus-linked -system-sqlite -verbose \
${lib.optionalString (!system-x86_64) "-no-sse2"} -no-sse3 -no-ssse3 \
-no-sse4.1 -no-sse4.2 -no-avx -no-avx2 -no-mips_dsp -no-mips_dspr2"
export dontAddPrefix=1
export buildFlags="module-qtbase module-qtimageformats"
export installFlags="module-qtbase-install_subtargets module-qtimageformats-install_subtargets"
( export MAKEFLAGS=-j$NIX_BUILD_CORES
configurePhase
)
buildPhase
installPhase
)
( mkdir -p Linux/DebugIntermediateStyle
cd Linux/DebugIntermediateStyle
qmake CONFIG+=debug ../../Telegram/MetaStyle.pro
buildPhase
)
( mkdir -p Linux/DebugIntermediateLang
cd Linux/DebugIntermediateLang
qmake CONFIG+=debug ../../Telegram/MetaLang.pro
buildPhase
)
( mkdir -p Linux/ReleaseIntermediate
cd Linux/ReleaseIntermediate
qmake $qmakeFlags ../../Telegram/Telegram.pro
pattern="^PRE_TARGETDEPS +="
grep "$pattern" "../../Telegram/Telegram.pro" | sed "s/$pattern//g" | xargs make
qmake $qmakeFlags ../../Telegram/Telegram.pro
buildPhase
)
install -Dm755 Linux/Release/Telegram $out/bin/telegram-desktop
mkdir -p $out/share/applications $out/share/kde4/services
sed "s,/usr/bin,$out/bin,g" $tgaur/telegramdesktop.desktop > $out/share/applications/telegramdesktop.desktop
sed "s,/usr/bin,$out/bin,g" $tgaur/tg.protocol > $out/share/kde4/services/tg.protocol
for icon_size in 16 32 48 64 128 256 512; do
install -Dm644 "Telegram/SourceFiles/art/icon''${icon_size}.png" "$out/share/icons/hicolor/''${icon_size}x''${icon_size}/apps/telegram-desktop.png"
done
fixupPhase
'';
meta = with stdenv.lib; {
description = "Telegram Desktop messaging app";
license = licenses.gpl3;
platforms = platforms.linux;
homepage = "https://desktop.telegram.org/";
maintainers = with maintainers; [ abbradar ];
};
}

234
pkgs/applications/networking/mailreaders/thunderbird-bin/sources.nix
View File

@ -4,123 +4,123 @@
# ruby generate_sources.rb > sources.nix
{
version = "38.6.0";
version = "38.7.1";
sources = [
{ locale = "ar"; arch = "linux-i686"; sha256 = "141b3e5a5a51b0ed8f11bc9233d19bccc3116e55d568eb4995bcd48c91ba3390"; }
{ locale = "ar"; arch = "linux-x86_64"; sha256 = "f2841d9da85e788d868eb56a43baa8e7d72d40c9c82ca60f4f958b9285be5bc3"; }
{ locale = "ast"; arch = "linux-i686"; sha256 = "aa52c0672bf8c2b28ae5efb26aa552592aad6c637b660f9cb4533cad72b9a4fc"; }
{ locale = "ast"; arch = "linux-x86_64"; sha256 = "1a083214fc2f31e52b0d03bffbef64e364b77457e447ddc134dc363004768b03"; }
{ locale = "be"; arch = "linux-i686"; sha256 = "f3e7653a7f9957e9722cf29a7a97b751ffc2b19bd4982ff603f6460afb07445d"; }
{ locale = "be"; arch = "linux-x86_64"; sha256 = "55d7082b20da1bbe23b8d1a2e1e07f6a02f9dd96b065cab1a8a2acd086790d21"; }
{ locale = "bg"; arch = "linux-i686"; sha256 = "132fb89107e653cb30e9f6fffbca6ced0451811080b89058a652dcb5187601f3"; }
{ locale = "bg"; arch = "linux-x86_64"; sha256 = "03868dab14f8bd671eed93a05c50c3836bb047e4195a2b8e92d04d3cf3244c67"; }
{ locale = "bn-BD"; arch = "linux-i686"; sha256 = "ffa2c116e814da8f0a5995f382de0b4d614e72b55ecc905185c014abea763851"; }
{ locale = "bn-BD"; arch = "linux-x86_64"; sha256 = "74631bb2d75687aefc6e8dfa9414176a92de7a22890704f6f84603703a3dd880"; }
{ locale = "br"; arch = "linux-i686"; sha256 = "3942e35a9ea655ac365a4b00f70d8b97e7833e50d00d7d07e5ce851956f55f00"; }
{ locale = "br"; arch = "linux-x86_64"; sha256 = "33dba57581571faac7cc11aeafda68fce323c9fc322a3c8e43cbce794489ab39"; }
{ locale = "ca"; arch = "linux-i686"; sha256 = "5001132684f89e6e4c4ab8d22f37739da4465577e850bed4748ad3079a0b592e"; }
{ locale = "ca"; arch = "linux-x86_64"; sha256 = "3cfad5f05320d179b575bc263ceecef0c9bfec08e7a3471dd779be8798f8f8e8"; }
{ locale = "cs"; arch = "linux-i686"; sha256 = "14879dadca5936473b42ccefc2485707330aa7062bd1c2094adafee0dde83a50"; }
{ locale = "cs"; arch = "linux-x86_64"; sha256 = "92f39de732f2264c5658e3282d0a4259b437f81277c926b3fe0a1c51bb18a27b"; }
{ locale = "cy"; arch = "linux-i686"; sha256 = "e38d9c45558bbf1414efff8568b79ed58c0383329923944aca72bcd075c71967"; }
{ locale = "cy"; arch = "linux-x86_64"; sha256 = "43f11c8ea150c1b58031fd765fc5d789e56df68ef36dd989a8a67135d9a1e501"; }
{ locale = "da"; arch = "linux-i686"; sha256 = "9815c3fb3c95d4fb73faeb9db10591a39131edcb846fb72b6c2b01ac132602f5"; }
{ locale = "da"; arch = "linux-x86_64"; sha256 = "6435f69ebb748f2f81dfcd1da4d66030792e73735d11c788c4478cdb750de89d"; }
{ locale = "de"; arch = "linux-i686"; sha256 = "d8601890fe1021c61b48cb755a98358fffb0e5c3de106d0408baa748c6e4ff21"; }
{ locale = "de"; arch = "linux-x86_64"; sha256 = "96626e10573940ce9a77277f8776066e1f33d852ff1a9be25c613ea54b2ad3d0"; }
{ locale = "dsb"; arch = "linux-i686"; sha256 = "c0cf3e5db343c031171cca6507839e18bb4232a498eb0ff87864c0d3f54c31d3"; }
{ locale = "dsb"; arch = "linux-x86_64"; sha256 = "5c94f8200bf7e5bccdb4f454232707c1354d4cb87713648847d742d1d127b5bc"; }
{ locale = "el"; arch = "linux-i686"; sha256 = "43b61ae50412d5df24f903bd1890be52164689b53ec9bbfe134b7bbb36952377"; }
{ locale = "el"; arch = "linux-x86_64"; sha256 = "163e041e125f84db5f9d55f6e8a2e8d15b7ac6335187a55f00f7019b3038249c"; }
{ locale = "en-GB"; arch = "linux-i686"; sha256 = "b34105daffdf9088fecd199e1525ebbc332ff6536487caa058d19daa4c7306c4"; }
{ locale = "en-GB"; arch = "linux-x86_64"; sha256 = "ac54bf8c804d17ecebab6a865471ce5adf712466612eb435e5871a4ffcc7238a"; }
{ locale = "en-US"; arch = "linux-i686"; sha256 = "2e60a2a5764cdee16659b125f7ad2dde7ff6e993c69a738d86fb39530e469328"; }
{ locale = "en-US"; arch = "linux-x86_64"; sha256 = "f0b4b0d5a7f4b21845e76411cd75d59b0e34a341747cafcb3e871a00b1b2535e"; }
{ locale = "es-AR"; arch = "linux-i686"; sha256 = "fa9de1698297336d3db8d7cc6c59ea1cad595c2d5caf8081f85fc217535d630d"; }
{ locale = "es-AR"; arch = "linux-x86_64"; sha256 = "62bf96299b20de2b6ea17db2113fd8220c60507314d9c3dfbd2ef06557746298"; }
{ locale = "es-ES"; arch = "linux-i686"; sha256 = "1e79df1375e29c6aaf2839584ee51e23a326587e02440c07f10969f82e29daa3"; }
{ locale = "es-ES"; arch = "linux-x86_64"; sha256 = "e5ef4e579c83b1f982b5d071966b3c1be39b94aa128e0ef14f4244e51b19c6c9"; }
{ locale = "et"; arch = "linux-i686"; sha256 = "110dc75c81abcca2199c2f6bee542fe0909bfbe678e91376a1413a81bac88edf"; }
{ locale = "et"; arch = "linux-x86_64"; sha256 = "71f7f7d5d9025423438138a62728d3494f2227c3b1daf8945cbd20d65e7629b3"; }
{ locale = "eu"; arch = "linux-i686"; sha256 = "ad2e6071fafe18f3db5d4af4d938450ec1a8f538e2a5efc7f8ce1d28f1f3dd66"; }
{ locale = "eu"; arch = "linux-x86_64"; sha256 = "32c8b0e825912b97a36cedf19ead4eba8427e08ac059b4bb9fda15c568ce6cff"; }
{ locale = "fi"; arch = "linux-i686"; sha256 = "203006ba5572a315f851e69e74779f92123df25d6a1964283bbf546c43ca0ecb"; }
{ locale = "fi"; arch = "linux-x86_64"; sha256 = "f87904779b68a60aef440a7eb5cf490fe224bc25517d9fa463575fd35c4fc895"; }
{ locale = "fr"; arch = "linux-i686"; sha256 = "4d92b6273006f6a20c6b405cfdd017930e7341230f0deefdbe8961a3ab2099d7"; }
{ locale = "fr"; arch = "linux-x86_64"; sha256 = "a7858e1fca3007710053cd6ffcd8d17fe111ec3727e98cfc410f426fb4dd04a1"; }
{ locale = "fy-NL"; arch = "linux-i686"; sha256 = "d222ea0506db332ab7590fc85dce4102613489506d7680bac31c82b855ae238e"; }
{ locale = "fy-NL"; arch = "linux-x86_64"; sha256 = "b466075727c3d3f709b9ddb1987f9fe69deb1efa34fecbd73aa1c5231ef844d8"; }
{ locale = "ga-IE"; arch = "linux-i686"; sha256 = "d786389a7866d2be769c079ec65396fe3888968f80f3fbd8d54e355ac3098f91"; }
{ locale = "ga-IE"; arch = "linux-x86_64"; sha256 = "8134a011c31cf63a5538fea89ef332a28ab510fb08e1251a9d460ba83946f656"; }
{ locale = "gd"; arch = "linux-i686"; sha256 = "a5b5cb6e9a2daf1587af84083cd680b14f49a0f998d4e6e80f09c37aebac0b0f"; }
{ locale = "gd"; arch = "linux-x86_64"; sha256 = "7b15ab841f95eda59256c7cb4c9c876b0bea34df9f0e1d3af3bd144230d7254a"; }
{ locale = "gl"; arch = "linux-i686"; sha256 = "7bee6ae14c9f43689ab2c7b9a7de60af9fe4d9d567efb94b26e3109af04d6c43"; }
{ locale = "gl"; arch = "linux-x86_64"; sha256 = "b9a6e5bd2c62745a82fd3685a694a6f34d3327b60a62af6e283caf3a67d77f22"; }
{ locale = "he"; arch = "linux-i686"; sha256 = "17a322f92322de536ead76e292d877ab8e9deff9855b1c12fc20855d3935a548"; }
{ locale = "he"; arch = "linux-x86_64"; sha256 = "e542cfdfd29f7d54520dc86c9b73252e57fd3346874f9d629fd31b25be463471"; }
{ locale = "hr"; arch = "linux-i686"; sha256 = "fe1fc94042eaeeedc1e7592cbedc5e4c922c5e05cd212feff8a654898d2c2a9e"; }
{ locale = "hr"; arch = "linux-x86_64"; sha256 = "de191f3cc421ed5b06ce981c0431decb933799252107b27103bc3c45ac6995be"; }
{ locale = "hsb"; arch = "linux-i686"; sha256 = "f55ad886854541ea1d684d168f8fb3c858fc8a11324dc14fb64340cb47f6d7fe"; }
{ locale = "hsb"; arch = "linux-x86_64"; sha256 = "ee03f60c834c141d3340dca9ecfce8f427ee50a3b6b963f4a565a843e895f614"; }
{ locale = "hu"; arch = "linux-i686"; sha256 = "8462e0a665d04b9273dbfc1095ef57831165438c21c34b5d04d22b51276fc047"; }
{ locale = "hu"; arch = "linux-x86_64"; sha256 = "6cc42919c6417860e19fcc851b8210b9d6e405c4b2ff0bf51cffb18af733b488"; }
{ locale = "hy-AM"; arch = "linux-i686"; sha256 = "2c3f4f4358387dad669254da46e21b4da1f54cedbc7be62c38448862a88edf37"; }
{ locale = "hy-AM"; arch = "linux-x86_64"; sha256 = "0556cb57c012554449d7044efaa5e8b4b938b15d55a19f91cb31ea5187b7ef76"; }
{ locale = "id"; arch = "linux-i686"; sha256 = "26d31f04b836d3e5e3874c4e37d258effc8bd228223f6b963df3434d2276529c"; }
{ locale = "id"; arch = "linux-x86_64"; sha256 = "55b2be7503278c0a41785796425fe35f5635e0c635d79a4246f7830a7cf6f075"; }
{ locale = "is"; arch = "linux-i686"; sha256 = "29ce03e041c320aaa61c8ecefbe1a6cd2e9b96e916f3605f09a59cd271cfb741"; }
{ locale = "is"; arch = "linux-x86_64"; sha256 = "44d7856e1779e86d715026a26fdc0db8beb8fac1bcba5c27ed652779f858c12e"; }
{ locale = "it"; arch = "linux-i686"; sha256 = "47dd016eda154be31646105061570653ab61ab99d8bf873cf9e8e4b727847fc6"; }
{ locale = "it"; arch = "linux-x86_64"; sha256 = "299941c56912734dd06c2f1dd89838d3a746dfde10df39f6caf198cf4fc6a332"; }
{ locale = "ja"; arch = "linux-i686"; sha256 = "ff809f8f752612d242d5787f511b4821294855dd42027d7493f789200747575a"; }
{ locale = "ja"; arch = "linux-x86_64"; sha256 = "babda834d5e6fa669691b974c4c4ea4b9207c3926796d0c1d76784b733d738a3"; }
{ locale = "ko"; arch = "linux-i686"; sha256 = "a04ca9cd1cd435d4ab5d832efaeb1a6fee5e9e6c933c5a3a9b0e21bbc5141f24"; }
{ locale = "ko"; arch = "linux-x86_64"; sha256 = "0390d47ca644679631b8bbb83cb45e404b4b7f1e4ad237d439318fd6464aeeb4"; }
{ locale = "lt"; arch = "linux-i686"; sha256 = "9e9d3ed60a3ba5ef761937e5b2b06a4eaac1c6f6c1d72a9b3fe0ab7818e3d18f"; }
{ locale = "lt"; arch = "linux-x86_64"; sha256 = "8d7cf2a173df6b7930a37244829934b2729341a8938288c988120010d1a52d2f"; }
{ locale = "nb-NO"; arch = "linux-i686"; sha256 = "fde6089efa39e867f8c8b4b6d6e9d5c006f87c4ceaabb78517b34ea288cebe1e"; }
{ locale = "nb-NO"; arch = "linux-x86_64"; sha256 = "9ff74ec5e87468f3912b1ec847eff2d215c35224b4ef82ba29efaba4a48f2bb0"; }
{ locale = "nl"; arch = "linux-i686"; sha256 = "349101916960741272549700a4050850730679826ef3f6c837b542628ac9b17b"; }
{ locale = "nl"; arch = "linux-x86_64"; sha256 = "0bc2cf52b46f15976cd5355960b81106279c4cea9b7d55ac0360a56dd934ce6a"; }
{ locale = "nn-NO"; arch = "linux-i686"; sha256 = "6eff1f88b362d81d71833b50606afffdb7e0210160bc9933226c472daa692259"; }
{ locale = "nn-NO"; arch = "linux-x86_64"; sha256 = "748726556948ebc59913a72965a54de67615217a93cf0351ece356524d8e3097"; }
{ locale = "pa-IN"; arch = "linux-i686"; sha256 = "6606ee970387998235ed96fdbacc64a47fe2bc0d78061cf4205200517ab6f092"; }
{ locale = "pa-IN"; arch = "linux-x86_64"; sha256 = "0a77fe35ddce1921252d2e2acbeb09d6e719d34b4d81af8d6ef9c5c846359780"; }
{ locale = "pl"; arch = "linux-i686"; sha256 = "b8d81eba8470a29768ded1c6882cdbf2f3306843754d29fa35e385b0a6efce25"; }
{ locale = "pl"; arch = "linux-x86_64"; sha256 = "2b10f69274860e7af35cbb795042d058c9480ad195cd435e457923da2341c99d"; }
{ locale = "pt-BR"; arch = "linux-i686"; sha256 = "4391c285e1db0767f7242fad4fbf6441572ef930acabc63209f1d2ac64e6d08c"; }
{ locale = "pt-BR"; arch = "linux-x86_64"; sha256 = "003060a341e1134870f96e1e032023884f3f22fa62261b07084e3cb8813423fb"; }
{ locale = "pt-PT"; arch = "linux-i686"; sha256 = "d261cbc11bd9b176b656c3ae75f802aee4f1828e14f1a9f0e8c7822e9a24c090"; }
{ locale = "pt-PT"; arch = "linux-x86_64"; sha256 = "81fb37b9591a159e9d5ceff18921683037b4c965765b47e736c9124ba6268ee2"; }
{ locale = "rm"; arch = "linux-i686"; sha256 = "a7d699ac74a568922a363eabaa38627564fbc715cdd3612a8f51e0c373594646"; }
{ locale = "rm"; arch = "linux-x86_64"; sha256 = "ab9c84765f54f02e385b360025d1c70937af91350cbf8eea666f97aec4e36276"; }
{ locale = "ro"; arch = "linux-i686"; sha256 = "00db7d515ee4abcba36713a7bac64a2afdfa1782bc3e4175ae2c69535c7b6cdf"; }
{ locale = "ro"; arch = "linux-x86_64"; sha256 = "03da97e6c832ce49ccf6736ddac4a14b92768442f6f462b0174324964693aaa7"; }
{ locale = "ru"; arch = "linux-i686"; sha256 = "d7d78792a83d76ce4c521674275b3b6443d0c12ad376b4ec3c34bc4edef64078"; }
{ locale = "ru"; arch = "linux-x86_64"; sha256 = "bc4c751c5079d3863df1b0dd5717d7f5c07c031fefe798642ff3ff91e8f7512c"; }
{ locale = "si"; arch = "linux-i686"; sha256 = "9525a7a704f262efa1ad18ab154d7f0eeec8f923f641621a38cce3be5c090cd4"; }
{ locale = "si"; arch = "linux-x86_64"; sha256 = "2e847ce3ee90d27b7e20602844cbc1c3a9e458a7d449386e5bc8067163b6559d"; }
{ locale = "sk"; arch = "linux-i686"; sha256 = "389e6dea7b61aced9ad491b57441963cf9c3f5f0c90a80778ccee71320a8bf53"; }
{ locale = "sk"; arch = "linux-x86_64"; sha256 = "c36e78ce9aecaa23cf183a453e6ae817a52b84e2129f4e41fd409a61e1705c6a"; }
{ locale = "sl"; arch = "linux-i686"; sha256 = "e8f1dd49850b2c359a66e8f79839a95d6e1a09de5cdd41a64c44315fdcea544c"; }
{ locale = "sl"; arch = "linux-x86_64"; sha256 = "3ae2a85dadbaf99109fa971bb0c7a825d4ad3d1357f4d51bc7bb20455564ea68"; }
{ locale = "sq"; arch = "linux-i686"; sha256 = "dd52238fbd564d49ae8f3dfcee7e608615d3e78bd99373b1bbcdf51b9e20c354"; }
{ locale = "sq"; arch = "linux-x86_64"; sha256 = "cbeadcb1de666c42c9e5b42b2a6c1fa14f80e4c6454ea8cfc34b0ad5dd472bb8"; }
{ locale = "sr"; arch = "linux-i686"; sha256 = "1318c997a56245b296b2f9ac004b07f87d6492448272c8978e78193fe484336b"; }
{ locale = "sr"; arch = "linux-x86_64"; sha256 = "0898d16c990669028fbea084755221c747db48392b30b7c498770fcb5df7b328"; }
{ locale = "sv-SE"; arch = "linux-i686"; sha256 = "50c76b8904b51a84136a1c69939e49541205ce8b804c2ce90cff196e826c275c"; }
{ locale = "sv-SE"; arch = "linux-x86_64"; sha256 = "bf3e5c83815458726317c8415963825975500452202f240200be0fab43b1e226"; }
{ locale = "ta-LK"; arch = "linux-i686"; sha256 = "7d62ec98b8f01b12425e7692c4966faeeeb42ea66cd6105c37742698215bde5a"; }
{ locale = "ta-LK"; arch = "linux-x86_64"; sha256 = "416cffbe25f2b00cd584fa455768b09c5f8d1bc7938263880903050f8c08fab4"; }
{ locale = "tr"; arch = "linux-i686"; sha256 = "581d6c8df1611d749d0dda9d1f248ebf354825f8a8097624fd08338ea5e01d38"; }
{ locale = "tr"; arch = "linux-x86_64"; sha256 = "24b1b9bfa251add2d7f3183b0c3aafdea6b4caa5bdbcea718462185d6dc63e5b"; }
{ locale = "uk"; arch = "linux-i686"; sha256 = "97175dba275e382b2436e9b7a948c46f137ed38612e90ea43466dd3fe20c878b"; }
{ locale = "uk"; arch = "linux-x86_64"; sha256 = "273b08710fbc57c30828736c38a158ff66ac788b2ca3726118367466cab09797"; }
{ locale = "vi"; arch = "linux-i686"; sha256 = "e0391fdecb11b5daac913f57894970208b51e1e7f1665ff56cb7a68dba0c442a"; }
{ locale = "vi"; arch = "linux-x86_64"; sha256 = "af51ee3bd2ac246a4b465aa65b13d1aa661dbce5e0988524532616fb9d2d651b"; }
{ locale = "zh-CN"; arch = "linux-i686"; sha256 = "5e7d1543d41912ffa0a71137b90c40ab5569ffab65e8b99f0b62446561a78ca2"; }
{ locale = "zh-CN"; arch = "linux-x86_64"; sha256 = "f85c8086b462474e40b0b090f9b566aa55b228ec49ec18fa1b5987ec3efa048b"; }
{ locale = "zh-TW"; arch = "linux-i686"; sha256 = "6f161428af67a1635364660a8ec6d7c785350204d5bac602ebcd32861e9baf62"; }
{ locale = "zh-TW"; arch = "linux-x86_64"; sha256 = "2088379539a9b4ece3012b603a5731c92567fa4b3e5c448ae54e2729c8df0658"; }
{ locale = "ar"; arch = "linux-i686"; sha256 = "186ba5f03adc7cb94c69351f5edcf241abdba1a3602f9b140a46682cb94b053c"; }
{ locale = "ar"; arch = "linux-x86_64"; sha256 = "7c6308024524c8ba458bb43cace95bdf92dfa7d797c7ff936598257c018e4807"; }
{ locale = "ast"; arch = "linux-i686"; sha256 = "61de0fc548ff70367334c82bec580caa895f3db63c6b045c5a717bfa282e69db"; }
{ locale = "ast"; arch = "linux-x86_64"; sha256 = "34c935a0b162e182a341699782143cad1e225ea63bf314c158d25f629889c5e1"; }
{ locale = "be"; arch = "linux-i686"; sha256 = "4442d37c8bb411c5c151bd98d06a375dc8ffcf72fee4d03bed6ac8691ccd8e2c"; }
{ locale = "be"; arch = "linux-x86_64"; sha256 = "e7226b6b42e7cfe4d36c430eca755f5deae8899fd64ea1877ad576f96fe29b8c"; }
{ locale = "bg"; arch = "linux-i686"; sha256 = "eaf46e571b55800dfaf63a807236e8bf5fa8e8ba77bc996830ab0dfcdce23300"; }
{ locale = "bg"; arch = "linux-x86_64"; sha256 = "62edb0cee78dd88a871355c996107901456f1fb70793d21209e75875c33d91a3"; }
{ locale = "bn-BD"; arch = "linux-i686"; sha256 = "76e3222d9b7bc4f5948c56be6248deb23c1777550f497f115487e323c16b2f95"; }
{ locale = "bn-BD"; arch = "linux-x86_64"; sha256 = "b7ad9dd397abb89b844f8a1adbd34d0dfdea6bb85b3f8ad5d5f297e7f8b1b081"; }
{ locale = "br"; arch = "linux-i686"; sha256 = "b10c7e572ba88f79acb2d57988308c5af6fde268f64434956c4312f8a7c3ed42"; }
{ locale = "br"; arch = "linux-x86_64"; sha256 = "174f671aa90307e4dd6756d60f37a0b628d7d1cee8c7bb623a1a32c55b26a967"; }
{ locale = "ca"; arch = "linux-i686"; sha256 = "b966f3381a30567db88890dd3885c56f9cf367d9c92e192d0c6c79066e482c91"; }
{ locale = "ca"; arch = "linux-x86_64"; sha256 = "e5d96ddd9ed6b685b872d90e95bded23124e21575e9e0bcb7aeaa77ef0226009"; }
{ locale = "cs"; arch = "linux-i686"; sha256 = "fdbe97bc87656569b20d8154619cd7b3b5c3b03cbbcd7ff2f1e07a3af547bb41"; }
{ locale = "cs"; arch = "linux-x86_64"; sha256 = "b24ea0ae2977d9380cadfd130f83971e798677ce956152d794523e90a54222e6"; }
{ locale = "cy"; arch = "linux-i686"; sha256 = "ba39bd39698ad0486e22806ff468b9a763712f35e943b93e6021365dc061c2ce"; }
{ locale = "cy"; arch = "linux-x86_64"; sha256 = "f51e4dcaeac1aeb53d858d029c34c366e948616f7ca3f35eb22b165fd2839376"; }
{ locale = "da"; arch = "linux-i686"; sha256 = "511441bfe56749643f59e10c9219b8c3192d64c50008ee3d8a2dc342993c0133"; }
{ locale = "da"; arch = "linux-x86_64"; sha256 = "9f60a1c06da4e61a415359eeaed831d61a8c8ad377952948c1475ee6a2bc0cd3"; }
{ locale = "de"; arch = "linux-i686"; sha256 = "d48939ad0dab7c4829cd41cd6afe9239d12ab2a2337296203b660613cbba2698"; }
{ locale = "de"; arch = "linux-x86_64"; sha256 = "6b1398161ab1271caa14b20c4ad0b3e4372fca743b4ae2e3d5bd1d77d8038c15"; }
{ locale = "dsb"; arch = "linux-i686"; sha256 = "c30f3fea47cca28fcc928d813e8c631db43a665d8f347f174b23ef3c1fdd7550"; }
{ locale = "dsb"; arch = "linux-x86_64"; sha256 = "592b18fa8ff3749c7a68b5f5406f5ae42f9f97e47cc8c2f9c18b242c8f192b8d"; }
{ locale = "el"; arch = "linux-i686"; sha256 = "1ccdde8b11337e75feabbd1e40f1316c287862769d0b9c37934f22108c74bf1a"; }
{ locale = "el"; arch = "linux-x86_64"; sha256 = "acb837b0120f00f6cb39e447e86cb140c0cabbe599bff70d85429126df377d85"; }
{ locale = "en-GB"; arch = "linux-i686"; sha256 = "ba4c223c22fda306f4b66daa6ed0d157c5c24489ec7627e1124c9f79b5aca989"; }
{ locale = "en-GB"; arch = "linux-x86_64"; sha256 = "f4bb5a60493f3fbf519a55dc7ff2fa7bb455ad344d27b133addb2864f9d9d100"; }
{ locale = "en-US"; arch = "linux-i686"; sha256 = "205729f0ce14666ef98b7e23dad0882d450a508b568fc1d2c99cdfffd2cc9547"; }
{ locale = "en-US"; arch = "linux-x86_64"; sha256 = "7c7cb801ea902f93e57f944209e1358bcbe73f8ee312112e94ade2a2ef4b1194"; }
{ locale = "es-AR"; arch = "linux-i686"; sha256 = "8bbb39afd31656bc7cdab60b179e0a5bb9d9d9fed62e1ad398dfc5c0f40a35ab"; }
{ locale = "es-AR"; arch = "linux-x86_64"; sha256 = "0d86ebebfd2ba294b0f27b5eb84b083a7c8cecc8fea944705525831cf3c161b8"; }
{ locale = "es-ES"; arch = "linux-i686"; sha256 = "76673ffb93fb3b902366c5939619dfa11ecd724dc5ff37fe769d598dc937c353"; }
{ locale = "es-ES"; arch = "linux-x86_64"; sha256 = "6e7098cf9eb6f1b55d7504b341b709133fb5d4d20cb761984647422749b71615"; }
{ locale = "et"; arch = "linux-i686"; sha256 = "3de2c84af3c7111a306e35f1f7304bf7a77a0e50c8d2c9bfbc896a11a6a23e5d"; }
{ locale = "et"; arch = "linux-x86_64"; sha256 = "a2bb5c2b6e174a65cf825293f57cc1628930686f6a674d2cb7fcee6aaf755afc"; }
{ locale = "eu"; arch = "linux-i686"; sha256 = "f0ec8c9613ee04c7f7c1b55cb81386036220a715b58edc302e2099882e2c642d"; }
{ locale = "eu"; arch = "linux-x86_64"; sha256 = "3ed3c4431fc604fbc05b6f17c9c6e74057278e9ef85480d60ea638843eab1394"; }
{ locale = "fi"; arch = "linux-i686"; sha256 = "e4dac93472bc5f41a75daf9ca18265de527b5fc621812bde2c634f1fa5a4692c"; }
{ locale = "fi"; arch = "linux-x86_64"; sha256 = "8a30c0c7a586f598e6065f20b2a0dc1e105f59d3e4adac8167da462e8e0193d2"; }
{ locale = "fr"; arch = "linux-i686"; sha256 = "adfe8aca07faf08ba780ca0f84d638d461f4a0f00b92d5a9cebe8102a94bce79"; }
{ locale = "fr"; arch = "linux-x86_64"; sha256 = "19ccb4a2ec44b1c8edce204627af3d0e84f214591d3b7a4f6e67e297dd9db0f9"; }
{ locale = "fy-NL"; arch = "linux-i686"; sha256 = "88f763080b2bbfb8957ed6b52189f2195b3317a1bfb851a6e686765e8a12181a"; }
{ locale = "fy-NL"; arch = "linux-x86_64"; sha256 = "5955d594802281794ef25e9fda196206464ac0594ce12e957b5c40c589c89ad0"; }
{ locale = "ga-IE"; arch = "linux-i686"; sha256 = "7fb849565e25b1bba853b434d7f0207bfc9b3f39251f08edf65a8a38ccd0dd96"; }
{ locale = "ga-IE"; arch = "linux-x86_64"; sha256 = "b56cd8b5fc665ad24061fdf2ac3196aff9f953395e894007b133bc83f676be33"; }
{ locale = "gd"; arch = "linux-i686"; sha256 = "860dca420cd8c6c18bc703ab4934948e038b4e7e91a1d80d3f632980f0799424"; }
{ locale = "gd"; arch = "linux-x86_64"; sha256 = "4e8723dacd9a4961f02fece36066166c044880fbc0c7aab4e0f1289a36bd22c6"; }
{ locale = "gl"; arch = "linux-i686"; sha256 = "fd071bf547ba0baaf13141e30f34c15108fb6e44432b02d55508cf3dfca91cdb"; }
{ locale = "gl"; arch = "linux-x86_64"; sha256 = "b999261eb53e28c5b43fa5d3ffcb2f9c12cca45a38c6e8fc56a342b1a5dda78a"; }
{ locale = "he"; arch = "linux-i686"; sha256 = "2c2e7d7a459dd85f88fb3839002e2eb602d47ce5df4d0572928d8a35a0df4773"; }
{ locale = "he"; arch = "linux-x86_64"; sha256 = "0c540f0ffb1224c8d3b18423690f319d25ff5e0c004d18cc8bc6b7d69ecbc48a"; }
{ locale = "hr"; arch = "linux-i686"; sha256 = "5d7e14f94f53c7623dc4fce69aa991a67792e0d2405a6c7044558d5023ea0cc0"; }
{ locale = "hr"; arch = "linux-x86_64"; sha256 = "6355145ae642332d1798f8ce169cb85cc930af6add6c8cda142e8183666fdb71"; }
{ locale = "hsb"; arch = "linux-i686"; sha256 = "897eca9ffdbf28f3d3f720dd44f68f67a289e4d2aff91005c180688b34358b08"; }
{ locale = "hsb"; arch = "linux-x86_64"; sha256 = "43d2cf464be8be57a5d2bdba1683e6179641448e351d9a8bee9889febe1ebefd"; }
{ locale = "hu"; arch = "linux-i686"; sha256 = "5e6b806364d7e97384bf3f30e4f398c8041cd8acc000b21edcf218ca24e1903a"; }
{ locale = "hu"; arch = "linux-x86_64"; sha256 = "5b96ea401ec1af9473cc57e4f09f6f264598e52196dd9da38cebe3e802649fc9"; }
{ locale = "hy-AM"; arch = "linux-i686"; sha256 = "3fbd40d914f9347f09848ffb3486d1cec9734f9ae3cc969bc71a8d9c61aea92b"; }
{ locale = "hy-AM"; arch = "linux-x86_64"; sha256 = "9f60903ccb571eebdf7fab4c62e1f0675d4c7f5bcbca7589e669c931b355b55a"; }
{ locale = "id"; arch = "linux-i686"; sha256 = "bd0e53bb5d792c9caf2aedc67cf1df2281d234905b96748766446e842448e39e"; }
{ locale = "id"; arch = "linux-x86_64"; sha256 = "f7bc98632e15fb73c61c5fd54c3e349e93f3f07b61ee92d704b105b05386949d"; }
{ locale = "is"; arch = "linux-i686"; sha256 = "6361b21f9a57468cb8e6273805437d4a40f90c0b461d447b17543f84f9cae8c2"; }
{ locale = "is"; arch = "linux-x86_64"; sha256 = "df4d4ef5a25a8aa2f9cbbfef2425056c19b568030e2b217f9bb535fcd81cc017"; }
{ locale = "it"; arch = "linux-i686"; sha256 = "def27fdc02da10e148b3312199826157b981165a98ea9a3f5135866092e07ad3"; }
{ locale = "it"; arch = "linux-x86_64"; sha256 = "3c55c72d8b9936dc0b0ecf2e88024d4e128f4cbdb32ec5770d4caa930e12d696"; }
{ locale = "ja"; arch = "linux-i686"; sha256 = "7f1e39da21362857afd57151b0bb606c7a8b52f0ea1362cbb5bf9c4eb9b18db8"; }
{ locale = "ja"; arch = "linux-x86_64"; sha256 = "3b70e990616d999c572a9e95f92dc62b004f5449891778a6530ee81dc1f42703"; }
{ locale = "ko"; arch = "linux-i686"; sha256 = "7023635ab8fde872b41b08f523128721863091d7bd7e76646ea2f2929a667719"; }
{ locale = "ko"; arch = "linux-x86_64"; sha256 = "370075633a30d3f4afbe69c617ecc4df33e51aa95704ef9fff599a13e9cb3ab2"; }
{ locale = "lt"; arch = "linux-i686"; sha256 = "f143791c658916ee2ddac2199293ded234cfd8201cd6399775ccb996cb784e18"; }
{ locale = "lt"; arch = "linux-x86_64"; sha256 = "5d48abb53a5b71be190dc4c127c5718704fbc12590c2c5fbcf3b4046f9840415"; }
{ locale = "nb-NO"; arch = "linux-i686"; sha256 = "319df90e458817537f7323e97c3d7fdeb2fd965a215b1173f87378b3c94e3ac7"; }
{ locale = "nb-NO"; arch = "linux-x86_64"; sha256 = "2f93a35135f387c8cb2e4ca4b0c800f846596d0f93350f3be0983797a0571359"; }
{ locale = "nl"; arch = "linux-i686"; sha256 = "8e3d9003a67a0d38821dae7a070eebe32698ae6a89272394d4f7faea91595360"; }
{ locale = "nl"; arch = "linux-x86_64"; sha256 = "bf2bb1676c5966b6fdcf34c93eb3444ed0f3dd6ed03c8e2a39f6757811bf0e7f"; }
{ locale = "nn-NO"; arch = "linux-i686"; sha256 = "e938fcf2e84bc19d766c89312f8ca8e055ffeaf7fe20ba8d616aeb0b862cd064"; }
{ locale = "nn-NO"; arch = "linux-x86_64"; sha256 = "ab0b01922e883a34874de33f6eae08a8e4e40d23dd7ddcdf42254386218728e6"; }
{ locale = "pa-IN"; arch = "linux-i686"; sha256 = "fd3fd9fe5280365a27ef4e81f7965da2e85ad149e4e026f6a8714a73d976eeb2"; }
{ locale = "pa-IN"; arch = "linux-x86_64"; sha256 = "6a68c72828036a256a8d04b1678be58c786671ef97f106b23812ebcf149f1d15"; }
{ locale = "pl"; arch = "linux-i686"; sha256 = "26bb8ca3617c70d1126ef4111787ab267bc6dcd28b2b995e07b7296bdf24723b"; }
{ locale = "pl"; arch = "linux-x86_64"; sha256 = "de6ac16163aab662ba4fef2130dd822ec9cfecc0f4beec54f2017785fec8eb0a"; }
{ locale = "pt-BR"; arch = "linux-i686"; sha256 = "82c459a487d2a7b156f92db36e85c815c714d59474ed9bd8cde46b08c69f1d57"; }
{ locale = "pt-BR"; arch = "linux-x86_64"; sha256 = "1f4caae64ced0c69fe6ba6330921fce0d220b616a0eb8b1e696da85cdcf5ec01"; }
{ locale = "pt-PT"; arch = "linux-i686"; sha256 = "830b649a394cd844bb1b159a76d265455f6ace76dec6697491367b2f6eff1588"; }
{ locale = "pt-PT"; arch = "linux-x86_64"; sha256 = "e89e906cd896c8e04754a9658dc72617954e0a097e6e3b648e5ce827c8cec7d7"; }
{ locale = "rm"; arch = "linux-i686"; sha256 = "260fc959ce74945d827c230124a451cec75b6347b78d7d8bbeb65a2bd91f5bd8"; }
{ locale = "rm"; arch = "linux-x86_64"; sha256 = "aa416170d0d04d0e2e570d0b0874b6c585d706f8b670de3c24bc5a9ce9819d8d"; }
{ locale = "ro"; arch = "linux-i686"; sha256 = "a24ec33c8812921ad0f15dd4306218a2443f7018be5141bcc8e87e0ce3f52929"; }
{ locale = "ro"; arch = "linux-x86_64"; sha256 = "5c8bb4872206cacd17cfb77ed3cf58024cdc81be181908213f80659c4d36594b"; }
{ locale = "ru"; arch = "linux-i686"; sha256 = "06bde08af3d4b73db3f0a8b87f4f5f3bbc95fd92d717a9ac83efddb7ebc0f12b"; }
{ locale = "ru"; arch = "linux-x86_64"; sha256 = "6adf1e6992b05b6c93152bb19a79fe39f319b5a5a62d2491191544eaaabbcc1b"; }
{ locale = "si"; arch = "linux-i686"; sha256 = "3f757064e857d8c4d025c0de8325b3bfd81648ac2b77ee11ca847e8ea85d35a5"; }
{ locale = "si"; arch = "linux-x86_64"; sha256 = "01147194ad382e4cc61c22c6a2672a01740ced6fdb3d4c2a9394ca9d62503c24"; }
{ locale = "sk"; arch = "linux-i686"; sha256 = "ffd8e8bbadb7be4672555f1ec8e4134af5c0898041cc197e1d0081b636d07642"; }
{ locale = "sk"; arch = "linux-x86_64"; sha256 = "d1e9df7d081afa272e94534ee3d6310c3498629cd7bba0fd7ab86675ea885714"; }
{ locale = "sl"; arch = "linux-i686"; sha256 = "2835ea496c48c171efa0d79924cd3183c12f6de49ce05af72214f6ad4a407c85"; }
{ locale = "sl"; arch = "linux-x86_64"; sha256 = "e585b0839c2b31ef12f562c4303b46b392493c6619b7e1b0c92e21c3afdb7461"; }
{ locale = "sq"; arch = "linux-i686"; sha256 = "592ece3de096b4135c24e9079f20b85b8c394d488caa6b7907b75d49f51fb30d"; }
{ locale = "sq"; arch = "linux-x86_64"; sha256 = "048bcb92d0915b909e2174c990948dd5c50345452369e067bf8c5770bc7b40c4"; }
{ locale = "sr"; arch = "linux-i686"; sha256 = "b24e02beeb02d44ba64884864cdfb6605e7b3454b6e953767ceeaf4817f41d95"; }
{ locale = "sr"; arch = "linux-x86_64"; sha256 = "caad067689a49308c2e51385750f3d2319e3a06757cf56060ce3c5ecb74a9ed6"; }
{ locale = "sv-SE"; arch = "linux-i686"; sha256 = "a2dc5de82a1736dd3aa157da305f5db478625508444df244a3492dfaff8278f3"; }
{ locale = "sv-SE"; arch = "linux-x86_64"; sha256 = "d2c4ab30e6e5d17716d7981d0039f043a41107edb917a838be66659d60653074"; }
{ locale = "ta-LK"; arch = "linux-i686"; sha256 = "58773ebf8d949541a2c19924935eb09f0d996aa4059ad3c17a71c664357c2bcc"; }
{ locale = "ta-LK"; arch = "linux-x86_64"; sha256 = "bb5c4d1d81373c1d25c1df4d896fbd1ba52acfed4e890a81650e34e5b9bd2ef0"; }
{ locale = "tr"; arch = "linux-i686"; sha256 = "c95f531aaa3d36788cf6511d51afa1242657890bdc10628218aef60d6d80b106"; }
{ locale = "tr"; arch = "linux-x86_64"; sha256 = "bf04a4f7b629e20f8389aad530b89b592686bd1a8340090311882934f9bea391"; }
{ locale = "uk"; arch = "linux-i686"; sha256 = "2c0c6d3a2d4228b7838864835665ff7d46cf8564d59db817ee1d8f9665828410"; }
{ locale = "uk"; arch = "linux-x86_64"; sha256 = "c51477c9aaa96765205c163df83acb003c2db837243225d5d1e8753b1de5b71b"; }
{ locale = "vi"; arch = "linux-i686"; sha256 = "3c92aef738962dab12fa0e118d64d29bb0d110f9ef2050630b3649d574036476"; }
{ locale = "vi"; arch = "linux-x86_64"; sha256 = "4854536b65fb7afb8925315ff4192c369db53f55b3ccec698cb561af1bc03f68"; }
{ locale = "zh-CN"; arch = "linux-i686"; sha256 = "3aa69342828a99d075e0b70938d1360dcb9016ad322638c57fba9288e37b9b3e"; }
{ locale = "zh-CN"; arch = "linux-x86_64"; sha256 = "9d590c31e369d8e1287c915cb91061f14359329c89e5038e3491052ff3df894a"; }
{ locale = "zh-TW"; arch = "linux-i686"; sha256 = "f133efa32b74f0203186abfeb5b191bf50711f04bf29762e2569b78e0feb66e3"; }
{ locale = "zh-TW"; arch = "linux-x86_64"; sha256 = "15d71526ef072de2b9adacb300e0eb158170839be82a7def9efa6ac55adcda37"; }
];
}

4
pkgs/applications/networking/mailreaders/thunderbird/default.nix
View File

@ -13,7 +13,7 @@
enableOfficialBranding ? false
}:
let version = "38.7.0"; in
let version = "38.7.1"; in
let verName = "${version}"; in
stdenv.mkDerivation rec {
@ -21,7 +21,7 @@ stdenv.mkDerivation rec {
src = fetchurl {
url = "http://archive.mozilla.org/pub/thunderbird/releases/${verName}/source/thunderbird-${verName}.source.tar.bz2";
sha256 = "1wbkj8a0p62mcbxlq8yyzrx51xi65qm8f2ccqiv5pb6qd51b5d0v";
sha256 = "0a4kbmas0a6wavp8dxkva0fl1y1qrx6b7l3xdjdan7qx7ysmm626";
};
buildInputs = # from firefox30Pkgs.xulrunner, but without gstreamer and libvpx

4
pkgs/applications/networking/remote/x2goclient/default.nix
View File

@ -2,11 +2,11 @@
stdenv.mkDerivation rec {
name = "x2goclient-${version}";
version = "4.0.5.0";
version = "4.0.5.1";
src = fetchurl {
url = "http://code.x2go.org/releases/source/x2goclient/${name}.tar.gz";
sha256 = "18a2pszh0nq2ir64a1ah1mlzddn4qcd12b339bv30n0y1ir92bi4";
sha256 = "04gdccqywas029a76k3r9zhr2mfn385i9r06cmi8mznxpczrhkl4";
};
buildInputs = [ cups libssh libXpm nxproxy openldap qt4 ];

7
pkgs/applications/science/logic/cvc4/default.nix
View File

@ -10,7 +10,12 @@ stdenv.mkDerivation rec {
};
buildInputs = [ gmp libantlr3c boost autoreconfHook ];
preConfigure = "patchShebangs ./src/";
preConfigure = ''
patchShebangs ./src/
OLD_CPPFLAGS="$CPPFLAGS"
export CPPFLAGS="$CPPFLAGS -P"
'';
postConfigure = ''CPPFLAGS="$OLD_CPPFLAGS"'';
doChecks = true;
meta = with stdenv.lib; {

10
pkgs/applications/science/machine-learning/torch/default.nix Normal file
View File

@ -0,0 +1,10 @@
{ callPackage, fetchgit, lua } :
let
src = fetchgit {
url = "https://github.com/grwlf/torch-distro";
rev = "f972c4253b14b95b53aefe7b24efa496223e73f2";
sha256 = "1lhjhivhyypaic33vj1nsghshsajf7vi6gwsclaf3nqdl27d1h1s";
};
in
callPackage (import ./torch-distro.nix) { inherit lua src; }

329
pkgs/applications/science/machine-learning/torch/torch-distro.nix Normal file
View File

@ -0,0 +1,329 @@
{ luarocks, lib , stdenv, writeText , readline, makeWrapper,
less, ncurses, cmake, openblas, coreutils, fetchgit, libuuid, czmq, openssl,
gnuplot, fetchurl, lua, src, libjpeg, libpng
} :
let
common_meta = {
homepage = http://torch.ch;
license = stdenv.lib.licenses.bsd3;
maintainers = with stdenv.lib.maintainers; [ smironov ];
platforms = stdenv.lib.platforms.gnu;
};
distro_src = src;
default_luarocks = luarocks;
pkgs_gnuplot = gnuplot;
luapkgs = rec {
luarocks = default_luarocks.override {
inherit lua;
};
buildLuaRocks = { rockspec ? "", luadeps ? [] , buildInputs ? []
, preBuild ? "" , postInstall ? ""
, runtimeDeps ? [] , ... }@args :
let
luadeps_ =
luadeps ++
(lib.concatMap (d : if d ? luadeps then d.luadeps else []) luadeps);
runtimeDeps_ =
runtimeDeps ++
(lib.concatMap (d : if d ? runtimeDeps then d.runtimeDeps else []) luadeps) ++
[ lua coreutils ];
mkcfg = ''
export LUAROCKS_CONFIG=config.lua
cat >config.lua <<EOF
rocks_trees = {
{ name = [[system]], root = [[${luarocks}]] }
${lib.concatImapStrings (i : dep : ", { name = [[dep${toString i}]], root = [[${dep}]] }") luadeps_}
};
variables = {
LUA_BINDIR = "$out/bin";
LUA_INCDIR = "$out/include";
LUA_LIBDIR = "$out/lib/lua/${lua.luaversion}";
};
EOF
'';
in
stdenv.mkDerivation (args // {
inherit preBuild postInstall;
inherit luadeps runtimeDeps;
phases = [ "unpackPhase" "patchPhase" "buildPhase"];
buildInputs = runtimeDeps ++ buildInputs ++ [ makeWrapper lua ];
buildPhase = ''
eval "$preBuild"
${mkcfg}
eval "`${luarocks}/bin/luarocks --deps-mode=all --tree=$out path`"
${luarocks}/bin/luarocks make --deps-mode=all --tree=$out ${rockspec}
for p in $out/bin/*; do
wrapProgram $p \
--suffix LD_LIBRARY_PATH ';' "${lib.makeSearchPath "lib" runtimeDeps_}" \
--suffix PATH ';' "${lib.makeSearchPath "bin" runtimeDeps_}" \
--suffix LUA_PATH ';' "\"$LUA_PATH\"" \
--suffix LUA_PATH ';' "\"$out/share/lua/${lua.luaversion}/?.lua;$out/share/lua/${lua.luaversion}/?/init.lua\"" \
--suffix LUA_CPATH ';' "\"$LUA_CPATH\"" \
--suffix LUA_CPATH ';' "\"$out/lib/lua/${lua.luaversion}/?.so;$out/lib/lua/${lua.luaversion}/?/init.so\""
done
eval "$postInstall"
'';
});
# FIXME: doesn't installs lua-files for some reason
# lua-cjson = buildLuaPackage {
# name = "lua-cjson";
# src = ./extra/lua-cjson;
# rockspec = "lua-cjson-2.1devel-1.rockspec";
# };
lua-cjson = stdenv.mkDerivation rec {
name = "lua-cjson";
src = "${distro_src}/extra/lua-cjson";
preConfigure = ''
makeFlags="PREFIX=$out LUA_LIBRARY=$out/lib/lua"
'';
buildInputs = [lua];
installPhase = ''
make install-extra $makeFlags
'';
};
luafilesystem = buildLuaRocks {
name = "filesystem";
src = "${distro_src}/extra/luafilesystem";
luadeps = [lua-cjson];
rockspec = "rockspecs/luafilesystem-1.6.3-1.rockspec";
};
penlight = buildLuaRocks {
name = "penlight";
src = "${distro_src}/extra/penlight";
luadeps = [luafilesystem];
};
luaffifb = buildLuaRocks {
name = "luaffifb";
src = "${distro_src}/extra/luaffifb";
};
sundown = buildLuaRocks rec {
name = "sundown";
src = "${distro_src}/pkg/sundown";
rockspec = "rocks/${name}-scm-1.rockspec";
};
cwrap = buildLuaRocks rec {
name = "cwrap";
src = "${distro_src}/pkg/cwrap";
rockspec = "rocks/${name}-scm-1.rockspec";
};
paths = buildLuaRocks rec {
name = "paths";
src = "${distro_src}/pkg/paths";
buildInputs = [cmake];
rockspec = "rocks/${name}-scm-1.rockspec";
};
torch = buildLuaRocks rec {
name = "torch";
src = "${distro_src}/pkg/torch";
luadeps = [ paths cwrap ];
buildInputs = [ cmake ];
rockspec = "rocks/torch-scm-1.rockspec";
preBuild = ''
substituteInPlace ${rockspec} \
--replace '"sys >= 1.0"' ' '
export LUA_PATH="$src/?.lua;$LUA_PATH"
'';
meta = common_meta // {
description = "Torch is a machine-learning library";
longDescription = ''
Torch is the main package in [Torch7](http://torch.ch) where data
structures for multi-dimensional tensors and mathematical operations
over these are defined. Additionally, it provides many utilities for
accessing files, serializing objects of arbitrary types and other
useful utilities.
'';
};
};
dok = buildLuaRocks rec {
name = "dok";
src = "${distro_src}/pkg/dok";
luadeps = [sundown];
rockspec = "rocks/${name}-scm-1.rockspec";
};
sys = buildLuaRocks rec {
name = "sys";
luadeps = [torch];
buildInputs = [readline cmake];
src = "${distro_src}/pkg/sys";
rockspec = "sys-1.1-0.rockspec";
preBuild = ''
export Torch_DIR=${torch}/share/cmake/torch
'';
};
xlua = buildLuaRocks rec {
name = "xlua";
luadeps = [torch sys];
src = "${distro_src}/pkg/xlua";
rockspec = "xlua-1.0-0.rockspec";
};
nn = buildLuaRocks rec {
name = "nn";
luadeps = [torch luaffifb];
buildInputs = [cmake];
src = "${distro_src}/extra/nn";
rockspec = "rocks/nn-scm-1.rockspec";
preBuild = ''
export Torch_DIR=${torch}/share/cmake/torch
'';
};
graph = buildLuaRocks rec {
name = "graph";
luadeps = [ torch ];
buildInputs = [cmake];
src = "${distro_src}/extra/graph";
rockspec = "rocks/graph-scm-1.rockspec";
preBuild = ''
export Torch_DIR=${torch}/share/cmake/torch
'';
};
nngraph = buildLuaRocks rec {
name = "nngraph";
luadeps = [ torch nn graph ];
buildInputs = [cmake];
src = "${distro_src}/extra/nngraph";
preBuild = ''
export Torch_DIR=${torch}/share/cmake/torch
'';
};
image = buildLuaRocks rec {
name = "image";
luadeps = [ torch dok sys xlua ];
buildInputs = [cmake libjpeg libpng];
src = "${distro_src}/pkg/image";
rockspec = "image-1.1.alpha-0.rockspec";
preBuild = ''
export Torch_DIR=${torch}/share/cmake/torch
'';
};
optim = buildLuaRocks rec {
name = "optim";
luadeps = [ torch ];
buildInputs = [cmake];
src = "${distro_src}/pkg/optim";
rockspec = "optim-1.0.5-0.rockspec";
preBuild = ''
export Torch_DIR=${torch}/share/cmake/torch
'';
};
gnuplot = buildLuaRocks rec {
name = "gnuplot";
luadeps = [ torch paths ];
runtimeDeps = [ pkgs_gnuplot less ];
src = "${distro_src}/pkg/gnuplot";
rockspec = "rocks/gnuplot-scm-1.rockspec";
};
unsup = buildLuaRocks rec {
name = "unsup";
luadeps = [ torch xlua optim ];
buildInputs = [ cmake ];
src = fetchgit {
url = "https://github.com/koraykv/unsup";
rev = "1d4632e716dc3c82feecc7dd4b22549df442859f";
sha256 = "0npjq3y1cfmk026sdijcw3f766innrmb3qggnxsz62grczhfvgls";
};
rockspec = "unsup-0.1-0.rockspec";
preBuild = ''
export Torch_DIR=${torch}/share/cmake/torch
'';
};
trepl = buildLuaRocks rec {
name = "trepl";
luadeps = [torch gnuplot paths penlight graph nn nngraph image gnuplot optim sys dok unsup];
runtimeDeps = [ ncurses readline ];
src = "${distro_src}/exe/trepl";
meta = common_meta // {
description = "A pure Lua REPL for Lua(JIT), with heavy support for Torch types.";
};
};
lbase64 = buildLuaRocks rec {
name = "lbase64";
src = fetchgit {
url = "https://github.com/LuaDist2/lbase64";
rev = "1e9e4f1e0bf589a0ed39f58acc185ec5e213d207";
sha256 = "1i1fpy9v6r4w3lrmz7bmf5ppq65925rv90gx39b3pykfmn0hcb9c";
};
};
luuid = stdenv.mkDerivation rec {
name = "luuid";
src = fetchgit {
url = "https://github.com/LuaDist/luuid";
sha256 = "062gdf1rild11jg46vry93hcbb36b4527pf1dy7q9fv89f7m2nav";
};
preConfigure = ''
cmakeFlags="-DLUA_LIBRARY=${lua}/lib/lua/${lua.luaversion} -DINSTALL_CMOD=$out/lib/lua/${lua.luaversion} -DINSTALL_MOD=$out/lib/lua/${lua.luaversion}"
'';
buildInputs = [cmake libuuid lua];
meta = {
# FIXME: set the exact revision for src
broken = true;
};
};
# Doesn't work due to missing deps (according to luarocs).
itorch = buildLuaRocks rec {
name = "itorch";
luadeps = [torch gnuplot paths penlight graph nn nngraph image gnuplot
optim sys dok lbase64 lua-cjson luuid];
buildInputs = [czmq openssl];
src = "${distro_src}/extra/iTorch";
meta = {
# FIXME: figure out whats wrong with deps
broken = true;
};
};
};
in
luapkgs

8
pkgs/applications/science/robotics/gazebo/6.nix Normal file
View File

@ -0,0 +1,8 @@
{ stdenv, fetchurl, callPackage, ignition, gazeboSimulator, ... } @ args:
callPackage ./default.nix (args // rec {
version = "6.5.1";
src-sha256 = "96260aa23f1a1f24bc116f8e359d31f3bc65011033977cb7fb2c64d574321908";
sdformat = gazeboSimulator.sdformat3;
})

81
pkgs/applications/science/robotics/gazebo/default.nix Normal file
View File

@ -0,0 +1,81 @@
{ stdenv, fetchurl, cmake, pkgconfig, boost, protobuf, freeimage
, boost-build, boost_process
, xorg_sys_opengl, tbb, ogre, tinyxml-2
, libtar, glxinfo, libusb, libxslt, ruby, ignition
, pythonPackages, utillinux
# these deps are hidden; cmake doesn't catch them
, gazeboSimulator, sdformat ? gazeboSimulator.sdformat, curl, tinyxml, kde4, x11
, withIgnitionTransport ? true
, libav, withLibAvSupport ? true
, openal, withAudioSupport ? false
, withQuickBuild ? false, withHeadless ? false, withLowMemorySupport ? false
, doxygen, withDocs ? true
, bullet, withBulletEngineSupport ? false
, graphviz, withModelEditorSchematicView ? true # graphviz needed for this view
, gdal, withDigitalElevationTerrainsSupport ? true
, gts, withConstructiveSolidGeometrySupport ? true
, hdf5, withHdf5Support ? true
, version ? "7.0.0"
, src-sha256 ? "127q2g93kvmak2b6vhl13xzg56h09v14s4pki8wv7aqjv0c3whbl"
, ...
}: with stdenv.lib;
stdenv.mkDerivation rec {
inherit version;
name = "gazebo-${version}";
src = fetchurl {
url = "http://osrf-distributions.s3.amazonaws.com/gazebo/releases/${name}.tar.bz2";
sha256 = src-sha256;
};
enableParallelBuilding = true; # gazebo needs this so bad
cmakeFlags = []
++ optional withQuickBuild [ "-DENABLE_TESTS_COMPILATION=False" ]
++ optional withLowMemorySupport [ "-DUSE_LOW_MEMORY_TESTS=True" ]
++ optional withHeadless [ "-DENABLE_SCREEN_TESTS=False" ];
buildInputs = [
#cmake pkgconfig boost protobuf
freeimage
xorg_sys_opengl
tbb
ogre
tinyxml-2
libtar
glxinfo
libusb
libxslt
ignition.math2
sdformat
pythonPackages.pyopengl
# TODO: add these hidden deps to cmake configuration & submit upstream
curl
tinyxml
x11
kde4.qt4
] ++ optional stdenv.isLinux utillinux # on Linux needs uuid/uuid.h
++ optional withDocs doxygen
++ optional withLibAvSupport libav #TODO: package rubygem-ronn and put it here
++ optional withAudioSupport openal
++ optional withBulletEngineSupport bullet
++ optional withIgnitionTransport ignition.transport
++ optional withModelEditorSchematicView graphviz
++ optional withDigitalElevationTerrainsSupport gdal
++ optional withConstructiveSolidGeometrySupport gts
++ optional withHdf5Support hdf5;
nativeBuildInputs = [ cmake pkgconfig ];
propagatedNativeBuildInputs = [ boost boost-build boost_process protobuf ];
meta = with stdenv.lib; {
homepage = http://gazebosim.org/;
description = "Multi-robot simulator for outdoor environments";
license = licenses.asl20;
maintainers = with maintainers; [ pxc ];
platforms = platforms.all;
};
}

34
pkgs/applications/version-management/bugseverywhere/default.nix Normal file
View File

@ -0,0 +1,34 @@
{ stdenv, pythonPackages, fetchurl }:
#
# Upstream stopped development of this package. If this package does not build
# anymore, feel free to remove it by reverting the appropriate patch
# (git log --grep bugseverywhere)
#
pythonPackages.buildPythonApplication rec {
version = "1.1.1";
name = "bugseverywhere-${version}";
src = fetchurl {
url =
"https://pypi.python.org/packages/source/b/bugs-everywhere/bugs-everywhere-${version}.tar.gz";
sha256 = "1ikm3ckwpimwcvx32vy7gh5gbp7q750j3327m17nvrj99g3daz2d";
};
# There are no tests in the repository.
doCheck = false;
buildInputs = with pythonPackages; [
jinja2
cherrypy
];
meta = with stdenv.lib; {
description = "Bugtracker supporting distributed revision control";
homepage = "http://www.bugseverywhere.org/";
license = licenses.gpl2Plus;
platforms = platforms.all;
maintainers = [ maintainers.matthiasbeyer ];
};
}

2
pkgs/applications/version-management/git-and-tools/default.nix
View File

@ -8,7 +8,7 @@ let
gitBase = lib.makeOverridable (import ./git) {
inherit fetchurl stdenv curl openssl zlib expat perl python gettext gnugrep
asciidoc xmlto docbook2x docbook_xsl docbook_xml_dtd_45 libxslt cpio tcl
tk makeWrapper subversionClient gzip libiconv;
tk makeWrapper subversionClient gzip openssh libiconv;
texinfo = texinfo5;
svnSupport = false; # for git-svn support
guiSupport = false; # requires tcl/tk

4
pkgs/applications/version-management/git-and-tools/git-cola/default.nix
View File

@ -2,11 +2,11 @@
pythonPackages.buildPythonApplication rec {
name = "git-cola-${version}";
version = "2.2.1";
version = "2.5";
src = fetchurl {
url = "https://github.com/git-cola/git-cola/archive/v${version}.tar.gz";
sha256 = "1v1s9gx16xihdcck4qp92bdci8zc6pb5a3z3y8k9jqj97hfkw2nz";
sha256 = "0ybjmlwm1plnvqi20y91ci7sgldzwlwn86vyyn9a157h7lf4ngb8";
};
buildInputs = [ makeWrapper gettext ];

15
pkgs/applications/version-management/git-and-tools/git/default.nix
View File

@ -1,4 +1,5 @@
{ fetchurl, stdenv, curl, openssl, zlib, expat, perl, python, gettext, cpio, gnugrep, gzip
{ fetchurl, stdenv, curl, openssl, zlib, expat, perl, python, gettext, cpio
, gnugrep, gzip, openssh
, asciidoc, texinfo, xmlto, docbook2x, docbook_xsl, docbook_xml_dtd_45
, libxslt, tcl, tk, makeWrapper, libiconv
, svnSupport, subversionClient, perlLibs, smtpPerlLibs
@ -9,7 +10,7 @@
}:
let
version = "2.7.4";
version = "2.8.0";
svn = subversionClient.override { perlBindings = true; };
in
@ -18,15 +19,23 @@ stdenv.mkDerivation {
src = fetchurl {
url = "https://www.kernel.org/pub/software/scm/git/git-${version}.tar.xz";
sha256 = "0ys55v2xrhzj74jrrqx75xpr458klnyxshh8d8swfpp0zgg79rfy";
sha256 = "0k77b5x41k80fqqmkmg59rdvs92xgp73iigh01l49h383r7rl2cs";
};
patches = [
./docbook2texi.patch
./symlinks-in-bin.patch
./git-sh-i18n.patch
./ssh-path.patch
];
postPatch = ''
for x in connect.c git-gui/lib/remote_add.tcl ; do
substituteInPlace "$x" \
--subst-var-by ssh "${openssh}/bin/ssh"
done
'';
buildInputs = [curl openssl zlib expat gettext cpio makeWrapper libiconv]
++ stdenv.lib.optionals withManual [ asciidoc texinfo xmlto docbook2x
docbook_xsl docbook_xml_dtd_45 libxslt ]

26
pkgs/applications/version-management/git-and-tools/git/ssh-path.patch Normal file
View File

@ -0,0 +1,26 @@
diff --git a/connect.c b/connect.c
index fd7ffe1..20cd992 100644
--- a/connect.c
+++ b/connect.c
@@ -768,7 +768,7 @@ struct child_process *git_connect(int fd[2], const char *url,
ssh = getenv("GIT_SSH");
if (!ssh)
- ssh = "ssh";
+ ssh = "@ssh@";
ssh_dup = xstrdup(ssh);
base = basename(ssh_dup);
diff --git a/git-gui/lib/remote_add.tcl b/git-gui/lib/remote_add.tcl
index 50029d0..17b9594 100644
--- a/git-gui/lib/remote_add.tcl
+++ b/git-gui/lib/remote_add.tcl
@@ -139,7 +139,7 @@ method _add {} {
# Parse the location
if { [regexp {(?:git\+)?ssh://([^/]+)(/.+)} $location xx host path]
|| [regexp {([^:][^:]+):(.+)} $location xx host path]} {
- set ssh ssh
+ set ssh @ssh@
if {[info exists env(GIT_SSH)]} {
set ssh $env(GIT_SSH)
}

127
pkgs/applications/video/avidemux/default.nix
View File

@ -1,46 +1,115 @@
{stdenv, fetchurl, cmake, pkgconfig, libxml2, qt4, gtk, gettext, SDL,
libXv, pixman, libpthreadstubs, libXau, libXdmcp, libxslt, x264,
alsaLib, lame, faad2, libvorbis, yasm, libvpx, xvidcore, libva,
faac ? null, faacSupport ? false }:
{ stdenv, lib, fetchurl, cmake, pkgconfig, lndir
, zlib, gettext, libvdpau, libva, libXv, sqlite, x265
, yasm, fribidi, gtk3, qt4
, withX264 ? true, x264
, withLAME ? true, lame
, withFAAC ? false, faac
, withVorbis ? true, libvorbis
, withPulse ? true, libpulseaudio
, withFAAD ? true, faad2
, withOpus ? true, libopus
, withVPX ? true, libvpx
}:
assert stdenv ? glibc;
assert faacSupport -> faac != null;
stdenv.mkDerivation {
name = "avidemux-2.5.6";
stdenv.mkDerivation rec {
name = "avidemux-${version}";
version = "2.6.12";
src = fetchurl {
url = mirror://sourceforge/avidemux/avidemux_2.5.6.tar.gz;
sha256 = "12wvxz0n2g85f079d8mdkkp2zm279d34m9v7qgcqndh48cn7znnn";
url = "mirror://sourceforge/avidemux/avidemux/${version}/avidemux_${version}.tar.gz";
sha256 = "0nz52yih8sff53inndkh2dba759xjzsh4b8xjww419lcpk0qp6kn";
};
buildInputs = [ cmake pkgconfig libxml2 qt4 gtk gettext SDL libXv
pixman libpthreadstubs libXau libXdmcp libxslt x264 alsaLib
lame faad2 libvorbis yasm libvpx xvidcore libva
] ++ stdenv.lib.optional faacSupport faac;
nativeBuildInputs = [ cmake pkgconfig yasm lndir ];
buildInputs = [ zlib gettext libvdpau libva libXv sqlite x265 fribidi gtk3 qt4 ]
++ lib.optional withX264 x264
++ lib.optional withLAME lame
++ lib.optional withFAAC faac
++ lib.optional withVorbis libvorbis
++ lib.optional withPulse libpulseaudio
++ lib.optional withFAAD faad2
++ lib.optional withOpus libopus
++ lib.optional withVPX libvpx
;
cmakeFlags = "-DPTHREAD_INCLUDE_DIR=${stdenv.glibc}/include" +
" -DGETTEXT_INCLUDE_DIR=${gettext}/include" +
" -DSDL_INCLUDE_DIR=${SDL}/include/SDL";
enableParallelBuilding = false;
NIX_LDFLAGS="-lpthread";
outputs = [ "out" "cli" "gtk" "qt4" ];
postInstall = ''
cd $NIX_BUILD_TOP/$sourceRoot
mkdir build_plugins
cd build_plugins
cmake $cmakeFlags -DAVIDEMUX_INSTALL_PREFIX=$out \
-DAVIDEMUX_SOURCE_DIR=$NIX_BUILD_TOP/$sourceRoot \
-DAVIDEMUX_CORECONFIG_DIR=$NIX_BUILD_TOP/$sourceRoot/build/config ../plugins
patches = [ ./dynamic_install_dir.patch ];
make
make install
buildCommand = ''
unpackPhase
cd "$sourceRoot"
patchPhase
export cmakeFlags="$cmakeFlags -DAVIDEMUX_SOURCE_DIR=$(pwd)"
function buildOutput() {
( plugin_ui="$1"
output_dir="$2"
shift 2
export cmakeFlags="$cmakeFlags -DPLUGIN_UI=$plugin_ui -DCMAKE_INSTALL_PREFIX=$output_dir"
for i in "$@" avidemux_plugins; do
( cd "$i"
cmakeConfigurePhase
buildPhase
installPhase
)
done
rm -rf avidemux_plugins/build
)
}
function buildUi() {
plugin_ui="$1"
output_dir="$2"
shift 2
# Hack to split builds properly
mkdir -p $output_dir
lndir $out $output_dir
buildOutput $plugin_ui $output_dir "$@"
}
function fixupUi() {
output_dir="$1"
shift
find $output_dir -lname $out\* -delete
find $output_dir -type f | while read -r f; do
rpath="$(patchelf --print-rpath $f 2>/dev/null)" || continue
new_rpath=""
IFS=':' read -ra old_rpath <<< "$rpath"
for p in "''${old_rpath[@]}"; do
new_rpath="$new_rpath:$p"
if [[ $p = $output_dir* ]]; then
new_rpath="$new_rpath:$out/''${p#$output_dir}"
fi
done
patchelf --set-rpath "$new_rpath" $f
patchelf --shrink-rpath $f
done
}
buildOutput COMMON $out avidemux_core
buildOutput SETTINGS $out
buildUi CLI $cli avidemux/cli
buildUi GTK $gtk avidemux/gtk
buildUi QT4 $qt4 avidemux/qt4
fixupPhase
fixupUi $cli
fixupUi $gtk
fixupUi $qt4
'';
meta = {
homepage = http://fixounet.free.fr/avidemux/;
description = "Free video editor designed for simple video editing tasks";
maintainers = with stdenv.lib.maintainers; [viric];
maintainers = with stdenv.lib.maintainers; [ viric abbradar ];
platforms = with stdenv.lib.platforms; linux;
license = stdenv.lib.licenses.gpl2;
};
}

12
pkgs/applications/video/avidemux/dynamic_install_dir.patch Normal file
View File

@ -0,0 +1,12 @@
diff -ru3 avidemux_2.6.12.old/avidemux_core/ADM_core/src/ADM_fileio.cpp avidemux_2.6.12/avidemux_core/ADM_core/src/ADM_fileio.cpp
--- avidemux_2.6.12.old/avidemux_core/ADM_core/src/ADM_fileio.cpp 2016-03-25 15:26:00.368213627 +0300
+++ avidemux_2.6.12/avidemux_core/ADM_core/src/ADM_fileio.cpp 2016-03-26 02:32:56.163550537 +0300
@@ -393,7 +393,7 @@
return ADM_getRelativePath(buffer, base1, base2, base3);
#else
- return ADM_getRelativePath(ADM_INSTALL_DIR, base1, base2, base3);
+ return ADM_getRelativePath(getenv("ADM_ROOT_DIR"), base1, base2, base3);
#endif
}

29
pkgs/applications/video/avidemux/wrapper.nix Normal file
View File

@ -0,0 +1,29 @@
{ buildEnv, avidemux, makeWrapper
# GTK version is broken upstream, see https://bugzilla.redhat.com/show_bug.cgi?id=1244340
, withUi ? "qt4"
}:
let
ui = builtins.getAttr withUi avidemux;
in buildEnv {
name = "avidemux-${withUi}-" + avidemux.version;
paths = [ avidemux ui ];
buildInputs = [ makeWrapper ];
postBuild = ''
# TODO: This could be avoided if buildEnv could be forced to create all directories
if [ -L $out/bin ]; then
rm $out/bin
mkdir $out/bin
for i in ${ui}/bin/*; do
ln -s $i $out/bin
done
fi
for i in $out/bin/*; do
wrapProgram $i --set ADM_ROOT_DIR $out
done
'';
}

5
pkgs/applications/video/vlc/default.nix
View File

@ -27,6 +27,11 @@ stdenv.mkDerivation rec {
sha256 = "1dazxbmzx2g5570pkg519a7fsj07rdr155kjsw7b9y8npql33lls";
};
# Comment-out the Qt 5.5 version check, as we do apply the relevant patch.
# https://trac.videolan.org/vlc/ticket/16497
postPatch = if (!withQt5) then null else
"sed '/I78ef29975181ee22429c9bd4b11d96d9e68b7a9c/s/^/: #/' -i configure";
buildInputs =
[ xz bzip2 perl zlib a52dec libmad faad2 ffmpeg alsaLib libdvdnav libdvdnav.libdvdread
libbluray dbus fribidi libvorbis libtheora speex lua5 libgcrypt

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

@ -15,7 +15,7 @@
with stdenv.lib;
let
version = "2.5.0";
version = "2.5.1";
audio = optionalString (hasSuffix "linux" stdenv.system) "alsa,"
+ optionalString pulseSupport "pa,"
+ optionalString sdlSupport "sdl,";
@ -26,7 +26,7 @@ stdenv.mkDerivation rec {
src = fetchurl {
url = "http://wiki.qemu.org/download/qemu-${version}.tar.bz2";
sha256 = "1m3j6xl7msrniidkvr5pw9d44yba5m7hm42xz8xy77v105s8hhrl";
sha256 = "0b2xa8604absdmzpcyjs7fix19y5blqmgflnwjzsp1mp7g1m51q2";
};
buildInputs =

2
pkgs/applications/virtualization/virtinst/default.nix
View File

@ -13,7 +13,7 @@ stdenv.mkDerivation rec {
};
pythonPath = with pythonPackages;
[ setuptools eventlet greenlet gflags netaddr sqlalchemy7 carrot routes
[ setuptools eventlet greenlet gflags netaddr carrot routes
PasteDeploy m2crypto ipy twisted sqlalchemy_migrate
distutils_extra simplejson readline glanceclient cheetah lockfile httplib2
# !!! should libvirt be a build-time dependency? Note that

9
pkgs/build-support/build-fhs-userenv/default.nix
View File

@ -1,9 +1,8 @@
{ runCommand, lib, writeText, writeScriptBin, stdenv, bash, ruby } :
{ env, runScript ? "${bash}/bin/bash", extraBindMounts ? [], extraInstallCommands ? "", importMeta ? {} } :
{ runCommand, lib, writeText, writeScriptBin, stdenv, ruby } :
{ env, runScript ? "bash", extraBindMounts ? [], extraInstallCommands ? "", importMeta ? {} } :
let
name = env.pname;
bash' = "${bash}/bin/bash";
# Sandboxing script
chroot-user = writeScriptBin "chroot-user" ''
@ -33,7 +32,7 @@ in runCommand name {
runCommand "${name}-shell-env" {
shellHook = ''
export CHROOTENV_EXTRA_BINDS="${lib.concatStringsSep ":" extraBindMounts}:$CHROOTENV_EXTRA_BINDS"
exec ${chroot-user}/bin/chroot-user ${env} ${bash'} -l ${init bash'} "$(pwd)"
exec ${chroot-user}/bin/chroot-user ${env} bash -l ${init "bash"} "$(pwd)"
'';
} ''
echo >&2 ""
@ -46,7 +45,7 @@ in runCommand name {
cat <<EOF >$out/bin/${name}
#! ${stdenv.shell}
export CHROOTENV_EXTRA_BINDS="${lib.concatStringsSep ":" extraBindMounts}:\$CHROOTENV_EXTRA_BINDS"
exec ${chroot-user}/bin/chroot-user ${env} ${bash'} ${init runScript} "\$(pwd)" "\$@"
exec ${chroot-user}/bin/chroot-user ${env} bash ${init runScript} "\$(pwd)" "\$@"
EOF
chmod +x $out/bin/${name}
${extraInstallCommands}

37
pkgs/build-support/fetchbower/default.nix
View File

@ -1,11 +1,26 @@
{ stdenv, fetch-bower, git }: name: version: target: outputHash: stdenv.mkDerivation {
name = "${name}-${version}";
buildCommand = ''
out=$PWD/out fetch-bower "${name}" "${version}" "${target}"
cp -R out $out
'';
outputHashMode = "recursive";
outputHashAlgo = "sha256";
inherit outputHash;
buildInputs = [git fetch-bower];
}
{ stdenv, lib, bower2nix }:
let
bowerVersion = version:
let
components = lib.splitString "#" version;
hash = lib.last components;
ver = if builtins.length components == 1 then version else hash;
in ver;
fetchbower = name: version: target: outputHash: stdenv.mkDerivation {
name = "${name}-${bowerVersion version}";
buildCommand = ''
fetch-bower --quiet --out=$PWD/out "${name}" "${target}" "${version}"
# In some cases, the result of fetchBower is different depending
# on the output directory (e.g. if the bower package contains
# symlinks). So use a local output directory before copying to
# $out.
cp -R out $out
'';
outputHashMode = "recursive";
outputHashAlgo = "sha256";
inherit outputHash;
buildInputs = [ bower2nix ];
};
in fetchbower

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

@ -66,6 +66,7 @@ rec {
mknod -m 666 ${dev}/random c 1 8
mknod -m 666 ${dev}/urandom c 1 9
mknod -m 666 ${dev}/tty c 5 0
mknod -m 666 ${dev}/ttyS0 c 4 64
mknod ${dev}/rtc c 254 0
. /sys/class/block/${hd}/uevent
mknod ${dev}/${hd} b $MAJOR $MINOR
@ -208,7 +209,7 @@ rec {
export PATH=/bin:/usr/bin:${coreutils}/bin
echo "Starting interactive shell..."
echo "(To run the original builder: \$origBuilder \$origArgs)"
exec ${bash}/bin/sh
exec ${busybox}/bin/setsid ${bashInteractive}/bin/bash < /dev/ttyS0 &> /dev/ttyS0
fi
'';
@ -219,7 +220,7 @@ rec {
-nographic -no-reboot \
-virtfs local,path=/nix/store,security_model=none,mount_tag=store \
-virtfs local,path=$TMPDIR/xchg,security_model=none,mount_tag=xchg \
-drive file=$diskImage,if=virtio,cache=writeback,werror=report \
-drive file=$diskImage,if=virtio,cache=unsafe,werror=report \
-kernel ${kernel}/${img} \
-initrd ${initrd}/initrd \
-append "console=ttyS0 panic=1 command=${stage2Init} out=$out mountDisk=$mountDisk loglevel=4" \

47
pkgs/data/fonts/noto-fonts/default.nix
View File

@ -1,15 +1,19 @@
{ stdenv, fetchurl, fetchFromGitHub, optipng, cairo, unzip, fontforge, pythonPackages, pkgconfig }:
{ stdenv, fetchurl, fetchFromGitHub, optipng, cairo, unzip, pythonPackages, pkgconfig, pngquant, which, imagemagick }:
rec {
# 18MB
noto-fonts = let version = "git-2015-09-08"; in stdenv.mkDerivation {
noto-fonts = let version = "git-2016-03-29"; in stdenv.mkDerivation {
name = "noto-fonts-${version}";
src = fetchFromGitHub {
owner = "googlei18n";
repo = "noto-fonts";
rev = "9d677e7e47a13f6e88052833277783fe4f27671f";
sha256 = "1dw1142znlk19a4mzhfi9pg3jzmz8pl1ivix7sd2grg70vxscxqc";
rev = "e8b0af48b15d64bd490edab4418b5e396cf29644";
sha256 = "02yv12fbb4n1gp9g9m0qxnj6adpg9hfsr9377h2d4xsf6sxcgy6f";
};
phases = "unpackPhase installPhase";
phases = [ "unpackPhase" "installPhase" ];
installPhase = ''
mkdir -p $out/share/fonts/noto
cp hinted/*.ttf $out/share/fonts/noto
@ -19,6 +23,9 @@ rec {
cp -n unhinted/*.ttf $out/share/fonts/noto
cp -n alpha/*.ttf $out/share/fonts/noto
'';
preferLocalBuild = true;
meta = with stdenv.lib; {
inherit version;
description = "Beautiful and free fonts for many languages";
@ -51,9 +58,9 @@ rec {
sha256 = "1vg3si6slvk8cklq6s5c76s84kqjc4wvwzr4ysljzjpgzra2rfn6";
};
buildInputs = [ unzip ];
nativeBuildInputs = [ unzip ];
phases = "unpackPhase installPhase";
phases = [ "unpackPhase" "installPhase" ];
sourceRoot = ".";
@ -86,34 +93,30 @@ rec {
};
};
# 12MB
noto-fonts-emoji = let version = "git-2015-08-17"; in stdenv.mkDerivation {
noto-fonts-emoji = let version = "git-2016-03-17"; in stdenv.mkDerivation {
name = "noto-fonts-emoji-${version}";
src = fetchFromGitHub {
owner = "googlei18n";
repo = "noto-emoji";
rev = "ffd7cfd0c84b7bf37210d0908ac94adfe3259ff2";
sha256 = "1pa94gw2y0b6p8r81zbjzcjgi5nrx4dqrqr6mk98wj6jbi465sh2";
rev = "c6379827aaa9cb0baca1a08a9d44ae74ca505236";
sha256 = "1zh1b617cjr5laha6lx0ys4k1c3az2zkgzjwc2nlb7dsdmfw1n0q";
};
buildInputs = with pythonPackages; [
optipng cairo fontforge python nototools fonttools pkgconfig
];
buildInputs = [ cairo ];
nativeBuildInputs = [ pngquant optipng which cairo pkgconfig imagemagick ]
++ (with pythonPackages; [ python fonttools nototools ]);
#FIXME: perhaps use our pngquant instead
preConfigure = ''
for f in ./*.py ./third_party/pngquant/configure; do
patchShebangs "$f"
done
postPatch = ''
sed -i 's,^PNGQUANT :=.*,PNGQUANT := ${pngquant}/bin/pngquant,' Makefile
patchShebangs flag_glyph_name.py
'';
preBuild = ''
export PYTHONPATH=$PYTHONPATH:$PWD
'';
enableParallelBuilding = true;
installPhase = ''
mkdir -p $out/share/fonts/noto
cp NotoColorEmoji.ttf NotoEmoji-Regular.ttf $out/share/fonts/noto
cp NotoColorEmoji.ttf fonts/NotoEmoji-Regular.ttf $out/share/fonts/noto
'';
meta = with stdenv.lib; {

6
pkgs/data/misc/tzdata/default.nix
View File

@ -2,16 +2,16 @@
stdenv.mkDerivation rec {
name = "tzdata-${version}";
version = "2016b";
version = "2016c";
srcs =
[ (fetchurl {
url = "http://www.iana.org/time-zones/repository/releases/tzdata${version}.tar.gz";
sha256 = "6392091d92556a32de488ea06a055c51bc46b7d8046c8a677f0ccfe286b3dbdc";
sha256 = "0j1dk830rkr1pijfac5wkdifi47k28mmvfys6z07l07jws0xj047";
})
(fetchurl {
url = "http://www.iana.org/time-zones/repository/releases/tzcode${version}.tar.gz";
sha256 = "e935c4fe78b5c5da3791f58f3ab7f07fb059a7c71d6b62b69ef345211ae5dfa7";
sha256 = "05m4ql1x3b4bmlg0vv1ibz2128mkk4xxnixagcmwlnwkhva1njrl";
})
];

2
pkgs/desktops/kde-5/applications-15.12/fetchsrcs.sh
View File

@ -4,7 +4,7 @@
set -x
# The trailing slash at the end is necessary!
WGET_ARGS='http://download.kde.org/stable/applications/15.12.1/ -A *.tar.xz'
WGET_ARGS='http://download.kde.org/stable/applications/15.12.3/ -A *.tar.xz'
mkdir tmp; cd tmp

1928
pkgs/desktops/kde-5/applications-15.12/srcs.nix
View File

File diff suppressed because it is too large Load Diff

49
pkgs/development/bower-modules/generic/default.nix Normal file
View File

@ -0,0 +1,49 @@
{ pkgs }:
{ buildInputs ? [], generated, ... } @ attrs:
let
# Fetches the bower packages. `generated` should be the result of a
# `bower2nix` command.
bowerPackages = import generated {
inherit (pkgs) buildEnv fetchbower;
};
in pkgs.stdenv.mkDerivation (
attrs
//
{
name = "bower_components-" + attrs.name;
inherit bowerPackages;
builder = builtins.toFile "builder.sh" ''
source $stdenv/setup
# The project's bower.json is required
cp $src/bower.json .
# Dereference symlinks -- bower doesn't like them
cp --recursive --reflink=auto \
--dereference --no-preserve=mode \
$bowerPackages bc
# Bower install in offline mode -- links together the fetched
# bower packages.
HOME=$PWD bower \
--config.storage.packages=bc/packages \
--config.storage.registry=bc/registry \
--offline install
# Sets up a single bower_components directory within
# the output derivation.
mkdir -p $out
mv bower_components $out
'';
buildInputs = buildInputs ++ [
pkgs.git
pkgs.nodePackages.bower
];
}
)

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

@ -4,11 +4,11 @@
stdenv.mkDerivation rec {
name = "fsharp-${version}";
version = "4.0.0.4";
version = "4.0.1.1";
src = fetchurl {
url = "https://github.com/fsharp/fsharp/archive/${version}.tar.gz";
sha256 = "1m9pwr4xjl3ikaf3pzsa4pb3pr533xa0v34y2cy4pjcc6j0f71av";
sha256 = "0mvmvwwpl4zq0yvgzdizww8l9azvlrc82xm32nz1fi1nw8x5qfqk";
};
buildInputs = [ mono pkgconfig dotnetbuildhelpers autoconf automake which ];

1
pkgs/development/compilers/ghc/6.12.3.nix
View File

@ -39,5 +39,6 @@ stdenv.mkDerivation rec {
maintainers = with stdenv.lib.maintainers; [ marcweber andres simons ];
platforms = ["x86_64-linux" "i686-linux"]; # Darwin is unsupported.
inherit (ghc.meta) license;
broken = true; # broken by gcc 5.x: http://hydra.nixos.org/build/33627548
};
}

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

@ -26,7 +26,7 @@ stdenv.mkDerivation rec {
gmp libyaml libedit libvpx imagemagick fribidi gperf
];
enableParallelBuilding = true;
enableParallelBuilding = false; # occasional build problems;
dontUseCmakeBuildDir = true;
NIX_LDFLAGS = "-lpam -L${pam}/lib";
MYSQL_INCLUDE_DIR="${mariadb}/include/mysql";

1
pkgs/development/compilers/ios-cross-compile/9.2.nix
View File

@ -58,6 +58,7 @@ clangStdenv.mkDerivation rec {
description =
"Provides an iOS cross compiler from 7.1 up to iOS-${version} and ldid";
platforms = stdenv.lib.platforms.linux;
hydraPlatforms = [];
maintainers = with stdenv.lib.maintainers; [ fxfactorial ];
license = stdenv.lib.licenses.gpl2;
};

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

@ -1,12 +1,12 @@
{ stdenv, fetchurl, makeWrapper, jre, unzip }:
stdenv.mkDerivation rec {
version = "1.0.1";
version = "1.0.1-2";
name = "kotlin-${version}";
src = fetchurl {
url = "https://github.com/JetBrains/kotlin/releases/download/${version}/kotlin-compiler-${version}.zip";
sha256 = "1hwdisjgy4q5y25gqnxk8ycd04j7hxb7xd0y6ixi12qfj7259a41";
sha256 = "0kdfvkb7qh3icchxswai24ifsiw25y3mq1xxcsp8nd3jn9krnj87";
};
propagatedBuildInputs = [ jre ] ;

1
pkgs/development/compilers/llvm/3.5/clang.nix
View File

@ -50,5 +50,6 @@ in stdenv.mkDerivation {
homepage = http://llvm.org/;
license = stdenv.lib.licenses.bsd3;
platforms = stdenv.lib.platforms.all;
broken = true;
};
}

6
pkgs/development/compilers/oraclejdk/jdk8-linux.nix
View File

@ -1,9 +1,9 @@
import ./jdk-linux-base.nix {
productVersion = "8";
patchVersion = "73";
patchVersion = "77";
downloadUrl = http://www.oracle.com/technetwork/java/javase/downloads/jdk8-downloads-2133151.html;
sha256_i686 = "1bi3yj2ds9w13p2lzvmxffk5gax8syi3bw52w8pam1jr3fmzgwgl";
sha256_x86_64 = "1rp3nbnhkncyr48m0nn3pf5fr4bp3lzm0ki4gca7mn7rzag19a26";
sha256_i686 = "14hyniai5l9qpg0pbnxa4rhyhk90qgihszfkn8h3vziqhmvrp27j";
sha256_x86_64 = "0hyzvvj4bf0r4jda8fv3k06d9bf37nji37qbq067mcjp5abc0zd4";
jceName = "jce_policy-8.zip";
jceDownloadUrl = http://www.oracle.com/technetwork/java/javase/downloads/jce8-download-2133166.html;
sha256JCE = "0n8b6b8qmwb14lllk2lk1q1ahd3za9fnjigz5xn65mpg48whl0pk";

6
pkgs/development/compilers/oraclejdk/jdk8psu-linux.nix
View File

@ -1,9 +1,9 @@
import ./jdk-linux-base.nix {
productVersion = "8";
patchVersion = "74";
patchVersion = "77";
downloadUrl = http://www.oracle.com/technetwork/java/javase/downloads/jdk8-downloads-2133151.html;
sha256_i686 = "1vc3g89fbrmznb10bhh5gs143hcjg4wsy4j4hwnr1djfj83y8188";
sha256_x86_64 = "1pfx7il1h42w3kigscdvm9vfy616lmsp1d2cqvplim3nyxwmvz8b";
sha256_i686 = "14hyniai5l9qpg0pbnxa4rhyhk90qgihszfkn8h3vziqhmvrp27j";
sha256_x86_64 = "0hyzvvj4bf0r4jda8fv3k06d9bf37nji37qbq067mcjp5abc0zd4";
jceName = "jce_policy-8.zip";
jceDownloadUrl = http://www.oracle.com/technetwork/java/javase/downloads/jce8-download-2133166.html;
sha256JCE = "0n8b6b8qmwb14lllk2lk1q1ahd3za9fnjigz5xn65mpg48whl0pk";

2
pkgs/development/compilers/rustc/generic.nix
View File

@ -166,7 +166,7 @@ with stdenv.lib; stdenv.mkDerivation {
buildInputs = [ ncurses ]
++ optional (!forceBundledLLVM) llvmShared;
enableParallelBuilding = true;
enableParallelBuilding = false; # missing files during linking, occasionally
outputs = [ "out" "doc" ];

16
pkgs/development/compilers/tinycc/default.nix
View File

@ -1,13 +1,19 @@
{ stdenv, fetchurl, perl, texinfo }:
{ stdenv, fetchurl, fetchgit, perl, texinfo }:
assert stdenv ? glibc;
stdenv.mkDerivation rec {
name = "tcc-0.9.26";
#name = "tcc-0.9.26";
name = "tcc-git-0.9.27pre-20160328";
src = fetchurl {
url = "mirror://savannah/tinycc/${name}.tar.bz2";
sha256 = "0wbdbdq6090ayw8bxnbikiv989kykff3m5rzbia05hrnwhd707jj";
#src = fetchurl {
# url = "mirror://savannah/tinycc/${name}.tar.bz2";
# sha256 = "0wbdbdq6090ayw8bxnbikiv989kykff3m5rzbia05hrnwhd707jj";
#};
src = fetchgit {
url = "git://repo.or.cz/tinycc.git";
rev = "80343ab7d829c21c65f8f9a14dd20158d028549f";
sha256 = "1bz75aj93ivb2d8hfk2bczsrwa56lv7vprvdi8c1r5phjvawbshy";
};
nativeBuildInputs = [ perl texinfo ];

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

@ -957,4 +957,9 @@ self: super: {
# We get lots of strange compiler errors during the test suite run.
jsaddle = dontCheck super.jsaddle;
# https://github.com/gwern/mueval/issues/14
mueval = super.mueval.override {
hint = self.hint_0_4_3;
};
}

63
pkgs/development/interpreters/erlang/R14.nix
View File

@ -1,63 +0,0 @@
{ stdenv, fetchurl, perl, gnum4, ncurses, openssl
, makeWrapper, gnused, gawk }:
let version = "14B04"; in
stdenv.mkDerivation {
name = "erlang-" + version;
src = fetchurl {
url = "http://www.erlang.org/download/otp_src_R${version}.tar.gz";
sha256 = "0vlvjlg8vzcy6inb4vj00bnj0aarvpchzxwhmi492nv31s8kb6q9";
};
buildInputs = [ perl gnum4 ncurses openssl makeWrapper ];
patchPhase = '' sed -i "s@/bin/rm@rm@" lib/odbc/configure erts/configure '';
preConfigure = ''
export HOME=$PWD/../
sed -e s@/bin/pwd@pwd@g -i otp_build
'';
configureFlags = "--with-ssl=${openssl}";
postInstall = let
manpages = fetchurl {
url = "http://www.erlang.org/download/otp_doc_man_R${version}.tar.gz";
sha256 = "1nh7l7wilyyaxvlwkjxgm3cq7wpd90sk6vxhgpvg7hwai8g52545";
};
in ''
tar xf "${manpages}" -C "$out/lib/erlang"
for i in "$out"/lib/erlang/man/man[0-9]/*.[0-9]; do
prefix="''${i%/*}"
ensureDir "$out/share/man/''${prefix##*/}"
ln -s "$i" "$out/share/man/''${prefix##*/}/''${i##*/}erl"
done
'';
# Some erlang bin/ scripts run sed and awk
postFixup = ''
wrapProgram $out/lib/erlang/bin/erl --prefix PATH ":" "${gnused}/bin/"
wrapProgram $out/lib/erlang/bin/start_erl --prefix PATH ":" "${gnused}/bin/:${gawk}/bin"
'';
setupHook = ./setup-hook.sh;
meta = {
homepage = "http://www.erlang.org/";
description = "Programming language used for massively scalable soft real-time systems";
longDescription = ''
Erlang is a programming language used to build massively scalable
soft real-time systems with requirements on high availability.
Some of its uses are in telecoms, banking, e-commerce, computer
telephony and instant messaging. Erlang's runtime system has
built-in support for concurrency, distribution and fault
tolerance.
'';
platforms = stdenv.lib.platforms.linux;
maintainers = [ stdenv.lib.maintainers.simons ];
};
}

13
pkgs/development/interpreters/luajit/default.nix
View File

@ -2,11 +2,12 @@
stdenv.mkDerivation rec {
name = "luajit-${version}";
version = "2.0.4";
version = "2.1.0-beta1";
luaversion = "5.1";
src = fetchurl {
url = "http://luajit.org/download/LuaJIT-${version}.tar.gz";
sha256 = "0zc0y7p6nx1c0pp4nhgbdgjljpfxsb5kgwp4ysz22l1p2bms83v2";
sha256 = "06170d38387c59d1292001a166e7f5524f5c5deafa8705a49a46fa42905668dd";
};
enableParallelBuilding = true;
@ -24,13 +25,17 @@ stdenv.mkDerivation rec {
configurePhase = false;
buildFlags = [ "amalg" ]; # Build highly optimized version
installPhase = "make install PREFIX=$out";
installPhase = ''
make install INSTALL_INC=$out/include PREFIX=$out
ln -s $out/bin/luajit* $out/bin/lua
ln -s $out/bin/luajit* $out/bin/luajit
'';
meta = with stdenv.lib; {
description = "high-performance JIT compiler for Lua 5.1";
homepage = http://luajit.org;
license = licenses.mit;
platforms = platforms.linux ++ platforms.darwin;
maintainers = [ maintainers.thoughtpolice ];
maintainers = with maintainers ; [ thoughtpolice smironov ];
};
}

8
pkgs/development/libraries/assimp/default.nix
View File

@ -1,4 +1,4 @@
{ stdenv, fetchurl, unzip, cmake, boost }:
{ stdenv, fetchurl, unzip, cmake, boost, zlib }:
let
major = "3";
@ -14,14 +14,14 @@ stdenv.mkDerivation {
sha256 = "17nyzsqzqpafamhi779f1bkh5mfgj8rpas034x3v9a0hdy3jg66s";
};
buildInputs = [ unzip cmake boost ];
buildInputs = [ unzip cmake boost zlib ];
meta = with stdenv.lib; {
description = "A library to import various 3D model formats";
homepage = http://assimp.sourceforge.net/;
license = licenses.bsd3;
maintainers = with maintainers; [ ehmry ];
platfroms = platforms.linux;
platfroms = [ platforms.linux platforms.darwin ];
inherit version;
};
}
}

24
pkgs/development/libraries/breakpad/default.nix Normal file
View File

@ -0,0 +1,24 @@
{ stdenv, fetchgit }:
stdenv.mkDerivation {
name = "breakpad-2016-03-28";
src = fetchgit {
url = "https://chromium.googlesource.com/breakpad/breakpad";
rev = "512cac3a1b69721ab727f3079f4d29e4580467b1";
sha256 = "0v7k7racdl2f16mbi3r0vkbkagh0gf6ksnpf3ri28b9pjfngkl5s";
};
breakpad_lss = fetchgit {
url = "https://chromium.googlesource.com/linux-syscall-support";
rev = "08056836f2b4a5747daff75435d10d649bed22f6";
sha256 = "1ryshs2nyxwa0kn3rlbnd5b3fhna9vqm560yviddcfgdm2jyg0hz";
};
enableParallelBuilding = true;
prePatch = ''
cp -r $breakpad_lss src/third_party/lss
chmod +w -R src/third_party/lss
'';
}

24
pkgs/development/libraries/cairo/default.nix
View File

@ -4,6 +4,7 @@
, xcbSupport ? true # no longer experimental since 1.12
, glSupport ? true, mesa_noglu ? null # mesa is no longer a big dependency
, pdfSupport ? true
, darwin
}:
assert glSupport -> mesa_noglu != null;
@ -11,14 +12,21 @@ assert glSupport -> mesa_noglu != null;
with { inherit (stdenv.lib) optional optionals; };
stdenv.mkDerivation rec {
name = "cairo-1.14.4";
name = "cairo-1.14.6";
src = fetchurl {
url = "http://cairographics.org/releases/${name}.tar.xz";
sha256 = "05p75r914d809711yg9rapgmmi4hymzbarhd3w0yrfadhiy9rv7n";
sha256 = "0lmjlzmghmr27y615px9hkm552x7ap6pmq9mfbzr6smp8y2b6g31";
};
nativeBuildInputs = [ pkgconfig libiconv ] ++ libintlOrEmpty;
nativeBuildInputs = [
pkgconfig
libiconv
] ++ libintlOrEmpty ++ optionals stdenv.isDarwin (with darwin.apple_sdk.frameworks; [
CoreGraphics
ApplicationServices
Carbon
]);
propagatedBuildInputs =
with xorg; [ xorg.xlibsWrapper fontconfig expat freetype pixman zlib libpng ]
@ -28,11 +36,17 @@ stdenv.mkDerivation rec {
++ optionals glSupport [ mesa_noglu ]
;
configureFlags = [ "--enable-tee" ]
configureFlags = if stdenv.isDarwin then [
"--disable-dependency-tracking"
"--enable-quartz"
"--enable-quartz-font"
"--enable-quartz-image"
"--enable-ft"
] else ([ "--enable-tee" ]
++ optional xcbSupport "--enable-xcb"
++ optional glSupport "--enable-gl"
++ optional pdfSupport "--enable-pdf"
;
);
preConfigure =
# On FreeBSD, `-ldl' doesn't exist.

33
pkgs/development/libraries/cl/default.nix Normal file
View File

@ -0,0 +1,33 @@
{stdenv, fetchurl, SDL, mesa, rebar, erlang, opencl-headers, ocl-icd }:
stdenv.mkDerivation rec {
version = "1.2.1";
name = "cl-${version}";
src = fetchurl {
url = "https://github.com/tonyrog/cl/archive/${name}.tar.gz";
sha256 = "03jv280h9gqqqkm0mmkjr53srd2mzhvyy1biss77wpjrzq2z12c8";
};
buildInputs = [ erlang rebar opencl-headers ocl-icd ];
#propagatedBuildInputs = [ SDL mesa ];
buildPhase = ''
sed 's/git/"${version}"/' -i src/cl.app.src
rebar compile
'';
# 'cp' line taken from Arch recipe
# https://projects.archlinux.org/svntogit/community.git/tree/trunk/PKGBUILD?h=packages/erlang-sdl
installPhase = ''
DIR=$out/lib/erlang/lib/${name}
mkdir -p $DIR
cp -ruv c_src doc ebin include priv src $DIR
'';
meta = {
homepage = https://github.com/tonyrog/cl;
description = "OpenCL binding for Erlang";
license = stdenv.lib.licenses.mit;
};
}

25
pkgs/development/libraries/dee/default.nix Normal file
View File

@ -0,0 +1,25 @@
{ stdenv, fetchurl, python, pkgconfig
, glib, icu, gobjectIntrospection }:
stdenv.mkDerivation rec {
name = "dee-${version}";
version = "1.2.7";
src = fetchurl {
url = "https://launchpad.net/dee/1.0/${version}/+download/${name}.tar.gz";
sha256 = "12mzffk0lyd566y46x57jlvb9af152b4dqpasr40zal4wrn37w0v";
};
buildInputs = [ glib gobjectIntrospection icu ];
nativeBuildInputs = [ python pkgconfig ];
enableParallelBuilding = true;
meta = with stdenv.lib; {
description = "A library that uses DBus to provide objects allowing you to create Model-View-Controller type programs across DBus";
homepage = "https://launchpad.net/dee";
license = licenses.lgpl3;
platforms = platforms.linux;
maintainers = with maintainers; [ abbradar ];
};
}

22
pkgs/development/libraries/esdl/default.nix
View File

@ -1,18 +1,26 @@
{stdenv, fetchurl, SDL, mesa, erlang}:
{stdenv, fetchurl, SDL, mesa, rebar, erlang}:
stdenv.mkDerivation rec {
name = "esdl-1.0.1";
name = "esdl-1.3.1";
src = fetchurl {
url = "mirror://sourceforge/esdl/${name}.src.tar.gz";
sha256 = "0zc7cmr44v10sb593dismdm5qc2v7sm3z9yh22g4r9g6asbg5z0n";
url = "mirror://sourceforge/esdl/${name}.src.tgz";
sha256 = "0f5ad519600qarsa2anmnaxh6b7djzx1dnwxzi4l36pxsq896y01";
};
buildInputs = [ erlang ];
buildInputs = [ erlang rebar ];
propagatedBuildInputs = [ SDL mesa ];
preBuild = ''
export makeFlags="INSTALLDIR=$out/lib/erlang/addons/${name}";
buildPhase = ''
rebar compile
'';
# 'cp' line taken from Arch recipe
# https://projects.archlinux.org/svntogit/community.git/tree/trunk/PKGBUILD?h=packages/erlang-sdl
installPhase = ''
DIR=$out/lib/erlang/lib/${name}
mkdir -p $DIR
cp -ruv c_src doc ebin include priv src $DIR
'';
meta = {

10
pkgs/development/libraries/freeimage/default.nix
View File

@ -1,9 +1,9 @@
{stdenv, fetchurl, unzip}:
stdenv.mkDerivation {
name = "freeimage-3.15.3";
name = "freeimage-3.17.0";
src = fetchurl {
url = mirror://sourceforge/freeimage/FreeImage3153.zip;
sha256 = "0i60fn1n9rw55dci0yw92zrw7k1jz3f9kv2z1wxmh84s5ngxa626";
url = mirror://sourceforge/freeimage/FreeImage3170.zip;
sha256 = "12bz57asdcfsz3zr9i9nska0fb6h3z2aizy412qjqkixkginbz7v";
};
buildInputs = [ unzip ];
prePatch = ''
@ -11,6 +11,10 @@ stdenv.mkDerivation {
-e 's@-o root -g root@@' \
-e 's@ldconfig@echo not running ldconfig@' \
-i Makefile.gnu Makefile.fip
# Fix gcc 5.1 macro problems
# https://chromium.googlesource.com/webm/libwebp/+/eebaf97f5a1cb713d81d311308d8a48c124e5aef%5E!/
sed -i -e 's/"\(#[^"]*\)"/" \1 "/g' Source/LibWebP/src/dsp/*
'';
postBuild = "make -f Makefile.fip";

1
pkgs/development/libraries/glib/default.nix
View File

@ -100,6 +100,7 @@ stdenv.mkDerivation rec {
substituteInPlace gio/tests/desktop-files/home/applications/epiphany-weather-for-toronto-island-9c6a4e022b17686306243dada811d550d25eb1fb.desktop --replace "Exec=/bin/true" "Exec=${coreutils}/bin/true"
# Needs machine-id, comment the test
sed -e '/\/gdbus\/codegen-peer-to-peer/ s/^\/*/\/\//' -i gio/tests/gdbus-peer.c
sed -e '/g_test_add_func/ s/^\/*/\/\//' -i gio/tests/gdbus-unix-addresses.c
# All gschemas fail to pass the test, upstream bug?
sed -e '/g_test_add_data_func/ s/^\/*/\/\//' -i gio/tests/gschema-compile.c
# Cannot reproduce the failing test_associations on hydra

26
pkgs/development/libraries/gobject-introspection/darwin-fixups.patch Normal file
View File

@ -0,0 +1,26 @@
diff -ur gobject-introspection-1.46.0-orig/giscanner/ccompiler.py gobject-introspection-1.46.0/giscanner/ccompiler.py
--- gobject-introspection-1.46.0-orig/giscanner/ccompiler.py 2016-02-01 12:25:41.000000000 -0500
+++ gobject-introspection-1.46.0/giscanner/ccompiler.py 2016-02-01 15:50:36.000000000 -0500
@@ -128,11 +128,7 @@
self.compiler.add_runtime_library_dir('.')
# https://bugzilla.gnome.org/show_bug.cgi?id=625195
- args.append('-Wl,-rpath=.')
-
- # Ensure libraries are always linked as we are going to use ldd to work
- # out their names later
- args.append('-Wl,--no-as-needed')
+ args.append('-Wl,-rpath,.')
for library in libraries:
self.compiler.add_library(library)
@@ -140,7 +136,7 @@
for library_path in libpaths:
args.append('-L' + library_path)
if os.path.isabs(library_path):
- args.append('-Wl,-rpath=' + library_path)
+ args.append('-Wl,-rpath,' + library_path)
else:
# libtool case: assemble linker command arguments, like we did before
Only in gobject-introspection-1.46.0/giscanner: ccompiler.py~

4
pkgs/development/libraries/gobject-introspection/default.nix
View File

@ -10,6 +10,7 @@ let
ver_maj = "1.46";
ver_min = "0";
in
with stdenv.lib;
stdenv.mkDerivation rec {
name = "gobject-introspection-${ver_maj}.${ver_min}";
@ -38,6 +39,9 @@ stdenv.mkDerivation rec {
patches = stdenv.lib.singleton (substituteAll {
src = ./absolute_shlib_path.patch;
inherit nixStoreDir;
}) ++ optional stdenv.isDarwin (substituteAll {
src = ./darwin-fixups.patch;
inherit nixStoreDir;
});
meta = with stdenv.lib; {

21
pkgs/development/libraries/gobject-introspection/separate-rpath-arg.patch Normal file
View File

@ -0,0 +1,21 @@
diff -ur gobject-introspection-1.46.0-orig/giscanner/ccompiler.py gobject-introspection-1.46.0/giscanner/ccompiler.py
--- gobject-introspection-1.46.0-orig/giscanner/ccompiler.py 2016-02-01 12:25:41.000000000 -0500
+++ gobject-introspection-1.46.0/giscanner/ccompiler.py 2016-02-01 12:26:52.000000000 -0500
@@ -128,7 +128,7 @@
self.compiler.add_runtime_library_dir('.')
# https://bugzilla.gnome.org/show_bug.cgi?id=625195
- args.append('-Wl,-rpath=.')
+ args.append('-Wl,-rpath,.')
# Ensure libraries are always linked as we are going to use ldd to work
# out their names later
@@ -140,7 +140,7 @@
for library_path in libpaths:
args.append('-L' + library_path)
if os.path.isabs(library_path):
- args.append('-Wl,-rpath=' + library_path)
+ args.append('-Wl,-rpath,' + library_path)
else:
# libtool case: assemble linker command arguments, like we did before

12
pkgs/development/libraries/gtk+/3.x.nix
View File

@ -3,11 +3,14 @@
, xlibs, x11, wayland, libxkbcommon, epoxy
, xineramaSupport ? stdenv.isLinux
, cupsSupport ? stdenv.isLinux, cups ? null
, darwin
}:
assert xineramaSupport -> xlibs.libXinerama != null;
assert cupsSupport -> cups != null;
with stdenv.lib;
let
ver_maj = "3.18";
ver_min = "5";
@ -27,6 +30,7 @@ stdenv.mkDerivation rec {
propagatedBuildInputs = with xlibs; with stdenv.lib;
[ expat glib cairo pango gdk_pixbuf atk at_spi2_atk libXrandr libXrender libXcomposite libXi libXcursor ]
++ optionals stdenv.isLinux [ wayland ]
++ optional stdenv.isDarwin (with darwin.apple_sdk.frameworks; [ AppKit Cocoa ])
++ optional xineramaSupport libXinerama
++ optional cupsSupport cups;
@ -37,6 +41,14 @@ stdenv.mkDerivation rec {
enableParallelBuilding = true;
configureFlags = optional stdenv.isDarwin [
"--disable-debug"
"--disable-dependency-tracking"
"--disable-glibtest"
"--with-gdktarget=quartz"
"--enable-quartz-backend"
];
postInstall = "rm -rf $out/share/gtk-doc";
passthru = {

23
pkgs/development/libraries/ignition-math/default.nix Normal file
View File

@ -0,0 +1,23 @@
{ stdenv, fetchurl, cmake }:
let
version = "2.3.0";
in
stdenv.mkDerivation rec {
name = "ign-math2-${version}";
src = fetchurl {
url = "http://gazebosim.org/distributions/ign-math/releases/ignition-math2-${version}.tar.bz2";
sha256 = "1a2jgq6allcxg62y0r61iv4hgxkfr1whpsxy75hg7k85s7da8dpl";
};
buildInputs = [ cmake ];
meta = with stdenv.lib; {
homepage = http://ignitionrobotics.org/libraries/math;
description = "Math library by Ingition Robotics, created for the Gazebo project";
license = licenses.asl20;
maintainers = with maintainers; [ pxc ];
platforms = platforms.all;
};
}

9
pkgs/development/libraries/ignition-transport/0.9.0.nix Normal file
View File

@ -0,0 +1,9 @@
{ stdenv, fetchurl, callPackage, ... } @ args :
callPackage ./generic.nix (args // rec {
version = "0.9.0";
src = fetchurl {
url = "http://gazebosim.org/distributions/ign-transport/releases/ignition-transport-${version}.tar.bz2";
sha256 = "15a8lkxri8q2gc7h0pj1dg2kivhy46v8d3mlxpjy90l77788bw1z";
};
})

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