commit 0aae3fda066752a84762ccc5438cae1b22f07b5e · pyrox.dev/nixpkgs

+7 -7

nixos/modules/services/monitoring/graphite.nix

···

       136
       136
        
             finders = mkOption {

     

       137
       137
        
               description = "List of finder plugins to load.";

     

       138
       138
        
               default = [];

     

       139
       139
       -
               example = literalExample "[ pkgs.python27Packages.graphite_influxdb ]";

     

       139
       139
       +
               example = literalExample "[ pkgs.python27Packages.influxgraph ]";

     

       140
       140
        
               type = types.listOf types.package;

     

       141
       141
        
             };

     

       142
       142
        
       

     
···

       485
       485
        
                 PYTHONPATH = let

     

       486
       486
        
                     penv = pkgs.python.buildEnv.override {

     

       487
       487
        
                       extraLibs = [

     

       488
       488
       -
                         pythonPackages.graphite_web

     

       488
       488
       +
                         pythonPackages.graphite-web

     

       489
       489
        
                         pythonPackages.pysqlite

     

       490
       490
        
                       ];

     

       491
       491
        
                     };

     
···

       524
       524
        
                 fi

     

       525
       525
        
       

     

       526
       526
        
                 # Only collect static files when graphite_web changes.

     

       527
       527
       -
                 if ! [ "${dataDir}/current_graphite_web" -ef "${pythonPackages.graphite_web}" ]; then

     

       527
       527
       +
                 if ! [ "${dataDir}/current_graphite_web" -ef "${pythonPackages.graphite-web}" ]; then

     

       528
       528
        
                   mkdir -p ${staticDir}

     

       529
       529
        
                   ${pkgs.pythonPackages.django_1_8}/bin/django-admin.py collectstatic  --noinput --clear

     

       530
       530
        
                   chown -R graphite:graphite ${staticDir}

     

       531
       531
       -
                   ln -sfT "${pythonPackages.graphite_web}" "${dataDir}/current_graphite_web"

     

       531
       531
       +
                   ln -sfT "${pythonPackages.graphite-web}" "${dataDir}/current_graphite_web"

     

       532
       532
        
                 fi

     

       533
       533
        
               '';

     

       534
       534
        
             };

     

       535
       535
        
       

     

       536
       536
       -
             environment.systemPackages = [ pythonPackages.graphite_web ];

     

       536
       536
       +
             environment.systemPackages = [ pythonPackages.graphite-web ];

     

       537
       537
        
           }))

     

       538
       538
        
       

     

       539
       539
        
           (mkIf cfg.api.enable {

     
···

       607
       607
        
                 GRAPHITE_URL = cfg.pager.graphiteUrl;

     

       608
       608
        
               };

     

       609
       609
        
               serviceConfig = {

     

       610
       610
       -
                 ExecStart = "${pkgs.pythonPackages.graphite_pager}/bin/graphite-pager --config ${pagerConfig}";

     

       610
       610
       +
                 ExecStart = "${pkgs.pythonPackages.graphitepager}/bin/graphite-pager --config ${pagerConfig}";

     

       611
       611
        
                 User = "graphite";

     

       612
       612
        
                 Group = "graphite";

     

       613
       613
        
               };

     
···

       615
       615
        
       

     

       616
       616
        
             services.redis.enable = mkDefault true;

     

       617
       617
        
       

     

       618
       618
       -
             environment.systemPackages = [ pkgs.pythonPackages.graphite_pager ];

     

       618
       618
       +
             environment.systemPackages = [ pkgs.pythonPackages.graphitepager ];

     

       619
       619
        
           })

     

       620
       620
        
       

     

       621
       621
        
           (mkIf cfg.beacon.enable {

+4 -1

nixos/tests/graphite.nix

···

       1
       1
       -
       import ./make-test.nix ({ ... } :

     

       1
       1
       +
       import ./make-test.nix ({ pkgs, ... } :

     

       2
       2
        
       {

     

       3
       3
        
         name = "graphite";

     

       4
       4
        
         nodes = {

     
···

       11
       11
        
                 api = {

     

       12
       12
        
                   enable = true;

     

       13
       13
        
                   port = 8082;

     

       14
       14
       +
                   finders = [ pkgs.python27Packages.influxgraph ];

     

       14
       15
        
                 };

     

       15
       16
        
                 carbon.enableCache = true;

     

       16
       17
        
                 seyren.enable = true;

     

       17
       18
        
                 pager.enable = true;

     

       19
       19
       +
                 beacon.enable = true;

     

       18
       20
        
               };

     

       19
       21
        
             };

     

       20
       22
        
         };

     
···

       25
       27
        
           $one->waitForUnit("graphiteWeb.service");

     

       26
       28
        
           $one->waitForUnit("graphiteApi.service");

     

       27
       29
        
           $one->waitForUnit("graphitePager.service");

     

       30
       30
       +
           $one->waitForUnit("graphite-beacon.service");

     

       28
       31
        
           $one->waitForUnit("carbonCache.service");

     

       29
       32
        
           $one->waitForUnit("seyren.service");

     

       30
       33
        
           # The services above are of type "simple". systemd considers them active immediately

+24

pkgs/development/python-modules/carbon/default.nix

···

       1
       1
       +
       { stdenv, buildPythonPackage, fetchPypi, isPy3k

     

       2
       2
       +
       , twisted, whisper, txamqp, cachetools, urllib3

     

       3
       3
       +
       }:

     

       4
       4
       +
       

     

       5
       5
       +
       buildPythonPackage rec {

     

       6
       6
       +
         pname = "carbon";

     

       7
       7
       +
         version = "1.1.3";

     

       8
       8
       +
       

     

       9
       9
       +
         disabled = isPy3k;

     

       10
       10
       +
       

     

       11
       11
       +
         src = fetchPypi {

     

       12
       12
       +
           inherit pname version;

     

       13
       13
       +
           sha256 = "1s7327p30w4l9ak4gc7m5ga521233179n2lr3j0ggfbmfhd6blky";

     

       14
       14
       +
         };

     

       15
       15
       +
       

     

       16
       16
       +
         propagatedBuildInputs = [ twisted whisper txamqp cachetools urllib3 ];

     

       17
       17
       +
       

     

       18
       18
       +
         meta = with stdenv.lib; {

     

       19
       19
       +
           homepage = http://graphite.wikidot.com/;

     

       20
       20
       +
           description = "Backend data caching and persistence daemon for Graphite";

     

       21
       21
       +
           maintainers = with maintainers; [ rickynils offline basvandijk ];

     

       22
       22
       +
           license = licenses.asl20;

     

       23
       23
       +
         };

     

       24
       24
       +
       }

+54

pkgs/development/python-modules/graphite-web/default.nix

···

       1
       1
       +
       { stdenv, buildPythonPackage, fetchPypi, isPy3k, which

     

       2
       2
       +
       , django, django_tagging, whisper, pycairo, cairocffi, ldap, memcached, pytz, urllib3, scandir

     

       3
       3
       +
       }:

     

       4
       4
       +
       if django.version != "1.8.18"

     

       5
       5
       +
       || django_tagging.version != "0.4.3"

     

       6
       6
       +
       then throw "graphite-web should be build with django_1_8 and django_tagging_0_4_3"

     

       7
       7
       +
       else buildPythonPackage rec {

     

       8
       8
       +
         pname = "graphite-web";

     

       9
       9
       +
         version = "1.1.3";

     

       10
       10
       +
       

     

       11
       11
       +
         disabled = isPy3k;

     

       12
       12
       +
       

     

       13
       13
       +
         src = fetchPypi {

     

       14
       14
       +
           inherit pname version;

     

       15
       15
       +
           sha256 = "0nvyq1859abdch2l90avsjk9vb03s7wgxgrjsqvjhf2b9c1ncsfh";

     

       16
       16
       +
         };

     

       17
       17
       +
       

     

       18
       18
       +
         propagatedBuildInputs = [

     

       19
       19
       +
           django django_tagging whisper pycairo cairocffi

     

       20
       20
       +
           ldap memcached pytz urllib3 scandir

     

       21
       21
       +
         ];

     

       22
       22
       +
       

     

       23
       23
       +
         postInstall = ''

     

       24
       24
       +
           wrapProgram $out/bin/run-graphite-devel-server.py \

     

       25
       25
       +
             --prefix PATH : ${which}/bin

     

       26
       26
       +
         '';

     

       27
       27
       +
       

     

       28
       28
       +
         preConfigure = ''

     

       29
       29
       +
           # graphite is configured by storing a local_settings.py file inside the

     

       30
       30
       +
           # graphite python package. Since that package is stored in the immutable

     

       31
       31
       +
           # Nix store we can't modify it. So how do we configure graphite?

     

       32
       32
       +
           #

     

       33
       33
       +
           # First of all we rename "graphite.local_settings" to

     

       34
       34
       +
           # "graphite_local_settings" so that the settings are not looked up in the

     

       35
       35
       +
           # graphite package anymore. Secondly we place a directory containing a

     

       36
       36
       +
           # graphite_local_settings.py on the PYTHONPATH in the graphite module

     

       37
       37
       +
           # <nixpkgs/nixos/modules/services/monitoring/graphite.nix>.

     

       38
       38
       +
           substituteInPlace webapp/graphite/settings.py \

     

       39
       39
       +
             --replace "graphite.local_settings" " graphite_local_settings"

     

       40
       40
       +
       

     

       41
       41
       +
           substituteInPlace webapp/graphite/settings.py \

     

       42
       42
       +
             --replace "join(WEBAPP_DIR, 'content')" "join('$out', 'webapp', 'content')"

     

       43
       43
       +
         '';

     

       44
       44
       +
       

     

       45
       45
       +
         # error: invalid command 'test'

     

       46
       46
       +
         doCheck = false;

     

       47
       47
       +
       

     

       48
       48
       +
         meta = with stdenv.lib; {

     

       49
       49
       +
           homepage = http://graphite.wikidot.com/;

     

       50
       50
       +
           description = "Enterprise scalable realtime graphing";

     

       51
       51
       +
           maintainers = with maintainers; [ rickynils offline basvandijk ];

     

       52
       52
       +
           license = licenses.asl20;

     

       53
       53
       +
         };

     

       54
       54
       +
       }

+25

pkgs/development/python-modules/graphite_beacon/default.nix

···

       1
       1
       +
       { stdenv, buildPythonPackage, fetchPypi

     

       2
       2
       +
       , tornado, pyyaml, funcparserlib

     

       3
       3
       +
       }:

     

       4
       4
       +
       buildPythonPackage rec {

     

       5
       5
       +
         pname = "graphite_beacon";

     

       6
       6
       +
         version = "0.27.0";

     

       7
       7
       +
       

     

       8
       8
       +
         src = fetchPypi {

     

       9
       9
       +
           inherit pname version;

     

       10
       10
       +
           sha256 = "03bp4wyfn3xhcqyvs5hnk1n87m4smsmm1p7qp459m7j8hwpbq2ks";

     

       11
       11
       +
         };

     

       12
       12
       +
       

     

       13
       13
       +
         propagatedBuildInputs = [ tornado pyyaml funcparserlib ];

     

       14
       14
       +
       

     

       15
       15
       +
         postPatch = ''

     

       16
       16
       +
           substituteInPlace requirements.txt --replace "==" ">="

     

       17
       17
       +
         '';

     

       18
       18
       +
       

     

       19
       19
       +
         meta = with stdenv.lib; {

     

       20
       20
       +
           description = "A simple alerting application for Graphite metrics";

     

       21
       21
       +
           homepage = https://github.com/klen/graphite-beacon;

     

       22
       22
       +
           maintainers = [ maintainers.offline ];

     

       23
       23
       +
           license = licenses.mit;

     

       24
       24
       +
         };

     

       25
       25
       +
       }

+32

pkgs/development/python-modules/graphitepager/default.nix

···

       1
       1
       +
       { stdenv, buildPythonPackage, fetchPypi

     

       2
       2
       +
       , jinja2, markupsafe, pagerduty, pushbullet, python_magic, python-simple-hipchat

     

       3
       3
       +
       , pyyaml, redis, requests, six, websocket_client, nose

     

       4
       4
       +
       }:

     

       5
       5
       +
       buildPythonPackage rec {

     

       6
       6
       +
         pname = "graphitepager";

     

       7
       7
       +
         version = "0.2.11";

     

       8
       8
       +
       

     

       9
       9
       +
         src = fetchPypi {

     

       10
       10
       +
           inherit pname version;

     

       11
       11
       +
           sha256 = "0v3g1qcgnkpgjzh6phnv13lnk8qjrcs9sq2qg6k0dk5ik31jfk3d";

     

       12
       12
       +
         };

     

       13
       13
       +
       

     

       14
       14
       +
         propagatedBuildInputs = [

     

       15
       15
       +
           jinja2 markupsafe pagerduty pushbullet python_magic python-simple-hipchat

     

       16
       16
       +
           pyyaml redis requests six websocket_client

     

       17
       17
       +
         ];

     

       18
       18
       +
       

     

       19
       19
       +
         postPatch = ''

     

       20
       20
       +
           substituteInPlace requirements.txt --replace "==" ">="

     

       21
       21
       +
         '';

     

       22
       22
       +
       

     

       23
       23
       +
         checkInputs = [ nose ];

     

       24
       24
       +
         checkPhase = "nosetests";

     

       25
       25
       +
       

     

       26
       26
       +
         meta = with stdenv.lib; {

     

       27
       27
       +
           description = "A simple alerting application for Graphite metrics";

     

       28
       28
       +
           homepage = https://github.com/seatgeek/graphite-pager;

     

       29
       29
       +
           maintainers = with maintainers; [ offline basvandijk ];

     

       30
       30
       +
           license = licenses.bsd2;

     

       31
       31
       +
         };

     

       32
       32
       +
       }

+30

pkgs/development/python-modules/influxgraph/default.nix

···

       1
       1
       +
       { stdenv, buildPythonPackage, fetchPypi, isPy3k

     

       2
       2
       +
       , influxdb, graphite_api, memcached, gnugrep

     

       3
       3
       +
       }:

     

       4
       4
       +
       

     

       5
       5
       +
       buildPythonPackage rec {

     

       6
       6
       +
         pname = "influxgraph";

     

       7
       7
       +
         version = "1.5.0";

     

       8
       8
       +
       

     

       9
       9
       +
         src = fetchPypi {

     

       10
       10
       +
           inherit pname version;

     

       11
       11
       +
           sha256 = "0l33sfwdh4bfprmzp2kx0d9098g6yxbnhyyx9qr3kzczpm0jg9vy";

     

       12
       12
       +
         };

     

       13
       13
       +
       

     

       14
       14
       +
         patchPhase = stdenv.lib.optionalString isPy3k ''

     

       15
       15
       +
           sed 's/python-memcached/python3-memcached/' \

     

       16
       16
       +
             -i ./influxgraph.egg-info/requires.txt    \

     

       17
       17
       +
             -i ./setup.py

     

       18
       18
       +
         '';

     

       19
       19
       +
       

     

       20
       20
       +
         propagatedBuildInputs = [ influxdb graphite_api memcached ];

     

       21
       21
       +
       

     

       22
       22
       +
         passthru.moduleName = "influxgraph.InfluxDBFinder";

     

       23
       23
       +
       

     

       24
       24
       +
         meta = with stdenv.lib; {

     

       25
       25
       +
           description = "InfluxDB storage plugin for Graphite-API";

     

       26
       26
       +
           homepage = https://github.com/InfluxGraph/influxgraph;

     

       27
       27
       +
           license = licenses.asl20;

     

       28
       28
       +
           maintainers = with maintainers; [ basvandijk ];

     

       29
       29
       +
         };

     

       30
       30
       +
       }

+20

pkgs/development/python-modules/whisper/default.nix

···

       1
       1
       +
       { stdenv, buildPythonPackage, fetchPypi, six }:

     

       2
       2
       +
       

     

       3
       3
       +
       buildPythonPackage rec {

     

       4
       4
       +
         pname = "whisper";

     

       5
       5
       +
         version = "1.1.3";

     

       6
       6
       +
       

     

       7
       7
       +
         src = fetchPypi {

     

       8
       8
       +
           inherit pname version;

     

       9
       9
       +
           sha256 = "1ahzsxk52ws8k3kdq52qbsbsx2r9z350j8gg9adw4x5fjwksz4r8";

     

       10
       10
       +
         };

     

       11
       11
       +
       

     

       12
       12
       +
         propagatedBuildInputs = [ six ];

     

       13
       13
       +
       

     

       14
       14
       +
         meta = with stdenv.lib; {

     

       15
       15
       +
           homepage = http://graphite.wikidot.com/;

     

       16
       16
       +
           description = "Fixed size round-robin style database";

     

       17
       17
       +
           maintainers = with maintainers; [ rickynils offline basvandijk ];

     

       18
       18
       +
           license = licenses.asl20;

     

       19
       19
       +
         };

     

       20
       20
       +
       }

+11 -160

pkgs/top-level/python-packages.nix

···

       69
       69
        
         # See build-setupcfg/default.nix for documentation.

     

       70
       70
        
         buildSetupcfg = import ../build-support/build-setupcfg self;

     

       71
       71
        
       

     

       72
       72
       -
         graphiteVersion = "1.0.2";

     

       73
       73
       -
       

     

       74
       72
        
         fetchPypi = makeOverridable( {format ? "setuptools", ... } @attrs:

     

       75
       73
        
           let

     

       76
       74
        
             fetchWheel = {pname, version, sha256, python ? "py2.py3", abi ? "none", platform ? "any"}:

     
···

       4782
       4780
        
         django_tagging = callPackage ../development/python-modules/django_tagging { };

     

       4783
       4781
        
       

     

       4784
       4782
        
         django_tagging_0_4_3 = if

     

       4785
       4785
       -
              self.django != self.django_1_8

     

       4783
       4783
       +
              self.django.version != "1.8.18"

     

       4786
       4784
        
         then throw "django_tagging_0_4_3 should be build with django_1_8"

     

       4787
       4785
        
         else (callPackage ../development/python-modules/django_tagging {}).overrideAttrs (attrs: rec {

     

       4788
       4788
       -
           name = "django-tagging-0.4.3";

     

       4786
       4786
       +
           pname = "django-tagging";

     

       4787
       4787
       +
           version = "0.4.3";

     

       4789
       4788
        
       

     

       4790
       4790
       -
           src = pkgs.fetchurl {

     

       4791
       4791
       -
             url = "mirror://pypi/d/django-tagging/${name}.tar.gz";

     

       4789
       4789
       +
           src = fetchPypi {

     

       4790
       4790
       +
             inherit pname version;

     

       4792
       4791
        
             sha256 = "0617azpmp6jpg3d88v2ir97qrc9aqcs2s9gyvv9bgf2cp55khxhs";

     

       4793
       4792
        
           };

     

       4794
       4793
        
           propagatedBuildInputs = with self; [ django ];

     
···

       15401
       15400
        
       

     

       15402
       15401
        
         whichcraft = callPackage ../development/python-modules/whichcraft { };

     

       15403
       15402
        
       

     

       15404
       15404
       -
         whisper = buildPythonPackage rec {

     

       15405
       15405
       -
           name = "whisper-${version}";

     

       15406
       15406
       -
           version = graphiteVersion;

     

       15407
       15407
       -
       

     

       15408
       15408
       -
           src = pkgs.fetchurl {

     

       15409
       15409
       -
             url = "mirror://pypi/w/whisper/${name}.tar.gz";

     

       15410
       15410
       -
             sha256 = "1v1bi3fl1i6p4z4ki692bykrkw6907dn3mfq0151f70lvi3zpns3";

     

       15411
       15411
       -
           };

     

       15412
       15412
       -
       

     

       15413
       15413
       -
           # error: invalid command 'test'

     

       15414
       15414
       -
           doCheck = false;

     

       15415
       15415
       -
       

     

       15416
       15416
       -
           meta = {

     

       15417
       15417
       -
             homepage = http://graphite.wikidot.com/;

     

       15418
       15418
       -
             description = "Fixed size round-robin style database";

     

       15419
       15419
       -
             maintainers = with maintainers; [ rickynils offline ];

     

       15420
       15420
       -
           };

     

       15421
       15421
       -
         };

     

       15403
       15403
       +
         whisper = callPackage ../development/python-modules/whisper { };

     

       15422
       15404
        
       

     

       15423
       15405
        
         worldengine = buildPythonPackage rec {

     

       15424
       15406
        
           name = "worldengine-${version}";

     
···

       15468
       15450
        
           };

     

       15469
       15451
        
         };

     

       15470
       15452
        
       

     

       15471
       15471
       -
         carbon = buildPythonPackage rec {

     

       15472
       15472
       -
           name = "carbon-${version}";

     

       15473
       15473
       -
           version = graphiteVersion;

     

       15474
       15474
       -
       

     

       15475
       15475
       -
           disabled = isPy3k;

     

       15476
       15476
       -
       

     

       15477
       15477
       -
           src = pkgs.fetchurl {

     

       15478
       15478
       -
             url = "mirror://pypi/c/carbon/${name}.tar.gz";

     

       15479
       15479
       -
             sha256 = "142smpmgbnjinvfb6s4ijazish4vfgzyd8zcmdkh55y051fkixkn";

     

       15480
       15480
       -
           };

     

       15481
       15481
       -
       

     

       15482
       15482
       -
           propagatedBuildInputs = with self; [ whisper txamqp zope_interface twisted ];

     

       15483
       15483
       -
       

     

       15484
       15484
       -
           meta = {

     

       15485
       15485
       -
             homepage = http://graphite.wikidot.com/;

     

       15486
       15486
       -
             description = "Backend data caching and persistence daemon for Graphite";

     

       15487
       15487
       -
             maintainers = with maintainers; [ rickynils offline ];

     

       15488
       15488
       -
             license = licenses.asl20;

     

       15489
       15489
       -
           };

     

       15490
       15490
       -
         };

     

       15491
       15491
       -
       

     

       15453
       15453
       +
         carbon = callPackage ../development/python-modules/carbon { };

     

       15492
       15454
        
       

     

       15493
       15455
        
         ujson = buildPythonPackage rec {

     

       15494
       15456
        
           name = "ujson-1.35";

     
···

       15616
       15578
        
           };

     

       15617
       15579
        
         };

     

       15618
       15580
        
       

     

       15619
       15619
       -
         graphite_web = if

     

       15620
       15620
       -
                 self.django != self.django_1_8

     

       15621
       15621
       -
              || self.django_tagging != self.django_tagging_0_4_3

     

       15622
       15622
       -
         then throw "graphite_web should be build with django_1_8 and django_tagging_0_4_3"

     

       15623
       15623
       -
         else buildPythonPackage rec {

     

       15624
       15624
       -
           name = "graphite-web-${version}";

     

       15625
       15625
       -
           disabled = isPy3k;

     

       15626
       15626
       -
           version = graphiteVersion;

     

       15627
       15627
       -
       

     

       15628
       15628
       -
           src = pkgs.fetchurl rec {

     

       15629
       15629
       -
             url = "mirror://pypi/g/graphite-web/${name}.tar.gz";

     

       15630
       15630
       -
             sha256 = "0q8bwlj75jqyzmazfsi5sa26xl58ssa8wdxm2l4j0jqyn8xpfnmc";

     

       15631
       15631
       -
           };

     

       15632
       15632
       -
       

     

       15633
       15633
       -
           propagatedBuildInputs = with self; [

     

       15634
       15634
       -
             django django_tagging whisper pycairo cairocffi

     

       15635
       15635
       -
             ldap memcached pytz urllib3 scandir

     

       15636
       15636
       -
           ];

     

       15637
       15637
       -
       

     

       15638
       15638
       -
           postInstall = ''

     

       15639
       15639
       -
             wrapProgram $out/bin/run-graphite-devel-server.py \

     

       15640
       15640
       -
               --prefix PATH : ${pkgs.which}/bin

     

       15641
       15641
       -
           '';

     

       15642
       15642
       -
       

     

       15643
       15643
       -
           preConfigure = ''

     

       15644
       15644
       -
             # graphite is configured by storing a local_settings.py file inside the

     

       15645
       15645
       -
             # graphite python package. Since that package is stored in the immutable

     

       15646
       15646
       -
             # Nix store we can't modify it. So how do we configure graphite?

     

       15647
       15647
       -
             #

     

       15648
       15648
       -
             # First of all we rename "graphite.local_settings" to

     

       15649
       15649
       -
             # "graphite_local_settings" so that the settings are not looked up in the

     

       15650
       15650
       -
             # graphite package anymore. Secondly we place a directory containing a

     

       15651
       15651
       -
             # graphite_local_settings.py on the PYTHONPATH in the graphite module

     

       15652
       15652
       -
             # <nixpkgs/nixos/modules/services/monitoring/graphite.nix>.

     

       15653
       15653
       -
             substituteInPlace webapp/graphite/settings.py \

     

       15654
       15654
       -
               --replace "graphite.local_settings" " graphite_local_settings"

     

       15655
       15655
       -
       

     

       15656
       15656
       -
             substituteInPlace webapp/graphite/settings.py \

     

       15657
       15657
       -
               --replace "join(WEBAPP_DIR, 'content')" "join('$out', 'webapp', 'content')"

     

       15658
       15658
       -
           '';

     

       15659
       15659
       -
       

     

       15660
       15660
       -
           # error: invalid command 'test'

     

       15661
       15661
       -
           doCheck = false;

     

       15662
       15662
       -
       

     

       15663
       15663
       -
           meta = {

     

       15664
       15664
       -
             homepage = http://graphite.wikidot.com/;

     

       15665
       15665
       -
             description = "Enterprise scalable realtime graphing";

     

       15666
       15666
       -
             maintainers = with maintainers; [ rickynils offline ];

     

       15667
       15667
       -
           };

     

       15668
       15668
       -
         };

     

       15581
       15581
       +
         graphite-web = callPackage ../development/python-modules/graphite-web { };

     

       15669
       15582
        
       

     

       15670
       15583
        
         graphite_api = callPackage ../development/python-modules/graphite-api { };

     

       15671
       15584
        
       

     

       15672
       15672
       -
         graphite_beacon = buildPythonPackage rec {

     

       15673
       15673
       -
           name = "graphite_beacon-0.27.0";

     

       15674
       15674
       -
       

     

       15675
       15675
       -
           src = pkgs.fetchurl {

     

       15676
       15676
       -
             url = "mirror://pypi/g/graphite_beacon/${name}.tar.gz";

     

       15677
       15677
       -
             sha256 = "03bp4wyfn3xhcqyvs5hnk1n87m4smsmm1p7qp459m7j8hwpbq2ks";

     

       15678
       15678
       -
           };

     

       15679
       15679
       -
       

     

       15680
       15680
       -
           propagatedBuildInputs = [ self.tornado self.pyyaml self.funcparserlib ];

     

       15681
       15681
       -
       

     

       15682
       15682
       -
           preBuild = "> requirements.txt";

     

       15683
       15683
       -
       

     

       15684
       15684
       -
           meta = {

     

       15685
       15685
       -
             description = "A simple alerting application for Graphite metrics";

     

       15686
       15686
       -
             homepage = https://github.com/klen/graphite-beacon;

     

       15687
       15687
       -
             maintainers = [ maintainers.offline ];

     

       15688
       15688
       -
             license = licenses.mit;

     

       15689
       15689
       -
           };

     

       15690
       15690
       -
         };

     

       15691
       15691
       -
       

     

       15692
       15692
       -
         graphite_influxdb = buildPythonPackage rec {

     

       15693
       15693
       -
           name = "graphite-influxdb-0.3";

     

       15694
       15694
       -
       

     

       15695
       15695
       -
           src = pkgs.fetchgit {

     

       15696
       15696
       -
             url = "https://github.com/vimeo/graphite-influxdb.git";

     

       15697
       15697
       -
             rev = "2273d12a24e1d804685a36debfd4224b7416b62f";

     

       15698
       15698
       -
             sha256 = "1v00fgrnmsd9c0ahggyw9sia5m7dyzz16i5pa4vy6w2sbfyrmm4v";

     

       15699
       15699
       -
           };

     

       15700
       15700
       -
       

     

       15701
       15701
       -
           propagatedBuildInputs = with self; [ influxdb graphite_api ];

     

       15702
       15702
       -
       

     

       15703
       15703
       -
           passthru.moduleName = "graphite_influxdb.InfluxdbFinder";

     

       15704
       15704
       -
       

     

       15705
       15705
       -
           meta = {

     

       15706
       15706
       -
             description = "An influxdb backend for Graphite-web and graphite-api";

     

       15707
       15707
       -
             homepage = https://github.com/vimeo/graphite-influxdb;

     

       15708
       15708
       -
             license = licenses.asl20;

     

       15709
       15709
       -
           };

     

       15710
       15710
       -
         };

     

       15711
       15711
       -
       

     

       15712
       15712
       -
         graphite_pager = buildPythonPackage rec {

     

       15713
       15713
       -
           name = "graphite-pager-${version}";

     

       15714
       15714
       -
           version = "2bbfe91220ec1e0ca1cdf4b5564386482a44ed7d";

     

       15715
       15715
       -
       

     

       15716
       15716
       -
           src = pkgs.fetchgit {

     

       15717
       15717
       -
             url = "https://github.com/offlinehacker/graphite-pager.git";

     

       15718
       15718
       -
             sha256 = "0ylal0vkc2yrjvssfz1gls84yk9vkvvkx3pyv4lx15jm2qqzdmxd";

     

       15719
       15719
       -
             rev = version;

     

       15720
       15720
       -
           };

     

       15721
       15721
       -
       

     

       15722
       15722
       -
           buildInputs = with self; [ nose mock ];

     

       15723
       15723
       -
           propagatedBuildInputs = with self; [

     

       15724
       15724
       -
             jinja2 pyyaml redis requests pagerduty

     

       15725
       15725
       -
             python-simple-hipchat pushbullet

     

       15726
       15726
       -
           ];

     

       15727
       15727
       -
       

     

       15728
       15728
       -
           patchPhase = "> requirements.txt";

     

       15729
       15729
       -
           checkPhase = "nosetests";

     

       15585
       15585
       +
         graphite_beacon = callPackage ../development/python-modules/graphite_beacon { };

     

       15730
       15586
        
       

     

       15731
       15731
       -
           meta = {

     

       15732
       15732
       -
             description = "A simple alerting application for Graphite metrics";

     

       15733
       15733
       -
             homepage = https://github.com/seatgeek/graphite-pager;

     

       15734
       15734
       -
             maintainers = with maintainers; [ offline ];

     

       15735
       15735
       -
             license = licenses.bsd2;

     

       15736
       15736
       -
           };

     

       15737
       15737
       -
         };

     

       15587
       15587
       +
         influxgraph = callPackage ../development/python-modules/influxgraph { };

     

       15738
       15588
        
       

     

       15589
       15589
       +
         graphitepager = callPackage ../development/python-modules/graphitepager { };

     

       15739
       15590
        
       

     

       15740
       15591
        
         pyspotify = buildPythonPackage rec {

     

       15741
       15592
        
           name = "pyspotify-${version}";