Linux command: free
-
23 |
- 24 | 25 | 26 | 27 |
15 |
15 |
16 |
17 | TimeSeries with optional data options.
95 | *
96 | * Options are of the form (defaults shown):
97 | *
98 | *
99 | * {
100 | * resetBounds: true, // enables/disables automatic scaling of the y-axis
101 | * resetBoundsInterval: 3000 // the period between scaling calculations, in millis
102 | * }
103 | *
104 | *
105 | * Presentation options for TimeSeries are specified as an argument to SmoothieChart.addTimeSeries.
106 | *
107 | * @constructor
108 | */
109 | function TimeSeries(options) {
110 | this.options = Util.extend({}, TimeSeries.defaultOptions, options);
111 | this.data = [];
112 | this.maxValue = Number.NaN; // The maximum value ever seen in this TimeSeries.
113 | this.minValue = Number.NaN; // The minimum value ever seen in this TimeSeries.
114 | }
115 |
116 | TimeSeries.defaultOptions = {
117 | resetBoundsInterval: 3000,
118 | resetBounds: true
119 | };
120 |
121 | /**
122 | * Recalculate the min/max values for this TimeSeries object.
123 | *
124 | * This causes the graph to scale itself in the y-axis.
125 | */
126 | TimeSeries.prototype.resetBounds = function() {
127 | if (this.data.length) {
128 | // Walk through all data points, finding the min/max value
129 | this.maxValue = this.data[0][1];
130 | this.minValue = this.data[0][1];
131 | for (var i = 1; i < this.data.length; i++) {
132 | var value = this.data[i][1];
133 | if (value > this.maxValue) {
134 | this.maxValue = value;
135 | }
136 | if (value < this.minValue) {
137 | this.minValue = value;
138 | }
139 | }
140 | } else {
141 | // No data exists, so set min/max to NaN
142 | this.maxValue = Number.NaN;
143 | this.minValue = Number.NaN;
144 | }
145 | };
146 |
147 | /**
148 | * Adds a new data point to the TimeSeries, preserving chronological order.
149 | *
150 | * @param timestamp the position, in time, of this data point
151 | * @param value the value of this data point
152 | * @param sumRepeatedTimeStampValues if timestamp has an exact match in the series, this flag controls
153 | * whether it is replaced, or the values summed (defaults to false.)
154 | */
155 | TimeSeries.prototype.append = function(timestamp, value, sumRepeatedTimeStampValues) {
156 | // Rewind until we hit an older timestamp
157 | var i = this.data.length - 1;
158 | while (i > 0 && this.data[i][0] > timestamp) {
159 | i--;
160 | }
161 |
162 | if (this.data.length > 0 && this.data[i][0] === timestamp) {
163 | // Update existing values in the array
164 | if (sumRepeatedTimeStampValues) {
165 | // Sum this value into the existing 'bucket'
166 | this.data[i][1] += value;
167 | value = this.data[i][1];
168 | } else {
169 | // Replace the previous value
170 | this.data[i][1] = value;
171 | }
172 | } else if (i < this.data.length - 1) {
173 | // Splice into the correct position to keep timestamps in order
174 | this.data.splice(i + 1, 0, [timestamp, value]);
175 | } else {
176 | // Add to the end of the array
177 | this.data.push([timestamp, value]);
178 | }
179 |
180 | this.maxValue = isNaN(this.maxValue) ? value : Math.max(this.maxValue, value);
181 | this.minValue = isNaN(this.minValue) ? value : Math.min(this.minValue, value);
182 | };
183 |
184 | TimeSeries.prototype.dropOldData = function(oldestValidTime, maxDataSetLength) {
185 | // We must always keep one expired data point as we need this to draw the
186 | // line that comes into the chart from the left, but any points prior to that can be removed.
187 | var removeCount = 0;
188 | while (this.data.length - removeCount >= maxDataSetLength && this.data[removeCount + 1][0] < oldestValidTime) {
189 | removeCount++;
190 | }
191 | if (removeCount !== 0) {
192 | this.data.splice(0, removeCount);
193 | }
194 | };
195 |
196 | /**
197 | * Initialises a new SmoothieChart.
198 | *
199 | * Options are optional, and should be of the form below. Just specify the values you
200 | * need and the rest will be given sensible defaults as shown:
201 | *
202 | *
203 | * {
204 | * minValue: undefined, // specify to clamp the lower y-axis to a given value
205 | * maxValue: undefined, // specify to clamp the upper y-axis to a given value
206 | * maxValueScale: 1, // allows proportional padding to be added above the chart. for 10% padding, specify 1.1.
207 | * yRangeFunction: undefined, // function({min: , max: }) { return {min: , max: }; }
208 | * scaleSmoothing: 0.125, // controls the rate at which y-value zoom animation occurs
209 | * millisPerPixel: 20, // sets the speed at which the chart pans by
210 | * maxDataSetLength: 2,
211 | * interpolation: 'bezier' // or 'linear'
212 | * timestampFormatter: null, // Optional function to format time stamps for bottom of chart. You may use SmoothieChart.timeFormatter, or your own: function(date) { return ''; }
213 | * horizontalLines: [], // [ { value: 0, color: '#ffffff', lineWidth: 1 } ],
214 | * grid:
215 | * {
216 | * fillStyle: '#000000', // the background colour of the chart
217 | * lineWidth: 1, // the pixel width of grid lines
218 | * strokeStyle: '#777777', // colour of grid lines
219 | * millisPerLine: 1000, // distance between vertical grid lines
220 | * sharpLines: false, // controls whether grid lines are 1px sharp, or softened
221 | * verticalSections: 2, // number of vertical sections marked out by horizontal grid lines
222 | * borderVisible: true // whether the grid lines trace the border of the chart or not
223 | * },
224 | * labels
225 | * {
226 | * disabled: false, // enables/disables labels showing the min/max values
227 | * fillStyle: '#ffffff', // colour for text of labels,
228 | * fontSize: 15,
229 | * fontFamily: 'sans-serif',
230 | * precision: 2
231 | * },
232 | * }
233 | *
234 | *
235 | * @constructor
236 | */
237 | function SmoothieChart(options) {
238 | this.options = Util.extend({}, SmoothieChart.defaultChartOptions, options);
239 | this.seriesSet = [];
240 | this.currentValueRange = 1;
241 | this.currentVisMinValue = 0;
242 | this.lastRenderTimeMillis = 0;
243 | }
244 |
245 | SmoothieChart.defaultChartOptions = {
246 | millisPerPixel: 20,
247 | maxValueScale: 1,
248 | interpolation: 'bezier',
249 | scaleSmoothing: 0.125,
250 | maxDataSetLength: 2,
251 | grid: {
252 | fillStyle: '#000000',
253 | strokeStyle: '#777777',
254 | lineWidth: 1,
255 | sharpLines: false,
256 | millisPerLine: 1000,
257 | verticalSections: 2,
258 | borderVisible: true
259 | },
260 | labels: {
261 | fillStyle: '#ffffff',
262 | disabled: false,
263 | fontSize: 10,
264 | fontFamily: 'monospace',
265 | precision: 2
266 | },
267 | horizontalLines: []
268 | };
269 |
270 | // Based on http://inspirit.github.com/jsfeat/js/compatibility.js
271 | SmoothieChart.AnimateCompatibility = (function() {
272 | var requestAnimationFrame = function(callback, element) {
273 | var requestAnimationFrame =
274 | window.requestAnimationFrame ||
275 | window.webkitRequestAnimationFrame ||
276 | window.mozRequestAnimationFrame ||
277 | window.oRequestAnimationFrame ||
278 | window.msRequestAnimationFrame ||
279 | function(callback) {
280 | return window.setTimeout(function() {
281 | callback(new Date().getTime());
282 | }, 16);
283 | };
284 | return requestAnimationFrame.call(window, callback, element);
285 | },
286 | cancelAnimationFrame = function(id) {
287 | var cancelAnimationFrame =
288 | window.cancelAnimationFrame ||
289 | function(id) {
290 | clearTimeout(id);
291 | };
292 | return cancelAnimationFrame.call(window, id);
293 | };
294 |
295 | return {
296 | requestAnimationFrame: requestAnimationFrame,
297 | cancelAnimationFrame: cancelAnimationFrame
298 | };
299 | })();
300 |
301 | SmoothieChart.defaultSeriesPresentationOptions = {
302 | lineWidth: 1,
303 | strokeStyle: '#ffffff'
304 | };
305 |
306 | /**
307 | * Adds a TimeSeries to this chart, with optional presentation options.
308 | *
309 | * Presentation options should be of the form (defaults shown):
310 | *
311 | *
312 | * {
313 | * lineWidth: 1,
314 | * strokeStyle: '#ffffff',
315 | * fillStyle: undefined
316 | * }
317 | *
318 | */
319 | SmoothieChart.prototype.addTimeSeries = function(timeSeries, options) {
320 | this.seriesSet.push({timeSeries: timeSeries, options: Util.extend({}, SmoothieChart.defaultSeriesPresentationOptions, options)});
321 | if (timeSeries.options.resetBounds && timeSeries.options.resetBoundsInterval > 0) {
322 | timeSeries.resetBoundsTimerId = setInterval(
323 | function() {
324 | timeSeries.resetBounds();
325 | },
326 | timeSeries.options.resetBoundsInterval
327 | );
328 | }
329 | };
330 |
331 | /**
332 | * Removes the specified TimeSeries from the chart.
333 | */
334 | SmoothieChart.prototype.removeTimeSeries = function(timeSeries) {
335 | // Find the correct timeseries to remove, and remove it
336 | var numSeries = this.seriesSet.length;
337 | for (var i = 0; i < numSeries; i++) {
338 | if (this.seriesSet[i].timeSeries === timeSeries) {
339 | this.seriesSet.splice(i, 1);
340 | break;
341 | }
342 | }
343 | // If a timer was operating for that timeseries, remove it
344 | if (timeSeries.resetBoundsTimerId) {
345 | // Stop resetting the bounds, if we were
346 | clearInterval(timeSeries.resetBoundsTimerId);
347 | }
348 | };
349 |
350 | /**
351 | * Instructs the SmoothieChart to start rendering to the provided canvas, with specified delay.
352 | *
353 | * @param canvas the target canvas element
354 | * @param delayMillis an amount of time to wait before a data point is shown. This can prevent the end of the series
355 | * from appearing on screen, with new values flashing into view, at the expense of some latency.
356 | */
357 | SmoothieChart.prototype.streamTo = function(canvas, delayMillis) {
358 | this.canvas = canvas;
359 | this.delay = delayMillis;
360 | this.start();
361 | };
362 |
363 | /**
364 | * Starts the animation of this chart.
365 | */
366 | SmoothieChart.prototype.start = function() {
367 | if (this.frame) {
368 | // We're already running, so just return
369 | return;
370 | }
371 |
372 | // Renders a frame, and queues the next frame for later rendering
373 | var animate = function() {
374 | this.frame = SmoothieChart.AnimateCompatibility.requestAnimationFrame(function() {
375 | this.render();
376 | animate();
377 | }.bind(this));
378 | }.bind(this);
379 |
380 | animate();
381 | };
382 |
383 | /**
384 | * Stops the animation of this chart.
385 | */
386 | SmoothieChart.prototype.stop = function() {
387 | if (this.frame) {
388 | SmoothieChart.AnimateCompatibility.cancelAnimationFrame(this.frame);
389 | delete this.frame;
390 | }
391 | };
392 |
393 | SmoothieChart.prototype.updateValueRange = function() {
394 | // Calculate the current scale of the chart, from all time series.
395 | var chartOptions = this.options,
396 | chartMaxValue = Number.NaN,
397 | chartMinValue = Number.NaN;
398 |
399 | for (var d = 0; d < this.seriesSet.length; d++) {
400 | // TODO(ndunn): We could calculate / track these values as they stream in.
401 | var timeSeries = this.seriesSet[d].timeSeries;
402 | if (!isNaN(timeSeries.maxValue)) {
403 | chartMaxValue = !isNaN(chartMaxValue) ? Math.max(chartMaxValue, timeSeries.maxValue) : timeSeries.maxValue;
404 | }
405 |
406 | if (!isNaN(timeSeries.minValue)) {
407 | chartMinValue = !isNaN(chartMinValue) ? Math.min(chartMinValue, timeSeries.minValue) : timeSeries.minValue;
408 | }
409 | }
410 |
411 | // Scale the chartMaxValue to add padding at the top if required
412 | if (chartOptions.maxValue != null) {
413 | chartMaxValue = chartOptions.maxValue;
414 | } else {
415 | chartMaxValue *= chartOptions.maxValueScale;
416 | }
417 |
418 | // Set the minimum if we've specified one
419 | if (chartOptions.minValue != null) {
420 | chartMinValue = chartOptions.minValue;
421 | }
422 |
423 | // If a custom range function is set, call it
424 | if (this.options.yRangeFunction) {
425 | var range = this.options.yRangeFunction({min: chartMinValue, max: chartMaxValue});
426 | chartMinValue = range.min;
427 | chartMaxValue = range.max;
428 | }
429 |
430 | if (!isNaN(chartMaxValue) && !isNaN(chartMinValue)) {
431 | var targetValueRange = chartMaxValue - chartMinValue;
432 | var valueRangeDiff = (targetValueRange - this.currentValueRange);
433 | var minValueDiff = (chartMinValue - this.currentVisMinValue);
434 | this.isAnimatingScale = Math.abs(valueRangeDiff) > 0.1 || Math.abs(minValueDiff) > 0.1;
435 | this.currentValueRange += chartOptions.scaleSmoothing * valueRangeDiff;
436 | this.currentVisMinValue += chartOptions.scaleSmoothing * minValueDiff;
437 | }
438 |
439 | this.valueRange = { min: chartMinValue, max: chartMaxValue };
440 | };
441 |
442 | SmoothieChart.prototype.render = function(canvas, time) {
443 | var nowMillis = new Date().getTime();
444 |
445 | if (!this.isAnimatingScale) {
446 | // We're not animating. We can use the last render time and the scroll speed to work out whether
447 | // we actually need to paint anything yet. If not, we can return immediately.
448 |
449 | // Render at least every 1/6th of a second. The canvas may be resized, which there is
450 | // no reliable way to detect.
451 | var maxIdleMillis = Math.min(1000/6, this.options.millisPerPixel);
452 |
453 | if (nowMillis - this.lastRenderTimeMillis < maxIdleMillis) {
454 | return;
455 | }
456 | }
457 | this.lastRenderTimeMillis = nowMillis;
458 |
459 | canvas = canvas || this.canvas;
460 | time = time || nowMillis - (this.delay || 0);
461 |
462 | // Round time down to pixel granularity, so motion appears smoother.
463 | time -= time % this.options.millisPerPixel;
464 |
465 | var context = canvas.getContext('2d'),
466 | chartOptions = this.options,
467 | dimensions = { top: 0, left: 0, width: canvas.clientWidth, height: canvas.clientHeight },
468 | // Calculate the threshold time for the oldest data points.
469 | oldestValidTime = time - (dimensions.width * chartOptions.millisPerPixel),
470 | valueToYPixel = function(value) {
471 | var offset = value - this.currentVisMinValue;
472 | return this.currentValueRange === 0
473 | ? dimensions.height
474 | : dimensions.height - (Math.round((offset / this.currentValueRange) * dimensions.height));
475 | }.bind(this),
476 | timeToXPixel = function(t) {
477 | return Math.round(dimensions.width - ((time - t) / chartOptions.millisPerPixel));
478 | };
479 |
480 | this.updateValueRange();
481 |
482 | context.font = chartOptions.labels.fontSize + 'px ' + chartOptions.labels.fontFamily;
483 |
484 | // Save the state of the canvas context, any transformations applied in this method
485 | // will get removed from the stack at the end of this method when .restore() is called.
486 | context.save();
487 |
488 | // Move the origin.
489 | context.translate(dimensions.left, dimensions.top);
490 |
491 | // Create a clipped rectangle - anything we draw will be constrained to this rectangle.
492 | // This prevents the occasional pixels from curves near the edges overrunning and creating
493 | // screen cheese (that phrase should need no explanation).
494 | context.beginPath();
495 | context.rect(0, 0, dimensions.width, dimensions.height);
496 | context.clip();
497 |
498 | // Clear the working area.
499 | context.save();
500 | context.fillStyle = chartOptions.grid.fillStyle;
501 | context.clearRect(0, 0, dimensions.width, dimensions.height);
502 | context.fillRect(0, 0, dimensions.width, dimensions.height);
503 | context.restore();
504 |
505 | // Grid lines...
506 | context.save();
507 | context.lineWidth = chartOptions.grid.lineWidth;
508 | context.strokeStyle = chartOptions.grid.strokeStyle;
509 | // Vertical (time) dividers.
510 | if (chartOptions.grid.millisPerLine > 0) {
511 | var textUntilX = dimensions.width - context.measureText(minValueString).width + 4;
512 | for (var t = time - (time % chartOptions.grid.millisPerLine);
513 | t >= oldestValidTime;
514 | t -= chartOptions.grid.millisPerLine) {
515 | var gx = timeToXPixel(t);
516 | if (chartOptions.grid.sharpLines) {
517 | gx -= 0.5;
518 | }
519 | context.beginPath();
520 | context.moveTo(gx, 0);
521 | context.lineTo(gx, dimensions.height);
522 | context.stroke();
523 | context.closePath();
524 |
525 | // Display timestamp at bottom of this line if requested, and it won't overlap
526 | if (chartOptions.timestampFormatter && gx < textUntilX) {
527 | // Formats the timestamp based on user specified formatting function
528 | // SmoothieChart.timeFormatter function above is one such formatting option
529 | var tx = new Date(t),
530 | ts = chartOptions.timestampFormatter(tx),
531 | tsWidth = context.measureText(ts).width;
532 | textUntilX = gx - tsWidth - 2;
533 | context.fillStyle = chartOptions.labels.fillStyle;
534 | context.fillText(ts, gx - tsWidth, dimensions.height - 2);
535 | }
536 | }
537 | }
538 |
539 | // Horizontal (value) dividers.
540 | for (var v = 1; v < chartOptions.grid.verticalSections; v++) {
541 | var gy = Math.round(v * dimensions.height / chartOptions.grid.verticalSections);
542 | if (chartOptions.grid.sharpLines) {
543 | gy -= 0.5;
544 | }
545 | context.beginPath();
546 | context.moveTo(0, gy);
547 | context.lineTo(dimensions.width, gy);
548 | context.stroke();
549 | context.closePath();
550 | }
551 | // Bounding rectangle.
552 | if (chartOptions.grid.borderVisible) {
553 | context.beginPath();
554 | context.strokeRect(0, 0, dimensions.width, dimensions.height);
555 | context.closePath();
556 | }
557 | context.restore();
558 |
559 | // Draw any horizontal lines...
560 | if (chartOptions.horizontalLines && chartOptions.horizontalLines.length) {
561 | for (var hl = 0; hl < chartOptions.horizontalLines.length; hl++) {
562 | var line = chartOptions.horizontalLines[hl],
563 | hly = Math.round(valueToYPixel(line.value)) - 0.5;
564 | context.strokeStyle = line.color || '#ffffff';
565 | context.lineWidth = line.lineWidth || 1;
566 | context.beginPath();
567 | context.moveTo(0, hly);
568 | context.lineTo(dimensions.width, hly);
569 | context.stroke();
570 | context.closePath();
571 | }
572 | }
573 |
574 | // For each data set...
575 | for (var d = 0; d < this.seriesSet.length; d++) {
576 | context.save();
577 | var timeSeries = this.seriesSet[d].timeSeries,
578 | dataSet = timeSeries.data,
579 | seriesOptions = this.seriesSet[d].options;
580 |
581 | // Delete old data that's moved off the left of the chart.
582 | timeSeries.dropOldData(oldestValidTime, chartOptions.maxDataSetLength);
583 |
584 | // Set style for this dataSet.
585 | context.lineWidth = seriesOptions.lineWidth;
586 | context.strokeStyle = seriesOptions.strokeStyle;
587 | // Draw the line...
588 | context.beginPath();
589 | // Retain lastX, lastY for calculating the control points of bezier curves.
590 | var firstX = 0, lastX = 0, lastY = 0;
591 | for (var i = 0; i < dataSet.length && dataSet.length !== 1; i++) {
592 | var x = timeToXPixel(dataSet[i][0]),
593 | y = valueToYPixel(dataSet[i][1]);
594 |
595 | if (i === 0) {
596 | firstX = x;
597 | context.moveTo(x, y);
598 | } else {
599 | switch (chartOptions.interpolation) {
600 | case "linear":
601 | case "line": {
602 | context.lineTo(x,y);
603 | break;
604 | }
605 | case "bezier":
606 | default: {
607 | // Great explanation of Bezier curves: http://en.wikipedia.org/wiki/Bezier_curve#Quadratic_curves
608 | //
609 | // Assuming A was the last point in the line plotted and B is the new point,
610 | // we draw a curve with control points P and Q as below.
611 | //
612 | // A---P
613 | // |
614 | // |
615 | // |
616 | // Q---B
617 | //
618 | // Importantly, A and P are at the same y coordinate, as are B and Q. This is
619 | // so adjacent curves appear to flow as one.
620 | //
621 | context.bezierCurveTo( // startPoint (A) is implicit from last iteration of loop
622 | Math.round((lastX + x) / 2), lastY, // controlPoint1 (P)
623 | Math.round((lastX + x)) / 2, y, // controlPoint2 (Q)
624 | x, y); // endPoint (B)
625 | break;
626 | }
627 | }
628 | }
629 |
630 | lastX = x; lastY = y;
631 | }
632 |
633 | if (dataSet.length > 1) {
634 | if (seriesOptions.fillStyle) {
635 | // Close up the fill region.
636 | context.lineTo(dimensions.width + seriesOptions.lineWidth + 1, lastY);
637 | context.lineTo(dimensions.width + seriesOptions.lineWidth + 1, dimensions.height + seriesOptions.lineWidth + 1);
638 | context.lineTo(firstX, dimensions.height + seriesOptions.lineWidth);
639 | context.fillStyle = seriesOptions.fillStyle;
640 | context.fill();
641 | }
642 |
643 | if (seriesOptions.strokeStyle && seriesOptions.strokeStyle !== 'none') {
644 | context.stroke();
645 | }
646 | context.closePath();
647 | }
648 | context.restore();
649 | }
650 |
651 | // Draw the axis values on the chart.
652 | if (!chartOptions.labels.disabled && !isNaN(this.valueRange.min) && !isNaN(this.valueRange.max)) {
653 | var maxValueString = parseFloat(this.valueRange.max).toFixed(chartOptions.labels.precision),
654 | minValueString = parseFloat(this.valueRange.min).toFixed(chartOptions.labels.precision);
655 | context.fillStyle = chartOptions.labels.fillStyle;
656 | context.fillText(maxValueString, dimensions.width - context.measureText(maxValueString).width - 2, chartOptions.labels.fontSize);
657 | context.fillText(minValueString, dimensions.width - context.measureText(minValueString).width - 2, dimensions.height - 2);
658 | }
659 |
660 | context.restore(); // See .save() above.
661 | };
662 |
663 | // Sample timestamp formatting function
664 | SmoothieChart.timeFormatter = function(date) {
665 | function pad2(number) { return (number < 10 ? '0' : '') + number }
666 | return pad2(date.getHours()) + ':' + pad2(date.getMinutes()) + ':' + pad2(date.getSeconds());
667 | };
668 |
669 | exports.TimeSeries = TimeSeries;
670 | exports.SmoothieChart = SmoothieChart;
671 |
672 | })(typeof exports === 'undefined' ? this : exports);
673 |
674 |
--------------------------------------------------------------------------------
/linux-tools/uptime/LICENSE:
--------------------------------------------------------------------------------
1 | Apache License
2 | Version 2.0, January 2004
3 | http://www.apache.org/licenses/
4 |
5 | TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
6 |
7 | 1. Definitions.
8 |
9 | "License" shall mean the terms and conditions for use, reproduction,
10 | and distribution as defined by Sections 1 through 9 of this document.
11 |
12 | "Licensor" shall mean the copyright owner or entity authorized by
13 | the copyright owner that is granting the License.
14 |
15 | "Legal Entity" shall mean the union of the acting entity and all
16 | other entities that control, are controlled by, or are under common
17 | control with that entity. For the purposes of this definition,
18 | "control" means (i) the power, direct or indirect, to cause the
19 | direction or management of such entity, whether by contract or
20 | otherwise, or (ii) ownership of fifty percent (50%) or more of the
21 | outstanding shares, or (iii) beneficial ownership of such entity.
22 |
23 | "You" (or "Your") shall mean an individual or Legal Entity
24 | exercising permissions granted by this License.
25 |
26 | "Source" form shall mean the preferred form for making modifications,
27 | including but not limited to software source code, documentation
28 | source, and configuration files.
29 |
30 | "Object" form shall mean any form resulting from mechanical
31 | transformation or translation of a Source form, including but
32 | not limited to compiled object code, generated documentation,
33 | and conversions to other media types.
34 |
35 | "Work" shall mean the work of authorship, whether in Source or
36 | Object form, made available under the License, as indicated by a
37 | copyright notice that is included in or attached to the work
38 | (an example is provided in the Appendix below).
39 |
40 | "Derivative Works" shall mean any work, whether in Source or Object
41 | form, that is based on (or derived from) the Work and for which the
42 | editorial revisions, annotations, elaborations, or other modifications
43 | represent, as a whole, an original work of authorship. For the purposes
44 | of this License, Derivative Works shall not include works that remain
45 | separable from, or merely link (or bind by name) to the interfaces of,
46 | the Work and Derivative Works thereof.
47 |
48 | "Contribution" shall mean any work of authorship, including
49 | the original version of the Work and any modifications or additions
50 | to that Work or Derivative Works thereof, that is intentionally
51 | submitted to Licensor for inclusion in the Work by the copyright owner
52 | or by an individual or Legal Entity authorized to submit on behalf of
53 | the copyright owner. For the purposes of this definition, "submitted"
54 | means any form of electronic, verbal, or written communication sent
55 | to the Licensor or its representatives, including but not limited to
56 | communication on electronic mailing lists, source code control systems,
57 | and issue tracking systems that are managed by, or on behalf of, the
58 | Licensor for the purpose of discussing and improving the Work, but
59 | excluding communication that is conspicuously marked or otherwise
60 | designated in writing by the copyright owner as "Not a Contribution."
61 |
62 | "Contributor" shall mean Licensor and any individual or Legal Entity
63 | on behalf of whom a Contribution has been received by Licensor and
64 | subsequently incorporated within the Work.
65 |
66 | 2. Grant of Copyright License. Subject to the terms and conditions of
67 | this License, each Contributor hereby grants to You a perpetual,
68 | worldwide, non-exclusive, no-charge, royalty-free, irrevocable
69 | copyright license to reproduce, prepare Derivative Works of,
70 | publicly display, publicly perform, sublicense, and distribute the
71 | Work and such Derivative Works in Source or Object form.
72 |
73 | 3. Grant of Patent License. Subject to the terms and conditions of
74 | this License, each Contributor hereby grants to You a perpetual,
75 | worldwide, non-exclusive, no-charge, royalty-free, irrevocable
76 | (except as stated in this section) patent license to make, have made,
77 | use, offer to sell, sell, import, and otherwise transfer the Work,
78 | where such license applies only to those patent claims licensable
79 | by such Contributor that are necessarily infringed by their
80 | Contribution(s) alone or by combination of their Contribution(s)
81 | with the Work to which such Contribution(s) was submitted. If You
82 | institute patent litigation against any entity (including a
83 | cross-claim or counterclaim in a lawsuit) alleging that the Work
84 | or a Contribution incorporated within the Work constitutes direct
85 | or contributory patent infringement, then any patent licenses
86 | granted to You under this License for that Work shall terminate
87 | as of the date such litigation is filed.
88 |
89 | 4. Redistribution. You may reproduce and distribute copies of the
90 | Work or Derivative Works thereof in any medium, with or without
91 | modifications, and in Source or Object form, provided that You
92 | meet the following conditions:
93 |
94 | (a) You must give any other recipients of the Work or
95 | Derivative Works a copy of this License; and
96 |
97 | (b) You must cause any modified files to carry prominent notices
98 | stating that You changed the files; and
99 |
100 | (c) You must retain, in the Source form of any Derivative Works
101 | that You distribute, all copyright, patent, trademark, and
102 | attribution notices from the Source form of the Work,
103 | excluding those notices that do not pertain to any part of
104 | the Derivative Works; and
105 |
106 | (d) If the Work includes a "NOTICE" text file as part of its
107 | distribution, then any Derivative Works that You distribute must
108 | include a readable copy of the attribution notices contained
109 | within such NOTICE file, excluding those notices that do not
110 | pertain to any part of the Derivative Works, in at least one
111 | of the following places: within a NOTICE text file distributed
112 | as part of the Derivative Works; within the Source form or
113 | documentation, if provided along with the Derivative Works; or,
114 | within a display generated by the Derivative Works, if and
115 | wherever such third-party notices normally appear. The contents
116 | of the NOTICE file are for informational purposes only and
117 | do not modify the License. You may add Your own attribution
118 | notices within Derivative Works that You distribute, alongside
119 | or as an addendum to the NOTICE text from the Work, provided
120 | that such additional attribution notices cannot be construed
121 | as modifying the License.
122 |
123 | You may add Your own copyright statement to Your modifications and
124 | may provide additional or different license terms and conditions
125 | for use, reproduction, or distribution of Your modifications, or
126 | for any such Derivative Works as a whole, provided Your use,
127 | reproduction, and distribution of the Work otherwise complies with
128 | the conditions stated in this License.
129 |
130 | 5. Submission of Contributions. Unless You explicitly state otherwise,
131 | any Contribution intentionally submitted for inclusion in the Work
132 | by You to the Licensor shall be under the terms and conditions of
133 | this License, without any additional terms or conditions.
134 | Notwithstanding the above, nothing herein shall supersede or modify
135 | the terms of any separate license agreement you may have executed
136 | with Licensor regarding such Contributions.
137 |
138 | 6. Trademarks. This License does not grant permission to use the trade
139 | names, trademarks, service marks, or product names of the Licensor,
140 | except as required for reasonable and customary use in describing the
141 | origin of the Work and reproducing the content of the NOTICE file.
142 |
143 | 7. Disclaimer of Warranty. Unless required by applicable law or
144 | agreed to in writing, Licensor provides the Work (and each
145 | Contributor provides its Contributions) on an "AS IS" BASIS,
146 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
147 | implied, including, without limitation, any warranties or conditions
148 | of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
149 | PARTICULAR PURPOSE. You are solely responsible for determining the
150 | appropriateness of using or redistributing the Work and assume any
151 | risks associated with Your exercise of permissions under this License.
152 |
153 | 8. Limitation of Liability. In no event and under no legal theory,
154 | whether in tort (including negligence), contract, or otherwise,
155 | unless required by applicable law (such as deliberate and grossly
156 | negligent acts) or agreed to in writing, shall any Contributor be
157 | liable to You for damages, including any direct, indirect, special,
158 | incidental, or consequential damages of any character arising as a
159 | result of this License or out of the use or inability to use the
160 | Work (including but not limited to damages for loss of goodwill,
161 | work stoppage, computer failure or malfunction, or any and all
162 | other commercial damages or losses), even if such Contributor
163 | has been advised of the possibility of such damages.
164 |
165 | 9. Accepting Warranty or Additional Liability. While redistributing
166 | the Work or Derivative Works thereof, You may choose to offer,
167 | and charge a fee for, acceptance of support, warranty, indemnity,
168 | or other liability obligations and/or rights consistent with this
169 | License. However, in accepting such obligations, You may act only
170 | on Your own behalf and on Your sole responsibility, not on behalf
171 | of any other Contributor, and only if You agree to indemnify,
172 | defend, and hold each Contributor harmless for any liability
173 | incurred by, or claims asserted against, such Contributor by reason
174 | of your accepting any such warranty or additional liability.
175 |
176 | END OF TERMS AND CONDITIONS
177 |
178 | APPENDIX: How to apply the Apache License to your work.
179 |
180 | To apply the Apache License to your work, attach the following
181 | boilerplate notice, with the fields enclosed by brackets "{}"
182 | replaced with your own identifying information. (Don't include
183 | the brackets!) The text should be enclosed in the appropriate
184 | comment syntax for the file format. We also recommend that a
185 | file or class name and description of purpose be included on the
186 | same "printed page" as the copyright notice for easier
187 | identification within third-party archives.
188 |
189 | Copyright {yyyy} {name of copyright owner}
190 |
191 | Licensed under the Apache License, Version 2.0 (the "License");
192 | you may not use this file except in compliance with the License.
193 | You may obtain a copy of the License at
194 |
195 | http://www.apache.org/licenses/LICENSE-2.0
196 |
197 | Unless required by applicable law or agreed to in writing, software
198 | distributed under the License is distributed on an "AS IS" BASIS,
199 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
200 | See the License for the specific language governing permissions and
201 | limitations under the License.
202 |
203 |
--------------------------------------------------------------------------------
/linux-tools/uptime/README.md:
--------------------------------------------------------------------------------
1 | # swoole-uptime
2 |
3 | ## 依赖
4 |
5 | * PHP 5.3+
6 | * Swoole 1.7.16
7 | * Linux, OS X and basic Windows support (Thanks to cygwin)
8 |
9 | ## 安装 Swoole扩展
10 |
11 | 1. Install from pecl
12 |
13 | ```
14 | pecl install swoole
15 | ```
16 |
17 | 2. Install from source
18 |
19 | ```
20 | sudo apt-get install php5-dev
21 | git clone https://github.com/swoole/swoole-src.git
22 | cd swoole-src
23 | phpize
24 | ./configure
25 | make && make install
26 | ```
27 |
28 | ## 运行
29 |
30 | 1. cd uptime/server
31 | 2. php server.php
32 | 3. 修改web目录下stats.js代码 var ws = new ReconnectingWebSocket("ws://192.168.1.10:8880"); 改成服务器的IP
33 | 4. 用浏览器打开web目录下的index.html
34 |
35 | ## 运行结果
36 |
37 | 1. 打开页面如下所示
38 | 
39 |
40 | ## nginx配置文件
41 | 1. 在doc/swoole-uptime.conf
42 |
43 |
--------------------------------------------------------------------------------
/linux-tools/uptime/doc/swoole-uptime.conf:
--------------------------------------------------------------------------------
1 | #设定虚拟主机配置
2 | server {
3 | #侦听80端口
4 | listen 80;
5 | server_name uptime.iizhu.com;
6 |
7 | #定义服务器的默认网站根目录位置
8 | root /var/www/code/swoole-uptime/web/;
9 |
10 | location / {
11 | #定义首页索引文件的名称
12 | index index.php index.html index.htm;
13 |
14 | }
15 |
16 | # 定义错误提示页面
17 | error_page 500 502 503 504 /50x.html;
18 | location = /50x.html {
19 | }
20 |
21 | #PHP 脚本请求全部转发到 FastCGI处理. 使用FastCGI默认配置.
22 | location ~ .php$ {
23 | fastcgi_pass 127.0.0.1:9000;
24 | fastcgi_index index.php;
25 | fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
26 | include fastcgi_params;
27 | }
28 |
29 | }
30 |
--------------------------------------------------------------------------------
/linux-tools/uptime/doc/uptime.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/toxmc/swoole-linux-dash/1eac7495f038fd4d756f6eccfc1e8e3aeaf8f06d/linux-tools/uptime/doc/uptime.png
--------------------------------------------------------------------------------
/linux-tools/uptime/server/server.php:
--------------------------------------------------------------------------------
1 | column('cmd', swoole_table::TYPE_STRING, 32);
31 | $table->create();
32 | $table->set('uptime', array('cmd' => $uptime_path));
33 |
34 | $server = new swoole_websocket_server($host, $port);
35 | $server->table = $table; //将table保存在serv对象上
36 |
37 | /**
38 | * websocket server配置
39 | */
40 | $server->set (array(
41 | 'worker_num' => 1, //worker进程数量
42 | 'daemonize' => false, //守护进程设置成true
43 | 'max_request' => 1000, //最大请求次数，当请求大于它时，将会自动重启该worker
44 | 'dispatch_mode' => 1
45 | ));
46 |
47 | /**
48 | * websocket server start
49 | * 成功后回调
50 | */
51 | $server->on('start', function ($serv) use($_maxMasterPidLength, $_maxManagerPidLength, $_maxWorkerIdLength, $_maxWorkerPidLength) {
52 | echo "\033[1A\n\033[K-----------------------\033[47;30m SWOOLE \033[0m-----------------------------\n\033[0m";
53 | echo 'swoole version:' . swoole_version() . " PHP version:".PHP_VERSION."\n";
54 | echo "------------------------\033[47;30m WORKERS \033[0m---------------------------\n";
55 | echo "\033[47;30mMasterPid\033[0m", str_pad('', $_maxMasterPidLength + 2 - strlen('MasterPid')),
56 | "\033[47;30mManagerPid\033[0m", str_pad('', $_maxManagerPidLength + 2 - strlen('ManagerPid')),
57 | "\033[47;30mWorkerId\033[0m", str_pad('', $_maxWorkerIdLength + 2 - strlen('WorkerId')),
58 | "\033[47;30mWorkerPid\033[0m", str_pad('', $_maxWorkerPidLength + 2 - strlen('WorkerPid')),"\n";
59 | });
60 |
61 | /**
62 | * 当worker 启动的时候调用
63 | */
64 | $server->on('workerStart',function ($serv, $worker_id) use($_maxMasterPidLength, $_maxManagerPidLength, $_maxWorkerIdLength, $_maxWorkerPidLength) {
65 | echo str_pad($serv->master_pid, $_maxMasterPidLength+2),
66 | str_pad($serv->manager_pid, $_maxManagerPidLength+2),
67 | str_pad($serv->worker_id, $_maxWorkerIdLength+2),
68 | str_pad($serv->worker_pid, $_maxWorkerIdLength), "\n";
69 |
70 | if ($worker_id==0) {
71 | $data = $serv->table->get('uptime');
72 | $serv->tick(1000, function($id) use($serv, $data) {
73 | $conn_list = $serv->connection_list();
74 | if (!empty($conn_list)) {
75 | $str = exec($data['cmd'],$string);
76 | foreach($conn_list as $fd) {
77 | $conn = $serv->connection_info($fd);
78 | if (!empty($conn)) {
79 | $nowtime = substr($str, 0, strpos($str,'up'));
80 | $str = str_replace($nowtime, '', $str);
81 | $str = str_replace('up', '', $str);
82 | $str = str_replace('days', '', $str);
83 | $str = str_replace('users', '', $str);
84 | $str = str_replace('load average:', '', $str);
85 | $str = $nowtime.','.$str;
86 | $serv->push($fd, $str);
87 | }
88 | }
89 | }
90 | });
91 | }
92 | });
93 |
94 | /**
95 | * 当WebSocket客户端与服务器建立连接并完成握手后会回调此函数。
96 | */
97 | $server->on('open', function (swoole_websocket_server $server, $request) {
98 | $fd = $request->fd;
99 | echo "server: handshake success with fd{$fd}\n";
100 | $server->push($fd, "nowtime -----------Linetime---------- ---users-- -----load average----\n");
101 | $server->push($fd, "nowtime,days,time,users,one,five,fifteen\n");
102 | });
103 |
104 | /**
105 | * 当服务器收到来自客户端的数据帧时会回调此函数。
106 | */
107 | $server->on('message', function (swoole_websocket_server $server, $frame) {
108 | echo "receive from {$frame->fd}:{$frame->data},opcode:{$frame->opcode},fin:{$frame->finish}\n";
109 | $server->push($frame->fd, "this is server");
110 | });
111 |
112 | /**
113 | * 当客户端关闭的时候调用
114 | */
115 | $server->on('close', function ($ser, $fd) {
116 | echo "client {$fd} closed\n";
117 | });
118 |
119 |
120 | $server->start();
--------------------------------------------------------------------------------
/linux-tools/uptime/web/img/forkme_right_orange_ff7600.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/toxmc/swoole-linux-dash/1eac7495f038fd4d756f6eccfc1e8e3aeaf8f06d/linux-tools/uptime/web/img/forkme_right_orange_ff7600.png
--------------------------------------------------------------------------------
/linux-tools/uptime/web/index.html:
--------------------------------------------------------------------------------
1 |
2 |
15 |
16 |
17 | SERVER TIME:00:00:00
20 |Up 0DAYS, 0:00
23 || {{ name }} | 13 |{{ value }} | 14 |
| {{ metric.name }} | 13 |{{ metric.data }} | 14 |
|
12 |
15 |
16 | |
17 | {{ metric.name }} | 18 |{{ metric.data }} | 19 |
| 14 | 15 | | 16 |
|---|
| 19 | {{ header }} 20 | 21 | {{ (header === sortByColumn) ? '▲': ''; }} 22 | {{ ('-' + header === sortByColumn) ? '▼': ''; }} 23 | 24 | | 25 |
| 30 | {{ row[header] }} 31 | | 32 |
| Name | 12 |13 | | Stats | 14 |% Full | 15 |Mount Path | 16 |
|---|---|---|---|---|
| {{partition['file_system']}} | 21 |
22 | |
28 | 29 | {{ partition['used'] }} / {{ partition['size'] }} 30 | | 31 |32 | {{ partition['used%'] }} 33 | | 34 |{{ partition['mounted'] }} | 35 |