JakeHillion/nixpkgs
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge branch 'staging-next' into staging

Browse Source
This commit is contained in:
Jan Tojnar 2020-05-18 21:09:48 +02:00
commit f8a9c6efac
No known key found for this signature in database
GPG Key ID: 7FAB2A15F7A607A4
501 changed files with 11984 additions and 6526 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

25
.github/CODEOWNERS vendored
View File

@ -55,6 +55,13 @@
# NixOS integration test driver
/nixos/lib/test-driver @tfc
# Updaters
## update.nix
/maintainers/scripts/update.nix @jtojnar
/maintainers/scripts/update.py @jtojnar
## common-updater-scripts
/pkgs/common-updater/scripts/update-source-version @jtojnar
# Python-related code and docs
/maintainers/scripts/update-python-libraries @FRidh
/pkgs/top-level/python-packages.nix @FRidh @jonringer
@ -174,9 +181,15 @@
/nixos/modules/services/monitoring/prometheus/exporters.xml @WilliButz
/nixos/tests/prometheus-exporters.nix @WilliButz
# PHP
/doc/languages-frameworks/php.section.md @etu
/nixos/tests/php @etu
/pkgs/build-support/build-pecl.nix @etu
/pkgs/development/interpreters/php @etu
/pkgs/top-level/php-packages.nix @etu
# PHP interpreter, packages, extensions, tests and documentation
/doc/languages-frameworks/php.section.md @NixOS/php
/nixos/tests/php @NixOS/php
/pkgs/build-support/build-pecl.nix @NixOS/php
/pkgs/development/interpreters/php @NixOS/php
/pkgs/top-level/php-packages.nix @NixOS/php
# Podman, CRI-O modules and related
/nixos/modules/virtualisation/containers.nix @NixOS/podman
/nixos/modules/virtualisation/cri-o.nix @NixOS/podman
/nixos/modules/virtualisation/podman.nix @NixOS/podman
/nixos/tests/podman.nix @NixOS/podman

96
doc/languages-frameworks/agda.section.md Normal file
View File

