alioth/nixpkgs
3
0
Fork 0
forked from mirrors/nixpkgs
Code Releases Activity

Merge master into haskell-updates

Browse source
This commit is contained in:
github-actions[bot] 2022-03-22 00:12:28 +00:00 committed by GitHub
parent d7b31a50c1 3d9818b9c7
commit cf3e30f70f
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
139 changed files with 11752 additions and 17619 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
.github/workflows/backport.yml vendored
View file

@ -2,6 +2,12 @@ name: Backport
on:
pull_request_target:
types: [closed, labeled]
# WARNING:
# When extending this action, be aware that $GITHUB_TOKEN allows write access to
# the GitHub repository. This means that it should not evaluate user input in a
# way that allows code injection.
jobs:
backport:
name: Backport Pull Request

5
.github/workflows/labels.yml vendored
View file

@ -4,6 +4,11 @@ on:
pull_request_target:
types: [edited, opened, synchronize, reopened]
# WARNING:
# When extending this action, be aware that $GITHUB_TOKEN allows some write
# access to the GitHub API. This means that it should not evaluate user input in
# a way that allows code injection.
permissions:
contents: read
pull-requests: write

5
.github/workflows/pending-set.yml vendored
View file

@ -3,6 +3,11 @@ name: "set pending status"
on:
pull_request_target:
# WARNING:
# When extending this action, be aware that $GITHUB_TOKEN allows write access to
# the GitHub repository. This means that it should not evaluate user input in a
# way that allows code injection.
jobs:
action:
runs-on: ubuntu-latest

2
doc/contributing/reviewing-contributions.chapter.md
View file

@ -125,7 +125,7 @@ Reviewing process:
- Type should be appropriate (string related types differs in their merging capabilities, `optionSet` and `string` types are deprecated).
- Description, default and example should be provided.
- Ensure that option changes are backward compatible.
- `mkRenamedOptionModule` and `mkAliasOptionModule` functions provide way to make option changes backward compatible.
- `mkRenamedOptionModuleWith` provides a way to make option changes backward compatible.
- Ensure that removed options are declared with `mkRemovedOptionModule`
- Ensure that changes that are not backward compatible are mentioned in release notes.
- Ensure that documentations affected by the change is updated.

26
doc/languages-frameworks/javascript.section.md
View file

