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];

        var append = "/";

        if (baseurl.split("").reverse()[0] == "/") {

          append = "";

        }

        return baseurl + append + this.path;

    }

    // 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,

        auto_bind: [],

        initialize: function() {

            var self = this;

            this._proxy_model_cache = {};

            _.each(this.auto_bind, function(fname) {

              self[fname] = _.bind(self[fname], self);

            });

            if (this.has_status) {

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

                this.handle_remove();

            }

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

            if (this.proxy_attrs) {

              this.init_proxy_attrs();             

            }

            if (this.storage_attrs) {

              this.init_storage_attrs();

            }

            if (this.model_actions) {

              this.init_model_actions();             

            }

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

        },

        // Initialize model actions object

        // For each entry in model's model_action object register the relevant 

        // model proxy `can_<actionname>` attributes.

        init_model_actions: function() {

          var actions = _.keys(this.model_actions);

          this.set({

            "actions": new models._ActionsModel({}, {

              actions: actions,

              model: this

            })

          });

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

          _.each(this.model_actions, function(params, key){

            var attr = 'can_' + key;

            if (params.length == 0) { return }

            var deps = params[0];

            var cb = _.bind(params[1], this);

            _.each(deps, function(dep) {

              this._set_proxy_attr(attr, dep, cb);

            }, this);

          }, this);

        },

        // Initialize proxy storage model attributes. These attribues allows 

        // us to automatically access cross collection associated objects.

        init_storage_attrs: function() {

          _.each(this.storage_attrs, function(params, attr) {

            var store, key, attr_name;

            store = synnefo.storage[params[0]];

            key = params[1];

            attr_resolver = params[2];

            if (!attr_resolver) {

              attr_resolver = function(model, attr) {

                return model.get(attr);

              }

            }

            attr_name = attr;

            var resolve_related_instance = function(storage, attr_name, val) {

              var data = {};

              if (!val) { 

                // update with undefined and return

                data[key] = undefined;

                this.set(data);

                return;

              };

              // retrieve related object (check if its a Model??)

              var obj = store.get(val);

              if (obj) {

                // set related object

                data[attr_name] = obj;

                this.set(data, {silent:true})

                this.trigger("change:" + attr_name, obj);

              } else {

                var self = this;

                var retry = window.setInterval(function(){

                  var obj = store.get(val);

                  if (obj) {

                    data[key] = obj;

                    self.set(data, {silent:true})

                    self.trigger("change:" + attr_name, obj);

                    clearInterval(retry);

                  }

                }, 500);

              }

            }

            var self = this;

            this.bind('change:' + attr, function(model) {

              resolve_related_instance.call(model, store, key, attr_resolver(model, attr));

            }, this);

            this.bind('add', function(model) {

              resolve_related_instance.call(model, store, key, attr_resolver(model, attr));

            }, this);

            resolve_related_instance.call(this, store, key, attr_resolver(this, attr));

          }, this);

        },

        _proxy_model_cache: {},

        _set_proxy_attr: function(attr, check_attr, cb) {

          // initial set

          var data = {};

          data[attr] = cb.call(this, this.get(check_attr));

          if (data[attr] !== undefined) {

            this.set(data, {silent:true});

          }

          this.bind('change:' + check_attr, function() {

            if (this.get(check_attr) instanceof models.Model) {

              var model = this.get(check_attr);

              var proxy_cache_key = attr + '_' + check_attr;

              if (this._proxy_model_cache[proxy_cache_key]) {

                var proxy = this._proxy_model_cache[proxy_cache_key];

                proxy[0].unbind('change', proxy[1]);

              }

              var changebind = _.bind(function() {

                var data = {};

                data[attr] = cb.call(this, this.get(check_attr));

                this.set(data);

              }, this);

              model.bind('change', changebind);

              this._proxy_model_cache[proxy_cache_key] = [model, changebind];

            }

            var val = cb.call(this, this.get(check_attr));

            var data = {};

            if (this.get(attr) !== val) {

              data[attr] = val;

              this.set(data);

            }

          }, this);

        },

        init_proxy_attrs: function() {

          _.each(this.proxy_attrs, function(opts, attr){

            var cb = opts[1];

            _.each(opts[0], function(check_attr){

              this._set_proxy_attr(attr, check_attr, cb)

            }, this);

          }, this);

        },

        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;

                };

                // for collections which associated models don't support 

                // deleted state identification through attributes, resolve  

                // deleted entries by checking for missing objects in fetch 

                // responses.

                if (this.updateEntries && options.removeMissing === undefined) {

                  options.removeMissing = true;

                }

            } else {

                if (options.refresh === undefined) {

                    options.refresh = true;

                    if (this.updateEntries) {

                      options.update = true;

                      options.removeMissing = 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').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')) {

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

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

            } else {

                return null;

            }

        },

        get_meta_keys: function() {

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

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

            } 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) {

                var osfamily = this.get_meta('osfamily');

                if (osfamily == 'windows') { 

                  users = ['Administrator'];

                } else {

                  users = ['root'];

                }

            }

            return users;

        },

        get_sort_order: function() {

            return parseInt(this.get('metadata') ? this.get('metadata').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

                }

            });

        }

    });

    // 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);

            }

        }

    });

    // Virtualmachine model

    models.VM = models.Model.extend({

        path: 'servers',

        has_status: true,

        proxy_attrs: {

          'busy': [

            ['status', 'state'], function() {

              return !_.contains(['ACTIVE', 'STOPPED'], this.get('status'));

            }

          ],

        },

        initialize: function(params) {

            var self = this;

            this.ports = new Backbone.FilteredCollection(undefined, {

              collection: synnefo.storage.ports,

              collectionFilter: function(m) {

                return self.id == m.get('device_id')

            }});

            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

            // images get refreshed on different intervals

            this.stats_update_interval = synnefo.config.STATS_INTERVAL || 5000;

            this.stats_available = false;

            // initialize interval

            this.init_stats_intervals(this.stats_update_interval);

            // handle progress message on instance change

            this.bind("change", _.bind(this.update_status_message, this));

            this.bind("change:task_state", _.bind(this.update_status, this));

            // force update of progress message

            this.update_status_message(true);

            // default values

            this.bind("change:state", _.bind(function(){

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

                    this.handle_destroy() 

                }

            }, this));

        },

        status: function(st) {

            if (!st) { return this.get("status")}

            return this.set({status:st});

        },

        update_status: function() {

            this.set_status(this.get('status'));

        },

        set_status: function(st) {

            var new_state = this.state_for_api_status(st);

            var transition = false;

            if (this.state() != new_state) {

                if (models.VM.STATES_TRANSITIONS[this.state()]) {

                    transition = this.state();

                }

            }

            // call it silently to avoid double change trigger

            var state = this.state_for_api_status(st);

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

            // trigger transition

            if (transition && models.VM.TRANSITION_STATES.indexOf(new_state) == -1) { 

                this.trigger("transition", {from:transition, to:new_state}) 

            };

            return st;

        },

        get_diagnostics: function(success) {

            this.__make_api_call(this.get_diagnostics_url(),

                                 "read", // create so that sync later uses POST to make the call

                                 null, // payload

                                 function(data) {

                                     success(data);

                                 },  

                                 null, 'diagnostics');

        },

        has_diagnostics: function() {

            return this.get("diagnostics") && this.get("diagnostics").length;

        },

        get_progress_info: function() {

            // details about progress message

            // contains a list of diagnostic messages