Gecko [ goons4good.org ]

Name	Size	Permission	Date
angular-spinner	[ DIR ]	drwxr-xr-x	2025-04-30 04:08
ui-utils-0.2.3	[ DIR ]	drwxr-xr-x	2025-04-30 04:08
angular-cookies.js	10.52 KB	-rw-r--r--	2025-04-29 15:40
angular-sanitize.js	23.44 KB	-rw-r--r--	2025-04-29 15:40
angular.min.js	120.31 KB	-rw-r--r--	2025-04-29 15:40
backup.js	857 B	-rw-r--r--	2025-04-29 15:40
main.js	34.43 KB	-rw-r--r--	2025-04-29 15:40
memcached.js	9.87 KB	-rw-r--r--	2025-04-29 15:40
optimize.js	3.85 KB	-rw-r--r--	2025-04-29 15:40
spin.js	9.79 KB	-rw-r--r--	2025-04-29 15:40
turbocache.js	8.86 KB	-rw-r--r--	2025-04-29 15:40
ui-bootstrap-tpls-0.11.2.js	138.04 KB	-rw-r--r--	2025-04-29 15:40
ui-bootstrap-tpls-0.12.1.js	139.39 KB	-rw-r--r--	2025-04-29 15:40

Rename

var a2_optimized_memcached_controller;
a2_optimized_memcached_controller = mainModule.controller('A2OptMemcachedController',
    ['$scope', '$modal', '$log', '$http', '$timeout', function ($scope, $modal, $log, $http, $timeout) {

$scope.action_file = 'memcached.live.php';

$scope.memcached_count = 0;

$scope.memcached_instances = [];

$scope.init = function () {
            $scope.isloading();
            $http.get($scope.action_file, {
                params: {
                    'action': 'get_instances'
                }
            }).success(function (data, status, headers, config) {
                $scope.memcached_instances = data;
                $scope.memcached_count = 0;
                $scope.instance = null;
                var key;
                for (key in $scope.memcached_instances) {

var swiftcache = {
                        'turbocache' : {'enabled': false},
                        'memcached' : {'enabled': false}
                    };

if(angular.isDefined($scope.vars.selectedApp.swiftcache)){
                        if(angular.isDefined($scope.vars.selectedApp.swiftcache.turbocache)){
                            swiftcache.turbocache = $scope.vars.selectedApp.swiftcache.turbocache;
                        }
                        if(angular.isDefined($scope.vars.selectedApp.swiftcache.memcached)){
                            swiftcache.memcached = $scope.vars.selectedApp.swiftcache.memcached;
                        }
                    }

swiftcache.memcached.id = $scope.memcached_instances[key]['id'];
                    swiftcache.memcached.user = $scope.memcached_instances[key]['user'];

$scope.update_swiftcache(swiftcache);

$scope.memcached_instances[key]['autorestarted'] = false;
                    $scope.memcached_count++;
                    $scope.instance = $scope.memcached_instances[key];
                }
                $scope.notloading();
                $scope.is_enabled();
            }).error(function (data, status, headers, config) {
                $scope.error(data);
            });

};

$scope.is_enabled = function () {
            $scope.isloading();
            $http.get($scope.action_file, {
                params: {
                    'action': 'is_enabled',
                    'app': $scope.vars.selectedApp
                }
            }).success(function (data, status, headers, config) {
                var swiftcache = $scope.vars.selectedApp.swiftcache;
                swiftcache.memcached.enabled = (data === 'true' || data === true);

if(swiftcache.memcached.enabled){
                    $scope.get_stats($scope.instance, false);
                }
                $scope.update_swiftcache(swiftcache);
                $scope.notloading();
            }).error(function (data, status, headers, config) {
                if(data != false){
                    $scope.error(data);
                }
                else{
                    $scope.notloading();
                }
                var swiftcache = $scope.vars.selectedApp.swiftcache;
                swiftcache.memcached.enabled = false;
                $scope.update_swiftcache(swiftcache);
                $scope.set_optimized($scope.vars.selectedApp);
            });
        };

$scope.enable = function (app) {
            var swiftcache = {};
            if (angular.isDefined($scope.vars.selectedApp.swiftcache)) {
                swiftcache = $scope.vars.selectedApp.swiftcache;
            }

if (angular.isUndefined(swiftcache.memcached)) {
                swiftcache.memcached = {};
            }

swiftcache.memcached.enabled = false;
            swiftcache.memcached.instance = $scope.instance;

$scope.update_swiftcache(swiftcache);

$scope.isloading();
            $http.get($scope.action_file, {
                params: {
                    'action': 'enable',
                    'type': app.type,
                    'app': app
                }
            }).success(function (data, status, headers, config) {
                $scope.add_alert("success", "Memcached has been enabled for " + config.params.app.title);
                $scope.set_selectedApp(data,false);
                $scope.get_stats($scope.instance,false);
                $scope.notloading();
            }).error(function (data, status, headers, config) {
                $scope.error(data);
            });
        };

$scope.disable = function (app) {
            $scope.isloading();
            $http.get($scope.action_file, {
                params: {
                    'action': 'disable',
                    'app': app,
                    'type': app.type
                }
            }).success(function (data, status, headers, config) {
                $scope.add_alert("success", "Memcached has been disabled for " + config.params.app.title);
                $scope.notloading();
                $scope.set_selectedApp(data,false);
                $scope.get_apps(false);
            }).error(function (data, status, headers, config) {
                $scope.error(data);
                $scope.is_enabled($scope.vars.selectedApp);
            });
        };

$scope.restart = function (instance) {
            $scope.isloading();
            $http.get($scope.action_file, {
                params: {
                    'action': 'restart',
                    "instance": instance
                }
            }).success(function (data, status, headers, config) {
                $scope.notloading();
                $scope.add_alert('success', 'Memcached restarted successfully.');
                $scope.get_stats(instance);
            }).error(function (data, status, headers, config) {
                $scope.error(data);
                $scope.get_stats(instance);
            });
        };

$scope.flush_cache = function (i) {
            $scope.isloading();
            $http.get($scope.action_file, {
                params: {
                    'action': 'flush',
                    'instance': i
                }
            }).success(function (data, status, headers, config) {
                $scope.get_stats(i);
                $scope.add_alert('success', 'Memcached flushed successfully.');
                $scope.notloading();
            }).error(function (data, status, headers, config) {
                config.params.instance.stats = [];
                $scope.error(data);
            });
        };

$scope.reset_stats = function (i) {
            $scope.isloading();
            $http.get($scope.action_file, {
                params: {
                    'action': 'reset',
                    'instance': i
                }
            }).success(function (data, status, headers, config) {
                $scope.notloading();
                $scope.get_stats(i);
                $scope.add_alert('success', 'Stats have been reset to zero.');
            }).error(function (data, status, headers, config) {
                $scope.memcached_stats = [];
                $scope.error(data);
            });
        };

$scope.get_stats = function (i, alert) {
            if (alert == null) {
                alert = false;
            }
            $scope.isloading();
            $http.get($scope.action_file, {
                params: {
                    'action'  : 'get_stats',
                    'instance': i,
                    'alert'   : alert
                }
            }).success(function (data, status, headers, config) {

var d = new Date();

if (data.length == 0 && i.autorestarted === false) {
                    i.autorestarted = true;
                    $scope.add_alert('warning', "Service is down, attempting to restart automatically.");
                    $scope.restart(i);
                    return false;
                }

var stats = data;

stats["bytes"] = parseInt(stats["bytes"]);
                stats["limit_maxbytes"] = parseInt(stats["limit_maxbytes"]);
                stats["total_items"] = parseInt(stats["total_items"]);
                stats["evictions"] = parseInt(stats["evictions"]);
                stats["get_hits"] = parseInt(stats["get_hits"]);
                stats["get_misses"] = parseInt(stats["get_misses"]);

stats["up_since"] = d.getTime() - (stats["uptime"] * 1000);
                stats["eviction_rate"] = (stats["total_items"] == 0) ? 0 : Math.round((stats["evictions"] / stats["total_items"]) * 100);
                stats["hit_rate"] = ( stats["get_hits"] == 0) ? 0 : Math.round(stats["get_hits"] / (stats["get_hits"] + stats["get_misses"]) * 100);
                stats["percent"] = Math.round(100 * stats["bytes"] / stats["limit_maxbytes"]);
                stats["MB"] = Math.round(stats["bytes"] / (1024 * 1024));
                stats["KB"] = Math.round(stats["bytes"] / 1024);
                stats["limit_maxKB"] = Math.round(stats["limit_maxbytes"] / 1024);
                stats["limit_maxMB"] = Math.round(stats["limit_maxbytes"] / (1024 * 1024));

stats["mem_usage"] = stats["bytes"] == 0 ? 0 : Math.round((stats["bytes"] / stats["limit_maxbytes"]) * 100);

i.stats = stats;
                $scope.instance = i;
                if (alert) {
                    $scope.add_alert("success", "Stats Refreshed");
                }
                $scope.notloading();
            }).error(function (data, status, headers, config) {
                $scope.error(data);

if (i.autorestarted === false) {
                    i.autorestarted = true;
                    $scope.add_alert('warning', "Service is down, attempting to restart automatically.");
                    $scope.restart(i);
                }
                $scope.memcached_instances[config.params.instance.id].stats = [];
            });
        };
    }
    ]);