| Server IP : 134.29.175.74 / Your IP : 216.73.216.160 Web Server : nginx/1.10.2 System : Windows NT CST-WEBSERVER 10.0 build 19045 (Windows 10) i586 User : Administrator ( 0) PHP Version : 7.1.0 Disable Function : NONE MySQL : OFF | cURL : ON | WGET : OFF | Perl : OFF | Python : OFF | Sudo : OFF | Pkexec : OFF Directory : /Program Files/MySQL/MySQL Workbench 6.3 CE/modules/ |
Upload File : |
# 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