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

Merge remote-tracking branch 'upstream/master' into staging

Browse Source
This commit is contained in:
Tuomas Tynkkynen 2016-04-15 22:46:41 +03:00
commit 8a66effde2
281 changed files with 20677 additions and 4129 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
lib/attrsets.nix
View File

@ -438,6 +438,24 @@ rec {
overrideExisting = old: new:
old // listToAttrs (map (attr: nameValuePair attr (attrByPath [attr] old.${attr} new)) (attrNames old));
/* Try given attributes in order. If no attributes are found, return
attribute list itself.
Example:
tryAttrs ["a" "b"] { a = 1; b = 2; }
=> 1
tryAttrs ["a" "b"] { c = 3; }
=> { c = 3; }
*/
tryAttrs = allAttrs: set:
let tryAttrs_ = attrs:
if attrs == [] then set
else
(let h = head attrs; in
if hasAttr h set then getAttr h set
else tryAttrs_ (tail attrs));
in tryAttrs_ allAttrs;
/*** deprecated stuff ***/

1
lib/maintainers.nix
View File

@ -243,6 +243,7 @@
mtreskin = "Max Treskin <zerthurd@gmail.com>";
mudri = "James Wood <lamudri@gmail.com>";
muflax = "Stefan Dorn <mail@muflax.com>";
myrl = "Myrl Hex <myrl.0xf@gmail.com>";
nathan-gs = "Nathan Bijnens <nathan@nathan.gs>";
nckx = "Tobias Geerinckx-Rice <tobias.geerinckx.rice@gmail.com>";
nequissimus = "Tim Steinbach <tim@nequissimus.com>";

18
lib/strings.nix
View File

@ -88,6 +88,16 @@ rec {
makeSearchPath = subDir: packages:
concatStringsSep ":" (map (path: path + "/" + subDir) packages);
/* Construct a Unix-style search path, given trying outputs in order.
If no output is found, fallback to `.out` and then to the default.
Example:
makeSearchPathOutputs "bin" ["bin"] [ pkgs.openssl pkgs.zlib ]
=> "/nix/store/9rz8gxhzf8sw4kf2j2f1grr49w8zx5vj-openssl-1.0.1r-bin/bin:/nix/store/wwh7mhwh269sfjkm6k5665b5kgp7jrk2-zlib-1.2.8/bin"
*/
makeSearchPathOutputs = subDir: outputs: pkgs:
makeSearchPath subDir (map (pkg: if pkg.outputUnspecified or false then lib.tryAttrs (outputs ++ ["out"]) pkg else pkg) pkgs);
/* Construct a library search path (such as RPATH) containing the
libraries for a set of packages
@ -100,7 +110,7 @@ rec {
*/
makeLibraryPath = pkgs: makeSearchPath "lib"
# try to guess the right output of each pkg
(map (pkg: pkg.lib or (pkg.out or pkg)) pkgs);
(map (pkg: if pkg.outputUnspecified or false then pkg.lib or (pkg.out or pkg) else pkg) pkgs);
/* Construct a binary search path (such as $PATH) containing the
binaries for a set of packages.
@ -109,7 +119,8 @@ rec {
makeBinPath ["/root" "/usr" "/usr/local"]
=> "/root/bin:/usr/bin:/usr/local/bin"
*/
makeBinPath = makeSearchPath "bin";
makeBinPath = pkgs: makeSearchPath "bin"
(map (pkg: if pkg.outputUnspecified or false then pkg.bin or (pkg.out or pkg) else pkg) pkgs);
/* Construct a perl search path (such as $PERL5LIB)
@ -121,7 +132,8 @@ rec {
makePerlPath [ pkgs.perlPackages.NetSMTP ]
=> "/nix/store/n0m1fk9c960d8wlrs62sncnadygqqc6y-perl-Net-SMTP-1.25/lib/perl5/site_perl"
*/
makePerlPath = makeSearchPath "lib/perl5/site_perl";
makePerlPath = pkgs: makeSearchPath "lib/perl5/site_perl"
(map (pkg: if pkg.outputUnspecified or false then pkg.lib or (pkg.out or pkg) else pkg) pkgs);
/* Dependening on the boolean `cond', return either the given string
or the empty string. Useful to contatenate against a bigger string.

1
nixos/doc/manual/configuration/configuration.xml
View File

@ -27,6 +27,7 @@ effect after you run <command>nixos-rebuild</command>.</para>
<!-- FIXME: auto-include NixOS module docs -->
<xi:include href="postgresql.xml" />
<xi:include href="gitlab.xml" />
<xi:include href="taskserver.xml" />
<xi:include href="acme.xml" />
<xi:include href="input-methods.xml" />

1
nixos/doc/manual/default.nix
View File

@ -57,6 +57,7 @@ let
chmod -R u+w .
cp ${../../modules/services/databases/postgresql.xml} configuration/postgresql.xml
cp ${../../modules/services/misc/gitlab.xml} configuration/gitlab.xml
cp ${../../modules/services/misc/taskserver/doc.xml} configuration/taskserver.xml
cp ${../../modules/security/acme.xml} configuration/acme.xml
cp ${../../modules/i18n/input-method/default.xml} configuration/input-methods.xml
ln -s ${optionsDocBook} options-db.xml

4
nixos/modules/misc/ids.nix
View File

@ -261,6 +261,8 @@
syncthing = 237;
mfi = 238;
caddy = 239;
taskd = 240;
factorio = 241;
# When adding a uid, make sure it doesn't match an existing gid. And don't use uids above 399!
@ -493,6 +495,8 @@
syncthing = 237;
#mfi = 238; # unused
caddy = 239;
taskd = 240;
factorio = 241;
# When adding a gid, make sure it doesn't match an existing
# uid. Users and groups with the same name should have equal

2
nixos/modules/misc/locate.nix
View File

@ -88,7 +88,7 @@ in {
serviceConfig.PrivateNetwork = "yes";
serviceConfig.NoNewPrivileges = "yes";
serviceConfig.ReadOnlyDirectories = "/";
serviceConfig.ReadWriteDirectories = cfg.output;
serviceConfig.ReadWriteDirectories = dirOf cfg.output;
};
systemd.timers.update-locatedb = mkIf cfg.enable

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

@ -158,6 +158,7 @@
./services/desktops/gnome3/tracker.nix
./services/desktops/profile-sync-daemon.nix
./services/desktops/telepathy.nix
./services/games/factorio.nix
./services/games/ghost-one.nix
./services/games/minecraft-server.nix
./services/games/minetest-server.nix
@ -250,6 +251,7 @@
./services/misc/sundtek.nix
./services/misc/svnserve.nix
./services/misc/synergy.nix
./services/misc/taskserver
./services/misc/uhub.nix
./services/misc/zookeeper.nix
./services/monitoring/apcupsd.nix
@ -427,6 +429,7 @@
./services/system/nscd.nix
./services/system/uptimed.nix
./services/torrent/deluge.nix
./services/torrent/flexget.nix
./services/torrent/peerflix.nix
./services/torrent/transmission.nix
./services/ttys/agetty.nix

102
nixos/modules/services/games/factorio.nix Normal file
View File

@ -0,0 +1,102 @@
{ config, lib, pkgs, ... }:
with lib;
let
cfg = config.services.factorio;
name = "Factorio";
stateDir = "/var/lib/factorio";
configFile = pkgs.writeText "factorio.conf" ''
use-system-read-write-data-directories=true
[path]
read-data=${pkgs.factorio-headless}/share/factorio/data
write-data=${stateDir}
'';
in
{
options = {
services.factorio = {
enable = mkEnableOption name;
port = mkOption {
type = types.int;
default = 34197;
description = ''
The port to which the service should bind.
This option will also open up the UDP port in the firewall configuration.
'';
};
saveName = mkOption {
type = types.string;
default = "default";
description = ''
The name of the savegame that will be used by the server.
When not present in ${stateDir}/saves, it will be generated before starting the service.
'';
};
# TODO Add more individual settings as nixos-options?
# TODO XXX The server tries to copy a newly created config file over the old one
# on shutdown, but fails, because it's in the nix store. When is this needed?
# Can an admin set options in-game and expect to have them persisted?
configFile = mkOption {
type = types.path;
default = configFile;
defaultText = "configFile";
description = ''
The server's configuration file.
The default file generated by this module contains lines essential to
the server's operation. Use its contents as a basis for any
customizations.
'';
};
};
};
config = mkIf cfg.enable {
users = {
users.factorio = {
uid = config.ids.uids.factorio;
description = "Factorio server user";
group = "factorio";
home = stateDir;
createHome = true;
};
groups.factorio = {
gid = config.ids.gids.factorio;
};
};
systemd.services.factorio = {
description = "Factorio headless server";
wantedBy = [ "multi-user.target" ];
after = [ "network.target" ];
preStart = ''
test -e ${stateDir}/saves/${cfg.saveName}.zip || ${pkgs.factorio-headless}/bin/factorio \
--config=${cfg.configFile} \
--create=${cfg.saveName}
'';
serviceConfig = {
User = "factorio";
Group = "factorio";
Restart = "always";
KillSignal = "SIGINT";
WorkingDirectory = stateDir;
PrivateTmp = true;
UMask = "0007";
ExecStart = toString [
"${pkgs.factorio-headless}/bin/factorio"
"--config=${cfg.configFile}"
"--port=${toString cfg.port}"
"--start-server=${cfg.saveName}"
];
};
};
networking.firewall.allowedUDPPorts = [ cfg.port ];
};
}

2
nixos/modules/services/misc/gammu-smsd.nix
View File

@ -228,7 +228,7 @@ in {
'')
+ optionalString (service == "sql" && sql.driver == "sqlite") ''
cat "${gammuPackage}/${initDBDir}/sqlite.sql" \
| ${pkgs.sqlite}/bin/sqlite3 ${sql.database}
| ${pkgs.sqlite.bin}/bin/sqlite3 ${sql.database}
''
+ (let execPsql = extraArgs: concatStringsSep " " [
(optionalString (sql.password != null) "PGPASSWORD=${sql.password}")

4
nixos/modules/services/misc/octoprint.nix
View File

@ -10,7 +10,7 @@ let
plugins.cura.cura_engine = "${pkgs.curaengine}/bin/CuraEngine";
server.host = cfg.host;
server.port = cfg.port;
webcam.ffmpeg = "${pkgs.ffmpeg}/bin/ffmpeg";
webcam.ffmpeg = "${pkgs.ffmpeg.bin}/bin/ffmpeg";
};
fullConfig = recursiveUpdate cfg.extraConfig baseConfig;
@ -102,7 +102,7 @@ in
wantedBy = [ "multi-user.target" ];
after = [ "network.target" ];
path = [ pluginsEnv ];
environment.PYTHONPATH = makeSearchPath pkgs.python.sitePackages [ pluginsEnv ];
environment.PYTHONPATH = makeSearchPathOutputs pkgs.python.sitePackages ["lib"] [ pluginsEnv ];
preStart = ''
mkdir -p "${cfg.stateDir}"

541
nixos/modules/services/misc/taskserver/default.nix Normal file
View File

@ -0,0 +1,541 @@
{ config, lib, pkgs, ... }:
with lib;
let
cfg = config.services.taskserver;
taskd = "${pkgs.taskserver}/bin/taskd";
mkVal = val:
if val == true then "true"
else if val == false then "false"
else if isList val then concatStringsSep ", " val
else toString val;
mkConfLine = key: val: let
result = "${key} = ${mkVal val}";
in optionalString (val != null && val != []) result;
mkManualPkiOption = desc: mkOption {
type = types.nullOr types.path;
default = null;
description = desc + ''
<note><para>
Setting this option will prevent automatic CA creation and handling.
</para></note>
'';
};
manualPkiOptions = {
ca.cert = mkManualPkiOption ''
Fully qualified path to the CA certificate.
'';
server.cert = mkManualPkiOption ''
Fully qualified path to the server certificate.
'';
server.crl = mkManualPkiOption ''
Fully qualified path to the server certificate revocation list.
'';
server.key = mkManualPkiOption ''
Fully qualified path to the server key.
'';
};
mkAutoDesc = preamble: ''
${preamble}
<note><para>
This option is for the automatically handled CA and will be ignored if any
of the <option>services.taskserver.pki.manual.*</option> options are set.
</para></note>
'';
mkExpireOption = desc: mkOption {
type = types.nullOr types.int;
default = null;
example = 365;
apply = val: if isNull val then -1 else val;
description = mkAutoDesc ''
The expiration time of ${desc} in days or <literal>null</literal> for no
expiration time.
'';
};
autoPkiOptions = {
bits = mkOption {
type = types.int;
default = 4096;
example = 2048;
description = mkAutoDesc "The bit size for generated keys.";
};
expiration = {
ca = mkExpireOption "the CA certificate";
server = mkExpireOption "the server certificate";
client = mkExpireOption "client certificates";
crl = mkExpireOption "the certificate revocation list (CRL)";
};
};
needToCreateCA = let
notFound = path: let
dotted = concatStringsSep "." path;
in throw "Can't find option definitions for path `${dotted}'.";
findPkiDefinitions = path: attrs: let
mkSublist = key: val: let
newPath = path ++ singleton key;
in if isOption val
then attrByPath newPath (notFound newPath) cfg.pki.manual
else findPkiDefinitions newPath val;
in flatten (mapAttrsToList mkSublist attrs);
in all isNull (findPkiDefinitions [] manualPkiOptions);
configFile = pkgs.writeText "taskdrc" (''
# systemd related
daemon = false
log = -
# logging
${mkConfLine "debug" cfg.debug}
${mkConfLine "ip.log" cfg.ipLog}
# general
${mkConfLine "ciphers" cfg.ciphers}
${mkConfLine "confirmation" cfg.confirmation}
${mkConfLine "extensions" cfg.extensions}
${mkConfLine "queue.size" cfg.queueSize}
${mkConfLine "request.limit" cfg.requestLimit}
# client
${mkConfLine "client.allow" cfg.allowedClientIDs}
${mkConfLine "client.deny" cfg.disallowedClientIDs}
# server
server = ${cfg.listenHost}:${toString cfg.listenPort}
${mkConfLine "trust" cfg.trust}
# PKI options
${if needToCreateCA then ''
ca.cert = ${cfg.dataDir}/keys/ca.cert
server.cert = ${cfg.dataDir}/keys/server.cert
server.key = ${cfg.dataDir}/keys/server.key
server.crl = ${cfg.dataDir}/keys/server.crl
'' else ''
ca.cert = ${cfg.pki.ca.cert}
server.cert = ${cfg.pki.server.cert}
server.key = ${cfg.pki.server.key}
server.crl = ${cfg.pki.server.crl}
''}
'' + cfg.extraConfig);
orgOptions = { name, ... }: {
options.users = mkOption {
type = types.uniq (types.listOf types.str);
default = [];
example = [ "alice" "bob" ];
description = ''
A list of user names that belong to the organization.
'';
};
options.groups = mkOption {
type = types.listOf types.str;
default = [];
example = [ "workers" "slackers" ];
description = ''
A list of group names that belong to the organization.
'';
};
};
mkShellStr = val: "'${replaceStrings ["'"] ["'\\''"] val}'";
certtool = "${pkgs.gnutls.bin}/bin/certtool";
nixos-taskserver = pkgs.buildPythonPackage {
name = "nixos-taskserver";
namePrefix = "";
src = pkgs.runCommand "nixos-taskserver-src" {} ''
mkdir -p "$out"
cat "${pkgs.substituteAll {
src = ./helper-tool.py;
inherit taskd certtool;
inherit (cfg) dataDir user group fqdn;
certBits = cfg.pki.auto.bits;
clientExpiration = cfg.pki.auto.expiration.client;
crlExpiration = cfg.pki.auto.expiration.crl;
}}" > "$out/main.py"
cat > "$out/setup.py" <<EOF
from setuptools import setup
setup(name="nixos-taskserver",
py_modules=["main"],
install_requires=["Click"],
entry_points="[console_scripts]\\nnixos-taskserver=main:cli")
EOF
'';
propagatedBuildInputs = [ pkgs.pythonPackages.click ];
};
in {
options = {
services.taskserver = {
enable = mkOption {
type = types.bool;
default = false;
example = true;
description = ''
Whether to enable the Taskwarrior server.
More instructions about NixOS in conjuction with Taskserver can be
found in the NixOS manual at
<olink targetdoc="manual" targetptr="module-taskserver"/>.
'';
};
user = mkOption {
type = types.str;
default = "taskd";
description = "User for Taskserver.";
};
group = mkOption {
type = types.str;
default = "taskd";
description = "Group for Taskserver.";
};
dataDir = mkOption {
type = types.path;
default = "/var/lib/taskserver";
description = "Data directory for Taskserver.";
};
ciphers = mkOption {
type = types.nullOr (types.separatedString ":");
default = null;
example = "NORMAL:-VERS-SSL3.0";
description = let
url = "https://gnutls.org/manual/html_node/Priority-Strings.html";
in ''
List of GnuTLS ciphers to use. See the GnuTLS documentation about
priority strings at <link xlink:href="${url}"/> for full details.
'';
};
organisations = mkOption {
type = types.attrsOf (types.submodule orgOptions);
default = {};
example.myShinyOrganisation.users = [ "alice" "bob" ];
example.myShinyOrganisation.groups = [ "staff" "outsiders" ];
example.yetAnotherOrganisation.users = [ "foo" "bar" ];
description = ''
An attribute set where the keys name the organisation and the values
are a set of lists of <option>users</option> and
<option>groups</option>.
'';
};
confirmation = mkOption {
type = types.bool;
default = true;
description = ''
Determines whether certain commands are confirmed.
'';
};
debug = mkOption {
type = types.bool;
default = false;
description = ''
Logs debugging information.
'';
};
extensions = mkOption {
type = types.nullOr types.path;
default = null;
description = ''
Fully qualified path of the Taskserver extension scripts.
Currently there are none.
'';
};
ipLog = mkOption {
type = types.bool;
default = false;
description = ''
Logs the IP addresses of incoming requests.
'';
};
queueSize = mkOption {
type = types.int;
default = 10;
description = ''
Size of the connection backlog, see <citerefentry>
<refentrytitle>listen</refentrytitle>
<manvolnum>2</manvolnum>
</citerefentry>.
'';
};
requestLimit = mkOption {
type = types.int;
default = 1048576;
description = ''
Size limit of incoming requests, in bytes.
'';
};
allowedClientIDs = mkOption {
type = with types; loeOf (either (enum ["all" "none"]) str);
default = [];
example = [ "[Tt]ask [2-9]+" ];
description = ''
A list of regular expressions that are matched against the reported
client id (such as <literal>task 2.3.0</literal>).
The values <literal>all</literal> or <literal>none</literal> have
special meaning. Overidden by any entry in the option
<option>services.taskserver.disallowedClientIDs</option>.
'';
};
disallowedClientIDs = mkOption {
type = with types; loeOf (either (enum ["all" "none"]) str);
default = [];
example = [ "[Tt]ask [2-9]+" ];
description = ''
A list of regular expressions that are matched against the reported
client id (such as <literal>task 2.3.0</literal>).
The values <literal>all</literal> or <literal>none</literal> have
special meaning. Any entry here overrides those in
<option>services.taskserver.allowedClientIDs</option>.
'';
};
listenHost = mkOption {
type = types.str;
default = "localhost";
example = "::";
description = ''
The address (IPv4, IPv6 or DNS) to listen on.
If the value is something else than <literal>localhost</literal> the
port defined by <option>listenPort</option> is automatically added to
<option>networking.firewall.allowedTCPPorts</option>.
'';
};
listenPort = mkOption {
type = types.int;
default = 53589;
description = ''
Port number of the Taskserver.
'';
};
fqdn = mkOption {
type = types.str;
default = "localhost";
description = ''
The fully qualified domain name of this server, which is also used
as the common name in the certificates.
'';
};
trust = mkOption {
type = types.enum [ "allow all" "strict" ];
default = "strict";
description = ''
Determines how client certificates are validated.
The value <literal>allow all</literal> performs no client
certificate validation. This is not recommended. The value
<literal>strict</literal> causes the client certificate to be
validated against a CA.
'';
};
pki.manual = manualPkiOptions;
pki.auto = autoPkiOptions;
extraConfig = mkOption {
type = types.lines;
default = "";
example = "client.cert = /tmp/debugging.cert";
description = ''
Extra lines to append to the taskdrc configuration file.
'';
};
};
};
config = mkMerge [
(mkIf cfg.enable {
environment.systemPackages = [ pkgs.taskserver nixos-taskserver ];
users.users = optional (cfg.user == "taskd") {
name = "taskd";
uid = config.ids.uids.taskd;
description = "Taskserver user";
group = cfg.group;
};
users.groups = optional (cfg.group == "taskd") {
name = "taskd";
gid = config.ids.gids.taskd;
};
systemd.services.taskserver-init = {
wantedBy = [ "taskserver.service" ];
before = [ "taskserver.service" ];
description = "Initialize Taskserver Data Directory";
preStart = ''
mkdir -m 0770 -p "${cfg.dataDir}"
chown "${cfg.user}:${cfg.group}" "${cfg.dataDir}"
'';
script = ''
${taskd} init
echo "include ${configFile}" > "${cfg.dataDir}/config"
touch "${cfg.dataDir}/.is_initialized"
'';
environment.TASKDDATA = cfg.dataDir;
unitConfig.ConditionPathExists = "!${cfg.dataDir}/.is_initialized";
serviceConfig.Type = "oneshot";
serviceConfig.User = cfg.user;
serviceConfig.Group = cfg.group;
serviceConfig.PermissionsStartOnly = true;
serviceConfig.PrivateNetwork = true;
serviceConfig.PrivateDevices = true;
serviceConfig.PrivateTmp = true;
};
systemd.services.taskserver = {
description = "Taskwarrior Server";
wantedBy = [ "multi-user.target" ];
after = [ "network.target" ];
environment.TASKDDATA = cfg.dataDir;
preStart = let
jsonOrgs = builtins.toJSON cfg.organisations;
jsonFile = pkgs.writeText "orgs.json" jsonOrgs;
helperTool = "${nixos-taskserver}/bin/nixos-taskserver";
in "${helperTool} process-json '${jsonFile}'";
serviceConfig = {
ExecStart = "@${taskd} taskd server";
ExecReload = "${pkgs.coreutils}/bin/kill -USR1 $MAINPID";
Restart = "on-failure";
PermissionsStartOnly = true;
PrivateTmp = true;
PrivateDevices = true;
User = cfg.user;
Group = cfg.group;
};
};
})
(mkIf needToCreateCA {
systemd.services.taskserver-ca = {
wantedBy = [ "taskserver.service" ];
after = [ "taskserver-init.service" ];
before = [ "taskserver.service" ];
description = "Initialize CA for TaskServer";
serviceConfig.Type = "oneshot";
serviceConfig.UMask = "0077";
serviceConfig.PrivateNetwork = true;
serviceConfig.PrivateTmp = true;
script = ''
silent_certtool() {
if ! output="$("${certtool}" "$@" 2>&1)"; then
echo "GNUTLS certtool invocation failed with output:" >&2
echo "$output" >&2
fi
}
mkdir -m 0700 -p "${cfg.dataDir}/keys"
chown root:root "${cfg.dataDir}/keys"
if [ ! -e "${cfg.dataDir}/keys/ca.key" ]; then
silent_certtool -p \
--bits ${toString cfg.pki.auto.bits} \
--outfile "${cfg.dataDir}/keys/ca.key"
silent_certtool -s \
--template "${pkgs.writeText "taskserver-ca.template" ''
cn = ${cfg.fqdn}
expiration_days = ${toString cfg.pki.auto.expiration.ca}
cert_signing_key
ca
''}" \
--load-privkey "${cfg.dataDir}/keys/ca.key" \
--outfile "${cfg.dataDir}/keys/ca.cert"
chgrp "${cfg.group}" "${cfg.dataDir}/keys/ca.cert"
chmod g+r "${cfg.dataDir}/keys/ca.cert"
fi
if [ ! -e "${cfg.dataDir}/keys/server.key" ]; then
silent_certtool -p \
--bits ${toString cfg.pki.auto.bits} \
--outfile "${cfg.dataDir}/keys/server.key"
silent_certtool -c \
--template "${pkgs.writeText "taskserver-cert.template" ''
cn = ${cfg.fqdn}
expiration_days = ${toString cfg.pki.auto.expiration.server}
tls_www_server
encryption_key
signing_key
''}" \
--load-ca-privkey "${cfg.dataDir}/keys/ca.key" \
--load-ca-certificate "${cfg.dataDir}/keys/ca.cert" \
--load-privkey "${cfg.dataDir}/keys/server.key" \
--outfile "${cfg.dataDir}/keys/server.cert"
chgrp "${cfg.group}" \
"${cfg.dataDir}/keys/server.key" \
"${cfg.dataDir}/keys/server.cert"
chmod g+r \
"${cfg.dataDir}/keys/server.key" \
"${cfg.dataDir}/keys/server.cert"
fi
if [ ! -e "${cfg.dataDir}/keys/server.crl" ]; then
silent_certtool --generate-crl \
--template "${pkgs.writeText "taskserver-crl.template" ''
expiration_days = ${toString cfg.pki.auto.expiration.crl}
''}" \
--load-ca-privkey "${cfg.dataDir}/keys/ca.key" \
--load-ca-certificate "${cfg.dataDir}/keys/ca.cert" \
--outfile "${cfg.dataDir}/keys/server.crl"
chgrp "${cfg.group}" "${cfg.dataDir}/keys/server.crl"
chmod g+r "${cfg.dataDir}/keys/server.crl"
fi
chmod go+x "${cfg.dataDir}/keys"
'';
};
})
(mkIf (cfg.listenHost != "localhost") {
networking.firewall.allowedTCPPorts = [ cfg.listenPort ];
})
{ meta.doc = ./taskserver.xml; }
];
}

144
nixos/modules/services/misc/taskserver/doc.xml Normal file
View File

@ -0,0 +1,144 @@
<chapter xmlns="http://docbook.org/ns/docbook"
xmlns:xlink="http://www.w3.org/1999/xlink"
version="5.0"
xml:id="module-taskserver">
<title>Taskserver</title>
<para>
Taskserver is the server component of
<link xlink:href="https://taskwarrior.org/">Taskwarrior</link>, a free and
open source todo list application.
</para>
<para>
<emphasis>Upstream documentation:</emphasis>
<link xlink:href="https://taskwarrior.org/docs/#taskd"/>
</para>
<section>
<title>Configuration</title>
<para>
Taskserver does all of its authentication via TLS using client
certificates, so you either need to roll your own CA or purchase a
certificate from a known CA, which allows creation of client
certificates.
These certificates are usually advertised as
<quote>server certificates</quote>.
</para>
<para>
So in order to make it easier to handle your own CA, there is a helper
tool called <command>nixos-taskserver</command> which manages the custom
CA along with Taskserver organisations, users and groups.
</para>
<para>
While the client certificates in Taskserver only authenticate whether a
user is allowed to connect, every user has its own UUID which identifies
it as an entity.
</para>
<para>
With <command>nixos-taskserver</command> the client certificate is created
along with the UUID of the user, so it handles all of the credentials
needed in order to setup the Taskwarrior client to work with a Taskserver.
</para>
</section>
<section>
<title>The nixos-taskserver tool</title>
<para>
Because Taskserver by default only provides scripts to setup users
imperatively, the <command>nixos-taskserver</command> tool is used for
addition and deletion of organisations along with users and groups defined
by <option>services.taskserver.organisations</option> and as well for
imperative set up.
</para>
<para>
The tool is designed to not interfere if the command is used to manually
set up some organisations, users or groups.
</para>
<para>
For example if you add a new organisation using
<command>nixos-taskserver org add foo</command>, the organisation is not
modified and deleted no matter what you define in
<option>services.taskserver.organisations</option>, even if you're adding
the same organisation in that option.
</para>
<para>
The tool is modelled to imitate the official <command>taskd</command>
command, documentation for each subcommand can be shown by using the
<option>--help</option> switch.
</para>
</section>
<section>
<title>Declarative/automatic CA management</title>
<para>
Everything is done according to what you specify in the module options,
however in order to set up a Taskwarrior client for synchronisation with a
Taskserver instance, you have to transfer the keys and certificates to the
client machine.
</para>
<para>
This is done using
<command>nixos-taskserver user export $orgname $username</command> which
is printing a shell script fragment to stdout which can either be used
verbatim or adjusted to import the user on the client machine.
</para>
<para>
For example, let's say you have the following configuration:
<screen>
{
services.taskserver.enable = true;
services.taskserver.fqdn = "server";
services.taskserver.listenHost = "::";
services.taskserver.organisations.my-company.users = [ "alice" ];
}
</screen>
This creates an organisation called <literal>my-company</literal> with the
user <literal>alice</literal>.
</para>
<para>
Now in order to import the <literal>alice</literal> user to another
machine <literal>alicebox</literal>, all we need to do is something like
this:
<screen>
$ ssh server nixos-taskserver user export my-company alice | sh
</screen>
Of course, if no SSH daemon is available on the server you can also copy
&amp; paste it directly into a shell.
</para>
<para>
After this step the user should be set up and you can start synchronising
your tasks for the first time with <command>task sync init</command> on
<literal>alicebox</literal>.
</para>
<para>
Subsequent synchronisation requests merely require the command
<command>task sync</command> after that stage.
</para>
</section>
<section>
<title>Manual CA management</title>
<para>
If you set any options within
<option>service.taskserver.pki.manual.*</option>, the automatic user and
CA management by the <command>nixos-taskserver</command> is disabled and
you need to create certificates and keys by yourself.
</para>
</section>
</chapter>

673
nixos/modules/services/misc/taskserver/helper-tool.py Normal file
View File

@ -0,0 +1,673 @@
import grp
import json
import pwd
import os
import re
import string
import subprocess
import sys
from contextlib import contextmanager
from shutil import rmtree
from tempfile import NamedTemporaryFile
import click
CERTTOOL_COMMAND = "@certtool@"
CERT_BITS = "@certBits@"
CLIENT_EXPIRATION = "@clientExpiration@"
CRL_EXPIRATION = "@crlExpiration@"
TASKD_COMMAND = "@taskd@"
TASKD_DATA_DIR = "@dataDir@"
TASKD_USER = "@user@"
TASKD_GROUP = "@group@"
FQDN = "@fqdn@"
CA_KEY = os.path.join(TASKD_DATA_DIR, "keys", "ca.key")
CA_CERT = os.path.join(TASKD_DATA_DIR, "keys", "ca.cert")
CRL_FILE = os.path.join(TASKD_DATA_DIR, "keys", "server.crl")
RE_CONFIGUSER = re.compile(r'^\s*user\s*=(.*)$')
RE_USERKEY = re.compile(r'New user key: (.+)$', re.MULTILINE)
def lazyprop(fun):
"""
Decorator which only evaluates the specified function when accessed.
"""
name = '_lazy_' + fun.__name__
@property
def _lazy(self):
val = getattr(self, name, None)
if val is None:
val = fun(self)
setattr(self, name, val)
return val
return _lazy
class TaskdError(OSError):
pass
def run_as_taskd_user():
uid = pwd.getpwnam(TASKD_USER).pw_uid
gid = grp.getgrnam(TASKD_GROUP).gr_gid
os.setgid(gid)
os.setuid(uid)
def taskd_cmd(cmd, *args, **kwargs):
"""
Invoke taskd with the specified command with the privileges of the 'taskd'
user and 'taskd' group.
If 'capture_stdout' is passed as a keyword argument with the value True,
the return value are the contents the command printed to stdout.
"""
capture_stdout = kwargs.pop("capture_stdout", False)
fun = subprocess.check_output if capture_stdout else subprocess.check_call
return fun(
[TASKD_COMMAND, cmd, "--data", TASKD_DATA_DIR] + list(args),
preexec_fn=run_as_taskd_user,
**kwargs
)
def certtool_cmd(*args, **kwargs):
"""
Invoke certtool from GNUTLS and return the output of the command.
The provided arguments are added to the certtool command and keyword
arguments are added to subprocess.check_output().
Note that this will suppress all output of certtool and it will only be
printed whenever there is an unsuccessful return code.
"""
return subprocess.check_output(
[CERTTOOL_COMMAND] + list(args),
preexec_fn=lambda: os.umask(0077),
stderr=subprocess.STDOUT,
**kwargs
)
def label(msg):
if sys.stdout.isatty() or sys.stderr.isatty():
sys.stderr.write(msg + "\n")
def mkpath(*args):
return os.path.join(TASKD_DATA_DIR, "orgs", *args)
def mark_imperative(*path):
"""
Mark the specified path as being imperatively managed by creating an empty
file called ".imperative", so that it doesn't interfere with the
declarative configuration.
"""
open(os.path.join(mkpath(*path), ".imperative"), 'a').close()
def is_imperative(*path):
"""
Check whether the given path is marked as imperative, see mark_imperative()
for more information.
"""
full_path = []
for component in path:
full_path.append(component)
if os.path.exists(os.path.join(mkpath(*full_path), ".imperative")):
return True
return False
def fetch_username(org, key):
for line in open(mkpath(org, "users", key, "config"), "r"):
match = RE_CONFIGUSER.match(line)
if match is None:
continue
return match.group(1).strip()
return None
@contextmanager
def create_template(contents):
"""
Generate a temporary file with the specified contents as a list of strings
and yield its path as the context.
"""
template = NamedTemporaryFile(mode="w", prefix="certtool-template")
template.writelines(map(lambda l: l + "\n", contents))
template.flush()
yield template.name
template.close()
def generate_key(org, user):
basedir = os.path.join(TASKD_DATA_DIR, "keys", org, user)
if os.path.exists(basedir):
raise OSError("Keyfile directory for {} already exists.".format(user))
privkey = os.path.join(basedir, "private.key")
pubcert = os.path.join(basedir, "public.cert")
try:
os.makedirs(basedir, mode=0700)
certtool_cmd("-p", "--bits", CERT_BITS, "--outfile", privkey)
template_data = [
"organization = {0}".format(org),
"cn = {}".format(FQDN),
"expiration_days = {}".format(CLIENT_EXPIRATION),
"tls_www_client",
"encryption_key",
"signing_key"
]
with create_template(template_data) as template:
certtool_cmd(
"-c",
"--load-privkey", privkey,
"--load-ca-privkey", CA_KEY,
"--load-ca-certificate", CA_CERT,
"--template", template,
"--outfile", pubcert
)
except:
rmtree(basedir)
raise
def revoke_key(org, user):
basedir = os.path.join(TASKD_DATA_DIR, "keys", org, user)
if not os.path.exists(basedir):
raise OSError("Keyfile directory for {} doesn't exist.".format(user))
pubcert = os.path.join(basedir, "public.cert")
expiration = "expiration_days = {}".format(CRL_EXPIRATION)
with create_template([expiration]) as template:
oldcrl = NamedTemporaryFile(mode="wb", prefix="old-crl")
oldcrl.write(open(CRL_FILE, "rb").read())
oldcrl.flush()
certtool_cmd(
"--generate-crl",
"--load-crl", oldcrl.name,
"--load-ca-privkey", CA_KEY,
"--load-ca-certificate", CA_CERT,
"--load-certificate", pubcert,
"--template", template,
"--outfile", CRL_FILE
)
oldcrl.close()
rmtree(basedir)
def is_key_line(line, match):
return line.startswith("---") and line.lstrip("- ").startswith(match)
def getkey(*args):
path = os.path.join(TASKD_DATA_DIR, "keys", *args)
buf = []
for line in open(path, "r"):
if len(buf) == 0:
if is_key_line(line, "BEGIN"):
buf.append(line)
continue
buf.append(line)
if is_key_line(line, "END"):
return ''.join(buf)
raise IOError("Unable to get key from {}.".format(path))
def mktaskkey(cfg, path, keydata):
heredoc = 'cat > "{}" <<EOF\n{}EOF'.format(path, keydata)
cmd = 'task config taskd.{} -- "{}"'.format(cfg, path)
return heredoc + "\n" + cmd
class User(object):
def __init__(self, org, name, key):
self.__org = org
self.name = name
self.key = key
def export(self):
pubcert = getkey(self.__org, self.name, "public.cert")
privkey = getkey(self.__org, self.name, "private.key")
cacert = getkey("ca.cert")
keydir = "${TASKDATA:-$HOME/.task}/keys"
credentials = '/'.join([self.__org, self.name, self.key])
allow_unquoted = string.ascii_letters + string.digits + "/-_."
if not all((c in allow_unquoted) for c in credentials):
credentials = "'" + credentials.replace("'", r"'\''") + "'"
script = [
"umask 0077",
'mkdir -p "{}"'.format(keydir),
mktaskkey("certificate", os.path.join(keydir, "public.cert"),
pubcert),
mktaskkey("key", os.path.join(keydir, "private.key"), privkey),
mktaskkey("ca", os.path.join(keydir, "ca.cert"), cacert),
"task config taskd.credentials -- {}".format(credentials)
]
return "\n".join(script) + "\n"
class Group(object):
def __init__(self, org, name):
self.__org = org
self.name = name
class Organisation(object):
def __init__(self, name, ignore_imperative):
self.name = name
self.ignore_imperative = ignore_imperative
def add_user(self, name):
"""
Create a new user along with a certificate and key.
Returns a 'User' object or None if the user already exists.
"""
if self.ignore_imperative and is_imperative(self.name):
return None
if name not in self.users.keys():
output = taskd_cmd("add", "user", self.name, name,
capture_stdout=True)
key = RE_USERKEY.search(output)
if key is None:
msg = "Unable to find key while creating user {}."
raise TaskdError(msg.format(name))
generate_key(self.name, name)
newuser = User(self.name, name, key.group(1))
self._lazy_users[name] = newuser
return newuser
return None
def del_user(self, name):
"""
Delete a user and revoke its keys.
"""
if name in self.users.keys():
user = self.get_user(name)
if self.ignore_imperative and \
is_imperative(self.name, "users", user.key):
return
# Work around https://bug.tasktools.org/browse/TD-40:
rmtree(mkpath(self.name, "users", user.key))
revoke_key(self.name, name)
del self._lazy_users[name]
def add_group(self, name):
"""
Create a new group.
Returns a 'Group' object or None if the group already exists.
"""
if self.ignore_imperative and is_imperative(self.name):
return None
if name not in self.groups.keys():
taskd_cmd("add", "group", self.name, name)
newgroup = Group(self.name, name)
self._lazy_groups[name] = newgroup
return newgroup
return None
def del_group(self, name):
"""
Delete a group.
"""
if name in self.users.keys():
if self.ignore_imperative and \
is_imperative(self.name, "groups", name):
return
taskd_cmd("remove", "group", self.name, name)
del self._lazy_groups[name]
def get_user(self, name):
return self.users.get(name)
@lazyprop
def users(self):
result = {}
for key in os.listdir(mkpath(self.name, "users")):
user = fetch_username(self.name, key)
if user is not None:
result[user] = User(self.name, user, key)
return result
def get_group(self, name):
return self.groups.get(name)
@lazyprop
def groups(self):
result = {}
for group in os.listdir(mkpath(self.name, "groups")):
result[group] = Group(self.name, group)
return result
class Manager(object):
def __init__(self, ignore_imperative=False):
"""
Instantiates an organisations manager.
If ignore_imperative is True, all actions that modify data are checked
whether they're created imperatively and if so, they will result in no
operation.
"""
self.ignore_imperative = ignore_imperative
def add_org(self, name):
"""
Create a new organisation.
Returns an 'Organisation' object or None if the organisation already
exists.
"""
if name not in self.orgs.keys():
taskd_cmd("add", "org", name)
neworg = Organisation(name, self.ignore_imperative)
self._lazy_orgs[name] = neworg
return neworg
return None
def del_org(self, name):
"""
Delete and revoke keys of an organisation with all its users and
groups.
"""
org = self.get_org(name)
if org is not None:
if self.ignore_imperative and is_imperative(name):
return
for user in org.users.keys():
org.del_user(user)
for group in org.groups.keys():
org.del_group(group)
taskd_cmd("remove", "org", name)
del self._lazy_orgs[name]
def get_org(self, name):
return self.orgs.get(name)
@lazyprop
def orgs(self):
result = {}
for org in os.listdir(mkpath()):
result[org] = Organisation(org, self.ignore_imperative)
return result
class OrganisationType(click.ParamType):
name = 'organisation'
def convert(self, value, param, ctx):
org = Manager().get_org(value)
if org is None:
self.fail("Organisation {} does not exist.".format(value))
return org
ORGANISATION = OrganisationType()
@click.group()
@click.pass_context
def cli(ctx):
"""
Manage Taskserver users and certificates
"""
for path in (CA_KEY, CA_CERT, CRL_FILE):
if not os.path.exists(path):
msg = "CA setup not done or incomplete, missing file {}."
ctx.fail(msg.format(path))
@cli.group("org")
def org_cli():
"""
Manage organisations
"""
pass
@cli.group("user")
def user_cli():
"""
Manage users
"""
pass
@cli.group("group")
def group_cli():
"""
Manage groups
"""
pass
@user_cli.command("list")
@click.argument("organisation", type=ORGANISATION)
def list_users(organisation):
"""
List all users belonging to the specified organisation.
"""
label("The following users exists for {}:".format(organisation.name))
for user in organisation.users.values():
sys.stdout.write(user.name + "\n")
@group_cli.command("list")
@click.argument("organisation", type=ORGANISATION)
def list_groups(organisation):
"""
List all users belonging to the specified organisation.
"""
label("The following users exists for {}:".format(organisation.name))
for group in organisation.groups.values():
sys.stdout.write(group.name + "\n")
@org_cli.command("list")
def list_orgs():
"""
List available organisations
"""
label("The following organisations exist:")
for org in Manager().orgs:
sys.stdout.write(org.name + "\n")
@user_cli.command("getkey")
@click.argument("organisation", type=ORGANISATION)
@click.argument("user")
def get_uuid(organisation, user):
"""
Get the UUID of the specified user belonging to the specified organisation.
"""
userobj = organisation.get_user(user)
if userobj is None:
msg = "User {} doesn't exist in organisation {}."
sys.exit(msg.format(userobj.name, organisation.name))
label("User {} has the following UUID:".format(userobj.name))
sys.stdout.write(user.key + "\n")
@user_cli.command("export")
@click.argument("organisation", type=ORGANISATION)
@click.argument("user")
def export_user(organisation, user):
"""
Export user of the specified organisation as a series of shell commands
that can be used on the client side to easily import the certificates.
Note that the private key will be exported as well, so use this with care!
"""
userobj = organisation.get_user(user)
if userobj is None:
msg = "User {} doesn't exist in organisation {}."
sys.exit(msg.format(userobj.name, organisation.name))
sys.stdout.write(userobj.export())
@org_cli.command("add")
@click.argument("name")
def add_org(name):
"""
Create an organisation with the specified name.
"""
if os.path.exists(mkpath(name)):
msg = "Organisation with name {} already exists."
sys.exit(msg.format(name))
taskd_cmd("add", "org", name)
mark_imperative(name)
@org_cli.command("remove")
@click.argument("name")
def del_org(name):
"""
Delete the organisation with the specified name.
All of the users and groups will be deleted as well and client certificates
will be revoked.
"""
Manager().del_org(name)
msg = ("Organisation {} deleted. Be sure to restart the Taskserver"
" using 'systemctl restart taskserver.service' in order for"
" the certificate revocation to apply.")
click.echo(msg.format(name), err=True)
@user_cli.command("add")
@click.argument("organisation", type=ORGANISATION)
@click.argument("user")
def add_user(organisation, user):
"""
Create a user for the given organisation along with a client certificate
and print the key of the new user.
The client certificate along with it's public key can be shown via the
'user export' subcommand.
"""
userobj = organisation.add_user(user)
if userobj is None:
msg = "User {} already exists in organisation {}."
sys.exit(msg.format(user, organisation))
else:
mark_imperative(organisation.name, "users", userobj.key)
@user_cli.command("remove")
@click.argument("organisation", type=ORGANISATION)
@click.argument("user")
def del_user(organisation, user):
"""
Delete a user from the given organisation.
This will also revoke the client certificate of the given user.
"""
organisation.del_user(user)
msg = ("User {} deleted. Be sure to restart the Taskserver using"
" 'systemctl restart taskserver.service' in order for the"
" certificate revocation to apply.")
click.echo(msg.format(user), err=True)
@group_cli.command("add")
@click.argument("organisation", type=ORGANISATION)
@click.argument("group")
def add_group(organisation, group):
"""
Create a group for the given organisation.
"""
groupobj = organisation.add_group(group)
if groupobj is None:
msg = "Group {} already exists in organisation {}."
sys.exit(msg.format(group, organisation))
else:
mark_imperative(organisation.name, "groups", groupobj.name)
@group_cli.command("remove")
@click.argument("organisation", type=ORGANISATION)
@click.argument("group")
def del_group(organisation, group):
"""
Delete a group from the given organisation.
"""
organisation.del_group(group)
click("Group {} deleted.".format(group), err=True)
def add_or_delete(old, new, add_fun, del_fun):
"""
Given an 'old' and 'new' list, figure out the intersections and invoke
'add_fun' against every element that is not in the 'old' list and 'del_fun'
against every element that is not in the 'new' list.
Returns a tuple where the first element is the list of elements that were
added and the second element consisting of elements that were deleted.
"""
old_set = set(old)
new_set = set(new)
to_delete = old_set - new_set
to_add = new_set - old_set
for elem in to_delete:
del_fun(elem)
for elem in to_add:
add_fun(elem)
return to_add, to_delete
@cli.command("process-json")
@click.argument('json-file', type=click.File('rb'))
def process_json(json_file):
"""
Create and delete users, groups and organisations based on a JSON file.
The structure of this file is exactly the same as the
'services.taskserver.organisations' option of the NixOS module and is used
for declaratively adding and deleting users.
Hence this subcommand is not recommended outside of the scope of the NixOS
module.
"""
data = json.load(json_file)
mgr = Manager(ignore_imperative=True)
add_or_delete(mgr.orgs.keys(), data.keys(), mgr.add_org, mgr.del_org)
for org in mgr.orgs.values():
if is_imperative(org.name):
continue
add_or_delete(org.users.keys(), data[org.name]['users'],
org.add_user, org.del_user)
add_or_delete(org.groups.keys(), data[org.name]['groups'],
org.add_group, org.del_group)
if __name__ == '__main__':
cli()

4
nixos/modules/services/networking/dnscrypt-proxy.nix
View File

@ -165,9 +165,9 @@ in
${pkgs.xz.out}/lib/liblzma.so.* mr,
${pkgs.libgcrypt.out}/lib/libgcrypt.so.* mr,
${pkgs.libgpgerror.out}/lib/libgpg-error.so.* mr,
${pkgs.libcap}/lib/libcap.so.* mr,
${pkgs.libcap.out}/lib/libcap.so.* mr,
${pkgs.lz4}/lib/liblz4.so.* mr,
${pkgs.attr}/lib/libattr.so.* mr,
${pkgs.attr.out}/lib/libattr.so.* mr,
${resolverListFile} r,
}

2
nixos/modules/services/networking/nntp-proxy.nix
View File

@ -224,7 +224,7 @@ in
serviceConfig.ExecStart = "${nntp-proxy}/bin/nntp-proxy ${confFile}";
preStart = ''
if [ ! \( -f ${cfg.sslCert} -a -f ${cfg.sslKey} \) ]; then
${pkgs.openssl}/bin/openssl req -subj '/CN=AutoGeneratedCert/O=NixOS Service/C=US' \
${pkgs.openssl.bin}/bin/openssl req -subj '/CN=AutoGeneratedCert/O=NixOS Service/C=US' \
-new -newkey rsa:2048 -days 365 -nodes -x509 -keyout ${cfg.sslKey} -out ${cfg.sslCert};
fi
'';

92
nixos/modules/services/networking/syncthing.nix
View File

@ -7,6 +7,21 @@ let
cfg = config.services.syncthing;
defaultUser = "syncthing";
header = {
description = "Syncthing service";
environment = {
STNORESTART = "yes";
STNOUPGRADE = "yes";
inherit (cfg) all_proxy;
} // config.networking.proxy.envVars;
};
service = {
Restart = "on-failure";
SuccessExitStatus = "2 3 4";
RestartForceExitStatus="3 4";
};
in
{
@ -17,22 +32,33 @@ in
services.syncthing = {
enable = mkOption {
enable = mkEnableOption ''
Syncthing - the self-hosted open-source alternative
to Dropbox and Bittorrent Sync. Initial interface will be
available on http://127.0.0.1:8384/.
'';
systemService = mkOption {
type = types.bool;
default = false;
description = ''
Whether to enable the Syncthing, self-hosted open-source alternative
to Dropbox and BittorrentSync. Initial interface will be
available on http://127.0.0.1:8384/.
'';
default = true;
description = "Auto launch Syncthing as a system service.";
};
user = mkOption {
type = types.string;
default = defaultUser;
description = ''
Syncthing will be run under this user (user must exist,
this can be your user name).
Syncthing will be run under this user (user will be created if it doesn't exist.
This can be your user name).
'';
};
group = mkOption {
type = types.string;
default = "nogroup";
description = ''
Syncthing will be run under this group (group will not be created if it doesn't exist.
This can be your user name).
'';
};
@ -64,10 +90,7 @@ in
Syncthing package to use.
'';
};
};
};
@ -77,7 +100,7 @@ in
users = mkIf (cfg.user == defaultUser) {
extraUsers."${defaultUser}" =
{ group = defaultUser;
{ group = cfg.group;
home = cfg.dataDir;
createHome = true;
uid = config.ids.uids.syncthing;
@ -88,30 +111,27 @@ in
config.ids.gids.syncthing;
};
systemd.services.syncthing =
{
description = "Syncthing service";
after = [ "network.target" ];
wantedBy = [ "multi-user.target" ];
environment = {
STNORESTART = "yes"; # do not self-restart
STNOUPGRADE = "yes";
inherit (cfg) all_proxy;
} // config.networking.proxy.envVars;
serviceConfig = {
User = cfg.user;
Group = optionalString (cfg.user == defaultUser) defaultUser;
PermissionsStartOnly = true;
Restart = "on-failure";
ExecStart = "${pkgs.syncthing}/bin/syncthing -no-browser -home=${cfg.dataDir}";
SuccessExitStatus = "2 3 4";
RestartForceExitStatus="3 4";
};
};
environment.systemPackages = [ cfg.package ];
};
systemd.services = mkIf cfg.systemService {
syncthing = header // {
after = [ "network.target" ];
wantedBy = [ "multi-user.target" ];
serviceConfig = service // {
User = cfg.user;
Group = cfg.group;
PermissionsStartOnly = true;
ExecStart = "${pkgs.syncthing}/bin/syncthing -no-browser -home=${cfg.dataDir}";
};
};
};
systemd.user.services = {
syncthing = header // {
serviceConfig = service // {
ExecStart = "${pkgs.syncthing}/bin/syncthing -no-browser";
};
};
};
};
}

24
nixos/modules/services/system/dbus.nix
View File

@ -139,30 +139,6 @@ in
systemd.services.dbus.restartTriggers = [ configDir ];
systemd.user = {
services.dbus = {
description = "D-Bus User Message Bus";
requires = [ "dbus.socket" ];
# NixOS doesn't support "Also" so we pull it in manually
# As the .service is supposed to come up at the same time as
# the .socket, we use basic.target instead of default.target
wantedBy = [ "basic.target" ];
serviceConfig = {
ExecStart = "${pkgs.dbus_daemon}/bin/dbus-daemon --session --address=systemd: --nofork --nopidfile --systemd-activation";
ExecReload = "${pkgs.dbus_daemon}/bin/dbus-send --print-reply --session --type=method_call --dest=org.freedesktop.DBus / org.freedesktop.DBus.ReloadConfig";
};
};
sockets.dbus = {
description = "D-Bus User Message Bus Socket";
socketConfig = {
ListenStream = "%t/bus";
ExecStartPost = "-${config.systemd.package}/bin/systemctl --user set-environment DBUS_SESSION_BUS_ADDRESS=unix:path=%t/bus";
};
wantedBy = [ "sockets.target" ];
};
};
environment.pathsToLink = [ "/etc/dbus-1" "/share/dbus-1" ];
};

100
nixos/modules/services/torrent/flexget.nix Normal file
View File

@ -0,0 +1,100 @@
{ config, lib, pkgs, timezone, ... }:
with lib;
let
cfg = config.services.flexget;
pkg = pkgs.python27Packages.flexget;
ymlFile = pkgs.writeText "flexget.yml" ''
${cfg.config}
${optionalString cfg.systemScheduler "schedules: no"}
'';
configFile = "${toString cfg.homeDir}/flexget.yml";
in {
options = {
services.flexget = {
enable = mkEnableOption "Run FlexGet Daemon";
user = mkOption {
default = "deluge";
example = "some_user";
type = types.string;
description = "The user under which to run flexget.";
};
homeDir = mkOption {
default = "/var/lib/deluge";
example = "/home/flexget";
type = types.path;
description = "Where files live.";
};
interval = mkOption {
default = "10m";
example = "1h";
type = types.string;
description = "When to perform a <command>flexget</command> run. See <command>man 7 systemd.time</command> for the format.";
};
systemScheduler = mkOption {
default = true;
example = "false";
type = types.bool;
description = "When true, execute the runs via the flexget-runner.timer. If false, you have to specify the settings yourself in the YML file.";
};
config = mkOption {
default = "";
type = types.lines;
description = "The YAML configuration for FlexGet.";
};
};
};
config = mkIf cfg.enable {
environment.systemPackages = [ pkgs.python27Packages.flexget ];
systemd.services = {
flexget = {
description = "FlexGet Daemon";
path = [ pkgs.pythonPackages.flexget ];
serviceConfig = {
User = cfg.user;
Environment = "TZ=${config.time.timeZone}";
ExecStartPre = "${pkgs.coreutils}/bin/install -m644 ${ymlFile} ${configFile}";
ExecStart = "${pkg}/bin/flexget -c ${configFile} daemon start";
ExecStop = "${pkg}/bin/flexget -c ${configFile} daemon stop";
ExecReload = "${pkg}/bin/flexget -c ${configFile} daemon reload";
Restart = "on-failure";
PrivateTmp = true;
WorkingDirectory = toString cfg.homeDir;
};
wantedBy = [ "multi-user.target" ];
};
flexget-runner = mkIf cfg.systemScheduler {
description = "FlexGet Runner";
after = [ "flexget.service" ];
wants = [ "flexget.service" ];
serviceConfig = {
User = cfg.user;
ExecStart = "${pkg}/bin/flexget -c ${configFile} execute";
PrivateTmp = true;
WorkingDirectory = toString cfg.homeDir;
};
};
};
systemd.timers.flexget-runner = mkIf cfg.systemScheduler {
description = "Run FlexGet every ${cfg.interval}";
wantedBy = [ "timers.target" ];
timerConfig = {
OnBootSec = "5m";
OnUnitInactiveSec = cfg.interval;
Unit = "flexget-runner.service";
};
};
};
}

2
nixos/modules/services/web-servers/apache-httpd/trac.nix
View File

@ -96,7 +96,7 @@ in
globalEnvVars = singleton
{ name = "PYTHONPATH";
value =
makeSearchPath "lib/${pkgs.python.libPrefix}/site-packages"
makeSearchPathOutputs "lib/${pkgs.python.libPrefix}/site-packages" ["lib"]
[ pkgs.mod_python
pkgs.pythonPackages.trac
pkgs.setuptools

2
nixos/modules/services/x11/desktop-managers/enlightenment.nix
View File

@ -7,7 +7,7 @@ let
e = pkgs.enlightenment;
xcfg = config.services.xserver;
cfg = xcfg.desktopManager.enlightenment;
GST_PLUGIN_PATH = lib.makeSearchPath "lib/gstreamer-1.0" [
GST_PLUGIN_PATH = lib.makeSearchPathOutputs "lib/gstreamer-1.0" ["lib"] [
pkgs.gst_all_1.gst-plugins-base
pkgs.gst_all_1.gst-plugins-good
pkgs.gst_all_1.gst-plugins-bad

5
nixos/modules/system/boot/coredump.nix
View File

@ -50,6 +50,11 @@ with lib;
(mkIf (!config.systemd.coredump.enable) {
boot.kernel.sysctl."kernel.core_pattern" = mkDefault "core";
systemd.extraConfig =
''
DefaultLimitCORE=0:infinity
'';
})
];

4
nixos/modules/system/boot/loader/grub/grub.nix
View File

@ -55,10 +55,10 @@ let
version extraConfig extraPerEntryConfig extraEntries
extraEntriesBeforeNixOS extraPrepareConfig configurationLimit copyKernels timeout
default fsIdentifier efiSupport gfxmodeEfi gfxmodeBios;
path = (makeSearchPath "bin" ([
path = (makeBinPath ([
pkgs.coreutils pkgs.gnused pkgs.gnugrep pkgs.findutils pkgs.diffutils pkgs.btrfs-progs
pkgs.utillinux ] ++ (if cfg.efiSupport && (cfg.version == 2) then [pkgs.efibootmgr ] else [])
)) + ":" + (makeSearchPath "sbin" [
)) + ":" + (makeSearchPathOutputs "sbin" ["bin"] [
pkgs.mdadm pkgs.utillinux
]);
});

4
nixos/modules/system/boot/stage-1.nix
View File

@ -31,7 +31,6 @@ let
extraUtils = pkgs.runCommand "extra-utils"
{ buildInputs = [pkgs.nukeReferences];
allowedReferences = [ "out" ]; # prevent accidents like glibc being included in the initrd
doublePatchelf = pkgs.stdenv.isArm;
}
''
set +o pipefail
@ -111,9 +110,6 @@ let
if ! test -L $i; then
echo "patching $i..."
patchelf --set-interpreter $out/lib/ld*.so.? --set-rpath $out/lib $i || true
if [ -n "$doublePatchelf" ]; then
patchelf --set-interpreter $out/lib/ld*.so.? --set-rpath $out/lib $i || true
fi
fi
done

2
nixos/modules/system/boot/systemd-unit-options.nix
View File

@ -193,7 +193,7 @@ in rec {
path = mkOption {
default = [];
apply = ps: "${makeSearchPath "bin" ps}:${makeSearchPath "sbin" ps}";
apply = ps: "${makeBinPath ps}:${makeSearchPathOutputs "sbin" ["bin"] ps}";
description = ''
Packages added to the service's <envar>PATH</envar>
environment variable. Both the <filename>bin</filename>

2
nixos/modules/virtualisation/azure-agent.nix
View File

@ -42,7 +42,7 @@ let
wrapProgram "$out/bin/waagent" \
--prefix PYTHONPATH : $PYTHONPATH \
--prefix PATH : "${makeSearchPath "bin" runtimeDeps}"
--prefix PATH : "${makeBinPath runtimeDeps}"
'';
};

2
nixos/modules/virtualisation/virtualbox-guest.nix
View File

@ -66,7 +66,7 @@ in
services.xserver.displayManager.sessionCommands =
''
PATH=${makeSearchPath "bin" [ pkgs.gnugrep pkgs.which pkgs.xorg.xorgserver.out ]}:$PATH \
PATH=${makeBinPath [ pkgs.gnugrep pkgs.which pkgs.xorg.xorgserver.out ]}:$PATH \
${kernel.virtualboxGuestAdditions}/bin/VBoxClient-all
'';

1
nixos/release.nix
View File

@ -253,6 +253,7 @@ in rec {
tests.sddm = callTest tests/sddm.nix {};
tests.sddm-kde5 = callTest tests/sddm-kde5.nix {};
tests.simple = callTest tests/simple.nix {};
tests.taskserver = callTest tests/taskserver.nix {};
tests.tomcat = callTest tests/tomcat.nix {};
tests.udisks2 = callTest tests/udisks2.nix {};
tests.virtualbox = callSubTests tests/virtualbox.nix { system = "x86_64-linux"; };

166
nixos/tests/taskserver.nix Normal file
View File

@ -0,0 +1,166 @@
import ./make-test.nix {
name = "taskserver";
nodes = rec {
server = {
services.taskserver.enable = true;
services.taskserver.listenHost = "::";
services.taskserver.fqdn = "server";
services.taskserver.organisations = {
testOrganisation.users = [ "alice" "foo" ];
anotherOrganisation.users = [ "bob" ];
};
};
client1 = { pkgs, ... }: {
environment.systemPackages = [ pkgs.taskwarrior pkgs.gnutls ];
users.users.alice.isNormalUser = true;
users.users.bob.isNormalUser = true;
users.users.foo.isNormalUser = true;
users.users.bar.isNormalUser = true;
};
client2 = client1;
};
testScript = { nodes, ... }: let
cfg = nodes.server.config.services.taskserver;
portStr = toString cfg.listenPort;
in ''
sub su ($$) {
my ($user, $cmd) = @_;
my $esc = $cmd =~ s/'/'\\${"'"}'/gr;
return "su - $user -c '$esc'";
}
sub setupClientsFor ($$) {
my ($org, $user) = @_;
for my $client ($client1, $client2) {
$client->nest("initialize client for user $user", sub {
$client->succeed(
(su $user, "rm -rf /home/$user/.task"),
(su $user, "task rc.confirmation=no config confirmation no")
);
my $exportinfo = $server->succeed(
"nixos-taskserver user export $org $user"
);
$exportinfo =~ s/'/'\\'''/g;
$client->nest("importing taskwarrior configuration", sub {
my $cmd = su $user, "eval '$exportinfo' >&2";
my ($status, $out) = $client->execute_($cmd);
if ($status != 0) {
$client->log("output: $out");
die "command `$cmd' did not succeed (exit code $status)\n";
}
});
$client->succeed(su $user,
"task config taskd.server server:${portStr} >&2"
);
$client->succeed(su $user, "task sync init >&2");
});
}
}
sub restartServer {
$server->succeed("systemctl restart taskserver.service");
$server->waitForOpenPort(${portStr});
}
sub readdImperativeUser {
$server->nest("(re-)add imperative user bar", sub {
$server->execute("nixos-taskserver org remove imperativeOrg");
$server->succeed(
"nixos-taskserver org add imperativeOrg",
"nixos-taskserver user add imperativeOrg bar"
);
setupClientsFor "imperativeOrg", "bar";
});
}
sub testSync ($) {
my $user = $_[0];
subtest "sync for user $user", sub {
$client1->succeed(su $user, "task add foo >&2");
$client1->succeed(su $user, "task sync >&2");
$client2->fail(su $user, "task list >&2");
$client2->succeed(su $user, "task sync >&2");
$client2->succeed(su $user, "task list >&2");
};
}
sub checkClientCert ($) {
my $user = $_[0];
my $cmd = "gnutls-cli".
" --x509cafile=/home/$user/.task/keys/ca.cert".
" --x509keyfile=/home/$user/.task/keys/private.key".
" --x509certfile=/home/$user/.task/keys/public.cert".
" --port=${portStr} server < /dev/null";
return su $user, $cmd;
}
startAll;
$server->waitForUnit("taskserver.service");
$server->succeed(
"nixos-taskserver user list testOrganisation | grep -qxF alice",
"nixos-taskserver user list testOrganisation | grep -qxF foo",
"nixos-taskserver user list anotherOrganisation | grep -qxF bob"
);
$server->waitForOpenPort(${portStr});
$client1->waitForUnit("multi-user.target");
$client2->waitForUnit("multi-user.target");
setupClientsFor "testOrganisation", "alice";
setupClientsFor "testOrganisation", "foo";
setupClientsFor "anotherOrganisation", "bob";
testSync $_ for ("alice", "bob", "foo");
$server->fail("nixos-taskserver user add imperativeOrg bar");
readdImperativeUser;
testSync "bar";
subtest "checking certificate revocation of user bar", sub {
$client1->succeed(checkClientCert "bar");
$server->succeed("nixos-taskserver user remove imperativeOrg bar");
restartServer;
$client1->fail(checkClientCert "bar");
$client1->succeed(su "bar", "task add destroy everything >&2");
$client1->fail(su "bar", "task sync >&2");
};
readdImperativeUser;
subtest "checking certificate revocation of org imperativeOrg", sub {
$client1->succeed(checkClientCert "bar");
$server->succeed("nixos-taskserver org remove imperativeOrg");
restartServer;
$client1->fail(checkClientCert "bar");
$client1->succeed(su "bar", "task add destroy even more >&2");
$client1->fail(su "bar", "task sync >&2");
};
readdImperativeUser;
subtest "check whether declarative config overrides user bar", sub {
restartServer;
testSync "bar";
};
'';
}

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

@ -48,7 +48,9 @@ in stdenv.mkDerivation rec {
'';
configurePhase = ''
runHook preConfigure
qmake PREFIX=$out PREFIXSHORTCUT=$out dfasma.pro
runHook postConfigure
'';
enableParallelBuilding = true;

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

@ -24,6 +24,7 @@ stdenv.mkDerivation rec {
++ stdenv.lib.optionals portaudioSupport [ portaudio ];
configurePhase = ''
runHook preConfigure
mkdir build
cd build
qmake \
@ -32,6 +33,7 @@ stdenv.mkDerivation rec {
CONFIG+=${stdenv.lib.optionalString portaudioSupport "acs_portaudio"} \
PREFIX="$out" PREFIXSHORTCUT="$out" \
../fmit.pro
runHook postConfigure
'';
enableParallelBuilding = true;

6
pkgs/applications/audio/iannix/default.nix
View File

@ -13,7 +13,11 @@ stdenv.mkDerivation rec {
buildInputs = [ alsaLib pkgconfig qt5.qtbase qt5.qtscript ];
configurePhase = ''qmake PREFIX=/'';
configurePhase = ''
runHook preConfigure
qmake PREFIX=/
runHook postConfigure
'';
installFlags = [ "INSTALL_ROOT=$(out)" ];

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

@ -21,7 +21,9 @@ stdenv.mkDerivation rec {
'';
configurePhase = ''
runHook preConfigure
qmake
runHook postConfigure
'';
enableParallelBuilding = true;

28
pkgs/applications/editors/atom/default.nix
View File

@ -1,19 +1,19 @@
{ stdenv, fetchurl, buildEnv, makeDesktopItem, makeWrapper, zlib, glib, alsaLib
{ stdenv, fetchurl, lib, makeDesktopItem, makeWrapper, zlib, glib, alsaLib
, dbus, gtk, atk, pango, freetype, fontconfig, libgnome_keyring3, gdk_pixbuf
, gvfs, cairo, cups, expat, libgpgerror, nspr, gconf, nss, xorg, libcap, systemd
}:
let
atomEnv = buildEnv {
name = "env-atom";
paths = [
stdenv.cc.cc zlib glib dbus gtk atk pango freetype libgnome_keyring3
fontconfig gdk_pixbuf cairo cups expat libgpgerror alsaLib nspr gconf nss
xorg.libXrender xorg.libX11 xorg.libXext xorg.libXdamage xorg.libXtst
xorg.libXcomposite xorg.libXi xorg.libXfixes xorg.libXrandr
xorg.libXcursor libcap systemd
];
};
atomPkgs = [
stdenv.cc.cc zlib glib dbus gtk atk pango freetype libgnome_keyring3
fontconfig gdk_pixbuf cairo cups expat libgpgerror alsaLib nspr gconf nss
xorg.libXrender xorg.libX11 xorg.libXext xorg.libXdamage xorg.libXtst
xorg.libXcomposite xorg.libXi xorg.libXfixes xorg.libXrandr
xorg.libXcursor libcap systemd
];
atomLib = lib.makeLibraryPath atomPkgs;
atomLib64 = lib.makeSearchPathOutputs "lib64" ["lib"] atomPkgs;
in stdenv.mkDerivation rec {
name = "atom-${version}";
version = "1.6.2";
@ -24,7 +24,7 @@ in stdenv.mkDerivation rec {
name = "${name}.deb";
};
buildInputs = [ atomEnv gvfs makeWrapper ];
nativeBuildInputs = [ makeWrapper ];
phases = [ "installPhase" "fixupPhase" ];
@ -41,10 +41,10 @@ in stdenv.mkDerivation rec {
patchelf --set-interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" \
$out/share/atom/resources/app/apm/bin/node
wrapProgram $out/bin/atom \
--prefix "LD_LIBRARY_PATH" : "${atomEnv}/lib:${atomEnv}/lib64" \
--prefix "LD_LIBRARY_PATH" : "${atomLib}:${atomLib64}" \
--prefix "PATH" : "${gvfs}/bin"
wrapProgram $out/bin/apm \
--prefix "LD_LIBRARY_PATH" : "${atomEnv}/lib:${atomEnv}/lib64"
--prefix "LD_LIBRARY_PATH" : "${atomLib}:${atomLib64}"
'';
meta = with stdenv.lib; {

109
pkgs/applications/editors/vscode/default.nix
View File

@ -1,90 +1,50 @@
{ callPackage, stdenv, fetchurl, makeWrapper
, jq, xlibs, gtk, python, nodejs
{ stdenv, callPackage, fetchurl, unzip
, ...
} @ args:
let
electron = callPackage ../../../development/tools/electron/default.nix (args // rec {
version = "0.35.6";
sha256 = "1bwn14769nby04zkza9jphsya2p6fjnkm1k2y4h5y2l4gnqdvmx0";
});
atomEnv = callPackage ../../../development/tools/electron/env-atom.nix (args);
version = "0.10.10";
rev = "5b5f4db87c10345b9d5c8d0bed745bcad4533135";
sha256 = if stdenv.system == "i686-linux" then "1mmgq4fxi2h4hvz7yxgzzyvlznkb42qwr8i1g2b1akdlgnrvvpby"
else if stdenv.system == "x86_64-linux" then "1zjb6mys5qs9mb21rpgpnbgq4gpnw6gsgfn5imf7ca7myk1bxnvk"
else if stdenv.system == "x86_64-darwin" then "0y1as2s6nhicyvdfszphhqp76iv9wcygglrl2f0jamm98g9qp66p"
else throw "Unsupported system: ${stdenv.system}";
urlMod = if stdenv.system == "i686-linux" then "linux-ia32"
else if stdenv.system == "x86_64-linux" then "linux-x64"
else if stdenv.system == "x86_64-darwin" then "darwin"
else throw "Unsupported system: ${stdenv.system}";
in
stdenv.mkDerivation rec {
name = "vscode-${version}";
version = "0.10.10";
inherit version;
src = fetchurl {
url = "https://github.com/Microsoft/vscode/archive/${version}.tar.gz";
sha256 = "1mzkip6621111xwwksqjad1kgpbhna4dhpkf6cnj2r18dkk2jmcw";
url = "https://az764295.vo.msecnd.net/stable/${rev}/VSCode-${urlMod}-stable.zip";
inherit sha256;
};
buildInputs = [ makeWrapper jq xlibs.libX11 xlibs.xproto gtk python nodejs electron ];
extensionGalleryJSON = ''
{
\"extensionsGallery\": {
\"serviceUrl\": \"https://marketplace.visualstudio.com/_apis/public/gallery\",
\"cacheUrl\": \"https://vscode.blob.core.windows.net/gallery/index\",
\"itemUrl\": \"https://marketplace.visualstudio.com/items\"
}
}
'';
configurePhase = ''
# PATCH SCRIPT SHEBANGS
echo "PATCH SCRIPT SHEBANGS"
patchShebangs ./scripts
# ADD EXTENSION GALLERY URLS TO APPLICATION CONFIGURATION
echo "AUGMENT APPLICATION CONFIGURATION"
echo "$(cat ./product.json) ${extensionGalleryJSON}" | jq -s add > tmpFile && \
mv tmpFile ./product.json
'';
buildPhase = ''
# BUILD COMPILE- & RUN-TIME DEPENDENCIES
echo "BUILD COMPILE- & RUN-TIME DEPENDENCIES"
mkdir -p ./tmp
HOME=./tmp ./scripts/npm.sh install
# COMPILE SOURCES
echo "COMPILE SOURCES"
./node_modules/.bin/gulp
'';
doCheck = true;
checkPhase = ''
# CHECK APPLICATION
echo "CHECK APPLICATION"
ATOM_SHELL_INTERNAL_RUN_AS_NODE=1 ${electron}/bin/electron ./node_modules/.bin/_mocha
'';
buildInputs = [ unzip ];
installPhase = ''
# PRUNE COMPILE-TIME DEPENDENCIES
echo "PRUNE COMPILE-TIME DEPENDENCIES"
npm prune --production
mkdir -p $out/bin
cp -r ./* $out/bin
# COPY FILES NEEDED FOR RUNNING APPLICATION TO OUT DIRECTORY
echo "COPY FILES NEEDED FOR RUNNING APPLICATION TO OUT DIRECTORY"
mkdir -p "$out"
cp -R ./.vscode "$out"/.vscode
cp -R ./extensions "$out"/extensions
cp -R ./out "$out"/out
cp -R ./node_modules "$out"/node_modules
cp ./package.json "$out"/package.json
cp ./product.json "$out"/product.json
cp ./tslint.json "$out"/tslint.json
# COPY LEGAL STUFF
cp ./LICENSE.txt "$out"/LICENSE.txt
cp ./OSSREADME.json "$out"/OSSREADME.json
cp ./ThirdPartyNotices.txt "$out"/ThirdPartyNotices.txt
${if (stdenv.system == "i686-linux" || stdenv.system == "x86_64-linux") then ''
patchelf --set-interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" \
$out/bin/code
'' else ""}
'';
# CREATE RUNNER SCRIPT
echo "CREATE RUNNER SCRIPT"
mkdir -p "$out"/bin
makeWrapper "${electron}/bin/electron" "$out/bin/vscode" \
--set VSCODE_DEV 1 \
--add-flags "$out"
postFixup = ''
${if (stdenv.system == "i686-linux" || stdenv.system == "x86_64-linux") then ''
patchelf \
--set-rpath "${atomEnv}/lib:${atomEnv}/lib64:$out/bin:$(patchelf --print-rpath $out/bin/code)" \
$out/bin/code
'' else ""}
'';
meta = with stdenv.lib; {
@ -95,7 +55,8 @@ in
It is also customizable, so users can change the editor's theme, keyboard shortcuts, and preferences.
'';
homepage = http://code.visualstudio.com/;
license = licenses.mit;
platforms = [ "x86_64-linux" ];
downloadPage = https://code.visualstudio.com/Updates;
license = licenses.unfree;
platforms = [ "i686-linux" "x86_64-linux" "x86_64-darwin" ];
};
}

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

@ -32,6 +32,7 @@ in
];
configurePhase = ''
runHook preConfigure
export GITREV=${gitRev}
export GITBRANCH=${gitBranch}
export GITTAG=${gitTag}
@ -39,6 +40,7 @@ in
cd qt
export sourceRoot=$sourceRoot/qt
qmake antimony.pro PREFIX=$out
runHook postConfigure
'';
enableParallelBuilding = true;

15
pkgs/applications/graphics/geeqie/default.nix
View File

@ -1,21 +1,22 @@
{ stdenv, fetchurl, pkgconfig, gtk, libpng, exiv2
, lcms, intltool, gettext, libchamplain, fbida
{ stdenv, fetchurl, pkgconfig, autoconf, automake, gtk, libpng, exiv2
, lcms, intltool, gettext, fbida
}:
stdenv.mkDerivation rec {
name = "geeqie-${version}";
version = "1.1"; # Don't upgrade to 1.2; see fee59b1235e658954b207ff6679264654c4708d2.
version = "1.2.3";
src = fetchurl {
url = "mirror://sourceforge/geeqie/${name}.tar.gz";
sha256 = "1kzy39z9505xkayyx7rjj2wda76xy3ch1s5z35zn8yli54ffhi2m";
url = "http://geeqie.org/${name}.tar.xz";
sha256 = "2629bf33a9070fad4804b1ef051c3bf8a8fdad3bba4e6188dc20588185003248";
};
preConfigure = "./autogen.sh";
configureFlags = [ "--enable-gps" ];
buildInputs = [
pkgconfig gtk libpng exiv2 lcms intltool gettext
#libchamplain
pkgconfig autoconf automake gtk libpng exiv2 lcms intltool gettext
];
postInstall = ''

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

@ -16,8 +16,10 @@ stdenv.mkDerivation rec {
buildInputs = [ qtbase exiv2 ];
configurePhase = ''
runHook preConfigure
sed -i 's;/usr;;' phototonic.pro
qmake PREFIX=""
runHook postConfigure
'';
installFlags = [ "INSTALL_ROOT=$(out)" ];

4
pkgs/applications/graphics/rapcad/default.nix
View File

@ -15,8 +15,10 @@ stdenv.mkDerivation rec {
buildInputs = [ qtbase cgal boost gmp mpfr flex bison dxflib readline ];
configurePhase = ''
qmake;
runHook preConfigure
qmake
sed -e "s@/usr/@$out/@g" -i $(find . -name Makefile)
runHook postConfigure
'';
meta = {

6
pkgs/applications/graphics/sane/backends/git.nix
View File

@ -1,10 +1,10 @@
{ callPackage, fetchgit, ... } @ args:
callPackage ./generic.nix (args // {
version = "2016-04-06";
version = "2016-04-14";
src = fetchgit {
sha256 = "af0b5943787bfe86169cd9bbf34284152e18b6df1f692773369545047e54a288";
rev = "e6b6ad9d4847e86aed8be0837a19bfada881f52d";
sha256 = "414fa7753043f8f3775d926eede01a9dbccf6255b2b2b961a3c48b4fa76a4952";
rev = "19c128a23e27c1ab5a030fa6ff74da1b740629bb";
url = "git://alioth.debian.org/git/sane/sane-backends.git";
};
})

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

@ -14,7 +14,7 @@ stdenv.mkDerivation rec {
sha256 = "0cgqaaikrb10plhf6zxbgqy32zqpiwyi9dpx3g8yr261q72r5c81";
};
NIX_CFLAGS_COMPILE = "-I${glib}/include/glib-2.0 -I${glib}/lib/glib-2.0/include";
NIX_CFLAGS_COMPILE = "-I${glib}/include/glib-2.0 -I${glib.out}/lib/glib-2.0/include";
configureFlags = [ "--disable-gsettings-convert-install" ];

6
pkgs/applications/misc/cool-retro-term/default.nix
View File

@ -19,7 +19,11 @@ stdenv.mkDerivation rec {
buildInputs = [ qtbase qtquick1 qmltermwidget qtquickcontrols qtgraphicaleffects ];
nativeBuildInputs = [ makeQtWrapper ];
configurePhase = "qmake PREFIX=$out";
configurePhase = ''
runHook preConfigure
qmake PREFIX=$out
runHook postConfigure
'';
installPhase = "make -j $NIX_BUILD_CORES INSTALL_ROOT=$out install";

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

@ -10,6 +10,10 @@ stdenv.mkDerivation {
sha256 = "0rgrsyi7951fsv3lzprlzrg55jf6pbdjfql85dylwmg9nc4y8xym";
};
postPatch = ''
sed -i 's,--static,,g' Makefile
'';
installPhase = ''
mkdir -p $out/bin
cp build/CuraEngine $out/bin/

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

@ -18,11 +18,11 @@ in
pythonPackages.buildPythonApplication rec {
name = "electrum-${version}";
version = "2.6.3";
version = "2.6.4";
src = fetchurl {
url = "https://download.electrum.org/${version}/Electrum-${version}.tar.gz";
sha256 = "0lj3a8zg6dznpnnxyza8a05c13py52j62rqlad1zcgksm5g63vic";
sha256 = "0rpqpspmrmgm0bhsnlnhlwhag6zg8hnv5bcw5vkqmv86891kpd9a";
};
propagatedBuildInputs = with pythonPackages; [

5
pkgs/applications/misc/guake/default.nix
View File

@ -16,8 +16,7 @@ gconftool-2 --recursive-unset /apps/guake
with lib;
let inputs = [ dbus gtk2 gconf python2 libutempter vte keybinder gnome3.gnome_common ];
pySubDir = "lib/${python2.libPrefix}/site-packages";
pyPath = makeSearchPath pySubDir (attrVals [ "dbus" "notify" "pyGtkGlade" "pyxdg" ] python2Packages ++ [ gnome2.gnome_python ]);
pyPath = makeSearchPathOutputs python2.sitePackages ["lib"] (attrVals [ "dbus" "notify" "pyGtkGlade" "pyxdg" ] python2Packages ++ [ gnome2.gnome_python ]);
in stdenv.mkDerivation rec {
name = "guake-${version}";
version = "0.8.3";
@ -63,7 +62,7 @@ let inputs = [ dbus gtk2 gconf python2 libutempter vte keybinder gnome3.gnome_co
wrapProgram $bin \
--prefix XDG_DATA_DIRS : "$out/share:$XDG_ICON_DIRS:$GSETTINGS_SCHEMAS_PATH" \
--prefix LD_LIBRARY_PATH : ${makeLibraryPath inputs} \
--prefix PYTHONPATH : "$out/${pySubDir}:${pyPath}:$PYTHONPATH"
--prefix PYTHONPATH : "$out/${python2.sitePackages}:${pyPath}:$PYTHONPATH"
done
'';

29
pkgs/applications/misc/j4-dmenu-desktop/default.nix Normal file
View File

@ -0,0 +1,29 @@
{ stdenv, fetchFromGitHub, cmake, dmenu }:
stdenv.mkDerivation rec {
name = "j4-dmenu-desktop-${version}";
version = "2.14";
src = fetchFromGitHub {
owner = "enkore";
repo = "j4-dmenu-desktop";
rev = "r${version}";
sha256 = "14srrkz4qx8qplgrrjv38ri4pnkxaxaq6jy89j13xhna492bq128";
};
postPatch = ''
sed -e 's,dmenu -i,${dmenu}/bin/dmenu -i,g' -i ./src/Main.hh
'';
nativeBuildInputs = [ cmake ];
# tests are fetching an external git repository
cmakeFlags = [ "-DNO_TESTS:BOOL=ON" ];
meta = with stdenv.lib; {
description = "A wrapper for dmenu that recognize .desktop files";
homepage = "https://github.com/enkore/j4-dmenu-desktop";
license = licenses.gpl3;
maintainer = with maintainers; [ ericsagnes ];
};
}

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

@ -16,8 +16,8 @@ stdenv.mkDerivation rec {
glib portaudio ];
cmakeFlags = [
"-DGTK2_GDKCONFIG_INCLUDE_DIR=${gtk2}/lib/gtk-2.0/include"
"-DGTK2_GLIBCONFIG_INCLUDE_DIR=${glib}/lib/glib-2.0/include"
"-DGTK2_GDKCONFIG_INCLUDE_DIR=${gtk2.out}/lib/gtk-2.0/include"
"-DGTK2_GLIBCONFIG_INCLUDE_DIR=${glib.out}/lib/glib-2.0/include"
];
enableParallelBuilding = true;

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

@ -26,7 +26,7 @@ assert stdenv.isLinux;
let
version = "4.2.9";
binpath = stdenv.lib.makeSearchPath "bin"
binpath = stdenv.lib.makeBinPath
[ cabextract
python2Packages.python
gettext

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

@ -11,7 +11,11 @@ stdenv.mkDerivation rec {
buildInputs = [ git gnupg makeQtWrapper pass qtbase qtsvg qttools ];
configurePhase = "qmake CONFIG+=release PREFIX=$out DESTDIR=$out";
configurePhase = ''
runHook preConfigure
qmake CONFIG+=release PREFIX=$out DESTDIR=$out
runHook postConfigure
'';
installPhase = ''
mkdir $out/bin

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

@ -29,7 +29,7 @@ in stdenv.mkDerivation rec {
"-I${dbus_libs.lib}/lib/dbus-1.0/include" ];
# Fix up python path so the lockfile library is on it.
PYTHONPATH = stdenv.lib.makeSearchPath "lib/${pythonFull.libPrefix}/site-packages" [
PYTHONPATH = stdenv.lib.makeSearchPathOutputs pythonFull.sitePackages ["lib"] [
pythonPackages.curses pythonPackages.lockfile
];

42
pkgs/applications/misc/tint2/default.nix
View File

@ -1,37 +1,41 @@
{ stdenv, fetchFromGitLab, pkgconfig, cmake, pango, cairo, glib, imlib2, libXinerama
, libXrender, libXcomposite, libXdamage, libX11, libXrandr, gtk, libpthreadstubs
, libXdmcp, librsvg, libstartup_notification
{ stdenv, fetchFromGitLab, pkgconfig, cmake, gettext, pango, cairo, glib
, pcre , imlib2, libXinerama , libXrender, libXcomposite, libXdamage, libX11
, libXrandr, gtk, libpthreadstubs , libXdmcp, librsvg
, libstartup_notification, wrapGAppsHook
}:
stdenv.mkDerivation rec {
name = "tint2-${version}";
version = "0.12.7";
version = "0.12.9";
src = fetchFromGitLab {
owner = "o9000";
repo = "tint2";
rev = version;
sha256 = "01wb1yy7zfi01fl34yzpn1d30fykcf8ivmdlynnxp5znqrdsqm2r";
sha256 = "17n3yssqiwxqrwsxypzw8skwzxm2540ikbyx7kfxv2gqlbjx5y6q";
};
enableParallelBuilding = true;
buildInputs = [ pkgconfig cmake pango cairo glib imlib2 libXinerama
libXrender libXcomposite libXdamage libX11 libXrandr gtk libpthreadstubs
libXdmcp librsvg libstartup_notification
];
nativeBuildInputs = [ pkgconfig cmake gettext wrapGAppsHook ];
preConfigure =
''
substituteInPlace CMakeLists.txt --replace /etc $out/etc
'';
buildInputs = [ pango cairo glib pcre imlib2 libXinerama libXrender
libXcomposite libXdamage libX11 libXrandr gtk libpthreadstubs libXdmcp
librsvg libstartup_notification ];
prePatch =
''
substituteInPlace ./src/tint2conf/properties.c --replace /usr/share/ /run/current-system/sw/share/
substituteInPlace ./src/launcher/apps-common.c --replace /usr/share/ /run/current-system/sw/share/
substituteInPlace ./src/launcher/icon-theme-common.c --replace /usr/share/ /run/current-system/sw/share/
'';
preConfigure = ''
substituteInPlace CMakeLists.txt --replace /etc $out/etc
'';
prePatch = ''
for f in ./src/tint2conf/properties.c \
./src/launcher/apps-common.c \
./src/launcher/icon-theme-common.c \
./themes/*tint2rc
do
substituteInPlace $f --replace /usr/share/ /run/current-system/sw/share/
done
'';
meta = {
homepage = https://gitlab.com/o9000/tint2;

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

@ -12,8 +12,10 @@ stdenv.mkDerivation rec {
buildInputs = [ qtbase qtx11extras pkgconfig boost ];
configurePhase = ''
runHook preConfigure
sed -i s/-Werror// twmnd/twmnd.pro
qmake
runHook postConfigure
'';
installPhase = ''

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

@ -30,7 +30,7 @@ rec {
name = "zathura-${zathura_core.version}";
plugins_path = stdenv.lib.makeSearchPath "lib" [
plugins_path = stdenv.lib.makeLibraryPath [
zathura_djvu
zathura_ps
(if useMupdf then zathura_pdf_mupdf else zathura_pdf_poppler)

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

@ -64,8 +64,8 @@ let
'';
patchPhase = let
rpaths = [ stdenv.cc.cc.lib ];
mkrpath = p: "${makeSearchPath "lib64" p}:${makeSearchPath "lib" p}";
rpaths = [ stdenv.cc.cc ];
mkrpath = p: "${makeSearchPathOutputs "lib64" ["lib"] p}:${makeLibraryPath p}";
in ''
for sofile in PepperFlash/libpepflashplayer.so \
libwidevinecdm.so libwidevinecdmadapter.so; do

2
pkgs/applications/networking/browsers/firefox-bin/default.nix
View File

@ -105,7 +105,7 @@ stdenv.mkDerivation {
libheimdal
libpulseaudio
systemd
] + ":" + stdenv.lib.makeSearchPath "lib64" [
] + ":" + stdenv.lib.makeSearchPathOutputs "lib64" ["lib"] [
stdenv.cc.cc
];

37
pkgs/applications/networking/browsers/google-chrome/default.nix
View File

@ -7,7 +7,7 @@
, dbus_libs, gtk, gdk_pixbuf, gcc
# Will crash without.
, udev
, libudev
# Loaded at runtime.
, libexif
@ -39,21 +39,18 @@ let
withCustomModes = true;
};
env = buildEnv {
name = "google-chrome-env";
paths = [
glib fontconfig freetype pango cairo libX11 libXi atk gconf nss nspr
libXcursor libXext libXfixes libXrender libXScrnSaver libXcomposite
alsaLib libXdamage libXtst libXrandr expat cups
dbus_libs gtk gdk_pixbuf gcc
udev
libexif
liberation_ttf curl utillinux xdg_utils wget
flac harfbuzz icu libpng opusWithCustomModes snappy speechd
bzip2 libcap
]
++ optional pulseSupport libpulseaudio;
};
deps = [
stdenv.cc.cc
glib fontconfig freetype pango cairo libX11 libXi atk gconf nss nspr
libXcursor libXext libXfixes libXrender libXScrnSaver libXcomposite
alsaLib libXdamage libXtst libXrandr expat cups
dbus_libs gtk gdk_pixbuf gcc
libudev
libexif
liberation_ttf curl utillinux xdg_utils wget
flac harfbuzz icu libpng opusWithCustomModes snappy speechd
bzip2 libcap
] ++ optional pulseSupport libpulseaudio;
in stdenv.mkDerivation rec {
inherit version;
@ -61,13 +58,16 @@ in stdenv.mkDerivation rec {
src = binary;
buildInputs = [ env patchelf ];
buildInputs = [ patchelf ];
unpackPhase = ''
ar x $src
tar xf data.tar.xz
'';
rpath = makeLibraryPath deps + ":" + makeSearchPathOutputs "lib64" ["lib"] deps;
binpath = makeBinPath deps;
installPhase = ''
case ${channel} in
beta) appname=chrome-beta dist=beta ;;
@ -76,7 +76,6 @@ in stdenv.mkDerivation rec {
esac
exe=$out/bin/google-chrome-$dist
rpath="${env}/lib:${env}/lib64"
mkdir -p $out/bin $out/share
@ -103,7 +102,7 @@ in stdenv.mkDerivation rec {
cat > $exe << EOF
#!${bash}/bin/sh
export LD_LIBRARY_PATH=$rpath\''${LD_LIBRARY_PATH:+:\$LD_LIBRARY_PATH}
export PATH=${env}/bin\''${PATH:+:\$PATH}
export PATH=$binpath\''${PATH:+:\$PATH}
$out/share/google/$appname/google-$appname "\$@"
EOF
chmod +x $exe

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

@ -46,7 +46,7 @@ stdenv.mkDerivation rec {
libPath = stdenv.lib.makeLibraryPath buildInputs
+ stdenv.lib.optionalString (stdenv.system == "x86_64-linux")
(":" + stdenv.lib.makeSearchPath "lib64" buildInputs);
(":" + stdenv.lib.makeSearchPathOutputs "lib64" ["lib"] buildInputs);
preFixup =
''

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

@ -46,7 +46,7 @@ stdenv.mkDerivation rec {
libPath = stdenv.lib.makeLibraryPath buildInputs
+ stdenv.lib.optionalString (stdenv.system == "x86_64-linux")
(":" + stdenv.lib.makeSearchPath "lib64" buildInputs);
(":" + stdenv.lib.makeSearchPathOutputs "lib64" ["lib"] buildInputs);
buildPhase = ''
echo "Patching Vivaldi binaries"

2
pkgs/applications/networking/dropbox/default.nix
View File

@ -36,7 +36,7 @@ let
# relative location where the dropbox libraries are stored
appdir = "opt/dropbox";
ldpath = stdenv.lib.makeSearchPath "lib"
ldpath = stdenv.lib.makeLibraryPath
[
dbus_libs gcc.cc glib libdrm libffi libICE libSM libX11 libXmu
ncurses popt qtbase qtdeclarative qtwebkit zlib

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

@ -6,7 +6,7 @@ let
version = "4.0.1631";
rpath = stdenv.lib.makeSearchPath "lib" [
rpath = stdenv.lib.makeLibraryPath [
xorg.libXext
xorg.libSM
xorg.libICE

8
pkgs/applications/networking/instant-messengers/slack/default.nix
View File

@ -6,7 +6,7 @@ let
version = "2.0.3";
rpath = stdenv.lib.makeSearchPath "lib" [
rpath = stdenv.lib.makeLibraryPath [
alsaLib
atk
cairo
@ -23,6 +23,7 @@ let
libnotify
nspr
nss
stdenv.cc.cc
systemd
xorg.libX11
@ -57,7 +58,7 @@ in stdenv.mkDerivation {
mkdir -p $out
dpkg -x $src $out
cp -av $out/usr/* $out
rm -rf $out/usr
rm -rf $out/usr $out/share/lintian
# Otherwise it looks "suspicious"
chmod -R g-w $out
@ -73,7 +74,8 @@ in stdenv.mkDerivation {
# Fix the desktop link
substituteInPlace $out/share/applications/slack.desktop \
--replace /usr/lib/slack/slack $out/lib/slack/slack
--replace /usr/bin/ $out/bin/ \
--replace /usr/share/ $out/share/
'';
meta = with stdenv.lib; {

6
pkgs/applications/networking/instant-messengers/telegram/cutegram/default.nix
View File

@ -24,7 +24,11 @@ stdenv.mkDerivation rec {
enableParallelBuilding = true;
configurePhase = "qmake -r PREFIX=$out";
configurePhase = ''
runHook preConfigure
qmake -r PREFIX=$out
runHook postConfigure
'';
fixupPhase = ''
wrapQtProgram $out/bin/cutegram \

2
pkgs/applications/networking/instant-messengers/telegram/libqtelegram-aseman-edition/default.nix
View File

@ -20,7 +20,9 @@ stdenv.mkDerivation rec {
'';
configurePhase = ''
runHook preConfigure
qmake -r PREFIX=$out
runHook postConfigure
'';
meta = with stdenv.lib; {

4
pkgs/applications/networking/instant-messengers/telegram/tdesktop/default.nix
View File

@ -48,10 +48,10 @@ in stdenv.mkDerivation rec {
"DEFINES+=TDESKTOP_DISABLE_REGISTER_CUSTOM_SCHEME"
"INCLUDEPATH+=${gtk2}/include/gtk-2.0"
"INCLUDEPATH+=${glib}/include/glib-2.0"
"INCLUDEPATH+=${glib}/lib/glib-2.0/include"
"INCLUDEPATH+=${glib.out}/lib/glib-2.0/include"
"INCLUDEPATH+=${cairo}/include/cairo"
"INCLUDEPATH+=${pango}/include/pango-1.0"
"INCLUDEPATH+=${gtk2}/lib/gtk-2.0/include"
"INCLUDEPATH+=${gtk2.out}/lib/gtk-2.0/include"
"INCLUDEPATH+=${gdk_pixbuf}/include/gdk-pixbuf-2.0"
"INCLUDEPATH+=${atk}/include/atk-1.0"
"INCLUDEPATH+=${libappindicator-gtk2}/include/libappindicator-0.1"

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

@ -21,7 +21,9 @@ stdenv.mkDerivation rec {
'';
configurePhase = ''
runHook preConfigure
qmake -r PREFIX=$out BUILD_MODE+=lib
runHook postConfigure
'';
meta = with stdenv.lib; {

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

@ -17,6 +17,7 @@ stdenv.mkDerivation rec {
enableParallelBuild = true;
configurePhase = ''
runHook preConfigure
export QMAKEFEATURES=${libcommuni}/features
qmake -r \
COMMUNI_INSTALL_PREFIX=$out \
@ -25,6 +26,7 @@ stdenv.mkDerivation rec {
COMMUNI_INSTALL_ICONS=$out/share/icons/hicolor \
COMMUNI_INSTALL_DESKTOP=$out/share/applications \
COMMUNI_INSTALL_THEMES=$out/share/communi/themes
runHook postConfigure
'';
postInstall = ''

6
pkgs/applications/networking/linssid/default.nix
View File

@ -27,7 +27,11 @@ stdenv.mkDerivation rec {
rm -fr qwt-lib
'';
configurePhase = "qmake linssid.pro";
configurePhase = ''
runHook preConfigure
qmake linssid.pro
runHook postConfigure
'';
meta = with stdenv.lib; {
description = "Graphical wireless scanning for Linux";

2
pkgs/applications/networking/mailreaders/thunderbird-bin/default.nix
View File

@ -105,7 +105,7 @@ stdenv.mkDerivation {
nspr
nss
pango
] + ":" + stdenv.lib.makeSearchPath "lib64" [
] + ":" + stdenv.lib.makeSearchPathOutputs "lib64" ["lib"] [
stdenv.cc.cc
];

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

@ -4,123 +4,123 @@
# ruby generate_sources.rb > sources.nix
{
version = "38.7.2";
version = "45.0";
sources = [
{ locale = "ar"; arch = "linux-i686"; sha256 = "63cdb91df96bc132e0b9b6c702cdc82b9583a58be11863c76c0a1a04b689b1ed"; }
{ locale = "ar"; arch = "linux-x86_64"; sha256 = "d1dc64cc1ca886b81da71e132b31644d89b8f61b4fab5f886c00b3b8defcd49a"; }
{ locale = "ast"; arch = "linux-i686"; sha256 = "b71ee84b0e56d7dd9b4cb40032055c8c1f8b4c18e9d679d84b71c226c928a189"; }
{ locale = "ast"; arch = "linux-x86_64"; sha256 = "dbb80209a669529b17553d152d5b3ccffbabd5c44b1e6a7e63a2d011e5425a2c"; }
{ locale = "be"; arch = "linux-i686"; sha256 = "358cf7d9b9b13cbd5614daa4f140a412e777f2dffe0dfa2673b33582f59e02f9"; }
{ locale = "be"; arch = "linux-x86_64"; sha256 = "bd4ac7afafcc4b4a65e34f207f7c07b24be36c06c8e067fb75f4a22ce759fb4b"; }
{ locale = "bg"; arch = "linux-i686"; sha256 = "853629b5625f9dd9a81d5f18d862f0f527043435a7c4624f6f78fa68541a5bba"; }
{ locale = "bg"; arch = "linux-x86_64"; sha256 = "8d094f3d934d2ca42c38b985145bec7f72b4ddb9af7c31e30413721eaecc934d"; }
{ locale = "bn-BD"; arch = "linux-i686"; sha256 = "d569e6211c4c011955553f3480fd8530ba6dd853b227859f95b0d8af4d9e8c6e"; }
{ locale = "bn-BD"; arch = "linux-x86_64"; sha256 = "5ed4e24f7725864b47dcbb0602463bc95bb33c8e4413483854e0bf3f33ad9376"; }
{ locale = "br"; arch = "linux-i686"; sha256 = "683716f591654dfc843a32198d5bbf6199bccb1a035d391293c4877f0ec47b1c"; }
{ locale = "br"; arch = "linux-x86_64"; sha256 = "965d58b4ea4280f20d197e28e0e9eb87b29fc955e4f6e15b6582027000d0da6f"; }
{ locale = "ca"; arch = "linux-i686"; sha256 = "eadc1248c9352574dcfcdcb3264a662d3a29f85a2f112f77a843f76d8778cba2"; }
{ locale = "ca"; arch = "linux-x86_64"; sha256 = "cdd631c4a32d529a85f04bee01bbc7f50396b183a0f154808e801d29f0f11aab"; }
{ locale = "cs"; arch = "linux-i686"; sha256 = "093f01ad325ba33f3f33f2efd72fb5cf3a87dd81162b094dc544744af78f3705"; }
{ locale = "cs"; arch = "linux-x86_64"; sha256 = "f74b39dfd0d9f2241ea65d55a6e9459296796adf228def80c57dd66c3f05921d"; }
{ locale = "cy"; arch = "linux-i686"; sha256 = "f84113f32952ae91a35d2aa166f16c4683e03fa43ce6fbd911d0f7f237b22ee8"; }
{ locale = "cy"; arch = "linux-x86_64"; sha256 = "6e53fd624a5c968e60cd485ea7c7b80a68c164c2f165287ec68a180066c560cb"; }
{ locale = "da"; arch = "linux-i686"; sha256 = "ff1f79558185d2a29487d15f95140716603f5978e8fcd891206ea0c5697342a0"; }
{ locale = "da"; arch = "linux-x86_64"; sha256 = "522c53748cc7ab0faab84e124e45f3bcdb865f4b5312ff129fc50700ebc4d8ef"; }
{ locale = "de"; arch = "linux-i686"; sha256 = "3e83bca492c325438f48880d76a259c3fbfa65eac71569a79e1fdff858268621"; }
{ locale = "de"; arch = "linux-x86_64"; sha256 = "020655df7c19750f86a7e1778846ed53e2fe350d44a76f4ac0acaeb82c9d4100"; }
{ locale = "dsb"; arch = "linux-i686"; sha256 = "3409d2988bb31b2dfc490e03976471e2d09139660a4c08daab518f3095b45170"; }
{ locale = "dsb"; arch = "linux-x86_64"; sha256 = "f5d084e8efe87488fed491432d93fb74c7e14b1fbcbc2abf21af6c669110b5bf"; }
{ locale = "el"; arch = "linux-i686"; sha256 = "514a3262c1d0e146b3dbfc24d54b73ce0a5e27e02f26692e25ba6e36897da125"; }
{ locale = "el"; arch = "linux-x86_64"; sha256 = "924b0e1514cddbad893446bb6561ca9422d46f6f5303fa7f847550f2f92a988f"; }
{ locale = "en-GB"; arch = "linux-i686"; sha256 = "1cff7f847a1ca8a52cfc9a733b7e223a8468a82f5ea9c7d8e1c074868a9baf27"; }
{ locale = "en-GB"; arch = "linux-x86_64"; sha256 = "5e803270db14ba348ab7b8697d488d172b774a8d782c22f079db0e8ccda793bf"; }
{ locale = "en-US"; arch = "linux-i686"; sha256 = "95428cacb129137747da7cab4c793f102f87a5224ad2a5adc6f52939df746432"; }
{ locale = "en-US"; arch = "linux-x86_64"; sha256 = "828317d27c4336aebf7122e2e5268697d8d0cdcde9bf874b63798f7fc6f84fd1"; }
{ locale = "es-AR"; arch = "linux-i686"; sha256 = "7ec8555eeb01f126671b89fd8dcc46f219bc938cf15ca8b7f67b13a1df38a101"; }
{ locale = "es-AR"; arch = "linux-x86_64"; sha256 = "082c9ace7d6775aff0e0b379206fa5109ce5bac08686ab937b7441edd6e17d6f"; }
{ locale = "es-ES"; arch = "linux-i686"; sha256 = "722e87bb5dbde3a7aa6ce5a913622a050a3fd1da822656a787cac6a18881737f"; }
{ locale = "es-ES"; arch = "linux-x86_64"; sha256 = "4420c5d0b773e76bdfa4e4ac842b86f3875ad81dc5b4d0666497a30d77267720"; }
{ locale = "et"; arch = "linux-i686"; sha256 = "a3128b1315428ec2906ff44bef49f8f448d7116bae80be7bd68bf78138cf5192"; }
{ locale = "et"; arch = "linux-x86_64"; sha256 = "299284d934129a15b70ca9f2d26fb05773d555972b14afe9f65826aaeda7bbf6"; }
{ locale = "eu"; arch = "linux-i686"; sha256 = "197ba5387010a6d95fff049d780829526d1676de43f1eaa16be2ae1f04f1601a"; }
{ locale = "eu"; arch = "linux-x86_64"; sha256 = "fc8386c294d107994463311d3778ad507a8848af3be8a533fd2c5be7394b9222"; }
{ locale = "fi"; arch = "linux-i686"; sha256 = "db764598fb0cec2fdd0e585b3396e53fa873af303c4f9a027061a0179e445705"; }
{ locale = "fi"; arch = "linux-x86_64"; sha256 = "ea87a217ec9934fae484a32f4dcc655cac04116c9b0c73e458eaee7e595f2b77"; }
{ locale = "fr"; arch = "linux-i686"; sha256 = "e27563fdfcfceb5ed4b2643d63d5c26834ca9afed1d887151671fd13086fd66a"; }
{ locale = "fr"; arch = "linux-x86_64"; sha256 = "0ee8fdb3d0a1e50afa5f232fba57d84b97c428c41176e73a712a2438bc3e8796"; }
{ locale = "fy-NL"; arch = "linux-i686"; sha256 = "a5a785c9ebfb40a7962e29603792de280c57ff5d77f7836c5048074d5c9d4178"; }
{ locale = "fy-NL"; arch = "linux-x86_64"; sha256 = "c5bbbb471fc2af310d768e7b01ff1336f78791a42a60b4473cdab00c0bd6e980"; }
{ locale = "ga-IE"; arch = "linux-i686"; sha256 = "9c18f2677315f8613203dc69a7877b83e787f6c0b96fb150ab7e4ba3ac712e54"; }
{ locale = "ga-IE"; arch = "linux-x86_64"; sha256 = "ccfcca939876bcca2e3b9fd81aee747d1c94f0df02f5258c9ae43564f61c7c23"; }
{ locale = "gd"; arch = "linux-i686"; sha256 = "60031f3767779568e49ea477fd2677adf0f437d5663a53b7d96203e2cbc85f1e"; }
{ locale = "gd"; arch = "linux-x86_64"; sha256 = "1090d5993cfffa923be8a8bb3acb197bd7968c994a1558a1024d81283e9341b2"; }
{ locale = "gl"; arch = "linux-i686"; sha256 = "5a67627f06ae51553730e9185a11208f6ba15c421ebc5fa3ba358a341830efae"; }
{ locale = "gl"; arch = "linux-x86_64"; sha256 = "2f7d114cfd69859f1cecd479ad00735744efe19b8a3db1be391fcd7dfe6ca757"; }
{ locale = "he"; arch = "linux-i686"; sha256 = "f6cd331db9669ec8d910210061e95f2c87e64afe6343f5faaf75a321a5b99471"; }
{ locale = "he"; arch = "linux-x86_64"; sha256 = "f665b75ad6ad846c57007e747931b89d773984beedb825c87fcb07a86ab52f9b"; }
{ locale = "hr"; arch = "linux-i686"; sha256 = "69b5baa57f47ce77373aa9505b2ccba0baf90911f2c3ebaef28b043b601ad34b"; }
{ locale = "hr"; arch = "linux-x86_64"; sha256 = "7bd6d9e36e87cf2e3aadb4fc7dec2dea371004466bc9a84ead3f60a59af38ae8"; }
{ locale = "hsb"; arch = "linux-i686"; sha256 = "72cd9a12387bc5dc02783bb6f6a1d55ab8444557e4d2c46c35b93ce0ab0cf394"; }
{ locale = "hsb"; arch = "linux-x86_64"; sha256 = "27b60e8cee363317070e74702d9ba97e5d68318caba0e17fc37aad6bf0fbb362"; }
{ locale = "hu"; arch = "linux-i686"; sha256 = "b0b8219da55e81f3feb0872333eadd0f490b251fae09244d31287f2e40339861"; }
{ locale = "hu"; arch = "linux-x86_64"; sha256 = "fb1b52b27253280f98e01b11e6f46e01d854998831b337a52922b925570ca330"; }
{ locale = "hy-AM"; arch = "linux-i686"; sha256 = "8474bc4a1fd0f8b27131ed3ba999402e1a56b7e04be157e571b95c470f43e779"; }
{ locale = "hy-AM"; arch = "linux-x86_64"; sha256 = "e68036c3057ce7c369b43335397c8248e5aac83a6db6e729c8e1116ed57a20a1"; }
{ locale = "id"; arch = "linux-i686"; sha256 = "23ea1fb9c64baf835be0a87f7633ee5b87cc05db90a652ca05f17d6b2cb1904c"; }
{ locale = "id"; arch = "linux-x86_64"; sha256 = "52584ff6ec72359f44891e630b099fc9114e1266a11cd0d063db5ff6034ed02e"; }
{ locale = "is"; arch = "linux-i686"; sha256 = "3e018dd9407823747dce9d32571a390a8fdff11339826bcd68c6879b8edb9c1b"; }
{ locale = "is"; arch = "linux-x86_64"; sha256 = "f86a8cd6be21403749607690c467baa126be38e547d1b0e3f50d40477b346fde"; }
{ locale = "it"; arch = "linux-i686"; sha256 = "82afb08b29d44aa09da71c454c42d31fbf7ee2756c6f1ddca5c456179e5a7f89"; }
{ locale = "it"; arch = "linux-x86_64"; sha256 = "d449b869faf6438697bb7e3f692c9bca6c1a116441b08dbd84e775de62564470"; }
{ locale = "ja"; arch = "linux-i686"; sha256 = "02bcacb390dd85bf2e7809751d840fa7c87bb8eac467d9bc2cb50a77559060f9"; }
{ locale = "ja"; arch = "linux-x86_64"; sha256 = "8ee832167990dc9546775a1c32518e4524b0f92147ce11e149b0b447932f7ecc"; }
{ locale = "ko"; arch = "linux-i686"; sha256 = "374b797f6d662e3deb5a05f6939f650a0ec272f7788cc7dc1a02fc0262e5c903"; }
{ locale = "ko"; arch = "linux-x86_64"; sha256 = "e0308132773119f13443ab475d66e651182adf508b7ca04b0efb65fd84013916"; }
{ locale = "lt"; arch = "linux-i686"; sha256 = "dce54478d896490141be7f10ef780196ce446e3312cf5623315baedc4354f992"; }
{ locale = "lt"; arch = "linux-x86_64"; sha256 = "e4b478609faa58ab0e8de7e2f542290f9ecf268d68f32828182208337523d3f5"; }
{ locale = "nb-NO"; arch = "linux-i686"; sha256 = "14b2df6e331ae651d1d913c2d7116466df63e9fd24aad02db7a7f3dd010820c4"; }
{ locale = "nb-NO"; arch = "linux-x86_64"; sha256 = "779f48e75546babae4ee153ce7d16f93af9daabf70f855dd702281e948a75cba"; }
{ locale = "nl"; arch = "linux-i686"; sha256 = "faa6893cff053c090428035964fe67af8ecf9f5b71225678754e96d38d498311"; }
{ locale = "nl"; arch = "linux-x86_64"; sha256 = "8a3ddebc51e182175afc272f16bdb7a584d78dd7af8849844f4e02892a439efd"; }
{ locale = "nn-NO"; arch = "linux-i686"; sha256 = "3298284a9b326eccc05343ec5795034fa46dbfe75458e19d39d23564391840ac"; }
{ locale = "nn-NO"; arch = "linux-x86_64"; sha256 = "e1f2da61eaf58f723e0c0021eb728e2a78a8cf36db60353e58d0233c2de60f73"; }
{ locale = "pa-IN"; arch = "linux-i686"; sha256 = "4cb1c3b16b8d70f19e14a185bfbbc505d66795ddc4d55e1575193dd018c950d6"; }
{ locale = "pa-IN"; arch = "linux-x86_64"; sha256 = "72b2c72ee5da9c4b353868efc0431b78feaeb0be8c18eecab6df4cfa0c5c7a3c"; }
{ locale = "pl"; arch = "linux-i686"; sha256 = "48e7d195e4b6b9144e32f4a254a40f10c59a167a05ce0f38a013f4b914511d55"; }
{ locale = "pl"; arch = "linux-x86_64"; sha256 = "ac6b2064b76b2a5f3cfad6089897126bca7cbf64922b61474eb01b0d65638221"; }
{ locale = "pt-BR"; arch = "linux-i686"; sha256 = "57aee02d52b638d393df6a824021a1355df83711dc50663cc67a71366004a017"; }
{ locale = "pt-BR"; arch = "linux-x86_64"; sha256 = "451de8f95bc2eaf67d1abb7ec604f566e5cb2f6b9a8ae2f2495f10a7157a12eb"; }
{ locale = "pt-PT"; arch = "linux-i686"; sha256 = "98391cba2a9cfd194cb427243738e588f6de9c112762a6c1e099ba7a4fe621a0"; }
{ locale = "pt-PT"; arch = "linux-x86_64"; sha256 = "92eeb485a7da11f1d600371d596c31fff778415784b54ec2fc5ba74199f49ec5"; }
{ locale = "rm"; arch = "linux-i686"; sha256 = "f4e3073d31b221dc2fb37162011d6ab9c0980137cd81f0d9bf70384cfda91e4a"; }
{ locale = "rm"; arch = "linux-x86_64"; sha256 = "4694fd61f7fe2a1066e08f85f041112076d63cf0fcb99db79c5833d714684388"; }
{ locale = "ro"; arch = "linux-i686"; sha256 = "088c29a337c926dcbe11ef19c072624014ae7b59cf0ba2a0b8f25a5a725ec796"; }
{ locale = "ro"; arch = "linux-x86_64"; sha256 = "0cb7c16955538ce7089e3aa8e5bc5c3325c4867aadf56837e7e3a05e86c4f482"; }
{ locale = "ru"; arch = "linux-i686"; sha256 = "b420443eec07c56afed8435c02c305d355935cb0131b672814878cc9fb0143e6"; }
{ locale = "ru"; arch = "linux-x86_64"; sha256 = "5964971c7261ba0619d34ce70d1fcf00aa105f159e2e47853d67fe03579dcbb7"; }
{ locale = "si"; arch = "linux-i686"; sha256 = "ffb21e8a7a02ec8ef445735bc519671f3f3bf90f994db750a4d29385d574fd24"; }
{ locale = "si"; arch = "linux-x86_64"; sha256 = "1177e20ff9b866c4c7e49a929c1f54c47174f80a8541ad0c98d5e472c4f20d26"; }
{ locale = "sk"; arch = "linux-i686"; sha256 = "1309eaf342d7bd7a31c1022183e13e1b02275b01228fbfbd0d5e8b3ef235cceb"; }
{ locale = "sk"; arch = "linux-x86_64"; sha256 = "adf736651eab43de2a927cd7ad471042f35eada0a5df4a09c0bbccf75dd17b44"; }
{ locale = "sl"; arch = "linux-i686"; sha256 = "102c828dd42872ca9472d94ff842f412bd907be1f4cec8605805fea9f75250e2"; }
{ locale = "sl"; arch = "linux-x86_64"; sha256 = "ebb608409f3c4ab44a6818020a826be7c3402977c18b08200df6b332e0a7fd3c"; }
{ locale = "sq"; arch = "linux-i686"; sha256 = "ff984951130343fdba5377f91e325e7cd21b7c4e25a524b4a1bc98978842e45c"; }
{ locale = "sq"; arch = "linux-x86_64"; sha256 = "15ca7d36207f8e7a80744d0d15966015c8dc395464cf7f70c98b643059f19fcb"; }
{ locale = "sr"; arch = "linux-i686"; sha256 = "6c93f80d249ab5558543cc7b13cf72c2abba1da0616a817661f790e5c17c24cd"; }
{ locale = "sr"; arch = "linux-x86_64"; sha256 = "3c6c64fbc264d4a3c98ae69c92ea778a87bd84ea23ded7f63117b4c77f93b4d5"; }
{ locale = "sv-SE"; arch = "linux-i686"; sha256 = "3a82d99b249d9a99d207fc0b1d5a1bd8523833dc61ec09dd917ff427659ec338"; }
{ locale = "sv-SE"; arch = "linux-x86_64"; sha256 = "0bf0e9ff45b3d25ef1b31f28b91e30280e8bdb25f864a31ccac795f66e27bb68"; }
{ locale = "ta-LK"; arch = "linux-i686"; sha256 = "d346b57092959dbc880c9dc5a8b832dc7967c171ac361aa9b7e77b5589bd4c9e"; }
{ locale = "ta-LK"; arch = "linux-x86_64"; sha256 = "6d86d75981ba1850980c3fa498c804dc64b4328c90d12d3a5c13af2f1e47af6d"; }
{ locale = "tr"; arch = "linux-i686"; sha256 = "179a67fbb2420615e179d1c69cc5dccf1b135a7c61aea26bda658c724655931f"; }
{ locale = "tr"; arch = "linux-x86_64"; sha256 = "bc95ac4b30ae806658218df21f5d9aa6c26b8b8c5fc8a58090de92e347735c58"; }
{ locale = "uk"; arch = "linux-i686"; sha256 = "8b49fbe88dcc328b94a99f3b30af9f783910dbcdea1fc5b160526409d56994f7"; }
{ locale = "uk"; arch = "linux-x86_64"; sha256 = "2ab49ec5742c07c44028d8aa980a6bd96623c554699037fd64d28cf4744789ce"; }
{ locale = "vi"; arch = "linux-i686"; sha256 = "6eecd8d5fa6d6a826fec7a09ba11092348a0fa74c7c7a8c1239f41392d2e2055"; }
{ locale = "vi"; arch = "linux-x86_64"; sha256 = "fdb2a25480eee0659803432fea02794f73aa18e9fe5a4b1c1c70ac5aceb09b4f"; }
{ locale = "zh-CN"; arch = "linux-i686"; sha256 = "64358161ecc5064ee9fd26e301136a58f32b387466d6127604772b59b44f32c5"; }
{ locale = "zh-CN"; arch = "linux-x86_64"; sha256 = "f9f54927e4ee378f56879b6ffc121d02ad300f6982d7751e730564ed9a9d8c80"; }
{ locale = "zh-TW"; arch = "linux-i686"; sha256 = "78a6721da743bec597c9dd1e6bededffa43d675784f3585b0d1f03989007f295"; }
{ locale = "zh-TW"; arch = "linux-x86_64"; sha256 = "fc3460aae0c3395220644ec0ce8c139512726e62d591ef51f4900ac3c9a9e461"; }
{ locale = "ar"; arch = "linux-i686"; sha256 = "1edc09feab9b25f333f192c07b33e0f4b3ee093145d32f4eca4e93003a396ce4"; }
{ locale = "ar"; arch = "linux-x86_64"; sha256 = "0681fca92f04ae1c4b3a306756f050f128b0534ee93ca6bc7fa0b5d5272a3bf3"; }
{ locale = "ast"; arch = "linux-i686"; sha256 = "f16600e6cfa49a99c6a827231e1411fefb6a0c83f9cfc44e862b3a97f7c778fc"; }
{ locale = "ast"; arch = "linux-x86_64"; sha256 = "9c37be63be7dc3f338af3326d5917592096b94df2423d1dc81daea4e31cd8658"; }
{ locale = "be"; arch = "linux-i686"; sha256 = "1779ec20a630b02543f51eb735f33e1b920061e328a8c0966209096f47051a18"; }
{ locale = "be"; arch = "linux-x86_64"; sha256 = "826d926a96ec9e8d5b46ed4649ac67ebe1a67db1eb746ee5e37b1fdf0f09ddb0"; }
{ locale = "bg"; arch = "linux-i686"; sha256 = "aa6d3070ffebb5fe9f9205cab6c6bb3b57033e5d6acbafc45ca3fc89fa35f849"; }
{ locale = "bg"; arch = "linux-x86_64"; sha256 = "e21460bf056e8b1fe683a11b688307580a13b51db03ffb235dc32c6e50ce8ac7"; }
{ locale = "bn-BD"; arch = "linux-i686"; sha256 = "77d6dd2686b8bd5962c70a8ea09c10cbc0f60a0c7effdf00ac346bca9b6af313"; }
{ locale = "bn-BD"; arch = "linux-x86_64"; sha256 = "a417f6bcd228afa2be0c71206af9f06841a8dc29950a8975e6455af215911e1f"; }
{ locale = "br"; arch = "linux-i686"; sha256 = "920c81326f5f33e1e1a3a4229d0544360aa9f7bbe5eb32db3ea30dc34764e515"; }
{ locale = "br"; arch = "linux-x86_64"; sha256 = "be967c23e45a06532dd8a2611a31bc842ff79c6da6b63444bd9f6a3db7f834a2"; }
{ locale = "ca"; arch = "linux-i686"; sha256 = "98d88b01ed35dbbaf5b06418a26018c86d6b07f9ce9fe999b007ce6844e3832c"; }
{ locale = "ca"; arch = "linux-x86_64"; sha256 = "616a724f6a0a1493c321a83c274895ba7234977f2d7ab264d44dda39d34dddaf"; }
{ locale = "cs"; arch = "linux-i686"; sha256 = "ebebf6d26d900103851e1f8ccc5cb26506902a996a5c92674f165c79ad090fde"; }
{ locale = "cs"; arch = "linux-x86_64"; sha256 = "43b1a4ad27868b968112c86893465d8c765d383a9653b64dc27609644b7c4bfc"; }
{ locale = "cy"; arch = "linux-i686"; sha256 = "52b7a40c87adac16d77e9a03827c0db49286f1576ead85c6a5bff3b8ab33d546"; }
{ locale = "cy"; arch = "linux-x86_64"; sha256 = "2c413971b22bafac67729e6f5967513f4dabbff441cad4aecaa3fa363aed807a"; }
{ locale = "da"; arch = "linux-i686"; sha256 = "aab8b9b66d9b80c94ff9b26102cec7cb9ff9c7dc859f4606bba8d48d47ebebf4"; }
{ locale = "da"; arch = "linux-x86_64"; sha256 = "24daf3a574619b2be424b4f5bbda732b500bd6ea5eff6e3b858dfe4bb0b2cfa1"; }
{ locale = "de"; arch = "linux-i686"; sha256 = "385860c48089394ba0bd939cc60506c62f9d4b54903ee3c0e04006e6af619408"; }
{ locale = "de"; arch = "linux-x86_64"; sha256 = "e0e61f60915f7562151e47e3458830aa1323519ce76cbd9638559ec177da1093"; }
{ locale = "dsb"; arch = "linux-i686"; sha256 = "e2a19f5fc03bb3ea1a97ed501540b42fea923033592b0790aa4bcd93ff619421"; }
{ locale = "dsb"; arch = "linux-x86_64"; sha256 = "95fa2341481aa869ef1d417c617ccbe54cc0f57ac0b4cb7266c6399887e1f04a"; }
{ locale = "el"; arch = "linux-i686"; sha256 = "3dc35863b9aea5cfdb28ecd71ad798eee711c859d27acb46fb2294861ba713d7"; }
{ locale = "el"; arch = "linux-x86_64"; sha256 = "546a4cf57c52ef054c2c58b9792b5b8ed0933368d8f4343f78604328c4117d42"; }
{ locale = "en-GB"; arch = "linux-i686"; sha256 = "74194c95fba578feec4ac92569be45a9b948a4ae403d62bce5e11f5047ebbf11"; }
{ locale = "en-GB"; arch = "linux-x86_64"; sha256 = "9da80fa8d1c96e08c2338c77c67548e4a16e151c8ebddfb28da779f1bfeabefe"; }
{ locale = "en-US"; arch = "linux-i686"; sha256 = "c4e1d0a902ab04db666ac90cf1003f8b48ed88e3291fbbf1d6b2606e805a45b0"; }
{ locale = "en-US"; arch = "linux-x86_64"; sha256 = "843ce88b796c4705c61ab5a68a215fc82c2ee32e655c2c4d0dd244e97ae0705d"; }
{ locale = "es-AR"; arch = "linux-i686"; sha256 = "4fe05cbcf9b1d5aee936c29f19675c1d9658630cfe0c68570244ac57a5e8612e"; }
{ locale = "es-AR"; arch = "linux-x86_64"; sha256 = "0c3b83406c1b38249e52e0c8f17389e9861cfd5578a15a66c9bad89784d21b31"; }
{ locale = "es-ES"; arch = "linux-i686"; sha256 = "937a41e69189e50ac893d06abcd5ab032281f0531a2cb5acbd60bfdd4fff6a75"; }
{ locale = "es-ES"; arch = "linux-x86_64"; sha256 = "3d58ed89c2dd316fdbcf218666ca837b5200dc35462a89f41e8a83c4eb7620fa"; }
{ locale = "et"; arch = "linux-i686"; sha256 = "46e211a049ca3e3e986db7620b087a4ec41b73b1f4051aece68881c73b342bf7"; }
{ locale = "et"; arch = "linux-x86_64"; sha256 = "69c968a92241703e4cc71e905b35a74e4326f6b8e32cad84dbeb3ea1b802c7a1"; }
{ locale = "eu"; arch = "linux-i686"; sha256 = "dc638be813979a640e12f1fc4bed727ce639bc8d50b1b1d084e8733a067155ef"; }
{ locale = "eu"; arch = "linux-x86_64"; sha256 = "26362027c5e5b3d69ebaecbed10c300d232dd3ccdbf96e113f720518584f5c03"; }
{ locale = "fi"; arch = "linux-i686"; sha256 = "947481357bacb8a91b0a49956007e8ffaf0575815d5dcff0750f4cb2890f9e22"; }
{ locale = "fi"; arch = "linux-x86_64"; sha256 = "35716446800a69a71aaf6f91e8bab850f8f681e6acaa6f36429f71a2bdd0e04a"; }
{ locale = "fr"; arch = "linux-i686"; sha256 = "27aeb7724e1d76d1d81bf583b94580d3745177b1983b63e4dd88ec6ae204ba13"; }
{ locale = "fr"; arch = "linux-x86_64"; sha256 = "482aba9f35f2026e4b9dfb009f45925f87a71a21c9338fd27a52ca1113d9759e"; }
{ locale = "fy-NL"; arch = "linux-i686"; sha256 = "7adb9045525b10914173092731ed3a4194e68b3b3661a83b008e8cb651518b0c"; }
{ locale = "fy-NL"; arch = "linux-x86_64"; sha256 = "4177e0f51a0877633cde98bc0d81a8f6391c6a87932546dfc094deea30ea5190"; }
{ locale = "ga-IE"; arch = "linux-i686"; sha256 = "c77fd8481fe999f3e0b63952137762947c58a397be82027755bbe2aa8bee9c8a"; }
{ locale = "ga-IE"; arch = "linux-x86_64"; sha256 = "39c2da28763cccabf86c6713bc62862edd37605c117d9c197cdeaabbb1cab31d"; }
{ locale = "gd"; arch = "linux-i686"; sha256 = "2be49f3b06a46ed89687de23459c42052b7a50814d32127121007c620fc56f8a"; }
{ locale = "gd"; arch = "linux-x86_64"; sha256 = "e0f9d78a12263fe8b8d40332bcc52a7c8db374c655564394e4ed850cf4567593"; }
{ locale = "gl"; arch = "linux-i686"; sha256 = "2f66892cf58b1aa63a748b9be966fbd07077a369a46ee4e4d241be37abfe083d"; }
{ locale = "gl"; arch = "linux-x86_64"; sha256 = "235b01ed0a702de629a61ee0a69ff4564fe479782d85c95a69fc121e5bf96df1"; }
{ locale = "he"; arch = "linux-i686"; sha256 = "5a3486d56950a6b14dcacf8cb40a55a7d2024c2838c52f77acc745fcbba6863e"; }
{ locale = "he"; arch = "linux-x86_64"; sha256 = "fae68a673712cb7929baf4e54358c851846901d519359ab53b270cfd215ecc5c"; }
{ locale = "hr"; arch = "linux-i686"; sha256 = "e2044cda9fd387af1368115a47e56c5a81d2f9fbf9135dc7b5441b88ac5bda1d"; }
{ locale = "hr"; arch = "linux-x86_64"; sha256 = "7205a8f3b20a5a1a7af08860a99d2be2d4ec78873f7e0cb579040285c3ef85f8"; }
{ locale = "hsb"; arch = "linux-i686"; sha256 = "a2357944e25f3d1434d33cade62d079b0dee878c8f6d1aa2d3cae94500dce14a"; }
{ locale = "hsb"; arch = "linux-x86_64"; sha256 = "3bb4658ecd2bce8d2204859cf95f8a85f90c6eb6f15e44ac50c1824aaa884da3"; }
{ locale = "hu"; arch = "linux-i686"; sha256 = "31da7a7cde19de47455b6cd855ed0e77efaa30e76989a26df71bce73134e384e"; }
{ locale = "hu"; arch = "linux-x86_64"; sha256 = "4703c48e899d36eb8d6aeb0f1d0101bf39f12c921716b7aaf041068b42046dfb"; }
{ locale = "hy-AM"; arch = "linux-i686"; sha256 = "bec4ef424007894fe85a06cf8af03da2bc48c7d68e6ecde3287a6863408e6392"; }
{ locale = "hy-AM"; arch = "linux-x86_64"; sha256 = "028bd4d92f502c4b4b0af52f5d992abfdf4d988974d8b991194284aa5ccb25b3"; }
{ locale = "id"; arch = "linux-i686"; sha256 = "5718068cd54ecb06e0ce7a4ddc87b923b76d7341a989a946717e2b34b1b49a0e"; }
{ locale = "id"; arch = "linux-x86_64"; sha256 = "112928c75789795e21050b8202d49b50fdb3b10f21c3d2c140e9cbd7ba96bafe"; }
{ locale = "is"; arch = "linux-i686"; sha256 = "4bd5abdb8fb9c389601b9e6c8fcd18e53e8c24097ee338199ee12b03f580faff"; }
{ locale = "is"; arch = "linux-x86_64"; sha256 = "e4ee538f072398ae16c70ebcd32e06129b2d94a88104710a2b165af1b1da8541"; }
{ locale = "it"; arch = "linux-i686"; sha256 = "2269ea4101db9f9bb961d79fa30ecece49178a747cb10fb5f90f09d14dcbacd6"; }
{ locale = "it"; arch = "linux-x86_64"; sha256 = "04cef93ee74ff13d6ddc9cfe60440d128bc8b432be62d988094d73461138cff1"; }
{ locale = "ja"; arch = "linux-i686"; sha256 = "762e6c0879c0983dc059f3b4550681d947b0ceb2dd82331a587463d881c7fb65"; }
{ locale = "ja"; arch = "linux-x86_64"; sha256 = "90748465b87b0bffcf70e7c6d83d2f6ce7873b751a5c1dc2d63d18cc60a8c25a"; }
{ locale = "ko"; arch = "linux-i686"; sha256 = "ce867efb9452465ae1f6ab0eebbe06721c3987614b42c901a12e43ce3e5a6ad5"; }
{ locale = "ko"; arch = "linux-x86_64"; sha256 = "9aab21893818eb86a7da148650873c4e6e1faa047d35e1ff6845001d4eabb2d4"; }
{ locale = "lt"; arch = "linux-i686"; sha256 = "3f8fec266c7e612183ea1d60e44f90c8f5c713b2af0038ca10fef9964662c0a9"; }
{ locale = "lt"; arch = "linux-x86_64"; sha256 = "f7efb6a495e57439c287ed8cdeacbdff6980ff89493497ab384a3c3c33fccaea"; }
{ locale = "nb-NO"; arch = "linux-i686"; sha256 = "02b0002e52a7e1c91a4f200ece1c9e1b133b7d50688e483c041cdf57ef7d8a06"; }
{ locale = "nb-NO"; arch = "linux-x86_64"; sha256 = "d4d6f125a9af64ad1967e414cb4f5d7a4cdc636c805f9790bf1c79573900aeef"; }
{ locale = "nl"; arch = "linux-i686"; sha256 = "16b9e1d15b64b7d44ba3f2e39aa5a772a6d26ec347170b86c6455f4591bae22b"; }
{ locale = "nl"; arch = "linux-x86_64"; sha256 = "0d8b130e681ca5a2ebd7b2f032b5779eb148540d7802097df8430f6cf095a5f8"; }
{ locale = "nn-NO"; arch = "linux-i686"; sha256 = "37d08bbf72c34ee677dd0fe39016f75a13e5e078ce23236b742a0de2131421dd"; }
{ locale = "nn-NO"; arch = "linux-x86_64"; sha256 = "c76e50a850ef98f07e030564fa8ec7411ca31aa128e8b6393227e40c91b47938"; }
{ locale = "pa-IN"; arch = "linux-i686"; sha256 = "3aef7a6aef6d05c17f757603c81f2f550c0681b3f3ae38abd02d8224c10754c0"; }
{ locale = "pa-IN"; arch = "linux-x86_64"; sha256 = "b5434c9a814f6ece725ef1bf7f47381fe7b56e2c1c05832a75e95152b8706725"; }
{ locale = "pl"; arch = "linux-i686"; sha256 = "215845fbfd3e76c73861b59324df380b794413b25efd1189975589bc843b9d28"; }
{ locale = "pl"; arch = "linux-x86_64"; sha256 = "0f07a3c7f6518dbe056814e0ab257036ffabd3770bebdf2ccd053eaee499654c"; }
{ locale = "pt-BR"; arch = "linux-i686"; sha256 = "28f668d318a441cd57c9e85dda1de98502a545933b7af2a3d2aef066952a3eb9"; }
{ locale = "pt-BR"; arch = "linux-x86_64"; sha256 = "eae9dee3c5677e40ec3ce0c6594937671ae07be49b8488abbe94d1ba52bd3f16"; }
{ locale = "pt-PT"; arch = "linux-i686"; sha256 = "36d9ae4720d5e673c02e2fe850f3e66786b853f1e5e81368e3e62715b612cc57"; }
{ locale = "pt-PT"; arch = "linux-x86_64"; sha256 = "bb5156054e96d515bac61cf942560d73166c27f052abf05344d81544b3d09938"; }
{ locale = "rm"; arch = "linux-i686"; sha256 = "79322d60677bfeb493f0ebc64d336201ff75f34af6131a8fda742518c45c7cc0"; }
{ locale = "rm"; arch = "linux-x86_64"; sha256 = "7544877e762913619dda73a3ebbc48d81aa2519a014284b79d7fdb65de678f20"; }
{ locale = "ro"; arch = "linux-i686"; sha256 = "d1ab21feb037542faf032668ba6875157775f5efa95b3c1a8a31cc0fc8ea0a40"; }
{ locale = "ro"; arch = "linux-x86_64"; sha256 = "8f2ef95bd7d82086dd8369e2ec144348d085527cab8e89b33d938c93103c4e15"; }
{ locale = "ru"; arch = "linux-i686"; sha256 = "99390a8350cdf26c69203670458fbc7b6700797a55fa37f498148dca0fbca7b7"; }
{ locale = "ru"; arch = "linux-x86_64"; sha256 = "6a52e3d8db23fd0c1e091f1b90dc80603cd8ce345d488228f3b595f1b707bb60"; }
{ locale = "si"; arch = "linux-i686"; sha256 = "15e8ca12df3192e174f2787aca1d4a5b992ca2f45525a5d2f06683b2e8864bd3"; }
{ locale = "si"; arch = "linux-x86_64"; sha256 = "6b7d66bbe8cb6ed0c4a1f44a3885d5c7e4a5db79a1db98530a099e6bb7a417bc"; }
{ locale = "sk"; arch = "linux-i686"; sha256 = "4ce5be3d7455c72ec7c6ecb56824220ab74712b1c4ee27212010cb8e12959edb"; }
{ locale = "sk"; arch = "linux-x86_64"; sha256 = "1a3911a18156a2dce9417c84bff20b7f41b8e5f5e2a578ffe33b26db0b4bcb30"; }
{ locale = "sl"; arch = "linux-i686"; sha256 = "a43200e303054b34c4e4e7c81f561a8c1d33c122af61e23b89b3a8cb8c0d26d5"; }
{ locale = "sl"; arch = "linux-x86_64"; sha256 = "f7e456499b7acf5e8eae4d04abcf43210f00bab8b4b7f42e047f2ee13473f3f6"; }
{ locale = "sq"; arch = "linux-i686"; sha256 = "9a444b55077da2817c72538c72f53e6ff945e4f88ba6c222e2676de21bae2435"; }
{ locale = "sq"; arch = "linux-x86_64"; sha256 = "96eb242e79a7155fe85dcd7eb1b1606f9d84c72aebffed2244cb149d7d77740f"; }
{ locale = "sr"; arch = "linux-i686"; sha256 = "79c98c7d34b327b596f0a3e417508d5bbe77fd61b761995635559cc5f88d85e7"; }
{ locale = "sr"; arch = "linux-x86_64"; sha256 = "0041421d294f06d993dd4184b66f6fa6c58244b231a64da1b20dd76b5becb4b4"; }
{ locale = "sv-SE"; arch = "linux-i686"; sha256 = "a17ab2cc74b4c9367c21a176eb1cd83fce74bea24996b4987644659f9ef0bc68"; }
{ locale = "sv-SE"; arch = "linux-x86_64"; sha256 = "0fd181a6d7425db8f0077175b8905f3a646af081a9db1a2b635f8c95c99e01b2"; }
{ locale = "ta-LK"; arch = "linux-i686"; sha256 = "34eca4b0d4d808b280045381def6976106e3e78c43d901bc512b9aea83537876"; }
{ locale = "ta-LK"; arch = "linux-x86_64"; sha256 = "4633828b594d330c252b5e4931e85f98797ec2aa17400e546dea7a4099bfe543"; }
{ locale = "tr"; arch = "linux-i686"; sha256 = "b8584087e44d967ec5badeee5d9ac86653709f858e65b4356e0fa8d3ea5e3369"; }
{ locale = "tr"; arch = "linux-x86_64"; sha256 = "dda18542ba3f27cf0b2a1499121c43dc5c085ada40cd825dad119135a1fd4385"; }
{ locale = "uk"; arch = "linux-i686"; sha256 = "5cb1e2fdbf857f93851ee1b1aa3ad00c538def17641f14742b446414706f74c1"; }
{ locale = "uk"; arch = "linux-x86_64"; sha256 = "84dc247e8a46f0ff1b5bd7f25956e0988edab18e72649b7d4c264b6160a47de2"; }
{ locale = "vi"; arch = "linux-i686"; sha256 = "a38fde2cbdb45552950db906b19eed3135e930da8242791811683bb2fb850fb4"; }
{ locale = "vi"; arch = "linux-x86_64"; sha256 = "5eff491a6d6ec1b54788beb300f61fbd98be72037a769054967af7a062afec61"; }
{ locale = "zh-CN"; arch = "linux-i686"; sha256 = "c4644e65f6d1a1cb710806026814c416268453b571531e87d71800deb3625128"; }
{ locale = "zh-CN"; arch = "linux-x86_64"; sha256 = "dd8d802b34d76ccdeb569b86aec75f27d29c23b6c74ce6d5bfb0a5239ee581af"; }
{ locale = "zh-TW"; arch = "linux-i686"; sha256 = "1a9e7322512caa10247f58674fbbf55d5a624ef36a9d570d8ebdb6e1c5c6889a"; }
{ locale = "zh-TW"; arch = "linux-x86_64"; sha256 = "a84310a24bfe845e9c3992fe5441e9cbc049054fdc53f659dbea997ae17e937f"; }
];
}

8
pkgs/applications/networking/sniffers/ettercap/default.nix
View File

@ -1,5 +1,5 @@
{ stdenv, fetchFromGitHub, cmake, libpcap, libnet, zlib, curl, pcre,
openssl, ncurses, glib, gtk, atk, pango, flex, bison }:
openssl, ncurses, glib, gtk2, atk, pango, flex, bison }:
stdenv.mkDerivation rec {
name = "ettercap-${version}";
@ -14,7 +14,7 @@ stdenv.mkDerivation rec {
buildInputs = [
cmake libpcap libnet zlib curl pcre openssl ncurses
glib gtk atk pango flex bison
glib gtk2 atk pango flex bison
];
preConfigure = ''
@ -23,8 +23,8 @@ stdenv.mkDerivation rec {
'';
cmakeFlags = [
"-DGTK2_GLIBCONFIG_INCLUDE_DIR=${glib}/lib/glib-2.0/include"
"-DGTK2_GDKCONFIG_INCLUDE_DIR=${gtk}/lib/gtk-2.0/include"
"-DGTK2_GLIBCONFIG_INCLUDE_DIR=${glib.out}/lib/glib-2.0/include"
"-DGTK2_GDKCONFIG_INCLUDE_DIR=${gtk2.out}/lib/gtk-2.0/include"
];
meta = with stdenv.lib; {

2
pkgs/applications/networking/spideroak/default.nix
View File

@ -16,7 +16,7 @@ let
else if stdenv.system == "i686-linux" then "8c23271291f40aa144bbf38ceb3cc2a05bed00759c87a65bd798cf8bb289d07a"
else throw "Spideroak client for: ${stdenv.system} not supported!";
ldpath = stdenv.lib.makeSearchPath "lib" [
ldpath = stdenv.lib.makeLibraryPath [
glib fontconfig libXext libX11 freetype libXrender
];

2
pkgs/applications/science/electronics/fritzing/default.nix
View File

@ -17,9 +17,11 @@ stdenv.mkDerivation rec {
buildInputs = [ qtbase qtsvg boost ];
configurePhase = ''
runHook preConfigure
cd fritzing-${version}.source
echo $PATH
qmake PREFIX=$out phoenix.pro
runHook postConfigure
'';
meta = {

4
pkgs/applications/science/machine-learning/torch/torch-distro.nix
View File

@ -73,8 +73,8 @@ let
for p in $out/bin/*; do
wrapProgram $p \
--suffix LD_LIBRARY_PATH ';' "${lib.makeSearchPath "lib" runtimeDeps_}" \
--suffix PATH ';' "${lib.makeSearchPath "bin" runtimeDeps_}" \
--suffix LD_LIBRARY_PATH ';' "${lib.makeLibraryPath runtimeDeps_}" \
--suffix PATH ';' "${lib.makeBinPath runtimeDeps_}" \
--suffix LUA_PATH ';' "\"$LUA_PATH\"" \
--suffix LUA_PATH ';' "\"$out/share/lua/${lua.luaversion}/?.lua;$out/share/lua/${lua.luaversion}/?/init.lua\"" \
--suffix LUA_CPATH ';' "\"$LUA_CPATH\"" \

2
pkgs/applications/science/math/mathematica/9.nix
View File

@ -63,7 +63,7 @@ stdenv.mkDerivation rec {
ldpath = stdenv.lib.makeLibraryPath buildInputs
+ stdenv.lib.optionalString (stdenv.system == "x86_64-linux")
(":" + stdenv.lib.makeSearchPath "lib64" buildInputs);
(":" + stdenv.lib.makeSearchPathOutputs "lib64" ["lib"] buildInputs);
phases = "unpackPhase installPhase fixupPhase";

2
pkgs/applications/science/math/mathematica/default.nix
View File

@ -73,7 +73,7 @@ stdenv.mkDerivation rec {
ldpath = stdenv.lib.makeLibraryPath buildInputs
+ stdenv.lib.optionalString (stdenv.system == "x86_64-linux")
(":" + stdenv.lib.makeSearchPath "lib64" buildInputs);
(":" + stdenv.lib.makeSearchPathOutputs "lib64" ["lib"] buildInputs);
phases = "unpackPhase installPhase fixupPhase";

2
pkgs/applications/science/math/maxima/default.nix
View File

@ -5,7 +5,7 @@ let
version = "5.36.1";
searchPath =
stdenv.lib.makeSearchPath "bin"
stdenv.lib.makeBinPath
(stdenv.lib.filter (x: x != null) [ sbcl rlwrap tk gnuplot ]);
in
stdenv.mkDerivation {

14
pkgs/applications/science/robotics/qgroundcontrol/default.nix
View File

@ -28,19 +28,11 @@ stdenv.mkDerivation rec {
patches = [ ./0001-fix-gcc-cmath-namespace-issues.patch ];
preConfigure = ''
git submodule init
git submodule update
'';
configurePhase = ''
runHook preConfigure
mkdir build
pushd build
qmake ../qgroundcontrol.pro
popd
(cd build && qmake ../qgroundcontrol.pro)
runHook postConfigure
'';
preBuild = "pushd build/";

2
pkgs/applications/version-management/cvs-fast-export/default.nix
View File

@ -39,7 +39,7 @@ mkDerivation rec {
postInstall =
let
binpath = makeSearchPath "bin" [ out rcs cvs git coreutils rsync ];
binpath = makeBinPath [ out rcs cvs git coreutils rsync ];
in ''
for prog in cvs-fast-export cvsconvert cvssync; do
wrapProgram $out/bin/$prog \

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

@ -15,7 +15,7 @@ stdenv.mkDerivation rec {
python ./setup.py install --prefix=$out
for i in bzr svn git; do
wrapProgram $out/bin/cvs2$i \
--prefix PATH : "${lib.makeSearchPath "bin" [ cvs ]}" \
--prefix PATH : "${lib.makeBinPath [ cvs ]}" \
--set PYTHONPATH "$(toPythonPath $out):$PYTHONPATH"
done
'';

4
pkgs/applications/version-management/reposurgeon/default.nix
View File

@ -46,12 +46,12 @@ mkDerivation rec {
postInstall =
let
binpath = makeSearchPath "bin" (
binpath = makeBinPath (
filter (x: x != null)
[ out git bazaar cvs darcs fossil mercurial
monotone rcs src subversion cvs_fast_export ]
);
pythonpath = makeSearchPath (python27.sitePackages) (
pythonpath = makeSearchPathOutputs python27.sitePackages ["lib"] (
filter (x: x != null)
[ python27Packages.readline or null python27Packages.hglib or null ]
);

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

@ -24,7 +24,7 @@ stdenv.mkDerivation rec {
pkg_path = "$out/${name}";
bin_path = "$out/bin";
install_freedesktop_items = ./install_freedesktop_items.sh;
runtime_paths = lib.makeSearchPath "bin" [
runtime_paths = lib.makeBinPath [
jre
#git mercurial subversion # the paths are requested in configuration
which

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

@ -1,7 +1,7 @@
{ stdenv, lib, fetchurl, makeWrapper
, pkgconfig, cmake, gnumake, yasm, pythonFull
, boost, avahi, libdvdcss, lame, autoreconfHook
, gettext, pcre, yajl, fribidi, which
, gettext, pcre-cpp, yajl, fribidi, which
, openssl, gperf, tinyxml2, taglib, libssh, swig, jre
, libX11, xproto, inputproto, libxml2
, libXt, libXmu, libXext, xextproto
@ -56,7 +56,7 @@ in stdenv.mkDerivation rec {
makeWrapper libxml2 gnutls
pkgconfig cmake gnumake yasm pythonFull
boost libmicrohttpd autoreconfHook
gettext pcre yajl fribidi libva
gettext pcre-cpp yajl fribidi libva
openssl gperf tinyxml2 taglib libssh swig jre
libX11 xproto inputproto which
libXt libXmu libXext xextproto

6
pkgs/applications/video/shotcut/default.nix
View File

@ -11,7 +11,11 @@ stdenv.mkDerivation rec {
buildInputs = [ SDL frei0r gettext makeWrapper mlt pkgconfig qtbase ];
configurePhase = "qmake PREFIX=$out";
configurePhase = ''
runHook preConfigure
qmake PREFIX=$out
runHook postConfigure
'';
postInstall = ''
mkdir -p $out/share/shotcut

3
pkgs/applications/virtualization/virtualbox/default.nix
View File

@ -195,6 +195,9 @@ in stdenv.mkDerivation {
passthru = { inherit version; /* for guest additions */ };
# Workaround for https://github.com/NixOS/patchelf/issues/93 (can be removed once this issue is addressed)
dontPatchELF = true;
meta = {
description = "PC emulator";
homepage = http://www.virtualbox.org/;

11
pkgs/applications/window-managers/bspwm/default.nix
View File

@ -1,12 +1,13 @@
{ stdenv, fetchurl, libxcb, libXinerama, sxhkd, xcbutil, xcbutilkeysyms, xcbutilwm }:
stdenv.mkDerivation rec {
name = "bspwm-0.9";
name = "bspwm-${version}";
version = "0.9.1";
src = fetchurl {
url = "https://github.com/baskerville/bspwm/archive/0.9.tar.gz";
sha256 = "1efb2db7b8a251bcc006d66a050cf66e9d311761c94890bebf91a32905042fde";
url = "https://github.com/baskerville/bspwm/archive/${version}.tar.gz";
sha256 = "11dvfcvr8bc116yb3pvl0k1h2gfm9rv652jbxd1c5pmc0yimifq2";
};
buildInputs = [ libxcb libXinerama xcbutil xcbutilkeysyms xcbutilwm ];
@ -14,7 +15,7 @@ stdenv.mkDerivation rec {
buildPhase = ''
make PREFIX=$out
'';
installPhase = ''
make PREFIX=$out install
'';

4
pkgs/applications/window-managers/sxhkd/default.nix
View File

@ -2,11 +2,11 @@
stdenv.mkDerivation rec {
name = "sxhkd-${version}";
version = "0.5.5";
version = "0.5.6";
src = fetchurl {
url = "https://github.com/baskerville/sxhkd/archive/${version}.tar.gz";
sha256 = "04s3y2bq9502gw72jj3y2zsh96yj3qg2av3zsa8ahd2farvrysg6";
sha256 = "15grmzpxz5fqlbfg2slj7gb7r6nzkvjmflmbkqx7mlby9pm6wdkj";
};
buildInputs = [ asciidoc libxcb xcbutil xcbutilkeysyms xcbutilwm ];

15
pkgs/build-support/docker/default.nix
View File

@ -151,7 +151,7 @@ EOF
postMount = ''
echo Packing raw image
tar -C mnt -cf $out .
tar -C mnt --mtime=0 -cf $out .
'';
};
@ -176,7 +176,7 @@ EOF
echo Packing layer
mkdir $out
tar -C layer -cf $out/layer.tar .
tar -C layer --mtime=0 -cf $out/layer.tar .
ts=$(${tarsum} < $out/layer.tar)
cat ${baseJson} | jshon -s "$ts" -i checksum > $out/json
echo -n "1.0" > $out/VERSION
@ -216,7 +216,7 @@ EOF
echo Packing layer
mkdir $out
tar -C layer -cf $out/layer.tar .
tar -C layer --mtime=0 -cf $out/layer.tar .
ts=$(${tarsum} < $out/layer.tar)
cat ${baseJson} | jshon -s "$ts" -i checksum > $out/json
echo -n "1.0" > $out/VERSION
@ -286,15 +286,18 @@ EOF
cp ${layer}/* temp/
chmod ug+w temp/*
touch layerFiles
# FIXME: might not be /nix/store
echo '/nix' >> layerFiles
echo '/nix/store' >> layerFiles
for dep in $(cat $layerClosure); do
find $dep >> layerFiles
done
echo Adding layer
tar -tf temp/layer.tar >> baseFiles
sed 's/^\.//' -i baseFiles
comm <(sort -n baseFiles|uniq) <(sort -n layerFiles|uniq|grep -v ${layer}) -1 -3 > newFiles
tar -rpf temp/layer.tar --no-recursion --files-from newFiles 2>/dev/null || true
tar -rpf temp/layer.tar --mtime=0 --no-recursion --files-from newFiles 2>/dev/null || true
echo Adding meta
@ -317,7 +320,7 @@ EOF
chmod -R a-w image
echo Cooking the image
tar -C image -c . | pigz > $out
tar -C image --mtime=0 -c . | pigz -nT > $out
'';
in

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

@ -87,6 +87,7 @@ in
assert builtins.isList urls;
assert (urls == []) != (url == "");
assert sha512 != "" -> builtins.compareVersions "1.11" builtins.nixVersion <= 0;
let

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

@ -17,7 +17,9 @@ stdenv.mkDerivation rec {
];
configurePhase = ''
runHook preConfigure
qmake PREFIX=/
runHook postConfigure
'';
installPhase = ''

32
pkgs/data/fonts/profont/default.nix Normal file
View File

@ -0,0 +1,32 @@
{ stdenv, fetchurl, unzip }:
stdenv.mkDerivation rec {
name = "profont";
src = fetchurl {
url = "http://tobiasjung.name/downloadfile.php?file=profont-x11.zip";
sha256 = "19ww5iayxzxxgixa9hgb842xd970mwghxfz2vsicp8wfwjh6pawr";
};
buildInputs = [ unzip ];
phases = [ "unpackPhase" "installPhase" ];
installPhase =
''
mkdir -p $out/share/doc/$name $out/share/fonts/misc
cp LICENSE $out/share/doc/$name/LICENSE
for f in *.pcf; do
gzip -c "$f" > $out/share/fonts/misc/"$f".gz
done
'';
meta = with stdenv.lib; {
homepage = http://tobiasjung.name;
description = "A monospaced font created to be a most readable font for programming";
maintainers = with stdenv.lib.maintainers; [ myrl ];
license = licenses.mit;
platforms = platforms.all;
};
}

1
pkgs/data/fonts/proggyfonts/default.nix
View File

@ -36,5 +36,6 @@ stdenv.mkDerivation rec {
description = "A set of fixed-width screen fonts that are designed for code listings";
license = licenses.mit;
platforms = platforms.all;
maintainers = [ maintainers.myrl ];
};
}

1
pkgs/desktops/gnome-3/3.18/apps/gnome-maps/default.nix
View File

@ -11,6 +11,7 @@ stdenv.mkDerivation rec {
gtk3 geoclue2 gnome3.gjs gnome3.libgee folks gfbgraph
gnome3.geocode_glib libchamplain file libsoup
gdk_pixbuf librsvg autoreconfHook
gnome3.gsettings_desktop_schemas gnome3.evolution_data_server
gnome3.gnome_online_accounts gnome3.defaultIconTheme ];
patches = [ ./soup.patch ];

17
pkgs/desktops/gnome-3/3.18/core/gnome-shell/default.nix
View File

@ -1,9 +1,10 @@
{ fetchurl, stdenv, pkgconfig, gnome3, json_glib, libcroco, intltool, libsecret
, python3, libsoup, polkit, clutter, networkmanager, docbook_xsl, docbook_xsl_ns, at_spi2_core
, libstartup_notification, telepathy_glib, telepathy_logger, libXtst, p11_kit, unzip
, sqlite, libgweather, libcanberra_gtk3
, libpulseaudio, libical, libtool, nss, gobjectIntrospection, gstreamer, makeWrapper
, accountsservice, gdk_pixbuf, gdm, upower, ibus, networkmanagerapplet, librsvg }:
, python3, python3Packages, libsoup, polkit, clutter, networkmanager
, docbook_xsl , docbook_xsl_ns, at_spi2_core, libstartup_notification
, telepathy_glib, telepathy_logger, libXtst, p11_kit, unzip, sqlite, libgweather
, libcanberra_gtk3 , libpulseaudio, libical, libtool, nss, gobjectIntrospection
, gstreamer, makeWrapper , accountsservice, gdk_pixbuf, gdm, upower, ibus
, networkmanagerapplet, librsvg }:
# http://sources.gentoo.org/cgi-bin/viewvc.cgi/gentoo-x86/gnome-base/gnome-shell/gnome-shell-3.10.2.1.ebuild?revision=1.3&view=markup
@ -15,7 +16,8 @@ stdenv.mkDerivation rec {
buildInputs = with gnome3;
[ gsettings_desktop_schemas gnome_keyring gnome-menus glib gcr json_glib accountsservice
libcroco intltool libsecret pkgconfig python3 libsoup polkit libcanberra gdk_pixbuf librsvg
libcroco intltool libsecret pkgconfig python3 python3Packages.pygobject3
libsoup polkit libcanberra gdk_pixbuf librsvg
clutter networkmanager libstartup_notification telepathy_glib docbook_xsl docbook_xsl_ns
libXtst p11_kit networkmanagerapplet gjs mutter libpulseaudio caribou evolution_data_server
libical libtool nss gobjectIntrospection gtk gstreamer makeWrapper gdm
@ -40,6 +42,9 @@ stdenv.mkDerivation rec {
--prefix XDG_DATA_DIRS : "${gnome_themes_standard}/share:$out/share:$XDG_ICON_DIRS" \
--suffix XDG_DATA_DIRS : "$GSETTINGS_SCHEMAS_PATH"
wrapProgram "$out/bin/gnome-shell-extension-tool" \
--prefix PYTHONPATH : "${python3Packages.pygobject3}/lib/python3.4/site-packages:$PYTHONPATH"
wrapProgram "$out/libexec/gnome-shell-calendar-server" \
--prefix XDG_DATA_DIRS : "${evolution_data_server}/share:$out/share:$XDG_ICON_DIRS:$GSETTINGS_SCHEMAS_PATH"

4
pkgs/desktops/gnome-3/3.18/core/grilo-plugins/default.nix
View File

@ -3,11 +3,11 @@
, gmime, json_glib, avahi, tracker, itstool }:
stdenv.mkDerivation rec {
name = "grilo-plugins-0.2.13";
name = "grilo-plugins-0.2.16";
src = fetchurl {
url = "mirror://gnome/sources/grilo-plugins/0.2/${name}.tar.xz";
sha256 = "008jwm5ydl0k25p3d2fkcail40fj9y3qknihxb5fg941p8qlhm55";
sha256 = "00sjmkzxc8w4qn4lp5yj65c4y83mwhp0zlvk11ghvpxnklgmgd40";
};
installFlags = [ "GRL_PLUGINS_DIR=$(out)/lib/grilo-0.2" ];

4
pkgs/desktops/gnome-3/3.18/core/grilo/default.nix
View File

@ -2,11 +2,11 @@
, libxml2, gnome3, gobjectIntrospection, libsoup }:
stdenv.mkDerivation rec {
name = "grilo-0.2.12";
name = "grilo-0.2.14";
src = fetchurl {
url = "mirror://gnome/sources/grilo/0.2/${name}.tar.xz";
sha256 = "11bvc7rsrjjwz8hp67p3fn8zmywrpawrcbi3vgw8b0dwa0sndd2m";
sha256 = "1k8wj8f7xfaw5hxypnmwd34li3fq8h76dacach547rvsfjhjxj3r";
};
setupHook = ./setup-hook.sh;

8
pkgs/desktops/gnome-3/3.18/core/libpeas/default.nix
View File

@ -1,13 +1,15 @@
{ stdenv, fetchurl, pkgconfig, intltool, gnome3
, glib, gtk3, gobjectIntrospection, python, pygobject3
, glib, gtk3, gobjectIntrospection, python3, python3Packages, ncurses
}:
stdenv.mkDerivation rec {
inherit (import ./src.nix fetchurl) name src;
configureFlags = [ "--enable-python3" ];
buildInputs = [
intltool pkgconfig glib gtk3 gobjectIntrospection python pygobject3
gnome3.defaultIconTheme
intltool pkgconfig glib gtk3 gobjectIntrospection python3 python3Packages.pygobject3
gnome3.defaultIconTheme ncurses
];
meta = with stdenv.lib; {

8
pkgs/desktops/gnome-3/3.18/core/totem/default.nix
View File

@ -1,6 +1,6 @@
{ stdenv, intltool, fetchurl, gst_all_1
, clutter_gtk, clutter-gst, pygobject3, shared_mime_info
, pkgconfig, gtk3, glib
, clutter_gtk, clutter-gst, python3, python3Packages, shared_mime_info
, pkgconfig, gtk3, glib, gobjectIntrospection
, bash, makeWrapper, itstool, libxml2, dbus_glib
, gnome3, librsvg, gdk_pixbuf, file }:
@ -19,13 +19,15 @@ stdenv.mkDerivation rec {
clutter_gtk clutter-gst gnome3.totem-pl-parser gnome3.grilo-plugins
gst_all_1.gstreamer gst_all_1.gst-plugins-base gst_all_1.gst-plugins-good
gst_all_1.gst-plugins-bad gst_all_1.gst-plugins-ugly gst_all_1.gst-libav
gnome3.libpeas pygobject3 shared_mime_info dbus_glib
gnome3.libpeas python3Packages.pygobject3 gobjectIntrospection shared_mime_info dbus_glib
gdk_pixbuf gnome3.defaultIconTheme librsvg gnome3.gnome_desktop
gnome3.gsettings_desktop_schemas makeWrapper file ];
preFixup = ''
wrapProgram "$out/bin/totem" \
--set GDK_PIXBUF_MODULE_FILE "$GDK_PIXBUF_MODULE_FILE" \
--prefix PYTHONPATH : "${python3Packages.pygobject3}/lib/python3.4/site-packages:$PYTHONPATH" \
--prefix GI_TYPELIB_PATH : "$out/lib/girepository-1.0:$GI_TYPELIB_PATH" \
--prefix GST_PLUGIN_SYSTEM_PATH_1_0 : "$GST_PLUGIN_SYSTEM_PATH_1_0" \
--prefix GRL_PLUGIN_PATH : "${gnome3.grilo-plugins}/lib/grilo-0.2" \
--prefix XDG_DATA_DIRS : "${gnome3.gnome_themes_standard}/share:$XDG_ICON_DIRS:$GSETTINGS_SCHEMAS_PATH"

2
pkgs/desktops/gnome-3/3.18/default.nix
View File

@ -382,6 +382,8 @@ let
gpaste = callPackage ./misc/gpaste { };
pidgin-im-gnome-shell-extension = callPackage ./misc/pidgin { };
gtkhtml = callPackage ./misc/gtkhtml { };
pomodoro = callPackage ./misc/pomodoro { };

42
pkgs/desktops/gnome-3/3.18/misc/pidgin/default.nix Normal file
View File

@ -0,0 +1,42 @@
{ stdenv, fetchFromGitHub, glib }:
stdenv.mkDerivation rec {
version = "1.0";
basename = "pidgin-im-gnome-shell-extension";
name = "${basename}-${version}";
src = fetchFromGitHub {
owner = "muffinmad";
repo = "${basename}";
rev = "v${version}";
sha256 = "0vj4w9qqx9gads24w3f6v6mfh5va28bp8rc4w7lz0vhp7njmy1yy";
};
buildInputs = [ glib ];
configurePhase = "";
buildPhase = "";
installPhase = ''
share_dir="$prefix/share"
extensions_dir="$share_dir/gnome-shell/extensions/pidgin@muffinmad"
mkdir -p "$extensions_dir"
mv *.js metadata.json dbus.xml gnome-shell-extension-pidgin.pot "$extensions_dir"
schemas_dir="$share_dir/gsettings-schemas/${name}/glib-2.0/schemas"
mkdir -p "$schemas_dir"
mv schemas/* "$schemas_dir" # fix Emacs syntax highlighting: */
${glib}/bin/glib-compile-schemas "$schemas_dir"
locale_dir="$share_dir/locale"
mkdir -p "$locale_dir"
mv locale/* $locale_dir # fix Emacs syntax highlighting: */
'';
meta = with stdenv.lib; {
homepage = https://github.com/muffinmad/pidgin-im-gnome-shell-extension;
description = "Make Pidgin IM conversations appear in the Gnome Shell message tray";
license = licenses.gpl2;
platforms = platforms.linux;
maintainers = with maintainers; [ DamienCassou ];
};
}

2
pkgs/desktops/kde-5/applications-15.12/ark.nix
View File

@ -20,7 +20,7 @@
, zip
}:
let PATH = lib.makeSearchPath "bin" [
let PATH = lib.makeBinPath [
p7zip unrar unzipNLS zip
];
in

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