@ -0,0 +1,96 @@
---
title: Agda
author: Alex Rice (alexarice)
date: 2020-01-06
---
# Agda
## How to use Agda
Agda can be installed from `agda`:
```
$ nix-env -iA agda
```
To use agda with libraries, the `agda.withPackages` function can be used. This function either takes:
+ A list of packages,
+ or a function which returns a list of packages when given the `agdaPackages` attribute set,
+ or an attribute set containing a list of packages and a GHC derivation for compilation (see below).
For example, suppose we wanted a version of agda which has access to the standard library. This can be obtained with the expressions:
```
agda.withPackages [ agdaPackages.standard-library ]
```
or
```
agda.withPackages (p: [ p.standard-library ])
```
or can be called as in the [Compiling Agda](#compiling-agda) section.
If you want to use a library in your home directory (for instance if it is a development version) then typecheck it manually (using `agda.withPackages` if necessary) and then override the `src` attribute of the package to point to your local repository.
Agda will not by default use these libraries. To tell agda to use the library we have some options:
- Call `agda` with the library flag:
```
$ agda -l standard-library -i . MyFile.agda
```
- Write a `my-library.agda-lib` file for the project you are working on which may look like:
```
name: my-library
include: .
depends: standard-library
```
- Create the file `~/.agda/defaults` and add any libraries you want to use by default.
More information can be found in the [official Agda documentation on library management](https://agda.readthedocs.io/en/v2.6.1/tools/package-system.html).
## Compiling Agda
Agda modules can be compiled with the `--compile` flag. A version of `ghc` with `ieee` is made available to the Agda program via the `--with-compiler` flag.
This can be overridden by a different version of `ghc` as follows:
```
agda.withPackages {
pkgs = [ ... ];
ghc = haskell.compiler.ghcHEAD;
}
```
## Writing Agda packages
To write a nix derivation for an agda library, first check that the library has a `*.agda-lib` file.
A derivation can then be written using `agdaPackages.mkDerivation`. This has similar arguments to `stdenv.mkDerivation` with the following additions:
+ `everythingFile` can be used to specify the location of the `Everything.agda` file, defaulting to `./Everything.agda`. If this file does not exist then either it should be patched in or the `buildPhase` should be overridden (see below).
+ `libraryName` should be the name that appears in the `*.agda-lib` file, defaulting to `pname`.
+ `libraryFile` should be the file name of the `*.agda-lib` file, defaulting to `${libraryName}.agda-lib`.
The build phase for `agdaPackages.mkDerivation` simply runs `agda` on the `Everything.agda` file. If something else is needed to build the package (e.g. `make`) then the `buildPhase` should be overridden (or a `preBuild` or `configurePhase` can be used if there are steps that need to be done prior to checking the `Everything.agda` file). `agda` and the Agda libraries contained in `buildInputs` are made available during the build phase. The install phase simply copies all `.agda`, `.agdai` and `.agda-lib` files to the output directory. Again, this can be overridden.
To add an agda package to `nixpkgs`, the derivation should be written to `pkgs/development/libraries/agda/${library-name}/` and an entry should be added to `pkgs/top-level/agda-packages.nix`. Here it is called in a scope with access to all other agda libraries, so the top line of the `default.nix` can look like:
```
{ mkDerivation, standard-library, fetchFromGitHub }:
```
and `mkDerivation` should be called instead of `agdaPackages.mkDerivation`. Here is an example skeleton derivation for iowa-stdlib:
```
mkDerivation {
version = "1.5.0";
pname = "iowa-stdlib";
src = ...
libraryFile = "";
libraryName = "IAL-1.3";
buildPhase = ''
patchShebangs find-deps.sh
make
'';
}
```
This library has a file called `.agda-lib`, and so we give an empty string to `libraryFile` as nothing precedes `.agda-lib` in the filename. This file contains `name: IAL-1.3`, and so we let `libraryName = "IAL-1.3"`. This library does not use an `Everything.agda` file and instead has a Makefile, so there is no need to set `everythingFile` and we set a custom `buildPhase`.
When writing an agda package it is essential to make sure that no `.agda-lib` file gets added to the store as a single file (for example by using `writeText`). This causes agda to think that the nix store is a agda library and it will attempt to write to it whenever it typechecks something. See [https://github.com/agda/agda/issues/4613](https://github.com/agda/agda/issues/4613).

14
doc/languages-frameworks/go.xml
View File

@ -36,7 +36,7 @@ pet = buildGoModule rec {
sha256 = "0m2fzpqxk7hrbxsgqplkg7h2p7gv6s1miymv3gvw0cz039skag0s";
};
modSha256 = "1879j77k96684wi554rkjxydrj8g3hpp0kvxz03sd8dmwr3lh83j"; <co xml:id='ex-buildGoModule-1' />
vendorSha256 = "1879j77k96684wi554rkjxydrj8g3hpp0kvxz03sd8dmwr3lh83j"; <co xml:id='ex-buildGoModule-1' />
subPackages = [ "." ]; <co xml:id='ex-buildGoModule-2' />
@ -56,7 +56,7 @@ pet = buildGoModule rec {
<calloutlist>
<callout arearefs='ex-buildGoModule-1'>
<para>
<varname>modSha256</varname> is the hash of the output of the intermediate fetcher derivation.
<varname>vendorSha256</varname> is the hash of the output of the intermediate fetcher derivation.
</para>
</callout>
<callout arearefs='ex-buildGoModule-2'>
@ -68,12 +68,12 @@ pet = buildGoModule rec {
</para>
<para>
<varname>modSha256</varname> can also take <varname>null</varname> as an input.
<varname>vendorSha256</varname> can also take <varname>null</varname> as an input.
When `null` is used as a value, the derivation won't be a
fixed-output derivation but disable the build sandbox instead. This can be useful outside
of nixpkgs where re-generating the modSha256 on each mod.sum changes is cumbersome,
but will fail to build by Hydra, as builds with a disabled sandbox are discouraged.
When `null` is used as a value, rather than fetching the dependencies
and vendoring them, we use the vendoring included within the source repo.
If you'd like to not have to update this field on dependency changes,
run `go mod vendor` in your source repo and set 'vendorSha256 = null;'
</para>
</section>

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

@ -5,6 +5,7 @@
<para>
The <link linkend="chap-stdenv">standard build environment</link> makes it easy to build typical Autotools-based packages with very little code. Any other kind of package can be accomodated by overriding the appropriate phases of <literal>stdenv</literal>. However, there are specialised functions in Nixpkgs to easily build packages for other programming languages, such as Perl or Haskell. These are described in this chapter.
</para>
<xi:include href="agda.section.xml" />
<xi:include href="android.section.xml" />
<xi:include href="beam.xml" />
<xi:include href="bower.xml" />

486
doc/languages-frameworks/python.section.md
View File

@ -36,66 +36,288 @@ The Nix and NixOS manuals explain how packages are generally installed. In the
case of Python and Nix, it is important to make a distinction between whether the
package is considered an application or a library.
Applications on Nix are typically installed 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.
Applications on Nix are typically installed 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 for
development cannot be installed, at least not individually, because they won't
be able to find each other resulting in import errors. Instead, it is possible
to create an environment with `python.buildEnv` or `python.withPackages` where
the interpreter and other executables are able to find each other and all of the
modules.
The same goes for Python applications. Python applications can be installed in
your profile, and will be wrapped to find their exact library dependencies,
without impacting other applications or polluting your user environment.
In the following examples we create an environment with Python 3.8, `numpy` and
`toolz`. As you may imagine, there is one limitation here, and that's that
you can install only one environment at a time. You will notice the complaints
about collisions when you try to install a second environment.
But Python libraries you would like to use for development cannot be installed,
at least not individually, because they won't be able to find each other
resulting in import errors. Instead, it is possible to create an environment
with `python.buildEnv` or `python.withPackages` where the interpreter and other
executables are wrapped to be able to find each other and all of the modules.
##### Environment defined in separate `.nix` file
In the following examples we will start by creating a simple, ad-hoc environment
with a nix-shell that has `numpy` and `toolz` in Python 3.8; then we will create
a re-usable environment in a single-file Python script; then we will create a
full Python environment for development with this same environment.
Philosphically, this should be familiar to users who are used to a `venv` style
of development: individual projects create their own Python environments without
impacting the global environment or each other.
#### Ad-hoc temporary Python environment with `nix-shell`
The simplest way to start playing with the way nix wraps and sets up Python
environments is with `nix-shell` at the cmdline. These environments create a
temporary shell session with a Python and a *precise* list of packages (plus
their runtime dependencies), with no other Python packages in the Python
interpreter's scope.
To create a Python 3.8 session with `numpy` and `toolz` available, run:
```sh
$ nix-shell -p 'python38.withPackages(ps: with ps; [ numpy toolz ])'
```
By default `nix-shell` will start a `bash` session with this interpreter in our
`PATH`, so if we then run:
```
[nix-shell:~/src/nixpkgs]$ python3
Python 3.8.1 (default, Dec 18 2019, 19:06:26)
[GCC 9.2.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> import numpy; import toolz
```
Note that no other modules are in scope, even if they were imperatively
installed into our user environment as a dependency of a Python application:
```
>>> import requests
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ModuleNotFoundError: No module named 'requests'
```
We can add as many additional modules onto the `nix-shell` as we need, and we
will still get 1 wrapped Python interpreter. We can start the interpreter
directly like so:
```sh
$ nix-shell -p 'python38.withPackages(ps: with ps; [ numpy toolz requests ])' --run python3
these derivations will be built:
/nix/store/xbdsrqrsfa1yva5s7pzsra8k08gxlbz1-python3-3.8.1-env.drv
building '/nix/store/xbdsrqrsfa1yva5s7pzsra8k08gxlbz1-python3-3.8.1-env.drv'...
created 277 symlinks in user environment
Python 3.8.1 (default, Dec 18 2019, 19:06:26)
[GCC 9.2.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> import requests
>>>
```
Notice that this time it built a new Python environment, which now includes
`requests`. Building an environment just creates wrapper scripts that expose the
selected dependencies to the interpreter while re-using the actual modules. This
means if any other env has installed `requests` or `numpy` in a different
context, we don't need to recompile them -- we just recompile the wrapper script
that sets up an interpreter pointing to them. This matters much more for "big"
modules like `pytorch` or `tensorflow`.
Module names usually match their names on [pypi.org](https://pypi.org/), but
you can use the [Nixpkgs search website](https://nixos.org/nixos/packages.html)
to find them as well (along with non-python packages).
At this point we can create throwaway experimental Python environments with
arbitrary dependencies. This is a good way to get a feel for how the Python
interpreter and dependencies work in Nix and NixOS, but to do some actual
development, we'll want to make it a bit more persistent.
##### Running Python scripts and using `nix-shell` as shebang
Sometimes, we have a script whose header looks like this:
```python
#!/usr/bin/env python3
import numpy as np
a = np.array([1,2])
b = np.array([3,4])
print(f"The dot product of {a} and {b} is: {np.dot(a, b)}")
```
Executing this script requires a `python3` that has `numpy`. Using what we learned
in the previous section, we could startup a shell and just run it like so:
```
nix-shell -p 'python38.withPackages(ps: with ps; [ numpy ])' --run 'python3 foo.py'
The dot product of [1 2] and [3 4] is: 11
```
But if we maintain the script ourselves, and if there are more dependencies, it
may be nice to encode those dependencies in source to make the script re-usable
without that bit of knowledge. That can be done by using `nix-shell` as a
[shebang](https://en.wikipedia.org/wiki/Shebang_(Unix), like so:
```python
#!/usr/bin/env nix-shell
#!nix-shell -i python3 -p "python3.withPackages(ps: [ ps.numpy ])"
import numpy as np
a = np.array([1,2])
b = np.array([3,4])
print(f"The dot product of {a} and {b} is: {np.dot(a, b)}")
```
Then we simply execute it, without requiring any environment setup at all!
```sh
$ ./foo.py
The dot product of [1 2] and [3 4] is: 11
```
If the dependencies are not available on the host where `foo.py` is executed, it
will build or download them from a Nix binary cache prior to starting up, prior
that it is executed on a machine with a multi-user nix installation.
This provides a way to ship a self bootstrapping Python script, akin to a
statically linked binary, where it can be run on any machine (provided nix is
installed) without having to assume that `numpy` is installed globally on the
system.
By default it is pulling the import checkout of Nixpkgs itself from our nix
channel, which is nice as it cache aligns with our other package builds, but we
can make it fully reproducible by pinning the `nixpkgs` import:
```python
#!/usr/bin/env nix-shell
#!nix-shell -i python3 -p "python3.withPackages(ps: [ ps.numpy ])"
#!nix-shell -I nixpkgs=https://github.com/NixOS/nixpkgs/archive/d373d80b1207d52621961b16aa4a3438e4f98167.tar.gz
import numpy as np
a = np.array([1,2])
b = np.array([3,4])
print(f"The dot product of {a} and {b} is: {np.dot(a, b)}")
```
This will execute with the exact same versions of Python 3.8, numpy, and system
dependencies a year from now as it does today, because it will always use
exactly git commit `d373d80b1207d52621961b16aa4a3438e4f98167` of Nixpkgs for all
of the package versions.
This is also a great way to ensure the script executes identically on different
servers.
##### Load environment from `.nix` expression
We've now seen how to create an ad-hoc temporary shell session, and how to
create a single script with Python dependencies, but in the course of normal
development we're usually working in an entire package repository.
As explained in the Nix manual, `nix-shell` can also load an expression from a
`.nix` file. Say we want to have Python 3.8, `numpy` and `toolz`, like before,
in an environment. We can add a `shell.nix` file describing our dependencies:
Create a file, e.g. `build.nix`, with the following expression
```nix
with import <nixpkgs> {};
python38.withPackages (ps: with ps; [ numpy toolz ])
(python38.withPackages (ps: [ps.numpy ps.toolz])).env
```
and install it in your profile with
```shell
nix-env -if build.nix
```
Now you can use the Python interpreter, as well as the extra packages (`numpy`,
`toolz`) that you added to the environment.
##### Environment defined in `~/.config/nixpkgs/config.nix`
And then at the command line, just typing `nix-shell` produces the same
environment as before. In a normal project, we'll likely have many more
dependencies; this can provide a way for developers to share the environments
with each other and with CI builders.
If you prefer you could also add the environment as a package override to the
Nixpkgs set, e.g. using `config.nix`,
What's happening here?
1. We begin with importing the Nix Packages collections. `import <nixpkgs>`
imports the `<nixpkgs>` function, `{}` calls it and the `with` statement
brings all attributes of `nixpkgs` in the local scope. These attributes form
the main package set.
2. Then we create a Python 3.8 environment with the `withPackages` function, as before.
3. The `withPackages` function expects us to provide a function as an argument
that takes the set of all Python packages and returns a list of packages to
include in the environment. Here, we select the packages `numpy` and `toolz`
from the package set.
To combine this with `mkShell` you can:
```nix
{ # ...
with import <nixpkgs> {};
let
pythonEnv = python38.withPackages (ps: [
ps.numpy
ps.toolz
]);
in mkShell {
buildInputs = [
pythonEnv
packageOverrides = pkgs: with pkgs; {
myEnv = python38.withPackages (ps: with ps; [ numpy toolz ]);
black
mypy
libffi
openssl
];
}
```
This will create a unified environment that has not just our Python interpreter
and its Python dependencies, but also tools like `black` or `mypy` and libraries
like `libffi` the `openssl` in scope. This is generic and can span any number of
tools or languages across the Nixpkgs ecosystem.
##### Installing environments globally on the system
Up to now, we've been creating environments scoped to an ad-hoc shell session,
or a single script, or a single project. This is generally advisable, as it
avoids pollution across contexts.
However, sometimes we know we will often want a Python with some basic packages,
and want this available without having to enter into a shell or build context.
This can be useful to have things like vim/emacs editors and plugins or shell
tools "just work" without having to set them up, or when running other software
that expects packages to be installed globally.
To create your own custom environment, create a file in `~/.config/nixpkgs/overlays/`
that looks like this:
```nix
# ~/.config/nixpkgs/overlays/myEnv.nix
self: super: {
myEnv = super.buildEnv {
name = "myEnv";
paths = [
# A Python 3 interpreter with some packages
(self.python3.withPackages (
ps: with ps; [
pyflakes
pytest
python-language-server
]
))
# Some other packages we'd like as part of this env
self.mypy
self.black
self.ripgrep
self.tmux
];
};
}
```
and install it in your profile with
```shell
nix-env -iA nixpkgs.myEnv
You can then build and install this to your profile with:
```sh
nix-env -iA myEnv
```
The environment is is installed by referring to the attribute, and considering
the `nixpkgs` channel was used.
One limitation of this is that you can only have 1 Python env installed
globally, since they conflict on the `python` to load out of your `PATH`.
If you get a conflict or prefer to keep the setup clean, you can have `nix-env`
atomically *uninstall* all other imperatively installed packages and replace
your profile with just `myEnv` by using the `--replace` flag.
##### Environment defined in `/etc/nixos/configuration.nix`
For the sake of completeness, here's another example how to install the
environment system-wide.
For the sake of completeness, here's how to install the environment system-wide
on NixOS.
```nix
{ # ...
@ -106,121 +328,16 @@ environment system-wide.
}
```
#### Temporary Python environment with `nix-shell`
The examples in the previous section showed how to install a Python environment
into a profile. For development you may need to use multiple environments.
`nix-shell` gives the possibility to temporarily load another environment, akin
to `virtualenv`.
There are two methods for loading a shell with Python packages. The first and
recommended method is to create an environment with `python.buildEnv` or
`python.withPackages` and load that. E.g.
```sh
$ nix-shell -p 'python38.withPackages(ps: with ps; [ numpy toolz ])'
```
opens a shell from which you can launch the interpreter
```sh
[nix-shell:~] python3
```
The other method, which is not recommended, does not create an environment and
requires you to list the packages directly,
```sh
$ nix-shell -p python38.pkgs.numpy python38.pkgs.toolz
```
Again, it is possible to launch the interpreter from the shell. The Python
interpreter has the attribute `pkgs` which contains all Python libraries for
that specific interpreter.
##### Load environment from `.nix` expression
As explained in the Nix manual, `nix-shell` can also load an
expression from a `.nix` file. Say we want to have Python 3.8, `numpy`
and `toolz`, like before, in an environment. Consider a `shell.nix` file
with
```nix
with import <nixpkgs> {};
(python38.withPackages (ps: [ps.numpy ps.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>`
imports the `<nixpkgs>` function, `{}` calls it and the `with` statement
brings all attributes of `nixpkgs` in the local scope. These attributes form
the main package set.
2. Then we create a Python 3.8 environment with the `withPackages` function.
3. The `withPackages` function expects us to provide a function as an argument
that takes the set of all python packages and returns a list of packages to
include in the environment. Here, we select the packages `numpy` and `toolz`
from the package set.
To combine this with `mkShell` you can:
```nix
with import <nixpkgs> {};
let
pythonEnv = python38.withPackages (ps: [
ps.numpy
ps.toolz
]);
in mkShell {
buildInputs = [
pythonEnv
hello
];
}
```
##### Execute command with `--run`
A convenient option with `nix-shell` is the `--run`
option, with which you can execute a command in the `nix-shell`. We can
e.g. directly open a Python shell
```sh
$ nix-shell -p python38Packages.numpy python38Packages.toolz --run "python3"
```
or run a script
```sh
$ nix-shell -p python38Packages.numpy python38Packages.toolz --run "python3 myscript.py"
```
##### `nix-shell` as shebang
In fact, for the second 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 just execute `./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 "python3.withPackages(ps: [ps.numpy])"
import numpy
print(numpy.__version__)
```
### Developing with Python
Now that you know how to get a working Python environment with 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 at how you
can use development mode with your code.
Above, we were mostly just focused on use cases and what to do to get started
creating working Python environments in nix.
#### Packaging a library
Now that you know the basics to be up and running, it is time to take a step
back and take a deeper look at at how Python packages are packaged on Nix. Then,
we will look at how you can use development mode with your code.
#### Python library packages in Nixpkgs
With Nix all packages are built by functions. The main function in Nix for
building Python libraries is `buildPythonPackage`. Let's see how we can build the
@ -262,6 +379,7 @@ An expression for `toolz` can be found in the Nixpkgs repository. As explained
in the introduction of this Python section, a derivation of `toolz` is available
for each interpreter version, e.g. `python38.pkgs.toolz` refers to the `toolz`
derivation corresponding to the CPython 3.8 interpreter.
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.
@ -312,7 +430,7 @@ Our example, `toolz`, does not 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
included in `buildInputs`, but if it is (also) a runtime dependency, then it
should be added to `propagatedBuildInputs`. Test dependencies are considered
build-time dependencies and passed to `checkInputs`.
@ -423,10 +541,11 @@ Note also the line `doCheck = false;`, we explicitly disabled running the test-s
#### Develop local package
As a Python developer you're likely aware of [development mode](http://setuptools.readthedocs.io/en/latest/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. Let's see how you can use it.
As a Python developer you're likely aware of [development mode](http://setuptools.readthedocs.io/en/latest/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. 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 `src = ./path/to/source/tree;`
@ -455,7 +574,6 @@ buildPythonPackage rec {
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
@ -481,11 +599,11 @@ We first create a function that builds `toolz` in `~/path/to/toolz/release.nix`
buildPythonPackage rec {
pname = "toolz";
version = "0.7.4";
version = "0.10.0";
src = fetchPypi {
inherit pname version;
sha256 = "43c2c9e5e7a16b6c88ba3088a9bfc82f7db8e13378be7c78d6c14a5f8ed05afd";
sha256 = "08fdd5ef7c96480ad11c12d472de21acd32359996f69a5259299b540feba4560";
};
meta = with lib; {
@ -497,8 +615,8 @@ buildPythonPackage rec {
}
```
It takes an argument `buildPythonPackage`.
We now call this function using `callPackage` in the definition of our environment
It takes an argument `buildPythonPackage`. We now call this function using
`callPackage` in the definition of our environment
```nix
with import <nixpkgs> {};
@ -548,7 +666,7 @@ Each interpreter has the following attributes:
- `buildEnv`. Function to build python interpreter environments with extra packages bundled together. See section *python.buildEnv function* for usage and documentation.
- `withPackages`. Simpler interface to `buildEnv`. See section *python.withPackages function* for usage and documentation.
- `sitePackages`. Alias for `lib/${libPrefix}/site-packages`.
- `executable`. Name of the interpreter executable, e.g. `python3.7`.
- `executable`. Name of the interpreter executable, e.g. `python3.8`.
- `pkgs`. Set of Python packages for that specific interpreter. The package set can be modified by overriding the interpreter and passing `packageOverrides`.
### Building packages and applications
@ -643,7 +761,7 @@ following are specific to `buildPythonPackage`:
appears more than once in dependency tree. Default is `true`.
* `disabled` ? false: If `true`, package is not built for the particular Python
interpreter version.
* `dontWrapPythonPrograms ? false`: Skip wrapping of python programs.
* `dontWrapPythonPrograms ? false`: Skip wrapping of Python programs.
* `permitUserSite ? false`: Skip setting the `PYTHONNOUSERSITE` environment
variable in wrapped programs.
* `installFlags ? []`: A list of strings. Arguments to be passed to `pip
@ -730,7 +848,7 @@ Another difference is that `buildPythonPackage` by default prefixes the names of
the packages with the version of the interpreter. Because this is irrelevant for
applications, the prefix is omitted.
When packaging a python application with `buildPythonApplication`, it should be
When packaging a Python application with `buildPythonApplication`, it should be
called with `callPackage` and passed `python` or `pythonPackages` (possibly
specifying an interpreter version), like this:
@ -761,7 +879,7 @@ luigi = callPackage ../applications/networking/cluster/luigi { };
```
Since the package is an application, a consumer doesn't need to care about
python versions or modules, which is why they don't go in `pythonPackages`.
Python versions or modules, which is why they don't go in `pythonPackages`.
#### `toPythonApplication` function
@ -875,7 +993,7 @@ thus be also written like this:
```nix
with import <nixpkgs> {};
(python36.withPackages (ps: [ps.numpy ps.requests])).env
(python38.withPackages (ps: [ps.numpy ps.requests])).env
```
In contrast to `python.buildEnv`, `python.withPackages` does not support the
@ -905,7 +1023,8 @@ are used in `buildPythonPackage`.
- `setuptoolsBuildHook` to build a wheel using `setuptools`.
- `setuptoolsCheckHook` to run tests with `python setup.py test`.
- `venvShellHook` to source a Python 3 `venv` at the `venvDir` location. A
`venv` is created if it does not yet exist.
`venv` is created if it does not yet exist. `postVenvCreation` can be used to
to run commands only after venv is first created.
- `wheelUnpackHook` to move a wheel to the correct folder so it can be installed
with the `pipInstallHook`.
@ -932,7 +1051,7 @@ pythonPackages.buildPythonPackage {
Running `nix-shell` with no arguments should give you the environment in which
the package would be built with `nix-build`.
Shortcut to setup environments with C headers/libraries and python packages:
Shortcut to setup environments with C headers/libraries and Python packages:
```shell
nix-shell -p pythonPackages.pyramid zlib libjpeg git
@ -963,7 +1082,6 @@ have timestamp 1. The `buildPythonPackage` function sets `DETERMINISTIC_BUILD=1`
and [PYTHONHASHSEED=0](https://docs.python.org/3.8/using/cmdline.html#envvar-PYTHONHASHSEED).
Both are also exported in `nix-shell`.
### Automatic tests
It is recommended to test packages as part of the build process.
@ -976,7 +1094,7 @@ example of such a situation is when `py.test` is used.
#### Common issues
* Non-working tests can often be deselected. By default `buildPythonPackage`
runs `python setup.py test`. Most python modules follows the standard test
runs `python setup.py test`. Most Python modules follows the standard test
protocol where the pytest runner can be used instead. `py.test` supports a
`-k` parameter to ignore test methods or classes:
@ -1052,7 +1170,7 @@ let
newpkgs = import pkgs.path { overlays = [ (self: super: {
python38 = let
packageOverrides = python-self: python-super: {
numpy = python-super.numpy_1_18.3;
numpy = python-super.numpy_1_18;
};
in super.python38.override {inherit packageOverrides;};
} ) ]; };
@ -1127,14 +1245,14 @@ 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.
### How to consume python modules using pip in a virtual environment like I am used to on other Operating Systems?
### How to consume Python modules using pip in a virtual environment like I am used to on other Operating Systems?
While this approach is not very idiomatic from Nix perspective, it can still be
useful when dealing with pre-existing projects or in situations where it's not
feasible or desired to write derivations for all required dependencies.
This is an example of a `default.nix` for a `nix-shell`, which allows to consume
a virtual environment created by `venv`, and install python modules through
a virtual environment created by `venv`, and install Python modules through
`pip` the traditional way.
Create this `default.nix` file, together with a `requirements.txt` and simply
@ -1149,7 +1267,7 @@ in pkgs.mkShell rec {
name = "impurePythonEnv";
venvDir = "./.venv";
buildInputs = [
# A python interpreter including the 'venv' module is required to bootstrap
# A Python interpreter including the 'venv' module is required to bootstrap
# the environment.
pythonPackages.python
@ -1163,7 +1281,7 @@ in pkgs.mkShell rec {
pythonPackages.requests
# In this particular example, in order to compile any binary extensions they may
# require, the python modules listed in the hypothetical requirements.txt need
# require, the Python modules listed in the hypothetical requirements.txt need
# the following packages to be installed locally:
taglib
openssl
@ -1174,16 +1292,23 @@ in pkgs.mkShell rec {
zlib
];
# Run this command, only after creating the virtual environment
postVenvCreation = ''
unset SOURCE_DATE_EPOCH
pip install -r requirements.txt
'';
# Now we can execute any commands within the virtual environment.
# This is optional and can be left out to run pip manually.
postShellHook = ''
pip install -r requirements.txt
# allow pip to install wheels
unset SOURCE_DATE_EPOCH
'';
}
```
In case the supplied venvShellHook is insufficient, or when python 2 support is
In case the supplied venvShellHook is insufficient, or when Python 2 support is
needed, you can define your own shell hook and adapt to your needs like in the
following example:
@ -1229,7 +1354,7 @@ in pkgs.mkShell rec {
```
Note that the `pip install` is an imperative action. So every time `nix-shell`
is executed it will attempt to download the python modules listed in
is executed it will attempt to download the Python modules listed in
requirements.txt. However these will be cached locally within the `virtualenv`
folder and not downloaded again.
@ -1290,9 +1415,8 @@ self: super: {
### How to use Intel's MKL with numpy and scipy?
MKL can be configured using an overlay. See the section “[Using
overlays to configure
alternatives](#sec-overlays-alternatives-blas-lapack)”.
MKL can be configured using an overlay. See the section "[Using overlays to
configure alternatives](#sec-overlays-alternatives-blas-lapack)".
### What inputs do `setup_requires`, `install_requires` and `tests_require` map to?

12
maintainers/maintainer-list.nix
View File

@ -1280,6 +1280,12 @@
githubId = 64804;
name = "Dennis Gosnell";
};
ccellado = {
email = "annplague@gmail.com";
github = "ccellado";
githubId = 44584960;
name = "Denis Khalmatov";
};
ceedubs = {
email = "ceedubs@gmail.com";
github = "ceedubs";
@ -8301,6 +8307,12 @@
githubId = 54934;
name = "Wout Mertens";
};
wnklmnn = {
email = "pascal@wnklmnn.de";
github = "wnklmnn";
githubId = 9423014;
name = "Pascal Winkelmann";
};
woffs = {
email = "github@woffs.de";
github = "woffs";

79
maintainers/scripts/update.nix
View File

@ -9,6 +9,10 @@
# TODO: add assert statements
let
pkgs = import ./../../default.nix (if include-overlays then { } else { overlays = []; });
inherit (pkgs) lib;
/* Remove duplicate elements from the list based on some extracted value. O(n^2) complexity.
*/
nubOn = f: list:
@ -16,43 +20,44 @@ let
[]
else
let
x = pkgs.lib.head list;
xs = pkgs.lib.filter (p: f x != f p) (pkgs.lib.drop 1 list);
x = lib.head list;
xs = lib.filter (p: f x != f p) (lib.drop 1 list);
in
[x] ++ nubOn f xs;
pkgs = import ./../../default.nix (if include-overlays then { } else { overlays = []; });
packagesWithPath = relativePath: cond: return: pathContent:
let
result = builtins.tryEval pathContent;
packagesWith = cond: return: set:
nubOn (pkg: pkg.updateScript)
(pkgs.lib.flatten
(pkgs.lib.mapAttrsToList
(name: pkg:
let
result = builtins.tryEval (
if pkgs.lib.isDerivation pkg && cond name pkg
then [(return name pkg)]
else if pkg.recurseForDerivations or false || pkg.recurseForRelease or false
then packagesWith cond return pkg
else []
);
in
if result.success then result.value
else []
)
set
)
);
dedupResults = lst: nubOn (pkg: pkg.updateScript) (lib.concatLists lst);
in
if result.success then
let
pathContent = result.value;
in
if lib.isDerivation pathContent then
lib.optional (cond relativePath pathContent) (return relativePath pathContent)
else if lib.isAttrs pathContent then
# If user explicitly points to an attrSet or it is marked for recursion, we recur.
if relativePath == [] || pathContent.recurseForDerivations or false || pathContent.recurseForRelease or false then
dedupResults (lib.mapAttrsToList (name: elem: packagesWithPath (relativePath ++ [name]) cond return elem) pathContent)
else []
else if lib.isList pathContent then
dedupResults (lib.imap0 (i: elem: packagesWithPath (relativePath ++ [i]) cond return elem) pathContent)
else []
else [];
packagesWith = packagesWithPath [];
packagesWithUpdateScriptAndMaintainer = maintainer':
let
maintainer =
if ! builtins.hasAttr maintainer' pkgs.lib.maintainers then
if ! builtins.hasAttr maintainer' lib.maintainers then
builtins.throw "Maintainer with name `${maintainer'} does not exist in `maintainers/maintainer-list.nix`."
else
builtins.getAttr maintainer' pkgs.lib.maintainers;
builtins.getAttr maintainer' lib.maintainers;
in
packagesWith (name: pkg: builtins.hasAttr "updateScript" pkg &&
packagesWith (relativePath: pkg: builtins.hasAttr "updateScript" pkg &&
(if builtins.hasAttr "maintainers" pkg.meta
then (if builtins.isList pkg.meta.maintainers
then builtins.elem maintainer pkg.meta.maintainers
@ -61,23 +66,23 @@ let
else false
)
)
(name: pkg: pkg)
(relativePath: pkg: pkg)
pkgs;
packagesWithUpdateScript = path:
let
attrSet = pkgs.lib.attrByPath (pkgs.lib.splitString "." path) null pkgs;
pathContent = lib.attrByPath (lib.splitString "." path) null pkgs;
in
if attrSet == null then
if pathContent == null then
builtins.throw "Attribute path `${path}` does not exists."
else
packagesWith (name: pkg: builtins.hasAttr "updateScript" pkg)
(name: pkg: pkg)
attrSet;
packagesWith (relativePath: pkg: builtins.hasAttr "updateScript" pkg)
(relativePath: pkg: pkg)
pathContent;
packageByName = name:
let
package = pkgs.lib.attrByPath (pkgs.lib.splitString "." name) null pkgs;
package = lib.attrByPath (lib.splitString "." name) null pkgs;
in
if package == null then
builtins.throw "Package with an attribute name `${name}` does not exists."
@ -125,15 +130,15 @@ let
packageData = package: {
name = package.name;
pname = pkgs.lib.getName package;
updateScript = map builtins.toString (pkgs.lib.toList package.updateScript);
pname = lib.getName package;
updateScript = map builtins.toString (lib.toList package.updateScript);
};
packagesJson = pkgs.writeText "packages.json" (builtins.toJSON (map packageData packages));
optionalArgs =
pkgs.lib.optional (max-workers != null) "--max-workers=${max-workers}"
++ pkgs.lib.optional (keep-going == "true") "--keep-going";
lib.optional (max-workers != null) "--max-workers=${max-workers}"
++ lib.optional (keep-going == "true") "--keep-going";
args = [ packagesJson ] ++ optionalArgs;

11
nixos/doc/manual/configuration/file-systems.xml
View File

@ -16,6 +16,17 @@
fsType = "ext4";
};
</programlisting>
This will create an entry in <filename>/etc/fstab</filename>, which will
generate a corresponding
<link xlink:href="https://www.freedesktop.org/software/systemd/man/systemd.mount.html">systemd.mount</link>
unit via
<link xlink:href="https://www.freedesktop.org/software/systemd/man/systemd-fstab-generator.html">systemd-fstab-generator</link>.
The filesystem will be mounted automatically unless
<literal>"noauto"</literal> is present in <link
linkend="opt-fileSystems._name__.options">options</link>.
<literal>"noauto"</literal> filesystems can be mounted explicitly using
<command>systemctl</command> e.g. <command>systemctl start
data.mount</command>.
Mount points are created automatically if they don’t already exist. For
<option><link linkend="opt-fileSystems._name__.device">device</link></option>,
it’s best to use the topology-independent device aliases in

33
nixos/doc/manual/release-notes/rl-2009.xml
View File

@ -61,6 +61,28 @@
This is to make it possible to use <literal>podman</literal> instead of <literal>docker</literal>.
</para>
</listitem>
<listitem>
<para>
MariaDB has been updated to 10.4, MariaDB Galera to 26.4.
Before you upgrade, it would be best to take a backup of your database.
For MariaDB Galera Cluster, see <link xlink:href="https://mariadb.com/kb/en/upgrading-from-mariadb-103-to-mariadb-104-with-galera-cluster/">Upgrading
from MariaDB 10.3 to MariaDB 10.4 with Galera Cluster</link> instead.
Before doing the upgrade read <link xlink:href="https://mariadb.com/kb/en/upgrading-from-mariadb-103-to-mariadb-104/#incompatible-changes-between-103-and-104">Incompatible
Changes Between 10.3 and 10.4</link>.
After the upgrade you will need to run <literal>mysql_upgrade</literal>.
MariaDB 10.4 introduces a number of changes to the authentication process, intended to make things easier and more
intuitive. See <link xlink:href="https://mariadb.com/kb/en/authentication-from-mariadb-104/">Authentication from MariaDB 10.4</link>.
unix_socket auth plugin does not use a password, and uses the connecting user's UID instead. When a new MariaDB data directory is initialized, two MariaDB users are
created and can be used with new unix_socket auth plugin, as well as traditional mysql_native_password plugin: root@localhost and mysql@localhost. To actually use
the traditional mysql_native_password plugin method, one must run the following:
<programlisting>
services.mysql.initialScript = pkgs.writeText "mariadb-init.sql" ''
ALTER USER root@localhost IDENTIFIED VIA mysql_native_password USING PASSWORD("verysecret");
'';
</programlisting>
When MariaDB data directory is just upgraded (not initialized), the users are not created or modified.
</para>
</listitem>
</itemizedlist>
</section>
@ -98,6 +120,12 @@
</para>
<itemizedlist>
<listitem>
<para>
The go-modules builder now uses vendorSha256 instead of modSha256 to pin
fetched version data. This is currently a warning, but will be removed in the next release.
</para>
</listitem>
<listitem>
<para>
Grafana is now built without support for phantomjs by default. Phantomjs support has been
@ -353,6 +381,11 @@ systemd.services.nginx.serviceConfig.ReadWritePaths = [ "/var/www" ];
will have changed.
</para>
</listitem>
<listitem>
<para>
The rkt module has been removed, it was archived by upstream.
</para>
</listitem>
</itemizedlist>
</section>

6
nixos/lib/testing-python.nix
View File

@ -10,11 +10,7 @@
with import ./build-vms.nix { inherit system pkgs minimal extraConfigurations; };
with pkgs;
let
jquery-ui = callPackage ./testing/jquery-ui.nix { };
jquery = callPackage ./testing/jquery.nix { };
in rec {
rec {
inherit pkgs;

6
nixos/lib/testing.nix
View File

@ -10,11 +10,7 @@
with import ./build-vms.nix { inherit system pkgs minimal extraConfigurations; };
with pkgs;
let
jquery-ui = callPackage ./testing/jquery-ui.nix { };
jquery = callPackage ./testing/jquery.nix { };
in rec {
rec {
inherit pkgs;

24
nixos/lib/testing/jquery-ui.nix
View File

@ -1,24 +0,0 @@
{ stdenv, fetchurl, unzip }:
stdenv.mkDerivation rec {
name = "jquery-ui-1.11.4";
src = fetchurl {
url = "https://jqueryui.com/resources/download/${name}.zip";
sha256 = "0ciyaj1acg08g8hpzqx6whayq206fvf4whksz2pjgxlv207lqgjh";
};
buildInputs = [ unzip ];
installPhase =
''
mkdir -p "$out/js"
cp -rv . "$out/js"
'';
meta = {
homepage = "https://jqueryui.com/";
description = "A library of JavaScript widgets and effects";
platforms = stdenv.lib.platforms.all;
};
}

36
nixos/lib/testing/jquery.nix
View File

@ -1,36 +0,0 @@
{ stdenv, fetchurl, compressed ? true }:
with stdenv.lib;
stdenv.mkDerivation rec {
name = "jquery-1.11.3";
src = if compressed then
fetchurl {
url = "http://code.jquery.com/${name}.min.js";
sha256 = "1f4glgxxn3jnvry3dpzmazj3207baacnap5w20gr2xlk789idfgc";
}
else
fetchurl {
url = "http://code.jquery.com/${name}.js";
sha256 = "1v956yf5spw0156rni5z77hzqwmby7ajwdcd6mkhb6zvl36awr90";
};
dontUnpack = true;
installPhase =
''
mkdir -p "$out/js"
cp -v "$src" "$out/js/jquery.js"
${optionalString compressed ''
(cd "$out/js" && ln -s jquery.js jquery.min.js)
''}
'';
meta = with stdenv.lib; {
description = "JavaScript library designed to simplify the client-side scripting of HTML";
homepage = "http://jquery.com/";
license = licenses.mit;
platforms = platforms.all;
};
}

4
nixos/modules/config/ldap.nix
View File

@ -244,6 +244,10 @@ in
if cfg.daemon.enable then nss_pam_ldapd else nss_ldap
);
system.nssDatabases.group = optional cfg.nsswitch "ldap";
system.nssDatabases.passwd = optional cfg.nsswitch "ldap";
system.nssDatabases.shadow = optional cfg.nsswitch "ldap";
users = mkIf cfg.daemon.enable {
groups.nslcd = {
gid = config.ids.gids.nslcd;

48
nixos/modules/config/nsswitch.nix
View File

@ -4,34 +4,7 @@
with lib;
let
# only with nscd up and running we can load NSS modules that are not integrated in NSS
canLoadExternalModules = config.services.nscd.enable;
# XXX Move these to their respective modules
nssmdns = canLoadExternalModules && config.services.avahi.nssmdns;
nsswins = canLoadExternalModules && config.services.samba.nsswins;
ldap = canLoadExternalModules && (config.users.ldap.enable && config.users.ldap.nsswitch);
hostArray = mkMerge [
(mkBefore [ "files" ])
(mkIf nssmdns [ "mdns_minimal [NOTFOUND=return]" ])
(mkIf nsswins [ "wins" ])
(mkAfter [ "dns" ])
(mkIf nssmdns (mkOrder 1501 [ "mdns" ])) # 1501 to ensure it's after dns
];
passwdArray = mkMerge [
(mkBefore [ "files" ])
(mkIf ldap [ "ldap" ])
];
shadowArray = mkMerge [
(mkBefore [ "files" ])
(mkIf ldap [ "ldap" ])
];
in {
{
options = {
# NSS modules. Hacky!
@ -122,9 +95,11 @@ in {
config = {
assertions = [
{
# generic catch if the NixOS module adding to nssModules does not prevent it with specific message.
assertion = config.system.nssModules.path != "" -> canLoadExternalModules;
message = "Loading NSS modules from path ${config.system.nssModules.path} requires nscd being enabled.";
# Prevent users from disabling nscd, with nssModules being set.
# If disabling nscd is really necessary, it's still possible to opt out
# by forcing config.system.nssModules to [].
assertion = config.system.nssModules.path != "" -> config.services.nscd.enable;
message = "Loading NSS modules from system.nssModules (${config.system.nssModules.path}), requires services.nscd.enable being set to true.";
}
];
@ -145,10 +120,13 @@ in {
'';
system.nssDatabases = {
passwd = passwdArray;
group = passwdArray;
shadow = shadowArray;
hosts = hostArray;
passwd = mkBefore [ "files" ];
group = mkBefore [ "files" ];
shadow = mkBefore [ "files" ];
hosts = mkMerge [
(mkBefore [ "files" ])
(mkAfter [ "dns" ])
];
services = mkBefore [ "files" ];
};
};

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

@ -1002,7 +1002,6 @@
./virtualisation/podman.nix
./virtualisation/qemu-guest-agent.nix
./virtualisation/railcar.nix
./virtualisation/rkt.nix
./virtualisation/virtualbox-guest.nix
./virtualisation/virtualbox-host.nix
./virtualisation/vmware-guest.nix

1
nixos/modules/rename.nix
View File

@ -48,6 +48,7 @@ with lib;
systemd-logind API). Instead of using the module you can now
simply add the brightnessctl package to environment.systemPackages.
'')
(mkRemovedOptionModule [ "virtualisation" "rkt" ] "The rkt module has been removed, it was archived by upstream")
(mkRemovedOptionModule ["services" "prey" ] ''
prey-bash-client is deprecated upstream

1
nixos/modules/security/google_oslogin.nix
View File

@ -50,6 +50,7 @@ in
# enable the nss module, so user lookups etc. work
system.nssModules = [ package ];
system.nssDatabases.passwd = [ "cache_oslogin" "oslogin" ];
system.nssDatabases.group = [ "cache_oslogin" "oslogin" ];
# Ugly: sshd refuses to start if a store path is given because /nix/store is group-writable.
# So indirect by a symlink.

7
nixos/modules/services/databases/mysql.nix
View File

@ -87,7 +87,6 @@ in
datadir = /var/lib/mysql
bind-address = 127.0.0.1
port = 3336
plugin-load-add = auth_socket.so
!includedir /etc/mysql/conf.d/
''';
@ -315,13 +314,16 @@ in
datadir = cfg.dataDir;
bind-address = mkIf (cfg.bind != null) cfg.bind;
port = cfg.port;
plugin-load-add = optional (cfg.ensureUsers != []) "auth_socket.so";
}
(mkIf (cfg.replication.role == "master" || cfg.replication.role == "slave") {
log-bin = "mysql-bin-${toString cfg.replication.serverId}";
log-bin-index = "mysql-bin-${toString cfg.replication.serverId}.index";
relay-log = "mysql-relay-bin";
server-id = cfg.replication.serverId;
binlog-ignore-db = [ "information_schema" "performance_schema" "mysql" ];
})
(mkIf (!isMariaDB) {
plugin-load-add = optional (cfg.ensureUsers != []) "auth_socket.so";
})
];
@ -444,7 +446,6 @@ in
( echo "stop slave;"
echo "change master to master_host='${cfg.replication.masterHost}', master_user='${cfg.replication.masterUser}', master_password='${cfg.replication.masterPassword}';"
echo "set global slave_exec_mode='IDEMPOTENT';"
echo "start slave;"
) | ${mysql}/bin/mysql -u root -N
''}

2
nixos/modules/services/databases/postgresql.nix
View File

@ -343,7 +343,7 @@ in
# Wait for PostgreSQL to be ready to accept connections.
postStart =
''
PSQL="${pkgs.sudo}/bin/sudo -u ${cfg.superUser} psql --port=${toString cfg.port}"
PSQL="${pkgs.utillinux}/bin/runuser -u ${cfg.superUser} -- psql --port=${toString cfg.port}"
while ! $PSQL -d postgres -c "" 2> /dev/null; do
if ! kill -0 "$MAINPID"; then exit 1; fi

3
nixos/modules/services/databases/redis.nix
View File

@ -11,12 +11,11 @@ let
port ${toString cfg.port}
${condOption "bind" cfg.bind}
${condOption "unixsocket" cfg.unixSocket}
daemonize yes
daemonize no
supervised systemd
loglevel ${cfg.logLevel}
logfile ${cfg.logfile}
syslog-enabled ${redisBool cfg.syslog}
pidfile /run/redis/redis.pid
databases ${toString cfg.databases}
${concatMapStrings (d: "save ${toString (builtins.elemAt d 0)} ${toString (builtins.elemAt d 1)}\n") cfg.save}
dbfilename dump.rdb

10
nixos/modules/services/misc/sssd.nix
View File

@ -42,11 +42,6 @@ in {
};
config = mkMerge [
(mkIf cfg.enable {
assertions = singleton {
assertion = nscd.enable;
message = "nscd must be enabled through `services.nscd.enable` for SSSD to work.";
};
systemd.services.sssd = {
description = "System Security Services Daemon";
wantedBy = [ "multi-user.target" ];
@ -74,11 +69,12 @@ in {
mode = "0400";
};
system.nssModules = optional cfg.enable pkgs.sssd;
system.nssModules = pkgs.sssd;
system.nssDatabases = {
group = [ "sss" ];
passwd = [ "sss" ];
shadow = [ "sss" ];
services = [ "sss" ];
shadow = [ "sss" ];
};
services.dbus.packages = [ pkgs.sssd ];
})

8
nixos/modules/services/misc/zoneminder.nix
View File

@ -63,10 +63,6 @@ let
${cfg.extraConfig}
'';
phpExtensions = with pkgs.phpPackages; [
{ pkg = apcu; name = "apcu"; }
];
in {
options = {
services.zoneminder = with lib; {
@ -289,11 +285,9 @@ in {
phpfpm = lib.mkIf useNginx {
pools.zoneminder = {
inherit user group;
phpPackage = pkgs.php.withExtensions ({ enabled, all }: enabled ++ [ all.apcu ]);
phpOptions = ''
date.timezone = "${config.time.timeZone}"
${lib.concatStringsSep "\n" (map (e:
"extension=${e.pkg}/lib/php/extensions/${e.name}.so") phpExtensions)}
'';
settings = lib.mapAttrs (name: lib.mkDefault) {
"listen.owner" = user;

1
nixos/modules/services/network-filesystems/samba.nix
View File

@ -224,6 +224,7 @@ in
(mkIf cfg.enable {
system.nssModules = optional cfg.nsswins samba;
system.nssDatabases.hosts = optional cfg.nsswins "wins";
systemd = {
targets.samba = {

4
nixos/modules/services/networking/avahi-daemon.nix
View File

@ -238,6 +238,10 @@ in
users.groups.avahi = {};
system.nssModules = optional cfg.nssmdns pkgs.nssmdns;
system.nssDatabases.hosts = optionals cfg.nssmdns (mkMerge [
[ "mdns_minimal [NOTFOUND=return]" ]
(mkOrder 1501 [ "mdns" ]) # 1501 to ensure it's after dns
]);
environment.systemPackages = [ pkgs.avahi ];

20
nixos/modules/services/web-servers/uwsgi.nix
View File

@ -79,7 +79,25 @@ in {
};
instance = mkOption {
type = types.attrs;
type = with lib.types; let
valueType = nullOr (oneOf [
bool
int
float
str
(lazyAttrsOf valueType)
(listOf valueType)
(mkOptionType {
name = "function";
description = "function";
check = x: isFunction x;
merge = mergeOneOption;
})
]) // {
description = "Json value or lambda";
emptyValue.value = {};
};
in valueType;
default = {
type = "normal";
};

25
nixos/modules/services/x11/window-managers/berry.nix Normal file
View File

@ -0,0 +1,25 @@
{ config, lib, pkgs, ... }:
with lib;
let
cfg = config.services.xserver.windowManager.berry;
in
{
###### interface
options = {
services.xserver.windowManager.berry.enable = mkEnableOption "berry";
};
###### implementation
config = mkIf cfg.enable {
services.xserver.windowManager.session = singleton {
name = "berry";
start = ''
${pkgs.berry}/bin/berry &
waitPID=$!
'';
};
environment.systemPackages = [ pkgs.berry ];
};
}

4
nixos/modules/services/x11/window-managers/default.nix
View File

@ -10,6 +10,7 @@ in
imports = [
./2bwm.nix
./afterstep.nix
./berry.nix
./bspwm.nix
./cwm.nix
./dwm.nix
@ -21,6 +22,7 @@ in
./i3.nix
./jwm.nix
./leftwm.nix
./lwm.nix
./metacity.nix
./mwm.nix
./openbox.nix
@ -28,6 +30,7 @@ in
./notion.nix
./ratpoison.nix
./sawfish.nix
./smallwm.nix
./stumpwm.nix
./spectrwm.nix
./tinywm.nix
@ -35,6 +38,7 @@ in
./windowmaker.nix
./wmii.nix
./xmonad.nix
./yeahwm.nix
./qtile.nix
./none.nix ];

25
nixos/modules/services/x11/window-managers/lwm.nix Normal file
View File

@ -0,0 +1,25 @@
{ config, lib, pkgs, ... }:
with lib;
let
cfg = config.services.xserver.windowManager.lwm;
in
{
###### interface
options = {
services.xserver.windowManager.lwm.enable = mkEnableOption "lwm";
};
###### implementation
config = mkIf cfg.enable {
services.xserver.windowManager.session = singleton {
name = "lwm";
start = ''
${pkgs.lwm}/bin/lwm &
waitPID=$!
'';
};
environment.systemPackages = [ pkgs.lwm ];
};
}

25
nixos/modules/services/x11/window-managers/smallwm.nix Normal file
View File

@ -0,0 +1,25 @@
{ config, lib, pkgs, ... }:
with lib;
let
cfg = config.services.xserver.windowManager.smallwm;
in
{
###### interface
options = {
services.xserver.windowManager.smallwm.enable = mkEnableOption "smallwm";
};
###### implementation
config = mkIf cfg.enable {
services.xserver.windowManager.session = singleton {
name = "smallwm";
start = ''
${pkgs.smallwm}/bin/smallwm &
waitPID=$!
'';
};
environment.systemPackages = [ pkgs.smallwm ];
};
}

25
nixos/modules/services/x11/window-managers/yeahwm.nix Normal file
View File

@ -0,0 +1,25 @@
{ config, lib, pkgs, ... }:
with lib;
let
cfg = config.services.xserver.windowManager.yeahwm;
in
{
###### interface
options = {
services.xserver.windowManager.yeahwm.enable = mkEnableOption "yeahwm";
};
###### implementation
config = mkIf cfg.enable {
services.xserver.windowManager.session = singleton {
name = "yeahwm";
start = ''
${pkgs.yeahwm}/bin/yeahwm &
waitPID=$!
'';
};
environment.systemPackages = [ pkgs.yeahwm ];
};
}

9
nixos/modules/system/boot/binfmt.nix
View File

@ -268,9 +268,10 @@ in {
mkdir -p -m 0755 /run/binfmt
${lib.concatStringsSep "\n" (lib.mapAttrsToList activationSnippet config.boot.binfmt.registrations)}
'';
systemd.additionalUpstreamSystemUnits = lib.mkIf (config.boot.binfmt.registrations != {})
[ "proc-sys-fs-binfmt_misc.automount"
"proc-sys-fs-binfmt_misc.mount"
];
systemd.additionalUpstreamSystemUnits = lib.mkIf (config.boot.binfmt.registrations != {}) [
"proc-sys-fs-binfmt_misc.automount"
"proc-sys-fs-binfmt_misc.mount"
"systemd-binfmt.service"
];
};
}

18
nixos/modules/system/boot/systemd.nix
View File

@ -164,7 +164,6 @@ let
"systemd-timedated.service"
"systemd-localed.service"
"systemd-hostnamed.service"
"systemd-binfmt.service"
"systemd-exit.service"
"systemd-update-done.service"
] ++ optionals config.services.journald.enableHttpGateway [
@ -832,16 +831,8 @@ in
system.build.units = cfg.units;
# Systemd provides various NSS modules to look up dynamic users, locally
# configured IP adresses and local container hostnames.
# On NixOS, these can only be passed to the NSS system via nscd (and its
# LD_LIBRARY_PATH), which is why it's usually a very good idea to have nscd
# enabled (also see the config.nscd.enable description).
# While there is already an assertion in place complaining loudly about
# having nssModules configured and nscd disabled, for some reason we still
# check for nscd being enabled before adding to nssModules.
system.nssModules = optional config.services.nscd.enable systemd.out;
system.nssDatabases = mkIf config.services.nscd.enable {
system.nssModules = [ systemd.out ];
system.nssDatabases = {
hosts = (mkMerge [
[ "mymachines" ]
(mkOrder 1600 [ "myhostname" ] # 1600 to ensure it's always the last
@ -851,6 +842,10 @@ in
[ "mymachines" ]
(mkAfter [ "systemd" ])
]);
group = (mkMerge [
[ "mymachines" ]
(mkAfter [ "systemd" ])
]);
};
environment.systemPackages = [ systemd ];
@ -1060,7 +1055,6 @@ in
systemd.targets.local-fs.unitConfig.X-StopOnReconfiguration = true;
systemd.targets.remote-fs.unitConfig.X-StopOnReconfiguration = true;
systemd.targets.network-online.wantedBy = [ "multi-user.target" ];
systemd.services.systemd-binfmt.wants = [ "proc-sys-fs-binfmt_misc.mount" ];
systemd.services.systemd-importd.environment = proxy_env;
# Don't bother with certain units in containers.

11
nixos/modules/tasks/filesystems/zfs.nix
View File

@ -433,7 +433,16 @@ in
services.zfs.zed.settings = {
ZED_EMAIL_PROG = mkDefault "${pkgs.mailutils}/bin/mail";
PATH = lib.makeBinPath [ packages.zfsUser pkgs.utillinux pkgs.gawk pkgs.gnused pkgs.gnugrep pkgs.coreutils pkgs.curl ];
PATH = lib.makeBinPath [
packages.zfsUser
pkgs.coreutils
pkgs.curl
pkgs.gawk
pkgs.gnugrep
pkgs.gnused
pkgs.nettools
pkgs.utillinux
];
};
environment.etc = genAttrs

64
nixos/modules/virtualisation/rkt.nix
View File

@ -1,64 +0,0 @@
{ config, lib, pkgs, ... }:
with lib;
let
cfg = config.virtualisation.rkt;
in
{
options.virtualisation.rkt = {
enable = mkEnableOption "rkt metadata service";
gc = {
automatic = mkOption {
default = true;
type = types.bool;
description = "Automatically run the garbage collector at a specific time.";
};
dates = mkOption {
default = "03:15";
type = types.str;
description = ''
Specification (in the format described by
<citerefentry><refentrytitle>systemd.time</refentrytitle>
<manvolnum>7</manvolnum></citerefentry>) of the time at
which the garbage collector will run.
'';
};
options = mkOption {
default = "--grace-period=24h";
type = types.str;
description = ''
Options given to <filename>rkt gc</filename> when the
garbage collector is run automatically.
'';
};
};
};
config = mkIf cfg.enable {
environment.systemPackages = [ pkgs.rkt ];
systemd.services.rkt = {
description = "rkt metadata service";
wantedBy = [ "multi-user.target" ];
after = [ "network.target" ];
serviceConfig = {
ExecStart = "${pkgs.rkt}/bin/rkt metadata-service";
};
};
systemd.services.rkt-gc = {
description = "rkt garbage collection";
startAt = optionalString cfg.gc.automatic cfg.gc.dates;
serviceConfig = {
Type = "oneshot";
ExecStart = "${pkgs.rkt}/bin/rkt gc ${cfg.gc.options}";
};
};
users.groups.rkt = {};
};
}

41
nixos/tests/agda.nix Normal file
View File

@ -0,0 +1,41 @@
import ./make-test-python.nix ({ pkgs, ... }:
let
hello-world = pkgs.writeText "hello-world" ''
open import IO
main = run(putStrLn "Hello World!")
'';
in
{
name = "agda";
meta = with pkgs.stdenv.lib.maintainers; {
maintainers = [ alexarice turion ];
};
machine = { pkgs, ... }: {
environment.systemPackages = [
(pkgs.agda.withPackages {
pkgs = p: [ p.standard-library ];
})
];
virtualisation.memorySize = 2000; # Agda uses a lot of memory
};
testScript = ''
# Minimal script that typechecks
machine.succeed("touch TestEmpty.agda")
machine.succeed("agda TestEmpty.agda")
# Minimal script that actually uses the standard library
machine.succeed('echo "import IO" > TestIO.agda')
machine.succeed("agda -l standard-library -i . TestIO.agda")
# # Hello world
machine.succeed(
"cp ${hello-world} HelloWorld.agda"
)
machine.succeed("agda -l standard-library -i . -c HelloWorld.agda")
'';
}
)

5
nixos/tests/all-tests.nix
View File

@ -23,6 +23,7 @@ in
{
_3proxy = handleTest ./3proxy.nix {};
acme = handleTest ./acme.nix {};
agda = handleTest ./agda.nix {};
atd = handleTest ./atd.nix {};
avahi = handleTest ./avahi.nix {};
babeld = handleTest ./babeld.nix {};
@ -303,6 +304,7 @@ in
syncthing-relay = handleTest ./syncthing-relay.nix {};
systemd = handleTest ./systemd.nix {};
systemd-analyze = handleTest ./systemd-analyze.nix {};
systemd-binfmt = handleTestOn ["x86_64-linux"] ./systemd-binfmt.nix {};
systemd-boot = handleTestOn ["x86_64-linux"] ./systemd-boot.nix {};
systemd-confinement = handleTest ./systemd-confinement.nix {};
systemd-timesyncd = handleTest ./systemd-timesyncd.nix {};
@ -347,6 +349,7 @@ in
yabar = handleTest ./yabar.nix {};
yggdrasil = handleTest ./yggdrasil.nix {};
zfs = handleTest ./zfs.nix {};
zsh-history = handleTest ./zsh-history.nix {};
zoneminder = handleTest ./zoneminder.nix {};
zookeeper = handleTest ./zookeeper.nix {};
zsh-history = handleTest ./zsh-history.nix {};
}

10
nixos/tests/docker-tools.nix
View File

@ -124,6 +124,16 @@ import ./make-test-python.nix ({ pkgs, ... }: {
f"docker run --rm ${examples.layersOrder.imageName} cat /tmp/layer{index}"
)
with subtest("Ensure environment variables are correctly inherited"):
docker.succeed(
"docker load --input='${examples.environmentVariables}'"
)
out = docker.succeed("docker run --rm ${examples.environmentVariables.imageName} env")
env = out.splitlines()
assert "FROM_PARENT=true" in env, "envvars from the parent should be preserved"
assert "FROM_CHILD=true" in env, "envvars from the child should be preserved"
assert "LAST_LAYER=child" in env, "envvars from the child should take priority"
with subtest("Ensure image with only 2 layers can be loaded"):
docker.succeed(
"docker load --input='${examples.two-layered-image}'"

8
nixos/tests/kubernetes/base.nix
View File

@ -3,7 +3,7 @@
pkgs ? import ../../.. { inherit system config; }
}:
with import ../../lib/testing.nix { inherit system pkgs; };
with import ../../lib/testing-python.nix { inherit system pkgs; };
with pkgs.lib;
let
@ -75,10 +75,8 @@ let
) machines;
testScript = ''
startAll;
${test}
'';
start_all()
'' + test;
};
mkKubernetesMultiNodeTest = attrs: mkKubernetesBaseTest ({

74
nixos/tests/kubernetes/dns.nix
View File

@ -75,51 +75,75 @@ let
singleNodeTest = {
test = ''
# prepare machine1 for test
$machine1->waitUntilSucceeds("kubectl get node machine1.${domain} | grep -w Ready");
$machine1->waitUntilSucceeds("docker load < ${redisImage}");
$machine1->waitUntilSucceeds("kubectl create -f ${redisPod}");
$machine1->waitUntilSucceeds("kubectl create -f ${redisService}");
$machine1->waitUntilSucceeds("docker load < ${probeImage}");
$machine1->waitUntilSucceeds("kubectl create -f ${probePod}");
machine1.wait_until_succeeds("kubectl get node machine1.${domain} | grep -w Ready")
machine1.wait_until_succeeds(
"docker load < ${redisImage}"
)
machine1.wait_until_succeeds(
"kubectl create -f ${redisPod}"
)
machine1.wait_until_succeeds(
"kubectl create -f ${redisService}"
)
machine1.wait_until_succeeds(
"docker load < ${probeImage}"
)
machine1.wait_until_succeeds(
"kubectl create -f ${probePod}"
)
# check if pods are running
$machine1->waitUntilSucceeds("kubectl get pod redis | grep Running");
$machine1->waitUntilSucceeds("kubectl get pod probe | grep Running");
$machine1->waitUntilSucceeds("kubectl get pods -n kube-system | grep 'coredns.*1/1'");
machine1.wait_until_succeeds("kubectl get pod redis | grep Running")
machine1.wait_until_succeeds("kubectl get pod probe | grep Running")
machine1.wait_until_succeeds("kubectl get pods -n kube-system | grep 'coredns.*1/1'")
# check dns on host (dnsmasq)
$machine1->succeed("host redis.default.svc.cluster.local");
machine1.succeed("host redis.default.svc.cluster.local")
# check dns inside the container
$machine1->succeed("kubectl exec -ti probe -- /bin/host redis.default.svc.cluster.local");
machine1.succeed("kubectl exec -ti probe -- /bin/host redis.default.svc.cluster.local")
'';
};
multiNodeTest = {
test = ''
# Node token exchange
$machine1->waitUntilSucceeds("cp -f /var/lib/cfssl/apitoken.secret /tmp/shared/apitoken.secret");
$machine2->waitUntilSucceeds("cat /tmp/shared/apitoken.secret | nixos-kubernetes-node-join");
machine1.wait_until_succeeds(
"cp -f /var/lib/cfssl/apitoken.secret /tmp/shared/apitoken.secret"
)
machine2.wait_until_succeeds(
"cat /tmp/shared/apitoken.secret | nixos-kubernetes-node-join"
)
# prepare machines for test
$machine1->waitUntilSucceeds("kubectl get node machine2.${domain} | grep -w Ready");
$machine2->waitUntilSucceeds("docker load < ${redisImage}");
$machine1->waitUntilSucceeds("kubectl create -f ${redisPod}");
$machine1->waitUntilSucceeds("kubectl create -f ${redisService}");
$machine2->waitUntilSucceeds("docker load < ${probeImage}");
$machine1->waitUntilSucceeds("kubectl create -f ${probePod}");
machine1.wait_until_succeeds("kubectl get node machine2.${domain} | grep -w Ready")
machine2.wait_until_succeeds(
"docker load < ${redisImage}"
)
machine1.wait_until_succeeds(
"kubectl create -f ${redisPod}"
)
machine1.wait_until_succeeds(
"kubectl create -f ${redisService}"
)
machine2.wait_until_succeeds(
"docker load < ${probeImage}"
)
machine1.wait_until_succeeds(
"kubectl create -f ${probePod}"
)
# check if pods are running
$machine1->waitUntilSucceeds("kubectl get pod redis | grep Running");
$machine1->waitUntilSucceeds("kubectl get pod probe | grep Running");
$machine1->waitUntilSucceeds("kubectl get pods -n kube-system | grep 'coredns.*1/1'");
machine1.wait_until_succeeds("kubectl get pod redis | grep Running")
machine1.wait_until_succeeds("kubectl get pod probe | grep Running")
machine1.wait_until_succeeds("kubectl get pods -n kube-system | grep 'coredns.*1/1'")
# check dns on hosts (dnsmasq)
$machine1->succeed("host redis.default.svc.cluster.local");
$machine2->succeed("host redis.default.svc.cluster.local");
machine1.succeed("host redis.default.svc.cluster.local")
machine2.succeed("host redis.default.svc.cluster.local")
# check dns inside the container
$machine1->succeed("kubectl exec -ti probe -- /bin/host redis.default.svc.cluster.local");
machine1.succeed("kubectl exec -ti probe -- /bin/host redis.default.svc.cluster.local")
'';
};
in {

68
nixos/tests/kubernetes/rbac.nix
View File

@ -94,43 +94,67 @@ let
singlenode = base // {
test = ''
$machine1->waitUntilSucceeds("kubectl get node machine1.my.zyx | grep -w Ready");
machine1.wait_until_succeeds("kubectl get node machine1.my.zyx | grep -w Ready")
$machine1->waitUntilSucceeds("docker load < ${kubectlImage}");
machine1.wait_until_succeeds(
"docker load < ${kubectlImage}"
)
$machine1->waitUntilSucceeds("kubectl apply -f ${roServiceAccount}");
$machine1->waitUntilSucceeds("kubectl apply -f ${roRole}");
$machine1->waitUntilSucceeds("kubectl apply -f ${roRoleBinding}");
$machine1->waitUntilSucceeds("kubectl create -f ${kubectlPod}");
machine1.wait_until_succeeds(
"kubectl apply -f ${roServiceAccount}"
)
machine1.wait_until_succeeds(
"kubectl apply -f ${roRole}"
)
machine1.wait_until_succeeds(
"kubectl apply -f ${roRoleBinding}"
)
machine1.wait_until_succeeds(
"kubectl create -f ${kubectlPod}"
)
$machine1->waitUntilSucceeds("kubectl get pod kubectl | grep Running");
machine1.wait_until_succeeds("kubectl get pod kubectl | grep Running")
$machine1->waitUntilSucceeds("kubectl exec -ti kubectl -- kubectl get pods");
$machine1->fail("kubectl exec -ti kubectl -- kubectl create -f /kubectl-pod-2.json");
$machine1->fail("kubectl exec -ti kubectl -- kubectl delete pods -l name=kubectl");
machine1.wait_until_succeeds("kubectl exec -ti kubectl -- kubectl get pods")
machine1.fail("kubectl exec -ti kubectl -- kubectl create -f /kubectl-pod-2.json")
machine1.fail("kubectl exec -ti kubectl -- kubectl delete pods -l name=kubectl")
'';
};
multinode = base // {
test = ''
# Node token exchange
$machine1->waitUntilSucceeds("cp -f /var/lib/cfssl/apitoken.secret /tmp/shared/apitoken.secret");
$machine2->waitUntilSucceeds("cat /tmp/shared/apitoken.secret | nixos-kubernetes-node-join");
machine1.wait_until_succeeds(
"cp -f /var/lib/cfssl/apitoken.secret /tmp/shared/apitoken.secret"
)
machine2.wait_until_succeeds(
"cat /tmp/shared/apitoken.secret | nixos-kubernetes-node-join"
)
$machine1->waitUntilSucceeds("kubectl get node machine2.my.zyx | grep -w Ready");
machine1.wait_until_succeeds("kubectl get node machine2.my.zyx | grep -w Ready")
$machine2->waitUntilSucceeds("docker load < ${kubectlImage}");
machine2.wait_until_succeeds(
"docker load < ${kubectlImage}"
)
$machine1->waitUntilSucceeds("kubectl apply -f ${roServiceAccount}");
$machine1->waitUntilSucceeds("kubectl apply -f ${roRole}");
$machine1->waitUntilSucceeds("kubectl apply -f ${roRoleBinding}");
$machine1->waitUntilSucceeds("kubectl create -f ${kubectlPod}");
machine1.wait_until_succeeds(
"kubectl apply -f ${roServiceAccount}"
)
machine1.wait_until_succeeds(
"kubectl apply -f ${roRole}"
)
machine1.wait_until_succeeds(
"kubectl apply -f ${roRoleBinding}"
)
machine1.wait_until_succeeds(
"kubectl create -f ${kubectlPod}"
)
$machine1->waitUntilSucceeds("kubectl get pod kubectl | grep Running");
machine1.wait_until_succeeds("kubectl get pod kubectl | grep Running")
$machine1->waitUntilSucceeds("kubectl exec -ti kubectl -- kubectl get pods");
$machine1->fail("kubectl exec -ti kubectl -- kubectl create -f /kubectl-pod-2.json");
$machine1->fail("kubectl exec -ti kubectl -- kubectl delete pods -l name=kubectl");
machine1.wait_until_succeeds("kubectl exec -ti kubectl -- kubectl get pods")
machine1.fail("kubectl exec -ti kubectl -- kubectl create -f /kubectl-pod-2.json")
machine1.fail("kubectl exec -ti kubectl -- kubectl delete pods -l name=kubectl")
'';
};

32
nixos/tests/mysql/mariadb-galera-mariabackup.nix
View File

@ -55,9 +55,9 @@ in {
};
galera = {
wsrep_on = "ON";
wsrep_debug = "OFF";
wsrep_debug = "NONE";
wsrep_retry_autocommit = "3";
wsrep_provider = "${pkgs.mariadb-galera_25}/lib/galera/libgalera_smm.so";
wsrep_provider = "${pkgs.mariadb-galera}/lib/galera/libgalera_smm.so";
wsrep_cluster_address = "gcomm://";
wsrep_cluster_name = "galera";
wsrep_node_address = "192.168.1.1";
@ -102,9 +102,9 @@ in {
};
galera = {
wsrep_on = "ON";
wsrep_debug = "OFF";
wsrep_debug = "NONE";
wsrep_retry_autocommit = "3";
wsrep_provider = "${pkgs.mariadb-galera_25}/lib/galera/libgalera_smm.so";
wsrep_provider = "${pkgs.mariadb-galera}/lib/galera/libgalera_smm.so";
wsrep_cluster_address = "gcomm://galera_01,galera_02,galera_03";
wsrep_cluster_name = "galera";
wsrep_node_address = "192.168.1.2";
@ -149,9 +149,9 @@ in {
};
galera = {
wsrep_on = "ON";
wsrep_debug = "OFF";
wsrep_debug = "NONE";
wsrep_retry_autocommit = "3";
wsrep_provider = "${pkgs.mariadb-galera_25}/lib/galera/libgalera_smm.so";
wsrep_provider = "${pkgs.mariadb-galera}/lib/galera/libgalera_smm.so";
wsrep_cluster_address = "gcomm://galera_01,galera_02,galera_03";
wsrep_cluster_name = "galera";
wsrep_node_address = "192.168.1.3";
@ -184,17 +184,17 @@ in {
galera_03.wait_for_unit("mysql")
galera_03.wait_for_open_port(3306)
galera_02.succeed(
"sudo -u testuser mysql -u root -e 'use testdb; select test_id from db1;' -N | grep 37"
"sudo -u testuser mysql -u testuser -e 'use testdb; select test_id from db1;' -N | grep 37"
)
galera_02.succeed(
"sudo -u testuser mysql -u root -e 'use testdb; create table db2 (test_id INT, PRIMARY KEY (test_id)) ENGINE = InnoDB;'"
"sudo -u testuser mysql -u testuser -e 'use testdb; create table db2 (test_id INT, PRIMARY KEY (test_id)) ENGINE = InnoDB;'"
)
galera_02.succeed("systemctl stop mysql")
galera_01.succeed(
"sudo -u testuser mysql -u testuser -e 'use testdb; insert into db2 values (38);'"
)
galera_03.succeed(
"sudo -u testuser mysql -u root -e 'use testdb; create table db3 (test_id INT, PRIMARY KEY (test_id)) ENGINE = InnoDB;'"
"sudo -u testuser mysql -u testuser -e 'use testdb; create table db3 (test_id INT, PRIMARY KEY (test_id)) ENGINE = InnoDB;'"
)
galera_01.succeed(
"sudo -u testuser mysql -u testuser -e 'use testdb; insert into db3 values (39);'"
@ -202,22 +202,22 @@ in {
galera_02.succeed("systemctl start mysql")
galera_02.wait_for_open_port(3306)
galera_02.succeed(
"sudo -u testuser mysql -u root -e 'show status' -N | grep 'wsrep_cluster_size.*3'"
"sudo -u testuser mysql -u testuser -e 'show status' -N | grep 'wsrep_cluster_size.*3'"
)
galera_03.succeed(
"sudo -u testuser mysql -u root -e 'show status' -N | grep 'wsrep_local_state_comment.*Synced'"
"sudo -u testuser mysql -u testuser -e 'show status' -N | grep 'wsrep_local_state_comment.*Synced'"
)
galera_01.succeed(
"sudo -u testuser mysql -u root -e 'use testdb; select test_id from db3;' -N | grep 39"
"sudo -u testuser mysql -u testuser -e 'use testdb; select test_id from db3;' -N | grep 39"
)
galera_02.succeed(
"sudo -u testuser mysql -u root -e 'use testdb; select test_id from db2;' -N | grep 38"
"sudo -u testuser mysql -u testuser -e 'use testdb; select test_id from db2;' -N | grep 38"
)
galera_03.succeed(
"sudo -u testuser mysql -u root -e 'use testdb; select test_id from db1;' -N | grep 37"
"sudo -u testuser mysql -u testuser -e 'use testdb; select test_id from db1;' -N | grep 37"
)
galera_01.succeed("sudo -u testuser mysql -u testuser -e 'use testdb; drop table db3;'")
galera_02.succeed("sudo -u testuser mysql -u root -e 'use testdb; drop table db2;'")
galera_03.succeed("sudo -u testuser mysql -u root -e 'use testdb; drop table db1;'")
galera_02.succeed("sudo -u testuser mysql -u testuser -e 'use testdb; drop table db2;'")
galera_03.succeed("sudo -u testuser mysql -u testuser -e 'use testdb; drop table db1;'")
'';
})

32
nixos/tests/mysql/mariadb-galera-rsync.nix
View File

@ -51,9 +51,9 @@ in {
};
galera = {
wsrep_on = "ON";
wsrep_debug = "OFF";
wsrep_debug = "NONE";
wsrep_retry_autocommit = "3";
wsrep_provider = "${pkgs.mariadb-galera_25}/lib/galera/libgalera_smm.so";
wsrep_provider = "${pkgs.mariadb-galera}/lib/galera/libgalera_smm.so";
wsrep_cluster_address = "gcomm://";
wsrep_cluster_name = "galera-rsync";
wsrep_node_address = "192.168.2.1";
@ -97,9 +97,9 @@ in {
};
galera = {
wsrep_on = "ON";
wsrep_debug = "OFF";
wsrep_debug = "NONE";
wsrep_retry_autocommit = "3";
wsrep_provider = "${pkgs.mariadb-galera_25}/lib/galera/libgalera_smm.so";
wsrep_provider = "${pkgs.mariadb-galera}/lib/galera/libgalera_smm.so";
wsrep_cluster_address = "gcomm://galera_04,galera_05,galera_06";
wsrep_cluster_name = "galera-rsync";
wsrep_node_address = "192.168.2.2";
@ -143,9 +143,9 @@ in {
};
galera = {
wsrep_on = "ON";
wsrep_debug = "OFF";
wsrep_debug = "NONE";
wsrep_retry_autocommit = "3";
wsrep_provider = "${pkgs.mariadb-galera_25}/lib/galera/libgalera_smm.so";
wsrep_provider = "${pkgs.mariadb-galera}/lib/galera/libgalera_smm.so";
wsrep_cluster_address = "gcomm://galera_04,galera_05,galera_06";
wsrep_cluster_name = "galera-rsync";
wsrep_node_address = "192.168.2.3";
@ -177,17 +177,17 @@ in {
galera_06.wait_for_unit("mysql")
galera_06.wait_for_open_port(3306)
galera_05.succeed(
"sudo -u testuser mysql -u root -e 'use testdb; select test_id from db1;' -N | grep 41"
"sudo -u testuser mysql -u testuser -e 'use testdb; select test_id from db1;' -N | grep 41"
)
galera_05.succeed(
"sudo -u testuser mysql -u root -e 'use testdb; create table db2 (test_id INT, PRIMARY KEY (test_id)) ENGINE = InnoDB;'"
"sudo -u testuser mysql -u testuser -e 'use testdb; create table db2 (test_id INT, PRIMARY KEY (test_id)) ENGINE = InnoDB;'"
)
galera_05.succeed("systemctl stop mysql")
galera_04.succeed(
"sudo -u testuser mysql -u testuser -e 'use testdb; insert into db2 values (42);'"
)
galera_06.succeed(
"sudo -u testuser mysql -u root -e 'use testdb; create table db3 (test_id INT, PRIMARY KEY (test_id)) ENGINE = InnoDB;'"
"sudo -u testuser mysql -u testuser -e 'use testdb; create table db3 (test_id INT, PRIMARY KEY (test_id)) ENGINE = InnoDB;'"
)
galera_04.succeed(
"sudo -u testuser mysql -u testuser -e 'use testdb; insert into db3 values (43);'"
@ -195,22 +195,22 @@ in {
galera_05.succeed("systemctl start mysql")
galera_05.wait_for_open_port(3306)
galera_05.succeed(
"sudo -u testuser mysql -u root -e 'show status' -N | grep 'wsrep_cluster_size.*3'"
"sudo -u testuser mysql -u testuser -e 'show status' -N | grep 'wsrep_cluster_size.*3'"
)
galera_06.succeed(
"sudo -u testuser mysql -u root -e 'show status' -N | grep 'wsrep_local_state_comment.*Synced'"
"sudo -u testuser mysql -u testuser -e 'show status' -N | grep 'wsrep_local_state_comment.*Synced'"
)
galera_04.succeed(
"sudo -u testuser mysql -u root -e 'use testdb; select test_id from db3;' -N | grep 43"
"sudo -u testuser mysql -u testuser -e 'use testdb; select test_id from db3;' -N | grep 43"
)
galera_05.succeed(
"sudo -u testuser mysql -u root -e 'use testdb; select test_id from db2;' -N | grep 42"
"sudo -u testuser mysql -u testuser -e 'use testdb; select test_id from db2;' -N | grep 42"
)
galera_06.succeed(
"sudo -u testuser mysql -u root -e 'use testdb; select test_id from db1;' -N | grep 41"
"sudo -u testuser mysql -u testuser -e 'use testdb; select test_id from db1;' -N | grep 41"
)
galera_04.succeed("sudo -u testuser mysql -u testuser -e 'use testdb; drop table db3;'")
galera_05.succeed("sudo -u testuser mysql -u root -e 'use testdb; drop table db2;'")
galera_06.succeed("sudo -u testuser mysql -u root -e 'use testdb; drop table db1;'")
galera_05.succeed("sudo -u testuser mysql -u testuser -e 'use testdb; drop table db2;'")
galera_06.succeed("sudo -u testuser mysql -u testuser -e 'use testdb; drop table db1;'")
'';
})

12
nixos/tests/mysql/mysql-replication.nix
View File

@ -59,7 +59,7 @@ in
master.wait_for_open_port(3306)
# Wait for testdb to be fully populated (5 rows).
master.wait_until_succeeds(
"mysql -u root -D testdb -N -B -e 'select count(id) from tests' | grep -q 5"
"sudo -u mysql mysql -u mysql -D testdb -N -B -e 'select count(id) from tests' | grep -q 5"
)
slave1.start()
@ -71,19 +71,21 @@ in
# wait for replications to finish
slave1.wait_until_succeeds(
"mysql -u root -D testdb -N -B -e 'select count(id) from tests' | grep -q 5"
"sudo -u mysql mysql -u mysql -D testdb -N -B -e 'select count(id) from tests' | grep -q 5"
)
slave2.wait_until_succeeds(
"mysql -u root -D testdb -N -B -e 'select count(id) from tests' | grep -q 5"
"sudo -u mysql mysql -u mysql -D testdb -N -B -e 'select count(id) from tests' | grep -q 5"
)
slave2.succeed("systemctl stop mysql")
master.succeed("echo 'insert into testdb.tests values (123, 456);' | mysql -u root -N")
master.succeed(
"echo 'insert into testdb.tests values (123, 456);' | sudo -u mysql mysql -u mysql -N"
)
slave2.succeed("systemctl start mysql")
slave2.wait_for_unit("mysql")
slave2.wait_for_open_port(3306)
slave2.wait_until_succeeds(
"echo 'select * from testdb.tests where Id = 123;' | mysql -u root -N | grep 456"
"echo 'select * from testdb.tests where Id = 123;' | sudo -u mysql mysql -u mysql -N | grep 456"
)
'';
})

24
nixos/tests/systemd-binfmt.nix Normal file
View File

@ -0,0 +1,24 @@
# Teach the kernel how to run armv7l and aarch64-linux binaries,
# and run GNU Hello for these architectures.
import ./make-test-python.nix ({ pkgs, ... }: {
name = "systemd-binfmt";
machine = {
boot.binfmt.emulatedSystems = [
"armv7l-linux"
"aarch64-linux"
];
};
testScript = let
helloArmv7l = pkgs.pkgsCross.armv7l-hf-multiplatform.hello;
helloAarch64 = pkgs.pkgsCross.aarch64-multiplatform.hello;
in ''
machine.start()
assert "world" in machine.succeed(
"${helloArmv7l}/bin/hello"
)
assert "world" in machine.succeed(
"${helloAarch64}/bin/hello"
)
'';
})

23
nixos/tests/zoneminder.nix Normal file
View File

@ -0,0 +1,23 @@
import ./make-test-python.nix ({ lib, ...}:
{
name = "zoneminder";
meta.maintainers = with lib.maintainers; [ danielfullmer ];
machine = { ... }:
{
services.zoneminder = {
enable = true;
database.createLocally = true;
database.username = "zoneminder";
};
time.timeZone = "America/New_York";
};
testScript = ''
machine.wait_for_unit("zoneminder.service")
machine.wait_for_unit("nginx.service")
machine.wait_for_open_port(8095)
machine.succeed("curl --fail http://localhost:8095/")
'';
})

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

@ -7,12 +7,12 @@
with stdenv.lib;
stdenv.mkDerivation rec {
version = "2.3.3";
version = "2.4.0";
pname = "audacity";
src = fetchzip {
url = "https://github.com/audacity/audacity/archive/Audacity-${version}.tar.gz";
sha256 = "0ddc03dbm4ixy877czmwd03fpjgr3y68bxfgb6n2q6cv4prp30ig";
sha256 = "1f0lbzisqaj4pr9xxsx105a9ibym2qbngalnsb7iwmcvyrpc0l6a";
};
preConfigure = /* we prefer system-wide libs */ ''

28
pkgs/applications/audio/bjumblr/default.nix Normal file
View File

@ -0,0 +1,28 @@
{ stdenv, fetchFromGitHub, libX11, cairo, lv2, pkgconfig, libsndfile }:
stdenv.mkDerivation rec {
pname = "BJumblr";
version = "0.2";
src = fetchFromGitHub {
owner = "sjaehn";
repo = pname;
rev = "v${version}";
sha256 = "14z8113zkwykbhm1a8h2xs972dgifvlfij92b08jckyc7cbz84ys";
};
nativeBuildInputs = [ pkgconfig ];
buildInputs = [
libX11 cairo lv2 libsndfile
];
installFlags = [ "PREFIX=$(out)" ];
meta = with stdenv.lib; {
homepage = "https://github.com/sjaehn/BJumblr";
description = "Pattern-controlled audio stream / sample re-sequencer LV2 plugin";
maintainers = [ maintainers.magnetophon ];
platforms = platforms.linux;
license = licenses.gpl3;
};
}

12
pkgs/applications/audio/lsp-plugins/default.nix
View File

@ -1,4 +1,4 @@
{ stdenv, fetchFromGitHub, pkgconfig, makeWrapper
{ stdenv, fetchFromGitHub, fetchpatch, pkgconfig, makeWrapper
, libsndfile, jack2Full
, libGLU, libGL, lv2, cairo
, ladspaH, php }:
@ -14,6 +14,16 @@ stdenv.mkDerivation rec {
sha256 = "1wiph3vxhydc6mr9hn2c6crd4cx592l2zv0wrzgmpnlm1lflzpbg";
};
patches = [
# Fix build
# https://github.com/sadko4u/lsp-plugins/issues/104
(fetchpatch {
url = "https://github.com/sadko4u/lsp-plugins/commit/4d901135fb82fa95e668b4d55d05e405f5e620d2.patch";
excludes = [ "TODO.txt" ];
sha256 = "wR2B6XnDXT2BGwmrsL72PH/BM1e9d9JvqHxDtfFDAug=";
})
];
nativeBuildInputs = [ pkgconfig php makeWrapper ];
buildInputs = [ jack2Full libsndfile libGLU libGL lv2 cairo ladspaH ];

8
pkgs/applications/audio/schismtracker/default.nix
View File

@ -4,26 +4,26 @@
stdenv.mkDerivation rec {
pname = "schismtracker";
version = "20190805";
version = "20200412";
src = fetchFromGitHub {
owner = pname;
repo = pname;
rev = version;
sha256 = "0qqps20vvn3rgpg8174bjrrm38gqcci2z5z4c1r1vhbccclahgsd";
sha256 = "1n6cgjiw3vkv7a1h1nki5syyjxjb6icknr9s049w2jrag10bxssn";
};
configureFlags = [ "--enable-dependency-tracking" ];
nativeBuildInputs = [ autoreconfHook python ];
buildInputs = [ alsaLib SDL ];
buildInputs = [ SDL ] ++ stdenv.lib.optional stdenv.isLinux alsaLib;
meta = with stdenv.lib; {
description = "Music tracker application, free reimplementation of Impulse Tracker";
homepage = "http://schismtracker.org/";
license = licenses.gpl2;
platforms = [ "x86_64-linux" "i686-linux" ];
platforms = [ "x86_64-linux" "i686-linux" "x86_64-darwin" ];
maintainers = with maintainers; [ ftrvxmtrx ];
};
}

10
pkgs/applications/audio/sfizz/default.nix
View File

@ -1,18 +1,18 @@
{ stdenv, fetchFromGitHub , cmake, libjack2, libsndfile }:
{ stdenv, fetchFromGitHub , cmake, libjack2, libsndfile, pkgconfig }:
stdenv.mkDerivation rec {
pname = "sfizz";
version = "unstable-2020-01-24";
version = "0.3.2";
src = fetchFromGitHub {
owner = "sfztools";
repo = pname;
rev = "b9c332777853cb35faeeda2ff4bf34ea7121ffb9";
sha256 = "0wzgwpcwal5a7ifrm1hx8y6vx832qixk9ilp8wkjnsdxj6i88p2c";
rev = version;
sha256 = "1px22x9lb6wyqfbv1jg1sbl1rsnwrzs8sm4dnas1w4ifchiv3ymd";
fetchSubmodules = true;
};
nativeBuildInputs = [ cmake ];
nativeBuildInputs = [ cmake pkgconfig ];
buildInputs = [ libjack2 libsndfile ];

20
pkgs/applications/blockchains/go-ethereum.nix
View File

@ -2,16 +2,30 @@
buildGoModule rec {
pname = "go-ethereum";
version = "1.9.13";
version = "1.9.14";
src = fetchFromGitHub {
owner = "ethereum";
repo = pname;
rev = "v${version}";
sha256 = "1yqqflp73yvjy6bp05xd1nv5fc6p1nx7g4spbssxf3ws96pdh425";
sha256 = "0vqsx4q7jn6vhmrm9kkk810d5nvnmyb6bni38ynkxcwlrp3qs6v2";
};
modSha256 = "07xrw3fivfpbkg4mp8ghrj1bishfas82dbd780fymgs2h74iigf3";
usb = fetchFromGitHub {
owner = "karalabe";
repo = "usb";
rev = "911d15fe12a9c411cf5d0dd5635231c759399bed";
sha256 = "0asd5fz2rhzkjmd8wjgmla5qmqyz4jaa6qf0n2ycia16jsck6wc2";
};
vendorSha256 = "01mbmc8qlp08127dlmcqz0viasmg7mrzqzmyw21an69sabcr112n";
overrideModAttrs = (_: {
postBuild = ''
cp -r --reflink=auto ${usb}/libusb vendor/github.com/karalabe/usb
cp -r --reflink=auto ${usb}/hidapi vendor/github.com/karalabe/usb
'';
});
subPackages = [
"cmd/abidump"

2
pkgs/applications/blockchains/lnd.nix
View File

@ -11,7 +11,7 @@ buildGoModule rec {
sha256 = "1amciz924s2h6qhy7w34jpv1jc25p5ayfxzvjph6hhx0bccrm88w";
};
modSha256 = "15i4h3pkvyav9qsbfinzifram0knkylg24j6j0mxs4bnj80j4ycm";
vendorSha256 = "1iyghg11cxvbzi0gl40fvv8pl3d3k52j179w3x5m1f09r5ji223y";
subPackages = ["cmd/lncli" "cmd/lnd"];

4
pkgs/applications/editors/apostrophe/default.nix
View File

@ -11,14 +11,14 @@ let
in stdenv.mkDerivation rec {
pname = "apostrophe";
version = "2.2.0.2";
version = "2.2.0.3";
src = fetchFromGitLab {
owner = "somas";
repo = pname;
domain = "gitlab.gnome.org";
rev = "v${version}";
sha256 = "13wvfkg0jw9mayd9ifzkqnhf8fmfjgr1lsj4niqbyrw130y9r9f6";
sha256 = "06bl1hc69ixk2vcb2ig74mwid14sl5zq6rfna7lx9na6j3l04879";
};
nativeBuildInputs = [ meson ninja cmake pkgconfig desktop-file-utils

162
pkgs/applications/editors/emacs-modes/elpa-generated.nix generated
View File

@ -39,10 +39,10 @@
elpaBuild {
pname = "ada-mode";
ename = "ada-mode";
version = "7.0.1";
version = "7.1.1";
src = fetchurl {
url = "https://elpa.gnu.org/packages/ada-mode-7.0.1.tar";
sha256 = "0iqninv4wf4ap8axk9m0gi39j3kq4jpbpdc8hczd34xrp83ml46a";
url = "https://elpa.gnu.org/packages/ada-mode-7.1.1.tar";
sha256 = "11ch0dn478ddzkcjcyqf2rjim7w0fjb8xfijqxxi07847w4gkklp";
};
packageRequires = [ emacs uniquify-files wisi ];
meta = {
@ -223,10 +223,10 @@
elpaBuild {
pname = "auctex";
ename = "auctex";
version = "12.2.0";
version = "12.2.1";
src = fetchurl {
url = "https://elpa.gnu.org/packages/auctex-12.2.0.tar";
sha256 = "0j919l3q5sq6h1k1kmk4kyv0vkzl4f98fxcd64v34x5q1ahjhg48";
url = "https://elpa.gnu.org/packages/auctex-12.2.1.tar";
sha256 = "14y0kdri2zvz81qwpncsr3ly4ciqab6g8yxl956k3ddn36b3a56s";
};
packageRequires = [ cl-lib emacs ];
meta = {
@ -685,10 +685,10 @@
elpaBuild {
pname = "darkroom";
ename = "darkroom";
version = "0.2";
version = "0.3";
src = fetchurl {
url = "https://elpa.gnu.org/packages/darkroom-0.2.el";
sha256 = "1a528brhz4vckhp77n2c1phkyqdliykpj9kzk3f834f4rwnb5mp0";
url = "https://elpa.gnu.org/packages/darkroom-0.3.el";
sha256 = "0l1xg5kqmjw22k78qnsln0ifx2dx74xxqj0qp8xxcpqvzzx0xh86";
};
packageRequires = [ cl-lib ];
meta = {
@ -925,10 +925,10 @@
elpaBuild {
pname = "ebdb";
ename = "ebdb";
version = "0.6.16";
version = "0.6.17";
src = fetchurl {
url = "https://elpa.gnu.org/packages/ebdb-0.6.16.tar";
sha256 = "0yn0nqjp68kwlrd4qs9fg3xizm9jnddkkyw25l0llq04b53zgjdl";
url = "https://elpa.gnu.org/packages/ebdb-0.6.17.tar";
sha256 = "07335pcqvvj1apzbwy4dc4i6pc6w21hr7v9fvgkc9c2x7fqlqg24";
};
packageRequires = [ cl-lib emacs seq ];
meta = {
@ -1036,6 +1036,21 @@
license = lib.licenses.free;
};
}) {};
eldoc = callPackage ({ elpaBuild, emacs, fetchurl, lib }:
elpaBuild {
pname = "eldoc";
ename = "eldoc";
version = "1.0.0";
src = fetchurl {
url = "https://elpa.gnu.org/packages/eldoc-1.0.0.el";
sha256 = "0jdqnndvpz929rbfgrm2bgw3z2vp7dvvgk3wnhvlhf63mdiza89m";
};
packageRequires = [ emacs ];
meta = {
homepage = "https://elpa.gnu.org/packages/eldoc.html";
license = lib.licenses.free;
};
}) {};
eldoc-eval = callPackage ({ elpaBuild, fetchurl, lib }:
elpaBuild {
pname = "eldoc-eval";
@ -1367,10 +1382,10 @@
elpaBuild {
pname = "gnorb";
ename = "gnorb";
version = "1.6.6";
version = "1.6.7";
src = fetchurl {
url = "https://elpa.gnu.org/packages/gnorb-1.6.6.tar";
sha256 = "1vlb9q7a622qylrgip5ld2yrzp4l58gl543i2jdxr7jxvamy22bp";
url = "https://elpa.gnu.org/packages/gnorb-1.6.7.tar";
sha256 = "17pz6i51z298rk7j3rraw1gxlssn88yi4bbpzyxv9cs7y1lfy8ld";
};
packageRequires = [ cl-lib ];
meta = {
@ -1378,6 +1393,21 @@
license = lib.licenses.free;
};
}) {};
gnu-elpa = callPackage ({ elpaBuild, fetchurl, lib }:
elpaBuild {
pname = "gnu-elpa";
ename = "gnu-elpa";
version = "1.1";
src = fetchurl {
url = "https://elpa.gnu.org/packages/gnu-elpa-1.1.tar";
sha256 = "0b0law1xwwqa42wb09b3w73psq2kx16lkiwxjxl0sshjcmarhv8r";
};
packageRequires = [];
meta = {
homepage = "https://elpa.gnu.org/packages/gnu-elpa.html";
license = lib.licenses.free;
};
}) {};
gnu-elpa-keyring-update = callPackage ({ elpaBuild
, fetchurl
, lib }:
@ -1419,10 +1449,10 @@
elpaBuild {
pname = "gnus-mock";
ename = "gnus-mock";
version = "0.4.4";
version = "0.4.5";
src = fetchurl {
url = "https://elpa.gnu.org/packages/gnus-mock-0.4.4.tar";
sha256 = "0v94z800f1y3ylbgbrw4nslqm7j2jr592g402nxgj9rlldazzxg0";
url = "https://elpa.gnu.org/packages/gnus-mock-0.4.5.tar";
sha256 = "1hfh315vrxd54r2f1wpdfk06b7lhpab7knygav58vdwwdbndlqiz";
};
packageRequires = [];
meta = {
@ -1696,10 +1726,10 @@
elpaBuild {
pname = "jsonrpc";
ename = "jsonrpc";
version = "1.0.9";
version = "1.0.11";
src = fetchurl {
url = "https://elpa.gnu.org/packages/jsonrpc-1.0.9.el";
sha256 = "1ncsdv9pr2zsfa9mxm4n68fppnkpm410mh72r7h5f8yj17lz00ss";
url = "https://elpa.gnu.org/packages/jsonrpc-1.0.11.el";
sha256 = "04cy1mqd6y8k5lcpg076szjk9av9345mmsnzzh6vgbcw3dcgbr23";
};
packageRequires = [ emacs ];
meta = {
@ -1981,10 +2011,10 @@
elpaBuild {
pname = "minimap";
ename = "minimap";
version = "1.2";
version = "1.3";
src = fetchurl {
url = "https://elpa.gnu.org/packages/minimap-1.2.el";
sha256 = "1vcxdxy7mv8mi4lrri3kmyf9kly3rb02z4kpfx5d1xv493havvb8";
url = "https://elpa.gnu.org/packages/minimap-1.3.el";
sha256 = "15azlmi6kk9pg1c4zrw952qsh9wq6ggqb4qqc84a7l67nhqb9bqp";
};
packageRequires = [];
meta = {
@ -2011,10 +2041,10 @@
elpaBuild {
pname = "modus-operandi-theme";
ename = "modus-operandi-theme";
version = "0.7.0";
version = "0.8.1";
src = fetchurl {
url = "https://elpa.gnu.org/packages/modus-operandi-theme-0.7.0.el";
sha256 = "17zvcqplbl3rk39k61v43ganzv06j49rlyickanwll5m1a3iibw2";
url = "https://elpa.gnu.org/packages/modus-operandi-theme-0.8.1.el";
sha256 = "0i8s6blkhx53m1jk1bblqs7fwlbn57xkxxhsp9famcj5m0xyfimb";
};
packageRequires = [ emacs ];
meta = {
@ -2026,10 +2056,10 @@
elpaBuild {
pname = "modus-vivendi-theme";
ename = "modus-vivendi-theme";
version = "0.7.0";
version = "0.8.1";
src = fetchurl {
url = "https://elpa.gnu.org/packages/modus-vivendi-theme-0.7.0.el";
sha256 = "1w4vrg39dghghkvll3h4kmzykc3zpp6pbychb39gcc13z2b06v8g";
url = "https://elpa.gnu.org/packages/modus-vivendi-theme-0.8.1.el";
sha256 = "121nlr5w58j4q47rh9xjjf9wzb97yl2m1n2l6g58ck4vnarwndl1";
};
packageRequires = [ emacs ];
meta = {
@ -2455,10 +2485,10 @@
elpaBuild {
pname = "phps-mode";
ename = "phps-mode";
version = "0.3.43";
version = "0.3.48";
src = fetchurl {
url = "https://elpa.gnu.org/packages/phps-mode-0.3.43.tar";
sha256 = "099s7c0ll8bbfgynijjaciv2qnyg4r2akajkhlmchh7y10kp5ii4";
url = "https://elpa.gnu.org/packages/phps-mode-0.3.48.tar";
sha256 = "1mnbrsgh6lx7kgkfsfq5zk78a97iwh8mxgxzyf1zq4jj6ziwd6bv";
};
packageRequires = [ emacs ];
meta = {
@ -2511,6 +2541,21 @@
license = lib.licenses.free;
};
}) {};
project = callPackage ({ elpaBuild, emacs, fetchurl, lib }:
elpaBuild {
pname = "project";
ename = "project";
version = "0.1.2";
src = fetchurl {
url = "https://elpa.gnu.org/packages/project-0.1.2.el";
sha256 = "0713hwim1chf6lxpg1rb234aa1gj92c153fjlc4jddp6dzzgn50d";
};
packageRequires = [ emacs ];
meta = {
homepage = "https://elpa.gnu.org/packages/project.html";
license = lib.licenses.free;
};
}) {};
psgml = callPackage ({ elpaBuild, fetchurl, lib }:
elpaBuild {
pname = "psgml";
@ -2795,10 +2840,10 @@
elpaBuild {
pname = "relint";
ename = "relint";
version = "1.15";
version = "1.17";
src = fetchurl {
url = "https://elpa.gnu.org/packages/relint-1.15.tar";
sha256 = "0sxmdsacj8my942k8j76m2y68nzab7190acv7cwgflc5n4f07yxa";
url = "https://elpa.gnu.org/packages/relint-1.17.tar";
sha256 = "1nv13dqdhf72c1jgk1ml4k6jqb8wsyphcx2vhsyhig5198lg4kd7";
};
packageRequires = [ emacs xr ];
meta = {
@ -3255,10 +3300,10 @@
elpaBuild {
pname = "tramp";
ename = "tramp";
version = "2.4.3.3";
version = "2.4.3.4";
src = fetchurl {
url = "https://elpa.gnu.org/packages/tramp-2.4.3.3.tar";
sha256 = "1di9ia59k6x7j9r8flwf05r160j30nrg0jvq5fjc9iazag9lniyw";
url = "https://elpa.gnu.org/packages/tramp-2.4.3.4.tar";
sha256 = "01il42xb6s38qnb7bhn9d7gscc5p5y4da5a4dp1i1cyi823sfp8f";
};
packageRequires = [ emacs ];
meta = {
@ -3345,10 +3390,10 @@
elpaBuild {
pname = "uniquify-files";
ename = "uniquify-files";
version = "1.0.2";
version = "1.0.3";
src = fetchurl {
url = "https://elpa.gnu.org/packages/uniquify-files-1.0.2.tar";
sha256 = "1vib79wsz5k94b9z0wiwhbzsdm70y9dla6szw2bb75245cx3kr0h";
url = "https://elpa.gnu.org/packages/uniquify-files-1.0.3.tar";
sha256 = "04yfys615ncz3jyh3hx5sg6x6szx028223184zv52skb4j99vkwq";
};
packageRequires = [ emacs ];
meta = {
@ -3659,10 +3704,10 @@
elpaBuild {
pname = "wisi";
ename = "wisi";
version = "3.0.1";
version = "3.1.1";
src = fetchurl {
url = "https://elpa.gnu.org/packages/wisi-3.0.1.tar";
sha256 = "01961apbirdi4y8qx2wb01f04knkw3hyin3ndrkjlkfslqbsnzzv";
url = "https://elpa.gnu.org/packages/wisi-3.1.1.tar";
sha256 = "0abm9xfyk2izi0w9172sfhdq83abcxgbngngbh2gby54df0ycn0q";
};
packageRequires = [ emacs seq ];
meta = {
@ -3679,10 +3724,10 @@
elpaBuild {
pname = "wisitoken-grammar-mode";
ename = "wisitoken-grammar-mode";
version = "1.0.3";
version = "1.1.0";
src = fetchurl {
url = "https://elpa.gnu.org/packages/wisitoken-grammar-mode-1.0.3.tar";
sha256 = "1vljnhi35vix30xch9mziczg56ss1r615yn2pgdcw8wa8sm14crw";
url = "https://elpa.gnu.org/packages/wisitoken-grammar-mode-1.1.0.tar";
sha256 = "123z9j76cm0p22d9n4kqvn2477fdkgp5jarw564nd71cxrrb52ms";
};
packageRequires = [ emacs mmm-mode wisi ];
meta = {
@ -3754,10 +3799,10 @@
elpaBuild {
pname = "xr";
ename = "xr";
version = "1.18";
version = "1.19";
src = fetchurl {
url = "https://elpa.gnu.org/packages/xr-1.18.tar";
sha256 = "1nq9pj47sxgpkw97c2xrkhgcwh3zsfd2a22qiqbl4i9zf2l9yy91";
url = "https://elpa.gnu.org/packages/xr-1.19.tar";
sha256 = "1aa3iqh0r635jw8k89zh8y4am9d4hfrqpk9mrdh2b51invjn8llq";
};
packageRequires = [ emacs ];
meta = {
@ -3765,6 +3810,21 @@
license = lib.licenses.free;
};
}) {};
xref = callPackage ({ elpaBuild, emacs, fetchurl, lib, project }:
elpaBuild {
pname = "xref";
ename = "xref";
version = "1.0.1";
src = fetchurl {
url = "https://elpa.gnu.org/packages/xref-1.0.1.el";
sha256 = "17wlwilm2d1gvin8mkkqnpw2skjx0klxfs1pqpy8rrzdfpsb55li";
};
packageRequires = [ emacs project ];
meta = {
homepage = "https://elpa.gnu.org/packages/xref.html";
license = lib.licenses.free;
};
}) {};
yasnippet = callPackage ({ cl-lib ? null, elpaBuild, fetchurl, lib }:
elpaBuild {
pname = "yasnippet";

10
pkgs/applications/editors/emacs-modes/elpa-packages.nix
View File

@ -8,6 +8,16 @@ To update the list of packages from MELPA,
2. Check for evaluation errors: `nix-instantiate ../../../.. -A emacsPackagesNg.elpaPackages`.
3. `git commit -m "elpa-packages $(date -Idate)" -- elpa-generated.nix`
## Update from overlay
Alternatively, run the following command:
./update-from-overlay
It will update both melpa and elpa packages using
https://github.com/nix-community/emacs-overlay. It's almost
instantenous and formats commits for you.
*/
{ lib, stdenv, texinfo }:

4
pkgs/applications/editors/emacs-modes/manual-packages.nix
View File

@ -98,7 +98,7 @@
sha256 = "09b7bg2s9aa4s8f2kdqs4xps3jxkq5wsvbi87ih8b6id38blhf78";
};
recipe = pkgs.writeText "recipe" ''
(haskell-unicode-input-method
(emacs-haskell-unicode-input-method
:repo "roelvandijk/emacs-haskell-unicode-input-method"
:fetcher github)
'';
@ -136,7 +136,6 @@
emacsSessionManagement = callPackage ./session-management-for-emacs { };
hsc3-mode = callPackage ./hsc3 { };
ido-ubiquitous = callPackage ./ido-ubiquitous { };
ocaml-mode = callPackage ./ocaml { };
prolog-mode = callPackage ./prolog { };
rectMark = callPackage ./rect-mark { };
sunriseCommander = callPackage ./sunrise-commander { };
@ -146,7 +145,6 @@
#
# Ideally this should be dropped some time during/after 20.03
bbdb3 = self.melpaStablePackages.bbdb;
ocamlMode = self.ocaml-mode;
jade = self.jade-mode;
# scalaMode2 = null; # No clear mapping as of now
flymakeCursor = self.melpaStablePackages.flymake-cursor;

259
pkgs/applications/editors/emacs-modes/melpa-packages.nix
View File

@ -10,44 +10,62 @@ env NIXPKGS_ALLOW_BROKEN=1 nix-instantiate --show-trace ../../../../ -A emacsPac
env NIXPKGS_ALLOW_BROKEN=1 nix-instantiate --show-trace ../../../../ -A emacsPackages.melpaPackages
3. `git commit -m "melpa-packages: $(date -Idate)" recipes-archive-melpa.json`
## Update from overlay
Alternatively, run the following command:
./update-from-overlay
It will update both melpa and elpa packages using
https://github.com/nix-community/emacs-overlay. It's almost
instantenous and formats commits for you.
*/
{ lib, external, pkgs }: variant: self: let
{ lib, external, pkgs }: variant: self:
let
dontConfigure = pkg:
if pkg != null then pkg.override (args: {
melpaBuild = drv: args.melpaBuild (drv // {
dontConfigure = true;
});
}) else null;
dontConfigure = pkg: if pkg != null then pkg.override (args: {
melpaBuild = drv: args.melpaBuild (drv // {
dontConfigure = true;
});
}) else null;
markBroken = pkg:
if pkg != null then pkg.override (args: {
melpaBuild = drv: args.melpaBuild (drv // {
meta = (drv.meta or { }) // { broken = true; };
});
}) else null;
markBroken = pkg: if pkg != null then pkg.override (args: {
melpaBuild = drv: args.melpaBuild (drv // {
meta = (drv.meta or {}) // { broken = true; };
});
}) else null;
externalSrc = pkg: epkg:
if pkg != null then pkg.override (args: {
melpaBuild = drv: args.melpaBuild (drv // {
inherit (epkg) src version;
externalSrc = pkg : epkg : if pkg != null then pkg.override (args : {
melpaBuild = drv : args.melpaBuild (drv // {
inherit (epkg) src version;
propagatedUserEnvPkgs = [ epkg ];
});
}) else null;
propagatedUserEnvPkgs = [ epkg ];
});
}) else null;
fix-rtags = pkg:
if pkg != null then dontConfigure (externalSrc pkg external.rtags)
else null;
fix-rtags = pkg : if pkg != null then dontConfigure (externalSrc pkg external.rtags)
else null;
generateMelpa = lib.makeOverridable ({ archiveJson ? ./recipes-archive-melpa.json
}:
let
inherit (import ./libgenerated.nix lib self) melpaDerivation;
super = (
lib.listToAttrs (builtins.filter
(s: s != null)
(map
(melpaDerivation variant)
(lib.importJSON archiveJson)
)
)
);
generateMelpa = lib.makeOverridable ({
archiveJson ? ./recipes-archive-melpa.json
}: let
inherit (import ./libgenerated.nix lib self) melpaDerivation;
super = lib.listToAttrs (builtins.filter (s: s != null)
(map (melpaDerivation variant)
(lib.importJSON archiveJson)));
overrides = rec {
shared = rec {
overrides = {
# Expects bash to be at /bin/bash
ac-rtags = fix-rtags super.ac-rtags;
@ -55,12 +73,11 @@ env NIXPKGS_ALLOW_BROKEN=1 nix-instantiate --show-trace ../../../../ -A emacsPac
inherit (self.melpaPackages) powerline;
};
auto-complete-clang-async = super.auto-complete-clang-async.overrideAttrs(old: {
auto-complete-clang-async = super.auto-complete-clang-async.overrideAttrs (old: {
buildInputs = old.buildInputs ++ [ external.llvmPackages.llvm ];
CFLAGS = "-I${external.llvmPackages.clang}/include";
LDFLAGS = "-L${external.llvmPackages.clang}/lib";
});
emacsClangCompleteAsync = auto-complete-clang-async;
# part of a larger package
caml = dontConfigure super.caml;
@ -75,7 +92,9 @@ env NIXPKGS_ALLOW_BROKEN=1 nix-instantiate --show-trace ../../../../ -A emacsPac
inherit (self.melpaPackages) easy-kill;
};
emacsql-sqlite = super.emacsql-sqlite.overrideAttrs(old: {
dune = dontConfigure super.dune;
emacsql-sqlite = super.emacsql-sqlite.overrideAttrs (old: {
buildInputs = old.buildInputs ++ [ pkgs.sqlite ];
postBuild = ''
@ -104,26 +123,32 @@ env NIXPKGS_ALLOW_BROKEN=1 nix-instantiate --show-trace ../../../../ -A emacsPac
evil-magit = super.evil-magit.overrideAttrs (attrs: {
# searches for Git at build time
nativeBuildInputs =
(attrs.nativeBuildInputs or []) ++ [ external.git ];
(attrs.nativeBuildInputs or [ ]) ++ [ external.git ];
});
eopengrok = super.eopengrok.overrideAttrs (attrs: {
nativeBuildInputs =
(attrs.nativeBuildInputs or []) ++ [ external.git ];
(attrs.nativeBuildInputs or [ ]) ++ [ external.git ];
});
ess-R-data-view = super.ess-R-data-view.override {
inherit (self.melpaPackages) ess ctable popup;
};
forge = super.forge.overrideAttrs (attrs: {
# searches for Git at build time
nativeBuildInputs =
(attrs.nativeBuildInputs or [ ]) ++ [ external.git ];
});
flycheck-rtags = fix-rtags super.flycheck-rtags;
gnuplot = super.gnuplot.overrideAttrs (old: {
nativeBuildInputs =
(old.nativeBuildInputs or []) ++ [ pkgs.autoreconfHook ];
(old.nativeBuildInputs or [ ]) ++ [ pkgs.autoreconfHook ];
});
pdf-tools = super.pdf-tools.overrideAttrs(old: {
pdf-tools = super.pdf-tools.overrideAttrs (old: {
nativeBuildInputs = [ external.pkgconfig ];
buildInputs = with external; old.buildInputs ++ [ autoconf automake libpng zlib poppler ];
preBuild = "make server/epdfinfo";
@ -140,7 +165,7 @@ env NIXPKGS_ALLOW_BROKEN=1 nix-instantiate --show-trace ../../../../ -A emacsPac
});
irony = super.irony.overrideAttrs (old: {
cmakeFlags = old.cmakeFlags or [] ++ [ "-DCMAKE_INSTALL_BINDIR=bin" ];
cmakeFlags = old.cmakeFlags or [ ] ++ [ "-DCMAKE_INSTALL_BINDIR=bin" ];
NIX_CFLAGS_COMPILE = "-UCLANG_RESOURCE_DIR";
preConfigure = ''
cd server
@ -174,115 +199,115 @@ env NIXPKGS_ALLOW_BROKEN=1 nix-instantiate --show-trace ../../../../ -A emacsPac
magit = super.magit.overrideAttrs (attrs: {
# searches for Git at build time
nativeBuildInputs =
(attrs.nativeBuildInputs or []) ++ [ external.git ];
(attrs.nativeBuildInputs or [ ]) ++ [ external.git ];
});
magit-find-file = super.magit-find-file.overrideAttrs (attrs: {
# searches for Git at build time
nativeBuildInputs =
(attrs.nativeBuildInputs or []) ++ [ external.git ];
(attrs.nativeBuildInputs or [ ]) ++ [ external.git ];
});
magit-gh-pulls = super.magit-gh-pulls.overrideAttrs (attrs: {
# searches for Git at build time
nativeBuildInputs =
(attrs.nativeBuildInputs or []) ++ [ external.git ];
(attrs.nativeBuildInputs or [ ]) ++ [ external.git ];
});
magit-imerge = super.magit-imerge.overrideAttrs (attrs: {
# searches for Git at build time
nativeBuildInputs =
(attrs.nativeBuildInputs or []) ++ [ external.git ];
(attrs.nativeBuildInputs or [ ]) ++ [ external.git ];
});
magit-lfs = super.magit-lfs.overrideAttrs (attrs: {
# searches for Git at build time
nativeBuildInputs =
(attrs.nativeBuildInputs or []) ++ [ external.git ];
(attrs.nativeBuildInputs or [ ]) ++ [ external.git ];
});
magit-org-todos = super.magit-org-todos.overrideAttrs (attrs: {
# searches for Git at build time
nativeBuildInputs =
(attrs.nativeBuildInputs or []) ++ [ external.git ];
(attrs.nativeBuildInputs or [ ]) ++ [ external.git ];
});
magit-stgit = super.magit-stgit.overrideAttrs (attrs: {
# searches for Git at build time
nativeBuildInputs =
(attrs.nativeBuildInputs or []) ++ [ external.git ];
(attrs.nativeBuildInputs or [ ]) ++ [ external.git ];
});
magit-tbdiff = super.magit-tbdiff.overrideAttrs (attrs: {
# searches for Git at build time
nativeBuildInputs =
(attrs.nativeBuildInputs or []) ++ [ external.git ];
(attrs.nativeBuildInputs or [ ]) ++ [ external.git ];
});
magit-topgit = super.magit-topgit.overrideAttrs (attrs: {
# searches for Git at build time
nativeBuildInputs =
(attrs.nativeBuildInputs or []) ++ [ external.git ];
(attrs.nativeBuildInputs or [ ]) ++ [ external.git ];
});
magit-vcsh = super.magit-vcsh.overrideAttrs (attrs: {
# searches for Git at build time
nativeBuildInputs =
(attrs.nativeBuildInputs or []) ++ [ external.git ];
(attrs.nativeBuildInputs or [ ]) ++ [ external.git ];
});
magit-gerrit = super.magit-gerrit.overrideAttrs (attrs: {
# searches for Git at build time
nativeBuildInputs =
(attrs.nativeBuildInputs or []) ++ [ external.git ];
(attrs.nativeBuildInputs or [ ]) ++ [ external.git ];
});
magit-annex = super.magit-annex.overrideAttrs (attrs: {
# searches for Git at build time
nativeBuildInputs =
(attrs.nativeBuildInputs or []) ++ [ external.git ];
(attrs.nativeBuildInputs or [ ]) ++ [ external.git ];
});
magit-todos = super.magit-todos.overrideAttrs (attrs: {
# searches for Git at build time
nativeBuildInputs =
(attrs.nativeBuildInputs or []) ++ [ external.git ];
(attrs.nativeBuildInputs or [ ]) ++ [ external.git ];
});
magit-filenotify = super.magit-filenotify.overrideAttrs (attrs: {
# searches for Git at build time
nativeBuildInputs =
(attrs.nativeBuildInputs or []) ++ [ external.git ];
(attrs.nativeBuildInputs or [ ]) ++ [ external.git ];
});
magit-gitflow = super.magit-gitflow.overrideAttrs (attrs: {
# searches for Git at build time
nativeBuildInputs =
(attrs.nativeBuildInputs or []) ++ [ external.git ];
(attrs.nativeBuildInputs or [ ]) ++ [ external.git ];
});
magithub = super.magithub.overrideAttrs (attrs: {
# searches for Git at build time
nativeBuildInputs =
(attrs.nativeBuildInputs or []) ++ [ external.git ];
(attrs.nativeBuildInputs or [ ]) ++ [ external.git ];
});
magit-svn = super.magit-svn.overrideAttrs (attrs: {
# searches for Git at build time
nativeBuildInputs =
(attrs.nativeBuildInputs or []) ++ [ external.git ];
(attrs.nativeBuildInputs or [ ]) ++ [ external.git ];
});
kubernetes = super.kubernetes.overrideAttrs (attrs: {
# searches for Git at build time
nativeBuildInputs =
(attrs.nativeBuildInputs or []) ++ [ external.git ];
(attrs.nativeBuildInputs or [ ]) ++ [ external.git ];
});
kubernetes-evil = super.kubernetes-evil.overrideAttrs (attrs: {
# searches for Git at build time
nativeBuildInputs =
(attrs.nativeBuildInputs or []) ++ [ external.git ];
(attrs.nativeBuildInputs or [ ]) ++ [ external.git ];
});
# upstream issue: missing file header
@ -298,12 +323,14 @@ env NIXPKGS_ALLOW_BROKEN=1 nix-instantiate --show-trace ../../../../ -A emacsPac
rtags = dontConfigure (externalSrc super.rtags external.rtags);
rtags-xref = dontConfigure super.rtags;
shm = super.shm.overrideAttrs (attrs: {
propagatedUserEnvPkgs = [ external.structured-haskell-mode ];
});
# Telega has a server portion for it's network protocol
telega = super.telega.overrideAttrs(old: {
telega = super.telega.overrideAttrs (old: {
buildInputs = old.buildInputs ++ [ pkgs.tdlib ];
postBuild = ''
@ -318,18 +345,27 @@ env NIXPKGS_ALLOW_BROKEN=1 nix-instantiate --show-trace ../../../../ -A emacsPac
'';
});
vdiff-magit = super.vdiff-magit.overrideAttrs (attrs: {
treemacs-magit = super.treemacs-magit.overrideAttrs (attrs: {
# searches for Git at build time
nativeBuildInputs =
(attrs.nativeBuildInputs or []) ++ [ external.git ];
(attrs.nativeBuildInputs or [ ]) ++ [ external.git ];
});
zmq = super.zmq.overrideAttrs(old: {
vdiff-magit = super.vdiff-magit.overrideAttrs (attrs: {
nativeBuildInputs =
(attrs.nativeBuildInputs or [ ]) ++ [ external.git ];
});
zmq = super.zmq.overrideAttrs (old: {
stripDebugList = [ "share" ];
preBuild = ''
make
'';
nativeBuildInputs = [
external.autoconf external.automake external.pkgconfig external.libtool
external.autoconf
external.automake
external.pkgconfig
external.libtool
(external.zeromq.override { enableDrafts = true; })
];
postInstall = ''
@ -351,9 +387,6 @@ env NIXPKGS_ALLOW_BROKEN=1 nix-instantiate --show-trace ../../../../ -A emacsPac
markdown-mode-plus = super."markdown-mode+";
package-plus = super."package+";
rect-plus = super."rect+";
};
stable = shared // {
# upstream issue: missing file header
bufshow = markBroken super.bufshow;
@ -364,9 +397,6 @@ env NIXPKGS_ALLOW_BROKEN=1 nix-instantiate --show-trace ../../../../ -A emacsPac
# upstream issue: missing file header
dictionary = markBroken super.dictionary;
# missing git
egg = markBroken super.egg;
# upstream issue: missing file header
elmine = markBroken super.elmine;
@ -385,8 +415,6 @@ env NIXPKGS_ALLOW_BROKEN=1 nix-instantiate --show-trace ../../../../ -A emacsPac
# upstream issue: doesn't build
eterm-256color = markBroken super.eterm-256color;
helm-rtags = fix-rtags super.helm-rtags;
# upstream issue: missing file header
qiita = markBroken super.qiita;
@ -405,9 +433,6 @@ env NIXPKGS_ALLOW_BROKEN=1 nix-instantiate --show-trace ../../../../ -A emacsPac
# upstream issue: missing file header
window-numbering = markBroken super.window-numbering;
};
unstable = shared // {
editorconfig = super.editorconfig.overrideAttrs (attrs: {
propagatedUserEnvPkgs = [ external.editorconfig-core-c ];
});
@ -415,7 +440,7 @@ env NIXPKGS_ALLOW_BROKEN=1 nix-instantiate --show-trace ../../../../ -A emacsPac
egg = super.egg.overrideAttrs (attrs: {
# searches for Git at build time
nativeBuildInputs =
(attrs.nativeBuildInputs or []) ++ [ external.git ];
(attrs.nativeBuildInputs or [ ]) ++ [ external.git ];
});
# missing dependencies
@ -426,91 +451,85 @@ env NIXPKGS_ALLOW_BROKEN=1 nix-instantiate --show-trace ../../../../ -A emacsPac
kapacitor = super.kapacitor.overrideAttrs (attrs: {
# searches for Git at build time
nativeBuildInputs =
(attrs.nativeBuildInputs or []) ++ [ external.git ];
});
forge = super.forge.overrideAttrs (attrs: {
# searches for Git at build time
nativeBuildInputs =
(attrs.nativeBuildInputs or []) ++ [ external.git ];
(attrs.nativeBuildInputs or [ ]) ++ [ external.git ];
});
gerrit = super.gerrit.overrideAttrs (attrs: {
nativeBuildInputs =
(attrs.nativeBuildInputs or []) ++ [ external.git ];
(attrs.nativeBuildInputs or [ ]) ++ [ external.git ];
});
gerrit-download = super.gerrit-download.overrideAttrs (attrs: {
nativeBuildInputs =
(attrs.nativeBuildInputs or []) ++ [ external.git ];
(attrs.nativeBuildInputs or [ ]) ++ [ external.git ];
});
github-pullrequest = super.github-pullrequest.overrideAttrs (attrs: {
nativeBuildInputs =
(attrs.nativeBuildInputs or []) ++ [ external.git ];
(attrs.nativeBuildInputs or [ ]) ++ [ external.git ];
});
helm-rtags = fix-rtags super.helm-rtags;
jist = super.jist.overrideAttrs (attrs: {
nativeBuildInputs =
(attrs.nativeBuildInputs or []) ++ [ external.git ];
(attrs.nativeBuildInputs or [ ]) ++ [ external.git ];
});
mandoku = super.mandoku.overrideAttrs (attrs: {
# searches for Git at build time
nativeBuildInputs =
(attrs.nativeBuildInputs or []) ++ [ external.git ];
(attrs.nativeBuildInputs or [ ]) ++ [ external.git ];
});
mandoku-tls = super.mandoku-tls.overrideAttrs (attrs: {
# searches for Git at build time
nativeBuildInputs =
(attrs.nativeBuildInputs or []) ++ [ external.git ];
(attrs.nativeBuildInputs or [ ]) ++ [ external.git ];
});
magit-p4 = super.magit-p4.overrideAttrs (attrs: {
# searches for Git at build time
nativeBuildInputs =
(attrs.nativeBuildInputs or []) ++ [ external.git ];
(attrs.nativeBuildInputs or [ ]) ++ [ external.git ];
});
magit-rbr = super.magit-rbr.overrideAttrs (attrs: {
# searches for Git at build time
nativeBuildInputs =
(attrs.nativeBuildInputs or []) ++ [ external.git ];
(attrs.nativeBuildInputs or [ ]) ++ [ external.git ];
});
magit-diff-flycheck = super.magit-diff-flycheck.overrideAttrs (attrs: {
# searches for Git at build time
nativeBuildInputs =
(attrs.nativeBuildInputs or []) ++ [ external.git ];
(attrs.nativeBuildInputs or [ ]) ++ [ external.git ];
});
magit-reviewboard = super.magit-reviewboard.overrideAttrs (attrs: {
# searches for Git at build time
nativeBuildInputs =
(attrs.nativeBuildInputs or []) ++ [ external.git ];
(attrs.nativeBuildInputs or [ ]) ++ [ external.git ];
});
magit-patch-changelog = super.magit-patch-changelog.overrideAttrs (attrs: {
# searches for Git at build time
nativeBuildInputs =
(attrs.nativeBuildInputs or []) ++ [ external.git ];
(attrs.nativeBuildInputs or [ ]) ++ [ external.git ];
});
magit-circleci = super.magit-circleci.overrideAttrs (attrs: {
# searches for Git at build time
nativeBuildInputs =
(attrs.nativeBuildInputs or []) ++ [ external.git ];
(attrs.nativeBuildInputs or [ ]) ++ [ external.git ];
});
orgit =
(super.orgit.overrideAttrs (attrs: {
# searches for Git at build time
nativeBuildInputs =
(attrs.nativeBuildInputs or []) ++ [ external.git ];
}));
(attrs.nativeBuildInputs or [ ]) ++ [ external.git ];
}));
# tries to write to $HOME
php-auto-yasnippets = super.php-auto-yasnippets.overrideAttrs (attrs: {
@ -528,13 +547,7 @@ env NIXPKGS_ALLOW_BROKEN=1 nix-instantiate --show-trace ../../../../ -A emacsPac
inherit (self.melpaPackages) powerline;
};
treemacs-magit = super.treemacs-magit.overrideAttrs (attrs: {
# searches for Git at build time
nativeBuildInputs =
(attrs.nativeBuildInputs or []) ++ [ external.git ];
});
vterm = super.vterm.overrideAttrs(old: {
vterm = super.vterm.overrideAttrs (old: {
buildInputs = old.buildInputs ++ [ self.emacs pkgs.cmake pkgs.libvterm-neovim ];
cmakeFlags = [
"-DEMACS_SOURCE=${self.emacs.src}"
@ -550,32 +563,38 @@ env NIXPKGS_ALLOW_BROKEN=1 nix-instantiate --show-trace ../../../../ -A emacsPac
rm -rf $out/share/emacs/site-lisp/elpa/vterm-**/{CMake*,build,*.c,*.h}
'';
});
# Legacy alias
emacs-libvterm = unstable.vterm;
# Map legacy renames from emacs2nix since code generation was ported to emacs lisp
_0xc = super."0xc";
_2048-game = super."2048-game";
_4clojure = super."4clojure";
at = super."@";
term-plus = super."term+";
term-plus-key-intercept = super."term+key-intercept";
term-plus-mux = super."term+mux";
xml-plus = super."xml+";
w3m = super.w3m.override (args: {
melpaBuild = drv: args.melpaBuild (drv // {
prePatch =
let w3m = "${lib.getBin external.w3m}/bin/w3m"; in ''
let w3m = "${lib.getBin external.w3m}/bin/w3m"; in
''
substituteInPlace w3m.el \
--replace 'defcustom w3m-command nil' \
'defcustom w3m-command "${w3m}"'
--replace 'defcustom w3m-command nil' \
'defcustom w3m-command "${w3m}"'
'';
});
});
};
};
in super // overrides.${variant});
# Deprecated legacy aliases for backwards compat
aliases = lib.listToAttrs (lib.attrValues (lib.mapAttrs (n: v: { name = v; value = builtins.trace "Melpa attribute '${v}' is a legacy alias that will be removed in 21.03, use '${n}' instead" melpaPackages.${n}; }) (lib.filterAttrs (n: v: lib.hasAttr n melpaPackages) {
"auto-complete-clang-async" = "emacsClangCompleteAsync";
"vterm" = "emacs-libvterm";
"0xc" = "_0xc";
"2048-game" = "_2048-game";
"4clojure" = "_4clojure";
"@" = "at";
"term+" = "term-plus";
"term+key-intercept" = "term-plus-key-intercept";
"term+mux" = "term-plus-mux";
"xml+" = "xml-plus";
})));
in generateMelpa { }
melpaPackages = lib.mapAttrs (n: v: if lib.hasAttr n overrides then overrides.${n} else v) super;
in
melpaPackages // aliases);
in
generateMelpa { }

32
pkgs/applications/editors/emacs-modes/ocaml/default.nix
View File

@ -1,32 +0,0 @@
{ stdenv, emacs, ocaml }:
# this package installs the emacs-mode which
# resides in the ocaml compiler sources.
let version = stdenv.lib.removePrefix "ocaml-" ocaml.name;
in stdenv.mkDerivation {
pname = "ocaml-mode";
inherit version;
inherit (ocaml) prefixKey src;
# a quick configure to get the Makefile generated. Since
# we do not build the ocaml itself, we don't really
# need it to support any features.
configureFlags = (with stdenv.lib; optional (!(versionAtLeast version "4.02")) "-no-tk") ++
[ "-no-curses" "-no-pthread" ];
buildInputs = [ emacs ];
dontBuild = true;
installPhase = ''
cd emacs;
mkdir -p "$out/share/emacs/site-lisp" "$out/bin"
EMACSDIR=$out/share/emacs/site-lisp make simple-install install-ocamltags
'';
meta = {
homepage = "http://caml.inria.fr";
description = "OCaml mode package for Emacs";
platforms = stdenv.lib.platforms.unix;
};
}

12
pkgs/applications/editors/emacs-modes/org-generated.nix generated
View File

@ -4,10 +4,10 @@
elpaBuild {
pname = "org";
ename = "org";
version = "20200504";
version = "20200511";
src = fetchurl {
url = "https://orgmode.org/elpa/org-20200504.tar";
sha256 = "1nalr2jafhzfkaf4bn8kscxd7nm1wz7dbw2629j2msxknw76dwk1";
url = "https://orgmode.org/elpa/org-20200511.tar";
sha256 = "147k6nmq00milw5knyhw01z481rcdl6s30vk4fkjidw508nkmg9c";
};
packageRequires = [];
meta = {
@ -19,10 +19,10 @@
elpaBuild {
pname = "org-plus-contrib";
ename = "org-plus-contrib";
version = "20200504";
version = "20200511";
src = fetchurl {
url = "https://orgmode.org/elpa/org-plus-contrib-20200504.tar";
sha256 = "1ykw3qspz18jgf3ngsvk2ys282489fcjrbk7pbv3ppxzjha4rmhb";
url = "https://orgmode.org/elpa/org-plus-contrib-20200511.tar";
sha256 = "1hsdp7n985404zdqj6gyfw1bxxbs0p3bf4fyizvgji21zxwnf63f";
};
packageRequires = [];
meta = {

4426
pkgs/applications/editors/emacs-modes/recipes-archive-melpa.json
View File

File diff suppressed because it is too large Load Diff

8
pkgs/applications/editors/emacs-modes/update-from-overlay
View File

@ -7,9 +7,13 @@ set -euxo pipefail
curl -s -O https://raw.githubusercontent.com/nix-community/emacs-overlay/master/repos/elpa/elpa-generated.nix
nix-instantiate ../../../.. -A emacsPackagesNg.elpaPackages --show-trace
git diff --exit-code elpa-generated.nix > /dev/null || git commit -m "elpa-packages: $(date --iso)" -- elpa-generated.nix
git diff --exit-code elpa-generated.nix > /dev/null || git commit -m "emacsPackages.elpa-packages: $(date --iso)" -- elpa-generated.nix
curl -s -O https://raw.githubusercontent.com/nix-community/emacs-overlay/master/repos/org/org-generated.nix
nix-instantiate ../../../.. -A emacsPackagesNg.orgPackages --show-trace
git diff --exit-code org-generated.nix > /dev/null || git commit -m "emacsPackages.org-packages: $(date --iso)" -- org-generated.nix
curl -s -O https://raw.githubusercontent.com/nix-community/emacs-overlay/master/repos/melpa/recipes-archive-melpa.json
env NIXPKGS_ALLOW_BROKEN=1 nix-instantiate --show-trace ../../../../ -A emacsPackages.melpaStablePackages
env NIXPKGS_ALLOW_BROKEN=1 nix-instantiate --show-trace ../../../../ -A emacsPackages.melpaPackages
git diff --exit-code recipes-archive-melpa.json > /dev/null || git commit -m "melpa-packages: $(date --iso)" -- recipes-archive-melpa.json
git diff --exit-code recipes-archive-melpa.json > /dev/null || git commit -m "emacsPackages.melpa-packages: $(date --iso)" -- recipes-archive-melpa.json

2
pkgs/applications/editors/glow/default.nix
View File

@ -11,7 +11,7 @@ buildGoModule rec {
sha256 = "0vhl8d7xxqqyl916nh8sgm1xdaf7xlc3r18464bd2av22q9yz68n";
};
modSha256 = "0r0yq7kgz7i1wf4gxxihdrn1c8mi4wcyhadncxbln24s9c5apxsf";
vendorSha256 = "1c16s5xiqr36azh2w90wg14jlw67ca2flbgjijpz7qd0ypxyfqlk";
buildFlagsArray = [ "-ldflags=" "-X=main.Version=${version}" ];

3
pkgs/applications/editors/gnome-builder/default.nix
View File

@ -9,6 +9,7 @@
, gnome3
, libgit2-glib
, gobject-introspection
, glade
, gspell
, gtk-doc
, gtk3
@ -65,7 +66,7 @@ stdenv.mkDerivation rec {
ctags
flatpak
gnome3.devhelp
gnome3.glade
glade
libgit2-glib
libpeas
libportal

1
pkgs/applications/editors/nvi/default.nix
View File

@ -51,5 +51,6 @@ stdenv.mkDerivation {
homepage = "http://www.bostic.com/vi/";
description = "The Berkeley Vi Editor";
license = stdenv.lib.licenses.free;
broken = true; # since 2020-02-08
};
}

9
pkgs/applications/editors/sublime/3/common.nix
View File

@ -13,7 +13,7 @@ let
primaryBinary = "sublime_text";
primaryBinaryAliases = [ "subl" "sublime" "sublime3" ];
downloadUrl = "https://download.sublimetext.com/sublime_text_3_build_${buildVersion}_${arch}.tar.bz2";
versionUrl = "https://www.sublimetext.com/${if dev then "3dev" else "3"}";
versionUrl = "https://download.sublimetext.com/latest/${if dev then "dev" else "stable"}";
versionFile = builtins.toString ./packages.nix;
archSha256 =
if stdenv.hostPlatform.system == "i686-linux" then
@ -133,7 +133,12 @@ in stdenv.mkDerivation (rec {
set -o errexit
PATH=${stdenv.lib.makeBinPath [ common-updater-scripts curl gnugrep ]}
latestVersion=$(curl -s ${versionUrl} | grep -Po '(?<=<p class="latest"><i>Version:</i> Build )([0-9]+)')
latestVersion=$(curl -s ${versionUrl})
if [[ "${buildVersion}" = "$latestVersion" ]]; then
echo "The new version same as the old version."
exit 0
fi
for platform in ${stdenv.lib.concatStringsSep " " meta.platforms}; do
# The script will not perform an update when the version attribute is up to date from previous platform run

2
pkgs/applications/editors/vscode/vscodium.nix
View File

@ -32,7 +32,7 @@ in
executableName = "codium";
longName = "VSCodium";
shortName = "Codium";
shortName = "vscodium";
src = fetchurl {
url = "https://github.com/VSCodium/vscodium/releases/download/${version}/VSCodium-${plat}-${version}.${archive_fmt}";

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

@ -34,6 +34,8 @@ stdenv.mkDerivation rec {
"-DUSE_KWALLET=OFF"
];
# Reduce the risk of collisions
postInstall = "rm -r $out/share/doc";
# darktable changed its rpath handling in commit
# 83c70b876af6484506901e6b381304ae0d073d3c and as a result the

14
pkgs/applications/graphics/nomacs/default.nix
View File

@ -18,25 +18,15 @@
mkDerivation rec {
pname = "nomacs";
version = "3.12";
version = "3.14.2";
src = fetchFromGitHub {
owner = "nomacs";
repo = "nomacs";
rev = version;
sha256 = "12582i5v85da7vwjxj8grj99hxg34ij5cn3b1578wspdfw1xfy1i";
sha256 = "1vms13kyg7cpqi2hxvrrhlnl7cq92ijr7dm1kl5ryglpcagqv811";
};
patches = [
./nomacs-iostream.patch
(fetchpatch {
name = "darwin-less-restrictive-opencv.patch";
url = "https://github.com/nomacs/nomacs/commit/d182fce4bcd9a25bd15e3de065ca67849a32458c.patch";
sha256 = "0j6sviwrjn69nqf59hjn30c4j838h8az7rnlwcx8ymlb21vd9x2h";
stripLen = 1;
})
];
enableParallelBuilding = true;
setSourceRoot = ''

3
pkgs/applications/graphics/pdfcpu/default.nix
View File

@ -11,7 +11,7 @@ buildGoModule rec {
sha256 = "0a7d36hzcvj68apzc726r2vqsjyrkcynxif5laarxapm6p67g3z4";
};
modSha256 = "0ak34wr5cbcvblndslsxdd24vfj3h02xqjqnj5amkll5iqn5mzi1";
vendorSha256 = "09alkpfyxapycv6zsaz7prgbr0a1jzd78n7w2mh01mg4hhb2j3k7";
subPackages = [ "cmd/pdfcpu" ];
@ -23,4 +23,3 @@ buildGoModule rec {
platforms = platforms.all;
};
}

8
pkgs/applications/graphics/sane/backends/airscan/default.nix
View File

@ -1,17 +1,17 @@
{ lib, stdenv, fetchFromGitHub, pkg-config, avahi, libsoup, libjpeg
{ lib, stdenv, fetchFromGitHub, pkg-config, avahi, libsoup, libjpeg, libpng
, sane-backends, meson, ninja }:
stdenv.mkDerivation rec {
pname = "sane-airscan";
version = "0.9.17";
version = "0.99.0";
nativeBuildInputs = [ meson ninja pkg-config ];
buildInputs = [ avahi libsoup libjpeg sane-backends ];
buildInputs = [ avahi libsoup libjpeg libpng sane-backends ];
src = fetchFromGitHub {
owner = "alexpevzner";
repo = pname;
rev = version;
sha256 = "03y0c1z5s3wbvxa9nvji62w42cmvcgm2sw72j7wm831995q3abmx";
sha256 = "0bbw3s95v5fmkpmmd26v9cf1c40dm85bgxlhs06ski5my803ck0a";
};
meta = with lib; {

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

@ -14,7 +14,7 @@ buildGoModule rec {
sha256 = "1yr2jhidqvbwh1y08lpqaidwpr5yx3bhvznm5fc9pk64s7z5kq3h";
};
modSha256 = "1mrfqhd0zb78rlqlj2ncb0srwjfl7rzhy2p9mwa82pgysvlp08gv";
vendorSha256 = "1ikrgl03r9zkn86kxkqi2kf540g3qzzz24i5wvh6g3d5q49nygl9";
meta = with lib; {
description = "Easily create & extract archives, and compress & decompress files of various formats";

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

@ -20,7 +20,7 @@ buildGoModule rec {
installShellCompletion scripts/cheat.{bash,fish,zsh}
'';
modSha256 = "1z4za3rivc3vqv59p5yb5c9dcpmq669rzmf4z7zilbvmgm0pbgfp";
vendorSha256 = null;
meta = with stdenv.lib; {
description = "Create and view interactive cheatsheets on the command-line";

17
pkgs/applications/misc/cpu-x/default.nix
View File

@ -1,22 +1,27 @@
{ stdenv, fetchFromGitHub, cmake, pkgconfig, gtk3, ncurses, curl
, json_c, libcpuid, pciutils, procps, wrapGAppsHook, nasm }:
{ stdenv, fetchFromGitHub, cmake, pkgconfig, gtk3, ncurses
, libcpuid, pciutils, procps, wrapGAppsHook, nasm, makeWrapper }:
stdenv.mkDerivation rec {
pname = "cpu-x";
version = "3.2.4";
version = "4.0.0";
src = fetchFromGitHub {
owner = "X0rg";
repo = "CPU-X";
rev = "v${version}";
sha256 = "03y49wh9v7x6brmavj5a2clihn0z4f01pypl7m8ymarv4y3a6xkl";
sha256 = "00xngmlayblvkg3l0rcfpxmnkkdz49ydh4smlhpii23gqii0rds3";
};
nativeBuildInputs = [ cmake pkgconfig wrapGAppsHook nasm ];
nativeBuildInputs = [ cmake pkgconfig wrapGAppsHook nasm makeWrapper ];
buildInputs = [
gtk3 ncurses curl json_c libcpuid pciutils procps
gtk3 ncurses libcpuid pciutils procps
];
postInstall = ''
wrapProgram $out/bin/cpu-x \
--prefix PATH : ${stdenv.lib.makeBinPath [ stdenv.cc ]}
'';
meta = with stdenv.lib; {
description = "Free software that gathers information on CPU, motherboard and more";
homepage = src.meta.homepage;

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

@ -11,7 +11,7 @@ buildGoModule rec {
sha256 = "17gvz9a0sn4p36hf4l77bxhhfipf4x998iay31layqwbnzmb4xy7";
};
modSha256 = "0pg0hxrr6jjd03wbjn5y65x02md3h352mnm1gr6vyiv7hn4ws14m";
vendorSha256 = "0b2m9xkac60k5rbxmb03cxf530m23av14pnsjk8067l998sm4vqi";
subPackages = [ "./exercism" ];

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

@ -11,7 +11,7 @@ buildGoModule rec {
sha256 = "057f9kp8g3wixjh9dm58g0qvzfcmhwbk1d573ldly4g5404r9bvf";
};
modSha256 = "1bypanvrkcqp8rk84cv2569671irgaf3cy27lcrknyina4pdvir5";
vendorSha256 = "0q4byhvs1c1xm4qjvs2vyf98vdv121qn0z51arcf7k4ayrys5xcx";
meta = with stdenv.lib; {
description = "Automatic GeoIP database updater";

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

@ -11,7 +11,7 @@ buildGoModule rec {
sha256 = "1wq55rvpyz0gjn8kiwwj49awsmi86zy1fdjcphzgb7883xalgr2m";
};
modSha256 = "13higizadnf4ypk8qn1b5s6mdg7n6l3indb43mjp1b4cfzjsyl91";
vendorSha256 = "1yw0gph4zfg8w4343882l6b9lggwyak2zz8ic1l1m2m44p3aq169";
meta = with lib; {
description = ''Displays "The Matrix" in a terminal'';

20
pkgs/applications/misc/hugo/default.nix
View File

@ -1,10 +1,10 @@
{ stdenv, buildGoModule, fetchFromGitHub }:
{ stdenv, buildGoModule, fetchFromGitHub, libsass }:
buildGoModule rec {
pname = "hugo";
version = "0.70.0";
goPackagePath = "github.com/gohugoio/hugo";
buildInputs = [ libsass ];
src = fetchFromGitHub {
owner = "gohugoio";
@ -13,7 +13,21 @@ buildGoModule rec {
sha256 = "14g1x95jh91z9xm3xkv2psw2jn7z6bv2009miyv727df4d58nh6m";
};
modSha256 = "015ha8pjz1fv8qg558xa6hl52fp2qd486ir9m01dvxw63xqx76ss";
golibsass = fetchFromGitHub {
owner = "bep";
repo = "golibsass";
rev = "8a04397f0baba474190a9f58019ff499ec43057a";
sha256 = "0xk3m2ynbydzx87dz573ihwc4ryq0r545vz937szz175ivgfrhh3";
};
overrideModAttrs = (_: {
postBuild = ''
rm -rf vendor/github.com/bep/golibsass/
cp -r --reflink=auto ${golibsass} vendor/github.com/bep/golibsass
'';
});
vendorSha256 = "1wl9pg5wf1n5n7gq6lyz0l5ij4icjpfinl4myxwj93l2hqqyx2lf";
buildFlags = [ "-tags" "extended" ];

25
pkgs/applications/misc/jgmenu/default.nix
View File

@ -1,4 +1,17 @@
{ stdenv, fetchFromGitHub, pkgconfig, python3Packages, pango, librsvg, libxml2, menu-cache, xorg, makeWrapper }:
{ stdenv
, fetchFromGitHub
, pkgconfig
, python3Packages
, pango
, librsvg
, libxml2
, menu-cache
, xorg
, makeWrapper
, enableXfcePanelApplet ? false
, xfce
, gtk3
}:
stdenv.mkDerivation rec {
pname = "jgmenu";
@ -25,9 +38,17 @@ stdenv.mkDerivation rec {
xorg.libXinerama
xorg.libXrandr
python3Packages.python
] ++ stdenv.lib.optionals enableXfcePanelApplet [
gtk3
xfce.libxfce4util
xfce.xfce4-panel
];
makeFlags = [ "prefix=${placeholder "out"}" ];
configureFlags = [
]
++ stdenv.lib.optionals enableXfcePanelApplet [
"--with-xfce4-panel-applet"
];
postFixup = ''
wrapPythonProgramsIn "$out/lib/jgmenu"

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

@ -26,13 +26,13 @@ assert i3GapsSupport -> ! i3Support && jsoncpp != null && i3-gaps != null;
stdenv.mkDerivation rec {
pname = "polybar";
version = "3.4.2";
version = "3.4.3";
src = fetchFromGitHub {
owner = pname;
repo = pname;
rev = version;
sha256 = "1ss4wzy68dpqr5a4m090nn36v8wsp4a7pj6whcxxdrrimgww5r88";
sha256 = "0fsfh3xv0c0hz10xqzvd01c0p0wvzcnanbyczi45zhaxfrisb39w";
fetchSubmodules = true;
};

6
pkgs/applications/misc/pueue/default.nix
View File

@ -2,16 +2,16 @@
rustPlatform.buildRustPackage rec {
pname = "pueue";
version = "0.4.0";
version = "0.5.0";
src = fetchFromGitHub {
owner = "Nukesor";
repo = pname;
rev = "v${version}";
sha256 = "050cx9ncs1hfb14llly0wm3h5s4377s3sinmkjc52xm2z2gc7m5f";
sha256 = "17v760mh5k5vb1h3xvaph5rfc5wdl6q42isil2k9n6y8bxr3yw84";
};
cargoSha256 = "1hw0y6c1ypp470cca3yw6fc7xvligy3av8hsa9bhdm5can46hyzi";
cargoSha256 = "1m659i3v3b5hfn5vb5126izcy690bkmlyihz2w90h2d02ig7170p";
nativeBuildInputs = [ installShellFiles ];

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

@ -11,7 +11,7 @@ buildGoModule rec {
sha256 = "1lanighxhnn28dfzils7i55zgxbw2abd6y723mq7x9wg1aa2bd0z";
};
modSha256 = "02ai193lpzsxdn1hpbndkfxdc88nyl4kcgbadhy122kgx13crcy8";
vendorSha256 = "04nywhkil5xkipcibrp6vi63rfcvqgv7yxbxmmrhqys2cdxfvazv";
subPackages = [ "." ];

2
pkgs/applications/misc/terminal-parrot/default.nix
View File

@ -11,7 +11,7 @@ buildGoModule rec {
sha256 = "1b4vr4s1zpkpf5kc1r2kdlp3hf88qp1f7h05g8kd62zf4sfbj722";
};
modSha256 = "01i8fim9z2l8rpdgfaih9ldvbap7gcx5767a15miv8q7sxpr90cp";
vendorSha256 = "1qalnhhq3fmyzj0hkzc5gk9wbypr558mz3ik5msw7fid68k2i48c";
meta = with stdenv.lib; {
description = "Shows colorful, animated party parrot in your terminial";

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

@ -11,7 +11,7 @@ buildGoModule rec {
sha256 = "0d3c621jaqxd6i58xm6nvi0avrh5mk23r169i95bn73igzw62w33";
};
modSha256 = "1nnp5ijz4n34gc97rar4wlvlbx21ndpjyb2mc6gxdk1wzx3mgswp";
vendorSha256 = "0cznb8glh36dwyyn1gx1ggkwa9zffrrxg52k78brnaczsl0rsmky";
meta = {
homepage = "https://github.com/sachaos/todoist";

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

@ -16,7 +16,7 @@ buildGoModule rec {
sha256 = "0v6yafpz3sycq6yb7w4dyxqclszvdgwbyhqs5ii8ckynqcf6ifn7";
};
modSha256 = "0csxc5q7i2iq8z71ysfan2kwf4mghi89i5zja5g1a4cvmcabiq1g";
vendorSha256 = "1q54bl1z9ljpsf63i5r6vzv7f143slja0n8lyppaxxdcg18h8gn0";
buildFlagsArray = [ "-ldflags=-s -w -X main.version=${version}" ];

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

@ -23,7 +23,7 @@ stdenv.mkDerivation rec {
] ++ stdenv.lib.optional stdenv.hostPlatform.isMusl
(fetchpatch {
name = "posix-ptys.patch";
url = "https://git.alpinelinux.org/cgit/aports/plain/community/xterm/posix-ptys.patch?id=3aa532e77875fa1db18c7fcb938b16647031bcc1";
url = "https://git.alpinelinux.org/aports/plain/community/xterm/posix-ptys.patch?id=3aa532e77875fa1db18c7fcb938b16647031bcc1";
sha256 = "0czgnsxkkmkrk1idw69qxbprh0jb4sw3c24zpnqq2v76jkl7zvlr";
});

4
pkgs/applications/networking/Sylk/default.nix
View File

@ -2,7 +2,7 @@
let
pname = "Sylk";
version = "2.7.0";
version = "2.7.2";
in
appimageTools.wrapType2 rec {
@ -10,7 +10,7 @@ appimageTools.wrapType2 rec {
src = fetchurl {
url = "http://download.ag-projects.com/Sylk/Sylk-${version}-x86_64.AppImage";
hash = "sha256:0xjg9j69yj06ys8229x6mwsjlk3mvxi8gnr2kymx0vhhg1zvqi1k";
hash = "sha256:1hz41jan8hw56ahpaajlb1yy5zjkyxrclzmqhklm5x59b76pd0zx";
};
profile = ''

4
pkgs/applications/networking/browsers/chromium/plugins.nix
View File

@ -45,11 +45,11 @@ let
flash = stdenv.mkDerivation rec {
pname = "flashplayer-ppapi";
version = "32.0.0.363";
version = "32.0.0.371";
src = fetchzip {
url = "https://fpdownload.adobe.com/pub/flashplayer/pdc/${version}/flash_player_ppapi_linux.x86_64.tar.gz";
sha256 = "0znk8an892mykgbz56hyv3gz65vc9mhb3vn96c6bsvicwl1fn460";
sha256 = "1nks2wx74b21hv0l7bnrzkxn7c6p6r8zgwbqvy3cqpi8famyr5v9";
stripRoot = false;
};

770
pkgs/applications/networking/browsers/firefox-bin/beta_sources.nix
View File

File diff suppressed because it is too large Load Diff

770
pkgs/applications/networking/browsers/firefox-bin/devedition_sources.nix
View File

File diff suppressed because it is too large Load Diff

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

@ -7,10 +7,10 @@ in
rec {
firefox = common rec {
pname = "firefox";
ffversion = "76.0";
ffversion = "76.0.1";
src = fetchurl {
url = "mirror://mozilla/firefox/releases/${ffversion}/source/firefox-${ffversion}.source.tar.xz";
sha512 = "3dq9h84w1qqidabbrl34jgyjr8bbmbf5wddjazpr7znfm49fn2xyg8fmm5lx9dakghk3wp8yhfi36gmk08fzlrm47v6h17dm9hkh0hz";
sha512 = "0gnhfcgrz6022xf3vqia3s3639xa5pjp13h343d3c09mn8r919cmm6s38vzj1v3734fm25zb68acyarsp72xqq8z1420rh02b2pv38q";
};
patches = [

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

@ -74,7 +74,7 @@ let
in
stdenv.mkDerivation rec {
pname = "flashplayer";
version = "32.0.0.363";
version = "32.0.0.371";
src = fetchurl {
url =
@ -85,14 +85,14 @@ stdenv.mkDerivation rec {
sha256 =
if debug then
if arch == "x86_64" then
"06711k4vbn6mqfd8gvx2snsxyalhw15hn5b64sja8726z5rxvzy7"
"1zrl7cxcl9hkafji15br8wp5vf9a5lb88xcpz6vi9q73j45mhzjd"
else
"0v584aqhy4xk08afi3ypkq4mqjq57y136z82i5ixyim88dqbaf4f"
"0cgnsn9zanadbacb660mj4k103cdyb2cak7ixnp1varqklss83n6"
else
if arch == "x86_64" then
"1g1ijxypm8a8mfc1x58gksmaakqpp7xmf277wiir8zqjn3vd6c64"
"1zc90gjixfhjng7pbx8vci1l69wf5m40149178zwzs6kz4ma5hb2"
else
"13nbxmqmbxqvdhdwdqimim2f9fz3y2vrsx6b3pck6352m4i4wzh8";
"0fqgas1g52a0zir2cxz3anizk3lkmwl68nbcn5rihgvjfqykbhn8";
};
nativeBuildInputs = [ unzip ];

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

@ -50,7 +50,7 @@
stdenv.mkDerivation {
pname = "flashplayer-standalone";
version = "32.0.0.363";
version = "32.0.0.371";
src = fetchurl {
url =
@ -60,9 +60,9 @@ stdenv.mkDerivation {
"https://fpdownload.macromedia.com/pub/flashplayer/updaters/32/flash_player_sa_linux.x86_64.tar.gz";
sha256 =
if debug then
"03zhza8lvc1nvz3racwfsajfd6rnbw3g56dp5wvr1qmaps8xaaqg"
"0n3bk2y1djaqrdygnr81n8lsnj2k60kaziffl41zpdvzi1jc7wgn"
else
"0bhp7jv2l2agfzr8m564k749a5g75dw1390phlwvf49n1h8ldap2";
"18ll9rnfhbnz54q4d7q9fb13lix4i62zr6z6n574qvwngrvbrr8a";
};
nativeBuildInputs = [ unzip ];

5
pkgs/applications/networking/cloudflared/default.nix
View File

@ -1,4 +1,4 @@
{ stdenv, buildGoModule, fetchFromGitHub }:
{ stdenv, buildGoModule, fetchFromGitHub, runCommand }:
buildGoModule rec {
pname = "cloudflared";
@ -11,7 +11,8 @@ buildGoModule rec {
sha256 = "1vbxm5z72y9zfg4carmja3fc1vhkanmc25pgnlw550p1l14y6404";
};
modSha256 = "1mnfp8nhbllv8msglci1hq4026rqsc1yibrh2xnwwbf2f3yqx8h0";
vendorSha256 = "14w2iz3ycbzfvlr8a6qn86aaa8687cm203d73wpfkfskp277hwz0";
deleteVendor = true;
buildFlagsArray = "-ldflags=-X main.Version=${version}";

2
pkgs/applications/networking/cluster/argo/default.nix
View File

@ -28,7 +28,7 @@ buildGoModule rec {
sha256 = "12wq79h4m8wlzf18r66965mbbjjb62kvnxdj50ra7nxa8jjxpsmf";
};
modSha256 = "1394bav1k1xv9n1rvji0j9a09mibk97xpha24640jkgmy9bnmg45";
vendorSha256 = "0dhzr62x2lzf3w0j2r496cr7jvkdcavfqaqr2xh972k3qqc9caky";
subPackages = [ "cmd/argo" ];

2
pkgs/applications/networking/cluster/argocd/default.nix
View File

@ -12,7 +12,7 @@ buildGoModule rec {
sha256 = "01vsyrks1k5yfvrarv8ia0isr7snilr21b7lfiy860si82r2r8hj";
};
modSha256 = "1qivg7yy7ymmgkrvl365x29d8jnsphbz18j1ykgwwysyw3n4jkdg";
vendorSha256 = "0r2nh7v00m6zbdnhsgjn01q9pkiz41ckkqgfnpqmkxaqmjz31iyj";
nativeBuildInputs = [ packr ];

2
pkgs/applications/networking/cluster/atlantis/default.nix
View File

@ -11,7 +11,7 @@ buildGoModule rec {
sha256 = "16zz4xwpqipdmszbz93xxw31hbh7s8pfa9dm64ybyni7wc4lvdy6";
};
modSha256 = "18f7cf61yn5jkji5a4v6xw6c7xl40nj32n5w34xmcmszzf64cwkn";
vendorSha256 = null;
subPackages = [ "." ];

8
pkgs/applications/networking/cluster/cni/plugins.nix
View File

@ -1,6 +1,6 @@
{ lib, fetchFromGitHub, buildGoPackage }:
{ lib, fetchFromGitHub, buildGoModule }:
buildGoPackage rec {
buildGoModule rec {
pname = "cni-plugins";
version = "0.8.6";
@ -11,10 +11,10 @@ buildGoPackage rec {
sha256 = "0f1cqxjf26sy1c4aw6y7pyd9lrz0vknby4q5j6xj77a1pab9073m";
};
goPackagePath = "github.com/containernetworking/plugins";
vendorSha256 = null;
buildFlagsArray = [
"-ldflags=-X ${goPackagePath}/pkg/utils/buildversion.BuildVersion=${version}"
"-ldflags=-X github.com/containernetworking/plugins/pkg/utils/buildversion.BuildVersion=${version}"
];
subPackages = [

2
pkgs/applications/networking/cluster/docker-machine/hyperkit.nix
View File

@ -1,7 +1,7 @@
{ lib, buildGoModule, minikube }:
buildGoModule rec {
inherit (minikube) version src nativeBuildInputs buildInputs modSha256 commit;
inherit (minikube) version src nativeBuildInputs buildInputs vendorSha256 commit;
pname = "docker-machine-hyperkit";

2
pkgs/applications/networking/cluster/docker-machine/kvm2.nix
View File

@ -1,7 +1,7 @@
{ lib, buildGoModule, minikube }:
buildGoModule rec {
inherit (minikube) version src nativeBuildInputs buildInputs modSha256 commit;
inherit (minikube) version src nativeBuildInputs buildInputs vendorSha256 commit;
pname = "docker-machine-kvm2";

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