volume_visualizer 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 593e47fe627c73fb820a9f2ca2fada9ac8047ff9
+  data.tar.gz: 96a938b038dfad171bab6a99fc2e5d236ee8392c
+SHA512:
+  metadata.gz: eca862e193efb061d4ab844e279d00b45265ec0993f548d566dac4c2b72ee9106d8bc5f788b537b017e3d5c76b720de7645a665bb9fa093de07129b0255fb4ec
+  data.tar.gz: 93735cd10cf0b1eadb9d9af2fd66d77d95d6d13ff49249f1b1f66aa4dca30b31e44ab12a77c669de475c8d3ef9ff80825a756d1cfd7d9c23159369bf73527519

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in volume_visualizer.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 TODO: Write your name
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,184 @@
+# Volviz - The Volume Visualizer
+
+Commandline tool for visualizing data distribution on your storage volumes.
+
+It can be difficult to create a mental picture of where your bytes are,
+especially when you have a lot of them. Thin provisioning, copy-on-write,
+deduplication and compression can help you pack more bytes into your raw
+storage, but can also make it even harder to understand what's really
+consuming your storage.
+
+This becomes really important when you're trying to cherrypick the most
+critical data from a 9TB filesystem that will still fit on a 640GB USB
+disk. It also would have been useful a year ago when I was trying to
+keep track of 100TB+ on a nearline backup system.
+
+It also particularly helps when you're using a tool like
+[zfs-auto-snapshot](https://github.com/zfsonlinux/zfs-auto-snapshot)
+and you're wondering if deleting any of your old snapshots would
+gain you back a significant amount of space, or if they're mostly
+just referencing the same data that's in the live filesystem.
+
+Volviz tries to help.
+
+If you've ever used [WinDirStat](https://windirstat.info/) or
+[Baobab](http://www.marzocca.net/linux/baobab/) (Gnome's Disk Usage
+Analyzer), you're familiar with the basic idea. Those tools, however,
+map the size of *files* in a hierarchy of *directories*.
+
+Volviz maps the size of *filesystems*, *snapshots*, and *volumes*. It
+shows the actual space used on disk, not just the reported size.
+
+## Screenshot
+
+![Screenshot](https://raw.githubusercontent.com/rleemorlang/volume_visualizer/master/example/screenshot_scaled.jpg)
+
+## Status
+
+Barely alpha. This was hacked together in a day. The HTML/JavaScript/CSS
+is the sort of mess you expect when cutting and pasting from a bunch of
+different examples.
+
+But safe! It's completely read-only in its default mode. If you ask it
+to, it'll write a JSON file and an HTML file where you tell it to.
+
+## Compatibility
+
+**Only ZFS is currently supported**. It shouldn't be too hard to refactor 
+and add adapters for LVM and others.
+
+Only Linux has been tested.
+
+## Acknowledgements
+
+Volviz gets all its visualization magic from [D3.js](http://d3js.org). D3.js
+is awesome.
+
+## Installation
+
+Installation should be simple with RubyGems. If you don't already have it,
+your package manager can install everything you need.
+ 
+    sudo apt-get install rubygems || sudo yum install rubygems
+
+Once that's done, you can install the latest release:
+
+    sudo gem install volume_visualizer
+
+## Usage
+
+Volviz's default mode will query the first volume it finds, discover where
+all the bytes are, launch an HTTP server and display a URL on the console.
+Navigate to this URL to see the visualization.
+
+**Note:** Volviz needs root privileges to get volume information, and will 
+run sudo if necessary. If you don't want to trust Volviz with root, there 
+are other ways to run it. Keep reading.
+
+### Default (Automatic) Mode
+
+In Automatic Mode, Volviz scans the first volume it finds and starts a web
+server to show you the output. Volviz will output a URL on the console.
+
+    > vv
+
+This is a shortcut for the `instaweb` command.
+
+    > vv instaweb
+
+You can specify the volume you want to visualize.
+
+    > vv --volume backup2
+
+### Untrusted (Parse) Mode
+
+Volviz only needs root when querying your volumes. If you don't like that,
+you can ask Volviz to parse a text file. First, ask volviz for the correct
+command.
+
+    > vv show-command
+
+You can figure it out yourself easily enough, but you can specify a
+volume if you like.
+
+    > vv show-command --volume backup2
+
+Once you're satisfied that the command Volviz suggests is safe, you can run
+it as root yourself and pipe the output into Volviz.
+
+    > sudo zfs list -t all -H -r \
+      -o name,available,used,referenced,usedbysnapshots,usedbydataset,\
+      usedbychildren,compressratio,type \
+      tank | vv --parse-file - 
+
+Or:
+
+    > sudo zfs list -t all -H -r \
+      -o name,available,used,referenced,usedbysnapshots,usedbydataset,\
+      usedbychildren,compressratio,type \
+      tank > /tmp/zfsdata
+    > vv --parse-file /tmp/zfsdata
+
+### Static Mode
+
+Volviz's built-in web server is meant for convenience only. You might instead
+want to generate static output that can be served by a webserver of your 
+choice.
+
+    > mkdir /var/www/volviz
+    > vv generate --output-path /var/www/volviz
+
+You can use a non-default name for the datafile if you like:
+
+    > vv generate --output-path /var/www/volviz --data-name backup2
+
+You can load alternate datafiles in the Volviz UI by appending
+`?data=backup2` to the URL.
+
+This might make particular sense if you want to update your data regularly
+from cron.
+
+You can combine untrusted and static mode if you like.
+
+    > vv generate --output-path /var/www/volviz --parse-file /tmp/zfsdata
+
+Maybe you have a bunch of hosts and you don't want to install Volviz on
+each one. Generate data to parse and ship it to a central host that has
+Volviz installed, and then use Static Mode to generate the output.
+Assuming you've put all your volume dumps in `/var/lib/volviz/`, here's
+some Bash that might be a good starting point.
+
+    OUTDIR=/var/www/volviz
+    DIR=$OUTDIR/directory.html
+    echo "<h1>Volviz</h1><ul>" > $DIR
+    for DATAFILE in /var/lib/volviz/*; do
+      NAME=`basename $DATAFILE`
+      vv generate --output-path $OUTDIR --data-name $NAME --parse-file $DATAFILE
+      echo "<li><a href="index.html?data=$NAME">$NAME</a></li>" >> $DIR
+    done
+    echo "</ul>" > $DIR
+
+    echo Processing complete. The following URL might work.
+    echo http://`hostname`/volviz/directory.html
+
+### Help!
+
+    > vv help
+
+You probably figured that out on your own.
+
+## Notes
+
+Volviz ignores any volume, filesystem, or snapshot with a reported size of
+0 bytes.
+
+## Contributing
+
+I'd be thrilled to get your pull request. Boilerplate follows.
+
+1. Fork it ( http://github.com/rleemorlang/volume_visualizer/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/assets/index.html

@@ -0,0 +1,320 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>Volviz - The Volume Visualizer</title>
+    <meta charset="utf-8">
+    <style>
+
+      path {
+        stroke: #fff;
+        fill-rule: evenodd;
+        opacity: 0.8;
+      }
+
+      path:hover {
+        fill: #f00;
+        opacity: 1;
+      }
+
+      svg {
+        margin-left: auto;
+        margin-right: auto;
+        display: block;
+      }
+
+
+      .tooltip, .tooltip-pending-removal {
+        position: absolute;
+        background-color: rgba(255,255,255,1);
+        padding: 10px;
+        border: 1px solid #ddd;
+        z-index: 10000;
+        display: inline-block;
+        font-family: Arial;
+        font-size: 13px;
+        border-radius: 10px;
+
+        pointer-events: none;
+
+        -webkit-touch-callout: none;
+        -webkit-user-select: none;
+        user-select: none;
+      }
+      .tooltip {
+
+        transition: opacity 500ms linear;
+        -webkit-transition: opacity 500ms linear;
+
+        transition-delay: 500ms;
+        -webkit-transition-delay: 500ms;
+
+        -moz-box-shadow: 4px 4px 8px rgba(0,0,0,.5);
+        -webkit-box-shadow: 4px 4px 8px rgba(0,0,0,.5);
+        box-shadow: 4px 4px 8px rgba(0,0,0,.5);
+
+      }
+    </style>
+  </head>
+  <body>
+    <center id="header">
+      <h1>Volume Visualizer</h1>
+      <h2>Data for volume "<span id="volname"></span>"</h2>
+    </center>
+    <script src="http://d3js.org/d3.v3.min.js"></script>
+    <script>
+
+      function urlObject(options) {
+        var url_search_arr,
+        option_key,
+        i,
+        urlObj,
+        get_param,
+        key,
+        val,
+        url_query,
+        url_get_params = {},
+        a = document.createElement('a'),
+        default_options = {
+          'url': window.location.href,
+          'unescape': true,
+          'convert_num': true
+        };
+
+        if (typeof options !== "object") {
+          options = default_options;
+          } else {
+          for (option_key in default_options) {
+            if (default_options.hasOwnProperty(option_key)) {
+              if (options[option_key] === undefined) {
+                options[option_key] = default_options[option_key];
+              }
+            }
+          }
+        }
+
+        a.href = options.url;
+        url_query = a.search.substring(1);
+        url_search_arr = url_query.split('&');
+
+        if (url_search_arr[0].length > 1) {
+          for (i = 0; i < url_search_arr.length; i += 1) {
+            get_param = url_search_arr[i].split("=");
+
+            if (options.unescape) {
+              key = decodeURI(get_param[0]);
+              val = decodeURI(get_param[1]);
+              } else {
+              key = get_param[0];
+              val = get_param[1];
+            }
+
+            if (options.convert_num) {
+              if (val.match(/^\d+$/)) {
+                val = parseInt(val, 10);
+                } else if (val.match(/^\d+\.\d+$/)) {
+                val = parseFloat(val);
+              }
+            }
+
+            if (url_get_params[key] === undefined) {
+              url_get_params[key] = val;
+              } else if (typeof url_get_params[key] === "string") {
+              url_get_params[key] = [url_get_params[key], val];
+              } else {
+              url_get_params[key].push(val);
+            }
+
+            get_param = [];
+          }
+        }
+
+        urlObj = {
+          protocol: a.protocol,
+          hostname: a.hostname,
+          host: a.host,
+          port: a.port,
+          hash: a.hash.substr(1),
+          pathname: a.pathname,
+          search: a.search,
+          parameters: url_get_params
+        };
+
+        return urlObj;
+      }
+      /*****
+      * A no frills tooltip implementation.
+      *****/
+
+      (function() {
+
+        var tooltip = window.tooltip = {}
+
+        tooltip.show = function(pos, content, gravity, dist, parentContainer, classes) {
+
+          var container = d3.select('body').selectAll('.tooltip').data([1])
+
+          container.enter().append('div').attr('class', 'tooltip ' + (classes ? classes : 'xy-tooltip'))
+
+          container.html(content)
+
+          gravity = gravity || 'n'
+          dist = dist || 20
+
+          var body = document.getElementsByTagName('body')[0]
+
+          var height = parseInt(container[0][0].offsetHeight)
+          , width = parseInt(container[0][0].offsetWidth)
+          , windowWidth = window.innerWidth
+          , windowHeight = window.innerHeight
+          , scrollTop = body.scrollTop
+          , scrollLeft = body.scrollLeft
+          , left = 0
+          , top = 0
+
+
+          switch (gravity) {
+            case 'e':
+            left = pos[0] - width - dist
+            top = pos[1] - (height / 2)
+            if (left < scrollLeft) left = pos[0] + dist
+            if (top < scrollTop) top = scrollTop + 5
+            if (top + height > scrollTop + windowHeight) top = scrollTop - height - 5
+            break
+            case 'w':
+            left = pos[0] + dist
+            top = pos[1] - (height / 2)
+            if (left + width > windowWidth) left = pos[0] - width - dist
+            if (top < scrollTop) top = scrollTop + 5
+            if (top + height > scrollTop + windowHeight) top = scrollTop - height - 5
+            break
+            case 's':
+            left = pos[0] - (width / 2)
+            top = pos[1] + dist
+            if (left < scrollLeft) left = scrollLeft + 5
+            if (left + width > windowWidth) left = windowWidth - width - 5
+            if (top + height > scrollTop + windowHeight) top = pos[1] - height - dist
+            break
+            case 'n':
+            left = pos[0] - (width / 2)
+            top = pos[1] - height - dist
+            if (left < scrollLeft) left = scrollLeft + 5
+            if (left + width > windowWidth) left = windowWidth - width - 5
+            if (scrollTop > top) top = pos[1] + 20
+            break
+          }
+
+
+          container.style('left', left+'px')
+          container.style('top', top+'px')
+
+          return container
+        }
+
+        tooltip.cleanup = function() {
+          // Find the tooltips, mark them for removal by this class (so other tooltip functions won't find it)
+          var tooltips = d3.selectAll('.tooltip').attr('class','tooltip-pending-removal').transition().duration(250).style('opacity',0).remove()
+
+        }
+      })();
+
+      var width = 960,
+      height = 960,
+      radius = Math.min(width, height) / 2 * 0.9;
+
+      var x = d3.scale.linear()
+      .range([0, 2 * Math.PI]);
+
+      var y = d3.scale.sqrt()
+      .range([0, radius]);
+
+
+      var svg = d3.select("body").append("svg")
+      .attr("width", width)
+      .attr("height", height)
+      .append("g")
+      .attr("transform", "translate(" + width / 2 + "," + (height / 2 + 10) + ")");
+
+      var partition = d3.layout.partition()
+      .value(function(d) { return d.size; });
+
+      var arc = d3.svg.arc()
+      .startAngle(function(d) { return Math.max(0, Math.min(2 * Math.PI, x(d.x)))})
+      .endAngle(function(d) { return Math.max(0, Math.min(2 * Math.PI, x(d.x + d.dx)))})
+      .innerRadius(function(d) { return Math.max(0, y(d.y)) + 0.5;})
+      .outerRadius(function(d) { return Math.max(0, y(d.y + d.dy)) - 0.5; });
+
+      d3.select(self.frameElement).style("height", height + "px");
+
+      // Interpolate the scales!
+      function arcTween(d) {
+        var xd = d3.interpolate(x.domain(), [d.x, d.x + d.dx]),
+        yd = d3.interpolate(y.domain(), [d.y, 1]),
+        yr = d3.interpolate(y.range(), [d.y ? 20 : 0, radius]);
+        return function(d, i) {
+          return i
+          ? function(t) { return arc(d); }
+          : function(t) { x.domain(xd(t)); y.domain(yd(t)).range(yr(t)); return arc(d); };
+        };
+      }
+
+      colors = {
+        "container": "#000099",
+        "free": "#cccccc",
+        "filesystem": "#0066cc",
+        "snapshot": "#3399ff",
+        "volume": "#ff6666"
+      }
+
+      var color = d3.scale.category20c();
+
+      var colors = {
+        "filesystem": d3.scale.ordinal().range([
+        "#5096ff", "#4c8ef2", "#4887e5", "#4480d9", "#4078cc",
+        "#3c70bf", "#3869b2", "#3461a6", "#305a99", "#2c528c"
+        ]),
+        "container": d3.scale.ordinal().range([
+        "#e5e5e5", "#ebebeb", "#e3e3e3", "#dbdbdb"
+        ]),
+        "snapshot": d3.scale.ordinal().range([
+        "#ff5f25", "#f25a23", "#e55521", "#d9511f"
+        ]),
+        "volume":  d3.scale.ordinal().range([
+        "#3bf0ff"
+        ]),
+        "root": function() { return "#ffffff"; },
+        "free": function() { return "#fdfdfd"; },
+      }
+
+      var color = function(node) {
+        return colors[node.type](node.name);
+      };
+
+      var data = urlObject().parameters.data || "volviz";
+      d3.json(data + ".json", function(error, root) {
+        document.getElementById("volname").innerHTML = root.name; 
+
+        var g = svg.selectAll("g")
+        .data(partition.nodes(root))
+        .enter().append("g");
+
+        var path = g.append("path")
+        .attr("d", arc)
+        .style("fill", function(d) { return color(d); })
+        .on("click", click)
+        .on("mouseover", function(d) {
+          if (d.type != "root") {
+            tooltip.show([d3.event.clientX, d3.event.clientY], 
+            '<div>'+d.name+'</div><div>'+d.size_human+'</div>')
+          };
+        });
+
+        function click(d) {
+          path.transition()
+          .duration(750)
+          .attrTween("d", arcTween(d));
+        }
+      });
+
+    </script>
+  </body>
+</html>