Merge branch 'master' into staging

lib/licenses.nix

@@ -134,6 +134,11 @@ lib.mapAttrs (n: v: v // { shortName = n; }) rec {
     fullName = "Unspecified free software license";
   };
 
+  gpl1 = spdx {
+    shortName = "GPL-1.0";
+    fullName = "GNU General Public License v1.0 only";
+  };
+
   gpl1Plus = spdx {
     spdxId = "GPL-1.0+";
     fullName = "GNU General Public License v1.0 or later";

lib/maintainers.nix

@@ -7,6 +7,7 @@
   _1126 = "Christian Lask <mail@elfsechsundzwanzig.de>";
   abbradar = "Nikolay Amiantov <ab@fmap.me>";
   aforemny = "Alexander Foremny <alexanderforemny@googlemail.com>";
+  aherrmann = "Andreas Herrmann <andreash87@gmx.ch>";
   ak = "Alexander Kjeldaas <ak@formalprivacy.com>";
   akc = "Anders Claesson <akc@akc.is>";
   algorith = "Dries Van Daele <dries_van_daele@telenet.be>";
@@ -84,7 +85,9 @@
   joachifm = "Joachim Fasting <joachifm@fastmail.fm>";
   joamaki = "Jussi Maki <joamaki@gmail.com>";
   joelteon = "Joel Taylor <me@joelt.io>";
+  jpbernardy = "Jean-Philippe Bernardy <jeanphilippe.bernardy@gmail.com>";
   jwiegley = "John Wiegley <johnw@newartisans.com>";
+  jzellner = "Jeff Zellner <jeffz@eml.cc>";
   kkallio = "Karn Kallio <tierpluspluslists@gmail.com>";
   koral = "Koral <koral@mailoo.org>";
   kragniz = "Louis Taylor <kragniz@gmail.com>";
@@ -95,6 +98,7 @@
   lovek323 = "Jason O'Conal <jason@oconal.id.au>";
   ludo = "Ludovic Courtès <ludo@gnu.org>";
   madjar = "Georges Dubus <georges.dubus@compiletoi.net>";
+  magnetophon = "Bart Brouns <bart@magnetophon.nl>";
   manveru = "Michael Fellinger <m.fellinger@gmail.com>";
   marcweber = "Marc Weber <marco-oweber@gmx.de>";
   matejc = "Matej Cotman <cotman.matej@gmail.com>";
@@ -105,6 +109,7 @@
   MP2E = "Cray Elliott <MP2E@archlinux.us>";
   msackman = "Matthew Sackman <matthew@wellquite.org>";
   nathan-gs = "Nathan Bijnens <nathan@nathan.gs>";
+  nckx = "Tobias Geerinckx-Rice <tobias.geerinckx.rice@gmail.com>";
   notthemessiah = "Brian Cohen <brian.cohen.88@gmail.com>";
   nslqqq = "Nikita Mikhailov <nslqqq@gmail.com>";
   ocharles = "Oliver Charles <ollie@ocharles.org.uk>";

nixos/doc/manual/default.nix

@@ -30,34 +30,13 @@ let
     else
       fn;
 
-  # Convert the list of options into an XML file and a JSON file.  The builtin
+  # Convert the list of options into an XML file.  The builtin
-  # unsafeDiscardStringContext is used to prevent the realisation of the store
+  # unsafeDiscardStringContext is used to prevent the realisation of
-  # paths which are used in options definitions.
+  # the store paths which are used in options definitions.
   optionsXML = builtins.toFile "options.xml" (builtins.unsafeDiscardStringContext (builtins.toXML optionsList'));
-  optionsJSON = builtins.toFile "options.json" (builtins.unsafeDiscardStringContext (builtins.toJSON optionsList'));
-
-  # Tools-friendly version of the list of NixOS options.
-  options' = stdenv.mkDerivation {
-    name = "options";
-
-    buildCommand = ''
-      # Export list of options in different format.
-      dst=$out/share/doc/nixos
-      mkdir -p $dst
-
-      cp ${optionsJSON} $dst/options.json
-      cp ${optionsXML} $dst/options.xml
-
-      mkdir -p $out/nix-support
-      echo "file json $dst/options.json" >> $out/nix-support/hydra-build-products
-      echo "file xml $dst/options.xml" >> $out/nix-support/hydra-build-products
-    ''; # */
-
-    meta.description = "List of NixOS options in various formats.";
-  };
 
   optionsDocBook = runCommand "options-db.xml" {} ''
-    optionsXML=${options'}/share/doc/nixos/options.xml
+    optionsXML=${optionsXML}
     if grep /nixpkgs/nixos/modules $optionsXML; then
       echo "The manual appears to depend on the location of Nixpkgs, which is bad"
       echo "since this prevents sharing via the NixOS channel.  This is typically"
@@ -83,8 +62,25 @@ let
 
 in rec {
 
-  # Tools-friendly version of the list of NixOS options.
+  # The NixOS options in JSON format.
-  options = options';
+  optionsJSON = stdenv.mkDerivation {
+    name = "options-json";
+
+    buildCommand = ''
+      # Export list of options in different format.
+      dst=$out/share/doc/nixos
+      mkdir -p $dst
+
+      cp ${builtins.toFile "options.json" (builtins.unsafeDiscardStringContext (builtins.toJSON
+        (listToAttrs (map (o: { name = o.name; value = removeAttrs o ["name" "visible" "internal"]; }) optionsList'))))
+      } $dst/options.json
+
+      mkdir -p $out/nix-support
+      echo "file json $dst/options.json" >> $out/nix-support/hydra-build-products
+    ''; # */
+
+    meta.description = "List of NixOS options in JSON format";
+  };
 
   # Generate the NixOS manual.
   manual = stdenv.mkDerivation {

nixos/doc/manual/installation/installing.xml

@@ -11,14 +11,9 @@
   <listitem><para>Boot from the CD.</para></listitem>
 
   <listitem><para>The CD contains a basic NixOS installation.  (It
-  also contains Memtest86+, useful if you want to test new hardware.)
+  also contains Memtest86+, useful if you want to test new hardware).
   When it’s finished booting, it should have detected most of your
-  hardware and brought up networking (check
+  hardware.</para></listitem>
-  <command>ifconfig</command>).  Networking is necessary for the
-  installer, since it will download lots of stuff (such as source
-  tarballs or Nixpkgs channel binaries).  It’s best if you have a DHCP
-  server on your network.  Otherwise configure networking manually
-  using <command>ifconfig</command>.</para></listitem>
 
   <listitem><para>The NixOS manual is available on virtual console 8
   (press Alt+F8 to access).</para></listitem>
@@ -29,6 +24,16 @@
   <listitem><para>If you downloaded the graphical ISO image, you can
   run <command>start display-manager</command> to start KDE.</para></listitem>
 
+  <listitem><para>The boot process should have brought up networking (check
+  <command>ifconfig</command>).  Networking is necessary for the
+  installer, since it will download lots of stuff (such as source
+  tarballs or Nixpkgs channel binaries).  It’s best if you have a DHCP
+  server on your network. Otherwise configure networking manually
+  using <command>ifconfig</command>.</para>
+  <para>To manually configure the network on the graphical installer,
+  first disable NetworkManager with
+  <command>stop NetworkManager</command>.</para></listitem>
+
   <listitem><para>The NixOS installer doesn’t do any partitioning or
   formatting yet, so you need to that yourself.  Use the following
   commands:

nixos/doc/manual/release-notes/rl-1411.xml

@@ -28,6 +28,8 @@ services.httpd.package = pkgs.apacheHttpd_2_2;
   is now called <literal>ve-<replaceable>container-name</replaceable></literal>
   rather than <literal>c-<replaceable>container-name</replaceable></literal>.</para></listitem>
 
+  <listitem><para>GNOME 3.10 support has been dropped. The default GNOME version is now 3.12.</para></listitem>
+
 </itemizedlist>
 
 </para>

nixos/modules/installer/cd-dvd/installation-cd-graphical.nix

@@ -14,6 +14,10 @@ with lib;
   # Include gparted for partitioning disks
   environment.systemPackages = [ pkgs.gparted ];
   
+  # Provide networkmanager for easy wireless configuration.
+  networking.networkmanager.enable = true;
+  networking.wireless.enable = mkForce false;
+
   # KDE complains if power management is disabled (to be precise, if
   # there is no power management backend such as upower).
   powerManagement.enable = true;

nixos/modules/installer/tools/nixos-generate-config.pl

@@ -430,7 +430,7 @@ my $hwConfig = <<EOF;
 # Do not modify this file!  It was generated by ‘nixos-generate-config’
 # and may be overwritten by future invocations.  Please make changes
 # to /etc/nixos/configuration.nix instead.
-{ config, pkgs, ... }:
+{ config, lib, pkgs, ... }:
 
 {
   imports =${\multiLineList("    ", @imports)};

nixos/modules/misc/ids.nix

@@ -159,6 +159,16 @@
       prosody = 149;
       i2pd = 150;
       dnscrypt-proxy = 151;
+      systemd-network = 152;
+      systemd-resolve = 153;
+      systemd-timesync = 154;
+      liquidsoap = 155;
+      etcd = 156;
+      docker-registry = 157;
+      hbase = 158;
+      opentsdb = 159;
+      scollector = 160;
+      bosun = 161;
 
       # When adding a uid, make sure it doesn't match an existing gid. And don't use uids above 399!
 
@@ -278,12 +288,20 @@
       mlmmj = 135;
       riemann = 137;
       riemanndash = 138;
+      hbase = 139;
+      opentsdb = 140;
       uhub = 142;
       mailpile = 146;
       redmine = 147;
       seeks = 148;
       prosody = 149;
       i2pd = 150;
+      systemd-network = 152;
+      systemd-resolve = 153;
+      systemd-timesync = 154;
+      liquidsoap = 155;
+      scollector = 156;
+      bosun = 157;
 
       # When adding a gid, make sure it doesn't match an existing uid. And don't use gids above 399!
 

nixos/modules/module-list.nix

@@ -89,6 +89,7 @@
   ./services/audio/alsa.nix
   # Disabled as fuppes it does no longer builds.
   # ./services/audio/fuppes.nix
+  ./services/audio/liquidsoap.nix
   ./services/audio/mpd.nix
   ./services/audio/mopidy.nix
   ./services/backup/almir.nix
@@ -107,6 +108,7 @@
   ./services/databases/4store.nix
   ./services/databases/couchdb.nix
   ./services/databases/firebird.nix
+  ./services/databases/hbase.nix
   ./services/databases/influxdb.nix
   ./services/databases/memcached.nix
   ./services/databases/monetdb.nix
@@ -114,6 +116,7 @@
   ./services/databases/mysql.nix
   ./services/databases/neo4j.nix
   ./services/databases/openldap.nix
+  ./services/databases/opentsdb.nix
   ./services/databases/postgresql.nix
   ./services/databases/redis.nix
   ./services/databases/virtuoso.nix
@@ -165,6 +168,8 @@
   ./services/misc/cgminer.nix
   ./services/misc/dictd.nix
   ./services/misc/disnix.nix
+  ./services/misc/docker-registry.nix
+  ./services/misc/etcd.nix
   ./services/misc/felix.nix
   ./services/misc/folding-at-home.nix
   ./services/misc/gitolite.nix
@@ -185,6 +190,7 @@
   ./services/misc/uhub.nix
   ./services/misc/zookeeper.nix
   ./services/monitoring/apcupsd.nix
+  ./services/monitoring/bosun.nix
   ./services/monitoring/collectd.nix
   ./services/monitoring/dd-agent.nix
   ./services/monitoring/graphite.nix
@@ -193,6 +199,7 @@
   ./services/monitoring/nagios.nix
   ./services/monitoring/riemann.nix
   ./services/monitoring/riemann-dash.nix
+  ./services/monitoring/scollector.nix
   ./services/monitoring/smartd.nix
   ./services/monitoring/statsd.nix
   ./services/monitoring/systemhealth.nix

nixos/modules/services/audio/liquidsoap.nix

@@ -0,0 +1,74 @@
+{ config, lib, pkgs, ... }:
+
+with lib;
+
+let
+  streams = builtins.attrNames config.services.liquidsoap.streams;
+
+  streamService =
+    name:
+    let stream = builtins.getAttr name config.services.liquidsoap.streams; in
+    { inherit name;
+      value = {
+        after = [ "network-online.target" "sound.target" ];
+        description = "${name} liquidsoap stream";
+        wantedBy = [ "multi-user.target" ];
+        path = [ pkgs.wget ];
+        preStart =
+          ''
+            mkdir -p /var/log/liquidsoap
+            chown liquidsoap -R /var/log/liquidsoap
+          '';
+        serviceConfig = {
+          PermissionsStartOnly="true";
+          ExecStart = "${pkgs.liquidsoap}/bin/liquidsoap ${stream}";
+          User = "liquidsoap";
+        };
+      };
+    };
+in
+{
+
+  ##### interface
+
+  options = {
+
+    services.liquidsoap.streams = mkOption {
+
+      description =
+        ''
+          Set of Liquidsoap streams to start,
+          one systemd service per stream.
+        '';
+
+      default = {};
+
+      example = {
+        myStream1 = literalExample "\"/etc/liquidsoap/myStream1.liq\"";
+        myStream2 = literalExample "./myStream2.liq";
+        myStream3 = literalExample "\"out(playlist(\"/srv/music/\"))\"";
+      };
+
+      type = types.attrsOf (types.either types.path types.str);
+    };
+
+  };
+  ##### implementation
+
+  config = mkIf (builtins.length streams != 0) {
+
+    users.extraUsers.liquidsoap = {
+      uid = config.ids.uids.liquidsoap;
+      group = "liquidsoap";
+      extraGroups = [ "audio" ];
+      description = "Liquidsoap streaming user";
+      home = "/var/lib/liquidsoap";
+      createHome = true;
+    };
+
+    users.extraGroups.liquidsoap.gid = config.ids.gids.liquidsoap;
+
+    systemd.services = builtins.listToAttrs ( map streamService streams );
+  };
+
+}

nixos/modules/services/backup/crashplan.nix

@@ -1,4 +1,4 @@
-{ config, pkgs, ... }:
+{ config, pkgs, lib, ... }:
 
 let
   cfg = config.services.crashplan;
@@ -6,7 +6,7 @@ let
   varDir = "/var/lib/crashplan";
 in
 
-with pkgs.lib;
+with lib;
 
 {
   options = {

nixos/modules/services/databases/hbase.nix

@@ -0,0 +1,133 @@
+{ config, lib, pkgs, ... }:
+
+with lib;
+
+let
+  cfg = config.services.hbase;
+
+  configFile = pkgs.writeText "hbase-site.xml" ''
+    <configuration>
+      <property>
+        <name>hbase.rootdir</name>
+        <value>file://${cfg.dataDir}/hbase</value>
+      </property>
+      <property>
+        <name>hbase.zookeeper.property.dataDir</name>
+        <value>${cfg.dataDir}/zookeeper</value>
+      </property>
+    </configuration>
+  '';
+
+  configDir = pkgs.runCommand "hbase-config-dir" {} ''
+    mkdir -p $out
+    cp ${cfg.package}/conf/* $out/
+    rm $out/hbase-site.xml
+    ln -s ${configFile} $out/hbase-site.xml
+  '' ;
+
+in {
+
+  ###### interface
+
+  options = {
+
+    services.hbase = {
+
+      enable = mkOption {
+        type = types.bool;
+        default = false;
+        description = ''
+          Whether to run HBase.
+        '';
+      };
+
+      package = mkOption {
+        type = types.package;
+        default = pkgs.hbase;
+        example = literalExample "pkgs.hbase";
+        description = ''
+          HBase package to use.
+        '';
+      };
+
+
+      user = mkOption {
+        type = types.string;
+        default = "hbase";
+        description = ''
+          User account under which HBase runs.
+        '';
+      };
+
+      group = mkOption {
+        type = types.string;
+        default = "hbase";
+        description = ''
+          Group account under which HBase runs.
+        '';
+      };
+
+      dataDir = mkOption {
+        type = types.path;
+        default = "/var/lib/hbase";
+        description = ''
+          Specifies location of HBase database files. This location should be
+          writable and readable for the user the HBase service runs as
+          (hbase by default).
+        '';
+      };
+
+      logDir = mkOption {
+        type = types.path;
+        default = "/var/log/hbase";
+        description = ''
+          Specifies the location of HBase log files.
+        '';
+      };
+
+    };
+
+  };
+
+  ###### implementation
+
+  config = mkIf config.services.hbase.enable {
+
+    systemd.services.hbase = {
+      description = "HBase Server";
+      wantedBy = [ "multi-user.target" ];
+
+      environment = {
+        JAVA_HOME = "${pkgs.jre}";
+        HBASE_LOG_DIR = cfg.logDir;
+      };
+
+      preStart =
+        ''
+        mkdir -p ${cfg.dataDir};
+        mkdir -p ${cfg.logDir};
+
+        if [ "$(id -u)" = 0 ]; then
+          chown ${cfg.user}:${cfg.group} ${cfg.dataDir}
+          chown ${cfg.user}:${cfg.group} ${cfg.logDir}
+        fi
+        '';
+
+      serviceConfig = {
+        PermissionsStartOnly = true;
+        User = cfg.user;
+        Group = cfg.group;
+        ExecStart = "${cfg.package}/bin/hbase --config ${configDir} master start";
+      };
+    };
+
+    users.extraUsers.hbase = {
+      description = "HBase Server user";
+      group = "hbase";
+      uid = config.ids.uids.hbase;
+    };
+
+    users.extraGroups.hbase.gid = config.ids.gids.hbase;
+
+  };
+}

nixos/modules/services/databases/opentsdb.nix

@@ -0,0 +1,100 @@
+{ config, lib, pkgs, ... }:
+
+with lib;
+
+let
+  cfg = config.services.opentsdb;
+
+  configFile = pkgs.writeText "opentsdb.conf" ''
+    tsd.core.auto_create_metrics = true
+    tsd.http.request.enable_chunked  = true
+  '';
+
+in {
+
+  ###### interface
+
+  options = {
+
+    services.opentsdb = {
+
+      enable = mkOption {
+        type = types.bool;
+        default = false;
+        description = ''
+          Whether to run OpenTSDB.
+        '';
+      };
+
+      package = mkOption {
+        type = types.package;
+        default = pkgs.opentsdb;
+        example = literalExample "pkgs.opentsdb";
+        description = ''
+          OpenTSDB package to use.
+        '';
+      };
+
+      user = mkOption {
+        type = types.string;
+        default = "opentsdb";
+        description = ''
+          User account under which OpenTSDB runs.
+        '';
+      };
+
+      group = mkOption {
+        type = types.string;
+        default = "opentsdb";
+        description = ''
+          Group account under which OpenTSDB runs.
+        '';
+      };
+
+      port = mkOption {
+        type = types.int;
+        default = 4242;
+        description = ''
+          Which port OpenTSDB listens on.
+        '';
+      };
+
+    };
+
+  };
+
+  ###### implementation
+
+  config = mkIf config.services.opentsdb.enable {
+
+    systemd.services.opentsdb = {
+      description = "OpenTSDB Server";
+      wantedBy = [ "multi-user.target" ];
+      requires = [ "hbase.service" ];
+
+      environment.JAVA_HOME = "${pkgs.jre}";
+      path = [ pkgs.gnuplot ];
+
+      preStart =
+        ''
+        COMPRESSION=NONE HBASE_HOME=${config.services.hbase.package} ${cfg.package}/share/opentsdb/tools/create_table.sh
+        '';
+
+      serviceConfig = {
+        PermissionsStartOnly = true;
+        User = cfg.user;
+        Group = cfg.group;
+        ExecStart = "${cfg.package}/bin/tsdb tsd --staticroot=${cfg.package}/share/opentsdb/static --cachedir=/tmp/opentsdb --port=${toString cfg.port} --config=${configFile}";
+      };
+    };
+
+    users.extraUsers.opentsdb = {
+      description = "OpenTSDB Server user";
+      group = "opentsdb";
+      uid = config.ids.uids.opentsdb;
+    };
+
+    users.extraGroups.opentsdb.gid = config.ids.gids.opentsdb;
+
+  };
+}

nixos/modules/services/misc/docker-registry.nix

@@ -0,0 +1,82 @@
+{ config, lib, pkgs, ... }:
+
+with lib;
+
+let
+  cfg = config.services.dockerRegistry;
+
+in {
+  ###### interface
+
+  options.services.dockerRegistry = {
+    enable = mkOption {
+      description = "Whether to enable docker registry server.";
+      default = false;
+      type = types.bool;
+    };
+
+    host = mkOption {
+      description = "Docker registry host or ip to bind to.";
+      default = "127.0.0.1";
+      type = types.str;
+    };
+
+    port = mkOption {
+      description = "Docker registry port to bind to.";
+      default = 5000;
+      type = types.int;
+    };
+
+    storagePath = mkOption {
+      type = types.path;
+      default = "/var/lib/docker/registry";
+      description = "Docker registry strorage path.";
+    };
+
+    extraConfig = mkOption {
+      description = ''
+        Docker extra registry configuration. See
+        <link xlink:href="https://github.com/docker/docker-registry/blob/master/config/config_sample.yml"/>
+      '';
+      default = {};
+      type = types.attrsOf types.str;
+    };
+  };
+
+  config = mkIf cfg.enable {
+    systemd.services.docker-registry = {
+      description = "Docker Container Registry";
+      wantedBy = [ "multi-user.target" ];
+      after = [ "network.target" ];
+
+      environment = {
+        REGISTRY_HOST = cfg.host;
+        REGISTRY_PORT = toString cfg.port;
+        GUNICORN_OPTS = "[--preload]"; # see https://github.com/docker/docker-registry#sqlalchemy
+        STORAGE_PATH = cfg.storagePath;
+      } // cfg.extraConfig;
+
+      serviceConfig = {
+        ExecStart = "${pkgs.pythonPackages.docker_registry}/bin/docker-registry";
+        User = "docker-registry";
+        Group = "docker";
+        PermissionsStartOnly = true;
+      };
+
+      preStart = ''
+        mkdir -p ${cfg.storagePath}
+        if [ "$(id -u)" = 0 ]; then
+          chown -R docker-registry:docker ${cfg.storagePath}
+        fi
+      '';
+      postStart = ''
+        until ${pkgs.curl}/bin/curl -s -o /dev/null 'http://${cfg.host}:${toString cfg.port}/'; do
+          sleep 1;
+        done
+      '';
+    };
+
+    users.extraGroups.docker.gid = mkDefault config.ids.gids.docker;
+    users.extraUsers.docker-registry.uid = config.ids.uids.docker-registry;
+  };
+}

nixos/modules/services/misc/etcd.nix

@@ -0,0 +1,144 @@
+{ config, lib, pkgs, ... }:
+
+with lib;
+
+let
+  cfg = config.services.etcd;
+
+in {
+
+  options.services.etcd = {
+    enable = mkOption {
+      description = "Whether to enable etcd.";
+      default = false;
+      type = types.uniq types.bool;
+    };
+
+    name = mkOption {
+      description = "Etcd unique node name.";
+      default = config.networking.hostName;
+      type = types.str;
+    };
+
+    advertiseClientUrls = mkOption {
+      description = "Etcd list of this member's client URLs to advertise to the rest of the cluster.";
+      default = cfg.listenClientUrls;
+      type = types.listOf types.str;
+    };
+
+    listenClientUrls = mkOption {
+      description = "Etcd list of URLs to listen on for client traffic.";
+      default = ["http://localhost:4001"];
+      type = types.listOf types.str;
+    };
+
+    listenPeerUrls = mkOption {
+      description = "Etcd list of URLs to listen on for peer traffic.";
+      default = ["http://localhost:7001"];
+      type = types.listOf types.str;
+    };
+
+    initialAdvertisePeerUrls = mkOption {
+      description = "Etcd list of this member's peer URLs to advertise to rest of the cluster.";
+      default = cfg.listenPeerUrls;
+      type = types.listOf types.str;
+    };
+
+    initialCluster = mkOption {
+      description = "Etcd initial cluster configuration for bootstrapping.";
+      default = ["${cfg.name}=http://localhost:7001"];
+      type = types.listOf types.str;
+    };
+
+    initialClusterState = mkOption {
+      description = "Etcd initial cluster configuration for bootstrapping.";
+      default = "new";
+      type = types.enum ["new" "existing"];
+    };
+
+    initialClusterToken = mkOption {
+      description = "Etcd initial cluster token for etcd cluster during bootstrap.";
+      default = "etcd-cluster";
+      type = types.str;
+    };
+
+    discovery = mkOption {
+      description = "Etcd discovery url";
+      default = "";
+      type = types.str;
+    };
+
+    extraConf = mkOption {
+      description = ''
+        Etcd extra configuration. See
+        <link xlink:href='https://github.com/coreos/etcd/blob/master/Documentation/configuration.md#environment-variables' />
+      '';
+      type = types.attrsOf types.str;
+      default = {};
+      example = literalExample ''
+        {
+          "CORS": "*",
+          "NAME": "default-name",
+          "MAX_RESULT_BUFFER": "1024",
+          "MAX_CLUSTER_SIZE": "9",
+          "MAX_RETRY_ATTEMPTS": "3"
+        }
+      '';
+    };
+
+    dataDir = mkOption {
+      type = types.path;
+      default = "/var/lib/etcd";
+      description = "Etcd data directory.";
+    };
+  };
+
+  config = mkIf cfg.enable {
+    systemd.services.etcd = {
+      description = "Etcd Daemon";
+      wantedBy = [ "multi-user.target" ];
+      after = [ "network-interfaces.target" ];
+
+      environment = {
+        ETCD_NAME = cfg.name;
+        ETCD_DISCOVERY = cfg.discovery;
+        ETCD_DATA_DIR = cfg.dataDir;
+        ETCD_ADVERTISE_CLIENT_URLS = concatStringsSep "," cfg.advertiseClientUrls;
+        ETCD_LISTEN_CLIENT_URLS = concatStringsSep "," cfg.listenClientUrls;
+        ETCD_LISTEN_PEER_URLS = concatStringsSep "," cfg.listenPeerUrls;
+        ETCD_INITIAL_ADVERTISE_PEER_URLS = concatStringsSep "," cfg.initialAdvertisePeerUrls;
+      } // (optionalAttrs (cfg.discovery == ""){
+        ETCD_INITIAL_CLUSTER = concatStringsSep "," cfg.initialCluster;
+        ETCD_INITIAL_CLUSTER_STATE = cfg.initialClusterState;
+        ETCD_INITIAL_CLUSTER_TOKEN = cfg.initialClusterToken;
+      }) // (mapAttrs' (n: v: nameValuePair "ETCD_${n}" v) cfg.extraConf);
+
+      serviceConfig = {
+        ExecStart = "${pkgs.etcd}/bin/etcd";
+        User = "etcd";
+        PermissionsStartOnly = true;
+      };
+      preStart = ''
+        mkdir -m 0700 -p ${cfg.dataDir}
+        if [ "$(id -u)" = 0 ]; then chown etcd ${cfg.dataDir}; fi
+      '';
+      postStart = ''
+        until ${pkgs.etcdctl}/bin/etcdctl set /nixos/state 'up'; do
+          sleep 1;
+        done
+        until ${pkgs.etcdctl}/bin/etcdctl get /nixos/state | grep up; do
+          sleep 1;
+        done
+      '';
+    };
+
+    environment.systemPackages = [ pkgs.etcdctl ];
+
+    users.extraUsers = singleton {
+      name = "etcd";
+      uid = config.ids.uids.etcd;
+      description = "Etcd daemon user";
+      home = cfg.dataDir;
+    };
+  };
+}

nixos/modules/services/misc/gitolite.nix

@@ -46,11 +46,19 @@ in
           A list of custom git hooks that get copied to <literal>~/.gitolite/hooks/common</literal>.
         '';
       };
+
+      user = mkOption {
+        type = types.str;
+        default = "gitolite";
+        description = ''
+          Gitolite user account. This is the username of the gitolite endpoint.
+        '';
+      };
     };
   };
 
   config = mkIf cfg.enable {
-    users.extraUsers.gitolite = {
+    users.extraUsers.${cfg.user} = {
       description     = "Gitolite user";
       home            = cfg.dataDir;
       createHome      = true;
@@ -62,7 +70,7 @@ in
       description = "Gitolite initialization";
       wantedBy    = [ "multi-user.target" ];
 
-      serviceConfig.User = "gitolite";
+      serviceConfig.User = "${cfg.user}";
       serviceConfig.Type = "oneshot";
       serviceConfig.RemainAfterExit = true;
 

nixos/modules/services/monitoring/bosun.nix

@@ -0,0 +1,136 @@
+{ config, lib, pkgs, ... }:
+
+with lib;
+
+let
+  cfg = config.services.bosun;
+
+  configFile = pkgs.writeText "bosun.conf" ''
+    tsdbHost = ${cfg.opentsdbHost}
+    httpListen = ${cfg.listenAddress}
+    stateFile = ${cfg.stateFile}
+    checkFrequency = 5m
+
+    ${cfg.extraConfig}
+  '';
+
+in {
+
+  options = {
+
+    services.bosun = {
+
+      enable = mkOption {
+        type = types.bool;
+        default = false;
+        description = ''
+          Whether to run bosun.
+        '';
+      };
+
+      package = mkOption {
+        type = types.package;
+        default = pkgs.bosun;
+        example = literalExample "pkgs.bosun";
+        description = ''
+          bosun binary to use.
+        '';
+      };
+
+      user = mkOption {
+        type = types.string;
+        default = "bosun";
+        description = ''
+          User account under which bosun runs.
+        '';
+      };
+
+      group = mkOption {
+        type = types.string;
+        default = "bosun";
+        description = ''
+          Group account under which bosun runs.
+        '';
+      };
+
+      opentsdbHost = mkOption {
+        type = types.string;
+        default = "localhost:4242";
+        description = ''
+          Host and port of the OpenTSDB database that stores bosun data.
+        '';
+      };
+
+      listenAddress = mkOption {
+        type = types.string;
+        default = ":8070";
+        description = ''
+          The host address and port that bosun's web interface will listen on.
+        '';
+      };
+
+      stateFile = mkOption {
+        type = types.string;
+        default = "/var/lib/bosun/bosun.state";
+        description = ''
+          Path to bosun's state file.
+        '';
+      };
+
+      extraConfig = mkOption {
+        type = types.string;
+        default = "";
+        description = ''
+          Extra configuration options for Bosun. You should describe your
+          desired templates, alerts, macros, etc through this configuration
+          option.
+
+          A detailed description of the supported syntax can be found at-spi2-atk
+          http://bosun.org/configuration.html
+        '';
+      };
+
+    };
+
+  };
+
+  config = mkIf config.services.bosun.enable {
+
+
+    systemd.services.bosun = {
+      description = "bosun metrics collector (part of Bosun)";
+      wantedBy = [ "multi-user.target" ];
+
+      preStart =
+        ''
+        mkdir -p `dirname ${cfg.stateFile}`;
+        touch ${cfg.stateFile}
+        touch ${cfg.stateFile}.tmp
+
+        if [ "$(id -u)" = 0 ]; then
+          chown ${cfg.user}:${cfg.group} ${cfg.stateFile}
+          chown ${cfg.user}:${cfg.group} ${cfg.stateFile}.tmp
+        fi
+        '';
+
+      serviceConfig = {
+        PermissionsStartOnly = true;
+        User = cfg.user;
+        Group = cfg.group;
+        ExecStart = ''
+          ${cfg.package}/bin/bosun -c ${configFile}
+        '';
+      };
+    };
+
+    users.extraUsers.bosun = {
+      description = "bosun user";
+      group = "bosun";
+      uid = config.ids.uids.bosun;
+    };
+
+    users.extraGroups.bosun.gid = config.ids.gids.bosun;
+
+  };
+
+}

nixos/modules/services/monitoring/riemann.nix

@@ -11,11 +11,15 @@ let
     cfg.extraClasspathEntries ++ [ "${riemann}/share/java/riemann.jar" ]
   );
 
+  riemannConfig = concatStringsSep "\n" (
+    [cfg.config] ++ (map (f: ''(load-file "${f}")'') cfg.configFiles)
+  );
+
   launcher = writeScriptBin "riemann" ''
     #!/bin/sh
     exec ${openjdk}/bin/java ${concatStringsSep "\n" cfg.extraJavaOpts} \
       -cp ${classpath} \
-      riemann.bin ${writeText "riemann.config" cfg.config}
+      riemann.bin ${writeText "riemann-config.clj" riemannConfig}
   '';
 
 in {
@@ -36,6 +40,16 @@ in {
           Contents of the Riemann configuration file.
         '';
       };
+      configFiles = mkOption {
+        type = with types; listOf path;
+        default = [];
+        description = ''
+          Extra files containing Riemann configuration. These files will be
+          loaded at runtime by Riemann (with Clojure's
+          <literal>load-file</literal> function) at the end of the
+          configuration.
+        '';
+      };
       extraClasspathEntries = mkOption {
         type = with types; listOf str;
         default = [];

nixos/modules/services/monitoring/scollector.nix

@@ -0,0 +1,114 @@
+{ config, lib, pkgs, ... }:
+
+with lib;
+
+let
+  cfg = config.services.scollector;
+
+  collectors = pkgs.runCommand "collectors" {}
+    ''
+    mkdir -p $out
+    ${lib.concatStringsSep
+        "\n"
+        (lib.mapAttrsToList
+          (frequency: binaries:
+            "mkdir -p $out/${frequency}\n" +
+            (lib.concatStringsSep
+              "\n"
+              (map (path: "ln -s ${path} $out/${frequency}/$(basename ${path})")
+                   binaries)))
+          cfg.collectors)}
+    '';
+
+in {
+
+  options = {
+
+    services.scollector = {
+
+      enable = mkOption {
+        type = types.bool;
+        default = false;
+        description = ''
+          Whether to run scollector.
+        '';
+      };
+
+      package = mkOption {
+        type = types.package;
+        default = pkgs.scollector;
+        example = literalExample "pkgs.scollector";
+        description = ''
+          scollector binary to use.
+        '';
+      };
+
+      user = mkOption {
+        type = types.string;
+        default = "scollector";
+        description = ''
+          User account under which scollector runs.
+        '';
+      };
+
+      group = mkOption {
+        type = types.string;
+        default = "scollector";
+        description = ''
+          Group account under which scollector runs.
+        '';
+      };
+
+      bosunHost = mkOption {
+        type = types.string;
+        default = "localhost:8070";
+        description = ''
+          Host and port of the bosun server that will store the collected
+          data.
+        '';
+      };
+
+      collectors = mkOption {
+        type = types.attrs;
+        default = {};
+        example = literalExample "{ 0 = [ \"\${postgresStats}/bin/collect-stats\" ]; }";
+        description = ''
+          An attribute set mapping the frequency of collection to a list of
+          binaries that should be executed at that frequency. You can use "0"
+          to run a binary forever.
+        '';
+      };
+
+    };
+
+  };
+
+  config = mkIf config.services.scollector.enable {
+
+    systemd.services.scollector = {
+      description = "scollector metrics collector (part of Bosun)";
+      wantedBy = [ "multi-user.target" ];
+
+      path = [ pkgs.coreutils pkgs.iproute ];
+
+      serviceConfig = {
+        PermissionsStartOnly = true;
+        User = cfg.user;
+        Group = cfg.group;
+        ExecStart = ''
+          ${cfg.package}/bin/scollector -h=${cfg.bosunHost} -c=${collectors}
+        '';
+      };
+    };
+
+    users.extraUsers.scollector = {
+      description = "scollector user";
+      group = "scollector";
+      uid = config.ids.uids.scollector;
+    };
+
+    users.extraGroups.scollector.gid = config.ids.gids.scollector;
+
+  };
+
+}

nixos/modules/services/networking/dnscrypt-proxy.nix

@@ -6,7 +6,8 @@ let
   dnscrypt-proxy = pkgs.dnscrypt-proxy;
   cfg = config.services.dnscrypt-proxy;
   uid = config.ids.uids.dnscrypt-proxy;
-  daemonArgs = [ "--daemonize"
+  daemonArgs =
+    [ "--daemonize"
       "--user=dnscrypt-proxy"
       "--local-address=${cfg.localAddress}:${toString cfg.port}"
       (optionalString cfg.tcpOnly "--tcp-only")

nixos/modules/services/networking/unifi.nix

@@ -1,9 +1,24 @@
-{ config, lib, pkgs, ... }:
+{ config, lib, pkgs, utils, ... }:
 with lib;
 let
   cfg = config.services.unifi;
   stateDir = "/var/lib/unifi";
   cmd = "@${pkgs.icedtea7_jre}/bin/java java -jar ${stateDir}/lib/ace.jar";
+  mountPoints = [
+    {
+      what = "${pkgs.unifi}/dl";
+      where = "${stateDir}/dl";
+    }
+    {
+      what = "${pkgs.unifi}/lib";
+      where = "${stateDir}/lib";
+    }
+    {
+      what = "${pkgs.mongodb}/bin";
+      where = "${stateDir}/bin";
+    }
+  ];
+  systemdMountPoints = map (m: "${utils.escapeSystemdPath m.where}.mount") mountPoints;
 in
 {
 
@@ -32,30 +47,18 @@ in
     # to be used as the working directory.
     systemd.mounts = map ({ what, where }: {
         bindsTo = [ "unifi.service" ];
-        requiredBy = [ "unifi.service" ];
+        partOf = [ "unifi.service" ];
-        before = [ "unifi.service" ];
         options = "bind";
         what = what;
         where = where;
-      }) [
+      }) mountPoints;
-        {
-          what = "${pkgs.unifi}/dl";
-          where = "${stateDir}/dl";
-        }
-        {
-          what = "${pkgs.unifi}/lib";
-          where = "${stateDir}/lib";
-        }
-        {
-          what = "${pkgs.mongodb}/bin";
-          where = "${stateDir}/bin";
-        }
-      ];
 
     systemd.services.unifi = {
       description = "UniFi controller daemon";
       wantedBy = [ "multi-user.target" ];
-      after = [ "network.target" ];
+      after = [ "network.target" ] ++ systemdMountPoints;
+      partOf = systemdMountPoints;
+      bindsTo = systemdMountPoints;
 
       preStart = ''
         # Ensure privacy of state
@@ -63,14 +66,14 @@ in
         chmod 0700 "${stateDir}"
 
         # Create the volatile webapps
+        rm -rf "${stateDir}/webapps"
         mkdir -p "${stateDir}/webapps"
         chown unifi "${stateDir}/webapps"
-        rm -f "{stateDir}/webapps/ROOT.war"
         ln -s "${pkgs.unifi}/webapps/ROOT.war" "${stateDir}/webapps/ROOT.war"
       '';
 
       postStop = ''
-        rm "${stateDir}/webapps/ROOT.war"
+        rm -rf "${stateDir}/webapps"
       '';
 
       serviceConfig = {

nixos/modules/services/printing/cupsd.nix

@@ -37,6 +37,7 @@ let
     paths = cfg.drivers;
     pathsToLink = [ "/lib/cups" "/share/cups" "/bin" "/etc/cups" ];
     postBuild = cfg.bindirCmds;
+    ignoreCollisions = true;
   };
 
 in
@@ -107,7 +108,7 @@ in
         type = types.listOf types.path;
         example = literalExample "[ pkgs.splix ]";
         description = ''
-          CUPS drivers to use. Drivers provided by CUPS, Ghostscript
+          CUPS drivers to use. Drivers provided by CUPS, cups-filters, Ghostscript
           and Samba are added unconditionally.
         '';
       };
@@ -175,7 +176,7 @@ in
       };
 
     services.printing.drivers =
-      [ pkgs.cups pkgs.cups_pdf_filter pkgs.ghostscript additionalBackends
+      [ pkgs.cups pkgs.ghostscript pkgs.cups_filters additionalBackends
         pkgs.perl pkgs.coreutils pkgs.gnused pkgs.bc pkgs.gawk pkgs.gnugrep
       ];
 

nixos/modules/services/security/haveged.nix

@@ -46,7 +46,7 @@ in
   
     systemd.services.haveged =
       { description = "Entropy Harvesting Daemon";
-        unitConfig.documentation = "man:haveged(8)";
+        unitConfig.Documentation = "man:haveged(8)";
         wantedBy = [ "multi-user.target" ];
         
         path = [ pkgs.haveged ];

nixos/modules/virtualisation/containers.nix

@@ -308,8 +308,6 @@ in
           '';
       }) config.containers;
 
-    # FIXME: auto-start containers.
-
     # Generate /etc/hosts entries for the containers.
     networking.extraHosts = concatStrings (mapAttrsToList (name: cfg: optionalString (cfg.localAddress != null)
       ''

nixos/release.nix

@@ -130,6 +130,7 @@ in rec {
   manual = buildFromConfig ({ pkgs, ... }: { }) (config: config.system.build.manual.manual);
   manualPDF = (buildFromConfig ({ pkgs, ... }: { }) (config: config.system.build.manual.manualPDF)).x86_64-linux;
   manpages = buildFromConfig ({ pkgs, ... }: { }) (config: config.system.build.manual.manpages);
+  options = (buildFromConfig ({ pkgs, ... }: { }) (config: config.system.build.manual.optionsJSON)).x86_64-linux;
 
 
   # Build the initial ramdisk so Hydra can keep track of its size over time.
@@ -235,8 +236,11 @@ in rec {
   tests.avahi = callTest tests/avahi.nix {};
   tests.bittorrent = callTest tests/bittorrent.nix {};
   tests.blivet = callTest tests/blivet.nix {};
+  tests.chromium = callTest tests/chromium.nix {};
   tests.cjdns = callTest tests/cjdns.nix {};
   tests.containers = callTest tests/containers.nix {};
+  tests.dockerRegistry = callTest tests/docker-registry.nix {};
+  tests.etcd = callTest tests/etcd.nix {};
   tests.firefox = callTest tests/firefox.nix {};
   tests.firewall = callTest tests/firewall.nix {};
   tests.gnome3 = callTest tests/gnome3.nix {};

nixos/tests/chromium.nix

@@ -0,0 +1,164 @@
+import ./make-test.nix (
+{ pkgs
+, channelMap ? {
+    stable = pkgs.chromium;
+    beta   = pkgs.chromiumBeta;
+    dev    = pkgs.chromiumDev;
+  }
+, ...
+}: rec {
+  name = "chromium";
+
+  machine.imports = [ ./common/x11.nix ];
+
+  startupHTML = pkgs.writeText "chromium-startup.html" ''
+    <!DOCTYPE html>
+    <html>
+    <head>
+    <meta charset="UTF-8">
+    <title>Chromium startup notifier</title>
+    </head>
+    <body onload="javascript:document.title='startup done'">
+      <img src="file://${pkgs.fetchurl {
+        url = "http://nixos.org/logo/nixos.svg";
+        sha256 = "0p2iaqcx2cj24xqycfw1pi4i5461gnn0034lafpi99ph435x6z68";
+      }}" />
+    </body>
+    </html>
+  '';
+
+  testScript = let
+    xdo = name: text: let
+      xdoScript = pkgs.writeText "${name}.xdo" text;
+    in "${pkgs.xdotool}/bin/xdotool '${xdoScript}'";
+  in ''
+    sub createNewWin {
+      $machine->nest("creating a new Chromium window", sub {
+        $machine->execute("${xdo "new-window" ''
+          search --onlyvisible --name "startup done"
+          windowfocus --sync
+          windowactivate --sync
+          key Ctrl+n
+        ''}");
+      });
+    }
+
+    sub closeWin {
+      Machine::retry sub {
+        $machine->execute("${xdo "close-window" ''
+          search --onlyvisible --name "new tab"
+          windowfocus --sync
+          windowactivate --sync
+          key Ctrl+w
+        ''}");
+        for (1..20) {
+          my ($status, $out) = $machine->execute("${xdo "wait-for-close" ''
+            search --onlyvisible --name "new tab"
+          ''}");
+          return 1 if $status != 0;
+          $machine->sleep(1);
+        }
+      }
+    }
+
+    sub waitForNewWin {
+      my $ret = 0;
+      $machine->nest("waiting for new Chromium window to appear", sub {
+        for (1..20) {
+          my ($status, $out) = $machine->execute("${xdo "wait-for-window" ''
+            search --onlyvisible --name "new tab"
+            windowfocus --sync
+            windowactivate --sync
+          ''}");
+          if ($status == 0) {
+            $ret = 1;
+            last;
+          }
+          $machine->sleep(1);
+        }
+      });
+      return $ret;
+    }
+
+    sub createAndWaitForNewWin {
+      for (1..3) {
+        createNewWin;
+        return 1 if waitForNewWin;
+      }
+      die "new window didn't appear within 60 seconds";
+    }
+
+    sub testNewWin {
+      my ($desc, $code) = @_;
+      createAndWaitForNewWin;
+      subtest($desc, $code);
+      closeWin;
+    }
+
+    sub chromiumTest {
+      my ($channel, $pkg, $code) = @_;
+      $machine->waitForX;
+
+      my $url = "file://${startupHTML}";
+      my $args = "--user-data-dir=/tmp/chromium-$channel";
+      $machine->execute(
+        "ulimit -c unlimited; ".
+        "$pkg/bin/chromium $args \"$url\" & disown"
+      );
+      $machine->waitUntilSucceeds("${xdo "check-startup" ''
+        search --sync --onlyvisible --name "startup done"
+        # close first start help popup
+        key Escape
+        windowfocus --sync
+        windowactivate --sync
+      ''}");
+
+      createAndWaitForNewWin;
+      $machine->screenshot($channel."_emptywin");
+      closeWin;
+
+      $machine->screenshot($channel."_startup_done");
+
+      subtest("Chromium $channel", $code);
+
+      $machine->shutdown;
+    }
+
+    for (${let
+      mkArray = name: pkg: "[\"${name}\", \"${pkg}\"]";
+      chanArrays = pkgs.lib.mapAttrsToList mkArray channelMap;
+    in pkgs.lib.concatStringsSep ", " chanArrays}) {
+      my ($channel, $pkg) = @$_;
+      chromiumTest $channel, $pkg, sub {
+        testNewWin "check sandbox", sub {
+          $machine->succeed("${xdo "type-url" ''
+            search --sync --onlyvisible --name "new tab"
+            windowfocus --sync
+            type --delay 1000 "chrome://sandbox"
+          ''}");
+
+          $machine->succeed("${xdo "submit-url" ''
+            search --sync --onlyvisible --name "new tab"
+            windowfocus --sync
+            key --delay 1000 Return
+          ''}");
+
+          $machine->screenshot($channel."_sandbox");
+
+          $machine->succeed("${xdo "submit-url" ''
+            search --sync --onlyvisible --name "sandbox status"
+            windowfocus --sync
+            key --delay 1000 Ctrl+a Ctrl+c
+          ''}");
+
+          my $clipboard = $machine->succeed("${pkgs.xclip}/bin/xclip -o");
+          die "sandbox not working properly: $clipboard"
+          unless $clipboard =~ /suid sandbox.*yes/mi
+              && $clipboard =~ /pid namespaces.*yes/mi
+              && $clipboard =~ /network namespaces.*yes/mi
+              && $clipboard =~ /seccomp.*sandbox.*yes/mi;
+        };
+      };
+    }
+  '';
+})

nixos/tests/docker-registry.nix

@@ -0,0 +1,40 @@
+# This test runs docker-registry and check if it works
+
+import ./make-test.nix {
+  name = "docker-registry";
+
+  nodes = {
+    registry = { config, pkgs, ... }: {
+      services.dockerRegistry.enable = true;
+      services.dockerRegistry.port = 8080;
+      services.dockerRegistry.host = "0.0.0.0";
+      networking.firewall.allowedTCPPorts = [ 8080 ];
+    };
+
+    client1 = { config, pkgs, ...}: {
+      virtualisation.docker.enable = true;
+      virtualisation.docker.extraOptions = "--insecure-registry registry:8080";
+    };
+
+    client2 = { config, pkgs, ...}: {
+      virtualisation.docker.enable = true;
+      virtualisation.docker.extraOptions = "--insecure-registry registry:8080";
+    };
+  };
+
+  testScript = ''
+    $client1->start();
+    $client1->waitForUnit("docker.service");
+    $client1->succeed("tar cv --files-from /dev/null | docker import - scratch");
+    $client1->succeed("docker tag scratch registry:8080/scratch");
+
+    $registry->start();
+    $registry->waitForUnit("docker-registry.service");
+    $client1->succeed("docker push registry:8080/scratch");
+
+    $client2->start();
+    $client2->waitForUnit("docker.service");
+    $client2->succeed("docker pull registry:8080/scratch");
+    $client2->succeed("docker images | grep scratch");
+  '';
+}

nixos/tests/etcd.nix

@@ -0,0 +1,108 @@
+# This test runs etcd as single node, multy node and using discovery
+
+import ./make-test.nix {
+  name = "etcd";
+
+  nodes = {
+    simple =
+      { config, pkgs, nodes, ... }:
+        {
+          services.etcd.enable = true;
+          services.etcd.listenClientUrls = ["http://0.0.0.0:4001"];
+          environment.systemPackages = [ pkgs.curl ];
+          networking.firewall.allowedTCPPorts = [ 4001 ];
+        };
+
+
+    node1 =
+      { config, pkgs, nodes, ... }:
+        {
+          services = {
+            etcd = {
+              enable = true;
+              listenPeerUrls = ["http://0.0.0.0:7001"];
+              initialAdvertisePeerUrls = ["http://node1:7001"];
+              initialCluster = ["node1=http://node1:7001" "node2=http://node2:7001"];
+            };
+          };
+
+          networking.firewall.allowedTCPPorts = [ 7001 ];
+        };
+
+    node2 =
+      { config, pkgs, ... }:
+        {
+          services = {
+            etcd = {
+              enable = true;
+              listenPeerUrls = ["http://0.0.0.0:7001"];
+              initialAdvertisePeerUrls = ["http://node2:7001"];
+              initialCluster = ["node1=http://node1:7001" "node2=http://node2:7001"];
+            };
+          };
+
+          networking.firewall.allowedTCPPorts = [ 7001 ];
+        };
+
+    discovery1 =
+      { config, pkgs, nodes, ... }:
+        {
+          services = {
+            etcd = {
+              enable = true;
+              listenPeerUrls = ["http://0.0.0.0:7001"];
+              initialAdvertisePeerUrls = ["http://discovery1:7001"];
+              discovery = "http://simple:4001/v2/keys/discovery/6c007a14875d53d9bf0ef5a6fc0257c817f0fb83/";
+            };
+          };
+
+          networking.firewall.allowedTCPPorts = [ 7001 ];
+        };
+
+    discovery2 =
+      { config, pkgs, ... }:
+        {
+          services = {
+            etcd = {
+              enable = true;
+              listenPeerUrls = ["http://0.0.0.0:7001"];
+              initialAdvertisePeerUrls = ["http://discovery2:7001"];
+              discovery = "http://simple:4001/v2/keys/discovery/6c007a14875d53d9bf0ef5a6fc0257c817f0fb83/";
+            };
+          };
+
+          networking.firewall.allowedTCPPorts = [ 7001 ];
+        };
+    };
+
+  testScript = ''
+    subtest "single node", sub {
+      $simple->start();
+      $simple->waitForUnit("etcd.service");
+      $simple->succeed("etcdctl set /foo/bar 'Hello world'");
+      $simple->waitUntilSucceeds("etcdctl get /foo/bar | grep 'Hello world'");
+    };
+
+    subtest "multy node", sub {
+      $node1->start();
+      $node2->start();
+      $node1->waitForUnit("etcd.service");
+      $node2->waitForUnit("etcd.service");
+      $node1->succeed("etcdctl set /foo/bar 'Hello world'");
+      $node2->waitUntilSucceeds("etcdctl get /foo/bar | grep 'Hello world'");
+      $node1->shutdown();
+      $node2->shutdown();
+    };
+
+    subtest "discovery", sub {
+      $simple->succeed("curl -X PUT http://localhost:4001/v2/keys/discovery/6c007a14875d53d9bf0ef5a6fc0257c817f0fb83/_config/size -d value=2");
+
+      $discovery1->start();
+      $discovery2->start();
+      $discovery1->waitForUnit("etcd.service");
+      $discovery2->waitForUnit("etcd.service");
+      $discovery1->succeed("etcdctl set /foo/bar 'Hello world'");
+      $discovery2->waitUntilSucceeds("etcdctl get /foo/bar | grep 'Hello world'");
+    };
+  '';
+}

pkgs/applications/audio/ardour/default.nix

@@ -6,7 +6,7 @@
 , perl, pkgconfig, python, serd, sord, sratom, suil }:
 
 let
-  tag = "3.5.380";
+  tag = "3.5.403";
 in
 
 stdenv.mkDerivation rec {
@@ -15,7 +15,7 @@ stdenv.mkDerivation rec {
   src = fetchgit {
     url = git://git.ardour.org/ardour/ardour.git;
     rev = "refs/tags/${tag}";
-    sha256 = "dbcbb2d9143e196d079c27b15266e47d24b81cb7591fe64b717f3485965ded7b";
+    sha256 = "7d7c8e2c7ccccca6c8324fd874509e1b0d89f3f42cb92982c50d212797463f4c";
   };
 
   buildInputs = 

pkgs/applications/audio/csound/default.nix

@@ -12,13 +12,13 @@
 }:
 
 stdenv.mkDerivation {
-  name = "csound-5.19.01";
+  name = "csound-6.03.2";
 
   enableParallelBuilding = true;
 
   src = fetchurl {
-    url = mirror://sourceforge/csound/Csound5.19.01.tar.gz;
+    url = mirror://sourceforge/csound/Csound6.03.2.tar.gz;
-    sha256 = "078i69jwgadmxwa5ffn8h1py7cmd9asa8swnh38fyp56lzgzn669";
+    sha256 = "0w6ij57dbfjljpf05bb9r91jphwaq1v63rh0713vl2n11d73dy7m";
   };
 
   buildInputs = [ cmake libsndfile flex bison alsaLib pulseaudio tcltk ];

pkgs/applications/audio/faust-compiler/default.nix

@@ -0,0 +1,51 @@
+{ fetchurl, stdenv, unzip }:
+
+stdenv.mkDerivation rec {
+
+  version = "0.9.67";
+  name = "faust-compiler-${version}";
+  src = fetchurl {
+    url = "http://downloads.sourceforge.net/project/faudiostream/faust-${version}.zip";
+    sha256 = "068vl9536zn0j4pknwfcchzi90rx5pk64wbcbd67z32w0csx8xm1";
+  };
+
+  buildInputs = [ unzip ];
+
+  patchPhase = ''
+    sed -i '77,101d' Makefile
+    sed -i 's#?= $(shell uname -s)#:= Linux#g'  architecture/osclib/oscpack/Makefile
+    sed -e "s@\$FAUST_INSTALL /usr/local /usr /opt /opt/local@$out@g" -i tools/faust2appls/faustpath
+  '';
+
+  postInstallPhase = ''
+    rm -rf $out/include/
+  '';
+
+  makeFlags = "PREFIX=$(out)";
+  FPATH = "$out"; # <- where to search
+
+  meta = with stdenv.lib; {
+    description = "A functional programming language for realtime audio signal processing";
+    longDescription = ''
+      FAUST (Functional Audio Stream) is a functional programming
+      language specifically designed for real-time signal processing
+      and synthesis. FAUST targets high-performance signal processing
+      applications and audio plug-ins for a variety of platforms and
+      standards.
+      The Faust compiler translates DSP specifications into very
+      efficient C++ code. Thanks to the notion of architecture,
+      FAUST programs can be easily deployed on a large variety of
+      audio platforms and plugin formats (jack, alsa, ladspa, maxmsp,
+      puredata, csound, supercollider, pure, vst, coreaudio) without
+      any change to the FAUST code.
+      This package has just the compiler. Install faust for the full
+      set of faust2somethingElse tools.
+    '';
+    homepage = http://faust.grame.fr/;
+    downloadPage = http://sourceforge.net/projects/faudiostream/files/;
+    license = licenses.gpl2;
+    platforms = platforms.linux;
+    maintainers = [ maintainers.magnetophon ];
+  };
+}
+

pkgs/applications/audio/gpodder/default.nix

@@ -1,6 +1,5 @@
 { pkgs, stdenv, fetchurl, python, buildPythonPackage, pythonPackages, mygpoclient, intltool,
-  ipodSupport ? true, libgpod, gpodderHome ? "", gpodderDownloadDir ? "",
+  ipodSupport ? true, libgpod, gnome3, hicolor_icon_theme }:
-  gnome3, hicolor_icon_theme }:
 
 with pkgs.lib;
 
@@ -8,20 +7,23 @@ let
   inherit (pythonPackages) coverage feedparser minimock sqlite3 dbus pygtk eyeD3;
 
 in buildPythonPackage rec {
-  name = "gpodder-3.8.0";
+  name = "gpodder-3.8.3";
 
   src = fetchurl {
     url = "http://gpodder.org/src/${name}.tar.gz";
-    sha256 = "0731f08f4270c81872b841b55200ae80feb4502706397d0085079471fb9a8fe4";
+    sha256 = "8ac120a6084bded6bc88ecadbbc9df54a85f44ef4507f73a76de1d7a5574303c";
   };
 
   buildInputs = [
     coverage feedparser minimock sqlite3 mygpoclient intltool
-    gnome3.gnome_icon_theme gnome3.gnome_icon_theme_symbolic
+    gnome3.gnome_themes_standard gnome3.gnome_icon_theme
-    hicolor_icon_theme
+    gnome3.gnome_icon_theme_symbolic hicolor_icon_theme
+    gnome3.gsettings_desktop_schemas
   ];
 
-  propagatedBuildInputs = [ feedparser dbus mygpoclient sqlite3 pygtk eyeD3 ]
+  propagatedUserEnvPkgs = [ gnome3.gnome_themes_standard ];
+
+  pythonPath = [ feedparser dbus mygpoclient sqlite3 pygtk eyeD3 ]
     ++ stdenv.lib.optional ipodSupport libgpod;
 
   postPatch = "sed -ie 's/PYTHONPATH=src/PYTHONPATH=\$(PYTHONPATH):src/' makefile";
@@ -30,8 +32,6 @@ in buildPythonPackage rec {
 
   preFixup = ''
     wrapProgram $out/bin/gpodder \
-      ${optionalString (gpodderHome != "") "--set GPODDER_HOME ${gpodderHome}"} \
-      ${optionalString (gpodderDownloadDir != "") "--set GPODDER_DOWNLOAD_DIR ${gpodderDownloadDir}"} \
       --prefix XDG_DATA_DIRS : "${gnome3.gnome_themes_standard}/share:$XDG_ICON_DIRS:$GSETTINGS_SCHEMAS_PATH"
   '';
 

pkgs/applications/audio/guitarix/default.nix

@@ -4,11 +4,11 @@
 
 stdenv.mkDerivation rec {
   name = "guitarix-${version}";
-  version = "0.31.0";
+  version = "0.32.0";
 
   src = fetchurl {
     url = "mirror://sourceforge/guitarix/guitarix2-${version}.tar.bz2";
-    sha256 = "0n3swk4xahspf42qglikfmvcz8my43wmp6sp4ns7h4m8hr9lgfk6";
+    sha256 = "06qxydcba1ga1l19kyqy0mk141mv6pa4wbkyh75xbwhyr65bwkc4";
   };
 
   buildInputs = [

pkgs/applications/audio/praat/default.nix

@@ -1,11 +1,12 @@
 { stdenv, fetchurl, alsaLib, gtk, pkgconfig }:
 
+let version = "5401"; in
 stdenv.mkDerivation {
-  name = "praat-5365";
+  name = "praat-${version}";
 
   src = fetchurl {
-    url = http://www.fon.hum.uva.nl/praat/praat5365_sources.tar.gz;
+    url = "http://www.fon.hum.uva.nl/praat/praat${version}_sources.tar.gz";
-    sha256 = "1w3mcq0mipx88i7ckhvzhmdj0p67nhppnn7kbkp21d01yyyz5rgq";
+    sha256 = "1hx0simc0hp5w5scyaiw8h8lrpafra4h1zy1jn1kzb0299yd06n3";
   };
 
   configurePhase = ''

pkgs/applications/audio/qtractor/default.nix

@@ -3,12 +3,12 @@
 , libtool, libvorbis, pkgconfig, qt4, rubberband, stdenv }:
 
 stdenv.mkDerivation rec {
-  version = "0.6.3";
+  version = "0.6.4";
   name = "qtractor-${version}";
 
   src = fetchurl {
     url = "mirror://sourceforge/qtractor/${name}.tar.gz";
-    sha256 = "1lsmd83vhgfzb3bf02hi6xp5ryh08lz4h21agy7wm3acjqc6gsc2";
+    sha256 = "1wgm9cx9mrxgd69kdabh78vb3nlyhhfbpd5k4g9s15ifny9cgwz4";
   };
 
   buildInputs =

pkgs/applications/audio/tomahawk/default.nix

@@ -0,0 +1,48 @@
+{ stdenv, fetchurl, cmake, pkgconfig, attica, boost, gnutls, libechonest
+, liblastfm, lucenepp, phonon, phonon_backend_vlc, qca2, qjson, qt4, qtkeychain
+, quazip, sparsehash, taglib, websocketpp
+
+, enableXMPP      ? true,  libjreen     ? null
+, enableKDE       ? false, kdelibs      ? null
+, enableTelepathy ? false, telepathy_qt ? null
+}:
+
+assert enableXMPP      -> libjreen     != null;
+assert enableKDE       -> kdelibs      != null;
+assert enableTelepathy -> telepathy_qt != null;
+
+let
+  quazipQt4 = quazip.override { qt = qt4; };
+in stdenv.mkDerivation rec {
+  name = "tomahawk-${version}";
+  version = "0.8.1";
+
+  src = fetchurl {
+    url = "http://download.tomahawk-player.org/tomahawk-0.8.1.tar.bz2";
+    sha256 = "0ca6fah30a2s8nnlryav95wyzhwys1ikjfwakrqf2hb0y5aczdpw";
+  };
+
+  cmakeFlags = [
+    "-DLUCENEPP_INCLUDE_DIR=${lucenepp}/include"
+    "-DLUCENEPP_LIBRARY_DIR=${lucenepp}/lib"
+  ];
+
+  buildInputs = [
+    cmake pkgconfig attica boost gnutls libechonest liblastfm lucenepp phonon
+    qca2 qjson qt4 qtkeychain quazipQt4 sparsehash taglib websocketpp
+  ] ++ stdenv.lib.optional enableXMPP      libjreen
+    ++ stdenv.lib.optional enableKDE       kdelibs
+    ++ stdenv.lib.optional enableTelepathy telepathy_qt;
+
+  propagatedBuildInputs = [ phonon_backend_vlc ];
+
+  enableParallelBuilding = true;
+
+  meta = with stdenv.lib; {
+    description = "A multi-source music player";
+    homepage = "http://tomahawk-player.org/";
+    license = licenses.gpl3Plus;
+    platforms = platforms.all;
+    maintainers = [ maintainers.aszlig ];
+  };
+}

pkgs/applications/audio/vimus/default.nix

@@ -0,0 +1,29 @@
+# This file was auto-generated by cabal2nix. Please do NOT edit manually!
+
+{ cabal, c2hs, dataDefault, deepseq, filepath, hspec
+, hspecExpectations, libmpd, mtl, ncurses, QuickCheck, time
+, transformers, utf8String, wcwidth
+}:
+
+cabal.mkDerivation (self: {
+  pname = "vimus";
+  version = "0.2.0";
+  sha256 = "0s7hfyil9rnr9rmjb08g1l1sxybx3qdkw2f59p433fkdjp2m140h";
+  isLibrary = true;
+  isExecutable = true;
+  buildDepends = [
+    dataDefault deepseq filepath libmpd mtl time utf8String wcwidth
+  ];
+  testDepends = [
+    dataDefault hspec hspecExpectations mtl QuickCheck transformers
+    wcwidth
+  ];
+  buildTools = [ c2hs ];
+  extraLibraries = [ ncurses ];
+  meta = {
+    description = "An MPD client with vim-like key bindings";
+    license = self.stdenv.lib.licenses.mit;
+    platforms = self.ghc.meta.platforms;
+    maintainers = with self.stdenv.lib.maintainers; [ jzellner ];
+  };
+})

pkgs/applications/backup/crashplan/default.nix

@@ -1,13 +1,13 @@
 { stdenv, fetchurl, makeWrapper, jre, cpio, gawk, gnugrep, gnused, procps, swt, gtk2, glib, libXtst }:
 
-let version = "3.6.3";
+let version = "3.6.4";
 
 in stdenv.mkDerivation rec {
   name = "crashplan-${version}";
 
   crashPlanArchive = fetchurl {
     url = "http://download.crashplan.com/installs/linux/install/CrashPlan/CrashPlan_${version}_Linux.tgz";
-    sha256 = "0v01fzc62bxr6lpamnxg1nb7vh4a8ky6mahbq76kmjxfqv7q0mb0";
+    sha256 = "0xmzpxfm8vghk552jy167wg1nky1pp93dqds1p922hn73g0x5cv3";
   };
 
   srcs = [ crashPlanArchive ];

pkgs/applications/editors/atom/default.nix

@@ -16,11 +16,11 @@ let
   };
 in stdenv.mkDerivation rec {
   name = "atom-${version}";
-  version = "0.139.0";
+  version = "0.150.0";
 
   src = fetchurl {
     url = "https://github.com/atom/atom/releases/download/v${version}/atom-amd64.deb";
-    sha256 = "0732s4r9qx0sgsnz415z5r9685scly2084q80kz2xw0d2gfx04xr";
+    sha256 = "1vvsxj1pwpcz0hn58k1hsrv994vm61lxkih58ix1rkj32wpvdjxn";
     name = "${name}.deb";
   };
 
@@ -39,6 +39,8 @@ in stdenv.mkDerivation rec {
       $out/share/atom/resources/app/apm/node_modules/atom-package-manager/bin/node
     wrapProgram $out/bin/atom \
       --prefix "LD_LIBRARY_PATH" : "${atomEnv}/lib:${atomEnv}/lib64"
+    wrapProgram $out/bin/apm \
+      --prefix "LD_LIBRARY_PATH" : "${atomEnv}/lib:${atomEnv}/lib64"
   '';
 
   meta = with stdenv.lib; {

pkgs/applications/editors/emacs-24/macport-24.4.nix

@@ -3,7 +3,7 @@
 
 stdenv.mkDerivation rec {
   emacsName = "emacs-24.4";
-  name = "${emacsName}-mac-5.0";
+  name = "${emacsName}-mac-5.1";
 
   #builder = ./builder.sh;
 
@@ -14,7 +14,7 @@ stdenv.mkDerivation rec {
 
   macportSrc = fetchurl {
     url = "ftp://ftp.math.s.chiba-u.ac.jp/emacs/${name}.tar.gz";
-    sha256 = "14ipkwmzv0b02sclhgp2xj0cvhl3gk40sc2l21s87621kk640dzv";
+    sha256 = "0qn200vv91qxf93x6y8fdi7l3bsni3clqzf8rcjdpbva1qzgcx27";
   };
 
   patches = [ ./darwin-new-sections.patch ];

pkgs/applications/editors/emacs-modes/js2/default.nix

@@ -1,12 +1,12 @@
 { stdenv, fetchgit, emacs }:
 
 stdenv.mkDerivation {
-  name = "js2-mode-0-20140114";
+  name = "js2-mode-0-20141118";
 
   src = fetchgit {
     url = "git://github.com/mooz/js2-mode.git";
-    rev = "b250efaad886dd07b8c69d4573425d095c6652e2";
+    rev = "3abcd90ddc2f446ddf0fb874dd79ba870c26ad2d";
-    sha256 = "30e61e7d364e9175d408bdaf57fda886a4eea22cf5cbd97abb5c307c52b05918";
+    sha256 = "c0aaab4eeb8d60cfd5c382c3e30d4725e5ec492720d573e663ea69ee43aa73a8";
   };
 
   buildInputs = [ emacs ];

pkgs/applications/editors/emacs-modes/rainbow-delimiters/default.nix

@@ -1,13 +1,13 @@
 {stdenv, fetchurl, emacs}:
 
-let version = "1.3.12";
+let version = "1.3.13";
 
 in stdenv.mkDerivation {
   name = "emacs-rainbow-delimiters-${version}";
 
   src = fetchurl {
     url = "https://github.com/jlr/rainbow-delimiters/archive/${version}.tar.gz";
-    sha256 = "0l65rqmnrc02q1b406kxc29w5cfpmrmq0glv493pjzhzc5m3r63z";
+    sha256 = "075j3nsk4jm0rs5671n28c1wksrfbvpl9a4f89kzcd7sk1h6ncvl";
   };
 
   buildInputs = [ emacs ];

pkgs/applications/editors/sublime3/default.nix

@@ -1,4 +1,4 @@
-{ fetchurl, stdenv, glib, xlibs, cairo, gtk, pango, makeWrapper}:
+{ fetchurl, stdenv, glib, xlibs, cairo, gtk, pango, makeWrapper, openssl, bzip2 }:
 
 assert stdenv.system == "i686-linux" || stdenv.system == "x86_64-linux";
 
@@ -41,7 +41,7 @@ in let
       mkdir -p $out
       cp -prvd * $out/
       # Without this, plugin_host crashes, even though it has the rpath
-      wrapProgram $out/plugin_host --prefix LD_PRELOAD : ${stdenv.gcc.gcc}/lib${stdenv.lib.optionalString stdenv.is64bit "64"}/libgcc_s.so.1
+      wrapProgram $out/plugin_host --prefix LD_PRELOAD : ${stdenv.gcc.gcc}/lib${stdenv.lib.optionalString stdenv.is64bit "64"}/libgcc_s.so.1:${openssl}/lib/libssl.so:${bzip2}/lib/libbz2.so
     '';
   };
 in stdenv.mkDerivation {

pkgs/applications/editors/vim/qvim.nix

@@ -1,5 +1,8 @@
 args@{...}: with args;
 
+let tag = "20140827";
+    sha256 = "02adf2212872db3c5d133642d2c12fbfc28b506e4c0c42552e3d079756f63f65";
+in
 
 let inherit (args.composableDerivation) composableDerivation edf; in
 composableDerivation {
@@ -9,14 +12,14 @@ composableDerivation {
                    else stdenv ).mkDerivation;
 } (fix: {
 
-    name = "qvim-7.4";
+    name = "qvim-7.4." + tag;
 
     enableParallelBuilding = true; # test this
 
     src = fetchgit {
       url = https://bitbucket.org/equalsraf/vim-qt.git ;
-      rev = "4160bfd5c1380e899d2f426b494fc4f1cf6ae85e";
+      rev = "refs/tags/package-" + tag;
-      sha256 = "1qa3xl1b9gqw66p71h53l7ibs4y3zfyj553jss70ybxaxchbhi5b";
+      inherit sha256;
     };
 
     # FIXME: adopt Darwin fixes from vim/default.nix, then chage meta.platforms.linux
@@ -119,7 +122,7 @@ composableDerivation {
   meta = with stdenv.lib; {
     description = "The most popular clone of the VI editor (Qt GUI fork)";
     homepage    = https://bitbucket.org/equalsraf/vim-qt/wiki/Home;
-    maintainers = with maintainers; [ smironov ];
+    maintainers = with maintainers; [ smironov ttuegel ];
     platforms   = platforms.linux;
   };
 })

pkgs/applications/graphics/digikam/default.nix

@@ -4,11 +4,11 @@ liblqr1, lensfun, pkgconfig, qjson, libkdcraw, opencv, libkexiv2, libkipi, boost
 shared_desktop_ontologies, marble, mysql }:
 
 stdenv.mkDerivation rec {
-  name = "digikam-3.5.0";
+  name = "digikam-4.4.0";
 
   src = fetchurl {
     url = "http://download.kde.org/stable/digikam/${name}.tar.bz2";
-    sha256 = "0an4awlg0b8pwl6v8p5zfl3aghgnxck2pc322cyk6i6yznj2mgap";
+    sha256 = "1sflh3i989f9xi4qym3rzcrx7ahrjf1n9si8c5q05dgm039a4s2w";
   };
 
   nativeBuildInputs = [ cmake automoc4 pkgconfig ];

pkgs/applications/graphics/sane/backends.nix

@@ -33,8 +33,8 @@ stdenv.mkDerivation rec {
   postInstall = ''
     if test "$udevSupport" = "1"; then
       mkdir -p $out/etc/udev/rules.d/
-      ./tools/sane-desc -m udev > $out/etc/udev/rules.d/60-libsane.rules || \
+      ./tools/sane-desc -m udev > $out/etc/udev/rules.d/49-libsane.rules || \
-      cp tools/udev/libsane.rules $out/etc/udev/rules.d/60-libsane.rules
+      cp tools/udev/libsane.rules $out/etc/udev/rules.d/49-libsane.rules
     fi
   '';
 

pkgs/applications/misc/calibre/default.nix

@@ -5,11 +5,11 @@
 }:
 
 stdenv.mkDerivation rec {
-  name = "calibre-2.10.0";
+  name = "calibre-2.11.0";
 
   src = fetchurl {
     url = "mirror://sourceforge/calibre/${name}.tar.xz";
-    sha256 = "06nya8r3bfkgfjsl83fl6l6g3ccw3mpmn3kih4i51gpcgma3aa6b";
+    sha256 = "19pn55yvc7yiz21gri5838zf7n88l6m2abbwzswn4x8v9915lls1";
   };
 
   inherit python;

pkgs/applications/misc/doomseeker/default.nix

@@ -23,6 +23,7 @@ stdenv.mkDerivation rec {
     homepage = http://doomseeker.drdteam.org/;
     description = "Multiplayer server browser for many Doom source ports";
     license = stdenv.lib.licenses.gpl2;
+    platforms = stdenv.lib.platforms.unix;
     maintainers = with stdenv.lib.maintainers; [ MP2E ];
   };
 }

pkgs/applications/misc/eaglemode/default.nix

@@ -1,16 +1,16 @@
 { stdenv, fetchurl, perl, libX11, libjpeg, libpng, libtiff, pkgconfig,
-librsvg, glib, gtk, libXext, libXxf86vm, poppler }:
+librsvg, glib, gtk, libXext, libXxf86vm, poppler, xineLib }:
 
 stdenv.mkDerivation rec {
-  name = "eaglemode-0.85.0";
+  name = "eaglemode-0.86.0";
 
   src = fetchurl {
     url = "mirror://sourceforge/eaglemode/${name}.tar.bz2";
-    sha256 = "0mz4rg2k36wvcv55dg0a5znaczpl5h4gwkkb34syj89xk8jlbwsc";
+    sha256 = "1a2hzyck95g740qg4p4wd4fjwsmlknh75i9sbx5r5v9pyr4i3m4f";
   };
 
   buildInputs = [ perl libX11 libjpeg libpng libtiff pkgconfig
-    librsvg glib gtk libXxf86vm libXext poppler ];
+    librsvg glib gtk libXxf86vm libXext poppler xineLib ];
 
   # The program tries to dlopen both Xxf86vm and Xext, so we use the
   # trick on NIX_LDFLAGS and dontPatchELF to make it find them.

pkgs/applications/misc/girara/default.nix

@@ -1,19 +1,27 @@
-{ stdenv, fetchurl, pkgconfig, gtk, gettext, ncurses }:
+{ stdenv, fetchurl, pkgconfig, gtk, gettext, withBuildColors ? true, ncurses ? null}:
 
+assert withBuildColors -> ncurses != null;
+
+with stdenv.lib;
 stdenv.mkDerivation rec {
-  name = "girara-0.2.3";
+  name = "girara-${version}";
+  version = "0.2.3";
 
   src = fetchurl {
     url = "http://pwmt.org/projects/girara/download/${name}.tar.gz";
     sha256 = "1phfmqp8y17zcy9yi6pm2f80x8ldbk60iswpm4bmjz5217jwqzxh";
   };
 
+  preConfigure = ''
+    sed -i 's/ifdef TPUT_AVAILABLE/ifneq ($(TPUT_AVAILABLE), 0)/' colors.mk
+  '';
+
   buildInputs = [ pkgconfig gtk gettext ];
 
-  makeFlags = [
+  makeFlags = [ "PREFIX=$(out)" ]
-    "PREFIX=$(out)"
+    ++ optional withBuildColors "TPUT=${ncurses}/bin/tput"
-    "TPUT=${ncurses}/bin/tput"
+    ++ optional (!withBuildColors) "TPUT_AVAILABLE=0"
-  ];
+    ;
 
   meta = {
     homepage = http://pwmt.org/projects/girara/;
@@ -22,9 +30,8 @@ stdenv.mkDerivation rec {
       girara is a library that implements a GTK+ based VIM-like user interface
       that focuses on simplicity and minimalism.
     '';
-    license = stdenv.lib.licenses.zlib;
+    license = licenses.zlib;
-    platforms = stdenv.lib.platforms.linux;
+    platforms = platforms.linux;
-    maintainers = [ stdenv.lib.maintainers.garbas ];
+    maintainers = [ maintainers.garbas ];
   };
 }
-

pkgs/applications/misc/gosmore/default.nix

@@ -1,34 +1,30 @@
-a@{fetchsvn, libxml2, gtk, curl, pkgconfig, lib, ...} :  
+{ stdenv, fetchsvn, libxml2, gtk, curl, pkgconfig } :
-let 
-  fetchsvn = a.fetchsvn;
 
-  buildInputs = with a; [
+let
-    libxml2 gtk curl pkgconfig
+  version = "30811";
-  ];
 in
-rec {
+stdenv.mkDerivation {
+  name = "gosmore-r${version}";
   src = fetchsvn {
     url = http://svn.openstreetmap.org/applications/rendering/gosmore;
-    sha256 = "0ds61gl75rnzvm0hj9papl5sfcgdv4310df9ch7x9rifssfli9zm";
+    sha256 = "0qyvrb4xgy4msc7f65widzkvjzc8mlddc4dyr1i76b7wd3gpk0xj";
-    rev = "24178";
+    rev = "${version}";
-  } + "/";
+  };
 
-  inherit buildInputs;
+  buildInputs = [ libxml2 gtk curl ];
-  configureFlags = [];
 
-  /* doConfigure should be removed if not needed */
+  nativeBuildInputs = [ pkgconfig ];
-  phaseNames = ["fixCurlIncludes" "doConfigure" "doMakeInstall"];
 
-  fixCurlIncludes = a.fullDepEntry ''
+  prePatch = ''
     sed -e '/curl.types.h/d' -i *.{c,h,hpp,cpp}
-  '' ["minInit" "doUnpack"];
+  '';
       
-  name = "gosmore-r21657";
+  meta = with stdenv.lib; {
-  meta = {
     description = "Open Street Map viewer";
-    maintainers = [
+    homepage = http://sourceforge.net/projects/gosmore/;
-      a.lib.maintainers.raskin
+    maintainers = with maintainers; [
+      raskin
     ];
-    platforms = a.lib.platforms.linux;
+    platforms = platforms.linux;
   };
 }

pkgs/applications/misc/hello/ex-2/default.nix

@@ -1,11 +1,11 @@
 { stdenv, fetchurl }:
 
 stdenv.mkDerivation rec {
-  name = "hello-2.9";
+  name = "hello-2.10";
 
   src = fetchurl {
     url = "mirror://gnu/hello/${name}.tar.gz";
-    sha256 = "19qy37gkasc4csb1d3bdiz9snn8mir2p3aj0jgzmfv0r2hi7mfzc";
+    sha256 = "0ssi1wpaf7plaswqqjwigppsg5fyh99vdlb9kzl7c9lng89ndq1i";
   };
 
   doCheck = true;
@@ -18,7 +18,7 @@ stdenv.mkDerivation rec {
     '';
     homepage = http://www.gnu.org/software/hello/manual/;
     license = stdenv.lib.licenses.gpl3Plus;
-    maintainers = [ stdenv.lib.maintainers.ludo ];
+    maintainers = [ stdenv.lib.maintainers.ludo stdenv.lib.maintainers.eelco ];
     platforms = stdenv.lib.platforms.all;
   };
 }

pkgs/applications/misc/redshift/default.nix

@@ -3,11 +3,11 @@
 , GConf, dbus, dbus_glib, makeWrapper, gtk, pygtk, pyxdg, geoclue }:
 
 stdenv.mkDerivation rec {
-  version = "1.8";
+  version = "1.9.1";
   name = "redshift-${version}";
   src = fetchurl {
     url = "https://github.com/jonls/redshift/archive/v${version}.tar.gz";
-    sha256 = "1srj2dwy32h71iqikb4ysv5ipclym80i9lys2ns8vjmclg7hj3vi";
+    sha256 = "0rj7lyg4ikwpk1hr1k2bgk9gjqvvv51z8hydsgpx2k2lqdv6lqri";
   };
 
   buildInputs = [

pkgs/applications/misc/sqliteman/default.nix

@@ -0,0 +1,31 @@
+{ stdenv, fetchurl, cmake, qt4, qscintilla }:
+
+stdenv.mkDerivation rec {
+  name = "sqliteman";
+  version = "1.2.0-c41b89e1";
+
+  src = fetchurl {
+    url = https://github.com/pvanek/sqliteman/archive/1.2.0.tar.gz;
+    sha256 = "1x4ppwf01jdnz3a4ycia6vv5qf3w2smbqx690z1pnkwbvk337akm";
+  };
+
+  buildInputs = [ cmake qt4 qscintilla ];
+
+  prePatch = ''
+    sed -i 's,m_file(0),m_file(QString()),' Sqliteman/sqliteman/main.cpp
+  '';
+
+  preConfigure = ''
+    cd Sqliteman
+    sed -i 's,/usr/include/Qsci,${qscintilla}/include/Qsci,' cmake/modules/FindQScintilla.cmake
+    sed -i 's,PATHS ''${QT_LIBRARY_DIR},PATHS ${qscintilla}/libs,' cmake/modules/FindQScintilla.cmake
+  '';
+
+  meta = with stdenv.lib; {
+    description = "Sqliteman is simple but powerfull Sqlite3 GUI database manager.";
+    homepage = http://sqliteman.yarpen.cz/;
+    license = licenses.gpl2Plus;
+    platforms = platforms.linux;
+    maintainers = [ maintainers.eikek ];
+  };
+}

pkgs/applications/misc/synergy/default.nix

@@ -1,16 +1,19 @@
-{ stdenv, fetchurl, cmake, x11, libX11, libXi, libXtst, libXrandr, xinput, curl
+{ stdenv, fetchFromGitHub, cmake, x11, libX11, libXi, libXtst, libXrandr
-, cryptopp ? null, unzip }:
+, xinput, curl, cryptopp ? null, unzip }:
 
 assert stdenv.isLinux -> cryptopp != null;
 
 with stdenv.lib;
 
 stdenv.mkDerivation rec {
-  name = "synergy-1.5.1";
+  name = "synergy-${version}";
+  version = "1.6.1";
 
-  src = fetchurl {
+  src = fetchFromGitHub {
-    url = "http://synergy-project.org/files/packages/${name}-r2398-Source.tar.gz";
+    owner = "synergy";
-    sha256 = "19q8ck15f0jgpbzlm34dzp046wf3iiwa21s1qfyj5sj7xjxwa367";
+    repo = "synergy";
+    rev = "1.6.1";
+    sha256 = "1043101c4phv1nbxiqp2jn1jhgzspv9q6v75z0kfzwgii5n5xq1c";
   };
 
   patches = optional stdenv.isLinux ./cryptopp.patch;

pkgs/applications/misc/tilda/default.nix

@@ -6,11 +6,11 @@
 stdenv.mkDerivation rec {
 
   name = "tilda-${version}";
-  version = "1.1.13";
+  version = "1.2.2";
 
   src = fetchurl {
     url = "https://github.com/lanoxx/tilda/archive/${name}.tar.gz";
-    sha256 = "1b9rnyrdvqmw2xjv899a4k6hvr9w482c4xvlpfnckckxdyp2852d";
+    sha256 = "1mzly0llsrxpc2yd1hml3gmwm023my2j3aszjw383pp34dab2nl5";
   };
 
   buildInputs = [ pkgconfig autoreconfHook gettext confuse vte gtk makeWrapper ];

pkgs/applications/networking/browsers/chromium/browser.nix

@@ -12,7 +12,7 @@ mkChromiumDerivation (base: rec {
     cp -v "$buildPath/"*.pak "$libExecPath/"
     cp -v "$buildPath/icudtl.dat" "$libExecPath/"
     cp -vLR "$buildPath/locales" "$buildPath/resources" "$libExecPath/"
-    cp -v $buildPath/libffmpegsumo.so "$libExecPath/"
+    cp -v "$buildPath/libpdf.so" "$buildPath/libffmpegsumo.so" "$libExecPath/"
 
     cp -v "$buildPath/chrome" "$libExecPath/$packageName"
 

pkgs/applications/networking/browsers/chromium/common.nix

@@ -69,7 +69,7 @@ let
     use_system_xdg_utils = true;
     use_system_yasm = true;
     use_system_zlib = false;
-    use_system_protobuf = true;
+    use_system_protobuf = versionOlder source.version "40.0.0.0";
 
     use_system_harfbuzz = false;
     use_system_icu = false; # Doesn't support ICU 52 yet.

pkgs/applications/networking/browsers/chromium/default.nix

@@ -9,7 +9,6 @@
 , gnomeKeyringSupport ? false
 , proprietaryCodecs ? true
 , enablePepperFlash ? false
-, enablePepperPDF ? false
 , enableWideVine ? false
 , cupsSupport ? false
 , pulseSupport ? false
@@ -36,7 +35,7 @@ let
     sandbox = callPackage ./sandbox.nix { };
 
     plugins = callPackage ./plugins.nix {
-      inherit enablePepperFlash enablePepperPDF enableWideVine;
+      inherit enablePepperFlash enableWideVine;
     };
   };
 
@@ -74,6 +73,7 @@ in stdenv.mkDerivation {
     ln -s "${chromium.browser}/share" "$out/share"
     makeWrapper "${browserBinary}" "$out/bin/chromium" \
       --set CHROMIUM_SANDBOX_BINARY_PATH "${sandboxBinary}" \
+      --run "export ${chromium.plugins.envVarsEnabled}" \
       --add-flags "${chromium.plugins.flagsEnabled}"
 
     ln -s "$out/bin/chromium" "$out/bin/chromium-browser"

pkgs/applications/networking/browsers/chromium/plugins.nix

@@ -1,6 +1,5 @@
 { stdenv
 , enablePepperFlash ? false
-, enablePepperPDF ? false
 , enableWideVine ? false
 
 , source
@@ -16,7 +15,7 @@ let
     src = source.plugins;
 
     phases = [ "unpackPhase" "patchPhase" "installPhase" "checkPhase" ];
-    outputs = [ "pdf" "flash" "widevine" ];
+    outputs = [ "flash" "widevine" ];
 
     unpackCmd = let
       chan = if source.channel == "dev"    then "chrome-unstable"
@@ -26,7 +25,6 @@ let
       mkdir -p plugins
       ar p "$src" data.tar.lzma | tar xJ -C plugins --strip-components=4 \
         ./opt/google/${chan}/PepperFlash \
-        ./opt/google/${chan}/libpdf.so \
         ./opt/google/${chan}/libwidevinecdm.so \
         ./opt/google/${chan}/libwidevinecdmadapter.so
     '';
@@ -40,7 +38,7 @@ let
       rpaths = [ stdenv.gcc.gcc ];
       mkrpath = p: "${makeSearchPath "lib64" p}:${makeSearchPath "lib" p}";
     in ''
-      for sofile in PepperFlash/libpepflashplayer.so libpdf.so \
+      for sofile in PepperFlash/libpepflashplayer.so \
                     libwidevinecdm.so libwidevinecdmadapter.so; do
         chmod +x "$sofile"
         patchelf --set-rpath "${mkrpath rpaths}" "$sofile"
@@ -51,25 +49,12 @@ let
     '';
 
     installPhase = let
-      pdfName = "Chrome PDF Viewer";
-      pdfDescription = "Portable Document Format";
-      pdfMimeTypes = concatStringsSep ";" [
-        "application/pdf"
-        "application/x-google-chrome-print-preview-pdf"
-      ];
-      pdfInfo = "#${pdfName}#${pdfDescription};${pdfMimeTypes}";
-
       wvName = "Widevine Content Decryption Module";
       wvDescription = "Playback of encrypted HTML audio/video content";
       wvMimeTypes = "application/x-ppapi-widevine-cdm";
       wvModule = "$widevine/lib/libwidevinecdmadapter.so";
       wvInfo = "#${wvName}#${wvDescription}:${wvMimeTypes}";
     in ''
-      install -vD libpdf.so "$pdf/lib/libpdf.so"
-      mkdir -p "$pdf/nix-support"
-      echo "--register-pepper-plugins='$pdf/lib/libpdf.so${pdfInfo}'" \
-        > "$pdf/nix-support/chromium-flags"
-
       flashVersion="$(
         sed -n -r 's/.*"version": "([^"]+)",.*/\1/p' PepperFlash/manifest.json
       )"
@@ -88,13 +73,18 @@ let
       mkdir -p "$widevine/nix-support"
       echo "--register-pepper-plugins='${wvModule}${wvInfo}'" \
         > "$widevine/nix-support/chromium-flags"
+      echo "NIX_CHROMIUM_PLUGIN_PATH_WIDEVINE=$widevine/lib" \
+        > "$widevine/nix-support/chromium-env-vars"
     '';
 
-    passthru.flagsEnabled = let
+    passthru = let
       enabledPlugins = optional enablePepperFlash plugins.flash
-                    ++ optional enablePepperPDF   plugins.pdf
                     ++ optional enableWideVine    plugins.widevine;
       getFlags = plugin: "$(< ${plugin}/nix-support/chromium-flags)";
-    in concatStringsSep " " (map getFlags enabledPlugins);
+      getEnvVars = plugin: "$(< ${plugin}/nix-support/chromium-env-vars)";
+    in {
+      flagsEnabled = concatStringsSep " " (map getFlags enabledPlugins);
+      envVarsEnabled = concatStringsSep " " (map getEnvVars enabledPlugins);
+    };
   };
 in plugins

pkgs/applications/networking/browsers/chromium/source/default.nix

@@ -22,9 +22,7 @@ stdenv.mkDerivation {
 
   prePatch = "patchShebangs .";
 
-  patches = let
+  patches = [ ./sandbox_userns_36.patch ./nix_plugin_paths.patch ];
-    onPre39 = optional (versionOlder version "39.0.0.0");
-  in [ ./sandbox_userns_36.patch ] ++ onPre39 ./missing_alg_import.patch;
 
   postPatch = ''
     sed -i -r \

pkgs/applications/networking/browsers/chromium/source/missing_alg_import.patch

@@ -1,11 +0,0 @@
-diff -Naur chromium-37.0.2062.94.old/media/cast/logging/encoding_event_subscriber.cc chromium-37.0.2062.94/media/cast/logging/encoding_event_subscriber.cc
---- chromium-37.0.2062.94.old/media/cast/logging/encoding_event_subscriber.cc	2014-08-29 02:05:15.149140733 -0700
-+++ chromium-37.0.2062.94/media/cast/logging/encoding_event_subscriber.cc	2014-08-29 02:06:00.182853590 -0700
-@@ -4,6 +4,7 @@
- 
- #include "media/cast/logging/encoding_event_subscriber.h"
- 
-+#include <algorithm>
- #include <cstring>
- #include <utility>
- 

pkgs/applications/networking/browsers/chromium/source/nix_plugin_paths.patch

@@ -0,0 +1,99 @@
+diff --git a/chrome/common/chrome_paths.cc b/chrome/common/chrome_paths.cc
+index 8a205a6..d5c24e1 100644
+--- a/chrome/common/chrome_paths.cc
++++ b/chrome/common/chrome_paths.cc
+@@ -97,21 +97,14 @@ static base::LazyInstance<base::FilePath>
+     g_invalid_specified_user_data_dir = LAZY_INSTANCE_INITIALIZER;
+ 
+ // Gets the path for internal plugins.
+-bool GetInternalPluginsDirectory(base::FilePath* result) {
+-#if defined(OS_MACOSX) && !defined(OS_IOS)
+-  // If called from Chrome, get internal plugins from a subdirectory of the
+-  // framework.
+-  if (base::mac::AmIBundled()) {
+-    *result = chrome::GetFrameworkBundlePath();
+-    DCHECK(!result->empty());
+-    *result = result->Append("Internet Plug-Ins");
+-    return true;
+-  }
+-  // In tests, just look in the module directory (below).
+-#endif
+-
+-  // The rest of the world expects plugins in the module directory.
+-  return PathService::Get(base::DIR_MODULE, result);
++bool GetInternalPluginsDirectory(base::FilePath* result,
++                                 const std::string& ident) {
++  std::string full_env = std::string("NIX_CHROMIUM_PLUGIN_PATH_") + ident;
++  const char* value = getenv(full_env.c_str());
++  if (value == NULL)
++      return PathService::Get(base::DIR_MODULE, result);
++  else
++      *result = base::FilePath(value);
+ }
+ 
+ }  // namespace
+@@ -248,11 +241,11 @@ bool PathProvider(int key, base::FilePath* result) {
+       create_dir = true;
+       break;
+     case chrome::DIR_INTERNAL_PLUGINS:
+-      if (!GetInternalPluginsDirectory(&cur))
++      if (!GetInternalPluginsDirectory(&cur, "ALL"))
+         return false;
+       break;
+     case chrome::DIR_PEPPER_FLASH_PLUGIN:
+-      if (!GetInternalPluginsDirectory(&cur))
++      if (!GetInternalPluginsDirectory(&cur, "PEPPERFLASH"))
+         return false;
+       cur = cur.Append(kPepperFlashBaseDirectory);
+       break;
+@@ -285,7 +278,7 @@ bool PathProvider(int key, base::FilePath* result) {
+       cur = cur.Append(FILE_PATH_LITERAL("script.log"));
+       break;
+     case chrome::FILE_FLASH_PLUGIN:
+-      if (!GetInternalPluginsDirectory(&cur))
++      if (!GetInternalPluginsDirectory(&cur, "FILEFLASH"))
+         return false;
+       cur = cur.Append(kInternalFlashPluginFileName);
+       break;
+@@ -295,12 +288,12 @@ bool PathProvider(int key, base::FilePath* result) {
+       cur = cur.Append(chrome::kPepperFlashPluginFilename);
+       break;
+     case chrome::FILE_PDF_PLUGIN:
+-      if (!GetInternalPluginsDirectory(&cur))
++      if (!GetInternalPluginsDirectory(&cur, "PDF"))
+         return false;
+       cur = cur.Append(kInternalPDFPluginFileName);
+       break;
+     case chrome::FILE_EFFECTS_PLUGIN:
+-      if (!GetInternalPluginsDirectory(&cur))
++      if (!GetInternalPluginsDirectory(&cur, "FILE_EFFECTS"))
+         return false;
+       cur = cur.Append(kEffectsPluginFileName);
+       break;
+@@ -308,7 +301,7 @@ bool PathProvider(int key, base::FilePath* result) {
+     // We currently need a path here to look up whether the plugin is disabled
+     // and what its permissions are.
+     case chrome::FILE_NACL_PLUGIN:
+-      if (!GetInternalPluginsDirectory(&cur))
++      if (!GetInternalPluginsDirectory(&cur, "NACL"))
+         return false;
+       cur = cur.Append(kInternalNaClPluginFileName);
+       break;
+@@ -343,7 +336,7 @@ bool PathProvider(int key, base::FilePath* result) {
+         cur = cur.DirName();
+       }
+ #else
+-      if (!GetInternalPluginsDirectory(&cur))
++      if (!GetInternalPluginsDirectory(&cur, "PNACL"))
+         return false;
+ #endif
+       cur = cur.Append(FILE_PATH_LITERAL("pnacl"));
+@@ -372,7 +365,7 @@ bool PathProvider(int key, base::FilePath* result) {
+     // In the component case, this is the source adapter. Otherwise, it is the
+     // actual Pepper module that gets loaded.
+     case chrome::FILE_WIDEVINE_CDM_ADAPTER:
+-      if (!GetInternalPluginsDirectory(&cur))
++      if (!GetInternalPluginsDirectory(&cur, "WIDEVINE"))
+         return false;
+       cur = cur.AppendASCII(kWidevineCdmAdapterFileName);
+       break;

pkgs/applications/networking/browsers/chromium/source/sources.nix

@@ -1,21 +1,21 @@
 # This file is autogenerated from update.sh in the parent directory.
 {
   dev = {
-    version = "40.0.2182.3";
+    version = "41.0.2224.3";
-    sha256 = "1713y6f2q5qh32wg027nphkv6p6rgq0q1awqcy543ypbk9p1jvbm";
+    sha256 = "04lgklidxx4bryqhnm7kjqbfr12ns8ic9g4yxk3dig71081sas5f";
-    sha256bin32 = "0qf0ccfg77qc17iy5cndkp827s8li3qyxasmgjq224g579wcj0bl";
+    sha256bin32 = "17fgh57yckk318r7r6qkc934dpq35qa6ps4x5fwscl070rzjf81k";
-    sha256bin64 = "07f97m548kj7indpzyyvksa4gisndxc1s8qslk43mgsx26kz62rf";
+    sha256bin64 = "1qsvjm38cxx3inrw0hs4q9f4i9arqfj9cs57xh64wflrnh2z52zf";
   };
   beta = {
-    version = "39.0.2171.19";
+    version = "40.0.2214.10";
-    sha256 = "19j86hzh552a73mvabzgdiq0s1ypr30b6lkn4kfxc2vhs1ds8nmg";
+    sha256 = "0wxkxgj6z18l2qkm0k16r8bpv9rdxk1g1ias03zzvlbj1bw3brdn";
-    sha256bin32 = "06imcc3r6g4f7yi8b4mzknqk11khzk44pjrw0qnw40kgjf0kkgd3";
+    sha256bin32 = "0wr2vg97d3qrryb5sz31sd3ycb1l17irrs79vfa04ip85jqv89zn";
-    sha256bin64 = "0qd594rbg049g1h4s7lgw9abcccx6wrl3fggkd1z9bl8ihj54j4b";
+    sha256bin64 = "0bclgy386vdmfdf59hwkypcs8wwmlpgl3npp089hmcdvv7dmars8";
   };
   stable = {
-    version = "38.0.2125.101";
+    version = "39.0.2171.65";
-    sha256 = "12hrl7i0xrjdwz8yaap5jhc6bzn29pk6dcz96743n6j7mcckac6k";
+    sha256 = "0lglcjvyhgmdm0sd76wv509pgwcfl86rlp9rj83z9giadwqlcmxi";
-    sha256bin32 = "1c35j4wx53njcqbdqznz2m0791bb9lpmhnpkrll36051437f25wl";
+    sha256bin32 = "1iqzi462vw8da5f8ysk76q68xhiw5ndqc3hhc6djipsc6h240bji";
-    sha256bin64 = "1k8hrrxlqc1mv88v2qkyq8188lfaibvqpqg0g8qgj2ha5vsnvwvw";
+    sha256bin64 = "1gxh3sxpnl0167la9ncnz7l85gzi4ax6g5pqni1nma5g5cqqm177";
   };
 }

pkgs/applications/networking/browsers/firefox/default.nix

@@ -15,14 +15,14 @@
 
 assert stdenv.gcc ? libc && stdenv.gcc.libc != null;
 
-let version = "33.1"; in
+let version = "33.1.1"; in
 
 stdenv.mkDerivation rec {
   name = "firefox-${version}";
 
   src = fetchurl {
     url = "http://ftp.mozilla.org/pub/mozilla.org/firefox/releases/${version}/source/firefox-${version}.source.tar.bz2";
-    sha1 = "bc87055d3b68e8458f07d0c04503b6aaed3771df";
+    sha1 = "1e9e3176e7d221c4f2ce479f37ee7c432236a0ec";
   };
 
   buildInputs =

pkgs/applications/networking/cluster/kubernetes/default.nix

@@ -0,0 +1,34 @@
+{ stdenv, fetchFromGitHub, which, go, makeWrapper, iptables,rsync }:
+
+stdenv.mkDerivation rec {
+  name = "kubernetes-${version}";
+  version = "v0.5.2";
+
+  src = fetchFromGitHub {
+    owner = "GoogleCloudPlatform";
+    repo = "kubernetes";
+    rev = version;
+    sha256 = "0nrm59v43jx0cskpd294q946053cfw3y2cgs53ji35dnhgj6fl6w";
+  };
+
+  buildInputs = [ makeWrapper which go iptables rsync ];
+
+  preBuild = "patchShebangs ./hack";
+
+  installPhase = ''
+    mkdir -p "$out/bin"
+    cp _output/local/go/bin/* "$out/bin/"
+  '';
+
+  preFixup = ''
+    wrapProgram "$out/bin/kube-proxy" --set "PATH" "${iptables}/bin"
+  '';
+
+  meta = with stdenv.lib; {
+    description = "Open source implementation of container cluster management.";
+    license = licenses.asl20;
+    homepage = https://github.com/GoogleCloudPlatform;
+    maintainers = with maintainers; [offline];
+    platforms = with platforms; linux;
+  };
+}

pkgs/applications/networking/dropbox/default.nix

@@ -25,9 +25,9 @@ let
     else if stdenv.system == "i686-linux" then "ld-linux.so.2"
     else throw "Dropbox client for: ${stdenv.system} not supported!";
 
-  version = "2.10.30";
+  version = "2.10.52";
-  sha256 = if stdenv.system == "x86_64-linux" then "1gdch4fka5f671zwl329j6b60igki1rzxw9ggxcywcg1h4rlvw7r"
+  sha256 = if stdenv.system == "x86_64-linux" then "0fn2frp00f0p0r6v5czzxfbw1ifan9w12k3ry8gq1m4bvx6g27p6"
-    else if stdenv.system == "i686-linux" then "1a4pswpy945iqzvi8kcs1r0sydb04h28v5zv0hdyra0c548wsm2g"
+    else if stdenv.system == "i686-linux" then "1rm5kspb53zqgaz48v8x3ffk1mcfi0nh0zsmsdniyrgqbis5mmm9"
     else throw "Dropbox client for: ${stdenv.system} not supported!";
 
   # relative location where the dropbox libraries are stored

pkgs/applications/networking/instant-messengers/gajim/default.nix

@@ -1,5 +1,5 @@
 { stdenv, fetchurl, python, intltool, pkgconfig, libX11, gtk
-, ldns, pyopenssl, pythonDBus, pythonPackages
+, ldns, pythonDBus, pythonPackages
 
 , enableJingle ? true, farstream ? null, gst_plugins_bad ? null
 ,                      libnice ? null
@@ -64,7 +64,7 @@ stdenv.mkDerivation rec {
     pythonPackages.sqlite3 pythonPackages.pyasn1
     pythonPackages.pyxdg
     pythonPackages.nbxmpp
-    pyopenssl pythonDBus
+    pythonPackages.pyopenssl pythonDBus
   ] ++ optionals enableJingle [ farstream gst_plugins_bad libnice ]
     ++ optional enableE2E pythonPackages.pycrypto
     ++ optional enableRST pythonPackages.docutils

pkgs/applications/networking/instant-messengers/mcabber/default.nix

@@ -1,4 +1,4 @@
-{stdenv, fetchurl, openssl, ncurses, pkgconfig, glib, loudmouth}:
+{stdenv, fetchurl, openssl, ncurses, pkgconfig, glib, loudmouth, libotr}:
 
 stdenv.mkDerivation rec {
   name = "mcabber-${version}";
@@ -6,12 +6,12 @@ stdenv.mkDerivation rec {
 
   src = fetchurl {
     url = "http://mcabber.com/files/mcabber-${version}.tar.bz2";
-    sha256 = "1248cgci1v2ypb90wfhyipwdyp1wskn3gzh78af5ai1a4w5rrjq0";
+    sha256 = "0vgsqw6yn0lzzcnr4fql4ycgf3gwqj6w4p0l4nqnvhkc94w62ikp";
   };
 
-  buildInputs = [openssl ncurses pkgconfig glib loudmouth];
+  buildInputs = [openssl ncurses pkgconfig glib loudmouth libotr];
 
-  configureFlags = "--with-openssl=${openssl}";
+  configureFlags = "--with-openssl=${openssl} --enable-modules --enable-otr";
   
   meta = with stdenv.lib; {
     homepage = http://mcabber.com/;

pkgs/applications/networking/instant-messengers/pidgin/default.nix

@@ -12,7 +12,8 @@
 
 stdenv.mkDerivation rec {
   name = "pidgin-${version}";
-  version = "2.10.10";
+  majorVersion = "2";
+  version = "${majorVersion}.10.10";
 
   src = fetchurl {
     url = "mirror://sourceforge/pidgin/${name}.tar.bz2";
@@ -51,6 +52,8 @@ stdenv.mkDerivation rec {
   ]
   ++ (lib.optionals (gnutls != null) ["--enable-gnutls=yes" "--enable-nss=no"]);
 
+  enableParallelBuilding = true;
+
   meta = with stdenv.lib; {
     description = "Multi-protocol instant messaging client";
     homepage = http://pidgin.im;

pkgs/applications/networking/instant-messengers/pidgin/wrapper.nix

@@ -17,7 +17,7 @@ drv = buildEnv {
       done
     fi
     wrapProgram $out/bin/pidgin \
-      --suffix-each PURPLE_PLUGIN_PATH ':' "$out/lib/purple-${pidgin.version} $out/lib/pidgin" \
+      --suffix-each PURPLE_PLUGIN_PATH ':' "$out/lib/purple-${pidgin.majorVersion} $out/lib/pidgin" \
       ${toString extraArgs}
   '';
   };

pkgs/applications/networking/jmeter/default.nix

@@ -3,7 +3,7 @@
 stdenv.mkDerivation rec {
   name = "jmeter-2.11";
   src = fetchurl {
-    url = "http://ftp.unicamp.br/pub/apache//jmeter/binaries/apache-${name}.tgz";
+    url = "http://archive.apache.org/dist/jmeter/binaries/apache-${name}.tgz";
     sha256 = "1fr3sw06qncb6yygcf2lbnkxma4v1dbigpf39ajrm0isxbpyv944";
   };
 

pkgs/applications/networking/mailreaders/alpine/default.nix

@@ -0,0 +1,38 @@
+{stdenv, fetchurl, ncurses, tcl, openssl, pam, pkgconfig, gettext, kerberos
+, openldap
+}:
+let
+  s = 
+  rec {
+    version = "2.00";
+    url = "ftp://ftp.cac.washington.edu/alpine/alpine-${version}.tar.bz2";
+    sha256 = "19m2w21dqn55rhxbh5lr9qarc2fqa9wmpj204jx7a0zrb90bhpf8";
+    baseName = "alpine";
+    name = "${baseName}-${version}";
+  };
+  buildInputs = [
+    ncurses tcl openssl pam kerberos openldap
+  ];
+in
+stdenv.mkDerivation {
+  inherit (s) name version;
+  inherit buildInputs;
+  src = fetchurl {
+    inherit (s) url sha256;
+  };
+  configureFlags = [
+    "--with-ssl-include-dir=${openssl}/include/openssl"
+    "--with-tcl-lib=tcl8.5"
+    ];
+  preConfigure = ''
+    export NIX_LDFLAGS="$NIX_LDFLAGS -lgcc_s"
+  '';
+  meta = {
+    inherit (s) version;
+    description = ''Console mail reader'';
+    license = stdenv.lib.licenses.asl20;
+    maintainers = [stdenv.lib.maintainers.raskin];
+    platforms = stdenv.lib.platforms.linux;
+    homepage = "https://www.washington.edu/alpine/";
+  };
+}

pkgs/applications/networking/mailreaders/imapfilter.nix

@@ -1,11 +1,11 @@
 { stdenv, fetchurl, openssl, lua, pcre }:
 
 stdenv.mkDerivation rec {
-  name = "imapfilter-2.5.6";
+  name = "imapfilter-2.5.7";
 
   src = fetchurl {
-    url = "https://github.com/lefcha/imapfilter/archive/v2.5.6.tar.gz";
+    url = "https://github.com/lefcha/imapfilter/archive/v2.5.7.tar.gz";
-    sha256 = "0c94xdcnkk33d2filzkbraymfzm09np78486kqzqwidnnfllsk86";
+    sha256 = "1l7sg7pyw1i8cxqnyb5xv983fakj8mxq6w44qd7w3kc7l6ixd4n7";
   };
 
   makeFlagsArray = "PREFIX=$(out)";

pkgs/applications/networking/mailreaders/mutt/default.nix

@@ -1,4 +1,4 @@
-{ stdenv, fetchurl, ncurses, which, perl, automake, autoconf
+{ stdenv, fetchurl, ncurses, which, perl, autoreconfHook
 , sslSupport ? true
 , imapSupport ? true
 , headerCache ? true
@@ -14,6 +14,7 @@
 assert headerCache -> gdbm != null;
 assert sslSupport -> openssl != null;
 assert saslSupport -> cyrus_sasl != null;
+assert gpgmeSupport -> gpgme != null;
 
 let
   version = "1.5.23";
@@ -26,15 +27,14 @@ stdenv.mkDerivation rec {
     sha256 = "0dzx4qk50pjfsb6cs5jahng96a52k12f7pm0sc78iqdrawg71w1s";
   };
 
-  buildInputs = [
+  buildInputs = with stdenv.lib;
-    ncurses which perl
+    [ ncurses which perl ]
-    (if headerCache then gdbm else null)
+    ++ optional headerCache gdbm
-    (if sslSupport then openssl else null)
+    ++ optional sslSupport openssl
-    (if saslSupport then cyrus_sasl else null)
+    ++ optional saslSupport cyrus_sasl
-    (if gpgmeSupport then gpgme else null)
+    ++ optional gpgmeSupport gpgme;
-  ]
+
-  ++ (stdenv.lib.optionals withSidebar [automake autoconf])
+  nativeBuildInputs = stdenv.lib.optional withSidebar autoreconfHook;
-  ;
 
   configureFlags = [
     "--with-mailpath=" "--enable-smtp"
@@ -59,7 +59,7 @@ stdenv.mkDerivation rec {
   patches = [] ++
     (stdenv.lib.optional withSidebar (fetchurl {
       url = http://lunar-linux.org/~tchan/mutt/patch-1.5.23.sidebar.20140412.txt;
-      sha256 = "0bq556sycl0qkr5vg5c3l16bh2bifqc2j7d64n4hw19q0ba2b45w";
+      sha256 = "1i2r7dj0pd1k0z3jjxn2szi6sf0k28i8dwhr4f65pn8r2lh3wisz";
     }));
 
   meta = with stdenv.lib; {

pkgs/applications/networking/mailreaders/realpine/default.nix

@@ -0,0 +1,39 @@
+{stdenv, fetchurl, ncurses, tcl, openssl, pam, pkgconfig, gettext, kerberos
+, openldap
+}:
+let
+  s = 
+  rec {
+    version = "2.03";
+    url = "mirror://sourceforge/re-alpine/re-alpine-${version}.tar.bz2";
+    sha256 = "11xspzbk9cwmklmcw6rxsan7j71ysd4m9c7qldlc59ck595k5nbh";
+    baseName = "re-alpine";
+    name = "${baseName}-${version}";
+  };
+  buildInputs = [
+    ncurses tcl openssl pam kerberos openldap
+  ];
+in
+stdenv.mkDerivation {
+  inherit (s) name version;
+  inherit buildInputs;
+  src = fetchurl {
+    inherit (s) url sha256;
+  };
+  configureFlags = [
+    "--with-ssl-include-dir=${openssl}/include/openssl"
+    "--with-tcl-lib=tcl8.5"
+    ];
+  preConfigure = ''
+    export NIX_LDFLAGS="$NIX_LDFLAGS -lgcc_s"
+  '';
+  meta = {
+    inherit (s) version;
+    description = ''Console mail reader'';
+    license = stdenv.lib.licenses.asl20;
+    maintainers = [stdenv.lib.maintainers.raskin];
+    platforms = stdenv.lib.platforms.linux;
+    homepage = "http://re-alpine.sf.net/";
+    downloadPage = "http://sourceforge.net/projects/re-alpine/files/";
+  };
+}

pkgs/applications/networking/owncloud-client/default.nix

@@ -0,0 +1,32 @@
+{ stdenv, fetchurl, cmake, qt4, pkgconfig, neon, qtkeychain, sqlite }:
+
+stdenv.mkDerivation rec {
+  name = "owncloud-client" + "-" + version;
+
+  version = "1.7.0";
+
+  src = fetchurl {
+    url = "https://download.owncloud.com/desktop/stable/mirall-${version}.tar.bz2";
+    sha256 = "b1cb0612e5022de263dc4c6309eba8207d694a40a80dae6762b4a56fa8d4d944";
+  };
+
+  buildInputs =
+    [ cmake qt4 pkgconfig neon qtkeychain sqlite];
+
+  #configurePhase = ''
+  #  mkdir build
+  #  cd build
+  #  cmake -DBUILD_WITH_QT4=on \
+  #        -DCMAKE_INSTALL_PREFIX=$out \
+  #        -DCMAKE_BUILD_TYPE=Release \
+  #        ..
+  #'';
+
+  enableParallelBuilding = true;
+
+  meta = {
+    description = "Synchronise your ownCloud with your computer using this desktop client";
+    homepage = https://owncloud.org;
+    maintainers = with stdenv.lib.maintainers; [ qknight ];
+  };
+}

pkgs/applications/networking/p2p/mldonkey/default.nix

@@ -11,6 +11,7 @@ stdenv.mkDerivation (rec {
   meta = {
     description = "Client for many p2p networks, with multiple frontends";
     homepage = http://mldonkey.sourceforge.net/;
+    license = stdenv.lib.licenses.gpl2;
   };
 
   buildInputs = [ ocaml zlib ncurses bzip2 file gd libpng ];

pkgs/applications/networking/pond/default.nix

@@ -0,0 +1,32 @@
+{ stdenv, lib, fetchgit, fetchhg, go, trousers }:
+
+let deps = import ./deps.nix {
+  inherit stdenv lib fetchgit fetchhg;
+};
+
+in stdenv.mkDerivation rec {
+  name = "pond";
+
+  buildInputs  = [ go trousers ];
+
+  unpackPhase = ''
+    export GOPATH=$PWD
+    echo $PWD
+    cp -LR ${deps}/src src
+    chmod u+w -R src
+  '';
+
+  installPhase = ''
+    export GOPATH="$PWD"
+    mkdir -p $out/bin
+    go build --tags nogui -v -o $out/bin/pond-cli github.com/agl/pond/client
+  '';
+
+  meta = with lib; {
+    description = "Forward secure, asynchronous messaging for the discerning";
+    homepage = https://pond.imperialviolet.org;
+    license = licenses.bsd3;
+    platforms = platforms.linux;
+  };
+}
+

pkgs/applications/networking/pond/deps.nix

@@ -0,0 +1,60 @@
+# This file was generated by go2nix.
+{ stdenv, lib, fetchgit, fetchhg}:
+
+let
+  goDeps = [
+    {
+      root = "github.com/agl/pond";
+      src = fetchgit {
+        url = "git://github.com/agl/pond.git";
+        rev = "f4e441c77a2039814046ff8219629c547fe8b689";
+        sha256 = "f2dfc6cb96cc4b8ae732e41d1958b62036f40cb346df2e14f27b5964a1416026";
+      };
+    }
+    {
+      root = "github.com/agl/ed25519";
+      src = fetchgit {
+        url = "git://github.com/agl/ed25519.git";
+        rev = "d2b94fd789ea21d12fac1a4443dd3a3f79cda72c";
+        sha256 = "83e3010509805d1d315c7aa85a356fda69d91b51ff99ed98a503d63adb3613e9";
+      };
+    }
+    {
+      root = "code.google.com/p/go.crypto";
+      src = fetchhg {
+        url = "https://code.google.com/p/go.crypto";
+        rev = "31393df5baea";
+        sha256 = "0b95dpsvxxapcjjvhj05fdmyn0mzffamc25hvxy7xgsl2l9yy3nw";
+      };
+    }
+    {
+      root = "code.google.com/p/go.net";
+      src = fetchhg {
+        url = "https://code.google.com/p/go.net";
+        rev = "90e232e2462d";
+        sha256 = "0hqvkaa0rbxwbi74xa6aqbkf63zk662x5hp3bp8vbhzkc4yl1h59";
+      };
+    }
+    {
+      root = "code.google.com/p/goprotobuf";
+      src = fetchhg {
+        url = "https://code.google.com/p/goprotobuf";
+        rev = "36be16571e14";
+        sha256 = "14yay2sgfbbs0bx3q03bdqn1kivyvxfdm34rmp2612gvinlll215";
+      };
+    }
+  ];
+
+in
+
+stdenv.mkDerivation rec {
+  name = "go-deps";
+
+  buildCommand =
+    lib.concatStrings
+      (map (dep: ''
+              mkdir -p $out/src/`dirname ${dep.root}`
+              ln -s ${dep.src} $out/src/${dep.root}
+            '') goDeps);
+}
+

pkgs/applications/office/calligra/default.nix

@@ -6,11 +6,11 @@
  }:
 
 stdenv.mkDerivation rec {
-  name = "calligra-2.7.5";
+  name = "calligra-2.8.6";
 
   src = fetchurl {
     url = "mirror://kde/stable/${name}/${name}.tar.xz";
-    sha256 = "0png8ac10xywxsml1z18as18kc9k9162l6an67hi6lgx0rv27ldi";
+    sha256 = "587dda4a340f46e28fe69de8f292fa33a3cf237445013f6ce5ceafa191cb3694";
   };
 
   nativeBuildInputs = [ cmake perl pkgconfig ];

pkgs/applications/science/logic/coq/HEAD.nix

@@ -3,7 +3,7 @@
 {stdenv, fetchgit, writeText, pkgconfig, ocaml, findlib, camlp5, ncurses, lablgtk ? null}:
 
 let
-  version = "8.5pre-edbd6a21";
+  version = "8.5pre-52f51fb3";
   coq-version = "8.5";
   buildIde = lablgtk != null;
   ideFlags = if buildIde then "-lablgtkdir ${lablgtk}/lib/ocaml/*/site-lib/lablgtk2 -coqide opt" else "";
@@ -17,8 +17,8 @@ stdenv.mkDerivation {
 
   src = fetchgit {
     url = git://scm.gforge.inria.fr/coq/coq.git;
-    rev = "edbd6a211c934778d9721c36463836ef902b4fdd";
+    rev = "52f51fb385d6a1c90bd7d055185fee50ef2670be";
-    sha256 = "19zk1lghqljh86z2kv6kpxwzinpkbwxzf244dmszx31zw4zdrskl";
+    sha256 = "0pgp59j2j8vk7nmcja5smly39dpkqfhpp29wpsn71piq6n52pql3";
   };
 
   buildInputs = [ pkgconfig ocaml findlib camlp5 ncurses lablgtk ];

pkgs/applications/science/logic/hol_light/Makefile.patch

@@ -1,13 +0,0 @@
-Index: Makefile
-===================================================================
---- /Makefile	(révision 199)
-+++ /Makefile	(copie de travail)
-@@ -59,7 +59,7 @@
-              then cp pa_j_3.1x_6.02.1.ml pa_j.ml; \
-              else if test ${CAMLP5_VERSION} = "6.02.2" -o ${CAMLP5_VERSION} = "6.02.3" -o ${CAMLP5_VERSION} = "6.03" -o ${CAMLP5_VERSION} = "6.04" -o ${CAMLP5_VERSION} = "6.05" -o ${CAMLP5_VERSION} = "6.06" ; \
-                   then cp pa_j_3.1x_6.02.2.ml pa_j.ml; \
--                  else if test ${CAMLP5_VERSION} = "6.06" -o ${CAMLP5_VERSION} = "6.07" -o ${CAMLP5_VERSION} = "6.08" -o ${CAMLP5_VERSION} = "6.09" -o ${CAMLP5_VERSION} = "6.10" -o ${CAMLP5_VERSION} = "6.11" ; \
-+                  else if test ${CAMLP5_VERSION} = "6.06" -o ${CAMLP5_VERSION} = "6.07" -o ${CAMLP5_VERSION} = "6.08" -o ${CAMLP5_VERSION} = "6.09" -o ${CAMLP5_VERSION} = "6.10" -o ${CAMLP5_VERSION} = "6.11" -o ${CAMLP5_VERSION} = "6.12" ; \
-                        then cp pa_j_3.1x_6.11.ml pa_j.ml; \
-                        else cp pa_j_3.1x_${CAMLP5_BINARY_VERSION}.xx.ml pa_j.ml; \
-                        fi \

pkgs/applications/science/logic/hol_light/default.nix

@@ -10,18 +10,16 @@ in
 
 stdenv.mkDerivation rec {
   name     = "hol_light-${version}";
-  version  = "199";
+  version  = "205";
 
   src = fetchsvn {
     url = http://hol-light.googlecode.com/svn/trunk;
     rev = version;
-    sha256 = "0308nw91iww18wvl30g5ygf6lhw329jh1vqi9hsh30inhb3dx3jw";
+    sha256 = "1qnk3fkfr6f74nd8wsi84s9kg872cw766sa15a2ldlhs9ma76chj";
   };
 
   buildInputs = [ ocaml findlib camlp5 ];
 
-  patches = [ ./Makefile.patch ];
-
   installPhase = ''
     mkdir -p "$out/lib/hol_light" "$out/bin"
     cp -a  . $out/lib/hol_light

pkgs/applications/version-management/gource/default.nix

@@ -3,12 +3,12 @@
 }:
 
 stdenv.mkDerivation rec {
-  version = "0.42";
+  version = "0.43";
   name = "gource-${version}";
 
   src = fetchurl {
     url = "https://github.com/acaudwell/Gource/releases/download/${name}/${name}.tar.gz";
-    sha256 = "08ab57z44y8b5wxg1193j6hiy50njbpi6dwafjh6nb0apcq8ziz5";
+    sha256 = "1r5x9ai86f609hf584n0xaf5hxkbilj5qihn89v7ghpmwk40m945";
   };
 
   buildInputs = [
@@ -20,10 +20,10 @@ stdenv.mkDerivation rec {
 
   NIX_CFLAGS_COMPILE = "-fpermissive"; # fix build with newer gcc versions
 
-  meta = {
+  meta = with stdenv.lib; {
-    homepage = "http://code.google.com/p/gource/";
+    homepage = http://code.google.com/p/gource/;
-    description = "software version control visualization tool";
+    description = "A Software version control visualization tool";
-    license = stdenv.lib.licenses.gpl3Plus;
+    license = licenses.gpl3Plus;
     longDescription = ''
       Software projects are displayed by Gource as an animated tree with
       the root directory of the project at its centre. Directories
@@ -34,6 +34,7 @@ stdenv.mkDerivation rec {
       Mercurial and Bazaar and SVN. Gource can also parse logs produced
       by several third party tools for CVS repositories.
     '';
-    platforms = stdenv.lib.platforms.linux;
+    platforms = platforms.linux;
+    maintainers = with maintainers; [ pSub ];
   };
 }

pkgs/applications/version-management/mr/default.nix

@@ -1,56 +1,31 @@
 { stdenv, fetchurl, perl }:
 
 stdenv.mkDerivation rec {
-
+  version = "1.20141024";
-  version = "1.13";
+  name = "mr-${version}";
-  name = "mr-" + version;
 
   src = fetchurl {
-    url = "http://ftp.de.debian.org/debian/pool/main/m/mr/mr_${version}.tar.gz";
+    url = "https://github.com/joeyh/myrepos/archive/${version}.tar.gz";
-    sha256 = "1q3qxk8dwbv30v2xxh852wnwl1msgkvk5cgxyicpqj8kh5b96zlz";
+    sha256 = "7b68183476867d15d6f111fc9678335b94824dcfa09f07c761a72d64cdf5ad4a";
   };
 
-  buildInputs = [perl];
+  buildInputs = [ perl ];
 
-  buildPhase = ''
+  makeFlags = "PREFIX=$(out)";
-    make build
-  '';
-
-  installPhase = ''
-    mkdir -pv $out/bin $out/share/man/man1 $out/share/mr
-    cp -v mr $out/bin
-    cp -v webcheckout $out/bin
-    cp -v mr.1 $out/share/man/man1
-    cp -v webcheckout.1 $out/share/man/man1
-    cp -v lib/* $out/share/mr
-  '';
 
   meta = {
     description = "Multiple Repository management tool";
-    longDescription = ''The mr(1) command can checkout, update, or perform other actions on a
+    longDescription = ''
-      set of repositories as if they were one combined respository. It
+      mr is a tool to manage all your version control repos. It can
-      supports any combination of subversion, git, cvs, mercurial, bzr,
+      checkout, update, or perform other actions on a set of
-      darcs, cvs, vcsh, fossil and veracity repositories, and support for
+      repositories as if they were one combined repository. It
-      other revision control systems can easily be added. (There are
+      supports any combination of subversion, git, cvs, mercurial,
-      extensions adding support for unison and git-svn.)
+      bzr, darcs, fossil and veracity repositories, and support for
-
+      other version control systems can easily be added.
-      It is extremely configurable via simple shell scripting. Some examples
-      of things it can do include:
-
-        - Update a repository no more frequently than once every twelve
-          hours.
-        - Run an arbitrary command before committing to a
-          repository.
-        - When updating a git repository, pull from two
-          different upstreams and merge the two together.
-        - Run several repository updates in parallel, greatly speeding
-          up the update process.
-        - Remember actions that failed due to a laptop being
-          offline, so they can be retried when it comes back online.
     '';
-    homepage = http://joeyh.name/code/mr/;
+    homepage = http://myrepos.branchable.com/;
     license = stdenv.lib.licenses.gpl2Plus;
     platforms = stdenv.lib.platforms.unix;
-    maintainers = [ stdenv.lib.maintainers.antono ];
+    maintainers = with stdenv.lib.maintainers; [ antono henrytill ];
   };
 }

pkgs/applications/version-management/src/default.nix

@@ -0,0 +1,38 @@
+{ stdenv, fetchurl, python, rcs, git }:
+
+stdenv.mkDerivation rec {
+  name = "src-0.12";
+
+  src = fetchurl {
+    url = "http://www.catb.org/~esr/src/${name}.tar.gz";
+    sha256 = "1w8k9z2dxim99nniid9kjsc5lzri7m4sd0n819y73aqcdi54lr1s";
+  };
+
+  buildInputs = [ python ];
+
+  patches = [ ./path.patch ];
+
+  postPatch = ''
+    sed -i \
+      -e 's|@python@|${python}|' \
+      -e 's|@rcs@|${rcs}|' \
+      -e 's|@git@|${git}|' \
+      src srctest
+  '';
+
+  makeFlags = [ "prefix=$(out)" ];
+
+  doCheck = true;
+
+  meta = {
+    description = "Simple single-file revision control";
+
+    homepage = http://www.catb.org/~esr/src/;
+
+    license = [ stdenv.lib.licenses.bsd3 ];
+
+    maintainers = [ stdenv.lib.maintainers.shlevy ];
+
+    platforms = stdenv.lib.platforms.all;
+  };
+}

pkgs/applications/version-management/src/path.patch

@@ -0,0 +1,30 @@
+diff -Naur src-0.12-orig/src src-0.12/src
+--- src-0.12-orig/src	2014-11-21 08:19:59.000000000 -0500
++++ src-0.12/src	2014-11-21 15:54:54.598113846 -0500
+@@ -1,4 +1,4 @@
+-#!/usr/bin/env python2
++#!@python@/bin/python
+ #
+ # src - simple revision control.
+ #
+@@ -58,6 +58,8 @@
+ 
+ import sys, os, subprocess, time, calendar, stat, glob, shutil, hashlib
+ 
++os.environ['PATH'] = "@rcs@/bin:@git@/bin:" + os.environ['PATH']
++
+ version="0.12"
+ 
+ def rfc3339(t):
+diff -Naur src-0.12-orig/srctest src-0.12/srctest
+--- src-0.12-orig/srctest	2014-11-21 08:12:00.000000000 -0500
++++ src-0.12/srctest	2014-11-21 15:58:31.370500990 -0500
+@@ -12,7 +12,7 @@
+ 
+ # Set the PATH to include the current directory, so the repository
+ # head version of src can always be tested.
+-PATH="$(pwd)":$PATH
++PATH="$(pwd)":@git@/bin:$PATH
+ 
+ trap "rm -fr $SANDBOX" 0 1 2 15
+ 

pkgs/applications/video/makemkv/default.nix

@@ -4,17 +4,17 @@
 
 stdenv.mkDerivation rec {
   name = "makemkv-${ver}";
-  ver = "1.8.14";
+  ver = "1.9.0";
   builder = ./builder.sh;
 
   src_bin = fetchurl {
     url = "http://www.makemkv.com/download/makemkv-bin-${ver}.tar.gz";
-    sha256 = "1kjxawqh6xnjcgvaqy7idg8k0g3zqrr1w5r2r3bf11pg0h1ys5l5";
+    sha256 = "1rcvg7a1h59mfwsl5w0fr89m101pkqm9vgj06dl91hkgp5nh3wah";
   };
 
   src_oss = fetchurl { 
     url = "http://www.makemkv.com/download/makemkv-oss-${ver}.tar.gz";
-    sha256 = "0cq3h45yyqma0kzi594dz0gbgjf3gyjcgxkiynifz3hacrbxbnd5";
+    sha256 = "0415gw2nacb57sz5m0hcaznynmznc6v8qb6028qnsqgv39d4w8f8";
   };
 
   buildInputs = [openssl qt4 mesa zlib pkgconfig libav];
@@ -22,7 +22,7 @@ stdenv.mkDerivation rec {
   libPath = stdenv.lib.makeLibraryPath [stdenv.gcc.gcc openssl mesa qt4 zlib ] 
           + ":" + stdenv.gcc.gcc + "/lib64";
 
-  meta = {
+  meta = with stdenv.lib; {
     description = "convert blu-ray and dvd to mkv";
     longDescription = ''
       makemkv is a one-click QT application that transcodes an encrypted
@@ -33,7 +33,8 @@ stdenv.mkDerivation rec {
       can always download the latest version from makemkv.com that will reset the
       expiration date.
     '';
-    license = stdenv.lib.licenses.unfree;
+    license = licenses.unfree;
     homepage = http://makemkv.com;
+    maintainers = [ maintainers.titanous ];
   };
 }

pkgs/applications/video/mpv/default.nix

@@ -58,11 +58,11 @@ in
 
 stdenv.mkDerivation rec {
   name = "mpv-${version}";
-  version = "0.6.1";
+  version = "0.6.2";
 
   src = fetchurl {
     url = "https://github.com/mpv-player/mpv/archive/v${version}.tar.gz";
-    sha256 = "03vzsvvb1dvm4rn70m97fdbzhlqj9crk7zpvcp00bcl956xjfc9s";
+    sha256 = "1s42i3vf8i86lx62kw00vvimjizvp8zpxdq53mqhdz1p5im2ylr0";
   };
 
   buildInputs = with stdenv.lib;

pkgs/applications/virtualization/bochs/default.nix

@@ -2,7 +2,7 @@
 , pkgconfig, libtool
 , gtk, mesa, readline, libX11, libXpm
 , docbook_xml_dtd_45, docbook_xsl
-, sdlSupport ? true, SDL ? null
+, sdlSupport ? true, SDL2 ? null
 , termSupport ? true , ncurses ? null
 , wxSupport ? false, wxGTK ? null # Warning! Broken
 # Optional, undocumented dependencies
@@ -10,7 +10,7 @@
 , curlSupport ? false, curl ? null
 }:
 
-assert sdlSupport -> (SDL != null);
+assert sdlSupport -> (SDL2 != null);
 assert termSupport -> (ncurses != null);
 assert wxSupport -> (gtk != null && wxGTK != null);
 assert wgetSupport -> (wget != null);
@@ -19,11 +19,11 @@ assert curlSupport -> (curl != null);
 stdenv.mkDerivation rec {
 
   name = "bochs-${version}";
-  version = "2.6.6";
+  version = "2.6.7";
 
   src = fetchurl {
     url = "http://downloads.sourceforge.net/project/bochs/bochs/${version}/${name}.tar.gz";
-    sha256 = "0nlrl218x93vz97n46aw2szsalx97r020mn43fjsif100v7zix6f";
+    sha256 = "10l2pgzwnmng0rd44kqv7y46nwpcc18j53h3kf3dlqlnd7mlwdd4";
   };
 
   # The huge list of configurable options
@@ -71,7 +71,7 @@ stdenv.mkDerivation rec {
   buildInputs = with stdenv.lib;
   [ pkgconfig libtool gtk mesa readline libX11 libXpm docbook_xml_dtd_45 docbook_xsl ]
   ++ optionals termSupport [ ncurses ]
-  ++ optionals sdlSupport [ SDL ]
+  ++ optionals sdlSupport [ SDL2 ]
   ++ optionals wxSupport [ wxGTK ]
   ++ optionals wgetSupport [ wget ]
   ++ optionals curlSupport [ curl ];
@@ -105,7 +105,7 @@ stdenv.mkDerivation rec {
     "--enable-raw-serial=no" ]
     # Boolean flags
     ++ stdenv.lib.optional termSupport "--with-term"
-    ++ stdenv.lib.optional sdlSupport "--with-sdl"
+    ++ stdenv.lib.optional sdlSupport "--with-sdl2"
     ++ stdenv.lib.optional wxSupport "--with-wx"
     ++ stdenv.lib.optional largefile "--enable-largefile"
     ++ stdenv.lib.optional idleHack "--enable-idle-hack"

pkgs/applications/virtualization/docker/default.nix

@@ -3,11 +3,11 @@ btrfsProgs, iptables, bash, e2fsprogs, xz}:
 
 stdenv.mkDerivation rec {
   name = "docker-${version}";
-  version = "1.3.0";
+  version = "1.3.1";
 
   src = fetchurl {
     url = "https://github.com/dotcloud/docker/archive/v${version}.tar.gz";
-    sha256 = "09bn88i8acv7kw39js1p7mgf3sglq7d782xnafkp0i97svf0x4y9";
+    sha256 = "0w1gz1apkcrmhgng2rkkzy7wmxm68zgs6a16bi4cx3a38n4mgday";
   };
 
   buildInputs = [ makeWrapper go sqlite lxc iproute bridge_utils devicemapper btrfsProgs iptables e2fsprogs];

pkgs/build-support/fetchurl/default.nix

@@ -81,16 +81,16 @@ assert builtins.isList urls;
 assert urls != [] -> url == "";
 assert url != "" -> urls == [];
 
-assert showURLs || (outputHash != "" && outputHashAlgo != "")
-    || md5 != "" || sha1 != "" || sha256 != "";
 
 let
 
+  hasHash = showURLs || (outputHash != "" && outputHashAlgo != "")
+    || md5 != "" || sha1 != "" || sha256 != "";
   urls_ = if urls != [] then urls else [url];
 
 in
 
-stdenv.mkDerivation {
+if (!hasHash) then throw "Specify hash for fetchurl fixed-output derivation: ${stdenv.lib.concatStringsSep ", " urls_}" else stdenv.mkDerivation {
   name =
     if showURLs then "urls"
     else if name != "" then name

pkgs/build-support/release/functions.sh

@@ -2,7 +2,7 @@ findTarball() {
     local suffix i
     if [ -d "$1/tarballs/" ]; then
         for suffix in tar.gz tgz tar.bz2 tbz2 tar.xz tar.lzma; do
-            for i in $1/tarballs/*.$suffix; do echo $i; return; done
+            for i in $1/tarballs/*.$suffix; do echo $i; break; done
         done | sort | head -1
         return
     else

pkgs/build-support/vm/default.nix

@@ -52,11 +52,11 @@ rec {
 
   createDeviceNodes = dev:
     ''
-      mknod ${dev}/null    c 1 3
+      mknod -m 666 ${dev}/null    c 1 3
-      mknod ${dev}/zero    c 1 5
+      mknod -m 666 ${dev}/zero    c 1 5
-      mknod ${dev}/random  c 1 8
+      mknod -m 666 ${dev}/random  c 1 8
-      mknod ${dev}/urandom c 1 9
+      mknod -m 666 ${dev}/urandom c 1 9
-      mknod ${dev}/tty     c 5 0
+      mknod -m 666 ${dev}/tty     c 5 0
       mknod ${dev}/rtc     c 254 0
       . /sys/class/block/${hd}/uevent
       mknod ${dev}/${hd} b $MAJOR $MINOR
@@ -118,7 +118,7 @@ rec {
     mount -t 9p store /fs/nix/store -o trans=virtio,version=9p2000.L,msize=262144,cache=loose
 
     mkdir -p /fs/tmp
-    mount -t tmpfs -o "mode=755" none /fs/tmp
+    mount -t tmpfs -o "mode=1777" none /fs/tmp
 
     echo "mounting host's temporary directory..."
     mkdir -p /fs/tmp/xchg
@@ -1511,6 +1511,40 @@ rec {
       packages = commonDebPackages ++ [ "diffutils" "libc-bin" ];
     };
 
+    ubuntu1410i386 = {
+      name = "ubuntu-14.10-utopic-i386";
+      fullName = "Ubuntu 14.10 Utopic (i386)";
+      packagesLists =
+        [ (fetchurl {
+            url = mirror://ubuntu/dists/utopic/main/binary-i386/Packages.bz2;
+            sha256 = "d703032d9291783772c790c17d428ea6cf6d04c3baac5159e623ae60b681e64e";
+          })
+          (fetchurl {
+            url = mirror://ubuntu/dists/utopic/universe/binary-i386/Packages.bz2;
+            sha256 = "cc9232b7fd937bd8894ad6daf28bd4b2a7428e09a0c1661c708e846b3af24ec8";
+          })
+        ];
+      urlPrefix = mirror://ubuntu;
+      packages = commonDebPackages ++ [ "diffutils" "libc-bin" ];
+    };
+
+    ubuntu1410x86_64 = {
+      name = "ubuntu-14.10-utopic-amd64";
+      fullName = "Ubuntu 14.10 Utopic (amd64)";
+      packagesList =
+        [ (fetchurl {
+            url = mirror://ubuntu/dists/utopic/main/binary-amd64/Packages.bz2;
+            sha256 = "56b5cce1a2c8ae1ea46b1d4c50345f0fc8f1108a8db27f6dd8409d566eb517c9";
+          })
+          (fetchurl {
+            url = mirror://ubuntu/dists/utopic/universe/binary-amd64/Packages.bz2;
+            sha256 = "66ca2bf3363b4b45b97e5f5047bd736947d672c31693ed78bacd36e63b19bb63";
+          })
+        ];
+      urlPrefix = mirror://ubuntu;
+      packages = commonDebPackages ++ [ "diffutils" "libc-bin" ];
+    };
+
     debian40i386 = {
       name = "debian-4.0r9-etch-i386";
       fullName = "Debian 4.0r9 Etch (i386)";
@@ -1582,22 +1616,22 @@ rec {
     debian70x86_64 = debian7x86_64;
 
     debian7i386 = {
-      name = "debian-7.6-wheezy-i386";
+      name = "debian-7.7-wheezy-i386";
-      fullName = "Debian 7.6 Wheezy (i386)";
+      fullName = "Debian 7.7 Wheezy (i386)";
       packagesList = fetchurl {
         url = mirror://debian/dists/wheezy/main/binary-i386/Packages.bz2;
-        sha256 = "1j093d6dwixyrk87sdvaayh3ffcn5aqwik36blndiw5njw2qkzgj";
+        sha256 = "f2fd890597b6f0d82c5d66ccc8b12a963937a0576a377dd0ccbe47de4c1b09c8";
       };
       urlPrefix = mirror://debian;
       packages = commonDebianPackages;
     };
 
     debian7x86_64 = {
-      name = "debian-7.6-wheezy-amd64";
+      name = "debian-7.7-wheezy-amd64";
-      fullName = "Debian 7.6 Wheezy (amd64)";
+      fullName = "Debian 7.7 Wheezy (amd64)";
       packagesList = fetchurl {
         url = mirror://debian/dists/wheezy/main/binary-amd64/Packages.bz2;
-        sha256 = "1n46fxq8a2dm1i7ysc80s5lg10z5dh0hyd8k3h532n5wzs44xqcc";
+        sha256 = "8ce14e88febc58310a1c13350f016ce583f068d10031ed4f0cb50985707786d8";
       };
       urlPrefix = mirror://debian;
       packages = commonDebianPackages;

pkgs/data/documentation/stdman/default.nix

@@ -0,0 +1,32 @@
+{ stdenv, curl, fetchFromGitHub }:
+
+stdenv.mkDerivation rec {
+  name = "stdman-${version}";
+  version = "d860212";
+
+  src = fetchFromGitHub {
+    owner = "jeaye";
+    repo = "stdman";
+    rev = "d860212767ca60472e33aa3bad22a3eac834b1f8";
+    sha256 = "09c5gjhcz97ghfrv9zkgfb1wckvmqnhbzga0xidbm1ir7640di8l";
+  };
+
+  preConfigure = "
+    patchShebangs ./configure
+    patchShebangs ./do_install
+  ";
+
+  buildInputs = [ curl ];
+  
+  meta = with stdenv.lib; {
+    description = "Formatted C++11/14 stdlib man pages (cppreference)";
+    longDescription = "stdman is a tool that parses archived HTML
+      files from cppreference and generates groff-formatted manual
+      pages for Unix-based systems. The goal is to provide excellent
+      formatting for easy readability.";
+    homepage = https://github.com/jeaye/stdman;
+    license = licenses.mit;
+    platforms = platforms.linux;
+    maintainers = [ maintainers.twey ];
+  };
+}

pkgs/data/fonts/symbola/default.nix

@@ -1,15 +1,15 @@
 {stdenv, fetchurl, unzip }:
 
 stdenv.mkDerivation rec {
-  name = "symbola-7.17";
+  name = "symbola-7.18";
 
   src = fetchurl {
     url = "http://users.teilar.gr/~g1951d/Symbola.zip";
-    sha256 = "19q5wcqk1rz8ps7jvvx1rai6x8ais79z71sm8d36hvsk2vr135al";
+    sha256 = "1dk0qawlgdfh58pz2wb80rs9h8m20nmnr4bhk6jmva8201ixz62f";
   };
   docs_pdf = fetchurl {
     url = "http://users.teilar.gr/~g1951d/Symbola.pdf";
-    sha256 = "11h2202p1p4np4nv5m8k41wk7431p2m35sjpmbi1ygizakkbla3p";
+    sha256 = "16f37fsi2zyy3ka409g3m5d9c09l0ba3rqkz912j90p4588dvk85";
   };
 
   buildInputs = [ unzip ];

pkgs/data/sgml+xml/schemas/xml-dtd/docbook/4.1.2.nix

@@ -21,4 +21,7 @@ import ./generic.nix {
   postInstall = "
     sed 's|V4.2|V4.1.2|g' < ${docbook42catalog} > catalog.xml
   ";
+  meta = {
+    branch = "4.1.2";
+  };
 }

pkgs/data/sgml+xml/schemas/xml-dtd/docbook/4.2.nix

@@ -7,4 +7,7 @@ import ./generic.nix {
     url = http://www.docbook.org/xml/4.2/docbook-xml-4.2.zip;
     md5 = "73fe50dfe74ca631c1602f558ed8961f";
   };
+  meta = {
+    branch = "4.2";
+  };
 }