karaf-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From jbono...@apache.org
Subject [04/51] [partial] karaf-decanter git commit: [KARAF-3849] Add karaf kibana dashboard
Date Thu, 16 Jul 2015 07:08:46 GMT
http://git-wip-us.apache.org/repos/asf/karaf-decanter/blob/a24aae9b/kibana/src/main/resources/vendor/jquery/jquery.flot.byte.js
----------------------------------------------------------------------
diff --git a/kibana/src/main/resources/vendor/jquery/jquery.flot.byte.js b/kibana/src/main/resources/vendor/jquery/jquery.flot.byte.js
new file mode 100644
index 0000000..aa4dc40
--- /dev/null
+++ b/kibana/src/main/resources/vendor/jquery/jquery.flot.byte.js
@@ -0,0 +1,107 @@
+(function ($) {
+  "use strict";
+
+  var options = {};
+
+  //Round to nearby lower multiple of base
+  function floorInBase(n, base) {
+    return base * Math.floor(n / base);
+  }
+
+  function init(plot) {
+    plot.hooks.processDatapoints.push(function (plot) {
+      $.each(plot.getAxes(), function(axisName, axis) {
+        var opts = axis.options;
+        if (opts.mode === "byte" || opts.mode === "byteRate") {
+          axis.tickGenerator = function (axis) {
+            var returnTicks = [],
+              tickSize = 2,
+              delta = axis.delta,
+              steps = 0,
+              tickMin = 0,
+              tickVal,
+              tickCount = 0;
+
+            //Set the reference for the formatter
+            if (opts.mode === "byteRate") {
+              axis.rate = true;
+            }
+
+            //Enforce maximum tick Decimals
+            if (typeof opts.tickDecimals === "number") {
+              axis.tickDecimals = opts.tickDecimals;
+            } else {
+              axis.tickDecimals = 2;
+            }
+
+            //Count the steps
+            while (Math.abs(delta) >= 1024) {
+              steps++;
+              delta /= 1024;
+            }
+
+            //Set the tick size relative to the remaining delta
+            while (tickSize <= 1024) {
+              if (delta <= tickSize) {
+                break;
+              }
+              tickSize *= 2;
+            }
+
+            //Tell flot the tickSize we've calculated
+            if (typeof opts.minTickSize !== "undefined" && tickSize < opts.minTickSize)
{
+              axis.tickSize = opts.minTickSize;
+            } else {
+              axis.tickSize = tickSize * Math.pow(1024,steps);
+            }
+
+            //Calculate the new ticks
+            tickMin = floorInBase(axis.min, axis.tickSize);
+            do {
+              tickVal = tickMin + (tickCount++) * axis.tickSize;
+              returnTicks.push(tickVal);
+            } while (tickVal < axis.max);
+
+            return returnTicks;
+          };
+
+          axis.tickFormatter = function(size, axis) {
+            var ext, steps = 0;
+
+            while (Math.abs(size) >= 1024) {
+              steps++;
+              size /= 1024;
+            }
+
+
+            switch (steps) {
+              case 0: ext = " B";  break;
+              case 1: ext = " KB"; break;
+              case 2: ext = " MB"; break;
+              case 3: ext = " GB"; break;
+              case 4: ext = " TB"; break;
+              case 5: ext = " PB"; break;
+              case 6: ext = " EB"; break;
+              case 7: ext = " ZB"; break;
+              case 8: ext = " YB"; break;
+            }
+
+
+            if (typeof axis.rate !== "undefined") {
+              ext += "/s";
+            }
+
+            return (size.toFixed(axis.tickDecimals) + ext);
+          };
+        }
+      });
+    });
+  }
+
+  $.plot.plugins.push({
+    init: init,
+    options: options,
+    name: "byte",
+    version: "0.1"
+  });
+})(jQuery);
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/karaf-decanter/blob/a24aae9b/kibana/src/main/resources/vendor/jquery/jquery.flot.events.js
----------------------------------------------------------------------
diff --git a/kibana/src/main/resources/vendor/jquery/jquery.flot.events.js b/kibana/src/main/resources/vendor/jquery/jquery.flot.events.js
new file mode 100644
index 0000000..9c39f4e
--- /dev/null
+++ b/kibana/src/main/resources/vendor/jquery/jquery.flot.events.js
@@ -0,0 +1,635 @@
+/**
+ * Flot plugin for adding 'events' to the plot.
+ *
+ * Events are small icons drawn onto the graph that represent something happening at that
time.
+ *
+ * This plugin adds the following options to flot:
+ *
+ * options = {
+ *      events: {
+ *          levels: int   // number of hierarchy levels
+ *          data: [],     // array of event objects
+ *          types: []     // array of icons
+ *          xaxis: int    // the x axis to attach events to
+ *      }
+ *  };
+ *
+ *
+ * An event is a javascript object in the following form:
+ *
+ * {
+ *      min: startTime,
+ *      max: endTime,
+ *      eventType: "type",
+ *      title: "event title",
+ *      description: "event description"
+ * }
+ *
+ * Types is an array of javascript objects in the following form:
+ *
+ * types: [
+ *     {
+ *         eventType: "eventType",
+ *         level: hierarchicalLevel,
+ *         icon: {
+               image: "eventImage1.png",
+ *             width: 10,
+ *             height: 10
+ *         }
+ *     }
+ *  ]
+ *
+ * @author Joel Oughton
+ */
+(function($){
+    function init(plot){
+        var DEFAULT_ICON = {
+            icon: "icon-caret-up",
+            size: 20,
+            width: 19,
+            height: 10
+        };
+
+        var _events = [], _types, _eventsEnabled = false, lastRange;
+
+        plot.getEvents = function(){
+            return _events;
+        };
+
+        plot.hideEvents = function(levelRange){
+
+            $.each(_events, function(index, event){
+                if (_withinHierarchy(event.level(), levelRange)) {
+                    event.visual().getObject().hide();
+                }
+            });
+
+        };
+
+        plot.showEvents = function(levelRange){
+            plot.hideEvents();
+
+            $.each(_events, function(index, event){
+                if (!_withinHierarchy(event.level(), levelRange)) {
+                    event.hide();
+                }
+            });
+
+            _drawEvents();
+        };
+
+        plot.hooks.processOptions.push(function(plot, options){
+            // enable the plugin
+            if (options.events.data != null) {
+                _eventsEnabled = true;
+            }
+        });
+
+        plot.hooks.draw.push(function(plot, canvascontext){
+            var options = plot.getOptions();
+            var xaxis = plot.getXAxes()[options.events.xaxis - 1];
+
+            if (_eventsEnabled) {
+
+                // check for first run
+                if (_events.length < 1) {
+
+                    _lastRange = xaxis.max - xaxis.min;
+
+                    // check for clustering
+                    if (options.events.clustering) {
+                        var ed = _clusterEvents(options.events.types, options.events.data,
xaxis.max - xaxis.min);
+                        _types = ed.types;
+                        _setupEvents(ed.data);
+                    } else {
+                        _types = options.events.types;
+                        _setupEvents(options.events.data);
+                    }
+
+                } else {
+                    if (options.events.clustering) {
+                        _clearEvents();
+                        var ed = _clusterEvents(options.events.types, options.events.data,
xaxis.max - xaxis.min);
+                        _types = ed.types;
+                        _setupEvents(ed.data);
+                    }
+                    _updateEvents();
+                }
+            }
+
+            _drawEvents();
+        });
+
+        var _drawEvents = function() {
+            var o = plot.getPlotOffset();
+            var pleft = o.left, pright = plot.width() - o.right;
+
+            $.each(_events, function(index, event){
+
+                // check event is inside the graph range and inside the hierarchy level
+                if (_insidePlot(event.getOptions().min) &&
+                    !event.isHidden()) {
+                    event.visual().draw();
+                }  else {
+                    event.visual().getObject().hide();
+                }
+            });
+
+            _identicalStarts();
+            _overlaps();
+        };
+
+        var _withinHierarchy = function(level, levelRange){
+            var range = {};
+
+            if (!levelRange) {
+                range.start = 0;
+                range.end = _events.length - 1;
+            } else {
+                range.start = (levelRange.min == undefined) ? 0 : levelRange.min;
+                range.end = (levelRange.max == undefined) ? _events.length - 1 : levelRange.max;
+            }
+
+            if (level >= range.start && level <= range.end) {
+                return true;
+            }
+            return false;
+        };
+
+        var _clearEvents = function(){
+            $.each(_events, function(index, val) {
+                val.visual().clear();
+            });
+
+            _events = [];
+        };
+
+        var _updateEvents = function() {
+            var o = plot.getPlotOffset(), left, top;
+            var xaxis = plot.getXAxes()[plot.getOptions().events.xaxis - 1];
+
+            $.each(_events, function(index, event) {
+                top = o.top + plot.height() - event.visual().height();
+                left = xaxis.p2c(event.getOptions().min) + o.left - event.visual().width()
/ 2;
+
+                event.visual().moveTo({ top: top, left: left });
+            });
+        };
+
+        var _showTooltip = function(x, y, event){
+            $('#tooltip').remove();
+
+            // @rashidkpc - hack to work with our normal tooltip placer
+            var $tooltip = $('<div id="tooltip">');
+            if (event) {
+                $tooltip
+                    .html(event.description)
+                    .place_tt(x, y, {
+                        offset: 10
+                    });
+            } else {
+                $tooltip.remove();
+            }
+        };
+
+        var _setupEvents = function(events){
+
+            $.each(events, function(index, event){
+                var level = (plot.getOptions().events.levels == null || !_types || !_types[event.eventType])
? 0 : _types[event.eventType].level;
+
+                if (level > plot.getOptions().events.levels) {
+                    throw "A type's level has exceeded the maximum. Level=" +
+                    level +
+                    ", Max levels:" +
+                    (plot.getOptions().events.levels);
+                }
+
+                _events.push(new VisualEvent(event, _buildDiv(event), level));
+            });
+
+            _events.sort(compareEvents);
+        };
+
+        var _identicalStarts = function() {
+            var ranges = [], range = {}, event, prev, offset = 0;
+
+            $.each(_events, function(index, val) {
+
+                if (prev) {
+                    if (val.getOptions().min == prev.getOptions().min) {
+
+                        if (!range.min) {
+                            range.min = index;
+                        }
+                        range.max = index;
+                    } else {
+                        if (range.min) {
+                            ranges.push(range);
+                            range = {};
+                        }
+                    }
+                }
+
+                prev = val;
+            });
+
+            if (range.min) {
+                ranges.push(range);
+            }
+
+            $.each(ranges, function(index, val) {
+                var removed = _events.splice(val.min - offset, val.max - val.min + 1);
+
+                $.each(removed, function(index, val) {
+                    val.visual().clear();
+                });
+
+                offset += val.max - val.min + 1;
+            });
+        };
+
+        var _overlaps = function() {
+            var xaxis = plot.getXAxes()[plot.getOptions().events.xaxis - 1];
+            var range, diff, cmid, pmid, left = 0, right = -1;
+            pright = plot.width() - plot.getPlotOffset().right;
+
+            // coverts a clump of events into a single vertical line
+            var processClump = function() {
+                // find the middle x value
+                pmid = _events[right].getOptions().min -
+                    (_events[right].getOptions().min - _events[left].getOptions().min) /
2;
+
+                cmid = xaxis.p2c(pmid);
+
+                // hide the events between the discovered range
+                while (left <= right) {
+                    _events[left++].visual().getObject().hide();
+                }
+
+                // draw a vertical line in the middle of where they are
+                if (_insidePlot(pmid)) {
+                    _drawLine('#000', 1, { x: cmid, y: 0 }, { x: cmid, y: plot.height() });
+
+                }
+            };
+
+            if (xaxis.min && xaxis.max) {
+                range = xaxis.max - xaxis.min;
+
+                for (var i = 1; i < _events.length; i++) {
+                    diff = _events[i].getOptions().min - _events[i - 1].getOptions().min;
+
+                    if (diff / range > 0.007) {  //enough variance
+                        // has a clump has been found
+                        if (right != -1) {
+                            //processClump();
+                        }
+                        right = -1;
+                        left = i;
+                    } else {    // not enough variance
+                        right = i;
+                        // handle to final case
+                        if (i == _events.length - 1) {
+                            //processClump();
+                        }
+                    }
+                }
+            }
+        };
+
+        var _buildDiv = function(event){
+            //var po = plot.pointOffset({ x: 450, y: 1});
+            var container = plot.getPlaceholder(), o = plot.getPlotOffset(), yaxis,
+            xaxis = plot.getXAxes()[plot.getOptions().events.xaxis - 1], axes = plot.getAxes();
+            var top, left, div, icon, level, drawableEvent, eventType;
+
+            // determine the y axis used
+            if (axes.yaxis && axes.yaxis.used) yaxis = axes.yaxis;
+            if (axes.yaxis2 && axes.yaxis2.used) yaxis = axes.yaxis2;
+
+            if(event.eventType.split(',')[1] === 'cluster') {
+                eventType = event.eventType.split(',')[0]
+            } else {
+                eventType = event.eventType;
+            }
+
+            // use the default icon and level
+            if (_types == null || !_types[eventType] || !_types[eventType].icon) {
+                icon = DEFAULT_ICON;
+                level = 0;
+            } else {
+                icon = _types[eventType].icon;
+                level = _types[eventType].level;
+            }
+
+            div = $('<i style="position:absolute" class="'+icon.icon+'"></i>').appendTo(container);
+
+            var width = icon.size || icon.width;
+            var height = icon.size || icon.height;
+
+            top = o.top + plot.height() - height + 1;
+            left = xaxis.p2c(event.min) + o.left - width / 2;
+
+            // Positions the marker
+            var cssOptions = {
+                left: left + 'px',
+                top: top
+            };
+
+            if (icon.outline) cssOptions['text-shadow'] = "1px 1px "+icon.outline+", -1px
-1px "+icon.outline+", -1px 1px "+icon.outline+", 1px -1px "+icon.outline;
+            if (icon.size) cssOptions['font-size'] = icon['size']+'px';
+            if (icon.color) cssOptions.color = icon.color;
+
+            div.css(cssOptions);
+            div.hide();
+            div.data({
+                "event": event
+            });
+            div.hover(
+            // mouseenter
+            function(){
+                var pos = $(this).offset();
+                _showTooltip(pos.left + $(this).width() / 2, pos.top, $(this).data("event"));
+            },
+            // mouseleave
+            function(){
+                //$(this).data("bouncing", false);
+                $('#tooltip').remove();
+                plot.clearSelection();
+            });
+
+            drawableEvent = new DrawableEvent(
+                div,
+                function(obj){
+                    obj.show();
+                },
+                function(obj){
+                    obj.remove();
+                },
+                function(obj, position){
+                    obj.css({
+                        top: position.top,
+                        left: position.left
+                    });
+                },
+                left, top, div.width(), div.height());
+
+            return drawableEvent;
+        };
+
+        var _getEventsAtPos = function(x, y){
+            var found = [], left, top, width, height;
+
+            $.each(_events, function(index, val){
+
+                left = val.div.offset().left;
+                top = val.div.offset().top;
+                width = val.div.width();
+                height = val.div.height();
+
+                if (x >= left && x <= left + width && y >= top &&
y <= top + height) {
+                    found.push(val);
+                }
+
+                return found;
+            });
+        };
+
+        var _insidePlot = function(x) {
+            var xaxis = plot.getXAxes()[plot.getOptions().events.xaxis - 1];
+            var xc = xaxis.p2c(x);
+
+            return xc > 0 && xc < xaxis.p2c(xaxis.max);
+        };
+
+        var _drawLine = function(color, lineWidth, from, to) {
+            var ctx = plot.getCanvas().getContext("2d");
+            var plotOffset = plot.getPlotOffset();
+
+            ctx.save();
+            ctx.translate(plotOffset.left, plotOffset.top);
+
+            ctx.beginPath();
+            ctx.strokeStyle = color;
+            ctx.lineWidth = lineWidth;
+            ctx.moveTo(from.x, from.y);
+            ctx.lineTo(to.x, to.y);
+            ctx.stroke();
+
+            ctx.restore();
+        };
+
+
+        /**
+         * Runs over the given 2d array of event objects and returns an object
+         * containing:
+         *
+         * {
+         *      types {},   // An array containing all the different event types
+         *      data [],    // An array of the clustered events
+         * }
+         *
+         * @param {Object} types
+         *          an object containing event types
+         * @param {Object} events
+         *          an array of event to cluster
+         * @param {Object} range
+         *          the current graph range
+         */
+        var _clusterEvents = function(types, events, range) {
+            //TODO: support custom types
+            var groups, clusters = [], newEvents = [];
+
+            // split into same evenType groups
+            groups = _groupEvents(events);
+
+            $.each(groups.eventTypes, function(index, val) {
+                clusters.push(_varianceAlgorithm(groups.groupedEvents[val], 1, range));
+            });
+
+            // summarise clusters
+            $.each(clusters, function(index, eventType) {
+
+                // each cluser of each event type
+                $.each(eventType, function(index, cluster) {
+
+                    var description = "<strong>"+(cluster.length>5?"Top 5 of ":"")
+ cluster.length + " events</strong>";
+                    $.each(cluster,function(i,c) {
+                        if(i > 5) {
+                            return;
+                        }
+                        description += '<div style="'+(i%2?'background-color:#444;':'')+
+                            '" style="padding-bottom:0px">'+c.description + "</div>";
+                    });
+
+                    var newEvent = {
+                        min: cluster[0].min,
+                        max: cluster[cluster.length - 1].min,    //TODO: needs to be max
of end event if it exists
+                        eventType: cluster[0].eventType + ",cluster",
+                        title: "Cluster of: " + cluster[0].title,
+                        description: description //+ ", Number of events in the cluster:
" + cluster.length
+                    };
+
+                    newEvents.push(newEvent);
+                });
+            });
+
+            return { types: types, data: newEvents };
+        };
+
+        /**
+         * Runs over the given 2d array of event objects and returns an object
+         * containing:
+         *
+         * {
+         *      eventTypes [],      // An array containing all the different event types
+         *      groupedEvents {},   // An object containing all the grouped events
+         * }
+         *
+         * @param {Object} events
+         *          an array of event objects
+         */
+        var _groupEvents = function(events) {
+            var eventTypes = [], groupedEvents = {};
+
+            $.each(events, function(index, val) {
+                if (!groupedEvents[val.eventType]) {
+                    groupedEvents[val.eventType] = [];
+                    eventTypes.push(val.eventType);
+                }
+
+                groupedEvents[val.eventType].push(val);
+            });
+
+            return { eventTypes: eventTypes, groupedEvents: groupedEvents };
+        };
+
+        /**
+         * Runs over the given 2d array of event objects and returns a 3d array of
+         * the same events,but clustered into groups with similar x deltas.
+         *
+         * This function assumes that the events are related. So it must be run on
+         * each set of related events.
+         *
+         * @param {Object} events
+         *          an array of event objects
+         * @param {Object} sens
+         *          a measure of the level of grouping tolerance
+         * @param {Object} space
+         *          the size of the space we have to place clusters within
+         */
+        var _varianceAlgorithm = function(events, sens, space) {
+            var cluster, clusters = [], sum = 0, avg, density;
+
+            events.sort(sortEvents);
+
+            // find the average x delta
+            for (var i = 1; i < events.length - 1; i++) {
+                sum += events[i].min - events[i-1].min;
+            }
+            avg = sum / (events.length - 2);
+
+            // first point
+            cluster = [ events[0] ];
+
+            // middle points
+            for (var i = 1; i < events.length; i++) {
+                var leftDiff = events[i - 1].min - events[i].min;
+
+                density = leftDiff / space;
+
+                var avgSens = avg * sens
+
+                if (leftDiff > avgSens && density > 0.05) {
+                    clusters.push(cluster);
+                    cluster = [ events[i] ];
+                } else {
+                    cluster.push(events[i]);
+                }
+            }
+
+            clusters.push(cluster);
+
+            return clusters;
+        };
+    }
+
+    var options = {
+        events: {
+            levels: null,
+            data: null,
+            types: null,
+            xaxis: 1,
+            clustering: false
+        }
+    };
+
+    $.plot.plugins.push({
+        init: init,
+        options: options,
+        name: "events",
+        version: "0.20"
+    });
+
+    /**
+     * A class that allows for the drawing an remove of some object
+     *
+     * @param {Object} object
+     *          the drawable object
+     * @param {Object} drawFunc
+     *          the draw function
+     * @param {Object} clearFunc
+     *          the clear function
+     */
+    function DrawableEvent(object, drawFunc, clearFunc, moveFunc, left, top, width, height){
+        var _object = object, _drawFunc = drawFunc, _clearFunc = clearFunc, _moveFunc = moveFunc,
+        _position = { left: left, top: top }, _width = width, _height = height;
+
+        this.width = function() { return _width; };
+        this.height = function() { return _height };
+        this.position = function() { return _position; };
+        this.draw = function() { _drawFunc(_object); };
+        this.clear = function() { _clearFunc(_object); };
+        this.getObject = function() { return _object; };
+        this.moveTo = function(position) {
+            _position = position;
+            _moveFunc(_object, _position);
+        };
+    }
+
+    /**
+     * Event class that stores options (eventType, min, max, title, description) and the
object to draw.
+     *
+     * @param {Object} options
+     * @param {Object} drawableEvent
+     */
+    function VisualEvent(options, drawableEvent, level){
+        var _parent, _options = options, _drawableEvent = drawableEvent,
+            _level = level, _hidden = false;
+
+        this.visual = function() { return _drawableEvent; }
+        this.level = function() { return _level; };
+        this.getOptions = function() { return _options; };
+        this.getParent = function() { return _parent; };
+
+        this.isHidden = function() { return _hidden; };
+        this.hide = function() { _hidden = true; };
+        this.unhide = function() { _hidden = false; };
+    }
+
+    function compareEvents(a, b) {
+        var ao = a.getOptions(), bo = b.getOptions();
+
+        if (ao.min > bo.min) return 1;
+        if (ao.min < bo.min) return -1;
+        return 0;
+    };
+
+    function sortEvents(a,b) {
+        if (a.min < b.min) return 1;
+        if (a.min > b.min) return -1;
+        return 0;
+    };
+
+
+})(jQuery);


Mime
View raw message