Synnefo

// Copyright 2011 GRNET S.A. All rights reserved.

// 

// Redistribution and use in source and binary forms, with or

// without modification, are permitted provided that the following

// conditions are met:

// 

//   1. Redistributions of source code must retain the above

//      copyright notice, this list of conditions and the following

//      disclaimer.

// 

//   2. Redistributions in binary form must reproduce the above

//      copyright notice, this list of conditions and the following

//      disclaimer in the documentation and/or other materials

//      provided with the distribution.

// 

// THIS SOFTWARE IS PROVIDED BY GRNET S.A. ``AS IS'' AND ANY EXPRESS

// OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED

// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL GRNET S.A OR

// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF

// USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED

// AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN

// ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

// POSSIBILITY OF SUCH DAMAGE.

// 

// The views and conclusions contained in the software and

// documentation are those of the authors and should not be

// interpreted as representing official policies, either expressed

// or implied, of GRNET S.A.

// 

;(function(root){

    // root

    var root = root;

    // setup namepsaces

    var snf = root.synnefo = root.synnefo || {};

    var models = snf.models = snf.models || {}

    var storage = snf.storage = snf.storage || {};

    var util = snf.util = snf.util || {};

    // shortcuts

    var bb = root.Backbone;

    var slice = Array.prototype.slice

    // logging

    var logger = new snf.logging.logger("SNF-MODELS");

    var debug = _.bind(logger.debug, logger);

    // get url helper

    var getUrl = function(baseurl) {

        var baseurl = baseurl || snf.config.api_urls[this.api_type];

        return baseurl + "/" + this.path;

    }

    var NIC_REGEX = /^nic-([0-9]+)-([0-9]+)$/

    // i18n

    BUILDING_MESSAGES = window.BUILDING_MESSAGES || {'INIT': 'init', 'COPY': '{0}, {1}, {2}', 'FINAL': 'final'};

    // Base object for all our models

    models.Model = bb.Model.extend({

        sync: snf.api.sync,

        api: snf.api,

        api_type: 'compute',

        has_status: false,

        initialize: function() {

            if (this.has_status) {

                this.bind("change:status", this.handle_remove);

                this.handle_remove();

            }

            this.api_call = _.bind(this.api.call, this);

            models.Model.__super__.initialize.apply(this, arguments);

        },

        handle_remove: function() {

            if (this.get("status") == 'DELETED') {

                if (this.collection) {

                    try { this.clear_pending_action();} catch (err) {};

                    try { this.reset_pending_actions();} catch (err) {};

                    try { this.stop_stats_update();} catch (err) {};

                    this.collection.remove(this.id);

                }

            }

        },

        // custom set method to allow submodels to use

        // set_<attr> methods for handling the value of each

        // attribute and overriding the default set method

        // for specific parameters

        set: function(params, options) {

            _.each(params, _.bind(function(value, key){

                if (this["set_" + key]) {

                    params[key] = this["set_" + key](value);

                }

            }, this))

            var ret = bb.Model.prototype.set.call(this, params, options);

            return ret;

        },

        url: function(options) {

            return getUrl.call(this, this.base_url) + "/" + this.id;

        },

        api_path: function(options) {

            return this.path + "/" + this.id;

        },

        parse: function(resp, xhr) {

        },

        remove: function(complete, error, success) {

            this.api_call(this.api_path(), "delete", undefined, complete, error, success);

        },

        changedKeys: function() {

            return _.keys(this.changedAttributes() || {});

        },

        // return list of changed attributes that included in passed list

        // argument

        getKeysChanged: function(keys) {

            return _.intersection(keys, this.changedKeys());

        },

        // boolean check of keys changed

        keysChanged: function(keys) {

            return this.getKeysChanged(keys).length > 0;

        },

        // check if any of the passed attribues has changed

        hasOnlyChange: function(keys) {

            var ret = false;

            _.each(keys, _.bind(function(key) {

                if (this.changedKeys().length == 1 && this.changedKeys().indexOf(key) > -1) { ret = true};

            }, this));

            return ret;

        }

    })

    // Base object for all our model collections

    models.Collection = bb.Collection.extend({

        sync: snf.api.sync,

        api: snf.api,

        api_type: 'compute',

        supportIncUpdates: true,

        initialize: function() {

            models.Collection.__super__.initialize.apply(this, arguments);

            this.api_call = _.bind(this.api.call, this);

        },

        url: function(options, method) {

            return getUrl.call(this, this.base_url) + (

                    options.details || this.details && method != 'create' ? '/detail' : '');

        },

        fetch: function(options) {

            if (!options) { options = {} };

            // default to update

            if (!this.noUpdate) {

                if (options.update === undefined) { options.update = true };

                if (!options.removeMissing && options.refresh) { options.removeMissing = true };

            } else {

                if (options.refresh === undefined) {

                    options.refresh = true;

                }

            }

            // custom event foreach fetch

            return bb.Collection.prototype.fetch.call(this, options)

        },

        create: function(model, options) {

            var coll = this;

            options || (options = {});

            model = this._prepareModel(model, options);

            if (!model) return false;

            var success = options.success;

            options.success = function(nextModel, resp, xhr) {

                if (success) success(nextModel, resp, xhr);

            };

            model.save(null, options);

            return model;

        },

        get_fetcher: function(interval, increase, fast, increase_after_calls, max, initial_call, params) {

            var fetch_params = params || {};

            var handler_options = {};

            fetch_params.skips_timeouts = true;

            handler_options.interval = interval;

            handler_options.increase = increase;

            handler_options.fast = fast;

            handler_options.increase_after_calls = increase_after_calls;

            handler_options.max= max;

            handler_options.id = "collection id";

            var last_ajax = undefined;

            var callback = _.bind(function() {

                // clone to avoid referenced objects

                var params = _.clone(fetch_params);

                updater._ajax = last_ajax;

                // wait for previous request to finish

                if (last_ajax && last_ajax.readyState < 4 && last_ajax.statusText != "timeout") {

                    // opera readystate for 304 responses is 0

                    if (!($.browser.opera && last_ajax.readyState == 0 && last_ajax.status == 304)) {

                        return;

                    }

                }

                last_ajax = this.fetch(params);

            }, this);

            handler_options.callback = callback;

            var updater = new snf.api.updateHandler(_.clone(_.extend(handler_options, fetch_params)));

            snf.api.bind("call", _.throttle(_.bind(function(){ updater.faster(true)}, this)), 1000);

            return updater;

        }

    });

    // Image model

    models.Image = models.Model.extend({

        path: 'images',

        get_size: function() {

            return parseInt(this.get('metadata') ? this.get('metadata').values.size : -1)

        },

        get_description: function(escape) {

            if (escape == undefined) { escape = true };

            if (escape) { return this.escape('description') || "No description available"}

            return this.get('description') || "No description available."

        },

        get_meta: function(key) {

            if (this.get('metadata') && this.get('metadata').values) {

                if (!this.get('metadata').values[key]) { return null }

                return _.escape(this.get('metadata').values[key]);

            } else {

                return null;

            }

        },

        get_meta_keys: function() {

            if (this.get('metadata') && this.get('metadata').values) {

                return _.keys(this.get('metadata').values);

            } else {

                return [];

            }

        },

        get_owner: function() {

            return this.get('owner') || _.keys(synnefo.config.system_images_owners)[0];

        },

        get_owner_uuid: function() {

            return this.get('owner_uuid');

        },

        is_system_image: function() {

          var owner = this.get_owner();

          return _.include(_.keys(synnefo.config.system_images_owners), owner)

        },

        owned_by: function(user) {

          if (!user) { user = synnefo.user }

          return user.get_username() == this.get('owner_uuid');

        },

        display_owner: function() {

            var owner = this.get_owner();

            if (_.include(_.keys(synnefo.config.system_images_owners), owner)) {

                return synnefo.config.system_images_owners[owner];

            } else {

                return owner;

            }

        },

        get_readable_size: function() {

            if (this.is_deleted()) {

                return synnefo.config.image_deleted_size_title || '(none)';

            }

            return this.get_size() > 0 ? util.readablizeBytes(this.get_size() * 1024 * 1024) : '(none)';

        },

        get_os: function() {

            return this.get_meta('OS');

        },

        get_gui: function() {

            return this.get_meta('GUI');

        },

        get_created_users: function() {

            try {

              var users = this.get_meta('users').split(" ");

            } catch (err) { users = null }

            if (!users) { users = [synnefo.config.os_created_users[this.get_os()] || "root"]}

            return users;

        },

        get_sort_order: function() {

            return parseInt(this.get('metadata') ? this.get('metadata').values.sortorder : -1)

        },

        get_vm: function() {

            var vm_id = this.get("serverRef");

            var vm = undefined;

            vm = storage.vms.get(vm_id);

            return vm;

        },

        is_public: function() {

            return this.get('is_public') == undefined ? true : this.get('is_public');

        },

        is_deleted: function() {

            return this.get('status') == "DELETED"

        },

        ssh_keys_paths: function() {

            return _.map(this.get_created_users(), function(username) {

                prepend = '';

                if (username != 'root') {

                    prepend = '/home'

                }

                return {'user': username, 'path': '{1}/{0}/.ssh/authorized_keys'.format(username, 

                                                             prepend)};

            });

        },

        _supports_ssh: function() {

            if (synnefo.config.support_ssh_os_list.indexOf(this.get_os()) > -1) {

                return true;

            }

            if (this.get_meta('osfamily') == 'linux') {

              return true;

            }

            return false;

        },

        supports: function(feature) {

            if (feature == "ssh") {

                return this._supports_ssh()

            }

            return false;

        },

        personality_data_for_keys: function(keys) {

            return _.map(this.ssh_keys_paths(), function(pathinfo) {

                var contents = '';

                _.each(keys, function(key){

                    contents = contents + key.get("content") + "\n"

                });

                contents = $.base64.encode(contents);

                return {

                    path: pathinfo.path,

                    contents: contents,

                    mode: 0600,

                    owner: pathinfo.user,

                    group: pathinfo.user

                }

            });

        }

    });

    // Flavor model

    models.Flavor = models.Model.extend({

        path: 'flavors',

        details_string: function() {

            return "{0} CPU, {1}MB, {2}GB".format(this.get('cpu'), this.get('ram'), this.get('disk'));

        },

        get_disk_size: function() {

            return parseInt(this.get("disk") * 1000)

        },

        get_ram_size: function() {

            return parseInt(this.get("ram"))

        },

        get_disk_template_info: function() {

            var info = snf.config.flavors_disk_templates_info[this.get("disk_template")];

            if (!info) {

                info = { name: this.get("disk_template"), description:'' };

            }

            return info

        },

        disk_to_bytes: function() {

            return parseInt(this.get("disk")) * 1024 * 1024 * 1024;

        },

        ram_to_bytes: function() {

            return parseInt(this.get("ram")) * 1024 * 1024;

        },

    });

    models.ParamsList = function(){this.initialize.apply(this, arguments)};

    _.extend(models.ParamsList.prototype, bb.Events, {

        initialize: function(parent, param_name) {

            this.parent = parent;

            this.actions = {};

            this.param_name = param_name;

            this.length = 0;

        },

        has_action: function(action) {

            return this.actions[action] ? true : false;

        },

        _parse_params: function(arguments) {

            if (arguments.length <= 1) {

                return [];

            }

            var args = _.toArray(arguments);

            return args.splice(1);

        },

        contains: function(action, params) {

            params = this._parse_params(arguments);

            var has_action = this.has_action(action);

            if (!has_action) { return false };

            var paramsEqual = false;

            _.each(this.actions[action], function(action_params) {

                if (_.isEqual(action_params, params)) {

                    paramsEqual = true;

                }

            });

            return paramsEqual;

        },

        is_empty: function() {

            return _.isEmpty(this.actions);

        },

        add: function(action, params) {

            params = this._parse_params(arguments);

            if (this.contains.apply(this, arguments)) { return this };

            var isnew = false

            if (!this.has_action(action)) {

                this.actions[action] = [];

                isnew = true;

            };

            this.actions[action].push(params);

            this.parent.trigger("change:" + this.param_name, this.parent, this);

            if (isnew) {

                this.trigger("add", action, params);

            } else {

                this.trigger("change", action, params);

            }

            return this;

        },

        remove_all: function(action) {

            if (this.has_action(action)) {

                delete this.actions[action];

                this.parent.trigger("change:" + this.param_name, this.parent, this);

                this.trigger("remove", action);

            }

            return this;

        },

        reset: function() {

            this.actions = {};

            this.parent.trigger("change:" + this.param_name, this.parent, this);

            this.trigger("reset");

            this.trigger("remove");

        },

        remove: function(action, params) {

            params = this._parse_params(arguments);

            if (!this.has_action(action)) { return this };

            var index = -1;

            _.each(this.actions[action], _.bind(function(action_params) {

                if (_.isEqual(action_params, params)) {

                    index = this.actions[action].indexOf(action_params);

                }

            }, this));

            if (index > -1) {

                this.actions[action].splice(index, 1);

                if (_.isEmpty(this.actions[action])) {

                    delete this.actions[action];

                }

                this.parent.trigger("change:" + this.param_name, this.parent, this);

                this.trigger("remove", action, params);

            }

        }

    });

    // Image model

    models.Network = models.Model.extend({

        path: 'networks',

        has_status: true,

        defaults: {'connecting':0},

        initialize: function() {

            var ret = models.Network.__super__.initialize.apply(this, arguments);

            this.set({"actions": new models.ParamsList(this, "actions")});

            this.update_state();

            this.bind("change:nics", _.bind(synnefo.storage.nics.update_net_nics, synnefo.storage.nics));

            this.bind("change:status", _.bind(this.update_state, this));

            return ret;

        },

        is_deleted: function() {

          return this.get('status') == 'DELETED';

        },

        toJSON: function() {

            var attrs = _.clone(this.attributes);

            attrs.actions = _.clone(this.get("actions").actions);

            return attrs;

        },

        set_state: function(val) {

            if (val == "PENDING" && this.get("state") == "DESTORY") {

                return "DESTROY";

            }

            return val;

        },

        update_state: function() {

            if (this.get("connecting") > 0) {

                this.set({state: "CONNECTING"});

                return

            }

            if (this.get_nics(function(nic){ return nic.get("removing") == 1}).length > 0) {

                this.set({state: "DISCONNECTING"});

                return

            }   

            if (this.contains_firewalling_nics() > 0) {

                this.set({state: "FIREWALLING"});

                return

            }   

            if (this.get("state") == "DESTROY") { 

                this.set({"destroyed":1});

            }

            this.set({state:this.get('status')});

        },

        is_public: function() {

            return this.get("public");

        },

        decrease_connecting: function() {

            var conn = this.get("connecting");

            if (!conn) { conn = 0 };

            if (conn > 0) {

                conn--;

            }

            this.set({"connecting": conn});

            this.update_state();

        },

        increase_connecting: function() {

            var conn = this.get("connecting");

            if (!conn) { conn = 0 };

            conn++;

            this.set({"connecting": conn});

            this.update_state();

        },

        connected_to: function(vm) {

            return this.get('linked_to').indexOf(""+vm.id) > -1;

        },

        connected_with_nic_id: function(nic_id) {

            return _.keys(this.get('nics')).indexOf(nic_id) > -1;

        },

        get_nics: function(filter) {

            var nics = synnefo.storage.nics.filter(function(nic) {

                return nic.get('network_id') == this.id;

            }, this);

            if (filter) {

                return _.filter(nics, filter);

            }

            return nics;

        },

        contains_firewalling_nics: function() {

            return this.get_nics(function(n){return n.get('pending_firewall')}).length

        },

        call: function(action, params, success, error) {

            if (action == "destroy") {

                var previous_state = this.get('state');

                var previous_status = this.get('status');

                this.set({state:"DESTROY"});

                var _success = _.bind(function() {

                    if (success) { success() };

                    synnefo.storage.quotas.get('cyclades.network.private').decrease();

                }, this);

                var _error = _.bind(function() {

                    this.set({state: previous_state, status: previous_status})

                    if (error) { error() };

                }, this);

                this.remove(undefined, _error, _success);

            }

            if (action == "disconnect") {

                if (this.get("state") == "DESTROY") {

                    return;

                }

                _.each(params, _.bind(function(nic_id) {

                    var nic = snf.storage.nics.get(nic_id);

                    this.get("actions").remove("disconnect", nic_id);

                    if (nic) {

                        this.remove_nic(nic, success, error);

                    }

                }, this));

            }

        },

        add_vm: function (vm, callback, error, options) {

            var payload = {add:{serverRef:"" + vm.id}};

            payload._options = options || {};

            return this.api_call(this.api_path() + "/action", "create", 

                                 payload,

                                 undefined,

                                 error,

                                 _.bind(function(){

                                     //this.vms.add_pending(vm.id);

                                     this.increase_connecting();

                                     if (callback) {callback()}

                                 },this), error);

        },

        remove_nic: function (nic, callback, error, options) {

            var payload = {remove:{attachment:"" + nic.get("attachment_id")}};

            payload._options = options || {};

            return this.api_call(this.api_path() + "/action", "create", 

                                 payload,

                                 undefined,

                                 error,

                                 _.bind(function(){

                                     nic.set({"removing": 1});

                                     nic.get_network().update_state();

                                     //this.vms.add_pending_for_remove(vm.id);

                                     if (callback) {callback()}

                                 },this), error);

        },

        rename: function(name, callback) {

            return this.api_call(this.api_path(), "update", {

                network:{name:name}, 

                _options:{

                    critical: false, 

                    error_params:{

                        title: "Network action failed",

                        ns: "Networks",

                        extra_details: {"Network id": this.id}

                    }

                }}, callback);

        },

        get_connectable_vms: function() {

            return storage.vms.filter(function(vm){

                return !vm.in_error_state() && !vm.is_building();

            })

        },

        state_message: function() {

            if (this.get("state") == "ACTIVE" && !this.is_public()) {

                if (this.get("cidr") && this.get("dhcp") == true) {

                    return this.get("cidr");

                } else {

                    return "Private network";

                }

            }

            if (this.get("state") == "ACTIVE" && this.is_public()) {

                  return "Public network";

            }

            return models.Network.STATES[this.get("state")];

        },

        in_progress: function() {

            return models.Network.STATES_TRANSITIONS[this.get("state")] != undefined;

        },

        do_all_pending_actions: function(success, error) {

          var params, actions, action_params;

          actions = _.clone(this.get("actions").actions);

            _.each(actions, _.bind(function(params, action) {

                action_params = _.map(actions[action], function(a){ return _.clone(a)});

                _.each(action_params, _.bind(function(params) {

                    this.call(action, params, success, error);

                }, this));

            }, this));

            this.get("actions").reset();

        }

    });

    models.Network.STATES = {

        'ACTIVE': 'Private network',

        'CONNECTING': 'Connecting...',

        'DISCONNECTING': 'Disconnecting...',

        'FIREWALLING': 'Firewall update...',

        'DESTROY': 'Destroying...',

        'PENDING': 'Pending...',

        'ERROR': 'Error'

    }

    models.Network.STATES_TRANSITIONS = {

        'CONNECTING': ['ACTIVE'],

        'DISCONNECTING': ['ACTIVE'],

        'PENDING': ['ACTIVE'],

        'FIREWALLING': ['ACTIVE']

    }

    // Virtualmachine model

    models.VM = models.Model.extend({

        path: 'servers',

        has_status: true,

        initialize: function(params) {

            this.pending_firewalls = {};

            models.VM.__super__.initialize.apply(this, arguments);

            this.set({state: params.status || "ERROR"});

            this.log = new snf.logging.logger("VM " + this.id);

            this.pending_action = undefined;

            // init stats parameter

            this.set({'stats': undefined}, {silent: true});

            // defaults to not update the stats

            // each view should handle this vm attribute 

            // depending on if it displays stat images or not

            this.do_update_stats = false;

            // interval time

            // this will dynamicaly change if the server responds that