Synnefo

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

            // handle progress message on instance change

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

            // force update of progress message

            this.update_status_message(true);

        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

            return this.get("status_messages");

        },

        get_status_message: function() {

            return this.get('status_message');

        },

        // extract status message from diagnostics

        status_message_from_diagnostics: function(diagnostics) {

            var valid_sources_map = synnefo.config.diagnostics_status_messages_map;

            var valid_sources = valid_sources_map[this.get('status')];

            if (!valid_sources) { return null };

            // filter messsages based on diagnostic source

            var messages = _.filter(diagnostics, function(diag) {

                return valid_sources.indexOf(diag.source) > -1;

            });

            var msg = messages[0];

            if (msg) {

              var message = msg.message;

              var message_tpl = snf.config.diagnostic_messages_tpls[msg.source];

              if (message_tpl) {

                  message = message_tpl.replace('MESSAGE', msg.message);

              }

              return message;

            }

            // no message to display, but vm in build state, display

            // finalizing message.

            if (this.is_building() == 'BUILD') {

                return synnefo.config.BUILDING_MESSAGES['FINAL'];

            }

            return null;

        },

        update_status_message: function(force) {

            // update only if one of the specified attributes has changed

            if (

              !this.keysChanged(['diagnostics', 'progress', 'status', 'state'])

                && !force

            ) { return };

            // if user requested to destroy the vm set the appropriate 

            // message.

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

                message = "Terminating..."

                this.set({status_message: message})

                return;

            }

            // set error message, if vm has diagnostic message display it as

            // progress message

            if (this.in_error_state()) {

                var d = this.get('diagnostics');

                if (d && d.length) {

                    var message = this.status_message_from_diagnostics(d);

                    this.set({status_message: message});

                } else {

                    this.set({status_message: null});

                return;

            }

            // identify building status message

            if (this.is_building()) {

                var self = this;

                var success = function(msg) {

                    self.set({status_message: msg});

                this.get_building_status_message(success);

                return;

            }

            this.set({status_message:null});

        },

        // get building status message. Asynchronous function since it requires

        // access to vm image.

        get_building_status_message: function(callback) {

            // no progress is set, vm is in initial build status

            var progress = this.get("progress");

            if (progress == 0 || !progress) {

                return callback(BUILDING_MESSAGES['INIT']);

            }

            // vm has copy progress, display copy percentage

            if (progress > 0 && progress <= 99) {

                this.get_copy_details(true, undefined, _.bind(

                    function(details){

                        callback(BUILDING_MESSAGES['COPY'].format(details.copy, 

                                                           details.size, 

                                                           details.progress));

                }, this));

                return;

            }

            // copy finished display FINAL message or identify status message

            // from diagnostics.

            if (progress >= 100) {

                if (!this.has_diagnostics()) {

                        callback(BUILDING_MESSAGES['FINAL']);

                } else {

                        var d = this.get("diagnostics");

                        var msg = this.status_message_from_diagnostics(d);

                        if (msg) {

                              callback(msg);

                        }

            return this.get_nics(function(n){ return n.get_network().is_public() })[0];

        get_diagnostics_url: function() {

            return this.url() + "/diagnostics";

        },

        parse_vm_api_data: function(data) {

            // do not add non existing DELETED entries

            if (data.status && data.status == "DELETED") {

                if (!this.get(data.id)) {

                    return false;

                }

            }

            // OS attribute

            if (this.has_meta(data)) {

                data['OS'] = data.metadata.values.OS || "okeanos";

            }

            if (!data.diagnostics) {

                data.diagnostics = [];

            }

            // network metadata

            data['firewalls'] = {};

            data['nics'] = {};

            data['linked_to'] = [];

            if (data['attachments'] && data['attachments'].values) {

                var nics = data['attachments'].values;

                _.each(nics, function(nic) {

                    var net_id = nic.network_id;

                    var index = parseInt(NIC_REGEX.exec(nic.id)[2]);

                    if (data['linked_to'].indexOf(net_id) == -1) {

                        data['linked_to'].push(net_id);

                    }

                    data['nics'][nic.id] = nic;

                })

            }

            // if vm has no metadata, no metadata object

            // is in json response, reset it to force

            // value update

            if (!data['metadata']) {

                data['metadata'] = {values:{}};

            }

            return data;

        },

              try {

              } catch (err) {};