nutella_framework 0.4.23 → 0.4.24

data/framework_components/monitoring-interface/js/view-controller/application-view-controller.js

@@ -0,0 +1,256 @@
+var ApplicationViewController = function(name, view) {
+    var self = ViewController(view);
+
+    // Protected variables
+    self._instanceViewControllers = {};
+    self._expansionAnimationFinished = undefined;
+    self._reductionAnimationFinished = undefined;
+    self._notification = undefined;
+    self._legend = undefined;
+
+    // Public variables
+    self.name = undefined;
+    self.coordinates = undefined;
+
+    // Render function of the component
+    var render = self.render;
+
+    self.render = function() {
+        var data = applicationModel.getApplicationData(self.name);
+
+        // Check if the notification must be displayed or not
+        if(self.expanded || self.notification() == 0) {
+            self._notification.show = false;
+        }
+        else {
+            self._notification.show = true;
+        }
+
+        if(self.expanded) {
+            self._legend.show = true;
+        }
+        else {
+            self._legend.show = false;
+        }
+
+        render();
+
+        self.renderInstances();
+    };
+
+
+
+    self.mouseOverEffect = function (backGroundRect, color) {
+        backGroundRect.fill(color);
+    };
+
+    self.mouseOutEffect = function (backGroundRect, color) {
+        backGroundRect.fill(color);
+    };
+
+    self.closeButtonClicked = function() {
+        self.clicked();
+    };
+
+    self.subscribeButtonClicked = function() {
+        $('#mailDisplay').modal({ show: true});
+        alertsModel.application = self.name;
+        alertsModel.instance = undefined;
+        alertsModel.component = undefined;
+        alertsModel.fetchData();
+    };
+
+    self.reduce = function() {
+        if(self.expanded == true) {
+            applicationModel.viewControllerApplicationSelected = undefined;
+            notificationCenter.dispatch(Notifications.ui.APPLICATION_CLICKED);
+            windowViewController.resetCenter();
+            notificationCenter.dispatch(Notifications.ui.APPLICATION_REDUCTION_STARTED);
+
+            // Notify the end of the animation
+            setTimeout(function(){
+                notificationCenter.dispatch(Notifications.ui.APPLICATION_REDUCTION_FINISHED);
+            }, Animations.application.APPLICATION_REDUCTION.delay + Animations.application.APPLICATION_REDUCTION.duration);
+        }
+    };
+
+    self.clicked = function() {
+
+        if(self.expanded == false) {
+            // Deselect the instance
+            applicationModel.viewControllerInstanceSelected = undefined;
+
+            applicationModel.viewControllerApplicationSelected = self;
+            notificationCenter.dispatch(Notifications.ui.APPLICATION_CLICKED);
+            windowViewController.center(self.coordinates.x, self.coordinates.y);
+            notificationCenter.dispatch(Notifications.ui.APPLICATION_EXPANSION_STARTED);
+
+            // Notify the end of the animation
+            setTimeout(function(){
+                notificationCenter.dispatch(Notifications.ui.APPLICATION_EXPANSION_FINISHED);
+            }, Animations.application.APPLICATION_EXPANSION.delay + Animations.application.APPLICATION_EXPANSION.duration);
+
+        }
+        else {
+            applicationModel.viewControllerApplicationSelected = undefined;
+            notificationCenter.dispatch(Notifications.ui.APPLICATION_CLICKED);
+            windowViewController.resetCenter();
+            notificationCenter.dispatch(Notifications.ui.APPLICATION_REDUCTION_STARTED);
+
+            // Notify the end of the animation
+            setTimeout(function(){
+                notificationCenter.dispatch(Notifications.ui.APPLICATION_REDUCTION_FINISHED);
+            }, Animations.application.APPLICATION_REDUCTION.delay + Animations.application.APPLICATION_REDUCTION.duration);
+        }
+
+        self.render();
+    };
+
+    // Data relative to the current selected instance
+    self.__defineGetter__("instanceComponentData", function() {
+        if(applicationModel.viewControllerInstanceSelected == undefined)
+            return undefined;
+
+        var instanceData = applicationModel.getInstanceData(self.name, applicationModel.viewControllerInstanceSelected.name);
+
+        return instanceData.components;
+        // TODO: fix here
+
+
+        if(instanceData != undefined)
+            return instanceData.components;
+        else
+            return undefined;
+    });
+
+    self.__defineGetter__("expanded", function() {
+        return self == applicationModel.viewControllerApplicationSelected;
+    });
+
+    self.__defineGetter__("status", function() {
+        return applicationModel.getApplicationData(self.name).problems == undefined || applicationModel.getApplicationData(self.name).problems == 0;
+    });
+
+    self.notification = function(name) {
+        var data = applicationModel.getApplicationData(self.name);
+
+        if(name == undefined) {
+            if(data.problems == undefined) {
+                return 0;
+            }
+            return data.problems;
+        }
+
+        var instance = data.instances.filter(function(instance) {
+            return instance.name == name;
+        });
+
+        if(instance.length == 0) {
+            return 0;
+        }
+
+        if(instance[0].problems == undefined) {
+            return 0;
+        }
+
+        return instance[0].problems;
+    };
+
+    self.renderInstances = function() {
+        var instances = applicationModel.getApplicationData(self.name).instances;
+        if(instances != undefined) {
+
+            // Create new instance tabs
+            self._view.selectAll(".instance_tabs")
+                .data(instances)
+                .enter()
+                .tabTable()
+                .append("g")
+                .class("instance_tab")
+                .each(function(data, index) {
+                    this.instanceViewController = InstanceViewController(self, data.name, index, d3.select(this).newView());
+                    self._instanceViewControllers[data.name] = this.instanceViewController;
+
+                    // Set the first instance as selected
+                    if(applicationModel.viewControllerInstanceSelected == undefined && self.expanded) {
+                        applicationModel.viewControllerInstanceSelected = this.instanceViewController;
+                    }
+                });
+
+            // Update instance tabs
+            self._view.selectAll(".instance_tab")
+                .data(instances)
+                .each(function(data) {
+                    var instanceViewController = this.instanceViewController;
+                    instanceViewController.name = data.name;
+
+                    // Render the application
+                    instanceViewController.render();
+                });
+
+            // Delete instance tabs
+            self._view.selectAll(".instance_tab")
+                .data(instances)
+                .exit()
+                .each(function(data) {
+                    var instanceViewController = this.instanceViewController;
+                    instanceViewController.deinit();
+                    delete self._instanceViewControllers[data.name];
+                })
+                .remove();
+        }
+    };
+
+
+    // Constructor
+    self.init = function() {
+
+        self.coordinates = {x: 0, y: 0};
+
+        self.name = name;
+
+        // Add graphic components
+        self.addUIApplication();    // Graphical visualization of the application
+        self.addUIConnectionView(); // Connection view component
+        self._notification = self.addUINotification();   // Application notification
+        self._notification.x = 50;
+        self._notification.y = -50;
+        self._legend = self.addUILegend(); // Graph legend
+
+        notificationCenter.subscribe(Notifications.ui.APPLICATION_CLICKED, function() {
+            self.render();
+        });
+
+        notificationCenter.subscribe(Notifications.ui.APPLICATION_EXPANSION_FINISHED, function() {
+            self._expansionAnimationFinished = true;
+        });
+
+        notificationCenter.subscribe(Notifications.ui.APPL, function() {
+            self._expansionAnimationFinished = true;
+        });
+
+
+        var oldCoordinates = undefined;
+
+        notificationCenter.subscribe(Notifications.ui.APPLICATION_EXPANSION_STARTED, function() {
+            oldCoordinates = self.coordinates;
+            self.coordinates = {x: (self.coordinates.x - windowViewController.width/2) * 15,
+                y: (self.coordinates.y - windowViewController.height/2) * 15
+            };
+            if(self.expanded == false) {
+                self._view.transition().duration(400).translate(self.coordinates.x, self.coordinates.y);
+            }
+        });
+
+        notificationCenter.subscribe(Notifications.ui.INSTANCE_CLICKED, function() {
+            self.render();
+        });
+    }();
+
+    // Destructor
+    self.deinit = function() {
+        applicationModel.viewControllerInstanceSelected = undefined;
+    };
+    return self;
+
+};

