Addd support for taking backup for the server.

Tweaked by Ashesh Vashi to integrate the backgroud process, and also
with some improvements as stated below:
* Resolved an issue loading existing preference.
* Improved the background process observer/executor for supporting
  detalied view.
* Added the utility path preferences in the ServerType class.

web/pgadmin/tools/backup/__init__.py

@@ -0,0 +1,440 @@
+##########################################################################
+#
+# pgAdmin 4 - PostgreSQL Tools
+#
+# Copyright (C) 2013 - 2016, The pgAdmin Development Team
+# This software is released under the PostgreSQL Licence
+#
+##########################################################################
+
+"""Implements Backup Utility"""
+
+import json
+import os
+from flask import render_template, request, current_app, \
+    url_for, Response
+from flask.ext.babel import gettext as _
+from pgadmin.utils.ajax import make_json_response, bad_request
+from pgadmin.utils import PgAdminModule, get_storage_directory
+from flask.ext.security import login_required, current_user
+from pgadmin.model import Server
+from config import PG_DEFAULT_DRIVER
+from pgadmin.misc.bgprocess.processes import BatchProcess, IProcessDesc
+
+
+# set template path for sql scripts
+MODULE_NAME = 'backup'
+server_info = {}
+
+
+class BackupModule(PgAdminModule):
+    """
+    class BackupModule(Object):
+
+        It is a utility which inherits PgAdminModule
+        class and define methods to load its own
+        javascript file.
+    """
+
+    LABEL = _('Backup')
+
+    def get_own_javascripts(self):
+        """"
+        Returns:
+            list: js files used by this module
+        """
+        return [{
+            'name': 'pgadmin.tools.backup',
+            'path': url_for('backup.index') + 'backup',
+            'when': None
+        }]
+
+    def show_system_objects(self):
+        """
+        return system preference objects
+        """
+        return self.pref_show_system_objects
+
+
+# Create blueprint for BackupModule class
+blueprint = BackupModule(
+    MODULE_NAME, __name__, static_url_path=''
+)
+
+
+class BACKUP(object):
+    """
+    Constants defined for Backup utilities
+    """
+    GLOBALS = 1
+    SERVER = 2
+    OBJECT = 3
+
+
+class BackupMessage(IProcessDesc):
+    """
+    BackupMessage(IProcessDesc)
+
+    Defines the message shown for the backup operation.
+    """
+    def __init__(self, _type, _sid, **kwargs):
+        self.backup_type = _type
+        self.sid = _sid
+        self.database = None
+
+        if 'database' in kwargs:
+            self.database = kwargs['database']
+
+    @property
+    def message(self):
+        # Fetch the server details like hostname, port, roles etc
+        s = Server.query.filter_by(
+            id=self.sid, user_id=current_user.id
+        ).first()
+
+        if self.backup_type == BACKUP.OBJECT:
+            return _(
+                "Backing up an object on the server - '{0}' on database '{1}'..."
+            ).format(
+                "{0} ({1}:{2})".format(s.name, s.host, s.port),
+                self.database
+            )
+        if self.backup_type == BACKUP.GLOBALS:
+            return _("Backing up the globals for the server - '{0}'...").format(
+                "{0} ({1}:{2})".format(s.name, s.host, s.port)
+            )
+        elif self.backup_type == BACKUP.SERVER:
+            return _("Backing up the server - '{0}'...").format(
+                "{0} ({1}:{2})".format(s.name, s.host, s.port)
+            )
+        else:
+            # It should never reach here.
+            return "Unknown Backup"
+
+    def details(self, cmd, args):
+        # Fetch the server details like hostname, port, roles etc
+        s = Server.query.filter_by(
+            id=self.sid, user_id=current_user.id
+        ).first()
+
+        res = '<div class="h5">'
+
+        if self.backup_type == BACKUP.OBJECT:
+            res += _(
+                "Backing up an object on the server - '{0}' on database '{1}'"
+            ).format(
+                "{0} ({1}:{2})".format(s.name, s.host, s.port),
+                self.database
+            ).encode('ascii', 'xmlcharrefreplace')
+        if self.backup_type == BACKUP.GLOBALS:
+            res += _("Backing up the globals for the server - '{0}'!").format(
+                "{0} ({1}:{2})".format(s.name, s.host, s.port)
+            ).encode('ascii', 'xmlcharrefreplace')
+        elif self.backup_type == BACKUP.SERVER:
+            res += _("Backing up the server - '{0}'!").format(
+                "{0} ({1}:{2})".format(s.name, s.host, s.port)
+            ).encode('ascii', 'xmlcharrefreplace')
+        else:
+            # It should never reach here.
+            res += "Backup"
+
+        res += '</div><div class="h5">'
+        res += _("Running command:").encode('ascii', 'xmlcharrefreplace')
+        res += '<br>'
+        res += cmd.encode('ascii', 'xmlcharrefreplace')
+
+        replace_next = False
+
+        def cmdArg(x):
+            if x:
+                x = x.replace('\\', '\\\\')
+                x = x.replace('"', '\\"')
+                x = x.replace('""', '\\"')
+
+                return  ' "' + x.encode('ascii', 'xmlcharrefreplace') + '"'
+
+            return ''
+
+        for arg in args:
+            if arg and len(arg) >= 2 and arg[:2] == '--':
+                res += ' ' + arg
+            elif replace_next:
+                res += ' XXX'
+            else:
+                if arg == '--file':
+                    replace_next = True
+                res += cmdArg(arg)
+        res += '</div>'
+
+        return res
+
+
+@blueprint.route("/")
+@login_required
+def index():
+    return bad_request(errormsg=_("This URL can not be called directly!"))
+
+
+@blueprint.route("/backup.js")
+@login_required
+def script():
+    """render own javascript"""
+    return Response(
+        response=render_template(
+            "backup/js/backup.js", _=_
+        ),
+        status=200,
+        mimetype="application/javascript"
+    )
+
+
+def filename_with_file_manager_path(file):
+    """
+    Args:
+        file: File name returned from client file manager
+
+    Returns:
+        Filename to use for backup with full path taken from preference
+    """
+    # Set file manager directory from preference
+    file_manager_dir = get_storage_directory()
+    return os.path.join(file_manager_dir, file)
+
+
+@blueprint.route('/create_job/<int:sid>', methods=['POST'])
+@login_required
+def create_backup_job(sid):
+    """
+    Args:
+        sid: Server ID
+
+        Creates a new job for backup task (Backup Server/Globals)
+
+    Returns:
+        None
+    """
+    if request.form:
+        # Convert ImmutableDict to dict
+        data = dict(request.form)
+        data = json.loads(data['data'][0])
+    else:
+        data = json.loads(request.data.decode())
+
+    data['file'] = filename_with_file_manager_path(data['file'])
+
+    # Fetch the server details like hostname, port, roles etc
+    server = Server.query.filter_by(
+        id=sid, user_id=current_user.id
+    ).first()
+
+    if server is None:
+        return make_json_response(
+            success=0,
+            errormsg=_("Couldn't find the given server")
+        )
+
+    # To fetch MetaData for the server
+    from pgadmin.utils.driver import get_driver
+    driver = get_driver(PG_DEFAULT_DRIVER)
+    manager = driver.connection_manager(server.id)
+    conn = manager.connection()
+    connected = conn.connected()
+
+    if not connected:
+        return make_json_response(
+            success=0,
+            errormsg=_("Please connect to the server first...")
+        )
+
+    utility = manager.utility('backup_server')
+
+    args = [
+        '--file',
+        data['file'],
+        '--host',
+        server.host,
+        '--port',
+        str(server.port),
+        '--username',
+        server.username,
+        '--no-password',
+        '--database',
+        driver.qtIdent(conn, server.maintenance_db)
+    ]
+    if 'role' in data and data['role']:
+        args.append('--role')
+        args.append(data['role'])
+    if 'verbose' in data and data['verbose']:
+        args.append('--verbose')
+    if 'dqoute' in data and data['dqoute']:
+        args.append('--quote-all-identifiers')
+    if data['type'] == 'global':
+        args.append('--globals-only')
+
+    try:
+        p = BatchProcess(
+            desc=BackupMessage(
+                BACKUP.SERVER if data['type'] != 'global' else BACKUP.GLOBALS,
+                sid
+            ),
+            cmd=utility, args=args
+        )
+        p.start()
+        jid = p.id
+    except Exception as e:
+        current_app.logger.exception(e)
+        return make_json_response(
+            status=410,
+            success=0,
+            errormsg=str(e)
+        )
+    # Return response
+    return make_json_response(
+        data={'job_id': jid, 'success': 1}
+    )
+
+
+@blueprint.route('/create_job/backup_object/<int:sid>', methods=['POST'])
+@login_required
+def create_backup_objects_job(sid):
+    """
+    Args:
+        sid: Server ID
+
+        Creates a new job for backup task (Backup Database(s)/Schema(s)/Table(s))
+
+    Returns:
+        None
+    """
+    if request.form:
+        # Convert ImmutableDict to dict
+        data = dict(request.form)
+        data = json.loads(data['data'][0])
+    else:
+        data = json.loads(request.data.decode())
+
+    data['file'] = filename_with_file_manager_path(data['file'])
+
+    # Fetch the server details like hostname, port, roles etc
+    server = Server.query.filter_by(
+        id=sid, user_id=current_user.id
+    ).first()
+
+    if server is None:
+        return make_json_response(
+            success=0,
+            errormsg=_("Couldn't find the given server")
+        )
+
+    # To fetch MetaData for the server
+    from pgadmin.utils.driver import get_driver
+    driver = get_driver(PG_DEFAULT_DRIVER)
+    manager = driver.connection_manager(server.id)
+    conn = manager.connection()
+    connected = conn.connected()
+
+    if not connected:
+        return make_json_response(
+            success=0,
+            errormsg=_("Please connect to the server first...")
+        )
+
+    utility = manager.utility('backup')
+    args = [
+        '--file',
+        data['file'],
+        '--host',
+        server.host,
+        '--port',
+        str(server.port),
+        '--username',
+        server.username,
+        '--no-password'
+    ]
+
+    def set_param(key, param):
+        if key in data:
+            args.append(param)
+
+    def set_value(key, param, value):
+        if key in data:
+            args.append(param)
+            if value:
+                if value is True:
+                    args.append(param[key])
+                else:
+                    args.append(value)
+
+    set_param('verbose', '--verbose')
+    set_param('dqoute', '--quote-all-identifiers')
+
+    if data['format'] is not None:
+        if data['format'] == 'custom':
+            args.extend(['--format', 'custom'])
+
+            set_param('blobs', '--blobs')
+            set_value('ratio', '--compress', True)
+
+        elif data['format'] == 'tar':
+            args.extend(['--format', 'tar'])
+
+            set_param('blobs', '--blobs')
+
+        elif data['format'] == 'plain':
+            args.extend(['--format', 'plain'])
+            if data['only_data']:
+                args.append('--data-only')
+                set_param('disable_trigger', '--disable-triggers')
+            else:
+                set_param('only_schema', '--schema-only')
+                set_param('dns_owner', '--no-owner')
+                set_param('include_create_database', '--create')
+                set_param('include_drop_database', '--clean')
+        elif data['format'] == 'directory':
+            args.extend(['--format', 'directory'])
+
+    set_param('pre_data', '--section pre-data')
+    set_param('data', '--section data')
+    set_param('post_data', '--section post-data')
+    set_param('dns_privilege', '--no-privileges')
+    set_param('dns_tablespace', '--no-tablespaces')
+    set_param('dns_unlogged_tbl_data', '--no-unlogged-table-data')
+    set_param('use_insert_commands', '--inserts')
+    set_param('use_column_inserts', '--column-inserts')
+    set_param('disable_quoting', '--disable-dollar-quoting')
+    set_param('with_oids', '--oids')
+    set_param('use_set_session_auth', '--use-set-session-authorization')
+
+    set_value('no_of_jobs', '--jobs', True)
+
+    for s in data['schemas']:
+        args.extend(['--schema', driver.qtIdent(conn, s)])
+
+    for s, t in data['tables']:
+        args.extend([
+            '--table', driver.qtIdent(conn, s) + '.' + driver.qtIdent(conn, t)
+        ])
+
+    args.append(driver.qtIdent(conn, data['database']))
+
+    try:
+        p = BatchProcess(
+            desc=BackupMessage(
+                BACKUP.OBJECT,
+                sid, database=data['database']
+            ),
+            cmd=utility, args=args)
+        p.start()
+        jid = p.id
+    except Exception as e:
+        current_app.logger.exception(e)
+        return make_json_response(
+            status=410,
+            success=0,
+            errormsg=str(e)
+        )
+
+    # Return response
+    return make_json_response(
+        data={'job_id': jid, 'Success': 1}
+    )

