def __init__(self, options={}):
"""Constructor
options[in] Array of options for controlling what is included
and how operations perform (e.g., verbose)
"""
Console.__init__(self, _NEW_BASE_COMMANDS, options)
try:
from mysql.utilities.common.utilities import get_util_path
path = get_util_path(options.get("utildir", ""))
if path is None:
raise
except:
raise UtilError(_UTILS_MISSING)
self.utils = Utilities(options)
if self.quiet:
self.f_out = tempfile.NamedTemporaryFile(delete=False)
print "Quiet mode, saving output to %s" % self.f_out.name
else:
self.f_out = None
def __init__(self, options=None):
"""Constructor
options[in] Array of options for controlling what is included
and how operations perform (e.g., verbose)
"""
if options is None:
options = {}
Console.__init__(self, _NEW_BASE_COMMANDS, options)
try:
self.path = get_util_path(options.get("utildir", ""))
if self.path is None:
raise
except:
raise UtilError(_UTILS_MISSING)
self.utils = Utilities(options)
self.errors = []
if self.quiet:
self.f_out = tempfile.NamedTemporaryFile(delete=False)
print("Quiet mode, saving output to {0}".format(self.f_out.name))
else:
self.f_out = None
def __init__(self, options={}):
"""Constructor
options[in] Array of options for controlling what is included
and how operations perform (e.g., verbose)
"""
Console.__init__(self, _NEW_BASE_COMMANDS, options)
try:
from mysql.utilities.common.utilities import get_util_path
path = get_util_path(options.get("utildir", ""))
if path is None:
raise
except:
raise UtilError(_UTILS_MISSING)
self.utils = Utilities(options)
if self.quiet:
self.f_out = tempfile.NamedTemporaryFile(delete=False)
print "Quiet mode, saving output to %s" % self.f_out.name
else:
self.f_out = None
class UtilitiesConsole(Console):
"""
The UtilitiesConsole class creates a console for running MySQL Utilities.
This class uses the Console class to encapsulate the screen handling and
key captures for a command line shell. This subclass provides the custom
commands (the utilities) to the console class for redirecting to the
methods contained in this class for executing utilities. These include:
- matching command from the shell to available utilities
- matching options from the shell to the options for a given utility
- showing the help for a utility
"""
def __init__(self, options=None):
"""Constructor
options[in] Array of options for controlling what is included
and how operations perform (e.g., verbose)
"""
if options is None:
options = {}
Console.__init__(self, _NEW_BASE_COMMANDS, options)
try:
self.path = get_util_path(options.get("utildir", ""))
if self.path is None:
raise
except:
raise UtilError(_UTILS_MISSING)
self.utils = Utilities(options)
self.errors = []
if self.quiet:
self.f_out = tempfile.NamedTemporaryFile(delete=False)
print("Quiet mode, saving output to {0}".format(self.f_out.name))
else:
self.f_out = None
def show_custom_command_help(self, arg):
"""Display the help for a utility
This method will display a list of the available utilities if the
command argument is 'utilities' or the help for a specific utility if
the command argument is the name of a known utility.
arg[in] Help command argument
"""
if self.quiet:
return
if arg and arg.lower() == 'utilities':
self.utils.show_utilities()
else:
matches = self.utils.get_util_matches(arg)
if len(matches) > 1:
self.utils.show_utilities(matches)
elif len(matches) == 1:
self.show_utility_help(matches)
else:
print("\n\nCannot find utility '{0}'.\n".format(arg))
def do_custom_tab(self, prefix):
"""Do custom tab key processing
This method performs the tab completion for a utility name. It searches
the available utilties for the prefix of the utility name. If an exact
match is found, it updates the command else it returns a list of
matches.
If the user has pressed TAB twice, it will display a list of all of
the utilities available.
prefix[in] Prefix of the utility name
"""
new_cmd = '' # blank string means no matches
find_cmd = prefix
if len(prefix) >= 5 and prefix[0:5] != 'mysql':
find_cmd = 'mysql' + find_cmd
matches = self.utils.get_util_matches(find_cmd)
if self.tab_count == 2:
self.utils.show_utilities(matches)
self.cmd_line.display_command()
self.tab_count = 0
# Do command completion here
elif len(matches) == 1:
new_cmd = matches[0]['name'] + ' '
start = len(prefix)
if prefix[0:5] != 'mysql':
start += 5
self.cmd_line.add(new_cmd[start:])
self.tab_count = 0
def do_custom_option_tab(self, command_text):
"""Do custom option tab key processing
This method performs the tab completion for the options for a utility.
It splits the command text into the utility name and requests the
option prefix from the command line.
If the user presses TAB twice, the method will display all of the
options for the specified utility.
command_text[in] Portion of command from the position of the cursor
Returns string - '' if not found, the remaining portion of the match
of the option if found (for example, we look for
'--verb' and find '--verbose' so we return 'ose').
"""
option_loc = 0
option = ''
cmd_len = len(command_text)
full_command = self.cmd_line.get_command()
# find utility name
i = full_command.find(' ')
if i < 0:
return # This may be an error!
util_name = full_command[0:i]
# get utility information
utils = self.utils.get_util_matches(util_name)
if len(utils) <= 0:
return '' # No option found because util does not exist.
# if double tab with no option specified, show all options
if cmd_len == 0 and self.tab_count == 2:
self.utils.show_options(utils[0])
self.cmd_line.display_command()
self.tab_count = 0
return
find_alias = False
if len(command_text) == 0:
option_loc = 0
# check for - or --
elif command_text[0:2] == '--':
option_loc = 2
elif command_text[0] == '-':
option_loc = 1
find_alias = True
option = command_text[option_loc:]
matches = self.utils.get_option_matches(utils[0], option, find_alias)
if self.tab_count == 2:
if len(matches) > 0:
self.utils.show_options(matches)
self.cmd_line.display_command()
self.tab_count = 0
return
# Do option completion here
if len(matches) == 1:
if not find_alias:
opt_name = matches[0]['name']
# Check for required value
if matches[0]['req_value']:
opt_name += '='
else:
opt_name += ' '
else: # using alias
opt_name = matches[0]['alias'] + ' '
# Now, replace the old value on the command line.
start = len(command_text) - option_loc
self.cmd_line.add(opt_name[start:].strip(' '))
self.tab_count = 0
def show_utility_help(self, utils):
"""Display help for a utility.
utils[in] The utility name.
"""
if self.quiet:
return
options = self.utils.get_options_dictionary(utils[0])
print("\n{0}\n".format(utils[0]['usage']))
print("{0} - {1}\n".format(utils[0]['name'], utils[0]['description']))
print("Options:")
print_dictionary_list(['Option', 'Description'],
['long_name', 'description'],
options, self.width, False)
print
def is_valid_custom_command(self, command_text): # pylint: disable=W0221
"""Validate the custom command
If the command_text is the name of a utility supported, return True
else return False.
command_text[in] Command from the user
Returns bool - True - valid, False - invalid
"""
parts = command_text.split(' ')
matches = self.utils.get_util_matches(parts[0])
return len(matches) >= 1
def execute_custom_command(self, command, parameters):
"""Execute the utility
This method executes the utility with the parameters specified by the
user. All output is displayed and control returns to the console class.
command[in] Name of the utility to execute
parameters[in] All options and parameters specified by the user
"""
if not command.lower().startswith('mysql'):
command = 'mysql' + command
# look in to the collected utilities
for util_info in self.utils.util_list:
if util_info["name"] == command:
# Get the command used to obtain the help from the utility
cmd = list(util_info["cmd"])
cmd.extend(parameters)
# Add quotes for Windows
if (os.name == "nt"):
# If there is a space in the command, quote it!
if (" " in cmd[0]):
cmd[0] = '"{0}"'.format(cmd[0])
# if cmd is freeze code utility, subprocess just need the
# executable part not absolute path using shell=False or
# Windows will complain about the path. The base path of
# mysqluc is used as location dir base of the subprocess.
if '.exe' in cmd[0]:
_, ut_cmd = os.path.split(cmd[0])
cmd[0] = ut_cmd.replace('"', '')
# If the second part has .py in it and spaces, quote it!
if len(cmd) > 1 and (" " in cmd[1]) and ('.py' in cmd[0]):
cmd[1] = '"{0}"'.format(cmd[1])
if self.quiet:
proc = subprocess.Popen(cmd, shell=False,
stdout=self.f_out,
stderr=self.f_out)
else:
proc = subprocess.Popen(cmd, shell=False,
stderr=subprocess.PIPE)
print
# check the output for errors
_, stderr_temp = proc.communicate()
return_code = proc.returncode
err_msg = ("\nThe console has detected that the utility '{0}' "
"ended with an error code.\nYou can get more "
"information about the error by running the console"
" command 'show last error'.").format(command)
if not self.quiet and return_code and stderr_temp:
print(err_msg)
if parameters:
msg = ("\nExecution of utility: '{0} {1}' ended with "
"return code '{2}' and with the following "
"error message:\n"
"{3}").format(command, ' '.join(parameters),
return_code, stderr_temp)
else:
msg = ("\nExecution of utility: '{0}' ended with "
"return code '{1}' and with the following "
"error message:\n{2}").format(command,
return_code,
stderr_temp)
self.errors.append(msg)
elif not self.quiet and return_code:
if parameters:
msg = ("\nExecution of utility: '{0} {1}' ended with "
"return code '{2}' but no error message was "
"streamed to the standard error, please review "
"the output from its execution."
"").format(command, ' '.join(parameters),
return_code)
else:
msg = ("\nExecution of utility: '{0}' ended with "
"return code '{1}' but no error message was "
"streamed to the standard error, please review "
"the output from its execution."
"").format(command, return_code)
print(msg)
return
# if got here, is because the utility was not found.
raise UtilError("The utility {0} is not accessible (from the path: "
"{1}).".format(command, self.path))
def show_custom_options(self):
"""Show all of the options for the mysqluc utility.
This method reads all of the options specified when mysqluc was
launched and displays them to the user. If none were specified, a
message is displayed instead.
"""
if self.quiet:
return
if len(self.options) == 0:
print("\n\nNo options specified.\n")
return
# Build a new list that normalizes the options as a dictionary
dictionary_list = []
for key in self.options.keys():
# Skip variables list and messages
if not key in ['variables', 'welcome', 'goodbye']:
value = self.options.get(key, '')
item = {
'name': key,
'value': value
}
dictionary_list.append(item)
print
print
print_dictionary_list(['Option', 'Value'], ['name', 'value'],
dictionary_list, self.width)
print
class UtilitiesConsole(Console):
"""
The UtilitiesConsole class creates a console for running MySQL Utilities.
This class uses the Console class to encapsulate the screen handling and
key captures for a command line shell. This subclass provides the custom
commands (the utilities) to the console class for redirecting to the
methods contained in this class for executing utilities. These include:
- matching command from the shell to available utilities
- matching options from the shell to the options for a given utility
- showing the help for a utility
"""
def __init__(self, options={}):
"""Constructor
options[in] Array of options for controlling what is included
and how operations perform (e.g., verbose)
"""
Console.__init__(self, _NEW_BASE_COMMANDS, options)
try:
from mysql.utilities.common.utilities import get_util_path
path = get_util_path(options.get("utildir", ""))
if path is None:
raise
except:
raise UtilError(_UTILS_MISSING)
self.utils = Utilities(options)
if self.quiet:
self.f_out = tempfile.NamedTemporaryFile(delete=False)
print "Quiet mode, saving output to %s" % self.f_out.name
else:
self.f_out = None
def show_custom_command_help(self, arg):
"""Display the help for a utility
This method will display a list of the available utilities if the
command argument is 'utilities' or the help for a specific utility if
the command argument is the name of a known utility.
arg[in] Help command argument
"""
if self.quiet:
return
if arg and arg.lower() == 'utilities':
self.utils.show_utilities()
else:
matches = self.utils.get_util_matches(arg)
if len(matches) > 1:
self.utils.show_utilities(matches)
elif len(matches) == 1:
self.show_utility_help(matches)
else:
print "\n\nCannot find utility '%s'.\n" % arg
def do_custom_tab(self, prefix):
"""Do custom tab key processing
This method performs the tab completion for a utility name. It searches
the available utilties for the prefix of the utility name. If an exact
match is found, it updates the command else it returns a list of
matches.
If the user has pressed TAB twice, it will display a list of all of
the utilities available.
prefix[in] Prefix of the utility name
"""
new_cmd = '' # blank string means no matches
find_cmd = prefix
if len(prefix) >= 5 and prefix[0:5] != 'mysql':
find_cmd = 'mysql' + find_cmd
matches = self.utils.get_util_matches(find_cmd)
if self.tab_count == 2:
self.utils.show_utilities(matches)
self.cmd_line.display_command()
self.tab_count = 0
# Do command completion here
elif len(matches) == 1:
new_cmd = matches[0]['name'] + ' '
start = len(prefix)
if prefix[0:5] != 'mysql':
start += 5
self.cmd_line.add(new_cmd[start:])
self.tab_count = 0
def do_custom_option_tab(self, command_text):
"""Do custom option tab key processing
This method performs the tab completion for the options for a utility.
It splits the command text into the utility name and requests the
option prefix from the command line.
If the user presses TAB twice, the method will display all of the
options for the specified utility.
command_text[in] Portion of command from the position of the cursor
Returns string - '' if not found, the remaining portion of the match
of the option if found (for example, we look for
'--verb' and find '--verbose' so we return 'ose').
"""
new_cmd = '' # blank string means no matches
option_loc = 0
option = ''
cmd_len = len(command_text)
full_command = self.cmd_line.get_command()
# find utility name
i = full_command.find(' ')
if i < 0:
return # This may be an error!
util_name = full_command[0:i]
# get utility information
utils = self.utils.get_util_matches(util_name)
if len(utils) <= 0:
return '' # No option found because util does not exist.
# if double tab with no option specified, show all options
if cmd_len == 0 and self.tab_count == 2:
self.utils.show_options(utils[0]['options'])
self.cmd_line.display_command()
self.tab_count = 0
return
find_alias = False
if len(command_text) == 0:
option_loc = 0
# check for - or --
elif command_text[0:2] == '--':
option_loc = 2
elif command_text[0] == '-':
option_loc = 1
find_alias = True
option = command_text[option_loc:]
matches = self.utils.get_option_matches(utils[0], option, find_alias)
if self.tab_count == 2:
if len(matches) > 0:
self.utils.show_options(matches)
self.cmd_line.display_command()
self.tab_count = 0
return
# Do option completion here
if len(matches) == 1:
if not find_alias:
opt_name = matches[0]['name']
# Check for required value
if matches[0]['req_value']:
opt_name += '='
else:
opt_name += ' '
else: # using alias
opt_name = matches[0]['alias'] + ' '
# Now, replace the old value on the command line.
start = len(command_text) - option_loc
self.cmd_line.add(opt_name[start:].strip(' '))
self.tab_count = 0
def show_utility_help(self, utils):
"""Display help for a utility.
utils[in] The utility name.
"""
if self.quiet:
return
options = self.utils.get_options_dictionary(utils[0]['options'])
print "\n%s\n" % utils[0]['usage']
print "%s - %s\n" % (utils[0]['name'], utils[0]['description'])
print "Options:"
print_dictionary_list(['Option', 'Description'],
['long_name', 'description'], options,
self.width, False)
print
def is_valid_custom_command(self, command_text):
"""Validate the custom command
If the command_text is the name of a utility supported, return True
else return False.
command_text[in] Command from the user
Returns bool - True - valid, False - invalid
"""
parts = command_text.split(' ')
matches = self.utils.get_util_matches(parts[0])
return len(matches) >= 1
def execute_custom_command(self, command, parameters):
"""Execute the utility
This method executes the utility with the parameters specified by the
user. All output is displayed and control returns to the console class.
command[in] Name of the utility to execute
parameters[in] All options and parameters specified by the user
"""
if not command.lower().startswith('mysql'):
command = 'mysql' + command
# Search for the utility to execute (matching the command)
path = os.path.normpath(self.utils.util_path)
utility_path = os.path.join(path, command)
util_found = False
# If not exist without ext we try adding one.
if os.path.isfile(utility_path):
util_found = True
else:
parts = os.path.splitext(command)
if parts[1] == "":
exts = [command + '.py', command + '.exe']
for ext in exts:
utility_path = os.path.join(path, ext)
if os.path.isfile(utility_path):
util_found = True
break
if not util_found:
raise UtilError("The utility %s is not accessible (from the path: "
"%s)." % (command, path))
cmd = []
# In cases where the utility does not have permissions to execute,
# the use of the interpreter is necessary
if '.py' in utility_path or not '.exe' in utility_path:
cmd.append('python ')
cmd += ['"', utility_path, '"', ' ', parameters]
if self.quiet:
proc = subprocess.Popen("".join(cmd),
shell=True,
stdout=self.f_out,
stderr=self.f_out)
else:
print
proc = subprocess.Popen("".join(cmd), shell=True)
res = proc.wait()
def show_custom_options(self):
"""Show all of the options for the mysqluc utility.
This method reads all of the options specified when mysqluc was
launched and displays them to the user. If none were specified, a
message is displayed instead.
"""
if self.quiet:
return
if len(self.options) == 0:
print "\n\nNo options specified.\n"
return
# Build a new list that normalizes the options as a dictionary
dictionary_list = []
for key in self.options.keys():
# Skip variables list and messages
if not key in ['variables', 'welcome', 'goodbye']:
value = self.options.get(key, '')
item = {'name': key, 'value': value}
dictionary_list.append(item)
print
print
print_dictionary_list(['Option', 'Value'], ['name', 'value'],
dictionary_list, self.width)
print
class UtilitiesConsole(Console):
"""
The UtilitiesConsole class creates a console for running MySQL Utilities.
This class uses the Console class to encapsulate the screen handling and
key captures for a command line shell. This subclass provides the custom
commands (the utilities) to the console class for redirecting to the
methods contained in this class for executing utilities. These include:
- matching command from the shell to available utilities
- matching options from the shell to the options for a given utility
- showing the help for a utility
"""
def __init__(self, options={}):
"""Constructor
options[in] Array of options for controlling what is included
and how operations perform (e.g., verbose)
"""
Console.__init__(self, _NEW_BASE_COMMANDS, options)
try:
from mysql.utilities.common.utilities import get_util_path
path = get_util_path(options.get("utildir", ""))
if path is None:
raise
except:
raise UtilError(_UTILS_MISSING)
self.utils = Utilities(options)
if self.quiet:
self.f_out = tempfile.NamedTemporaryFile(delete=False)
print "Quiet mode, saving output to %s" % self.f_out.name
else:
self.f_out = None
def show_custom_command_help(self, arg):
"""Display the help for a utility
This method will display a list of the available utilities if the
command argument is 'utilities' or the help for a specific utility if
the command argument is the name of a known utility.
arg[in] Help command argument
"""
if self.quiet:
return
if arg and arg.lower() == 'utilities':
self.utils.show_utilities()
else:
matches = self.utils.get_util_matches(arg)
if len(matches) > 1:
self.utils.show_utilities(matches)
elif len(matches) == 1:
self.show_utility_help(matches)
else:
print "\n\nCannot find utility '%s'.\n" % arg
def do_custom_tab(self, prefix):
"""Do custom tab key processing
This method performs the tab completion for a utility name. It searches
the available utilties for the prefix of the utility name. If an exact
match is found, it updates the command else it returns a list of
matches.
If the user has pressed TAB twice, it will display a list of all of
the utilities available.
prefix[in] Prefix of the utility name
"""
new_cmd = '' # blank string means no matches
find_cmd = prefix
if len(prefix) >= 5 and prefix[0:5] != 'mysql':
find_cmd = 'mysql' + find_cmd
matches = self.utils.get_util_matches(find_cmd)
if self.tab_count == 2:
self.utils.show_utilities(matches)
self.cmd_line.display_command()
self.tab_count = 0
# Do command completion here
elif len(matches) == 1:
new_cmd = matches[0]['name'] + ' '
start = len(prefix)
if prefix[0:5] != 'mysql':
start += 5
self.cmd_line.add(new_cmd[start:])
self.tab_count = 0
def do_custom_option_tab(self, command_text):
"""Do custom option tab key processing
This method performs the tab completion for the options for a utility.
It splits the command text into the utility name and requests the
option prefix from the command line.
If the user presses TAB twice, the method will display all of the
options for the specified utility.
command_text[in] Portion of command from the position of the cursor
Returns string - '' if not found, the remaining portion of the match
of the option if found (for example, we look for
'--verb' and find '--verbose' so we return 'ose').
"""
new_cmd = '' # blank string means no matches
option_loc = 0
option = ''
cmd_len = len(command_text)
full_command = self.cmd_line.get_command()
# find utility name
i = full_command.find(' ')
if i < 0:
return # This may be an error!
util_name = full_command[0:i]
# get utility information
utils = self.utils.get_util_matches(util_name)
if len(utils) <= 0:
return '' # No option found because util does not exist.
# if double tab with no option specified, show all options
if cmd_len == 0 and self.tab_count == 2:
self.utils.show_options(utils[0]['options'])
self.cmd_line.display_command()
self.tab_count = 0
return
find_alias = False
if len(command_text) == 0:
option_loc = 0
# check for - or --
elif command_text[0:2] == '--':
option_loc = 2
elif command_text[0] == '-':
option_loc = 1
find_alias = True
option = command_text[option_loc:]
matches = self.utils.get_option_matches(utils[0], option, find_alias)
if self.tab_count == 2:
if len(matches) > 0:
self.utils.show_options(matches)
self.cmd_line.display_command()
self.tab_count = 0
return
# Do option completion here
if len(matches) == 1:
if not find_alias:
opt_name = matches[0]['name']
# Check for required value
if matches[0]['req_value']:
opt_name += '='
else:
opt_name += ' '
else: # using alias
opt_name = matches[0]['alias'] + ' '
# Now, replace the old value on the command line.
start = len(command_text) - option_loc
self.cmd_line.add(opt_name[start:].strip(' '))
self.tab_count = 0
def show_utility_help(self, utils):
"""Display help for a utility.
utils[in] The utility name.
"""
if self.quiet:
return
options = self.utils.get_options_dictionary(utils[0]['options'])
print "\n%s\n" % utils[0]['usage']
print "%s - %s\n" % (utils[0]['name'], utils[0]['description'])
print "Options:"
print_dictionary_list(['Option', 'Description'],
['long_name', 'description'],
options, self.width, False)
print
def is_valid_custom_command(self, command_text):
"""Validate the custom command
If the command_text is the name of a utility supported, return True
else return False.
command_text[in] Command from the user
Returns bool - True - valid, False - invalid
"""
parts = command_text.split(' ')
matches = self.utils.get_util_matches(parts[0])
return len(matches) >= 1
def execute_custom_command(self, command, parameters):
"""Execute the utility
This method executes the utility with the parameters specified by the
user. All output is displayed and control returns to the console class.
command[in] Name of the utility to execute
parameters[in] All options and parameters specified by the user
"""
if not command.lower().startswith('mysql'):
command = 'mysql' + command
# Search for the utility to execute (matching the command)
path = os.path.normpath(self.utils.util_path)
utility_path = os.path.join(path, command)
util_found = False
# If not exist without ext we try adding one.
if os.path.isfile(utility_path):
util_found = True
else:
parts = os.path.splitext(command)
if parts[1] == "":
exts = [command+'.py', command+'.exe']
for ext in exts:
utility_path = os.path.join(path, ext)
if os.path.isfile(utility_path):
util_found = True
break
if not util_found:
raise UtilError("The utility %s is not accessible (from the path: "
"%s)." % (command, path))
cmd = []
# In cases where the utility does not have permissions to execute,
# the use of the interpreter is necessary
if '.py' in utility_path or not '.exe' in utility_path:
cmd.append('python ')
cmd += ['"', utility_path, '"', ' ', parameters]
if self.quiet:
proc = subprocess.Popen("".join(cmd), shell=True,
stdout=self.f_out, stderr=self.f_out)
else:
print
proc = subprocess.Popen("".join(cmd), shell=True)
res = proc.wait()
def show_custom_options(self):
"""Show all of the options for the mysqluc utility.
This method reads all of the options specified when mysqluc was
launched and displays them to the user. If none were specified, a
message is displayed instead.
"""
if self.quiet:
return
if len(self.options) == 0:
print "\n\nNo options specified.\n"
return
# Build a new list that normalizes the options as a dictionary
dictionary_list = []
for key in self.options.keys():
# Skip variables list and messages
if not key in ['variables', 'welcome', 'goodbye']:
value = self.options.get(key, '')
item = {
'name' : key,
'value' : value
}
dictionary_list.append(item)
print
print
print_dictionary_list(['Option', 'Value'], ['name', 'value'],
dictionary_list, self.width)
print