data/framework_components/monitoring-interface/js/view-controller/instance-view-controller.js

@@ -0,0 +1,112 @@
+var InstanceViewController = function(parentApplicationViewController, name, index, layer) {
+    var self = ViewController(layer);
+
+    // Public variables
+    self.name = undefined;
+    self.applicationName = undefined;
+    self.parentApplicationViewController = undefined;
+    self.tab = undefined;
+    self._notification = undefined;
+
+    var render = self.render;
+    self.render = function() {
+
+        // Position the graphical objects
+        self.tab.x = - windowViewController.width / 2 +
+            UITab.style.width / 2 +
+            UIApplication.style.margin;
+
+        self.tab.y = - windowViewController.height / 2 +
+            UITab.style.height / 2 +
+            UITab.style.height * index +
+            UIApplication.style.margin +
+            UIApplication.style.headerRectHeightExpanded;
+
+        if(parentApplicationViewController == applicationModel.viewControllerApplicationSelected) {
+            self.tab.show = true;
+        }
+        else {
+            self.tab.show = false;
+        }
+
+        self._notification.x = - windowViewController.width / 2 +
+            UITab.style.width +
+            UIApplication.style.margin -
+            UINotification.style.margin.x;
+
+
+        self._notification.y = - windowViewController.height / 2 +
+            UITab.style.height * index +
+            UIApplication.style.margin +
+            UIApplication.style.headerRectHeightExpanded +
+            UINotification.style.margin.y;
+
+        // Display notification only if errors are present
+        if(applicationModel.viewControllerApplicationSelected == self.parentApplicationViewController &&
+            self.notification() > 0) {
+            self._notification.show = true;
+        }
+        else {
+            self._notification.show = false;
+        }
+
+        render();
+    };
+
+    self.clicked = function() {
+        if(!self.selected) {
+            applicationModel.viewControllerInstanceSelected = self;
+            notificationCenter.dispatch(Notifications.ui.INSTANCE_CLICKED);
+        }
+    };
+
+    self.subscribeButtonClicked = function() {
+        alertsModel.application = applicationModel.viewControllerApplicationSelected.name;
+        alertsModel.instance = self.name;
+        alertsModel.component = undefined;
+        $('#mailDisplay').modal({ show: true});
+        alertsModel.fetchData();
+    };
+
+    // Getters
+    self.__defineGetter__("selected", function() {
+        if(applicationModel.viewControllerInstanceSelected == undefined)
+            return false;
+
+        return self.name == applicationModel.viewControllerInstanceSelected.name &&
+            self.applicationName == applicationModel.viewControllerInstanceSelected.applicationName;
+    });
+
+    self.getTabsNumber = function() {
+          return _.size(self.parentApplicationViewController._instanceViewControllers);
+    };
+
+    self.notification = function() {
+        return self.parentApplicationViewController.notification(name);
+    };
+
+    // Constructor
+    self.init = function() {
+        self.name = name;
+        self.parentApplicationViewController = parentApplicationViewController;
+        self.applicationName = self.parentApplicationViewController.name;
+        //self.selected = false;
+
+        self.tab = self.addUITab(self.name);
+
+        // Calculate the position of the notification and add it
+        self._notification = self.addUINotification();
+
+        notificationCenter.subscribe(Notifications.ui.INSTANCE_CLICKED, self.render);
+        notificationCenter.subscribe(Notifications.ui.APPLICATION_EXPANSION_FINISHED, self.render);
+    }();
+
+    // Destructor
+    self.deinit = function() {
+        notificationCenter.unsubscribe(Notifications.ui.INSTANCE_CLICKED, self.render);
+        notificationCenter.unsubscribe(Notifications.ui.APPLICATION_EXPANSION_FINISHED, self.render);
+    };
+
+    return self;
+
+};

