# Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved. # # This program is free software; you can redistribute it and/or # modify it under the terms of the GNU General Public License as # published by the Free Software Foundation; version 2 of the # License. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA # 02110-1301 USA from wb import DefineModule import grt from grt import log_warning import mforms import traceback import time import json from wb_common import OperationCancelledError fabric_unavailable_message = "" fabric_client = "" ModuleInfo = DefineModule(name= "WBFabric", author= "Oracle Corp.", version="1.0") def perform_fabric_operation(conn, name, callback = None, callback_params = None): """ Current Fabric operations are done using the next cycle: - Open Connection - Execute Specific Operation - Close Connection This method allows performing these operations using this life cycle, removing from the specific operation the burden of common operations such as password retrieval and exception handling. The specific operation should be done on a function received as callback. To pass data from the caller to the actual Fabric operation method use the callback_params, this method will also include the connection_id on such params. """ error = "" # Retrieves the Fabric node connection data host = conn.parameterValues["hostName"] port = conn.parameterValues["port"] user = conn.parameterValues["userName"] try: # Retrieves the required password accepted, password = mforms.Utilities.find_or_ask_for_password("Fabric Node Connection", '%s@%s' % (host, port), user, False) if accepted: # Opens a connection to the Fabric instance conn_id = grt.modules.WbFabricInterface.openConnection(conn, password) if conn_id > 0: # Executes the callback function which will interact with Fabric using the # created connection. if callback: if callback_params: callback_params['conn_id'] = conn_id else: callback_params = {'conn_id':conn_id} error = callback(callback_params) # Finally closes the connection grt.modules.WbFabricInterface.closeConnection(conn_id) except OperationCancelledError, e: error = "Operation Cancelled" log_warning("WBFabric Module", "User cancelled %s\n" % name) except Exception, e: error = str(e) log_warning("WBFabric Module", "Error %s : %s\n" % (conn.name, traceback.format_exc())) return error def _execute_fabric_command(conn_id, fabric_command): """ This function will be used to actually execute a valid Fabric command and process the result. The data resulting from Fabric operations is returned in JSON format. The Fabric commands will return 2 recordsets which are returned as 2 lists on the returned json data: - The first element is a status record, it is processed here and if there were errors an exception is thrown. - The second is the actual list of data returned by the executed function. """ return_data = None out = grt.modules.WbFabricInterface.execute(conn_id, fabric_command) all_data = json.loads(out) status = all_data[0][0] if status['message']: raise Exception(status['message']) elif len(all_data) == 2: return_data = all_data[1] return return_data def _get_managed_connections(conn): connections = {} for connection in grt.root.wb.rdbmsMgmt.storedConns: params = connection.parameterValues if params.has_key('fabric_managed') and params['fabric_managed'] == conn.__id__: mparams = connection.parameterValues address = "%s:%s" % (mparams['hostName'], mparams['port']) connections[address] = connection return connections def _update_fabric_connections(params): error = '' conn = params['conn'] conn_id = params['conn_id'] # Pulls the HA groups groups = _execute_fabric_command(conn_id, 'call group.lookup_groups()') # Variables for error handling fabric_group_count = 0 matched_groups = [] added_servers = 0 managed_connections = 0 # Sorts the groups def group_key(item): return item['group_id'] groups = sorted(groups, key=group_key) fabric_group_count = len(groups) group_filter = conn.parameterValues["haGroupFilter"].strip() # Retrieves the list of the existing managed connections existing_connections = _get_managed_connections(conn) for group in groups: include_group = not group_filter or group['group_id'] in group_filter if include_group: matched_groups.append(group['group_id']) servers = _execute_fabric_command(conn_id, 'call group.lookup_servers("%s")' % group['group_id']) # Sorts the servers def server_key(item): return item['address'] servers = sorted(servers, key=server_key) # Creates a connection for each retrieved server. for server in servers: address = server['address'] host, port = address.split(':') # If the managed servers are located on the Fabric node # most probably they will use localhost or 127.0.0.1 as # address on the Fabric configuration. # We need to replace that for the Fabric node IP in order # to create the connections in WB if host in ['localhost', '127.0.0.1']: host = conn.parameterValues["hostName"] address = '%s:%s' % (host, port) managed_connections += 1 managed_conn = None if existing_connections.has_key(address): managed_conn = existing_connections[address] del existing_connections[address] else: child_conn_name = '%s/%s:%s' % (conn.name, host, port) server_user = conn.parameterValues["mysqlUserName"] managed_conn = grt.modules.Workbench.create_connection(host, server_user, '', 1, 0, int(port), child_conn_name) added_servers += 1 # Update connection settings managed_conn.parameterValues["fabric_managed"] = conn.__id__ managed_conn.parameterValues["fabric_group_id"] = group["group_id"] # Includes the rest of the server parameters on the connection parameters for att in server.keys(): if att != 'address': managed_conn.parameterValues['fabric_%s' % att] = server[att] # Removes the remaining connections (which no longer exist on the Fabric node) for connection in existing_connections.values(): grt.modules.Workbench.deleteConnection(connection) conn.parameterValues["managedConnectionsUpdateTime"] = time.strftime('%Y-%m-%d %H:%M:%S') if added_servers or existing_connections: grt.modules.Workbench.refreshHomeConnections() elif managed_connections == 0: if fabric_group_count == 0: error = "There are no High Availability Groups defined on the %s Fabric node." % conn.name elif not matched_groups: error = "There are no High Availability Groups matching the configured group filter on %s." % conn.name else: error = "There are no Managed Servers defined for the included groups in %s: %s." % (conn.name, ','.join(matched_groups)) return error @ModuleInfo.export(grt.STRING, grt.classes.db_mgmt_Connection) def testConnection(conn): """ Attempts a connection to the Fabric server; returns an error if required. Since no additional operations are needed on such a connection, the specific operation callback is None. """ error = perform_fabric_operation(conn, 'testing Fabric Connection') return error @ModuleInfo.export(grt.STRING, grt.classes.db_mgmt_Connection) def updateConnections(conn): """ Connects to the Fabric server and updates the Fabric connections in WB """ error = perform_fabric_operation(conn, 'updating Fabric Servers', _update_fabric_connections, {'conn':conn} ) return error