web/pgadmin/tools/backup/templates/backup/js/backup.js

@@ -0,0 +1,670 @@
+define([
+      'jquery', 'underscore', 'underscore.string', 'alertify',
+      'pgadmin.browser', 'backbone', 'backgrid', 'backform', 'pgadmin.browser.node'
+      ],
+
+  // This defines Backup dialog
+  function($, _, S, alertify, pgBrowser, Backbone, Backgrid, Backform, pgNode) {
+
+    // if module is already initialized, refer to that.
+    if (pgBrowser.Backup) {
+      return pgBrowser.Backup;
+    }
+
+/*
+=====================
+TODO LIST FOR BACKUP:
+=====================
+1) Add Object tree on object tab which allows user to select
+   objects which can be backed up
+2) Allow user to select/deselect objects
+3) If database is selected in browser
+   show all database children objects selected in Object tree
+4) If schema is selected in browser
+   show all schema children objects selected in Object tree
+5) If table is selected then show table/schema/database selected
+   in Object tree
+6) if root objects like database/schema is not selected and their
+   children are selected then add them separately with in tables attribute
+   with schema.
+*/
+
+    var CustomSwitchControl = Backform.CustomSwitchControl = Backform.SwitchControl.extend({
+        template: _.template([
+          '<label class="<%=Backform.controlLabelClassName%> custom_switch_label_class"><%=label%></label>',
+          '<div class="<%=Backform.controlsClassName%> custom_switch_control_class">',
+          '  <div class="checkbox">',
+          '    <label>',
+          '      <input type="checkbox" class="<%=extraClasses.join(\' \')%>"',
+          '        name="<%=name%>" <%=value ? "checked=\'checked\'" : ""%>',
+          '        <%=disabled ? "disabled" : ""%> <%=required ? "required" : ""%> />',
+          '    </label>',
+          '  </div>',
+          '</div>',
+          '<% if (helpMessage && helpMessage.length) { %>',
+          '  <span class="<%=Backform.helpMessageClassName%>"><%=helpMessage%></span>',
+          '<% } %>'
+        ].join("\n")),
+        className: 'pgadmin-control-group form-group col-xs-6'
+    });
+
+    //Backup Model (Server Node)
+    var BackupModel = Backbone.Model.extend({
+      idAttribute: 'id',
+      defaults: {
+        file: undefined,
+        role: undefined,
+        dqoute: false,
+        verbose: true,
+        type: undefined /* global, server */
+      },
+      schema: [{
+        id: 'file', label: '{{ _('Filename') }}',
+        type: 'text', disabled: false, control: Backform.FileControl,
+        dialog_type: 'create_file', supp_types: ['*', 'sql']
+      },{
+        id: 'role', label: '{{ _('Role name') }}',
+        control: 'node-list-by-name', node: 'role',
+        select2: { allowClear: false }
+      },{
+        type: 'nested', control: 'fieldset', label: '{{ _('Miscellaneous') }}',
+        schema:[{
+          id: 'verbose', label: '{{ _('Verbose messages') }}',
+          control: Backform.CustomSwitchControl, disabled: false,
+          group: '{{ _('Miscellaneous') }}'
+        },{
+          id: 'dqoute', label: '{{ _('Force double quote on identifiers') }}',
+          control: Backform.CustomSwitchControl, disabled: false,
+          group: '{{ _('Miscellaneous') }}'
+        }]
+      },{
+        id: 'server_note', label: '{{ _('Note') }}',
+        text: '{{ _('The backup format will be PLAIN') }}',
+        type: 'note', visible: function(m){
+          return m.get('type') === 'server';
+        }
+      },{
+        id: 'globals_note', label: '{{ _('Note') }}',
+        text: '{{ _('Only objects global to the entire database will be backed up in PLAIN format') }}',
+        type: 'note', visible: function(m){
+          return m.get('type') === 'globals';
+        }
+     },{
+     }],
+      validate: function() {
+        // TODO: HOW TO VALIDATE ???
+        return null;
+      }
+    });
+
+    //Backup Model (Objects like Database/Schema/Table)
+    var BackupObjectModel = Backbone.Model.extend({
+      idAttribute: 'id',
+      defaults: {
+        file: undefined,
+        role: 'postgres',
+        format: 'custom',
+        verbose: true,
+        blobs: true,
+        encoding: undefined,
+        schemas: [],
+        tables: [],
+        database: undefined
+      },
+      schema: [{
+        id: 'file', label: '{{ _('Filename') }}',
+        type: 'text', disabled: false, control: Backform.FileControl,
+        dialog_type: 'create_file', supp_types: ['*', 'sql']
+      },{
+        id: 'format', label: '{{ _('Format') }}',
+        type: 'text', disabled: false,
+        control: 'select2', select2: {
+            allowClear: false,
+            width: "100%"
+        },
+        options: [
+          {label: "Custom", value: "custom"},
+          {label: "Tar", value: "tar"},
+          {label: "Plain", value: "plain"},
+          {label: "Directory", value: "directory"}
+        ]
+      },{
+        id: 'ratio', label: '{{ _('Comprasion ratio') }}',
+        type: 'int', min: 0, max:9, disabled: false
+      },{
+        id: 'encoding', label: '{{ _('Encoding') }}',
+        type: 'text', disabled: false,  node: 'database',
+        control: 'node-ajax-options', url: 'get_encodings'
+      },{
+        id: 'no_of_jobs', label: '{{ _('Number of jobs') }}',
+        type: 'int', deps: ['format'], disabled: function(m) {
+          return !(m.get('format') === "Directory");
+        }
+      },{
+        id: 'role', label: '{{ _('Role name') }}',
+        control: 'node-list-by-name', node: 'role',
+        select2: { allowClear: false }
+      },{
+        type: 'nested', control: 'fieldset', label: '{{ _('Sections') }}',
+        group: '{{ _('Dump options') }}',
+        schema:[{
+          id: 'pre_data', label: '{{ _('Pre-data') }}',
+          control: Backform.CustomSwitchControl, group: '{{ _('Sections') }}',
+          deps: ['only_data', 'only_schema'], disabled: function(m) {
+            return m.get('only_data')
+                   || m.get('only_schema');
+          }
+        },{
+          id: 'data', label: '{{ _('Data') }}',
+          control: Backform.CustomSwitchControl, group: '{{ _('Sections') }}',
+          deps: ['only_data', 'only_schema'], disabled: function(m) {
+            return m.get('only_data')
+                   || m.get('only_schema');
+          }
+        },{
+          id: 'post_data', label: '{{ _('Post-data') }}',
+          control: Backform.CustomSwitchControl, group: '{{ _('Sections') }}',
+          deps: ['only_data', 'only_schema'], disabled: function(m) {
+            return m.get('only_data')
+                   || m.get('only_schema');
+          }
+        }]
+      },{
+        type: 'nested', control: 'fieldset', label: '{{ _('Type of objects') }}',
+        group: '{{ _('Dump options') }}',
+        schema:[{
+          id: 'only_data', label: '{{ _('Only data') }}',
+          control: Backform.CustomSwitchControl, group: '{{ _('Type of objects') }}',
+          deps: ['pre_data', 'data', 'post_data','only_schema'], disabled: function(m) {
+            return m.get('pre_data')
+                   || m.get('data')
+                   || m.get('post_data')
+                   || m.get('only_schema');
+          }
+        },{
+          id: 'only_schema', label: '{{ _('Only schema') }}',
+          control: Backform.CustomSwitchControl, group: '{{ _('Type of objects') }}',
+          deps: ['pre_data', 'data', 'post_data', 'only_data'], disabled: function(m) {
+            return m.get('pre_data')
+                   || m.get('data')
+                   || m.get('post_data')
+                   || m.get('only_data');
+          }
+        },{
+          id: 'blobs', label: '{{ _('Blobs') }}',
+          control: Backform.CustomSwitchControl, disabled: false, group: '{{ _('Type of objects') }}'
+        }]
+      },{
+        type: 'nested', control: 'fieldset', label: '{{ _('Do not save') }}',
+        group: '{{ _('Dump options') }}',
+        schema:[{
+          id: 'dns_owner', label: '{{ _('Owner') }}',
+          control: Backform.CustomSwitchControl, disabled: false, group: '{{ _('Do not save') }}'
+        },{
+          id: 'dns_privilege', label: '{{ _('Privilege') }}',
+          control: Backform.CustomSwitchControl, disabled: false, group: '{{ _('Do not save') }}'
+        },{
+          id: 'dns_tablespace', label: '{{ _('Tablespace') }}',
+          control: Backform.CustomSwitchControl, disabled: false, group: '{{ _('Do not save') }}'
+        },{
+          id: 'dns_unlogged_tbl_data', label: '{{ _('Unlogged table data') }}',
+          control: Backform.CustomSwitchControl, disabled: false, group: '{{ _('Do not save') }}'
+        }]
+      },{
+        type: 'nested', control: 'fieldset', label: '{{ _('Queries') }}',
+        group: '{{ _('Dump options') }}',
+        schema:[{
+          id: 'use_column_inserts', label: '{{ _('Use Column Inserts') }}',
+          control: Backform.CustomSwitchControl, disabled: false, group: '{{ _('Queries') }}'
+        },{
+          id: 'use_insert_commands', label: '{{ _('Use Insert Commands') }}',
+          control: Backform.CustomSwitchControl, disabled: false, group: '{{ _('Queries') }}'
+        },{
+          id: 'include_create_database', label: '{{ _('Include CREATE DATABASE statement') }}',
+          control: Backform.CustomSwitchControl, disabled: false, group: '{{ _('Queries') }}'
+        },{
+          id: 'include_drop_database', label: '{{ _('Include DROP DATABASE statement') }}',
+          control: Backform.CustomSwitchControl, disabled: false, group: '{{ _('Queries') }}'
+        }]
+      },{
+        type: 'nested', control: 'fieldset', label: '{{ _('Disable') }}',
+        group: '{{ _('Dump options') }}',
+        schema:[{
+          id: 'disable_trigger', label: '{{ _('Trigger') }}',
+          control: Backform.CustomSwitchControl, group: '{{ _('Disable') }}',
+          deps: ['only_data'], disabled: function(m) {
+            return !(m.get('only_data'));
+          }
+        },{
+          id: 'disable_quoting', label: '{{ _('$ quoting') }}',
+          control: Backform.CustomSwitchControl, disabled: false, group: '{{ _('Disable') }}'
+        }]
+      },{
+        type: 'nested', control: 'fieldset', label: '{{ _('Miscellaneous') }}',
+        group: '{{ _('Dump options') }}',
+        schema:[{
+          id: 'with_oids', label: '{{ _('With OID(s)') }}',
+          control: Backform.CustomSwitchControl, disabled: false, group: '{{ _('Miscellaneous') }}'
+        },{
+          id: 'verbose', label: '{{ _('Verbose messages') }}',
+          control: Backform.CustomSwitchControl, disabled: false, group: '{{ _('Miscellaneous') }}'
+        },{
+          id: 'dqoute', label: '{{ _('Force double quote on identifiers') }}',
+          control: Backform.CustomSwitchControl, disabled: false, group: '{{ _('Miscellaneous') }}'
+        },{
+          id: 'use_set_session_auth', label: '{{ _('Use SET SESSION AUTHORIZATION') }}',
+          control: Backform.CustomSwitchControl, disabled: false, group: '{{ _('Miscellaneous') }}'
+        }]
+      }],
+      validate: function() {
+        return null;
+      }
+    });
+
+    // Create an Object Backup of pgBrowser class
+    pgBrowser.Backup  = {
+      init: function() {
+        if (this.initialized)
+          return;
+
+        this.initialized = true;
+
+        // Define list of nodes on which backup context menu option appears
+        var backup_supported_nodes = [
+              'database', 'schema', 'table'
+            ];
+
+        /**
+          Enable/disable backup menu in tools based
+          on node selected
+          if selected node is present in supported_nodes,
+          menu will be enabled otherwise disabled.
+          Also, hide it for system view in catalogs
+        */
+        menu_enabled = function(itemData, item, data) {
+          var t = pgBrowser.tree, i = item, d = itemData;
+          var parent_item = t.hasParent(i) ? t.parent(i): null,
+              parent_data = parent_item ? t.itemData(parent_item) : null;
+            if(!_.isUndefined(d) && !_.isNull(d) && !_.isNull(parent_data))
+              return (
+                (_.indexOf(backup_supported_nodes, d._type) !== -1 &&
+                parent_data._type != 'catalog') ? true: false
+              );
+            else
+              return false;
+        };
+
+        menu_enabled_server = function(itemData, item, data) {
+          var t = pgBrowser.tree, i = item, d = itemData;
+          var parent_item = t.hasParent(i) ? t.parent(i): null,
+              parent_data = parent_item ? t.itemData(parent_item) : null;
+              // If server node selected && connected
+              if(!_.isUndefined(d) && !_.isNull(d))
+                return (('server' === d._type) && d.connected);
+              else
+                false;
+        };
+
+        // Define the nodes on which the menus to be appear
+        var menus = [{
+          name: 'backup_global', module: this,
+          applies: ['tools'], callback: 'start_backup_global',
+          priority: 10, label: '{{_("Backup Globals...") }}',
+          icon: 'fa fa-floppy-o', enable: menu_enabled_server
+        },{
+          name: 'backup_server', module: this,
+          applies: ['tools'], callback: 'start_backup_server',
+          priority: 10, label: '{{_("Backup Server...") }}',
+          icon: 'fa fa-floppy-o', enable: menu_enabled_server
+        },{
+          name: 'backup_global_ctx', module: this, node: 'server',
+          applies: ['context'], callback: 'start_backup_global',
+          priority: 10, label: '{{_("Backup Globals...") }}',
+          icon: 'fa fa-floppy-o', enable: menu_enabled_server
+        },{
+          name: 'backup_server_ctx', module: this, node: 'server',
+          applies: ['context'], callback: 'start_backup_server',
+          priority: 10, label: '{{_("Backup Server...") }}',
+          icon: 'fa fa-floppy-o', enable: menu_enabled_server
+        },{
+          name: 'backup_object', module: this,
+          applies: ['tools'], callback: 'backup_objects',
+          priority: 10, label: '{{_("Backup...") }}',
+          icon: 'fa fa-floppy-o', enable: menu_enabled
+        }];
+
+        for (var idx = 0; idx < backup_supported_nodes.length; idx++) {
+          menus.push({
+            name: 'backup_' + backup_supported_nodes[idx],
+            node: backup_supported_nodes[idx], module: this,
+            applies: ['context'], callback: 'backup_objects',
+            priority: 10, label: '{{_("Backup...") }}',
+            icon: 'fa fa-floppy-o', enable: menu_enabled
+            });
+        }
+
+        pgAdmin.Browser.add_menus(menus);
+        return this;
+      },
+      start_backup_global: function(action, item) {
+        var params = {'globals': true };
+        this.start_backup_global_server.apply(
+          this, [action, item, params]
+        );
+      },
+      start_backup_server: function(action, item) {
+        var params = {'server': true };
+        this.start_backup_global_server.apply(
+          this, [action, item, params]
+        );
+      },
+
+      // Callback to draw Backup Dialog for globals/server
+      start_backup_global_server: function(action, item, params) {
+
+        var of_type = undefined;
+
+        // Set Notes according to type of backup
+        if (!_.isUndefined(params['globals']) && params['globals']) {
+          of_type = 'globals';
+        } else {
+          of_type = 'server';
+        }
+
+        var DialogName = 'BackupDialog_' + of_type,
+            DialogTitle = ((of_type == 'globals') ?
+              '{{ _('Backup Globals...') }}' :
+              '{{ _('Backup Server...') }}');
+
+        if(!alertify[DialogName]) {
+          alertify.dialog(DialogName ,function factory() {
+            return {
+               main: function(title) {
+                this.set('title', title);
+               },
+               setup:function() {
+                return {
+                  buttons: [{
+                    text: '{{ _('Backup') }}', key: 27, className: 'btn btn-primary fa fa-lg fa-save pg-alertify-button'
+                    },{
+                    text: '{{ _('Cancel') }}', key: 27, className: 'btn btn-danger fa fa-lg fa-times pg-alertify-button'
+                  }],
+                  // Set options for dialog
+                  options: {
+                    title: DialogTitle,
+                    //disable both padding and overflow control.
+                    padding : !1,
+                    overflow: !1,
+                    model: 0,
+                    resizable: true,
+                    maximizable: true,
+                    pinnable: false
+                  }
+                };
+              },
+              hooks: {
+                // Triggered when the dialog is closed
+                onclose: function() {
+                  if (this.view) {
+                    // clear our backform model/view
+                    this.view.remove({data: true, internal: true, silent: true});
+                  }
+                }
+              },
+              prepare: function() {
+                var self = this;
+                // Disable Backup button until user provides Filename
+                this.__internal.buttons[0].element.disabled = true;
+
+                var $container = $("<div class='backup_dialog'></div>");
+                // Find current/selected node
+                var t = pgBrowser.tree,
+                  i = t.selected(),
+                  d = i && i.length == 1 ? t.itemData(i) : undefined,
+                  node = d && pgBrowser.Nodes[d._type];
+
+                if (!d)
+                  return;
+                // Create treeInfo
+                var treeInfo = node.getTreeNodeHierarchy.apply(node, [i]);
+                // Instance of backbone model
+                var newModel = new BackupModel(
+                  {type: of_type}, {node_info: treeInfo}
+                  ),
+                  fields = Backform.generateViewSchema(
+                    treeInfo, newModel, 'create', node, treeInfo.server, true
+                  );
+
+                var view = this.view = new Backform.Dialog({
+                  el: $container, model: newModel, schema: fields
+                });
+                // Add our class to alertify
+                $(this.elements.body.childNodes[0]).addClass(
+                  'alertify_tools_dialog_properties obj_properties'
+                );
+                // Render dialog
+                view.render();
+
+                this.elements.content.appendChild($container.get(0));
+
+                // Listen to model & if filename is provided then enable Backup button
+                this.view.model.on('change', function() {
+                    if (!_.isUndefined(this.get('file')) && this.get('file') !== '') {
+                      this.errorModel.clear();
+                      self.__internal.buttons[0].element.disabled = false;
+                    } else {
+                      self.__internal.buttons[0].element.disabled = true;
+                      this.errorModel.set('file', '{{ _('Please provide filename') }}')
+                    }
+                });
+              },
+              // Callback functions when click on the buttons of the Alertify dialogs
+              callback: function(e) {
+                if (e.button.text === '{{ _('Backup') }}') {
+                  // Fetch current server id
+                  var t = pgBrowser.tree,
+                    i = t.selected(),
+                    d = i && i.length == 1 ? t.itemData(i) : undefined,
+                    node = d && pgBrowser.Nodes[d._type];
+
+                  if (!d)
+                    return;
+
+                  var treeInfo = node.getTreeNodeHierarchy.apply(node, [i]);
+
+                  var self = this,
+                    baseUrl = "{{ url_for('backup.index') }}" +
+                      "create_job/" + treeInfo.server._id,
+                    args =  this.view.model.toJSON();
+
+                  $.ajax({
+                    url: baseUrl,
+                    method: 'POST',
+                    data:{ 'data': JSON.stringify(args) },
+                    success: function(res) {
+                      if (res.success) {
+                        alertify.message('{{ _('Background process for taking backup has been created!') }}', 1);
+                        pgBrowser.Events.trigger('pgadmin-bgprocess:created', self);
+                      }
+                    },
+                    error: function(xhr, status, error) {
+                      try {
+                        var err = $.parseJSON(xhr.responseText);
+                        alertify.alert(
+                          '{{ _('Backup failed...') }}',
+                          err.errormsg
+                        );
+                      } catch (e) {}
+                    }
+                  });
+                }
+              }
+          };
+       });
+      }
+        alertify[DialogName](true).resizeTo('60%','50%');
+     },
+
+      // Callback to draw Backup Dialog for objects
+      backup_objects: function(action, treeItem) {
+        var title = S('{{ 'Backup (%s: %s)' }}'),
+            tree = pgBrowser.tree,
+            item = treeItem || tree.selected(),
+            data = item && item.length == 1 && tree.itemData(item),
+            node = data && data._type && pgBrowser.Nodes[data._type];
+
+        if (!node)
+          return;
+
+        title = title.sprintf(node.label, data.label).value();
+
+        if(!alertify.backup_objects) {
+          // Create Dialog title on the fly with node details
+          alertify.dialog('backup_objects' ,function factory() {
+            return {
+               main: function(title) {
+                this.set('title', title);
+               },
+               setup:function() {
+                return {
+                  buttons: [{
+                    text: '{{ _('Backup') }}', key: 27, className: 'btn btn-primary fa fa-lg fa-save pg-alertify-button'
+                    },{
+                    text: '{{ _('Cancel') }}', key: 27, className: 'btn btn-danger fa fa-lg fa-times pg-alertify-button'
+                  }],
+                  // Set options for dialog
+                  options: {
+                    title: title,
+                    //disable both padding and overflow control.
+                    padding : !1,
+                    overflow: !1,
+                    model: 0,
+                    resizable: true,
+                    maximizable: true,
+                    pinnable: false
+                  }
+                };
+              },
+              hooks: {
+                // triggered when the dialog is closed
+                onclose: function() {
+                  if (this.view) {
+                    this.view.remove({data: true, internal: true, silent: true});
+                  }
+                }
+              },
+              prepare: function() {
+                var self = this;
+                // Disable Backup button until user provides Filename
+                this.__internal.buttons[0].element.disabled = true;
+                var $container = $("<div class='backup_dialog'></div>");
+                var t = pgBrowser.tree,
+                  i = t.selected(),
+                  d = i && i.length == 1 ? t.itemData(i) : undefined,
+                  node = d && pgBrowser.Nodes[d._type];
+
+                if (!d)
+                  return;
+
+                var treeInfo = node.getTreeNodeHierarchy.apply(node, [i]);
+
+                var newModel = new BackupObjectModel(
+                  {}, {node_info: treeInfo}
+                  ),
+                  fields = Backform.generateViewSchema(
+                    treeInfo, newModel, 'create', node, treeInfo.server, true
+                  );
+
+                var view = this.view = new Backform.Dialog({
+                  el: $container, model: newModel, schema: fields
+                });
+
+                $(this.elements.body.childNodes[0]).addClass(
+                  'alertify_tools_dialog_properties obj_properties'
+                );
+
+                view.render();
+
+                this.elements.content.appendChild($container.get(0));
+
+                 // Listen to model & if filename is provided then enable Backup button
+                this.view.model.on('change', function() {
+                    if (!_.isUndefined(this.get('file')) && this.get('file') !== '') {
+                      this.errorModel.clear();
+                      self.__internal.buttons[0].element.disabled = false;
+                    } else {
+                      self.__internal.buttons[0].element.disabled = true;
+                      this.errorModel.set('file', '{{ _('Please provide filename') }}')
+                    }
+                });
+
+              },
+              // Callback functions when click on the buttons of the Alertify dialogs
+              callback: function(e) {
+                if (e.button.text === "Backup") {
+                  // Fetch current server id
+                  var t = pgBrowser.tree,
+                    i = t.selected(),
+                    d = i && i.length == 1 ? t.itemData(i) : undefined,
+                    node = d && pgBrowser.Nodes[d._type];
+
+                  if (!d)
+                    return;
+
+                  var treeInfo = node.getTreeNodeHierarchy.apply(node, [i]);
+
+                  // Set current database into model
+                  this.view.model.set('database', treeInfo.database.label);
+
+                  // We will remove once object tree is implemented
+                  // If selected node is Schema then add it in model
+                  if(d._type == 'schema') {
+                    var schemas = [];
+                    schemas.push(d.label);
+                    this.view.model.set('schemas', schemas);
+                  }
+                  // If selected node is Table then add it in model along with
+                  // its schema
+                  if(d._type == 'table') {
+                    var tables = [],
+                      selected_table = [];
+                    selected_table.push(treeInfo.schema.label)
+                    selected_table.push(d.label);
+                    this.view.model.set('tables', selected_table);
+                  }
+
+                  var self = this,
+                    baseUrl = "{{ url_for('backup.index') }}" +
+                      "create_job/backup_object/" + treeInfo.server._id,
+                      args =  this.view.model.toJSON();
+
+                  $.ajax({
+                    url: baseUrl,
+                    method: 'POST',
+                    data:{ 'data': JSON.stringify(args) },
+                    success: function(res) {
+                      if (res.success) {
+                        alertify.message('{{ _('Background process for taking backup has been created!') }}', 1);
+                        pgBrowser.Events.trigger('pgadmin-bgprocess:created', self);
+                      }
+                    },
+                    error: function(xhr, status, error) {
+                      try {
+                        var err = $.parseJSON(xhr.responseText);
+                        alertify.alert(
+                          '{{ _('Backup failed...') }}',
+                          err.errormsg
+                        );
+                      } catch (e) {}
+                    }
+                  });
+                }
+             }
+          };
+        });
+      }
+      alertify.backup_objects(title).resizeTo('65%','60%');
+      }
+    };
+    return pgBrowser.Backup;
+  });