data/framework_components/monitoring-interface/js/view-controller/view-controller.js

@@ -0,0 +1,74 @@
+var ViewController = function(view) {
+    var self = {};
+
+    // Protected variables
+    self._view = undefined;
+    self._uis = [];
+
+    //#GETTER AND SETTER
+    self.__defineSetter__("view", function(view){
+        self._view = view;
+    });
+
+    self.__defineGetter__("view", function(){
+        return self._view;
+    });
+
+    self.render = function() {
+        self._uis.forEach(function(ui) {
+            ui.render(self._view);
+        });
+    };
+
+    // Add ui components
+    self.addUIApplication = function() {
+        var uiApplication = UIApplication(self);
+        self.addUiComponent(uiApplication);
+        return uiApplication;
+    };
+
+    self.addUIConnectionView = function() {
+        var uiConnectionView = UIConnectionView(self);
+        self.addUiComponent(uiConnectionView);
+        return uiConnectionView;
+    };
+
+    self.addUITab = function(name) {
+        var uiTab = UITab(self, name);
+        self.addUiComponent(uiTab);
+        return uiTab;
+    };
+
+    self.addUINotification = function(notificationName) {
+        var uiNotification = UINotification(self);
+        uiNotification.name = notificationName;
+        self.addUiComponent(uiNotification);
+        return uiNotification;
+    };
+
+    self.addUILegend = function() {
+        var uiLegend = UILegend(self);
+        self.addUiComponent(uiLegend);
+        return uiLegend;
+    };
+
+    self.addUiComponent = function(ui) {
+        self._uis.push(ui);
+    };
+
+    self.newView = function() {
+        return self._view.newView();
+    };
+
+    // Constructor
+    self.init = function() {
+        self._view = view;
+    }();
+
+    // Destructor
+    self.deinit = function() {
+        self._view.remove();
+    };
+
+    return self;
+};