@ -85,7 +85,7 @@ you will still need to commit the modified version of the lock files, but at lea
each tool has an abstraction to just build the node_modules (dependencies) directory. you can always use the stdenv.mkDerivation with the node_modules to build the package (symlink the node_modules directory and then use the package build command). the node_modules abstraction can be also used to build some web framework frontends. For an example of this see how [plausible](https://github.com/NixOS/nixpkgs/blob/master/pkgs/servers/web-apps/plausible/default.nix) is built. mkYarnModules to make the derivation containing node_modules. Then when building the frontend you can just symlink the node_modules directory
## javascript packages inside nixpkgs {#javascript-packages-nixpkgs}
## Javascript packages inside nixpkgs {#javascript-packages-nixpkgs}
The `pkgs/development/node-packages` folder contains a generated collection of
[NPM packages](https://npmjs.com/) that can be installed with the Nix package
@ -121,12 +121,14 @@ requires `node-gyp-build`, so [we override](https://github.com/NixOS/nixpkgs/blo
};
```
### Adding and Updating Javascript packages in nixpkgs
To add a package from NPM to nixpkgs:
1. Modify `pkgs/development/node-packages/node-packages.json` to add, update
or remove package entries to have it included in `nodePackages` and
`nodePackages_latest`.
2. Run the script: `cd pkgs/development/node-packages && ./generate.sh`.
2. Run the script: `./pkgs/development/node-packages/generate.sh`.
3. Build your new package to test your changes:
`cd /path/to/nixpkgs && nix-build -A nodePackages.<new-or-updated-package>`.
To build against the latest stable Current Node.js version (e.g. 14.x):
@ -137,6 +139,26 @@ For more information about the generation process, consult the
[README.md](https://github.com/svanderburg/node2nix) file of the `node2nix`
tool.
To update NPM packages in nixpkgs, run the same `generate.sh` script:
```sh
./pkgs/development/node-packages/generate.sh
```
#### Git protocol error
Some packages may have Git dependencies from GitHub specified with `git://`.
GitHub has
[disabled unecrypted Git connections](https://github.blog/2021-09-01-improving-git-protocol-security-github/#no-more-unauthenticated-git),
so you may see the following error when running the generate script:
`The unauthenticated git protocol on port 9418 is no longer supported`.
Use the following Git configuration to resolve the issue:
```sh
git config --global url."https://github.com/".insteadOf git://github.com/
```
## Tool specific instructions {#javascript-tool-specific}
### node2nix {#javascript-node2nix}

5
lib/default.nix
View file

@ -67,7 +67,7 @@ let
inherit (self.trivial) id const pipe concat or and bitAnd bitOr bitXor
bitNot boolToString mergeAttrs flip mapNullable inNixShell isFloat min max
importJSON importTOML warn warnIf throwIfNot checkListOfEnum
info showWarnings nixpkgsVersion version
info showWarnings nixpkgsVersion version isInOldestRelease
mod compare splitByAndCompare functionArgs setFunctionArgs isFunction
toHexString toBaseDigits;
inherit (self.fixedPoints) fix fix' converge extends composeExtensions
@ -120,7 +120,8 @@ let
mkOptionDefault mkDefault mkImageMediaOverride mkForce mkVMOverride
mkFixStrictness mkOrder mkBefore mkAfter mkAliasDefinitions
mkAliasAndWrapDefinitions fixMergeModules mkRemovedOptionModule
mkRenamedOptionModule mkMergedOptionModule mkChangedOptionModule
mkRenamedOptionModule mkRenamedOptionModuleWith
mkMergedOptionModule mkChangedOptionModule
mkAliasOptionModule mkDerivedConfig doRename;
inherit (self.options) isOption mkEnableOption mkSinkUndeclaredOptions
mergeDefaultOption mergeOneOption mergeEqualOption mergeUniqueOption

20
lib/modules.nix
View file

@ -954,6 +954,26 @@ rec {
use = builtins.trace "Obsolete option `${showOption from}' is used. It was renamed to `${showOption to}'.";
};
mkRenamedOptionModuleWith = {
/* Old option path as list of strings. */
from,
/* New option path as list of strings. */
to,
/*
Release number of the first release that contains the rename, ignoring backports.
Set it to the upcoming release, matching the nixpkgs/.version file.
*/
sinceRelease,
}: doRename {
inherit from to;
visible = false;
warn = lib.isInOldestRelease sinceRelease;
use = lib.warnIf (lib.isInOldestRelease sinceRelease)
"Obsolete option `${showOption from}' is used. It was renamed to `${showOption to}'.";
};
/* Return a module that causes a warning to be shown if any of the "from"
option is defined; the defined values can be used in the "mergeFn" to set
the "to" value.

24
lib/trivial.nix
View file

@ -166,6 +166,30 @@ rec {
/* Returns the current nixpkgs release number as string. */
release = lib.strings.fileContents ../.version;
/* The latest release that is supported, at the time of release branch-off,
if applicable.
Ideally, out-of-tree modules should be able to evaluate cleanly with all
supported Nixpkgs versions (master, release and old release until EOL).
So if possible, deprecation warnings should take effect only when all
out-of-tree expressions/libs/modules can upgrade to the new way without
losing support for supported Nixpkgs versions.
This release number allows deprecation warnings to be implemented such that
they take effect as soon as the oldest release reaches end of life. */
oldestSupportedRelease =
# Update on master only. Do not backport.
2111;
/* Whether a feature is supported in all supported releases (at the time of
release branch-off, if applicable). See `oldestSupportedRelease`. */
isInOldestRelease =
/* Release number of feature introduction as an integer, e.g. 2111 for 21.11.
Set it to the upcoming release, matching the nixpkgs/.version file.
*/
release:
release <= lib.trivial.oldestSupportedRelease;
/* Returns the current nixpkgs release code name.
On each release the first letter is bumped and a new animal is chosen

18
nixos/doc/manual/from_md/release-notes/rl-2205.section.xml
View file

@ -62,6 +62,14 @@
notes</link> for details.
</para>
</listitem>
<listitem>
<para>
Module authors can use
<literal>mkRenamedOptionModuleWith</literal> to automate the
deprecation cycle without annoying out-of-tree module authors
and their users.
</para>
</listitem>
</itemizedlist>
</section>
<section xml:id="sec-release-22.05-new-services">
@ -274,6 +282,13 @@
<link xlink:href="options.html#opt-services.nbd.server.enable">services.nbd</link>.
</para>
</listitem>
<listitem>
<para>
<link xlink:href="https://github.com/Mic92/nix-ld">nix-ld</link>,
Run unpatched dynamic binaries on NixOS. Available as
<link xlink:href="options.html#opt-programs.nix-ld.enable">programs.nix-ld</link>.
</para>
</listitem>
<listitem>
<para>
<link xlink:href="https://timetagger.app">timetagger</link>,
@ -1200,7 +1215,8 @@
Legacy options have been mapped to the corresponding
options under under
<link xlink:href="options.html#opt-nix.settings">nix.settings</link>
but may be deprecated in the future.
and will be deprecated when NixOS 21.11 reaches end of
life.
</para>
</listitem>
<listitem>

6
nixos/doc/manual/release-notes/rl-2205.section.md
View file

@ -21,6 +21,8 @@ In addition to numerous new and upgraded packages, this release has the followin
- [`kops`](https://kops.sigs.k8s.io) defaults to 1.22.4, which will enable [Instance Metadata Service Version 2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/configuring-instance-metadata-service.html) and require tokens on new clusters with Kubernetes 1.22. This will increase security by default, but may break some types of workloads. See the [release notes](https://kops.sigs.k8s.io/releases/1.22-notes/) for details.
- Module authors can use `mkRenamedOptionModuleWith` to automate the deprecation cycle without annoying out-of-tree module authors and their users.
## New Services {#sec-release-22.05-new-services}
- [aesmd](https://github.com/intel/linux-sgx#install-the-intelr-sgx-psw), the Intel SGX Architectural Enclave Service Manager. Available as [services.aesmd](#opt-services.aesmd.enable).
@ -79,6 +81,8 @@ In addition to numerous new and upgraded packages, this release has the followin
- [nbd](https://nbd.sourceforge.io/), a Network Block Device server. Available as [services.nbd](options.html#opt-services.nbd.server.enable).
- [nix-ld](https://github.com/Mic92/nix-ld), Run unpatched dynamic binaries on NixOS. Available as [programs.nix-ld](options.html#opt-programs.nix-ld.enable).
- [timetagger](https://timetagger.app), an open source time-tracker with an intuitive user experience and powerful reporting. [services.timetagger](options.html#opt-services.timetagger.enable).
- [rstudio-server](https://www.rstudio.com/products/rstudio/#rstudio-server), a browser-based version of the RStudio IDE for the R programming language. Available as [services.rstudio-server](options.html#opt-services.rstudio-server.enable).
@ -448,7 +452,7 @@ In addition to numerous new and upgraded packages, this release has the followin
Similarly [virtualisation.vmVariantWithBootloader](#opt-virtualisation.vmVariantWithBootLoader) was added.
- The configuration portion of the `nix-daemon` module has been reworked and exposed as [nix.settings](options.html#opt-nix-settings):
* Legacy options have been mapped to the corresponding options under under [nix.settings](options.html#opt-nix.settings) but may be deprecated in the future.
* Legacy options have been mapped to the corresponding options under under [nix.settings](options.html#opt-nix.settings) and will be deprecated when NixOS 21.11 reaches end of life.
* [nix.buildMachines.publicHostKey](options.html#opt-nix.buildMachines.publicHostKey) has been added.
- The `writers.writePyPy2`/`writers.writePyPy3` and corresponding `writers.writePyPy2Bin`/`writers.writePyPy3Bin` convenience functions to create executable Python 2/3 scripts using the PyPy interpreter were added.

20
nixos/modules/hardware/video/nvidia.nix
View file

@ -244,7 +244,7 @@ in
modules = optional (igpuDriver == "amdgpu") [ pkgs.xorg.xf86videoamdgpu ];
deviceSection = ''
BusID "${igpuBusId}"
${optionalString syncCfg.enable ''Option "AccelMethod" "none"''}
${optionalString (syncCfg.enable && igpuDriver != "amdgpu") ''Option "AccelMethod" "none"''}
'';
} ++ singleton {
name = "nvidia";
@ -269,9 +269,15 @@ in
Option "AllowNVIDIAGPUScreens"
'';
services.xserver.displayManager.setupCommands = optionalString syncCfg.enable ''
services.xserver.displayManager.setupCommands = let
sinkGpuProviderName = if igpuDriver == "amdgpu" then
# find the name of the provider if amdgpu
"`${pkgs.xorg.xrandr}/bin/xrandr --listproviders | ${pkgs.gnugrep}/bin/grep -i AMD | ${pkgs.gnused}/bin/sed -n 's/^.*name://p'`"
else
igpuDriver;
in optionalString syncCfg.enable ''
# Added by nvidia configuration module for Optimus/PRIME.
${pkgs.xorg.xrandr}/bin/xrandr --setprovideroutputsource ${igpuDriver} NVIDIA-0
${pkgs.xorg.xrandr}/bin/xrandr --setprovideroutputsource "${sinkGpuProviderName}" NVIDIA-0
${pkgs.xorg.xrandr}/bin/xrandr --auto
'';
@ -283,14 +289,14 @@ in
environment.etc."egl/egl_external_platform.d".source =
"/run/opengl-driver/share/egl/egl_external_platform.d/";
hardware.opengl.package = mkIf (!offloadCfg.enable) nvidia_x11.out;
hardware.opengl.package32 = mkIf (!offloadCfg.enable) nvidia_x11.lib32;
hardware.opengl.extraPackages = [
nvidia_x11.out
pkgs.nvidia-vaapi-driver
] ++ optional offloadCfg.enable nvidia_x11.out;
];
hardware.opengl.extraPackages32 = [
nvidia_x11.lib32
pkgs.pkgsi686Linux.nvidia-vaapi-driver
] ++ optional offloadCfg.enable nvidia_x11.lib32;
];
environment.systemPackages = [ nvidia_x11.bin ]
++ optionals cfg.nvidiaSettings [ nvidia_x11.settings ]

8
nixos/modules/module-list.nix
View file

@ -181,6 +181,7 @@
./programs/mtr.nix
./programs/nano.nix
./programs/nbd.nix
./programs/nix-ld.nix
./programs/neovim.nix
./programs/nm-applet.nix
./programs/npm.nix
@ -1168,7 +1169,12 @@
./system/boot/stage-1.nix
./system/boot/stage-2.nix
./system/boot/systemd.nix
./system/boot/systemd-nspawn.nix
./system/boot/systemd/coredump.nix
./system/boot/systemd/journald.nix
./system/boot/systemd/logind.nix
./system/boot/systemd/nspawn.nix
./system/boot/systemd/tmpfiles.nix
./system/boot/systemd/user.nix
./system/boot/timesyncd.nix
./system/boot/tmp.nix
./system/etc/etc-activation.nix

12
nixos/modules/programs/nix-ld.nix Normal file
View file

@ -0,0 +1,12 @@
{ pkgs, lib, config, ... }:
{
meta.maintainers = [ lib.maintainers.mic92 ];
options = {
programs.nix-ld.enable = lib.mkEnableOption ''nix-ld, Documentation: <link xlink:href="https://github.com/Mic92/nix-ld"/>'';
};
config = lib.mkIf config.programs.nix-ld.enable {
systemd.tmpfiles.rules = [
"L+ ${pkgs.nix-ld.ldPath} - - - - ${pkgs.nix-ld}/libexec/nix-ld"
];
};
}

8
nixos/modules/services/misc/nix-daemon.nix
View file

@ -112,11 +112,11 @@ in
{
imports = [
(mkRenamedOptionModule [ "nix" "useChroot" ] [ "nix" "useSandbox" ])
(mkRenamedOptionModule [ "nix" "chrootDirs" ] [ "nix" "sandboxPaths" ])
(mkRenamedOptionModule [ "nix" "daemonIONiceLevel" ] [ "nix" "daemonIOSchedPriority" ])
(mkRenamedOptionModuleWith { sinceRelease = 2003; from = [ "nix" "useChroot" ]; to = [ "nix" "useSandbox" ]; })
(mkRenamedOptionModuleWith { sinceRelease = 2003; from = [ "nix" "chrootDirs" ]; to = [ "nix" "sandboxPaths" ]; })
(mkRenamedOptionModuleWith { sinceRelease = 2205; from = [ "nix" "daemonIONiceLevel" ]; to = [ "nix" "daemonIOSchedPriority" ]; })
(mkRemovedOptionModule [ "nix" "daemonNiceLevel" ] "Consider nix.daemonCPUSchedPolicy instead.")
] ++ mapAttrsToList (oldConf: newConf: mkRenamedOptionModule [ "nix" oldConf ] [ "nix" "settings" newConf ]) legacyConfMappings;
] ++ mapAttrsToList (oldConf: newConf: mkRenamedOptionModuleWith { sinceRelease = 2205; from = [ "nix" oldConf ]; to = [ "nix" "settings" newConf ]; }) legacyConfMappings;
###### interface

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

@ -224,6 +224,7 @@ in
targets.samba = {
description = "Samba Server";
after = [ "network.target" ];
wants = [ "network-online.target" ];
wantedBy = [ "multi-user.target" ];
};
# Refer to https://github.com/samba-team/samba/tree/master/packaging/systemd

632
nixos/modules/system/activation/switch-to-configuration.pl
View file

File diff suppressed because it is too large Load diff

448
nixos/modules/system/boot/systemd.nix
View file

@ -2,7 +2,6 @@
with utils;
with systemdUtils.unitOptions;
with systemdUtils.lib;
with lib;
let
@ -12,6 +11,8 @@ let
systemd = cfg.package;
inherit (systemdUtils.lib)
makeUnit
generateUnits
makeJobScript
unitConfig
serviceConfig
@ -79,32 +80,6 @@ let
"printer.target"
"smartcard.target"
# Login stuff.
"systemd-logind.service"
"autovt@.service"
"systemd-user-sessions.service"
"dbus-org.freedesktop.import1.service"
"dbus-org.freedesktop.machine1.service"
"dbus-org.freedesktop.login1.service"
"user@.service"
"user-runtime-dir@.service"
# Journal.
"systemd-journald.socket"
"systemd-journald@.socket"
"systemd-journald-varlink@.socket"
"systemd-journald.service"
"systemd-journald@.service"
"systemd-journal-flush.service"
"systemd-journal-catalog-update.service"
] ++ (optional (!config.boot.isContainer) "systemd-journald-audit.socket") ++ [
"systemd-journald-dev-log.socket"
"syslog.socket"
# Coredumps.
"systemd-coredump.socket"
"systemd-coredump@.service"
# Kernel module loading.
"systemd-modules-load.service"
"kmod-static-nodes.service"
@ -165,19 +140,12 @@ let
# Slices / containers.
"slices.target"
"user.slice"
"machine.slice"
"machines.target"
"systemd-importd.service"
"systemd-machined.service"
"systemd-nspawn@.service"
# Temporary file creation / cleanup.
"systemd-tmpfiles-clean.service"
"systemd-tmpfiles-clean.timer"
"systemd-tmpfiles-setup.service"
"systemd-tmpfiles-setup-dev.service"
# Misc.
"systemd-sysctl.service"
"dbus-org.freedesktop.timedate1.service"
@ -188,9 +156,6 @@ let
"systemd-hostnamed.service"
"systemd-exit.service"
"systemd-update-done.service"
] ++ optionals config.services.journald.enableHttpGateway [
"systemd-journal-gatewayd.socket"
"systemd-journal-gatewayd.service"
] ++ cfg.additionalUpstreamSystemUnits;
upstreamSystemWants =
@ -201,36 +166,6 @@ let
"timers.target.wants"
];
upstreamUserUnits = [
"app.slice"
"background.slice"
"basic.target"
"bluetooth.target"
"default.target"
"exit.target"
"graphical-session-pre.target"
"graphical-session.target"
"paths.target"
"printer.target"
"session.slice"
"shutdown.target"
"smartcard.target"
"sockets.target"
"sound.target"
"systemd-exit.service"
"systemd-tmpfiles-clean.service"
"systemd-tmpfiles-clean.timer"
"systemd-tmpfiles-setup.service"
"timers.target"
"xdg-desktop-autostart.target"
];
logindHandlerType = types.enum [
"ignore" "poweroff" "reboot" "halt" "kexec" "suspend"
"hibernate" "hybrid-sleep" "suspend-then-hibernate" "lock"
];
proxy_env = config.networking.proxy.envVars;
in
@ -383,26 +318,6 @@ in
'';
};
systemd.coredump.enable = mkOption {
default = true;
type = types.bool;
description = ''
Whether core dumps should be processed by
<command>systemd-coredump</command>. If disabled, core dumps
appear in the current directory of the crashing process.
'';
};
systemd.coredump.extraConfig = mkOption {
default = "";
type = types.lines;
example = "Storage=journal";
description = ''
Extra config options for systemd-coredump. See coredump.conf(5) man page
for available options.
'';
};
systemd.extraConfig = mkOption {
default = "";
type = types.lines;
@ -413,142 +328,6 @@ in
'';
};
services.journald.console = mkOption {
default = "";
type = types.str;
description = "If non-empty, write log messages to the specified TTY device.";
};
services.journald.rateLimitInterval = mkOption {
default = "30s";
type = types.str;
description = ''
Configures the rate limiting interval that is applied to all
messages generated on the system. This rate limiting is applied
per-service, so that two services which log do not interfere with
each other's limit. The value may be specified in the following
units: s, min, h, ms, us. To turn off any kind of rate limiting,
set either value to 0.
See <option>services.journald.rateLimitBurst</option> for important
considerations when setting this value.
'';
};
services.journald.rateLimitBurst = mkOption {
default = 10000;
type = types.int;
description = ''
Configures the rate limiting burst limit (number of messages per
interval) that is applied to all messages generated on the system.
This rate limiting is applied per-service, so that two services
which log do not interfere with each other's limit.
Note that the effective rate limit is multiplied by a factor derived
from the available free disk space for the journal as described on
<link xlink:href="https://www.freedesktop.org/software/systemd/man/journald.conf.html">
journald.conf(5)</link>.
Note that the total amount of logs stored is limited by journald settings
such as <literal>SystemMaxUse</literal>, which defaults to a 4 GB cap.
It is thus recommended to compute what period of time that you will be
able to store logs for when an application logs at full burst rate.
With default settings for log lines that are 100 Bytes long, this can
amount to just a few hours.
'';
};
services.journald.extraConfig = mkOption {
default = "";
type = types.lines;
example = "Storage=volatile";
description = ''
Extra config options for systemd-journald. See man journald.conf
for available options.
'';
};
services.journald.enableHttpGateway = mkOption {
default = false;
type = types.bool;
description = ''
Whether to enable the HTTP gateway to the journal.
'';
};
services.journald.forwardToSyslog = mkOption {
default = config.services.rsyslogd.enable || config.services.syslog-ng.enable;
defaultText = literalExpression "services.rsyslogd.enable || services.syslog-ng.enable";
type = types.bool;
description = ''
Whether to forward log messages to syslog.
'';
};
services.logind.extraConfig = mkOption {
default = "";
type = types.lines;
example = "IdleAction=lock";
description = ''
Extra config options for systemd-logind. See
<link xlink:href="https://www.freedesktop.org/software/systemd/man/logind.conf.html">
logind.conf(5)</link> for available options.
'';
};
services.logind.killUserProcesses = mkOption {
default = false;
type = types.bool;
description = ''
Specifies whether the processes of a user should be killed
when the user logs out. If true, the scope unit corresponding
to the session and all processes inside that scope will be
terminated. If false, the scope is "abandoned" (see
<link xlink:href="https://www.freedesktop.org/software/systemd/man/systemd.scope.html#">
systemd.scope(5)</link>), and processes are not killed.
</para>
<para>
See <link xlink:href="https://www.freedesktop.org/software/systemd/man/logind.conf.html#KillUserProcesses=">logind.conf(5)</link>
for more details.
'';
};
services.logind.lidSwitch = mkOption {
default = "suspend";
example = "ignore";
type = logindHandlerType;
description = ''
Specifies what to be done when the laptop lid is closed.
'';
};
services.logind.lidSwitchDocked = mkOption {
default = "ignore";
example = "suspend";
type = logindHandlerType;
description = ''
Specifies what to be done when the laptop lid is closed
and another screen is added.
'';
};
services.logind.lidSwitchExternalPower = mkOption {
default = config.services.logind.lidSwitch;
defaultText = literalExpression "services.logind.lidSwitch";
example = "ignore";
type = logindHandlerType;
description = ''
Specifies what to do when the laptop lid is closed and the system is
on external power. By default use the same action as specified in
services.logind.lidSwitch.
'';
};
systemd.sleep.extraConfig = mkOption {
default = "";
type = types.lines;
@ -559,95 +338,6 @@ in
'';
};
systemd.user.extraConfig = mkOption {
default = "";
type = types.lines;
example = "DefaultCPUAccounting=yes";
description = ''
Extra config options for systemd user instances. See man systemd-user.conf for
available options.
'';
};
systemd.tmpfiles.rules = mkOption {
type = types.listOf types.str;
default = [];
example = [ "d /tmp 1777 root root 10d" ];
description = ''
Rules for creation, deletion and cleaning of volatile and temporary files
automatically. See
<citerefentry><refentrytitle>tmpfiles.d</refentrytitle><manvolnum>5</manvolnum></citerefentry>
for the exact format.
'';
};
systemd.tmpfiles.packages = mkOption {
type = types.listOf types.package;
default = [];
example = literalExpression "[ pkgs.lvm2 ]";
apply = map getLib;
description = ''
List of packages containing <command>systemd-tmpfiles</command> rules.
All files ending in .conf found in
<filename><replaceable>pkg</replaceable>/lib/tmpfiles.d</filename>
will be included.
If this folder does not exist or does not contain any files an error will be returned instead.
If a <filename>lib</filename> output is available, rules are searched there and only there.
If there is no <filename>lib</filename> output it will fall back to <filename>out</filename>
and if that does not exist either, the default output will be used.
'';
};
systemd.user.units = mkOption {
description = "Definition of systemd per-user units.";
default = {};
type = with types; attrsOf (submodule (
{ name, config, ... }:
{ options = concreteUnitOptions;
config = {
unit = mkDefault (makeUnit name config);
};
}));
};
systemd.user.paths = mkOption {
default = {};
type = with types; attrsOf (submodule [ { options = pathOptions; } unitConfig ]);
description = "Definition of systemd per-user path units.";
};
systemd.user.services = mkOption {
default = {};
type = with types; attrsOf (submodule [ { options = serviceOptions; } unitConfig serviceConfig ] );
description = "Definition of systemd per-user service units.";
};
systemd.user.slices = mkOption {
default = {};
type = with types; attrsOf (submodule [ { options = sliceOptions; } unitConfig ] );
description = "Definition of systemd per-user slice units.";
};
systemd.user.sockets = mkOption {
default = {};
type = with types; attrsOf (submodule [ { options = socketOptions; } unitConfig ] );
description = "Definition of systemd per-user socket units.";
};
systemd.user.targets = mkOption {
default = {};
type = with types; attrsOf (submodule [ { options = targetOptions; } unitConfig] );
description = "Definition of systemd per-user target units.";
};
systemd.user.timers = mkOption {
default = {};
type = with types; attrsOf (submodule [ { options = timerOptions; } unitConfig ] );
description = "Definition of systemd per-user timer units.";
};
systemd.additionalUpstreamSystemUnits = mkOption {
default = [ ];
type = types.listOf types.str;
@ -783,8 +473,6 @@ in
in ({
"systemd/system".source = generateUnits "system" enabledUnits enabledUpstreamSystemUnits upstreamSystemWants;
"systemd/user".source = generateUnits "user" cfg.user.units upstreamUserUnits [];
"systemd/system.conf".text = ''
[Manager]
${optionalString config.systemd.enableCgroupAccounting ''
@ -810,76 +498,17 @@ in
${config.systemd.extraConfig}
'';
"systemd/user.conf".text = ''
[Manager]
${config.systemd.user.extraConfig}
'';
"systemd/journald.conf".text = ''
[Journal]
Storage=persistent
RateLimitInterval=${config.services.journald.rateLimitInterval}
RateLimitBurst=${toString config.services.journald.rateLimitBurst}
${optionalString (config.services.journald.console != "") ''
ForwardToConsole=yes
TTYPath=${config.services.journald.console}
''}
${optionalString (config.services.journald.forwardToSyslog) ''
ForwardToSyslog=yes
''}
${config.services.journald.extraConfig}
'';
"systemd/coredump.conf".text =
''
[Coredump]
${config.systemd.coredump.extraConfig}
'';
"systemd/logind.conf".text = ''
[Login]
KillUserProcesses=${if config.services.logind.killUserProcesses then "yes" else "no"}
HandleLidSwitch=${config.services.logind.lidSwitch}
HandleLidSwitchDocked=${config.services.logind.lidSwitchDocked}
HandleLidSwitchExternalPower=${config.services.logind.lidSwitchExternalPower}
${config.services.logind.extraConfig}
'';
"systemd/sleep.conf".text = ''
[Sleep]
${config.systemd.sleep.extraConfig}
'';
# install provided sysctl snippets
"sysctl.d/50-coredump.conf".source = "${systemd}/example/sysctl.d/50-coredump.conf";
"sysctl.d/50-default.conf".source = "${systemd}/example/sysctl.d/50-default.conf";
"tmpfiles.d".source = (pkgs.symlinkJoin {
name = "tmpfiles.d";
paths = map (p: p + "/lib/tmpfiles.d") cfg.tmpfiles.packages;
postBuild = ''
for i in $(cat $pathsPath); do
(test -d "$i" && test $(ls "$i"/*.conf | wc -l) -ge 1) || (
echo "ERROR: The path '$i' from systemd.tmpfiles.packages contains no *.conf files."
exit 1
)
done
'' + concatMapStrings (name: optionalString (hasPrefix "tmpfiles.d/" name) ''
rm -f $out/${removePrefix "tmpfiles.d/" name}
'') config.system.build.etc.passthru.targets;
}) + "/*";
"systemd/system-generators" = { source = hooks "generators" cfg.generators; };
"systemd/system-shutdown" = { source = hooks "shutdown" cfg.shutdown; };
});
services.dbus.enable = true;
users.users.systemd-coredump = {
uid = config.ids.uids.systemd-coredump;
group = "systemd-coredump";
};
users.groups.systemd-coredump = {};
users.users.systemd-network = {
uid = config.ids.uids.systemd-network;
group = "systemd-network";
@ -899,36 +528,6 @@ in
unitConfig.X-StopOnReconfiguration = true;
};
systemd.tmpfiles.packages = [
# Default tmpfiles rules provided by systemd
(pkgs.runCommand "systemd-default-tmpfiles" {} ''
mkdir -p $out/lib/tmpfiles.d
cd $out/lib/tmpfiles.d
ln -s "${systemd}/example/tmpfiles.d/home.conf"
ln -s "${systemd}/example/tmpfiles.d/journal-nocow.conf"
ln -s "${systemd}/example/tmpfiles.d/static-nodes-permissions.conf"
ln -s "${systemd}/example/tmpfiles.d/systemd.conf"
ln -s "${systemd}/example/tmpfiles.d/systemd-nologin.conf"
ln -s "${systemd}/example/tmpfiles.d/systemd-nspawn.conf"
ln -s "${systemd}/example/tmpfiles.d/systemd-tmp.conf"
ln -s "${systemd}/example/tmpfiles.d/tmp.conf"
ln -s "${systemd}/example/tmpfiles.d/var.conf"
ln -s "${systemd}/example/tmpfiles.d/x11.conf"
'')
# User-specified tmpfiles rules
(pkgs.writeTextFile {
name = "nixos-tmpfiles.d";
destination = "/lib/tmpfiles.d/00-nixos.conf";
text = ''
# This file is created automatically and should not be modified.
# Please change the option ‘systemd.tmpfiles.rules’ instead.
${concatStringsSep "\n" cfg.tmpfiles.rules}
'';
})
];
systemd.units =
mapAttrs' (n: v: nameValuePair "${n}.path" (pathToUnit n v)) cfg.paths
// mapAttrs' (n: v: nameValuePair "${n}.service" (serviceToUnit n v)) cfg.services
@ -943,14 +542,6 @@ in
(v: let n = escapeSystemdPath v.where;
in nameValuePair "${n}.automount" (automountToUnit n v)) cfg.automounts);
systemd.user.units =
mapAttrs' (n: v: nameValuePair "${n}.path" (pathToUnit n v)) cfg.user.paths
// mapAttrs' (n: v: nameValuePair "${n}.service" (serviceToUnit n v)) cfg.user.services
// mapAttrs' (n: v: nameValuePair "${n}.slice" (sliceToUnit n v)) cfg.user.slices
// mapAttrs' (n: v: nameValuePair "${n}.socket" (socketToUnit n v)) cfg.user.sockets
// mapAttrs' (n: v: nameValuePair "${n}.target" (targetToUnit n v)) cfg.user.targets
// mapAttrs' (n: v: nameValuePair "${n}.timer" (timerToUnit n v)) cfg.user.timers;
system.requiredKernelConfig = map config.lib.kernelConfig.isEnabled
[ "DEVTMPFS" "CGROUPS" "INOTIFY_USER" "SIGNALFD" "TIMERFD" "EPOLL" "NET"
"SYSFS" "PROC_FS" "FHANDLE" "CRYPTO_USER_API_HASH" "CRYPTO_HMAC"
@ -958,11 +549,6 @@ in
"TMPFS_XATTR" "SECCOMP"
];
users.groups.systemd-journal.gid = config.ids.gids.systemd-journal;
users.users.systemd-journal-gateway.uid = config.ids.uids.systemd-journal-gateway;
users.users.systemd-journal-gateway.group = "systemd-journal-gateway";
users.groups.systemd-journal-gateway.gid = config.ids.gids.systemd-journal-gateway;
# Generate timer units for all services that have a ‘startAt’ value.
systemd.timers =
mapAttrs (name: service:
@ -979,42 +565,14 @@ in
})
(filterAttrs (name: service: service.startAt != []) cfg.user.services);
systemd.sockets.systemd-journal-gatewayd.wantedBy =
optional config.services.journald.enableHttpGateway "sockets.target";
# Provide the systemd-user PAM service, required to run systemd
# user instances.
security.pam.services.systemd-user =
{ # Ensure that pam_systemd gets included. This is special-cased
# in systemd to provide XDG_RUNTIME_DIR.
startSession = true;
};
# Some overrides to upstream units.
systemd.services."systemd-backlight@".restartIfChanged = false;
systemd.services."systemd-fsck@".restartIfChanged = false;
systemd.services."systemd-fsck@".path = [ config.system.path ];
systemd.services."user@".restartIfChanged = false;
systemd.services.systemd-journal-flush.restartIfChanged = false;
systemd.services.systemd-random-seed.restartIfChanged = false;
systemd.services.systemd-remount-fs.restartIfChanged = false;
systemd.services.systemd-update-utmp.restartIfChanged = false;
systemd.services.systemd-user-sessions.restartIfChanged = false; # Restart kills all active sessions.
systemd.services.systemd-udev-settle.restartIfChanged = false; # Causes long delays in nixos-rebuild
# Restarting systemd-logind breaks X11
# - upstream commit: https://cgit.freedesktop.org/xorg/xserver/commit/?id=dc48bd653c7e101
# - systemd announcement: https://github.com/systemd/systemd/blob/22043e4317ecd2bc7834b48a6d364de76bb26d91/NEWS#L103-L112
# - this might be addressed in the future by xorg
#systemd.services.systemd-logind.restartTriggers = [ config.environment.etc."systemd/logind.conf".source ];
systemd.services.systemd-logind.restartIfChanged = false;
systemd.services.systemd-logind.stopIfChanged = false;
# The user-runtime-dir@ service is managed by systemd-logind we should not touch it or else we break the users' sessions.
systemd.services."user-runtime-dir@".stopIfChanged = false;
systemd.services."user-runtime-dir@".restartIfChanged = false;
systemd.services.systemd-journald.restartTriggers = [ config.environment.etc."systemd/journald.conf".source ];
systemd.services.systemd-journald.stopIfChanged = false;
systemd.services."systemd-journald@".restartTriggers = [ config.environment.etc."systemd/journald.conf".source ];
systemd.services."systemd-journald@".stopIfChanged = false;
systemd.targets.local-fs.unitConfig.X-StopOnReconfiguration = true;
systemd.targets.remote-fs.unitConfig.X-StopOnReconfiguration = true;
systemd.targets.network-online.wantedBy = [ "multi-user.target" ];
@ -1025,8 +583,6 @@ in
systemd.services.systemd-remount-fs.unitConfig.ConditionVirtualization = "!container";
systemd.services.systemd-random-seed.unitConfig.ConditionVirtualization = "!container";
boot.kernel.sysctl."kernel.core_pattern" = mkIf (!cfg.coredump.enable) "core";
# Increase numeric PID range (set directly instead of copying a one-line file from systemd)
# https://github.com/systemd/systemd/pull/12226
boot.kernel.sysctl."kernel.pid_max" = mkIf pkgs.stdenv.is64bit (lib.mkDefault 4194304);

57
nixos/modules/system/boot/systemd/coredump.nix Normal file
View file

@ -0,0 +1,57 @@
{ config, lib, pkgs, utils, ... }:
with lib;
let
cfg = config.systemd.coredump;
systemd = config.systemd.package;
in {
options = {
systemd.coredump.enable = mkOption {
default = true;
type = types.bool;
description = ''
Whether core dumps should be processed by
<command>systemd-coredump</command>. If disabled, core dumps
appear in the current directory of the crashing process.
'';
};
systemd.coredump.extraConfig = mkOption {
default = "";
type = types.lines;
example = "Storage=journal";
description = ''
Extra config options for systemd-coredump. See coredump.conf(5) man page
for available options.
'';
};
};
config = {
systemd.additionalUpstreamSystemUnits = [
"systemd-coredump.socket"
"systemd-coredump@.service"
];
environment.etc = {
"systemd/coredump.conf".text =
''
[Coredump]
${cfg.extraConfig}
'';
# install provided sysctl snippets
"sysctl.d/50-coredump.conf".source = "${systemd}/example/sysctl.d/50-coredump.conf";
"sysctl.d/50-default.conf".source = "${systemd}/example/sysctl.d/50-default.conf";
};
users.users.systemd-coredump = {
uid = config.ids.uids.systemd-coredump;
group = "systemd-coredump";
};
users.groups.systemd-coredump = {};
boot.kernel.sysctl."kernel.core_pattern" = mkIf (!cfg.enable) "core";
};
}

131
nixos/modules/system/boot/systemd/journald.nix Normal file
View file

@ -0,0 +1,131 @@
{ config, lib, pkgs, ... }:
with lib;
let
cfg = config.services.journald;
in {
options = {
services.journald.console = mkOption {
default = "";
type = types.str;
description = "If non-empty, write log messages to the specified TTY device.";
};
services.journald.rateLimitInterval = mkOption {
default = "30s";
type = types.str;
description = ''
Configures the rate limiting interval that is applied to all
messages generated on the system. This rate limiting is applied
per-service, so that two services which log do not interfere with
each other's limit. The value may be specified in the following
units: s, min, h, ms, us. To turn off any kind of rate limiting,
set either value to 0.
See <option>services.journald.rateLimitBurst</option> for important
considerations when setting this value.
'';
};
services.journald.rateLimitBurst = mkOption {
default = 10000;
type = types.int;
description = ''
Configures the rate limiting burst limit (number of messages per
interval) that is applied to all messages generated on the system.
This rate limiting is applied per-service, so that two services
which log do not interfere with each other's limit.
Note that the effective rate limit is multiplied by a factor derived
from the available free disk space for the journal as described on
<link xlink:href="https://www.freedesktop.org/software/systemd/man/journald.conf.html">
journald.conf(5)</link>.
Note that the total amount of logs stored is limited by journald settings
such as <literal>SystemMaxUse</literal>, which defaults to a 4 GB cap.
It is thus recommended to compute what period of time that you will be
able to store logs for when an application logs at full burst rate.
With default settings for log lines that are 100 Bytes long, this can
amount to just a few hours.
'';
};
services.journald.extraConfig = mkOption {
default = "";
type = types.lines;
example = "Storage=volatile";
description = ''
Extra config options for systemd-journald. See man journald.conf
for available options.
'';
};
services.journald.enableHttpGateway = mkOption {
default = false;
type = types.bool;
description = ''
Whether to enable the HTTP gateway to the journal.
'';
};
services.journald.forwardToSyslog = mkOption {
default = config.services.rsyslogd.enable || config.services.syslog-ng.enable;
defaultText = literalExpression "services.rsyslogd.enable || services.syslog-ng.enable";
type = types.bool;
description = ''
Whether to forward log messages to syslog.
'';
};
};
config = {
systemd.additionalUpstreamSystemUnits = [
"systemd-journald.socket"
"systemd-journald@.socket"
"systemd-journald-varlink@.socket"
"systemd-journald.service"
"systemd-journald@.service"
"systemd-journal-flush.service"
"systemd-journal-catalog-update.service"
] ++ (optional (!config.boot.isContainer) "systemd-journald-audit.socket") ++ [
"systemd-journald-dev-log.socket"
"syslog.socket"
] ++ optionals cfg.enableHttpGateway [
"systemd-journal-gatewayd.socket"
"systemd-journal-gatewayd.service"
];
environment.etc = {
"systemd/journald.conf".text = ''
[Journal]
Storage=persistent
RateLimitInterval=${cfg.rateLimitInterval}
RateLimitBurst=${toString cfg.rateLimitBurst}
${optionalString (cfg.console != "") ''
ForwardToConsole=yes
TTYPath=${cfg.console}
''}
${optionalString (cfg.forwardToSyslog) ''
ForwardToSyslog=yes
''}
${cfg.extraConfig}
'';
};
users.groups.systemd-journal.gid = config.ids.gids.systemd-journal;
users.users.systemd-journal-gateway.uid = config.ids.uids.systemd-journal-gateway;
users.users.systemd-journal-gateway.group = "systemd-journal-gateway";
users.groups.systemd-journal-gateway.gid = config.ids.gids.systemd-journal-gateway;
systemd.sockets.systemd-journal-gatewayd.wantedBy =
optional cfg.enableHttpGateway "sockets.target";
systemd.services.systemd-journal-flush.restartIfChanged = false;
systemd.services.systemd-journald.restartTriggers = [ config.environment.etc."systemd/journald.conf".source ];
systemd.services.systemd-journald.stopIfChanged = false;
systemd.services."systemd-journald@".restartTriggers = [ config.environment.etc."systemd/journald.conf".source ];
systemd.services."systemd-journald@".stopIfChanged = false;
};
}

114
nixos/modules/system/boot/systemd/logind.nix Normal file
View file

@ -0,0 +1,114 @@
{ config, lib, pkgs, utils, ... }:
with lib;
let
cfg = config.services.logind;
logindHandlerType = types.enum [
"ignore" "poweroff" "reboot" "halt" "kexec" "suspend"
"hibernate" "hybrid-sleep" "suspend-then-hibernate" "lock"
];
in
{
options = {
services.logind.extraConfig = mkOption {
default = "";
type = types.lines;
example = "IdleAction=lock";
description = ''
Extra config options for systemd-logind. See
<link xlink:href="https://www.freedesktop.org/software/systemd/man/logind.conf.html">
logind.conf(5)</link> for available options.
'';
};
services.logind.killUserProcesses = mkOption {
default = false;
type = types.bool;
description = ''
Specifies whether the processes of a user should be killed
when the user logs out. If true, the scope unit corresponding
to the session and all processes inside that scope will be
terminated. If false, the scope is "abandoned" (see
<link xlink:href="https://www.freedesktop.org/software/systemd/man/systemd.scope.html#">
systemd.scope(5)</link>), and processes are not killed.
</para>
<para>
See <link xlink:href="https://www.freedesktop.org/software/systemd/man/logind.conf.html#KillUserProcesses=">logind.conf(5)</link>
for more details.
'';
};
services.logind.lidSwitch = mkOption {
default = "suspend";
example = "ignore";
type = logindHandlerType;
description = ''
Specifies what to be done when the laptop lid is closed.
'';
};
services.logind.lidSwitchDocked = mkOption {
default = "ignore";
example = "suspend";
type = logindHandlerType;
description = ''
Specifies what to be done when the laptop lid is closed
and another screen is added.
'';
};
services.logind.lidSwitchExternalPower = mkOption {
default = cfg.lidSwitch;
defaultText = literalExpression "services.logind.lidSwitch";
example = "ignore";
type = logindHandlerType;
description = ''
Specifies what to do when the laptop lid is closed and the system is
on external power. By default use the same action as specified in
services.logind.lidSwitch.
'';
};
};
config = {
systemd.additionalUpstreamSystemUnits = [
"systemd-logind.service"
"autovt@.service"
"systemd-user-sessions.service"
"dbus-org.freedesktop.import1.service"
"dbus-org.freedesktop.machine1.service"
"dbus-org.freedesktop.login1.service"
"user@.service"
"user-runtime-dir@.service"
];
environment.etc = {
"systemd/logind.conf".text = ''
[Login]
KillUserProcesses=${if cfg.killUserProcesses then "yes" else "no"}
HandleLidSwitch=${cfg.lidSwitch}
HandleLidSwitchDocked=${cfg.lidSwitchDocked}
HandleLidSwitchExternalPower=${cfg.lidSwitchExternalPower}
${cfg.extraConfig}
'';
};
# Restarting systemd-logind breaks X11
# - upstream commit: https://cgit.freedesktop.org/xorg/xserver/commit/?id=dc48bd653c7e101
# - systemd announcement: https://github.com/systemd/systemd/blob/22043e4317ecd2bc7834b48a6d364de76bb26d91/NEWS#L103-L112
# - this might be addressed in the future by xorg
#systemd.services.systemd-logind.restartTriggers = [ config.environment.etc."systemd/logind.conf".source ];
systemd.services.systemd-logind.restartIfChanged = false;
systemd.services.systemd-logind.stopIfChanged = false;
# The user-runtime-dir@ service is managed by systemd-logind we should not touch it or else we break the users' sessions.
systemd.services."user-runtime-dir@".stopIfChanged = false;
systemd.services."user-runtime-dir@".restartIfChanged = false;
};
}

0
nixos/modules/system/boot/systemd-nspawn.nix → nixos/modules/system/boot/systemd/nspawn.nix
View file

104
nixos/modules/system/boot/systemd/tmpfiles.nix Normal file
View file

@ -0,0 +1,104 @@
{ config, lib, pkgs, utils, ... }:
with lib;
let
cfg = config.systemd.tmpfiles;
systemd = config.systemd.package;
in
{
options = {
systemd.tmpfiles.rules = mkOption {
type = types.listOf types.str;
default = [];
example = [ "d /tmp 1777 root root 10d" ];
description = ''
Rules for creation, deletion and cleaning of volatile and temporary files
automatically. See
<citerefentry><refentrytitle>tmpfiles.d</refentrytitle><manvolnum>5</manvolnum></citerefentry>
for the exact format.
'';
};
systemd.tmpfiles.packages = mkOption {
type = types.listOf types.package;
default = [];
example = literalExpression "[ pkgs.lvm2 ]";
apply = map getLib;
description = ''
List of packages containing <command>systemd-tmpfiles</command> rules.
All files ending in .conf found in
<filename><replaceable>pkg</replaceable>/lib/tmpfiles.d</filename>
will be included.
If this folder does not exist or does not contain any files an error will be returned instead.
If a <filename>lib</filename> output is available, rules are searched there and only there.
If there is no <filename>lib</filename> output it will fall back to <filename>out</filename>
and if that does not exist either, the default output will be used.
'';
};
};
config = {
systemd.additionalUpstreamSystemUnits = [
"systemd-tmpfiles-clean.service"
"systemd-tmpfiles-clean.timer"
"systemd-tmpfiles-setup.service"
"systemd-tmpfiles-setup-dev.service"
];
systemd.additionalUpstreamUserUnits = [
"systemd-tmpfiles-clean.service"
"systemd-tmpfiles-clean.timer"
"systemd-tmpfiles-setup.service"
];
environment.etc = {
"tmpfiles.d".source = (pkgs.symlinkJoin {
name = "tmpfiles.d";
paths = map (p: p + "/lib/tmpfiles.d") cfg.packages;
postBuild = ''
for i in $(cat $pathsPath); do
(test -d "$i" && test $(ls "$i"/*.conf | wc -l) -ge 1) || (
echo "ERROR: The path '$i' from systemd.tmpfiles.packages contains no *.conf files."
exit 1
)
done
'' + concatMapStrings (name: optionalString (hasPrefix "tmpfiles.d/" name) ''
rm -f $out/${removePrefix "tmpfiles.d/" name}
'') config.system.build.etc.passthru.targets;
}) + "/*";
};
systemd.tmpfiles.packages = [
# Default tmpfiles rules provided by systemd
(pkgs.runCommand "systemd-default-tmpfiles" {} ''
mkdir -p $out/lib/tmpfiles.d
cd $out/lib/tmpfiles.d
ln -s "${systemd}/example/tmpfiles.d/home.conf"
ln -s "${systemd}/example/tmpfiles.d/journal-nocow.conf"
ln -s "${systemd}/example/tmpfiles.d/static-nodes-permissions.conf"
ln -s "${systemd}/example/tmpfiles.d/systemd.conf"
ln -s "${systemd}/example/tmpfiles.d/systemd-nologin.conf"
ln -s "${systemd}/example/tmpfiles.d/systemd-nspawn.conf"
ln -s "${systemd}/example/tmpfiles.d/systemd-tmp.conf"
ln -s "${systemd}/example/tmpfiles.d/tmp.conf"
ln -s "${systemd}/example/tmpfiles.d/var.conf"
ln -s "${systemd}/example/tmpfiles.d/x11.conf"
'')
# User-specified tmpfiles rules
(pkgs.writeTextFile {
name = "nixos-tmpfiles.d";
destination = "/lib/tmpfiles.d/00-nixos.conf";
text = ''
# This file is created automatically and should not be modified.
# Please change the option ‘systemd.tmpfiles.rules’ instead.
${concatStringsSep "\n" cfg.rules}
'';
})
];
};
}

158
nixos/modules/system/boot/systemd/user.nix Normal file
View file

@ -0,0 +1,158 @@
{ config, lib, pkgs, utils, ... }:
with utils;
with systemdUtils.unitOptions;
with lib;
let
cfg = config.systemd.user;
systemd = config.systemd.package;
inherit
(systemdUtils.lib)
makeUnit
generateUnits
makeJobScript
unitConfig
serviceConfig
commonUnitText
targetToUnit
serviceToUnit
socketToUnit
timerToUnit
pathToUnit;
upstreamUserUnits = [
"app.slice"
"background.slice"
"basic.target"
"bluetooth.target"
"default.target"
"exit.target"
"graphical-session-pre.target"
"graphical-session.target"
"paths.target"
"printer.target"
"session.slice"
"shutdown.target"
"smartcard.target"
"sockets.target"
"sound.target"
"systemd-exit.service"
"timers.target"
"xdg-desktop-autostart.target"
] ++ config.systemd.additionalUpstreamUserUnits;
in {
options = {
systemd.user.extraConfig = mkOption {
default = "";
type = types.lines;
example = "DefaultCPUAccounting=yes";
description = ''
Extra config options for systemd user instances. See man systemd-user.conf for
available options.
'';
};
systemd.user.units = mkOption {
description = "Definition of systemd per-user units.";
default = {};
type = with types; attrsOf (submodule (
{ name, config, ... }:
{ options = concreteUnitOptions;
config = {
unit = mkDefault (makeUnit name config);
};
}));
};
systemd.user.paths = mkOption {
default = {};
type = with types; attrsOf (submodule [ { options = pathOptions; } unitConfig ]);
description = "Definition of systemd per-user path units.";
};
systemd.user.services = mkOption {
default = {};
type = with types; attrsOf (submodule [ { options = serviceOptions; } unitConfig serviceConfig ] );
description = "Definition of systemd per-user service units.";
};
systemd.user.slices = mkOption {
default = {};
type = with types; attrsOf (submodule [ { options = sliceOptions; } unitConfig ] );
description = "Definition of systemd per-user slice units.";
};
systemd.user.sockets = mkOption {
default = {};
type = with types; attrsOf (submodule [ { options = socketOptions; } unitConfig ] );
description = "Definition of systemd per-user socket units.";
};
systemd.user.targets = mkOption {
default = {};
type = with types; attrsOf (submodule [ { options = targetOptions; } unitConfig] );
description = "Definition of systemd per-user target units.";
};
systemd.user.timers = mkOption {
default = {};
type = with types; attrsOf (submodule [ { options = timerOptions; } unitConfig ] );
description = "Definition of systemd per-user timer units.";
};
systemd.additionalUpstreamUserUnits = mkOption {
default = [];
type = types.listOf types.str;
example = [];
description = ''
Additional units shipped with systemd that should be enabled for per-user systemd instances.
'';
internal = true;
};
};
config = {
systemd.additionalUpstreamSystemUnits = [
"user.slice"
];
environment.etc = {
"systemd/user".source = generateUnits "user" cfg.units upstreamUserUnits [];
"systemd/user.conf".text = ''
[Manager]
${cfg.extraConfig}
'';
};
systemd.user.units =
mapAttrs' (n: v: nameValuePair "${n}.path" (pathToUnit n v)) cfg.paths
// mapAttrs' (n: v: nameValuePair "${n}.service" (serviceToUnit n v)) cfg.services
// mapAttrs' (n: v: nameValuePair "${n}.slice" (sliceToUnit n v)) cfg.slices
// mapAttrs' (n: v: nameValuePair "${n}.socket" (socketToUnit n v)) cfg.sockets
// mapAttrs' (n: v: nameValuePair "${n}.target" (targetToUnit n v)) cfg.targets
// mapAttrs' (n: v: nameValuePair "${n}.timer" (timerToUnit n v)) cfg.timers;
# Generate timer units for all services that have a ‘startAt’ value.
systemd.user.timers =
mapAttrs (name: service: {
wantedBy = ["timers.target"];
timerConfig.OnCalendar = service.startAt;
})
(filterAttrs (name: service: service.startAt != []) cfg.services);
# Provide the systemd-user PAM service, required to run systemd
# user instances.
security.pam.services.systemd-user =
{ # Ensure that pam_systemd gets included. This is special-cased
# in systemd to provide XDG_RUNTIME_DIR.
startSession = true;
};
# Some overrides to upstream units.
systemd.services."user@".restartIfChanged = false;
systemd.services.systemd-user-sessions.restartIfChanged = false; # Restart kills all active sessions.
};
}

1
nixos/tests/all-tests.nix
View file

@ -356,6 +356,7 @@ in
nginx-sso = handleTest ./nginx-sso.nix {};
nginx-variants = handleTest ./nginx-variants.nix {};
nitter = handleTest ./nitter.nix {};
nix-ld = handleTest ./nix-ld {};
nix-serve = handleTest ./nix-serve.nix {};
nix-serve-ssh = handleTest ./nix-serve-ssh.nix {};
nixops = handleTest ./nixops/default.nix {};

50
nixos/tests/keepassxc.nix
View file

@ -15,20 +15,54 @@ import ./make-test-python.nix ({ pkgs, ...} :
];
services.xserver.enable = true;
# Regression test for https://github.com/NixOS/nixpkgs/issues/163482
qt5 = {
enable = true;
platformTheme = "gnome";
style = "adwaita-dark";
};
test-support.displayManager.auto.user = "alice";
environment.systemPackages = [ pkgs.keepassxc ];
environment.systemPackages = with pkgs; [
keepassxc
xdotool
];
};
enableOCR = true;
testScript = { nodes, ... }: ''
start_all()
machine.wait_for_x()
testScript = { nodes, ... }: let
aliceDo = cmd: ''machine.succeed("su - alice -c '${cmd}' >&2 &");'';
in ''
with subtest("Ensure X starts"):
start_all()
machine.wait_for_x()
# start KeePassXC window
machine.execute("su - alice -c keepassxc >&2 &")
with subtest("Can create database and entry with CLI"):
${aliceDo "keepassxc-cli db-create -k foo.keyfile foo.kdbx"}
${aliceDo "keepassxc-cli add --no-password -k foo.keyfile foo.kdbx bar"}
machine.wait_for_text("KeePassXC ${pkgs.keepassxc.version}")
machine.screenshot("KeePassXC")
with subtest("Ensure KeePassXC starts"):
# start KeePassXC window
${aliceDo "keepassxc >&2 &"}
machine.wait_for_text("KeePassXC ${pkgs.keepassxc.version}")
machine.screenshot("KeePassXC")
with subtest("Can open existing database"):
machine.send_key("ctrl-o")
machine.sleep(5)
# Regression #163482: keepassxc did not crash
machine.succeed("ps -e | grep keepassxc")
machine.wait_for_text("foo.kdbx")
machine.send_key("ret")
machine.sleep(1)
# Click on "Browse" button to select keyfile
machine.send_key("tab")
machine.send_chars("/home/alice/foo.keyfile")
machine.send_key("ret")
# Passwords folder is displayed
machine.wait_for_text("Passwords")
'';
})

20
nixos/tests/nix-ld.nix Normal file
View file

@ -0,0 +1,20 @@
import ./make-test-python.nix ({ lib, pkgs, ...} :
{
name = "nix-ld";
nodes.machine = { pkgs, ... }: {
programs.nix-ld.enable = true;
environment.systemPackages = [
(pkgs.runCommand "patched-hello" {} ''
install -D -m755 ${pkgs.hello}/bin/hello $out/bin/hello
patchelf $out/bin/hello --set-interpreter ${pkgs.nix-ld.ldPath}
'')
];
};
testScript = ''
start_all()
path = "${pkgs.stdenv.cc}/nix-support/dynamic-linker"
with open(path) as f:
real_ld = f.read().strip()
machine.succeed(f"NIX_LD={real_ld} hello")
'';
})

30
nixos/tests/switch-test.nix
View file

@ -51,6 +51,12 @@ in {
environment.systemPackages = [ pkgs.socat ]; # for the socket activation stuff
users.mutableUsers = false;
# For boot/switch testing
system.build.installBootLoader = lib.mkForce (pkgs.writeShellScript "install-dummy-loader" ''
echo "installing dummy bootloader"
touch /tmp/bootloader-installed
'');
specialisation = rec {
simpleService.configuration = {
systemd.services.test = {
@ -502,10 +508,33 @@ in {
machine.succeed(
"${stderrRunner} ${originalSystem}/bin/switch-to-configuration test"
)
# This tests whether the /etc/os-release parser works which is a fallback
# when /etc/NIXOS is missing. If the parser does not work, switch-to-configuration
# would fail.
machine.succeed("rm /etc/NIXOS")
machine.succeed(
"${stderrRunner} ${otherSystem}/bin/switch-to-configuration test"
)
with subtest("actions"):
# boot action
machine.fail("test -f /tmp/bootloader-installed")
out = switch_to_specialisation("${machine}", "simpleService", action="boot")
assert_contains(out, "installing dummy bootloader")
assert_lacks(out, "activating the configuration...") # good indicator of a system activation
machine.succeed("test -f /tmp/bootloader-installed")
machine.succeed("rm /tmp/bootloader-installed")
# switch action
machine.fail("test -f /tmp/bootloader-installed")
out = switch_to_specialisation("${machine}", "", action="switch")
assert_contains(out, "installing dummy bootloader")
assert_contains(out, "activating the configuration...") # good indicator of a system activation
machine.succeed("test -f /tmp/bootloader-installed")
# test and dry-activate actions are tested further down below
with subtest("services"):
switch_to_specialisation("${machine}", "")
# Nothing happens when nothing is changed
@ -519,6 +548,7 @@ in {
# Start a simple service
out = switch_to_specialisation("${machine}", "simpleService")
assert_lacks(out, "installing dummy bootloader") # test does not install a bootloader
assert_lacks(out, "stopping the following units:")
assert_lacks(out, "NOT restarting the following changed units:")
assert_contains(out, "reloading the following units: dbus.service\n") # huh

15
pkgs/applications/audio/friture/default.nix
View file

@ -1,16 +1,16 @@
{ lib, fetchFromGitHub, fetchpatch, python3Packages, wrapQtAppsHook }:
{ lib, fetchFromGitHub, python3Packages, wrapQtAppsHook }:
let
py = python3Packages;
in py.buildPythonApplication rec {
pname = "friture";
version = "0.48";
version = "0.49";
src = fetchFromGitHub {
owner = "tlecomte";
repo = pname;
rev = "v${version}";
sha256 = "sha256-oOH58jD49xAeSuP+l6tYUpwkYsnfeSGTt8x4DFzTY6g=";
sha256 = "sha256-xKgyBV/Qc+9PgXyxcT0xG1GXLC6KnjavJ/0SUE+9VSY=";
};
nativeBuildInputs = (with py; [ numpy cython scipy ]) ++
@ -28,15 +28,6 @@ in py.buildPythonApplication rec {
rtmixer
];
patches = [
# Backported fix that resolves an issue with setuptools packaging
(fetchpatch {
name = "fix-setuptools-packaging.patch";
url = "https://github.com/tlecomte/friture/commit/ea7210dae883edf17de8fec82f9428b18ee138b6.diff";
sha256 = "sha256-Kv/vmC8kcqfOgfIPQyZN46sbV6bezhq6pyj8bvke6s8=";
})
];
postPatch = ''
# Remove version constraints from Python dependencies in setup.py
sed -i -E "s/\"([A-Za-z0-9]+)(=|>|<)=[0-9\.]+\"/\"\1\"/g" setup.py

29
pkgs/applications/audio/furnace/default.nix
View file

@ -1,8 +1,9 @@
{ stdenv
, lib
, nix-update-script
, gitUpdater
, testVersion
, furnace
, fetchFromGitHub
, fetchpatch
, cmake
, pkg-config
, makeWrapper
@ -18,24 +19,16 @@
stdenv.mkDerivation rec {
pname = "furnace";
version = "0.5.6";
version = "0.5.8";
src = fetchFromGitHub {
owner = "tildearrow";
repo = "furnace";
rev = "v${version}";
fetchSubmodules = true;
sha256 = "sha256-BcaPQuDFkAaxFQKwoI6xdSWcyHo5VsqZcwf++JISqRs=";
sha256 = "103ymd3wa1sfsr6qg15vpcs53j350i7zidv3azlf7cynk6k28xim";
};
patches = [
(fetchpatch {
name = "0001-furnace-fix-wrong-include-path.patch";
url = "https://github.com/tildearrow/furnace/commit/456db22f9d9f0ed40d74fe50dde492e69e901fcc.patch";
sha256 = "17ikb1z9ldm7kdj00m4swsrq1qx94vlzhc6h020x3ryzwnglc8d3";
})
];
postPatch = ''
# rtmidi is not used yet
sed -i -e '/add_subdirectory(extern\/rtmidi/d' -e '/DEPENDENCIES_LIBRARIES rtmidi/d' CMakeLists.txt
@ -85,8 +78,16 @@ stdenv.mkDerivation rec {
cp -r ../demos $out/share/furnace/
'';
passthru.updateScript = nix-update-script {
attrPath = pname;
passthru = {
updateScript = gitUpdater {
inherit pname version;
rev-prefix = "v";
};
tests.version = testVersion {
package = furnace;
# The command always exits with code 1
command = "(furnace --version || [ $? -eq 1 ])";
};
};
meta = with lib; {

4
pkgs/applications/audio/pyradio/default.nix
View file

@ -2,7 +2,7 @@
python3Packages.buildPythonApplication rec {
pname = "pyradio";
version = "0.8.9.15";
version = "0.8.9.16";
propagatedBuildInputs = with python3Packages; [
requests
@ -14,7 +14,7 @@ python3Packages.buildPythonApplication rec {
owner = "coderholic";
repo = pname;
rev = version;
sha256 = "sha256-r4T7t8Q46N59jqTkvdKBo6tffkrOYhoO/CZWvkBHOAQ=";
sha256 = "sha256-uerQfyGHWhLbO6UkLSMA1tdfW/8fDQkcm6hYIdwwC7I=";
};
checkPhase = ''

6
pkgs/applications/audio/spotify/default.nix
View file

@ -10,14 +10,14 @@ let
# If an update breaks things, one of those might have valuable info:
# https://aur.archlinux.org/packages/spotify/
# https://community.spotify.com/t5/Desktop-Linux
version = "1.1.77.643.g3c4c6fc6";
version = "1.1.80.699.gc3dac750";
# To get the latest stable revision:
# curl -H 'X-Ubuntu-Series: 16' 'https://api.snapcraft.io/api/v1/snaps/details/spotify?channel=stable' | jq '.download_url,.version,.last_updated'
# To get general information:
# curl -H 'Snap-Device-Series: 16' 'https://api.snapcraft.io/v2/snaps/info/spotify' | jq '.'
# More examples of api usage:
# https://github.com/canonical-websites/snapcraft.io/blob/master/webapp/publisher/snaps/views.py
rev = "57";
rev = "58";
deps = [
alsa-lib
@ -80,7 +80,7 @@ stdenv.mkDerivation {
# https://community.spotify.com/t5/Desktop-Linux/Redistribute-Spotify-on-Linux-Distributions/td-p/1695334
src = fetchurl {
url = "https://api.snapcraft.io/api/v1/snaps/download/pOBIoZ2LrCB3rDohMxoYGnbN14EHOgD7_${rev}.snap";
sha512 = "d9f8fe692db479bcce1f47c87b65c5ac6d62e16b76a0f9b2d693d82d2b9ed2c7cf370cb091ce8ecd291c47d1efdbaa897c9bffb210edd901dc3d5425995229f7";
sha512 = "91385a5a8de31d6e9f1945d23108447fd369c1cdc2e4d95cbb7cec5d403c3be14a1b0fabe3fb01aef809a39b033d289add1bcb307ab19c7fcb63689dbae57c53";
};
nativeBuildInputs = [ makeWrapper wrapGAppsHook squashfsTools ];

27
pkgs/applications/editors/vscode/extensions/rust-analyzer/build-deps/package.json
View file

@ -1,26 +1,19 @@
{
"name": "rust-analyzer",
"version": "0.2.834",
"version": "0.2.975",
"dependencies": {
"https-proxy-agent": "^5.0.0",
"node-fetch": "^2.6.1",
"vscode-languageclient": "8.0.0-next.2",
"d3": "^7.1.0",
"vscode-languageclient": "8.0.0-next.8",
"d3": "^7.3.0",
"d3-graphviz": "^4.0.0",
"@types/glob": "^7.1.4",
"@types/mocha": "^8.2.3",
"@types/node": "~14.17.5",
"@types/node-fetch": "^2.5.11",
"@types/vscode": "^1.57.0",
"@typescript-eslint/eslint-plugin": "^4.28.2",
"@typescript-eslint/parser": "^4.28.2",
"eslint": "^7.30.0",
"glob": "^7.1.6",
"mocha": "^9.0.2",
"@types/vscode": "~1.63.0",
"@typescript-eslint/eslint-plugin": "^5.10.0",
"@typescript-eslint/parser": "^5.10.0",
"@vscode/test-electron": "^2.1.1",
"eslint": "^8.7.0",
"tslib": "^2.3.0",
"typescript": "^4.3.5",
"typescript": "^4.5.5",
"typescript-formatter": "^7.2.2",
"vsce": "^1.95.1",
"vscode-test": "^1.5.1"
"vsce": "^2.6.7"
}
}

4
pkgs/applications/editors/vscode/extensions/rust-analyzer/default.nix
View file

@ -20,13 +20,13 @@ let
# Use the plugin version as in vscode marketplace, updated by update script.
inherit (vsix) version;
releaseTag = "2021-11-29";
releaseTag = "2022-03-07";
src = fetchFromGitHub {
owner = "rust-analyzer";
repo = "rust-analyzer";
rev = releaseTag;
sha256 = "sha256-vh7z8jupVxXPOko3sWUsOB7eji/7lKfwJ/CE3iw97Sw=";
sha256 = "sha256-/qKh4utesAjlyG8A3hEmSx+HBgh48Uje6ZRtUGz5f0g=";
};
build-deps = nodePackages."rust-analyzer-build-deps-../../applications/editors/vscode/extensions/rust-analyzer/build-deps";

49
pkgs/applications/editors/vscode/extensions/rust-analyzer/update.sh Executable file
View file

@ -0,0 +1,49 @@
#!/usr/bin/env nix-shell
#!nix-shell -i bash -p curl jq libarchive
#shellcheck shell=bash
set -euo pipefail
cd "$(dirname "$0")"
nixpkgs=../../../../../../
node_packages="$nixpkgs/pkgs/development/node-packages"
owner=rust-analyzer
repo=rust-analyzer
ver=$(
curl -s "https://api.github.com/repos/$owner/$repo/releases" |
jq 'map(select(.prerelease | not)) | .[0].tag_name' --raw-output
)
node_src="$(nix-build "$nixpkgs" -A rust-analyzer.src --no-out-link)/editors/code"
# Check vscode compatibility
req_vscode_ver="$(jq '.engines.vscode' "$node_src/package.json" --raw-output)"
req_vscode_ver="${req_vscode_ver#^}"
cur_vscode_ver="$(nix-instantiate --eval --strict "$nixpkgs" -A vscode.version | tr -d '"')"
if [[ "$(nix-instantiate --eval --strict -E "(builtins.compareVersions \"$req_vscode_ver\" \"$cur_vscode_ver\")")" -gt 0 ]]; then
echo "vscode $cur_vscode_ver is incompatible with the extension requiring ^$req_vscode_ver"
exit 1
fi
extension_ver=$(curl "https://github.com/rust-analyzer/rust-analyzer/releases/download/$ver/rust-analyzer-linux-x64.vsix" -L |
bsdtar -xf - --to-stdout extension/package.json | # Use bsdtar to extract vsix(zip).
jq --raw-output '.version')
echo "Extension version: $extension_ver"
# We need devDependencies to build vsix.
# `esbuild` is a binary package an is already in nixpkgs so we omit it here.
jq '{ name, version: $ver, dependencies: (.dependencies + .devDependencies | del(.esbuild)) }' "$node_src/package.json" \
--arg ver "$extension_ver" \
>"build-deps/package.json.new"
old_deps="$(jq '.dependencies' build-deps/package.json)"
new_deps="$(jq '.dependencies' build-deps/package.json.new)"
if [[ "$old_deps" == "$new_deps" ]]; then
echo "package.json dependencies not changed, do simple version change"
sed -E '/^ "rust-analyzer-build-deps/,+3 s/version = ".*"/version = "'"$extension_ver"'"/' \
--in-place "$node_packages"/node-packages.nix
mv build-deps/package.json{.new,}
else
echo "package.json dependencies changed, updating nodePackages"
mv build-deps/package.json{.new,}
./"$node_packages"/generate.sh
fi

8
pkgs/applications/emulators/yuzu/default.nix
View file

@ -4,25 +4,25 @@ let
in {
mainline = libsForQt5.callPackage ./base.nix rec {
pname = "yuzu-mainline";
version = "882";
version = "953";
branchName = branch;
src = fetchFromGitHub {
owner = "yuzu-emu";
repo = "yuzu-mainline";
rev = "mainline-0-${version}";
sha256 = "17j845laxnaq50icwl32yisdivwcnwa59fxdr297yxrz4hmfzhxq";
sha256 = "0p07gybyhr6flzmhz92qlrwcq7l37c2wmcxw8sbrvhj2pgaaw9ic";
fetchSubmodules = true;
};
};
early-access = libsForQt5.callPackage ./base.nix rec {
pname = "yuzu-ea";
version = "2432";
version = "2557";
branchName = branch;
src = fetchFromGitHub {
owner = "pineappleEA";
repo = "pineapple-src";
rev = "EA-${version}";
sha256 = "0zqab61rphgjzyxk52idhr7dqwwxih0f8b9hig3zvrwkdry9wfh4";
sha256 = "013xxgyn8y5fv0xbrm0zfl9xmi0gx4hpflrbjskg1hcvb2bjqyvj";
};
};
}.${branch}

22
pkgs/applications/misc/1password-gui/default.nix
View file

@ -30,14 +30,23 @@
, systemd
, udev
, xdg-utils
# The 1Password polkit file requires a list of users for whom polkit
# integrations should be enabled. This should be a list of strings that
# correspond to usernames.
, polkitPolicyOwners ? []
}:
stdenv.mkDerivation rec {
let
# Convert the polkitPolicyOwners variable to a polkit-compatible string for the polkit file.
policyOwners = lib.concatStringsSep " " (map (user: "unix-user:${user}") polkitPolicyOwners);
in stdenv.mkDerivation rec {
pname = "1password";
version = "8.5.0";
version = "8.6.0";
src = fetchurl {
url = "https://downloads.1password.com/linux/tar/stable/x86_64/1password-${version}.x64.tar.gz";
sha256 = "tnZr+qjUcJ9Fhk6RP8iwu+/JsvYSE03NHhBfhedyCTQ=";
sha256 = "AgmLbf2YHZr8McSIL5dxp5HxOC7gLrZWIopuA7aL0JI=";
};
nativeBuildInputs = [ makeWrapper ];
@ -86,9 +95,12 @@ stdenv.mkDerivation rec {
substituteInPlace $out/share/applications/${pname}.desktop \
--replace 'Exec=/opt/1Password/${pname}' 'Exec=${pname}'
'' + (lib.optionalString (polkitPolicyOwners != [ ])
''
# Polkit file
install -Dm 0644 -t $out/share/polkit-1/actions com.1password.1Password.policy
mkdir -p $out/share/polkit-1/actions
substitute com.1password.1Password.policy.tpl $out/share/polkit-1/actions/com.1password.1Password.policy --replace "\''${POLICY_OWNERS}" "${policyOwners}"
'') + ''
# Icons
cp -a resources/icons $out/share

19
pkgs/applications/misc/bottles/default.nix
View file

@ -4,7 +4,7 @@
, python3Packages, gettext
, appstream-glib, gdk-pixbuf, glib, gobject-introspection, gspell, gtk3, gtksourceview4, gnome
, steam, xdg-utils, pciutils, cabextract, wineWowPackages
, freetype, p7zip, gamemode
, freetype, p7zip, gamemode, mangohud
, bottlesExtraLibraries ? pkgs: [ ] # extra packages to add to steam.run multiPkgs
, bottlesExtraPkgs ? pkgs: [ ] # extra packages to add to steam.run targetPkgs
}:
@ -12,7 +12,7 @@
let
steam-run = (steam.override {
# required by wine runner `caffe`
extraLibraries = pkgs: with pkgs; [ libunwind libusb1 ]
extraLibraries = pkgs: with pkgs; [ libunwind libusb1 gnutls ]
++ bottlesExtraLibraries pkgs;
extraPkgs = pkgs: [ ]
++ bottlesExtraPkgs pkgs;
@ -20,8 +20,10 @@ let
in
python3Packages.buildPythonApplication rec {
pname = "bottles";
version = "2022.2.28-trento-1";
sha256 = "tE6YuuZZcs3RKxs1S6OoGt0CXz3oHUi/sopFN0iywds=";
version = "2022.3.14-trento-3";
sha256 = "0wdqj9l69a9pnray2zcfgl2yw0hmrh23njbgwgqccimch014ckdq";
# Note: Update via pkgs/applications/misc/bottles/update.py
# mostly copypasted from pkgs/applications/networking/instant-messengers/telegram/tdesktop/update.py
src = fetchFromGitHub {
owner = "bottlesdevs";
@ -80,6 +82,7 @@ python3Packages.buildPythonApplication rec {
freetype
p7zip
gamemode # programs.gamemode.enable
mangohud
];
format = "other";
@ -89,13 +92,19 @@ python3Packages.buildPythonApplication rec {
preConfigure = ''
patchShebangs build-aux/meson/postinstall.py
substituteInPlace src/backend/wine/winecommand.py \
--replace '= f"{Paths.runners}' '= f"${steam-run}/bin/steam-run {Paths.runners}'
--replace \
'self.__get_runner()' \
'(lambda r: (f"${steam-run}/bin/steam-run {r}", r)[r == "wine" or r == "wine64"])(self.__get_runner())'
'';
preFixup = ''
makeWrapperArgs+=("''${gappsWrapperArgs[@]}")
'';
passthru = {
updateScript = ./update.py;
};
meta = with lib; {
description = "An easy-to-use wineprefix manager";
homepage = "https://usebottles.com/";

65
pkgs/applications/misc/bottles/update.py Executable file
View file

@ -0,0 +1,65 @@
#! /usr/bin/env nix-shell
#! nix-shell -i python3 -p python3 nix nix-prefetch-git
import fileinput
import json
import os
import re
import subprocess
from datetime import datetime
from urllib.request import urlopen, Request
DIR = os.path.dirname(os.path.abspath(__file__))
HEADERS = {'Accept': 'application/vnd.github.v3+json'}
def github_api_request(endpoint):
base_url = 'https://api.github.com/'
request = Request(base_url + endpoint, headers=HEADERS)
with urlopen(request) as http_response:
return json.loads(http_response.read().decode('utf-8'))
def get_commit_date(repo, sha):
url = f'https://api.github.com/repos/{repo}/commits/{sha}'
request = Request(url, headers=HEADERS)
with urlopen(request) as http_response:
commit = json.loads(http_response.read().decode())
date = commit['commit']['committer']['date'].rstrip('Z')
date = datetime.fromisoformat(date).date().isoformat()
return 'unstable-' + date
def nix_prefetch_git(url, rev):
"""Prefetches the requested Git revision (incl. submodules) of the given repository URL."""
print(f'nix-prefetch-git {url} {rev}')
out = subprocess.check_output(['nix-prefetch-git', '--quiet', '--url', url, '--rev', rev, '--fetch-submodules'])
return json.loads(out)['sha256']
def nix_prefetch_url(url, unpack=False):
"""Prefetches the content of the given URL."""
print(f'nix-prefetch-url {url}')
options = ['--type', 'sha256']
if unpack:
options += ['--unpack']
out = subprocess.check_output(['nix-prefetch-url'] + options + [url])
return out.decode('utf-8').rstrip()
def update_file(relpath, version, sha256):
file_path = os.path.join(DIR, relpath)
with fileinput.FileInput(file_path, inplace=True) as f:
for line in f:
result = line
result = re.sub(r'^ version = ".+";', f' version = "{version}";', result)
result = re.sub(r'^ sha256 = ".+";', f' sha256 = "{sha256}";', result)
print(result, end='')
if __name__ == "__main__":
bottles_version = github_api_request('repos/bottlesdevs/Bottles/releases/latest')['tag_name']
bottles_hash = nix_prefetch_git('https://github.com/bottlesdevs/Bottles.git', bottles_version)
update_file('default.nix', bottles_version, bottles_hash)

4
pkgs/applications/misc/dbeaver/default.nix
View file

@ -20,13 +20,13 @@
stdenv.mkDerivation rec {
pname = "dbeaver";
version = "22.0.0"; # When updating also update fetchedMavenDeps.sha256
version = "22.0.1"; # When updating also update fetchedMavenDeps.sha256
src = fetchFromGitHub {
owner = "dbeaver";
repo = "dbeaver";
rev = version;
sha256 = "sha256-LSEsaCEUoKViKC+IjJrV/w1VzOGi4EOr4LnAutOIyJU=";
sha256 = "sha256-IG5YWwq3WVzQBvAslQ9Z2Ou6ADzf4n9NkQCtH4Jgkac=";
};
fetchedMavenDeps = stdenv.mkDerivation {

5
pkgs/applications/misc/electron-cash/default.nix
View file

@ -3,13 +3,13 @@
python3Packages.buildPythonApplication rec {
pname = "electron-cash";
version = "4.2.5";
version = "4.2.7";
src = fetchFromGitHub {
owner = "Electron-Cash";
repo = "Electron-Cash";
rev = version;
sha256 = "sha256-ALIrNnhpX46xdQdfJdx/9e/QtdyBEgi5xLrbuOBJR7o=";
sha256 = "sha256-m8a3x5fPSrnrCH30MToT3aKtX35nFUbeerR7ubWgOOI=";
};
propagatedBuildInputs = with python3Packages; [
@ -40,6 +40,7 @@ python3Packages.buildPythonApplication rec {
keepkey
btchip
hidapi
pyopenssl
pyscard
pysatochip
];

56
pkgs/applications/misc/faircamp/default.nix Normal file
View file

@ -0,0 +1,56 @@
{ lib
, rustPlatform
, fetchgit
, makeWrapper
, ffmpeg
, callPackage
, unstableGitUpdater
}:
rustPlatform.buildRustPackage {
pname = "faircamp";
version = "unstable-2022-01-19";
# TODO when switching to a stable release, use fetchFromGitea and add a
# version test. Meanwhile, fetchgit is used to make unstableGitUpdater work.
src = fetchgit {
url = "https://codeberg.org/simonrepp/faircamp.git";
rev = "f8ffc7a35a12251b83966b35c63f72b4912f75a9";
sha256 = "sha256-9t42+813IPLUChbLkcwzoCr7FXSL1g+ZG6I3d+7pmec=";
};
cargoHash = "sha256-24ALBede3W8rjlBRdtL0aazRyK1RmNLdHF/bt5i4S5Y=";
nativeBuildInputs = [
makeWrapper
];
postInstall = ''
wrapProgram $out/bin/faircamp \
--prefix PATH : ${lib.makeBinPath [ ffmpeg ]}
'';
passthru.tests.wav = callPackage ./test-wav.nix { };
passthru.updateScript = unstableGitUpdater { };
meta = with lib; {
description = "A self-hostable, statically generated bandcamp alternative";
longDescription = ''
Faircamp takes a directory on your disk - your Catalog - and from it
produces a fancy-looking (and technically simple and completely static)
website, which presents your music in a way similar to how popular
commercial service bandcamp does it.
You can upload the files faircamp generates to any webspace - no database
and no programming language support (PHP or such) is required. If your
webspace supports SSH access, faircamp can be configured to upload your
website for you automatically, otherwise you can use FTP or whichever
means you prefer to do that manually.
'';
homepage = "https://codeberg.org/simonrepp/faircamp";
license = licenses.gpl3Plus;
maintainers = with maintainers; [ fgaz ];
platforms = platforms.all;
};
}

14
pkgs/applications/misc/faircamp/test-wav.nix Normal file
View file

@ -0,0 +1,14 @@
{ stdenv
, faircamp
, ffmpeg
}:
stdenv.mkDerivation {
name = "faircamp-test-wav";
meta.timeout = 60;
buildCommand = ''
mkdir album
${ffmpeg}/bin/ffmpeg -f lavfi -i "sine=frequency=440:duration=1" album/track.wav
${faircamp}/bin/faircamp --build-dir $out
'';
}

3
pkgs/applications/misc/keepassx/community.nix
View file

@ -22,6 +22,7 @@
, qtx11extras
, quazip
, readline
, wrapGAppsHook
, wrapQtAppsHook
, yubikey-personalization
, zlib
@ -90,7 +91,7 @@ stdenv.mkDerivation rec {
runHook postCheck
'';
nativeBuildInputs = [ asciidoctor cmake wrapQtAppsHook qttools pkg-config ];
nativeBuildInputs = [ asciidoctor cmake wrapGAppsHook wrapQtAppsHook qttools pkg-config ];
buildInputs = [
curl

16
pkgs/applications/networking/browsers/chromium/upstream-info.json
View file

@ -1,8 +1,8 @@
{
"stable": {
"version": "99.0.4844.74",
"sha256": "165vzxv3xi4r9ia3qnqsr4p9ai0344w1pnq03c6jdq7x613lcprd",
"sha256bin64": "1xzr7qv4rcardl3apr8w22dn81lzqkklhp26qqlbdcylacqqji04",
"version": "99.0.4844.82",
"sha256": "0p6jqwal0yrvn8iylm2f3n07hkkaf8899iw9i3cvks0d870hpfxq",
"sha256bin64": "0zhhibz727qx2wg2pcazha3q9xwf1bcm1f9hgid7jq2pq7fq3hdr",
"deps": {
"gn": {
"version": "2022-01-10",
@ -45,9 +45,9 @@
}
},
"ungoogled-chromium": {
"version": "99.0.4844.74",
"sha256": "165vzxv3xi4r9ia3qnqsr4p9ai0344w1pnq03c6jdq7x613lcprd",
"sha256bin64": "1xzr7qv4rcardl3apr8w22dn81lzqkklhp26qqlbdcylacqqji04",
"version": "99.0.4844.82",
"sha256": "0p6jqwal0yrvn8iylm2f3n07hkkaf8899iw9i3cvks0d870hpfxq",
"sha256bin64": "0zhhibz727qx2wg2pcazha3q9xwf1bcm1f9hgid7jq2pq7fq3hdr",
"deps": {
"gn": {
"version": "2022-01-10",
@ -56,8 +56,8 @@
"sha256": "1103lf38h7412949j6nrk48m2vv2rrxacn42sjg33lg88nyv7skv"
},
"ungoogled-patches": {
"rev": "99.0.4844.74-1",
"sha256": "1ki517fi55rz7ib2sq0q6gw1w1m2j4yakkpcgpmgvapg05s3zg7m"
"rev": "99.0.4844.82-1",
"sha256": "1zj8834slli7ydslcwid15r7id4iw0d7ns42hkrj24zl9zh3d5q3"
}
}
}

10
pkgs/applications/networking/browsers/firefox/librewolf/src.json
View file

@ -1,11 +1,11 @@
{
"packageVersion": "97.0.2-1",
"packageVersion": "98.0-1",
"source": {
"rev": "97.0.2-1",
"sha256": "0pk9ci0wvz61879w3fvy8p1w4w8anv5s7rfiimz21m351gcf3d7m"
"rev": "98.0-1",
"sha256": "1z42a42d6z0gyc5i0pamcqq5bak6pgg1ldvlrjdyjnpvda74s0fn"
},
"firefox": {
"version": "97.0.2",
"sha512": "efbf33723f5979025454b6cc183927afb4bc72a51c00b5d45940122da596b8ac99080f3a6a59f5dd85a725e356349ec57e7eba1c36cdab7d55a28b04895d274c"
"version": "98.0",
"sha512": "5b9186dd2a5dee5f2d2a2ce156fc06e2073cf71a70891a294cf3358218592f19ec3413d33b68d6f38e3cc5f940213e590a188e2b6efc39f416e90a55f89bfd9b"
}
}

4
pkgs/applications/networking/browsers/vivaldi/default.nix
View file

@ -20,11 +20,11 @@ let
vivaldiName = if isSnapshot then "vivaldi-snapshot" else "vivaldi";
in stdenv.mkDerivation rec {
pname = "vivaldi";
version = "5.1.2567.49-1";
version = "5.1.2567.66-1";
src = fetchurl {
url = "https://downloads.vivaldi.com/${branch}/vivaldi-${branch}_${version}_amd64.deb";
sha256 = "1cyd789apjh71vzry2zjxb0c215yarfryb9jzxjmkfvrqg4g23xr";
sha256 = "1v9hcjgvblscpsw8c2nm8x7frzkfv2ph8l5hibyidnfjppx1qqz2";
};
unpackPhase = ''

6
pkgs/applications/networking/browsers/vivaldi/ffmpeg-codecs.nix
View file

@ -2,11 +2,11 @@
stdenv.mkDerivation rec {
pname = "chromium-codecs-ffmpeg-extra";
version = "97.0.4692.56";
version = "97.0.4692.71";
src = fetchurl {
url = "https://launchpadlibrarian.net/574348729/${pname}_${version}-0ubuntu0.18.04.1_amd64.deb";
sha256 = "sha256-v5DHJxQjHjBeIS/psaM+LyUaHKlwzrKncLarErbUGVU=";
url = "https://launchpadlibrarian.net/579085093/${pname}_${version}-0ubuntu0.18.04.1_amd64.deb";
sha256 = "sha256-YUv1D8U776NJBRPvYJigG7gyH9zd19FbnjAvIEhfYpA=";
};
buildInputs = [ dpkg ];

6
pkgs/applications/networking/browsers/vivaldi/update.sh
View file

@ -36,9 +36,13 @@ git commit -m "vivaldi: ${vivaldi_version_old} -> ${vivaldi_version}"
# Check vivaldi-ffmpeg-codecs version.
chromium_version_old=$(version vivaldi-ffmpeg-codecs)
chromium_version=$(bsdtar xOf "$path" data.tar.xz | bsdtar xOf - ./opt/vivaldi/vivaldi-bin | strings | grep '^[0-9]\{2,\}\.[0-9]\+\.[0-9]\{4,\}\+\.[0-9]\+$')
ffmpeg_update_script=$(bsdtar xOf "$path" data.tar.xz | bsdtar xOf - ./opt/vivaldi/update-ffmpeg)
chromium_version=$(sed -rne 's/FFMPEG_VERSION_DEB\=([0-9]+\.[0-9]+\.[0-9]+\.[0-9]+).*/\1/p' <<< $ffmpeg_update_script)
download_subdir=$(sed -rne 's/.*FFMPEG_URL_DEB\=https:\/\/launchpadlibrarian\.net\/([0-9]+)\/.*_amd64\.deb/\1/p' <<< $ffmpeg_update_script)
if [[ "$chromium_version" != "$chromium_version_old" ]]; then
# replace the download prefix
sed -i $ffmpeg_nix -e "s/\(https:\/\/launchpadlibrarian\.net\/\)[0-9]\+/\1$download_subdir/g"
(cd "$root" && update-source-version vivaldi-ffmpeg-codecs "$chromium_version")
git add "${ffmpeg_nix}"

109
pkgs/applications/networking/browsers/webbrowser/default.nix
View file

@ -1,109 +0,0 @@
{ stdenv, lib, fetchgit, makeDesktopItem, pkg-config, makeWrapper
# Build
, python2, autoconf213, yasm, perl
, unzip, gnome2, gnum4
# Runtime
, xorg, zip, freetype, fontconfig, glibc, libffi
, dbus, dbus-glib, gtk2, alsa-lib, jack2, ffmpeg
}:
let
libPath = lib.makeLibraryPath [ ffmpeg ];
in stdenv.mkDerivation rec {
pname = "webbrowser";
version = "29.0.0rc1";
src = fetchgit {
url = "https://git.nuegia.net/webbrowser.git";
rev = version;
sha256 = "1d82943mla6q3257081d946kgms91dg0n93va3zlzm9hbbqilzm6";
fetchSubmodules = true;
};
desktopItem = makeDesktopItem {
name = "webbrowser";
exec = "webbrowser %U";
icon = "webbrowser";
desktopName = "Web Browser";
genericName = "Web Browser";
categories = [ "Network" "WebBrowser" ];
mimeTypes = [
"text/html"
"text/xml"
"application/xhtml+xml"
"application/vnd.mozilla.xul+xml"
"x-scheme-handler/http"
"x-scheme-handler/https"
];
};
nativeBuildInputs = [
gnum4 makeWrapper perl pkg-config python2 unzip
];
buildInputs = [
alsa-lib dbus dbus-glib ffmpeg fontconfig freetype yasm zip jack2 gtk2
gnome2.GConf xorg.libXt
];
enableParallelBuilding = true;
configurePhase = ''
export MOZCONFIG=$PWD/.mozconfig
export MOZ_NOSPAM=1
cp $src/doc/mozconfig.example $MOZCONFIG
# Need to modify it
chmod 644 $MOZCONFIG
substituteInPlace $MOZCONFIG \
--replace "mk_add_options PYTHON=/usr/bin/python2" "mk_add_options PYTHON=${python2}/bin/python2" \
--replace "mk_add_options AUTOCONF=/usr/bin/autoconf-2.13" "mk_add_options AUTOCONF=${autoconf213}/bin/autoconf" \
--replace 'mk_add_options MOZ_OBJDIR=$HOME/build/wbobjects/' "" \
--replace "ac_add_options --x-libraries=/usr/lib64" "ac_add_options --x-libraries=${lib.makeLibraryPath [ xorg.libX11 ]}" \
--replace "_BUILD_64=1" "_BUILD_64=${lib.optionalString stdenv.hostPlatform.is64bit "1"}" \
--replace "--enable-ccache" "--disable-ccache"
echo >> $MOZCONFIG '
#
# NixOS-specific adjustments
#
ac_add_options --prefix=$out
mk_add_options MOZ_MAKE_FLAGS="-j$NIX_BUILD_CORES"
'
'';
buildPhase = "$src/mach build";
installPhase = ''
$src/mach install
mkdir -p $out/share/applications
cp ${desktopItem}/share/applications/* $out/share/applications
for n in 16 32 48; do
size=$n"x"$n
mkdir -p $out/share/icons/hicolor/$size/apps
cp $src/webbrowser/branding/unofficial/default$n.png \
$out/share/icons/hicolor/$size/apps/webbrowser.png
done
# Needed to make videos work
wrapProgram $out/lib/webbrowser-${version}/webbrowser \
--prefix LD_LIBRARY_PATH : "${libPath}"
'';
meta = with lib; {
description = "Generic web browser without trackers compatible with XUL plugins using UXP rendering engine";
homepage = "https://git.nuegia.net/webbrowser.git/";
license = [ licenses.mpl20 licenses.gpl3 ];
maintainers = with maintainers; [ TheBrainScrambler ];
platforms = [ "i686-linux" "x86_64-linux" ];
broken = true; # 2021-01-07
};
}

6
pkgs/applications/networking/cluster/sonobuoy/default.nix
View file

@ -1,11 +1,11 @@
{ lib, buildGoModule, fetchFromGitHub }:
# SHA of ${version} for the tool's help output. Unfortunately this is needed in build flags.
let rev = "6cf7519717a14c9a3e495fcd4588fa4eb16d2be2";
let rev = "1005bee8fff1b8daa30ddbcca717d03384630a71";
in
buildGoModule rec {
pname = "sonobuoy";
version = "0.56.2"; # Do not forget to update `rev` above
version = "0.56.3"; # Do not forget to update `rev` above
ldflags =
let t = "github.com/vmware-tanzu/sonobuoy";
@ -20,7 +20,7 @@ buildGoModule rec {
owner = "vmware-tanzu";
repo = "sonobuoy";
rev = "v${version}";
sha256 = "sha256-KYpBubNHAstKUtf9Ys4VCWyZ+y4HjzVMs9EtWzVFviQ=";
sha256 = "sha256-7yN3/bGjcntzMQRbB//fmqvD7me/xKLytfF+mQ1fcfc=";
};
vendorSha256 = "sha256-qKXm39CwrTcXENIMh2BBS3MUlhJvmTTA3UzZNpF0PCc=";

170
pkgs/applications/networking/cluster/terraform-providers/providers.json
View file

@ -3,10 +3,10 @@
"owner": "CiscoDevNet",
"provider-source-address": "registry.terraform.io/CiscoDevNet/aci",
"repo": "terraform-provider-aci",
"rev": "v2.0.1",
"sha256": "165k2sf4hq84zidlh0y5jmzwnid5gz7slhnb9rgp2771pzqm0gki",
"rev": "v2.1.0",
"sha256": "sha256-7fOvTEinJUpSaCnlP+191VTSEpE4z11+HUcH2iTFj60=",
"vendorSha256": null,
"version": "2.0.1"
"version": "2.1.0"
},
"acme": {
"owner": "vancluever",
@ -40,10 +40,10 @@
"owner": "aliyun",
"provider-source-address": "registry.terraform.io/aliyun/alicloud",
"repo": "terraform-provider-alicloud",
"rev": "v1.160.0",
"sha256": "sha256-ijSOvBS8bcFKX0qa2Cl/xqDdwduamVdCWzgTCWao1Sg=",
"vendorSha256": "sha256-oKaghX3u8H9vDFvmo+jelTIbvuHnAt27Z9N0oEWxcxc=",
"version": "1.160.0"
"rev": "v1.161.0",
"sha256": "sha256-vQrX9mFZLy16aV6hEA8X9MV995Ew+lJb8PxCvxDGoN0=",
"vendorSha256": "sha256-rIydGW7X0tL+ZwV1wEu3Zz3FZPrNozQI0Qx+Ee9tAik=",
"version": "1.161.0"
},
"ansible": {
"owner": "nbering",
@ -94,10 +94,10 @@
"owner": "hashicorp",
"provider-source-address": "registry.terraform.io/hashicorp/aws",
"repo": "terraform-provider-aws",
"rev": "v4.5.0",
"sha256": "sha256-L1LRuinU3YrqywRGpmUqGQgjZ1JuYhECjCN6ysYPzco=",
"vendorSha256": "sha256-3akEup/M7Zc5MPf2XA+324PxQiHegIwzR05JNSjYanw=",
"version": "4.5.0"
"rev": "v4.6.0",
"sha256": "sha256-Bq6DrwN4212LeBHb/j60v/fEvZwFseSRB8KZ3hrJYmQ=",
"vendorSha256": "sha256-hbN5apdCiA4eN0uCWlTRAEunO4nFB/VX+gchxp/6BJQ=",
"version": "4.6.0"
},
"azuread": {
"owner": "hashicorp",
@ -148,10 +148,10 @@
"owner": "DrFaust92",
"provider-source-address": "registry.terraform.io/DrFaust92/bitbucket",
"repo": "terraform-provider-bitbucket",
"rev": "v2.8.0",
"sha256": "sha256-W+mAud3DpBViLeFwXLWIwZ1+TOco8FWZnVrIbHUwgIU=",
"vendorSha256": "sha256-hSMVLDZXC9QMpcgREjEUjhxArtotrIrIyfdNIZw8uM4=",
"version": "2.8.0"
"rev": "v2.12.0",
"sha256": "sha256-FIJ2nnTHV+Rb4Dbtqcdc06qaBBg3hG8NBwv1LxgnoQI=",
"vendorSha256": "sha256-GEnLgGk9yohWXftNfp9Y21BQKE1B6QwN08d7k0ofKTc=",
"version": "2.12.0"
},
"brightbox": {
"owner": "brightbox",
@ -230,19 +230,19 @@
"owner": "Constellix",
"provider-source-address": "registry.terraform.io/Constellix/constellix",
"repo": "terraform-provider-constellix",
"rev": "v0.4.1",
"sha256": "15myw5ff22wi4cykwc2plghmfwl6d6m9pfskjqiwq8hffv35h50v",
"rev": "v0.4.2",
"sha256": "sha256-XnLTh/AP0OcFD5U2I1LSNpQ3s1OObueURDnioAtIQlU=",
"vendorSha256": null,
"version": "0.4.1"
"version": "0.4.2"
},
"consul": {
"owner": "hashicorp",
"provider-source-address": "registry.terraform.io/hashicorp/consul",
"repo": "terraform-provider-consul",
"rev": "v2.14.0",
"sha256": "19kmjjg4f74askwwwslbh5wvi5ndcr4wzm0374qr8gc57qiwxkpy",
"rev": "v2.15.0",
"sha256": "sha256-6NQL1ZlHZsxfoRV0zMOXApuCR+nj8CPWjpxj7BAJivY=",
"vendorSha256": null,
"version": "2.14.0"
"version": "2.15.0"
},
"ct": {
"owner": "poseidon",
@ -338,19 +338,19 @@
"owner": "exoscale",
"provider-source-address": "registry.terraform.io/exoscale/exoscale",
"repo": "terraform-provider-exoscale",
"rev": "v0.33.0",
"sha256": "sha256-mih0Bo6fcNgpyeCQ+GWSPyTrPlGzmBXkEO43TOVWMds=",
"rev": "v0.33.1",
"sha256": "sha256-HlhJe8jyvtACOF0msFMSrt9l//Ik03poSvhP+JccRyQ=",
"vendorSha256": null,
"version": "0.33.0"
"version": "0.33.1"
},
"external": {
"owner": "hashicorp",
"provider-source-address": "registry.terraform.io/hashicorp/external",
"repo": "terraform-provider-external",
"rev": "v2.2.0",
"sha256": "0s7zxz9dni1p93di1ddx595d0mmizq7zrvkbbx1m4c5f208m262x",
"vendorSha256": "1f5gh110rylb1cw4dlwdzsj8sb0myj7xcj7ix966l5qa9x05p9pn",
"version": "2.2.0"
"rev": "v2.2.2",
"sha256": "sha256-gImRxsDUgBHmw/5DeKcO9BzB906JB8dUcSGKQj+Vcy0=",
"vendorSha256": "sha256-1BUFg8epcEsCf6yyJr4E4CdX2o6/3R384opRTxwrsng=",
"version": "2.2.2"
},
"fastly": {
"owner": "fastly",
@ -392,10 +392,10 @@
"owner": "integrations",
"provider-source-address": "registry.terraform.io/integrations/github",
"repo": "terraform-provider-github",
"rev": "v4.21.0",
"sha256": "sha256-ayL22zlfZkGL/ycyQX384g7CjFHDgK8k010kg1fI4h4=",
"rev": "v4.22.0",
"sha256": "sha256-bSKK72dBxfZCwSq3/vg97Dq1o/121KSM4h14MC87BMo=",
"vendorSha256": null,
"version": "4.21.0"
"version": "4.22.0"
},
"gitlab": {
"owner": "gitlabhq",
@ -411,20 +411,20 @@
"provider-source-address": "registry.terraform.io/hashicorp/google",
"proxyVendor": true,
"repo": "terraform-provider-google",
"rev": "v4.13.0",
"sha256": "sha256-QSHlnvsWmkdUE7dd6HqzYtyYC+XDW69dIp/h7u1jD9g=",
"vendorSha256": "sha256-1tiFBc03RyIAtnu/NqhU3RowM8JhuLNS+blfyjXBcW0=",
"version": "4.13.0"
"rev": "v4.14.0",
"sha256": "sha256-VWbyxZ5ag9jRF5yaiEdVkRpmnsSb5IiE5FtE2e3j0b8=",
"vendorSha256": "sha256-NrP3+pBePNex/ZmVM349p5vI8uVcs21Sti2C3NfxZkQ=",
"version": "4.14.0"
},
"google-beta": {
"owner": "hashicorp",
"provider-source-address": "registry.terraform.io/hashicorp/google-beta",
"proxyVendor": true,
"repo": "terraform-provider-google-beta",
"rev": "v4.13.0",
"sha256": "sha256-jjYUijzUgIiSC9eL6rbgtuBSh6bbHLjeifN+GIndrVs=",
"vendorSha256": "sha256-1tiFBc03RyIAtnu/NqhU3RowM8JhuLNS+blfyjXBcW0=",
"version": "4.13.0"
"rev": "v4.14.0",
"sha256": "sha256-VEQff8SnyPLu9I6dbGRac5rF/hRAihlxFhX6KLaov/Y=",
"vendorSha256": "sha256-NrP3+pBePNex/ZmVM349p5vI8uVcs21Sti2C3NfxZkQ=",
"version": "4.14.0"
},
"grafana": {
"owner": "grafana",
@ -511,10 +511,10 @@
"owner": "IBM-Cloud",
"provider-source-address": "registry.terraform.io/IBM-Cloud/ibm",
"repo": "terraform-provider-ibm",
"rev": "v1.39.2",
"sha256": "sha256-9r0tt0N3m/IYq/9oepQ4DcB78ds8pb1up1TyjFYzX1U=",
"vendorSha256": "sha256-8qgm1zDdwKNE/bs1n5cpY/DUD3SKtFmnvEgwtKorASk=",
"version": "1.39.2"
"rev": "v1.40.0-beta0",
"sha256": "sha256-1C0JdzoHf/GKdlLyHA6GgJpb3lbYFXeMGeWYJ7RkyfU=",
"vendorSha256": "sha256-YgRgm5S7cXHO9yqUUuVVkFRQL+pf0RMPJI9oUaWob2I=",
"version": "1.40.0-beta0"
},
"icinga2": {
"owner": "Icinga",
@ -565,10 +565,10 @@
"owner": "kingsoftcloud",
"provider-source-address": "registry.terraform.io/kingsoftcloud/ksyun",
"repo": "terraform-provider-ksyun",
"rev": "v1.3.42",
"sha256": "sha256-wj4o2XSz8ylZJdseIi/TadlhOwFWZ6nfDOUezbeGYw4=",
"rev": "v1.3.43",
"sha256": "sha256-HOZ1nhHLdiYy+WR2y4OsyRGReK+OJFTaWqYU0X4eEQ0=",
"vendorSha256": "sha256-nbAEaRFtFtB4ftLgnCv3MmkjFFbcNkCuxZc+G8/ObPE=",
"version": "1.3.42"
"version": "1.3.43"
},
"kubectl": {
"owner": "gavinbunney",
@ -619,10 +619,10 @@
"owner": "numtide",
"provider-source-address": "registry.terraform.io/numtide/linuxbox",
"repo": "terraform-provider-linuxbox",
"rev": "v0.4.2",
"sha256": "1ghlp0nnc67m5rsx6aixqxjd5vhpbi88gcfyv3710dvqxchdgscy",
"vendorSha256": "01d556pfaa2ycww5kgd1f3shp2i2r48kgwnls39lhplp5qmnkz4g",
"version": "0.4.2"
"rev": "v0.4.3",
"sha256": "sha256-MzasMVtXO7ZeZ+qEx2Z+7881fOIA0SFzSvXVHeEROtg=",
"vendorSha256": "sha256-Jlg3a91pOhMC5SALzL9onajZUZ2H9mXfU5CKvotbCbw=",
"version": "0.4.3"
},
"local": {
"owner": "hashicorp",
@ -674,10 +674,10 @@
"owner": "equinix",
"provider-source-address": "registry.terraform.io/equinix/metal",
"repo": "terraform-provider-metal",
"rev": "v3.3.0-alpha.1",
"sha256": "0lihzid312q8qh1bl9x1wqslshq7pb0q4m8dgbww1cszzg6xb5aq",
"vendorSha256": "0aniiiysh6iq20fcqvdgs6a4l3prbxzpqpp2ixpfaxhg4z5l8zrf",
"version": "3.3.0-alpha.1"
"rev": "v3.3.0-alpha.2",
"sha256": "sha256-RUD4BJy0/s23+OWlQfFEh59BEhhtobW7zDOOcosC0l4=",
"vendorSha256": "sha256-Ln9EyycPduVuj+JefH9f+Q5KlNGvbcwcEDgaqH2M0So=",
"version": "3.3.0-alpha.2"
},
"minio": {
"owner": "aminueza",
@ -719,10 +719,10 @@
"owner": "newrelic",
"provider-source-address": "registry.terraform.io/newrelic/newrelic",
"repo": "terraform-provider-newrelic",
"rev": "v2.39.2",
"sha256": "sha256-NfszsBliZAjY52kPWB7yhOEYZB2V4yOp6IDffF7EG6k=",
"vendorSha256": "sha256-DD6zXX7anks5jRw9tn8lUvgJY4k81oGSQr0a/xofkGk=",
"version": "2.39.2"
"rev": "v2.41.0-beta.2",
"sha256": "sha256-tAEEJuU2ceTwXRtgGUFiFw1jgdJHSPG/WfaMDRm+gGQ=",
"vendorSha256": "sha256-Dvm8vmlfV7LH73Y2jNTO106V/fOA7K78jFclbFKZVXA=",
"version": "2.41.0-beta.2"
},
"nomad": {
"owner": "hashicorp",
@ -755,10 +755,10 @@
"owner": "hashicorp",
"provider-source-address": "registry.terraform.io/hashicorp/null",
"repo": "terraform-provider-null",
"rev": "v3.1.0",
"sha256": "0s6j2py9bb3knrn0f8aga8ypkxj6v5ns08k7zgw26h3wwdxwyd12",
"vendorSha256": null,
"version": "3.1.0"
"rev": "v3.1.1",
"sha256": "sha256-OKnlIt+R16d5GOKqM7/+sApQoC1+nv9h5Ty32QIIMuQ=",
"vendorSha256": "sha256-MtVpbcN/GZRYabsli2mhUXyCuRLRR0NEvcX1iLM552c=",
"version": "3.1.1"
},
"nutanix": {
"deleteVendor": true,
@ -829,10 +829,10 @@
"owner": "opentelekomcloud",
"provider-source-address": "registry.terraform.io/opentelekomcloud/opentelekomcloud",
"repo": "terraform-provider-opentelekomcloud",
"rev": "v1.27.7",
"sha256": "sha256-8y++zfxRam4sZvGWajyGiPv/5G8K7D4+ReNU7DBlqe8=",
"vendorSha256": "sha256-OqN+QGclKYo4jjQi0HJ/80zVTPkcOQyl4n6i2BpDZQE=",
"version": "1.27.7"
"rev": "v1.28.0",
"sha256": "sha256-D+sIpGNQQ5UUNoesX6zd8BHo5RYfoTb/9x3lvFyoD50=",
"vendorSha256": "sha256-FMcPG7EJvU6XNKd2+8+xmjqSI0Ec9Xx/6gZvK9zJ3wg=",
"version": "1.28.0"
},
"opsgenie": {
"owner": "opsgenie",
@ -928,10 +928,10 @@
"owner": "hashicorp",
"provider-source-address": "registry.terraform.io/hashicorp/random",
"repo": "terraform-provider-random",
"rev": "v3.1.0",
"sha256": "1677mia6bbydqa8w50f1y85rynpv9lhg9ar5s6japsr5g78lrcqf",
"vendorSha256": null,
"version": "3.1.0"
"rev": "v3.1.2",
"sha256": "sha256-Yk1CPR9gN70E+Qpc20vBQG2MY/RCO5cvaNtD8N++d5A=",
"vendorSha256": "sha256-/IjOv7/kQlGuV9+9Vhc7zUrr6hbcoxZyKi+q52YA/kk=",
"version": "3.1.2"
},
"rundeck": {
"owner": "rundeck",
@ -1009,10 +1009,10 @@
"owner": "chanzuckerberg",
"provider-source-address": "registry.terraform.io/chanzuckerberg/snowflake",
"repo": "terraform-provider-snowflake",
"rev": "v0.25.36",
"sha256": "sha256-AeIQfdn68EnSj2BXZIsC0+L3EJ6tRHLD0NYHdPcf89w=",
"vendorSha256": "sha256-oYjoTZ79ricoFZTokiFcCKNXAeqFvW4RIMQmTp763gE=",
"version": "0.25.36"
"rev": "v0.28.8",
"sha256": "sha256-v5+qmBqPJk9BTkjmXRn2yiIHlFkFcqoH7RuenM54Eys=",
"vendorSha256": "sha256-G/UIKuKtolLY7RIQF06wzn/ZYTMihEmJZ1DqVcHFGdg=",
"version": "0.28.8"
},
"sops": {
"owner": "carlpett",
@ -1045,10 +1045,10 @@
"owner": "StatusCakeDev",
"provider-source-address": "registry.terraform.io/StatusCakeDev/statuscake",
"repo": "terraform-provider-statuscake",
"rev": "v2.0.0-pre",
"sha256": "sha256-S9VJRGREoRJPIb9gv822Y/8ZRa0x7WoPjU7BxLlRpOM=",
"vendorSha256": "sha256-wKrbjxRCDk8GFAR0OFz4w9UnkIXH9EO/S+p2RKNLJaM=",
"version": "2.0.0-pre"
"rev": "v2.0.1-pre",
"sha256": "sha256-/SWmGy6kMAt4TAswlpmfs4rVAa/DZBFoE1Yv+EcWfGo=",
"vendorSha256": "sha256-sFKhbOsE2eQ4Qxfbtab19nZRIKhJXNdsg274tWRjoVg=",
"version": "2.0.1-pre"
},
"sumologic": {
"owner": "SumoLogic",
@ -1072,10 +1072,10 @@
"owner": "tencentcloudstack",
"provider-source-address": "registry.terraform.io/tencentcloudstack/tencentcloud",
"repo": "terraform-provider-tencentcloud",
"rev": "v1.65.0",
"sha256": "sha256-NpKZ4KbEDxCYmG2E4F/bHEUmK6invkcIaNkXDZjhmDI=",
"rev": "v1.65.2",
"sha256": "sha256-JrgLHagLc+yhTMa6gVJpVxy3NGCO2BED/87z0JEhesE=",
"vendorSha256": null,
"version": "1.65.0"
"version": "1.65.2"
},
"tfe": {
"owner": "hashicorp",
@ -1164,10 +1164,10 @@
"owner": "Venafi",
"provider-source-address": "registry.terraform.io/Venafi/venafi",
"repo": "terraform-provider-venafi",
"rev": "v0.14.0",
"sha256": "16a7mr4dzfkvf9gg77dax92dp6g99plfg5qpzfhxdfanb25lq7za",
"vendorSha256": "0vmmki2pmg6ns75ldygyvj5pzl3blzz62zfqh4jsm1zbswfs75df",
"version": "0.14.0"
"rev": "v0.15.0",
"sha256": "sha256-7pfEQ7tHA+RiyotlvEymedCsDtR+8EDob1kKw55U5V0=",
"vendorSha256": "sha256-lj8cuv9jR+3P7OiO/eW8poHcX+LsQo+kOyspiqdMXRY=",
"version": "0.15.0"
},
"vercel": {
"owner": "ondrejsika",

4
pkgs/applications/networking/instant-messengers/psi-plus/default.nix
View file

@ -43,13 +43,13 @@ assert enablePsiMedia -> enablePlugins;
mkDerivation rec {
pname = "psi-plus";
version = "1.5.1600";
version = "1.5.1615";
src = fetchFromGitHub {
owner = "psi-plus";
repo = "psi-plus-snapshots";
rev = version;
sha256 = "sha256-AZSxElEpYUYa92KdYxVyM+ppKHpXXwwlBFVOOKH/O7g=";
sha256 = "sha256-aD+JVGmBWHUav2bH9rXGtgqI+/5lJTMrYLRP7E65JxI=";
};
cmakeFlags = [

66
pkgs/applications/networking/instant-messengers/sky/default.nix Normal file
View file

@ -0,0 +1,66 @@
{ lib
, mkDerivation
, fetchurl
, autoPatchelfHook
, zstd
, curl
, ffmpeg
, libjpeg_turbo
, libpam-wrapper
, libv4l
, pulseaudio
, zlib
, xorg
}:
mkDerivation rec {
pname = "sky";
version = "2.1.7801";
src = fetchurl {
url = "https://tel.red/repos/archlinux/sky-archlinux-${version}-1-x86_64.pkg.tar.zst";
sha256 = "sha256-3xiq2b3CwNjRd09q0z8olrmLGhgkJGAVkZoJSIHom+k=";
};
nativeBuildInputs = [ autoPatchelfHook zstd ];
buildInputs = [
curl
ffmpeg
libjpeg_turbo
libpam-wrapper
libv4l
pulseaudio
xorg.libX11
xorg.libXScrnSaver
xorg.libXcursor
xorg.libXdamage
xorg.libXinerama
xorg.libXmu
xorg.libXrandr
xorg.libXtst
xorg.libXv
xorg.libxkbfile
zlib
];
installPhase = ''
runHook preInstall
mkdir $out
mv * $out/
ln --force --symbolic $out/lib/sky/sky{,_sender} $out/bin
substituteInPlace $out/share/applications/sky.desktop \
--replace /usr/ $out/
runHook postInstall
'';
meta = {
description = "Lync & Skype for Business on Linux";
homepage = "https://tel.red/";
license = lib.licenses.unfree;
maintainers = [ lib.maintainers.wucke13 ];
platforms = [ "x86_64-linux" ];
};
}

6
pkgs/applications/networking/mailreaders/himalaya/default.nix
View file

@ -12,16 +12,16 @@
rustPlatform.buildRustPackage rec {
pname = "himalaya";
version = "0.5.9";
version = "0.5.10";
src = fetchFromGitHub {
owner = "soywod";
repo = pname;
rev = "v${version}";
sha256 = "sha256-g+ySsHnJ4FpmJLEjlutuiJmMkKI3Jb+HkWi1WBIo1aw=";
sha256 = "sha256-CXchZbXX7NH2ZXeAoPph3qxxdcAdDVZLBmOMwxFu+Yo=";
};
cargoSha256 = "sha256-NkkONl57zSilElVAOXUBxWnims4+EIVkkTdExbeBAaQ=";
cargoSha256 = "sha256-sSQX7DHDgh1eO1Dwn1f0m51Bl2ZG1daRtrnYvsvPOkg=";
nativeBuildInputs = lib.optionals enableCompletions [ installShellFiles ]
++ lib.optionals (!stdenv.hostPlatform.isDarwin) [ pkg-config ];

97
pkgs/applications/networking/p2p/fragments/default.nix
View file

@ -1,76 +1,89 @@
{ lib
, stdenv
, fetchFromGitLab
, meson
, vala
, ninja
, pkg-config
, wrapGAppsHook
, desktop-file-utils
, fetchpatch
, appstream-glib
, python3
, dbus
, desktop-file-utils
, git
, glib
, gtk3
, libhandy
, libtransmission
, libb64
, libutp
, miniupnpc
, dht
, libnatpmp
, libevent
, curl
, gtk4
, libadwaita
, meson
, ninja
, openssl
, zlib
, pkg-config
, python3
, rustPlatform
, sqlite
, transmission
, wrapGAppsHook4
}:
stdenv.mkDerivation rec {
let
patchedTransmission = transmission.overrideAttrs (oldAttrs: {
patches = (oldAttrs.patches or []) ++ [
(fetchpatch {
url = "https://raw.githubusercontent.com/flathub/de.haeckerfelix.Fragments/2aee477c8e26a24570f8dbbdbd1c49e017ae32eb/transmission_pdeathsig.patch";
sha256 = "sha256-/rCoA566tMmzqcIfffC082Y56TwEyyQJ0knxymtscbA=";
})
];
});
in stdenv.mkDerivation rec {
pname = "fragments";
version = "1.5";
version = "2.0.2";
src = fetchFromGitLab {
domain = "gitlab.gnome.org";
owner = "World";
repo = "Fragments";
rev = version;
sha256 = "0x1kafhlgyi65l4w67c24r8mpvasg3q3c4wlgnjc9sxvp6ki7xbn";
sha256 = "sha256-CMa1yka0kOxMhxSuazlJxTk4fzxuuwKYLBpEMwHbBUE=";
};
patches = [
# Fix dependency resolution
./dependency-resolution.patch
];
postPatch = ''
patchShebangs build-aux/meson/postinstall.py
'';
cargoDeps = rustPlatform.fetchCargoTarball {
inherit src;
name = "${pname}-${version}";
hash = "sha256-/rFZcbpITYkpSCEZp9XH253u90RGmuVLEBGIRNBgI/o=";
};
nativeBuildInputs = [
appstream-glib
desktop-file-utils
git
meson
vala
ninja
pkg-config
wrapGAppsHook
desktop-file-utils
appstream-glib
python3
];
wrapGAppsHook4
] ++ (with rustPlatform; [
cargoSetupHook
rust.cargo
rust.rustc
]);
buildInputs = [
dbus
glib
gtk3
libhandy
libtransmission
libb64
libutp
miniupnpc
dht
libnatpmp
libevent
curl
gtk4
libadwaita
openssl
zlib
sqlite
];
preFixup = ''
gappsWrapperArgs+=(
--prefix PATH : "${lib.makeBinPath [ patchedTransmission ]}"
)
'';
meta = with lib; {
homepage = "https://gitlab.gnome.org/World/Fragments";
description = "A GTK3 BitTorrent Client";
description = "Easy to use BitTorrent client for the GNOME desktop environment";
maintainers = with maintainers; [ emilytrau ];
license = licenses.gpl3Plus;
platforms = platforms.linux;

25
pkgs/applications/networking/p2p/fragments/dependency-resolution.patch
View file

@ -1,25 +0,0 @@
diff --git a/meson.build b/meson.build
index 5030d0c..6de7a20 100644
--- a/meson.build
+++ b/meson.build
@@ -32,10 +32,11 @@ transmission_dep = declare_dependency(
meson.get_compiler('c').find_library('dht'),
meson.get_compiler('c').find_library('natpmp'),
meson.get_compiler('c').find_library('event'),
- meson.get_compiler('c').find_library('libcurl'),
- meson.get_compiler('c').find_library('libcrypto'),
+ meson.get_compiler('c').find_library('curl'),
+ meson.get_compiler('c').find_library('crypto'),
+ meson.get_compiler('c').find_library('ssl'),
meson.get_compiler('c').find_library('libpthread'),
- meson.get_compiler('c').find_library('libz'),
+ meson.get_compiler('c').find_library('z'),
transmission_vapi,
transmission_lib
])
@@ -45,4 +46,4 @@ subdir('data')
subdir('po')
subdir('src')
-meson.add_install_script('build-aux/postinstall.py')
+meson.add_install_script('python3', '../build-aux/postinstall.py')

101
pkgs/applications/office/micropad/default.nix Normal file
View file

@ -0,0 +1,101 @@
{ lib
, stdenv
, fetchFromGitHub
, fetchzip
, makeWrapper
, makeDesktopItem
, mkYarnPackage
, electron
, desktopToDarwinBundle
, copyDesktopItems
}:
let
executableName = "micropad";
electron_exec =
if stdenv.isDarwin
then "${electron}/Applications/Electron.app/Contents/MacOS/Electron"
else "${electron}/bin/electron";
in
mkYarnPackage rec {
pname = "micropad";
version = "3.30.6";
src = fetchFromGitHub {
owner = "MicroPad";
repo = "Micropad-Electron";
rev = "v${version}";
sha256 = "sha256-v3hnHG6FMW2xBU/DnenqjFizQv/OZ9cW99n/3SoENe8=";
};
micropad-core = fetchzip {
url = "https://github.com/MicroPad/MicroPad-Core/releases/download/v${version}/micropad.tar.xz";
hash = "sha256-aqshYbVrQg6tYtTlO91FGiH7DuueOA0OU5KGCVc7XvI=";
};
packageJSON = ./package.json;
yarnLock = ./yarn.lock;
yarnNix = ./yarn.nix;
nativeBuildInputs = [ copyDesktopItems makeWrapper ]
++ lib.optionals stdenv.isDarwin [ desktopToDarwinBundle ];
buildPhase = ''
runHook preBuild
pushd deps/micropad/
yarn --offline build
popd
runHook postBuild
'';
installPhase = ''
runHook preInstall
# resources
mkdir -p "$out/share/"
cp -r './deps/micropad' "$out/share/micropad"
ln -s '${micropad-core}' "$out/share/micropad/core"
rm "$out/share/micropad/node_modules"
cp -r './node_modules' "$out/share/micropad"
# icons
for icon in $out/share/micropad/build/icons/*.png; do
mkdir -p "$out/share/icons/hicolor/$(basename $icon .png | sed -e 's/^icon-//')/apps"
ln -s "$icon" "$out/share/icons/hicolor/$(basename $icon .png | sed -e 's/^icon-//')/apps/micropad.png"
done
# executable wrapper
makeWrapper '${electron_exec}' "$out/bin/${executableName}" \
--add-flags "$out/share/micropad" \
--add-flags "\''${NIXOS_OZONE_WL:+\''${WAYLAND_DISPLAY:+--enable-features=UseOzonePlatform --ozone-platform=wayland}}"
runHook postInstall
'';
# Do not attempt generating a tarball for micropad again.
# note: `doDist = false;` does not work.
distPhase = ''
true
'';
# The desktop item properties should be kept in sync with data from upstream:
# https://github.com/MicroPad/MicroPad-Electron/blob/master/package.json
desktopItems = [
(makeDesktopItem {
name = "micropad";
exec = "${executableName} %u";
icon = "micropad";
desktopName = "µPad";
startupWMClass = "µPad";
comment = meta.description;
categories = ["Office"];
})
];
meta = with lib; {
description = "A powerful note-taking app that helps you organise + take notes without restrictions";
homepage = "https://getmicropad.com/";
license = licenses.mpl20;
maintainers = with maintainers; [rhysmdnz];
inherit (electron.meta) platforms;
};
}

87
pkgs/applications/office/micropad/package.json Normal file
View file

@ -0,0 +1,87 @@
{
"name": "micropad",
"version": "3.30.5",
"description": "A powerful note-taking app that helps you organise + take notes without restrictions.",
"main": "main.js",
"scripts": {
"start": "yarn build && yarn electron . --is-dev --no-sandbox",
"build": "yarn tsc -p tsconfig.json",
"update-core": "rm -rf core && rm -rf tmp && mkdir tmp && wget https://github.com/MicroPad/MicroPad-Core/releases/download/v${npm_package_version}/micropad.tar.xz -P ./tmp && cd tmp && tar -xf micropad.tar.xz && rm build/*.map && rm build/static/*/*.map && cp -r build ../core && cd .. && rm -rf tmp",
"pack": "yarn build && yarn electron-builder --dir",
"dist": "yarn build && yarn electron-builder"
},
"repository": {
"type": "git",
"url": "git+https://github.com/MicroPad/Electron.git"
},
"author": {
"name": "Nick Webster",
"email": "nick@nick.geek.nz"
},
"license": "MPL-2.0",
"bugs": {
"url": "https://github.com/MicroPad/Electron/issues"
},
"homepage": "https://getmicropad.com",
"devDependencies": {
"electron": "^17.1.0",
"electron-builder": "^23.0.2",
"typescript": "~4.5.4"
},
"dependencies": {
"dictionary-en": "^3.0.0",
"dictionary-en-au": "^2.1.1",
"electron-context-menu": "^3.1.2",
"localforage": "^1.10.0",
"typo-js": "^1.2.1"
},
"build": {
"appId": "com.getmicropad.micropad",
"productName": "µPad",
"publish": {
"provider": "github",
"releaseType": "release"
},
"asarUnpack": [
"preload.js"
],
"linux": {
"target": [
"tar.gz",
"AppImage",
"snap",
"deb",
"rpm",
"pacman"
],
"executableName": "micropad",
"category": "Office",
"icon": "build/icons"
},
"pacman": {
"depends": [
"gtk3"
]
},
"snap": {
"publish": {
"provider": "github",
"releaseType": "release"
}
},
"mac": {
"target": {
"target": "dmg",
"arch": "universal"
},
"category": "public.app-category.productivity",
"identity": null
},
"win": {
"target": [
"nsis",
"portable"
]
}
}
}

2006
pkgs/applications/office/micropad/yarn.lock Normal file
View file

File diff suppressed because it is too large Load diff

2341
pkgs/applications/office/micropad/yarn.nix Normal file
View file

File diff suppressed because it is too large Load diff

4
pkgs/applications/science/astronomy/kstars/default.nix
View file

@ -14,11 +14,11 @@
mkDerivation rec {
pname = "kstars";
version = "3.5.7";
version = "3.5.8";
src = fetchurl {
url = "mirror://kde/stable/kstars/kstars-${version}.tar.xz";
sha256 = "sha256-qo8SLum46BM0QzGR6rJ2w2ERK53Lm8+N+ghR6HoQDQY=";
sha256 = "sha256-Zg2QKDe3q/OBDW4k9y/YTwREopvX1D4YlrGf7OHIjD8=";
};
nativeBuildInputs = [ extra-cmake-modules kdoctools ];

50
pkgs/applications/science/misc/golly/beta.nix
View file

@ -1,50 +0,0 @@
{lib, stdenv, fetchgit
, wxGTK, perl, python2, zlib, libGLU, libGL, libX11
, automake, autoconf
}:
stdenv.mkDerivation rec {
pname = "golly";
version = "2.8.99.2.20161122";
#src = fetchurl {
# url="mirror://sourceforge/project/golly/golly/golly-2.8/golly-2.8-src.tar.gz";
# sha256="0a4vn2hm7h4b47v2iwip1z3n9y8isf79v08aipl2iqms2m3p5204";
#};
src = fetchgit {
url = "git://git.code.sf.net/p/golly/code";
rev = "93495edf3c9639332c6eb43ca7149c69629ee5d8";
sha256 = "1j308s9zlqkr3wnl1l32s5zk7r3g4ijwawkkysl8j5ik9sibi2gk";
};
setSourceRoot = ''
export sourceRoot="$(echo */gui-wx/configure)"
'';
nativeBuildInputs = [autoconf automake];
buildInputs = [
wxGTK perl python2 zlib libGLU libGL libX11
];
# Link against Python explicitly as it is needed for scripts
makeFlags=[
"AM_LDFLAGS="
];
NIX_LDFLAGS="-l${python2.libPrefix} -lperl -ldl -lGL";
preConfigure=''
export NIX_LDFLAGS="$NIX_LDFLAGS -L$(dirname "$(find ${perl} -name libperl.so)")"
export NIX_CFLAGS_COMPILE="$NIX_CFLAGS_COMPILE
-DPYTHON_SHLIB=$(basename "$(
readlink -f ${python2}/lib/libpython*.so)")"
sh autogen.sh
'';
meta = {
description = "Cellular automata simulation program";
license = lib.licenses.gpl2;
maintainers = [lib.maintainers.raskin];
platforms = lib.platforms.linux;
downloadPage = "https://sourceforge.net/projects/golly/files/golly";
};
}

6
pkgs/applications/version-management/bcompare/default.nix
View file

@ -4,19 +4,19 @@
let
pname = "bcompare";
version = "4.4.0.25886";
version = "4.4.2.26348";
throwSystem = throw "Unsupported system: ${stdenv.hostPlatform.system}";
srcs = {
x86_64-linux = fetchurl {
url = "https://www.scootersoftware.com/${pname}-${version}_amd64.deb";
sha256 = "sha256-zQZrCjXzoOZ5o5M4t1n5/HhGoGTcZSj5rlf9Uz9UZko=";
sha256 = "sha256-GotORErgPs7IPXATbBfIisDCNwp8csl7pDSwV77FylA=";
};
x86_64-darwin = fetchurl {
url = "https://www.scootersoftware.com/BCompareOSX-${version}.zip";
sha256 = "sha256-dez30a1sp+4XuBBYhu07Vpn1+AUmX0Ni7aad7hy2ajQ=";
sha256 = "sha256-XqmtW2EGyFmOzCooXczP3mtMN5UVQCCx7DJnVDlzAko=";
};
aarch64-darwin = srcs.x86_64-darwin;

45
pkgs/applications/video/yuview/default.nix Normal file
View file

@ -0,0 +1,45 @@
{ lib
, stdenv
, fetchFromGitHub
, qmake
, wrapQtAppsHook
}:
stdenv.mkDerivation rec {
pname = "yuview";
version = "2.12.1";
src = fetchFromGitHub {
owner = "IENT";
repo = "YUView";
rev = "v${version}";
sha256 = "sha256-BQnlq6TBxGbwqn6lAZGBo4+2HeXdFYL33LKqKSXMvdY=";
};
nativeBuildInputs = [ qmake wrapQtAppsHook ];
patches = [ ./disable_version_check.patch ];
enableParallelBuilding = true;
meta = with lib; {
homepage = "https://ient.github.io/YUView";
description = "YUV Viewer and Analysis Tool";
longDescription = ''
YUView is a Qt based YUV player with an advanced analytic toolset for
Linux, Windows and Mac. At its core, YUView is a powerful YUV player that
can open and show almost any YUV format. With its simple interface it is
easy to navigate through sequences and inspect details and a side by side
and comparison view can help to spot differences between two sequences. A
sophisticated statistics renderer can overlay the video with supplemental
information. More features include playlists, support for visual tests and
presentations, support of compressed formats (through libde265 and
FFmpeg), support for raw RGB files as well as image files and image
sequences, and many more. Further information can be found in the YUV help
in the application itself or in our wiki.
'';
license = licenses.gpl3Plus;
maintainers = with maintainers; [ leixb ];
platforms = platforms.unix;
};
}

15
pkgs/applications/video/yuview/disable_version_check.patch Normal file
View file

@ -0,0 +1,15 @@
diff --git a/YUViewLib/src/common/Typedef.h b/YUViewLib/src/common/Typedef.h
--- a/YUViewLib/src/common/Typedef.h
+++ b/YUViewLib/src/common/Typedef.h
@@ -212,12 +212,7 @@ private:
#define YUVIEW_VERSION "Unknown"
#endif
-#ifndef YUVIEW_HASH
#define VERSION_CHECK 0
-#define YUVIEW_HASH 0
-#else
-#define VERSION_CHECK 1
-#endif
#define MAX_RECENT_FILES 10

1491
pkgs/applications/virtualization/crosvm/Cargo.lock generated Normal file
View file

File diff suppressed because it is too large Load diff

50
pkgs/applications/virtualization/crosvm/default.nix
View file

@ -1,5 +1,6 @@
{ stdenv, lib, rustPlatform, fetchgit, runCommand, symlinkJoin
, pkg-config, minijail, dtc, libusb1, libcap, linux
{ stdenv, lib, rustPlatform, fetchgit
, pkg-config, wayland-scanner, libcap, minijail, wayland, wayland-protocols
, linux
}:
let
@ -11,55 +12,26 @@ let
else if isx86_64 then "x86_64"
else throw "no seccomp policy files available for host platform";
crosvmSrc = fetchgit {
inherit (upstreamInfo.components."chromiumos/platform/crosvm")
url rev sha256 fetchSubmodules;
};
adhdSrc = fetchgit {
inherit (upstreamInfo.components."chromiumos/third_party/adhd")
url rev sha256 fetchSubmodules;
};
in
rustPlatform.buildRustPackage rec {
pname = "crosvm";
inherit (upstreamInfo) version;
unpackPhase = ''
runHook preUnpack
mkdir -p chromiumos/platform chromiumos/third_party
pushd chromiumos/platform
unpackFile ${crosvmSrc}
mv ${crosvmSrc.name} crosvm
popd
pushd chromiumos/third_party
unpackFile ${adhdSrc}
mv ${adhdSrc.name} adhd
popd
chmod -R u+w -- "$sourceRoot"
runHook postUnpack
'';
sourceRoot = "chromiumos/platform/crosvm";
src = fetchgit (builtins.removeAttrs upstreamInfo.src [ "date" "path" ]);
patches = [
./default-seccomp-policy-dir.diff
];
cargoSha256 = "0aax0slg59afbyn3ygswwap2anv11k6sr9hfpysb4f8rvymvx7hd";
cargoLock.lockFile = ./Cargo.lock;
nativeBuildInputs = [ pkg-config ];
nativeBuildInputs = [ pkg-config wayland-scanner ];
buildInputs = [ dtc libcap libusb1 minijail ];
buildInputs = [ libcap minijail wayland wayland-protocols ];
postPatch = ''
cp ${./Cargo.lock} Cargo.lock
sed -i "s|/usr/share/policy/crosvm/|$out/share/policy/|g" \
seccomp/*/*.policy
'';
@ -77,11 +49,7 @@ in
lib.optionalString (stdenv.buildPlatform == stdenv.hostPlatform)
"${linux}/${stdenv.hostPlatform.linux-kernel.target}";
passthru = {
inherit adhdSrc;
src = crosvmSrc;
updateScript = ./update.py;
};
passthru.updateScript = ./update.py;
meta = with lib; {
description = "A secure virtual machine monitor for KVM";

33
pkgs/applications/virtualization/crosvm/update.py
View file

@ -12,9 +12,7 @@ from lxml import etree
from lxml.etree import HTMLParser
from urllib.request import urlopen
# ChromiumOS components required to build crosvm.
components = ['chromiumos/platform/crosvm', 'chromiumos/third_party/adhd']
git_path = 'chromiumos/platform/crosvm'
git_root = 'https://chromium.googlesource.com/'
manifest_versions = f'{git_root}chromiumos/manifest-versions'
buildspecs_url = f'{manifest_versions}/+/refs/heads/master/full/buildspecs/'
@ -54,32 +52,27 @@ with urlopen(f'{buildspecs_url}{chrome_major_version}/?format=TEXT') as resp:
buildspecs.sort(reverse=True)
buildspec = splitext(buildspecs[0])[0]
revisions = {}
# Read the buildspec, and extract the git revisions for each component.
# Read the buildspec, and extract the git revision.
with urlopen(f'{buildspecs_url}{chrome_major_version}/{buildspec}.xml?format=TEXT') as resp:
xml = base64.decodebytes(resp.read())
root = etree.fromstring(xml)
for project in root.findall('project'):
revisions[project.get('name')] = project.get('revision')
revision = root.find(f'./project[@name="{git_path}"]').get('revision')
# Initialize the data that will be output from this script. Leave the
# rc number in buildspec so nobody else is subject to the same level
# of confusion I have been.
data = {'version': f'{chrome_major_version}.{buildspec}', 'components': {}}
data = {'version': f'{chrome_major_version}.{buildspec}'}
# Fill in the 'components' dictionary with the output from
# nix-prefetch-git, which can be passed straight to fetchGit when
# imported by Nix.
for component in components:
argv = ['nix-prefetch-git',
'--url', git_root + component,
'--rev', revisions[component]]
# Fill in the 'src' key with the output from nix-prefetch-git, which
# can be passed straight to fetchGit when imported by Nix.
argv = ['nix-prefetch-git',
'--fetch-submodules',
'--url', git_root + git_path,
'--rev', revision]
output = subprocess.check_output(argv)
data['src'] = json.loads(output.decode('utf-8'))
output = subprocess.check_output(argv)
data['components'][component] = json.loads(output.decode('utf-8'))
# Find the path to crosvm's default.nix, so the srcs data can be
# Find the path to crosvm's default.nix, so the src data can be
# written into the same directory.
argv = ['nix-instantiate', '--eval', '--json', '-A', 'crosvm.meta.position']
position = json.loads(subprocess.check_output(argv).decode('utf-8'))

31
pkgs/applications/virtualization/crosvm/upstream-info.json
View file

@ -1,23 +1,14 @@
{
"version": "81.12871.0.0-rc1",
"components": {
"chromiumos/platform/crosvm": {
"url": "https://chromium.googlesource.com/chromiumos/platform/crosvm",
"rev": "8b8c01e1ad31718932491e4aee63f56109a138e2",
"date": "2020-01-25T02:28:10+00:00",
"sha256": "1qmf1k06pwynh15c3nr9m6v90z2pkk930xniwvlvbvnazrk4rllg",
"fetchSubmodules": false,
"deepClone": false,
"leaveDotGit": false
},
"chromiumos/third_party/adhd": {
"url": "https://chromium.googlesource.com/chromiumos/third_party/adhd",
"rev": "f361d5b02623274723bff251dafa1e2a2887b013",
"date": "2020-01-23T18:37:46+00:00",
"sha256": "1p8iwjwgmcgmzri03ik2jaid8l0ch0bzn6z9z64dix1hlrvrlliw",
"fetchSubmodules": false,
"deepClone": false,
"leaveDotGit": false
}
"version": "99.14468.0.0-rc1",
"src": {
"url": "https://chromium.googlesource.com/chromiumos/platform/crosvm",
"rev": "410ea3a1980bfe96968a7dfb7a7d203d43b186b2",
"date": "2022-01-11T00:01:17-08:00",
"path": "/nix/store/y2rpzh1any8c4nwnwkvir7241kbcj8fn-crosvm-410ea3a",
"sha256": "1bgwndh2f60ka1f8c8yqnqqkra510ai9miyfvvm0b3dnsdpy77kd",
"fetchLFS": false,
"fetchSubmodules": true,
"deepClone": false,
"leaveDotGit": false
}
}

4
pkgs/applications/virtualization/distrobox/default.nix
View file

@ -2,13 +2,13 @@
stdenvNoCC.mkDerivation rec {
pname = "distrobox";
version = "1.2.13";
version = "1.2.14";
src = fetchFromGitHub {
owner = "89luca89";
repo = pname;
rev = version;
sha256 = "047mrhsfi88mgwylnnyxg6xa7hjjrajn2pf7vfmb6161myqybvfy";
sha256 = "sha256-gHKyuIL4K/SLBJw8xNuPdNifDcHI91AFTiHaiv38gus=";
};
dontConfigure = true;

1
pkgs/applications/virtualization/virtualbox/guest-additions/default.nix
View file

@ -162,5 +162,6 @@ in stdenv.mkDerivation rec {
license = "GPL";
maintainers = [ lib.maintainers.sander ];
platforms = lib.platforms.linux;
broken = kernel.kernelAtLeast "5.17";
};
}

32
pkgs/data/fonts/ccsymbols/default.nix Normal file
View file

@ -0,0 +1,32 @@
{ lib, fetchurl, unzip }:
let
pname = "ccsymbols";
version = "2020-04-19";
in
fetchurl rec {
name = "${pname}-${version}";
url = "https://www.ctrl.blog/file/${version}_cc-symbols.zip";
sha256 = "sha256-mrNgTS6BAVJrIz9fHOjf8pkSbZtZ55UjyoL9tQ1fiA8=";
recursiveHash = true;
nativeBuildInputs = [ unzip ];
downloadToTemp = true;
postFetch = ''
mkdir -p "$out/share/fonts/ccsymbols"
unzip -d "$out/share/fonts/ccsymbols" "$downloadedFile"
'';
passthru = { inherit pname version; };
meta = with lib; {
description = "Creative Commons symbol font";
homepage = "https://www.ctrl.blog/entry/creative-commons-unicode-fallback-font.html";
maintainers = with maintainers; [ qyliss ];
license = licenses.publicDomain;
platforms = platforms.all;
};
}

11
pkgs/desktops/gnome/extensions/collisions.json
View file

@ -43,6 +43,10 @@
"gnome-trash": [
"gnome-trash@gnome-trash.b00f.gitlab.com",
"gnome-trash@b00f.github.io"
],
"volume-scroller": [
"volume_scroller@trflynn89.pm.me",
"volume_scroller@noskoski"
]
},
"40": {
@ -98,6 +102,10 @@
"wireguard-indicator": [
"wireguard-indicator@gregos.me",
"wireguard-indicator@atareao.es"
],
"volume-scroller": [
"volume_scroller@trflynn89.pm.me",
"volume_scroller@noskoski"
]
},
"41": {
@ -129,5 +137,6 @@
"floatingDock@sun.wxg@gmail.com",
"floating-dock@nandoferreira_prof@hotmail.com"
]
}
},
"42": {}
}

1
pkgs/desktops/gnome/extensions/default.nix
View file

@ -58,6 +58,7 @@ in rec {
gnome38Extensions = mapUuidNames (produceExtensionsList "38");
gnome40Extensions = mapUuidNames (produceExtensionsList "40");
gnome41Extensions = mapUuidNames (produceExtensionsList "41");
gnome42Extensions = mapUuidNames (produceExtensionsList "42");
gnomeExtensions = lib.trivial.pipe (gnome40Extensions // gnome41Extensions) [
# Apply some custom patches for automatically packaged extensions

3
pkgs/desktops/gnome/extensions/extensionRenames.nix
View file

@ -55,6 +55,9 @@
"extension-list@tu.berry" = "extension-list";
"screen-lock@garciabaameiro.com" = "screen-lock"; # Don't know why they got 'extension-list' as slug
"volume_scroller@trflynn89.pm.me" = "volume-scroller";
"volume_scroller@noskoski" = "volume-scroller-2";
# ####### GNOME 3.38 #######
"bottompanel@tmoer93" = "bottompanel";

268
pkgs/desktops/gnome/extensions/extensions.json
View file

File diff suppressed because one or more lines are too long

1
pkgs/desktops/gnome/extensions/update-extensions.py
View file

@ -18,6 +18,7 @@ supported_versions = {
"38": "3.38",
"40": "40",
"41": "41",
"42": "42",
}

4
pkgs/desktops/lxqt/obconf-qt/default.nix
View file

@ -15,13 +15,13 @@
mkDerivation rec {
pname = "obconf-qt";
version = "0.16.1";
version = "0.16.2";
src = fetchFromGitHub {
owner = "lxqt";
repo = pname;
rev = version;
sha256 = "1nw2r3h7ynmygpslnzjn40vvickd988nm31wy2b645xcck89q4rm";
sha256 = "zxwQfKowgpLjfxSV2t7Ly8o7DFqoIxi60zIVCcKDQWo=";
};
nativeBuildInputs = [

4
pkgs/desktops/xfce/applications/xfce4-screenshooter/default.nix
View file

@ -3,10 +3,10 @@
mkXfceDerivation {
category = "apps";
pname = "xfce4-screenshooter";
version = "1.9.9";
version = "1.9.10";
odd-unstable = false;
sha256 = "sha256-QOYJl+bxRk0+spgtGADPgkw2lPLfQOwTZQuZNHWq39c=";
sha256 = "sha256-i3QdQij58JYv3fWdESUeTV0IW3A8RVGNtmuxUc6FUMg=";
buildInputs = [ exo gtk3 libsoup libxfce4ui libxfce4util xfce4-panel glib-networking ];

2
pkgs/development/compilers/cudatoolkit/default.nix
View file

@ -86,5 +86,5 @@ rec {
gcc = gcc10; # can bump to 11 along with stdenv.cc
};
cudatoolkit_11 = cudatoolkit_11_4;
cudatoolkit_11 = cudatoolkit_11_6;
}

3
pkgs/development/libraries/capnproto/default.nix
View file

@ -21,6 +21,9 @@ stdenv.mkDerivation rec {
cmakeFlags = lib.optional (!(stdenv.hostPlatform.isCompatible stdenv.buildPlatform)) "-DEXTERNAL_CAPNP";
# Upstream 77ac9154440bcc216fda1092fd5bb51da62ae09c, modified to apply to v0.9.1. Drop on update.
patches = lib.optional stdenv.hostPlatform.isMusl ./musl-no-fibers.patch;
meta = with lib; {
homepage = "https://capnproto.org/";
description = "Cap'n Proto cerealization protocol";

244
pkgs/development/libraries/capnproto/musl-no-fibers.patch Normal file
View file

@ -0,0 +1,244 @@
From 3d983eff304c28574c330a52d70a60145c9e157e Mon Sep 17 00:00:00 2001
From: Jonas Vautherin <jonas.vautherin@gmail.com>
Date: Fri, 14 Jan 2022 00:14:26 +0100
Subject: [PATCH] Add support for musl
---
Based on upstream 77ac9154440bcc216fda1092fd5bb51da62ae09c,
modified slightly by dtzWill to apply to v0.9.1.
(drop whitespace change to a cmake "if (WITH_OPENSSL)",
leave the other instance of that change since it applies)
---
Co-authored-by: Guillaume Papin <guillaume.papin@epitech.eu>
(cherry picked from commit 77ac9154440bcc216fda1092fd5bb51da62ae09c)
---
.github/workflows/quick-test.yml | 9 ++++++
c++/CMakeLists.txt | 46 ++++++++++++++++++++++++++++-
c++/cmake/CapnProtoConfig.cmake.in | 32 ++++++++++++++++++++
c++/configure.ac | 47 ++++++++++++++++++++++++++++--
c++/src/kj/CMakeLists.txt | 11 ++++++-
5 files changed, 141 insertions(+), 4 deletions(-)
diff --git a/.github/workflows/quick-test.yml b/.github/workflows/quick-test.yml
index c18ef6a6..773ff043 100644
--- a/.github/workflows/quick-test.yml
+++ b/.github/workflows/quick-test.yml
@@ -10,6 +10,15 @@ on:
- 'release-*'
jobs:
+ Linux-musl:
+ runs-on: ubuntu-latest
+ container: alpine:latest
+ steps:
+ - uses: actions/checkout@v2
+ - name: install dependencies
+ run: apk add autoconf automake build-base cmake libtool libucontext-dev linux-headers openssl-dev
+ - name: super-test
+ run: ./super-test.sh quick
Linux:
runs-on: ubuntu-latest
strategy:
diff --git a/c++/CMakeLists.txt b/c++/CMakeLists.txt
index 548dfd1f..5de7ab26 100644
--- a/c++/CMakeLists.txt
+++ b/c++/CMakeLists.txt
@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.4)
+cmake_minimum_required(VERSION 3.6)
project("Cap'n Proto" CXX)
set(VERSION 0.9.1)
@@ -64,6 +64,50 @@ elseif (WITH_OPENSSL)
find_package(OpenSSL REQUIRED COMPONENTS Crypto SSL)
endif()
+set(WITH_FIBERS "AUTO" CACHE STRING
+ "Whether or not to build libkj-async with fibers")
+# define list of values GUI will offer for the variable
+set_property(CACHE WITH_FIBERS PROPERTY STRINGS AUTO ON OFF)
+
+# CapnProtoConfig.cmake.in needs this variable.
+set(_WITH_LIBUCONTEXT OFF)
+
+if (WITH_FIBERS OR WITH_FIBERS STREQUAL "AUTO")
+ set(_capnp_fibers_found OFF)
+ if (WIN32 OR CYGWIN)
+ set(_capnp_fibers_found ON)
+ else()
+ # Fibers need makecontext, setcontext, getcontext, swapcontext that may be in libc,
+ # or in libucontext (e.g. for musl).
+ # We assume that makecontext implies that the others are present.
+ include(CheckLibraryExists)
+ check_library_exists(c makecontext "" HAVE_UCONTEXT_LIBC)
+ if (HAVE_UCONTEXT_LIBC)
+ set(_capnp_fibers_found ON)
+ else()
+ # Try with libucontext
+ find_package(PkgConfig)
+ if (PKG_CONFIG_FOUND)
+ pkg_check_modules(libucontext IMPORTED_TARGET libucontext)
+ if (libucontext_FOUND)
+ set(_WITH_LIBUCONTEXT ON)
+ set(_capnp_fibers_found ON)
+ endif()
+ else()
+ set(_capnp_fibers_found OFF)
+ endif()
+ endif()
+ endif()
+
+ if (_capnp_fibers_found)
+ set(WITH_FIBERS ON)
+ elseif(WITH_FIBERS STREQUAL "AUTO")
+ set(WITH_FIBERS OFF)
+ else()
+ message(FATAL_ERROR "Missing 'makecontext', 'getcontext', 'setcontext' or 'swapcontext' symbol in libc and no libucontext found: KJ won't be able to build with fibers. Disable fibers (-DWITH_FIBERS=OFF).")
+ endif()
+endif()
+
if(MSVC)
# TODO(cleanup): Enable higher warning level in MSVC, but make sure to test
# build with that warning level and clean out false positives.
diff --git a/c++/cmake/CapnProtoConfig.cmake.in b/c++/cmake/CapnProtoConfig.cmake.in
index 667f502f..0580b11a 100644
--- a/c++/cmake/CapnProtoConfig.cmake.in
+++ b/c++/cmake/CapnProtoConfig.cmake.in
@@ -62,6 +62,38 @@ if (@WITH_OPENSSL@) # WITH_OPENSSL
endif()
endif()
+if (@_WITH_LIBUCONTEXT@) # _WITH_LIBUCONTEXT
+ set(forwarded_config_flags)
+ if(CapnProto_FIND_QUIETLY)
+ list(APPEND forwarded_config_flags QUIET)
+ endif()
+ if(CapnProto_FIND_REQUIRED)
+ list(APPEND forwarded_config_flags REQUIRED)
+ endif()
+ # If the consuming project called find_package(CapnProto) with the QUIET or REQUIRED flags, forward
+ # them to calls to find_package(PkgConfig) and pkg_check_modules(). Note that find_dependency()
+ # would do this for us in the former case, but there is no such forwarding wrapper for
+ # pkg_check_modules().
+
+ find_package(PkgConfig ${forwarded_config_flags})
+ if(NOT ${PkgConfig_FOUND})
+ # If we're here, the REQUIRED flag must not have been passed, else we would have had a fatal
+ # error. Nevertheless, a diagnostic for this case is probably nice.
+ if(NOT CapnProto_FIND_QUIETLY)
+ message(WARNING "pkg-config cannot be found")
+ endif()
+ set(CapnProto_FOUND OFF)
+ return()
+ endif()
+
+ if (CMAKE_VERSION VERSION_LESS 3.6)
+ # CMake >= 3.6 required due to the use of IMPORTED_TARGET
+ message(SEND_ERROR "libucontext support requires CMake >= 3.6.")
+ endif()
+
+ pkg_check_modules(libucontext IMPORTED_TARGET ${forwarded_config_flags} libucontext)
+endif()
+
include("${CMAKE_CURRENT_LIST_DIR}/CapnProtoTargets.cmake")
include("${CMAKE_CURRENT_LIST_DIR}/CapnProtoMacros.cmake")
diff --git a/c++/configure.ac b/c++/configure.ac
index 72fe8456..b627bec8 100644
--- a/c++/configure.ac
+++ b/c++/configure.ac
@@ -32,6 +32,11 @@ AC_ARG_WITH([openssl],
[build libkj-tls by linking against openssl @<:@default=check@:>@])],
[],[with_openssl=check])
+AC_ARG_WITH([fibers],
+ [AS_HELP_STRING([--with-fibers],
+ [build libkj-async with fibers @<:@default=check@:>@])],
+ [],[with_fibers=check])
+
AC_ARG_ENABLE([reflection], [
AS_HELP_STRING([--disable-reflection], [
compile Cap'n Proto in "lite mode", in which all reflection APIs (schema.h, dynamic.h, etc.)
@@ -195,8 +200,46 @@ AS_IF([test "$with_openssl" != no], [
])
AM_CONDITIONAL([BUILD_KJ_TLS], [test "$with_openssl" != no])
-# CapnProtoConfig.cmake.in needs this variable.
-AC_SUBST(WITH_OPENSSL, $with_openssl)
+# Fibers need the symbols getcontext, setcontext, swapcontext and makecontext.
+# We assume that makecontext implies the rest.
+AS_IF([test "$with_fibers" != no], [
+ libc_supports_fibers=yes
+ AC_SEARCH_LIBS([makecontext], [], [], [
+ libc_supports_fibers=no
+ ])
+
+ AS_IF([test "$libc_supports_fibers" = yes], [
+ with_fibers=yes
+ ], [
+ # If getcontext does not exist in libc, try with libucontext
+ ucontext_supports_fibers=yes
+ AC_CHECK_LIB(ucontext, [makecontext], [], [
+ ucontext_supports_fibers=no
+ ])
+ AS_IF([test "$ucontext_supports_fibers" = yes], [
+ ASYNC_LIBS="$ASYNC_LIBS -lucontext"
+ with_fibers=yes
+ ], [
+ AS_IF([test "$with_fibers" = yes], [
+ AC_MSG_ERROR([Missing symbols required for fibers (makecontext, setcontext, ...). Disable fibers (--without-fibers) or install libucontext])
+ ], [
+ AC_MSG_WARN([could not find required symbols (makecontext, setcontext, ...) -- won't build with fibers])
+ with_fibers=no
+ ])
+ ])
+ ])
+])
+AS_IF([test "$with_fibers" = yes], [
+ CXXFLAGS="$CXXFLAGS -DKJ_USE_FIBERS"
+], [
+ CXXFLAGS="$CXXFLAGS -DKJ_USE_FIBERS=0"
+])
+
+# CapnProtoConfig.cmake.in needs these variables,
+# we force them to NO because we don't need the CMake dependency for them,
+# the dependencies are provided by the .pc files.
+AC_SUBST(WITH_OPENSSL, NO)
+AC_SUBST(_WITH_LIBUCONTEXT, NO)
AM_CONDITIONAL([HAS_FUZZING_ENGINE], [test "x$LIB_FUZZING_ENGINE" != "x"])
diff --git a/c++/src/kj/CMakeLists.txt b/c++/src/kj/CMakeLists.txt
index 813fac4d..f7b4dddf 100644
--- a/c++/src/kj/CMakeLists.txt
+++ b/c++/src/kj/CMakeLists.txt
@@ -136,6 +136,15 @@ if(NOT CAPNP_LITE)
add_library(kj-async ${kj-async_sources})
add_library(CapnProto::kj-async ALIAS kj-async)
target_link_libraries(kj-async PUBLIC kj)
+ if(WITH_FIBERS)
+ target_compile_definitions(kj-async PUBLIC KJ_USE_FIBERS)
+ if(_WITH_LIBUCONTEXT)
+ target_link_libraries(kj-async PUBLIC PkgConfig::libucontext)
+ endif()
+ else()
+ target_compile_definitions(kj-async PUBLIC KJ_USE_FIBERS=0)
+ endif()
+
if(UNIX)
# external clients of this library need to link to pthreads
target_compile_options(kj-async INTERFACE "-pthread")
@@ -181,7 +190,7 @@ if(NOT CAPNP_LITE)
add_library(kj-tls ${kj-tls_sources})
add_library(CapnProto::kj-tls ALIAS kj-tls)
target_link_libraries(kj-tls PUBLIC kj-async)
- if (WITH_OPENSSL)
+ if(WITH_OPENSSL)
target_compile_definitions(kj-tls PRIVATE KJ_HAS_OPENSSL)
target_link_libraries(kj-tls PRIVATE OpenSSL::SSL OpenSSL::Crypto)
endif()
--
2.35.1

4
pkgs/development/libraries/librtprocess/default.nix
View file

@ -2,13 +2,13 @@
stdenv.mkDerivation rec {
pname = "librtprocess";
version = "0.11.0";
version = "0.12.0";
src = fetchFromGitHub {
owner = "CarVac";
repo = pname;
rev = version;
sha256 = "1bivy3rymmmkdx5phbxq4qaq15hw633dgpks57z9ara15mh817xx";
sha256 = "sha256-/1o6SWUor+ZBQ6RsK2PoDRu03jcVRG58PNYFttriH2w=";
};
nativeBuildInputs = [ cmake ];

48
pkgs/development/libraries/libvirt/0001-qemu-segmentation-fault-in-virtqemud-executing-qemuD.patch Normal file
View file

@ -0,0 +1,48 @@
From 823a62ec8aac4fb75e6e281164f3eb56ae47597c Mon Sep 17 00:00:00 2001
From: Boris Fiuczynski <fiuczy@linux.ibm.com>
Date: Tue, 1 Mar 2022 18:47:59 +0100
Subject: [PATCH] qemu: segmentation fault in virtqemud executing
qemuDomainUndefineFlags
Commit 5adfb3472342741c443ac91dee0abb18b5a3d038 causes a segmentation fault.
Stack trace of thread 664419:
#0 0x000003ff62ec553c in qemuDomainUndefineFlags (dom=0x3ff6c002810, flags=<optimized out>) at ../src/qemu/qemu_driver.c:6618
#1 0x000003ff876a7e5c in virDomainUndefineFlags (domain=domain@entry=0x3ff6c002810, flags=<optimized out>) at ../src/libvirt-domain.c:6519
#2 0x000002aa2b64a808 in remoteDispatchDomainUndefineFlags (server=0x2aa2c3d7880, msg=0x2aa2c3d2770, args=<optimized out>, rerr=0x3ff8287b950, client=<optimized out>)
at src/remote/remote_daemon_dispatch_stubs.h:13080
#3 remoteDispatchDomainUndefineFlagsHelper (server=0x2aa2c3d7880, client=<optimized out>, msg=0x2aa2c3d2770, rerr=0x3ff8287b950, args=<optimized out>, ret=0x0)
at src/remote/remote_daemon_dispatch_stubs.h:13059
#4 0x000003ff8758bbf4 in virNetServerProgramDispatchCall (msg=0x2aa2c3d2770, client=0x2aa2c3e3050, server=0x2aa2c3d7880, prog=0x2aa2c3d8010)
at ../src/rpc/virnetserverprogram.c:428
#5 virNetServerProgramDispatch (prog=0x2aa2c3d8010, server=server@entry=0x2aa2c3d7880, client=0x2aa2c3e3050, msg=0x2aa2c3d2770) at ../src/rpc/virnetserverprogram.c:302
#6 0x000003ff8758c260 in virNetServerProcessMsg (msg=<optimized out>, prog=<optimized out>, client=<optimized out>, srv=0x2aa2c3d7880) at ../src/rpc/virnetserver.c:140
#7 virNetServerHandleJob (jobOpaque=0x2aa2c3e2d30, opaque=0x2aa2c3d7880) at ../src/rpc/virnetserver.c:160
#8 0x000003ff874c49aa in virThreadPoolWorker (opaque=<optimized out>) at ../src/util/virthreadpool.c:164
#9 0x000003ff874c3f62 in virThreadHelper (data=<optimized out>) at ../src/util/virthread.c:256
#10 0x000003ff86c1cf8c in start_thread () from /lib64/libc.so.6
#11 0x000003ff86c9650e in thread_start () from /lib64/libc.so.6
Signed-off-by: Boris Fiuczynski <fiuczy@linux.ibm.com>
Reviewed-by: Jim Fehlig <jfehlig@suse.com>
Reviewed-by: Michal Privoznik <mprivozn@redhat.com>
---
src/qemu/qemu_driver.c | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/src/qemu/qemu_driver.c b/src/qemu/qemu_driver.c
index bcd9bdb436..8337eed510 100644
--- a/src/qemu/qemu_driver.c
+++ b/src/qemu/qemu_driver.c
@@ -6615,7 +6615,7 @@ qemuDomainUndefineFlags(virDomainPtr dom,
}
}
- if (vm->def->os.loader->nvram) {
+ if (vm->def->os.loader && vm->def->os.loader->nvram) {
nvram_path = g_strdup(vm->def->os.loader->nvram);
} else if (vm->def->os.firmware == VIR_DOMAIN_OS_DEF_FIRMWARE_EFI) {
qemuDomainNVRAMPathFormat(cfg, vm->def, &nvram_path);
--
2.35.1

1
pkgs/development/libraries/libvirt/default.nix
View file

@ -130,6 +130,7 @@ stdenv.mkDerivation rec {
patches = [
./0001-meson-patch-in-an-install-prefix-for-building-on-nix.patch
./0001-qemu-segmentation-fault-in-virtqemud-executing-qemuD.patch
];
# remove some broken tests

2
pkgs/development/node-packages/generate.sh
View file

@ -9,7 +9,7 @@ node2nix=$(nix-build ../../.. -A nodePackages.node2nix)
rm -f ./node-env.nix
# Track the latest active nodejs LTS here: https://nodejs.org/en/about/releases/
${node2nix}/bin/node2nix \
"${node2nix}/bin/node2nix" \
-i node-packages.json \
-o node-packages.nix \
-c composition.nix \

6071
pkgs/development/node-packages/node-packages.nix generated
View file

File diff suppressed because it is too large Load diff

11
pkgs/development/ocaml-modules/ca-certs/default.nix
View file

@ -1,28 +1,29 @@
{ lib, buildDunePackage, fetchurl
, bos, fpath, rresult, ptime, mirage-crypto, x509, astring, logs
, cacert, alcotest
, bos, fpath, ptime, mirage-crypto, x509, astring, logs
, cacert, alcotest, fmt
}:
buildDunePackage rec {
pname = "ca-certs";
version = "0.2.1";
version = "0.2.2";
minimumOCamlVersion = "4.07";
src = fetchurl {
url = "https://github.com/mirage/ca-certs/releases/download/v${version}/ca-certs-v${version}.tbz";
sha256 = "d43109496a5129feff967d557c556af96f8b10456896a405c43b7cf0c35d0af3";
sha256 = "sha256-Tx53zBJemZh3ODh/8izahxDoJvXvNFLyAA8LMM1mhlI=";
};
useDune2 = true;
propagatedBuildInputs = [ bos fpath rresult ptime mirage-crypto x509 astring logs ];
propagatedBuildInputs = [ bos fpath ptime mirage-crypto x509 astring logs ];
# Assumes nss-cacert < 3.74 https://github.com/mirage/ca-certs/issues/21
doCheck = false;
checkInputs = [
cacert # for /etc/ssl/certs/ca-bundle.crt
alcotest
fmt
];
meta = with lib; {

4
pkgs/development/ocaml-modules/gapi-ocaml/default.nix
View file

@ -5,7 +5,7 @@
buildDunePackage rec {
pname = "gapi-ocaml";
version = "0.4.1";
version = "0.4.2";
useDune2 = true;
@ -15,7 +15,7 @@ buildDunePackage rec {
owner = "astrada";
repo = pname;
rev = "v${version}";
sha256 = "0riax23grjnq9pczmp1yv02ji0svvs2kbiqskj6f6yjviamnpa31";
sha256 = "sha256-imicHOlNjPHHW/lcWRJmURafYZFe/6J3efKPJcel8J8=";
};
propagatedBuildInputs = [ cryptokit ocamlnet ocurl yojson ];

4
pkgs/development/php-packages/php-cs-fixer/default.nix
View file

@ -1,14 +1,14 @@
{ mkDerivation, fetchurl, makeWrapper, lib, php }:
let
pname = "php-cs-fixer";
version = "3.7.0";
version = "3.8.0";
in
mkDerivation {
inherit pname version;
src = fetchurl {
url = "https://github.com/FriendsOfPHP/PHP-CS-Fixer/releases/download/v${version}/php-cs-fixer.phar";
sha256 = "sha256-a7mKM++0iQm9hQFCDfyR6Jdb9h98YNHmbdQso8BU3WE=";
sha256 = "sha256-kOdJ2xuS095xVdPxoz4q/XM0BpyJEy6V/CtkuTN/Chk=";
};
dontUnpack = true;

53
pkgs/development/python-modules/boto/bug-953970_python3.8-compat.patch Normal file
View file

@ -0,0 +1,53 @@
Index: python-boto/tests/unit/utils/test_utils.py
===================================================================
--- python-boto.orig/tests/unit/utils/test_utils.py
+++ python-boto/tests/unit/utils/test_utils.py
@@ -85,7 +85,7 @@ class TestPassword(unittest.TestCase):
def hmac_hashfunc(cls, msg):
if not isinstance(msg, bytes):
msg = msg.encode('utf-8')
- return hmac.new(b'mysecretkey', msg)
+ return hmac.new(b'mysecretkey', msg, digestmod='sha256')
class HMACPassword(Password):
hashfunc = hmac_hashfunc
@@ -95,15 +95,15 @@ class TestPassword(unittest.TestCase):
password.set('foo')
self.assertEquals(str(password),
- hmac.new(b'mysecretkey', b'foo').hexdigest())
+ hmac.new(b'mysecretkey', b'foo', digestmod='sha256').hexdigest())
def test_constructor(self):
- hmac_hashfunc = lambda msg: hmac.new(b'mysecretkey', msg)
+ hmac_hashfunc = lambda msg: hmac.new(b'mysecretkey', msg, digestmod='sha256')
password = Password(hashfunc=hmac_hashfunc)
password.set('foo')
self.assertEquals(password.str,
- hmac.new(b'mysecretkey', b'foo').hexdigest())
+ hmac.new(b'mysecretkey', b'foo', digestmod='sha256').hexdigest())
class TestPythonizeName(unittest.TestCase):
Index: python-boto/boto/ecs/item.py
===================================================================
--- python-boto.orig/boto/ecs/item.py
+++ python-boto/boto/ecs/item.py
@@ -22,6 +22,7 @@
import xml.sax
import cgi
+from html import escape
from boto.compat import six, StringIO
class ResponseGroup(xml.sax.ContentHandler):
@@ -67,7 +68,7 @@ class ResponseGroup(xml.sax.ContentHandl
return None
def endElement(self, name, value, connection):
- self._xml.write("%s</%s>" % (cgi.escape(value).replace("&amp;amp;", "&amp;"), name))
+ self._xml.write("%s</%s>" % (escape(value).replace("&amp;amp;", "&amp;"), name))
if len(self._nodepath) == 0:
return
obj = None

10
pkgs/development/python-modules/boto/default.nix
View file

@ -2,7 +2,6 @@
, buildPythonPackage
, fetchPypi
, pythonAtLeast
, isPy38
, python
, nose
, mock
@ -13,18 +12,23 @@
buildPythonPackage rec {
pname = "boto";
version = "2.49.0";
disabled = pythonAtLeast "3.9"; # no longer compatible with hmac std lib package
disabled = pythonAtLeast "3.10"; # cannot import name 'Mapping' from 'collections'
src = fetchPypi {
inherit pname version;
sha256 = "ea0d3b40a2d852767be77ca343b58a9e3a4b00d9db440efb8da74b4e58025e5a";
};
patches = [
# fixes hmac tests
# https://sources.debian.org/src/python-boto/2.49.0-4/debian/patches/bug-953970_python3.8-compat.patch/
./bug-953970_python3.8-compat.patch
];
checkPhase = ''
${python.interpreter} tests/test.py default
'';
doCheck = !isPy38; # hmac functionality has changed
checkInputs = [ nose mock ];
propagatedBuildInputs = [ requests httpretty ];

6
pkgs/development/python-modules/mitmproxy/default.nix
View file

@ -45,14 +45,14 @@
buildPythonPackage rec {
pname = "mitmproxy";
version = "7.0.4";
version = "8.0.0";
disabled = pythonOlder "3.8";
src = fetchFromGitHub {
owner = pname;
repo = pname;
rev = "v${version}";
sha256 = "sha256-424WNG9Yj+Zfo1UTh7emknZ7xTtpFPz7Ph+FpE149FM=";
sha256 = "sha256-Efazsi8BjBrk7lBKSn2APKHxCc7mzxNrC92BL0VsnCM=";
};
propagatedBuildInputs = [
@ -98,8 +98,6 @@ buildPythonPackage rec {
requests
];
doCheck = !stdenv.isDarwin;
postPatch = ''
# remove dependency constraints
sed 's/>=\([0-9]\.\?\)\+\( \?, \?<\([0-9]\.\?\)\+\)\?\( \?, \?!=\([0-9]\.\?\)\+\)\?//' -i setup.py

3
pkgs/development/python-modules/myfitnesspal/default.nix
View file

@ -15,9 +15,6 @@
, pythonOlder
}:
# TODO: Define this package in "all-packages.nix" using "toPythonApplication".
# This currently errors out, complaining about not being able to find "etree" from "lxml" even though "lxml" is defined in "propagatedBuildInputs".
buildPythonPackage rec {
pname = "myfitnesspal";
version = "1.17.0";

4
pkgs/development/python-modules/openai/default.nix
View file

@ -17,7 +17,7 @@
buildPythonPackage rec {
pname = "openai";
version = "0.15.0";
version = "0.16.0";
disabled = pythonOlder "3.7.1";
@ -26,7 +26,7 @@ buildPythonPackage rec {
owner = "openai";
repo = "openai-python";
rev = "v${version}";
sha256 = "sha256-HOMBVrAz3cP8r4w8CKXKy6epxf00myYJiKv1PQ1iqhQ=";
sha256 = "sha256-9BxFOiGIf3Cy7OU0as6onV5ltECInM9wwCr+qCMuPbU=";
};
propagatedBuildInputs = [

4
pkgs/development/python-modules/simplisafe-python/default.nix
View file

@ -19,7 +19,7 @@
buildPythonPackage rec {
pname = "simplisafe-python";
version = "2022.02.1";
version = "2022.03.0";
format = "pyproject";
disabled = pythonOlder "3.8";
@ -28,7 +28,7 @@ buildPythonPackage rec {
owner = "bachya";
repo = pname;
rev = version;
sha256 = "sha256-r+TcSzFkEGRsuTtEHBT/GMNa9r6GsIyvbLaF32cFfeQ=";
sha256 = "sha256-B4Tg122S2lJaBXBKUSN2ndt5EOiC5HyORTQXofZKUpw=";
};
nativeBuildInputs = [

39
pkgs/development/python-modules/slixmpp/default.nix
View file

@ -4,31 +4,25 @@
, aiohttp
, fetchPypi
, gnupg
, isPy3k
, pyasn1
, pyasn1-modules
, pytestCheckHook
, substituteAll
, pythonOlder
}:
buildPythonPackage rec {
pname = "slixmpp";
version = "1.8.0.1";
version = "1.8.1";
format = "setuptools";
disabled = !isPy3k;
disabled = pythonOlder "3.7";
src = fetchPypi {
inherit pname version;
sha256 = "sha256-J3znZl77jST94KhUBQcCxSK0qnsVWIYTG6u3po5FHh8=";
hash = "sha256-QgTIC+4JtAD9nnS+fJKZwF0aJEIrFmPHkYg8cPgXmcA=";
};
patches = [
(substituteAll {
src = ./hardcode-gnupg-path.patch;
inherit gnupg;
})
];
propagatedBuildInputs = [
aiodns
aiohttp
@ -36,15 +30,28 @@ buildPythonPackage rec {
pyasn1-modules
];
checkInputs = [ pytestCheckHook ];
checkInputs = [
pytestCheckHook
];
# Exclude live tests
disabledTestPaths = [ "tests/live_test.py" ];
patches = [
(substituteAll {
src = ./hardcode-gnupg-path.patch;
inherit gnupg;
})
];
pythonImportsCheck = [ "slixmpp" ];
disabledTestPaths = [
# Exclude live tests
"tests/live_test.py"
];
pythonImportsCheck = [
"slixmpp"
];
meta = with lib; {
description = "Elegant Python library for XMPP";
description = "Python library for XMPP";
homepage = "https://slixmpp.readthedocs.io/";
license = licenses.mit;
maintainers = with maintainers; [ fab ];

4
pkgs/development/python-modules/xmlschema/default.nix
View file

@ -8,7 +8,7 @@
}:
buildPythonPackage rec {
version = "1.9.2";
version = "1.10.0";
pname = "xmlschema";
disabled = pythonOlder "3.6";
@ -17,7 +17,7 @@ buildPythonPackage rec {
owner = "sissaschool";
repo = "xmlschema";
rev = "v${version}";
sha256 = "1d18x150g0jz3nw5al5dygizwkjgzdnmd5kf46v8ribfz48iirr6";
sha256 = "sha256-er6+/2fZTw+CDIwCGqTNoXi7KJ3XOsbcWYaH8A2SSgo=";
};
propagatedBuildInputs = [

26
pkgs/development/python-modules/youtube-search-python/default.nix
View file

@ -1,27 +1,37 @@
{ lib, buildPythonPackage, pythonOlder, fetchPypi, httpx }:
{ lib
, buildPythonPackage
, pythonOlder
, fetchPypi
, httpx
}:
buildPythonPackage rec {
pname = "youtube-search-python";
version = "1.6.2";
version = "1.6.3";
format = "setuptools";
disabled = pythonOlder "3.6";
src = fetchPypi {
inherit pname version;
sha256 = "sha256-PeWi1eygUSgUXZ68bUJ44IoffNDme06JNR9ns6njqMU=";
hash = "sha256-zAza1XMKLIMZFFS0v/4ATqh6j7aEB2Y+eliE/hNPORw=";
};
propagatedBuildInputs = [ httpx ];
propagatedBuildInputs = [
httpx
];
pythonImportsCheck = [ "youtubesearchpython" ];
pythonImportsCheck = [
"youtubesearchpython"
];
# project has no tests
# Project has no tests
doCheck = false;
meta = with lib; {
description = "Search for YouTube videos, channels & playlists & get video information using link WITHOUT YouTube Data API v3";
description = "Search for YouTube videos, channels & playlists & get video information using link without YouTube Data API";
homepage = "https://github.com/alexmercerind/youtube-search-python";
license = licenses.mit;
maintainers = [ maintainers.marsam ];
maintainers = with maintainers; [ marsam ];
};
}

4
pkgs/development/tools/database/sqlcheck/default.nix
View file

@ -2,13 +2,13 @@
stdenv.mkDerivation rec {
pname = "sqlcheck";
version = "1.2";
version = "1.3";
src = fetchFromGitHub {
owner = "jarulraj";
repo = "sqlcheck";
rev = "v${version}";
sha256 = "0v8idyhwhbphxzmh03lih3wd9gdq317zn7wsf01infih7b6l0k69";
sha256 = "sha256-rGqCtEO2K+OT44nYU93mF1bJ07id+ixPkRSC8DcO6rY=";
fetchSubmodules = true;
};

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