data/framework_components/monitoring-interface/js/view-controller/window-view-controller.js

@@ -0,0 +1,169 @@
+var WindowViewController = function(view) {
+    var self = ViewController(view);
+
+    // Static variables
+    WindowViewController.style = {
+        margin: 10
+    };
+
+    // Protected variables
+    self._width = undefined;
+    self._height = undefined;
+    self._applicationViewControllers = {};   // UIApplication array
+    self._center = undefined;
+
+
+    // Private variables
+    var rectGrid = undefined;
+
+    self.updateViewBoxAnimated = function() {
+        self._width  = window.innerWidth;
+        self._height = window.innerHeight;
+        if(self._center == undefined)
+            self._view.transition().attr("viewBox", "0 0 " + self._width + " " + self._height);
+        else
+            self._view.transition().attr("viewBox", (-self._width/2 + self._center.x) + "  " + (-self._height/2 + self._center.y) + " " + self._width + " " + self._height);
+    };
+
+    self.updateViewBox = function() {
+        self._width  = window.innerWidth;
+        self._height = window.innerHeight;
+        if(self._center == undefined)
+            self._view.attr("viewBox", "0 0 " + self._width + " " + self._height);
+        else
+            self._view.attr("viewBox", (-self._width/2 + self._center.x) + "  " + (-self._height/2 + self._center.y) + " " + self._width + " " + self._height);
+    };
+
+    self.updateRectGrid = function() {
+        rectGrid = d3.layout.grid()
+            .bands()
+            .size([window.innerWidth - WindowViewController.style.margin,
+                window.innerHeight- WindowViewController.style.margin])
+            .padding([0.1, 0.1]);
+    };
+
+    self.resizeWindow = function() {
+
+        self.updateViewBox();
+
+        self.updateRectGrid();
+
+        if(applicationModel.data != undefined) {
+            self.renderData(applicationModel.data.applications)
+        }
+
+        //TODO: Send notification
+    };
+
+    //#GETTER AND SETTER
+    self.__defineGetter__("height", function(){
+        return self._height;
+    });
+
+    self.__defineGetter__("width", function(){
+        return self._width;
+    });
+
+
+
+    // Render function of the component
+    self.renderData = function(data) {
+
+        // Create application view controllers
+        self._view.selectAll(".applicationView")
+            .data(data)
+            .enter()
+            .append("g")
+            .class("applicationView")
+            .translate(self._width / 2, self._height / 2)
+            .each(function(data) {
+                var applicationViewController = ApplicationViewController(data.name, d3.select(this));
+                this.applicationViewController = applicationViewController;
+                self._applicationViewControllers[data.name] = applicationViewController;
+            });
+
+        // Update data in applications
+        self._view.selectAll(".applicationView")
+            .data(rectGrid(data))
+            .transition()
+            .duration(Animations.application.GRID_LAYOUT_REPOSITION.duration)
+            //.attr("transform", function(d) { return "translate(" + (d.x + rectGrid.nodeSize()[0]/2) + "," + (d.y + rectGrid.nodeSize()[1]/2) + ")"; })
+            .each(function(data) {
+                var applicationViewController = this.applicationViewController;
+                applicationViewController.name = data.name;
+                applicationViewController.coordinates = {
+                    x: data.x + rectGrid.nodeSize()[0] / 2,
+                    y: data.y + rectGrid.nodeSize()[1] / 2
+                };
+
+                // Render the application
+                applicationViewController.render();
+            });
+
+        // Update the application position
+        if(applicationModel.viewControllerApplicationSelected == undefined) {
+            // Update the position of all appllications
+            self._view.selectAll(".applicationView")
+                .data(rectGrid(data))
+                .transition()
+                .duration(Animations.application.GRID_LAYOUT_REPOSITION.duration)
+                .attr("transform", function (d) {
+                    return "translate(" + (d.x + rectGrid.nodeSize()[0] / 2) + "," + (d.y + rectGrid.nodeSize()[1] / 2) + ")";
+                });
+        }
+
+
+        // Delete old applications
+        self._view.selectAll(".applicationView")
+            .data(data)
+            .exit()
+            .each(function(data) {
+                var applicationViewController = this.applicationViewController;
+                applicationViewController.deinit();
+                delete self._applicationViewControllers[data.name];
+            })
+            .remove();
+    };
+
+    self.center = function(x, y) {
+        self._center = {x: x, y: y};
+        self.updateViewBoxAnimated();
+    };
+
+    self.resetCenter = function() {
+        self._center = undefined;
+        self.updateViewBoxAnimated();
+    };
+
+    // Constructor
+    self.init = function() {
+
+        // Subscribe to data notification
+        notificationCenter.subscribe(Notifications.data.APPLICATION_DATA_CHANGE,
+            function() {
+                self.updateRectGrid();
+                self.renderData(applicationModel.data.applications);
+            });
+
+        notificationCenter.subscribe(Notifications.ui.APPLICATION_REDUCTION_FINISHED,
+            function() {
+                self.updateRectGrid();
+                self.renderData(applicationModel.data.applications);
+        });
+
+        window.addEventListener("resize", self.resizeWindow);
+
+        // Init the grid layout
+        self.updateRectGrid();
+    }();
+
+    // Destructor
+    self.deinit = function() {
+        // Place here the code for dealloc eventual objects
+    };
+
+    return self;
+
+};
+
+var windowViewController = WindowViewController();

data/framework_components/monitoring-interface/nutella.json

@@ -0,0 +1,6 @@
+{
+	"name": "monitoring-interface",
+	"version": "0.0.1",
+	"type": "interface",
+	"description": "The web interface of Monitoring"
+}

data/framework_components/order.json

@@ -1,4 +1,5 @@
 [
+  "monitoring-bot",
   "logging_bot",
   "runs_list_bot",
   "main_interface",