On 06/25/2012 03:00 PM, Petr Viktorin wrote:
On 06/20/2012 06:15 PM, Rob Crittenden wrote:
Petr Viktorin wrote:
On 06/04/2012 04:56 PM, Petr Viktorin wrote:
Currently, FreeIPA's install/admin scripts are long pieces of code
that aren't very reusable, importable, or testable.
They have been extended over time with features such as logging and
error handling, but since each tool was extended individually, there
is much inconsistency and code duplication.
This patch starts a framework which the admin tools can use, and
converts ipa-ldap-updater to use the framework.
In an earlier patch I found that improving a particular
functionality in
all the commands is not workable, so I want to tackle this one tool
at a
time.
I'm starting with ipa-ldap-updater, because it's pretty small, doesn't
use DNs (I don't want conflicts with John's work), and has the
interesting --upgrade option.
The framework does these tasks:
- Parse options
- Select tool to run (see below)
- Validate options
- Set up logging
- Run the tool code
- Handle any errors
- Log success/failure
The base class has some defaults for these that the tools can
extend/override.
To handle the case where one script does two different things
(ipa-ldap-updater with/without --upgrade, or ipa-server-install
with/without --uninstall), I want to split the tool in two classes
rather than have repeated ifs in the code.
This meant that option parsing (and initializing the parser) has to be
done before creating an instance of the tool. I use a factory
classmethod.
I put the admintool base class in ipapython/ as it should be useful for
ipa-client-install as well.
First part of the work for:
https://fedorahosted.org/freeipa/ticket/2652
Attaching rebased patch.
I gather you want people to be calling run_cli() in their admin tools.
Should main() be made private then? I could see someone getting confused
and using main instead, which would work, but then the return value
might not do the right thing.
Or maybe just drop run_cli and have main exit with sys.exit()?
I don't see why running a command as a Python function should be
discouraged. In fact it could even help -- for example logging could
only be set up once, so if we call, say, ipa-ldap-updater from
ipa-server-install, all related logs would go to a single file.
A C-style main (taking a list of arguments and returning the exit
status) is a good thing for modularity and testability.
The `run_cli` method is just a convenient shortcut for the usual usage,
so the calling modules can be as small as possible.
If people get confused and call main instead of run_cli, they need to
manually pass in sys.argv. I think this is enough of a warning that
their assumptions aren't right.
To make it even clearer I've removed the possibility to pass None as
argv to main() and have it auto-filled.
Some relevant reading:
http://www.artima.com/weblogs/viewpost.jsp?thread=4829 (old but still
valid)
http://en.wikipedia.org/wiki/Main_function#Python
It isn't correctly handling the case of an update not found:
ipa : INFO Parsing file ad
[Errno 2] No such file or directory: 'ad'
ipa : INFO File
"/usr/lib/python2.7/site-packages/ipapython/admintool.py", line 151, in
execute
self.run()
File
"/usr/lib/python2.7/site-packages/ipaserver/install/ipa_ldap_updater.py",
line
180, in run
modified = ld.update(self.files)
File "/usr/lib/python2.7/site-packages/ipaserver/install/ldapupdate.py",
line 828, in update
sys.exit(1)
ipa : INFO The ipa-ldap-updater command failed, exception: SystemExit: 1
I've added validation for missing files, and improved the error message
ldapupdate raises (for cases the validation doesn't catch, like passing
directories or unreadable files).
Ideally ldapupdate would not try to handle the error itself, but that
code is used in more places that I don't want to break, so I'm leaving
the extraneous print in.
Running in test mode with the attached update doesn't seem to work
either. There is nothing special about this file, just something I had
lying around:
ipa : INFO File
"/usr/lib/python2.7/site-packages/ipapython/admintool.py", line 151, in
execute
self.run()
File
"/usr/lib/python2.7/site-packages/ipaserver/install/ipa_ldap_updater.py",
line
184, in run
'Update complete, changes to be made, test mode', 2)
ipa : INFO The ipa-ldap-updater command failed, exception: ScriptError:
Update complete, changes to be made, test mode
ipa : ERROR Update complete, changes to be made, test mode
ipa : ERROR None
Fixed.
The unit tests still pass which is good.
With ipa-ldap-updater the return value is a bit strange. All the updates
themselves can fail for one reason or another and the command can still
consider this a success (it may fail because a feature is not enabled,
for example). Still, the success message displayed at the end is a bit
jarring when the updates themselves aren't applied. Here is a snippet
when running ad.update live:
ipa : INFO New entry: uid=adtrust,cn=notfound,cn=etc,dc=greyoak,dc=com
ipa : DEBUG ---------------------------------------------
ipa : DEBUG dn: uid=adtrust,cn=notfound,cn=etc,dc=greyoak,dc=com
ipa : DEBUG add: 'account' to objectClass, current value []
ipa : DEBUG add: updated value [u'account']
ipa : DEBUG ---------------------------------------------
ipa : DEBUG dn: uid=adtrust,cn=notfound,cn=etc,dc=greyoak,dc=com
ipa : DEBUG objectClass:
ipa : DEBUG account
ipa : DEBUG add: 'adtrust' to uid, current value []
ipa : DEBUG add: updated value [u'adtrust']
ipa : DEBUG ---------------------------------------------
ipa : DEBUG dn: uid=adtrust,cn=notfound,cn=etc,dc=greyoak,dc=com
ipa : DEBUG objectClass:
ipa : DEBUG account
ipa : DEBUG uid:
ipa : DEBUG adtrust
ipa : DEBUG ---------------------------------------------
ipa : DEBUG Final value
ipa : DEBUG dn: uid=adtrust,cn=notfound,cn=etc,dc=greyoak,dc=com
ipa : DEBUG objectClass:
ipa : DEBUG account
ipa : DEBUG uid:
ipa : DEBUG adtrust
ipa : INFO Parent DN of uid=adtrust,cn=notfound,cn=etc,dc=greyoak,dc=com
may not exist, cannot create the entry
ipa : INFO The ipa-ldap-updater command was successful
[root@pinto freeipa]# echo $?
0
This may be contrasting just because it is a contrived case. The command
rval is separate from whether the updates all applied, so maybe this
is ok.
The current ipa-ldap-updater also works this way, so this should go in a
separate ticket.
I worry that changing the return value could make installations fail,
for example.
rob
Thanks for the review!
Once again, this time with the patch.
--
Petr³
From a3087e2e92918b4b373e2840f95228ab2652f044 Mon Sep 17 00:00:00 2001
From: Petr Viktorin <pvikt...@redhat.com>
Date: Fri, 20 Apr 2012 04:39:59 -0400
Subject: [PATCH] Framework for admin/install tools, with ipa-ldap-updater
Currently, FreeIPA's install/admin scripts are long pieces of code
that aren't very reusable, importable, or testable.
They have been extended over time with features such as logging and
error handling, but since each tool was extended individually, there
is much inconsistency and code duplication.
This patch starts a framework which the admin tools can use, and
converts ipa-ldap-updater to use the framework.
Common tasks the tools do -- option parsing, validation, logging
setup, error handling -- are represented as methods. Individual
tools can extend, override or reuse the defaults as they see fit.
The ipa-ldap-updater has two modes (normal and --upgrade) that
don't share much functionality. They are represented by separate
classes. Option parsing, and selecting which class to run, happens
before they're instantiated.
All code is moved to importable modules to aid future testing. The
only thing that remains in the ipa-ldap-updater script is a two-line
call to the library.
First part of the work for:
https://fedorahosted.org/freeipa/ticket/2652
---
install/tools/ipa-ldap-updater | 198 ++++------------------------
ipapython/admintool.py | 230 +++++++++++++++++++++++++++++++++
ipaserver/install/installutils.py | 91 ++++++-------
ipaserver/install/ipa_ldap_updater.py | 187 +++++++++++++++++++++++++++
ipaserver/install/ldapupdate.py | 2 +-
5 files changed, 483 insertions(+), 225 deletions(-)
rewrite install/tools/ipa-ldap-updater (85%)
create mode 100644 ipapython/admintool.py
create mode 100644 ipaserver/install/ipa_ldap_updater.py
diff --git a/install/tools/ipa-ldap-updater b/install/tools/ipa-ldap-updater
dissimilarity index 85%
index 197b840b07867269340f56e32989820d8af59ae1..0fc5a5bc448d04eb9ce8562ee1feebbf8f0fe356 100755
--- a/install/tools/ipa-ldap-updater
+++ b/install/tools/ipa-ldap-updater
@@ -1,173 +1,25 @@
-#!/usr/bin/python
-# Authors: Rob Crittenden <rcrit...@redhat.com>
-#
-# Copyright (C) 2008 Red Hat
-# see file 'COPYING' for use and warranty information
-#
-# 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, either version 3 of the License, or
-# (at your option) any later version.
-#
-# 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, see <http://www.gnu.org/licenses/>.
-#
-
-# Documentation can be found at http://freeipa.org/page/LdapUpdate
-
-# TODO
-# save undo files?
-
-import os
-import sys
-try:
- from ipapython.config import IPAOptionParser
- from ipapython import ipautil, config
- from ipaserver.install import installutils
- from ipaserver.install.ldapupdate import LDAPUpdate, BadSyntax, UPDATES_DIR
- from ipaserver.install.upgradeinstance import IPAUpgrade
- from ipapython import sysrestore
- import krbV
- from ipalib import api
- from ipapython.ipa_log_manager import *
-except ImportError:
- print >> sys.stderr, """\
-There was a problem importing one of the required Python modules. The
-error was:
-
- %s
-""" % sys.exc_value
- sys.exit(1)
-
-def parse_options():
- usage = "%prog [options] input_file(s)\n"
- usage += "%prog [options]\n"
- parser = IPAOptionParser(usage=usage, formatter=config.IPAFormatter())
-
- parser.add_option("-d", "--debug", action="store_true", dest="debug",
- help="Display debugging information about the update(s)",
- default=False)
- parser.add_option("-t", "--test", action="store_true", dest="test",
- help="Run through the update without changing anything",
- default=False)
- parser.add_option("-y", dest="password",
- help="File containing the Directory Manager password")
- parser.add_option("-l", '--ldapi', action="store_true", dest="ldapi",
- default=False, help="Connect to the LDAP server using the ldapi socket")
- parser.add_option("-u", '--upgrade', action="store_true", dest="upgrade",
- default=False, help="Upgrade an installed server in offline mode")
- parser.add_option("-p", '--plugins', action="store_true", dest="plugins",
- default=False, help="Execute update plugins. Always true when applying all update files.")
- parser.add_option("-W", '--password', action="store_true",
- dest="ask_password",
- help="Prompt for the Directory Manager password")
-
- options, args = parser.parse_args()
- safe_options = parser.get_safe_opts(options)
-
- return safe_options, options, args
-
-def get_dirman_password():
- """Prompt the user for the Directory Manager password and verify its
- correctness.
- """
- password = installutils.read_password("Directory Manager", confirm=False, validate=False)
-
- return password
-
-def main():
- badsyntax = False
- upgradefailed = False
-
- safe_options, options, args = parse_options()
-
- run_plugins = options.plugins
-
- files = []
- if len(args) > 0:
- files = args
-
- if len(files) < 1:
- run_plugins = True
-
- if os.getegid() == 0:
- installutils.check_server_configuration()
- else:
- if not os.path.exists('/etc/ipa/default.conf'):
- sys.exit("IPA is not configured on this system.")
- if options.upgrade:
- sys.exit('Upgrade can only be done as root')
- if run_plugins:
- sys.exit('Plugins can only be run as root.')
-
- dirman_password = ""
- if options.password:
- pw = ipautil.template_file(options.password, [])
- dirman_password = pw.strip()
- else:
- if (options.ask_password or not options.ldapi) and not options.upgrade:
- dirman_password = get_dirman_password()
- if dirman_password is None:
- sys.exit("\nDirectory Manager password required")
-
- if options.upgrade:
- standard_logging_setup('/var/log/ipaupgrade.log', verbose=True, debug=options.debug, filemode='a')
- else:
- standard_logging_setup(None, verbose=True, debug=options.debug)
-
- cfg = dict (
- in_server=True,
- context='updates',
- debug=options.debug,
- )
- api.bootstrap(**cfg)
- api.finalize()
-
- updates = None
- if options.upgrade:
- root_logger.debug('%s was invoked with arguments %s and options: %s' % (sys.argv[0], args, safe_options))
- realm = krbV.default_context().default_realm
- upgrade = IPAUpgrade(realm, files, live_run=not options.test)
- upgrade.create_instance()
- modified = upgrade.modified
- badsyntax = upgrade.badsyntax
- upgradefailed = upgrade.upgradefailed
- else:
- ld = LDAPUpdate(dm_password=dirman_password, sub_dict={}, live_run=not options.test, ldapi=options.ldapi, plugins=run_plugins)
- if len(files) < 1:
- files = ld.get_all_files(UPDATES_DIR)
- modified = ld.update(files)
-
- if badsyntax:
- root_logger.info('Bad syntax detected in upgrade file(s).')
- print 'Bad syntax detected in upgrade file(s).'
- return 1
- elif upgradefailed:
- root_logger.info('IPA upgrade failed.')
- print 'IPA upgrade failed.'
- return 1
- elif modified and options.test:
- root_logger.info('Update complete, changes to be made, test mode')
- return 2
- else:
- root_logger.info('Update complete')
- return 0
-
-try:
- if __name__ == "__main__":
- sys.exit(main())
-except BadSyntax, e:
- print "There is a syntax error in this update file:"
- print " %s" % e
- sys.exit(1)
-except RuntimeError, e:
- sys.exit(e)
-except SystemExit, e:
- sys.exit(e)
-except KeyboardInterrupt, e:
- sys.exit(1)
+#!/usr/bin/python
+# Authors: Rob Crittenden <rcrit...@redhat.com>
+#
+# Copyright (C) 2008 Red Hat
+# see file 'COPYING' for use and warranty information
+#
+# 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, either version 3 of the License, or
+# (at your option) any later version.
+#
+# 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, see <http://www.gnu.org/licenses/>.
+#
+
+# Documentation can be found at http://freeipa.org/page/LdapUpdate
+
+from ipaserver.install.ipa_ldap_updater import LDAPUpdater
+
+LDAPUpdater.run_cli()
diff --git a/ipapython/admintool.py b/ipapython/admintool.py
new file mode 100644
index 0000000000000000000000000000000000000000..c36aa70986023c8124cef38a4b4d2b9d4157e9f3
--- /dev/null
+++ b/ipapython/admintool.py
@@ -0,0 +1,230 @@
+# Authors:
+# Petr Viktorin <pvikt...@redhat.com>
+#
+# Copyright (C) 2012 Red Hat
+# see file 'COPYING' for use and warranty information
+#
+# 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, either version 3 of the License, or
+# (at your option) any later version.
+#
+# 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, see <http://www.gnu.org/licenses/>.
+
+"""A common framework for command-line admin tools, e.g. install scripts
+
+Handles common operations like option parsing and logging
+"""
+
+import sys
+import os
+import traceback
+from optparse import OptionGroup
+
+from ipapython import version
+from ipapython import config
+from ipapython import ipa_log_manager
+
+
+class ScriptError(StandardError):
+ """An exception that records an error message and a return value
+ """
+ def __init__(self, msg='', rval=1):
+ self.msg = msg
+ self.rval = rval
+
+ def __str__(self):
+ return self.msg or ''
+
+
+class AdminTool(object):
+ """Base class for command-line admin tools
+
+ To run the tool, call the main() classmethod with a list of command-line
+ arguments.
+ Alternatively, call run_cli() to run with command-line arguments in
+ sys.argv, and call sys.exit() with the return value.
+
+ Some commands actually represent multiple related tools, e.g.
+ ``ipa-server-install`` and ``ipa-server-install --uninstall`` would be
+ represented by separate classes. Only their options are the same.
+
+ To handle this, AdminTool provides classmethods for option parsing
+ and selecting the appropriate command class.
+
+ A class-wide option parser is made by calling add_options.
+ The options are then parsed into options and arguments, and
+ get_command_class is called with those to retrieve the class.
+ That class is then instantiated and run.
+
+ Running consists of a few steps:
+ - validating options or the environment (validate_options)
+ - setting up logging (setup_logging)
+ - running the actual command (run)
+
+ Any unhandled exceptions are handled in handle_error.
+ And at the end, either log_success or log_failure is called.
+
+ Class attributes to define in subclasses:
+ command_name - shown in logs
+ log_file_name - if None, logging is to stderr only
+ needs_root - if true, non-root users can't run the tool
+ usage - text shown in help
+ """
+ command_name = None
+ log_file_name = None
+ needs_root = False
+ usage = None
+
+ _option_parsers = dict()
+
+ @classmethod
+ def make_parser(cls):
+ """Create an option parser shared across all instances of this class"""
+ parser = config.IPAOptionParser(version=version.VERSION,
+ usage=cls.usage, formatter=config.IPAFormatter())
+ cls.option_parser = parser
+ cls.add_options(parser)
+
+ @classmethod
+ def add_options(cls, parser):
+ """Add command-specific options to the option parser"""
+ parser.add_option("-d", "--debug", dest="debug", default=False,
+ action="store_true", help="print debugging information")
+
+ @classmethod
+ def run_cli(cls):
+ """Run this command with sys.argv, exit process with the return value
+ """
+ sys.exit(cls.main(sys.argv))
+
+ @classmethod
+ def main(cls, argv):
+ """The main entry point
+
+ Parses command-line arguments, selects the actual command class to use
+ based on them, and runs that command.
+
+ :param argv: Command-line arguments.
+ :return: Command exit code
+ """
+ if cls not in cls._option_parsers:
+ # We use cls._option_parsers, a dictionary keyed on class, to check
+ # if we need to create a parser. This is because cls.option_parser
+ # can refer to the parser of a superclass.
+ cls.make_parser()
+ cls._option_parsers[cls] = cls.option_parser
+
+ options, args = cls.option_parser.parse_args(argv[1:])
+
+ command_class = cls.get_command_class(options, args)
+ command = command_class(options, args)
+
+ return command.execute()
+
+ @classmethod
+ def get_command_class(cls, options, args):
+ return cls
+
+ def __init__(self, options, args):
+ self.options = options
+ self.args = args
+ self.safe_options = self.option_parser.get_safe_opts(options)
+
+ def execute(self):
+ """Do everything needed after options are parsed
+
+ This includes validating options, setting up logging, doing the
+ actual work, and handling the result.
+ """
+ try:
+ self.validate_options()
+ self.ask_for_options()
+ self.setup_logging()
+ self.run()
+ except BaseException, exception:
+ traceback = sys.exc_info()[2]
+ error_message, return_value = self.handle_error(exception)
+ else:
+ return_value = 0
+ if return_value:
+ self.log_failure(error_message, return_value, exception,
+ traceback)
+ return return_value
+ else:
+ self.log_success()
+ return 0
+
+ def validate_options(self):
+ """Validate self.options
+
+ It's also possible to compute and store information that will be
+ useful later, but no changes to the system should be made here.
+ """
+ if self.needs_root and os.getegid() != 0:
+ raise ScriptError('Must be root to run %s' % self.command_name, 1)
+
+ def ask_for_options(self):
+ """Ask for missing options interactively
+
+ Similar to validate_options. This is separate method because we want
+ any validation errors to abort the script before bothering the user
+ with prompts.
+ """
+ pass
+
+ def setup_logging(self):
+ """Set up logging, and assign the logger to use to self.logger
+ """
+ ipa_log_manager.standard_logging_setup(
+ self.log_file_name, debug=self.options.debug)
+ self.logger = ipa_log_manager.root_logger
+
+ def handle_error(self, exception):
+ """Given an exception, return a message (or None) and process exit code
+ """
+ if isinstance(exception, ScriptError):
+ return exception.msg, exception.rval or 1
+ elif isinstance(exception, SystemExit):
+ if isinstance(exception.code, int):
+ return None, exception.code
+ return str(exception.code), 1
+
+ return str(exception), 1
+
+ def run(self):
+ """Actual running of the command
+
+ This is where the hard work is done. The base implementation logs
+ the invocation of the command.
+ """
+ self.logger.debug(
+ '%s was invoked with arguments %s and options: %s' % (
+ self.command_name, self.args, self.safe_options))
+
+ def log_failure(self, error_message, return_value, exception, backtrace):
+ try:
+ logger = self.logger
+ except AttributeError:
+ # Logging was not set up yet
+ print >> sys.stderr, '\n', error_message
+ else:
+ logger.info(''.join(traceback.format_tb(backtrace)))
+ logger.info('The %s command failed, exception: %s: %s',
+ self.command_name, type(exception).__name__, exception)
+ if error_message:
+ logger.error(error_message)
+
+ def log_success(self):
+ try:
+ logger = self.logger
+ except AttributeError:
+ pass
+ else:
+ logger.info('The %s command was successful', self.command_name)
diff --git a/ipaserver/install/installutils.py b/ipaserver/install/installutils.py
index 313761777cddcbf5ad9dd134556d72931e51a2b3..ad2036b3fc2a503054e50cec2f7d0d65d270344c 100644
--- a/ipaserver/install/installutils.py
+++ b/ipaserver/install/installutils.py
@@ -37,7 +37,8 @@
from dns.exception import DNSException
import ldap
-from ipapython import ipautil, sysrestore
+from ipapython import ipautil, sysrestore, admintool
+from ipapython.admintool import ScriptError
from ipapython.ipa_log_manager import *
from ipalib.util import validate_hostname
from ipapython import config
@@ -61,18 +62,6 @@ class HostReverseLookupError(HostLookupError):
class HostnameLocalhost(HostLookupError):
pass
-
-class ScriptError(StandardError):
- """An exception that records an error message and a return value
- """
- def __init__(self, msg = '', rval = 1):
- self.msg = msg
- self.rval = rval
-
- def __str__(self):
- return self.msg
-
-
class ReplicaConfig:
def __init__(self):
self.realm_name = ""
@@ -721,65 +710,65 @@ def run_script(main_function, operation_name, log_file_name=None,
sys.exit(return_value)
except BaseException, error:
- handle_error(error, log_file_name)
+ message, exitcode = handle_error(error, log_file_name)
+ if message:
+ print >> sys.stderr, message
+ sys.exit(exitcode)
def handle_error(error, log_file_name=None):
- """Handle specific errors"""
+ """Handle specific errors. Returns a message and return code"""
if isinstance(error, SystemExit):
- sys.exit(error)
+ if isinstance(error.code, int):
+ return None, error.code
+ elif error.code is None:
+ return None, 0
+ else:
+ return str(error), 1
if isinstance(error, RuntimeError):
- sys.exit(error)
+ return str(error), 1
if isinstance(error, KeyboardInterrupt):
- print >> sys.stderr, "Cancelled."
- sys.exit(1)
+ return "Cancelled.", 1
- if isinstance(error, ScriptError):
- if error.msg:
- print >> sys.stderr, error.msg
- sys.exit(error.rval)
+ if isinstance(error, admintool.ScriptError):
+ return error.msg, error.rval
if isinstance(error, socket.error):
- print >> sys.stderr, error
- sys.exit(1)
+ return error, 1
if isinstance(error, ldap.INVALID_CREDENTIALS):
- print >> sys.stderr, "Invalid password"
- sys.exit(1)
+ return "Invalid password", 1
if isinstance(error, ldap.INSUFFICIENT_ACCESS):
- print >> sys.stderr, "Insufficient access"
- sys.exit(1)
+ return "Insufficient access", 1
if isinstance(error, ldap.LOCAL_ERROR):
- print >> sys.stderr, error.args[0]['info']
- sys.exit(1)
+ return error.args[0]['info'], 1
if isinstance(error, ldap.SERVER_DOWN):
- print >> sys.stderr, error.args[0]['desc']
- sys.exit(1)
+ return error.args[0]['desc'], 1
if isinstance(error, ldap.LDAPError):
- print >> sys.stderr, 'LDAP error: %s' % type(error).__name__
- print >> sys.stderr, error.args[0]['info']
- sys.exit(1)
+ return 'LDAP error: %s\n%s' % (
+ type(error).__name__, error.args[0]['info']), 1
if isinstance(error, config.IPAConfigError):
- print >> sys.stderr, "An IPA server to update cannot be found. Has one been configured yet?"
- print >> sys.stderr, "The error was: %s" % error
- sys.exit(1)
+ message = "An IPA server to update cannot be found. Has one been configured yet?"
+ message += "\nThe error was: %s" % error
+ return message, 1
if isinstance(error, errors.LDAPError):
- print >> sys.stderr, "An error occurred while performing operations: %s" % error
- sys.exit(1)
+ return "An error occurred while performing operations: %s" % error, 1
if isinstance(error, HostnameLocalhost):
- print >> sys.stderr, "The hostname resolves to the localhost address (127.0.0.1/::1)"
- print >> sys.stderr, "Please change your /etc/hosts file so that the hostname"
- print >> sys.stderr, "resolves to the ip address of your network interface."
- print >> sys.stderr, ""
- print >> sys.stderr, "Please fix your /etc/hosts file and restart the setup program"
- sys.exit(1)
+ message = '\n'.join(
+ "The hostname resolves to the localhost address (127.0.0.1/::1)",
+ "Please change your /etc/hosts file so that the hostname",
+ "resolves to the ip address of your network interface.",
+ "",
+ "Please fix your /etc/hosts file and restart the setup program",
+ )
+ return message, 1
if log_file_name:
- print >> sys.stderr, "Unexpected error - see %s for details:" % log_file_name
+ message = "Unexpected error - see %s for details:" % log_file_name
else:
- print >> sys.stderr, "Unexpected error"
- print >> sys.stderr, '%s: %s' % (type(error).__name__, error)
- sys.exit(1)
+ message = "Unexpected error"
+ message += '\n%s: %s' % (type(error).__name__, error)
+ return message, 1
diff --git a/ipaserver/install/ipa_ldap_updater.py b/ipaserver/install/ipa_ldap_updater.py
new file mode 100644
index 0000000000000000000000000000000000000000..d059cf96a79ce6ee838c712cd6c624fefd5896d6
--- /dev/null
+++ b/ipaserver/install/ipa_ldap_updater.py
@@ -0,0 +1,187 @@
+#!/usr/bin/python
+# Authors: Rob Crittenden <rcrit...@redhat.com>
+# Petr Viktorin <pvikt...@redhat.com>
+#
+# Copyright (C) 2008 Red Hat
+# see file 'COPYING' for use and warranty information
+#
+# 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, either version 3 of the License, or
+# (at your option) any later version.
+#
+# 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, see <http://www.gnu.org/licenses/>.
+#
+
+# Documentation can be found at http://freeipa.org/page/LdapUpdate
+
+# TODO
+# save undo files?
+
+import os
+
+import krbV
+
+from ipalib import api
+from ipapython import ipautil, admintool
+from ipaserver.install import installutils
+from ipaserver.install.ldapupdate import LDAPUpdate, UPDATES_DIR
+from ipaserver.install.upgradeinstance import IPAUpgrade
+from ipapython import ipa_log_manager
+
+
+class LDAPUpdater(admintool.AdminTool):
+ command_name = 'ipa-ldap-updater'
+
+ usage = "%prog [options] input_file(s)\n"
+ usage += "%prog [options]\n"
+
+ @classmethod
+ def add_options(cls, parser):
+ super(LDAPUpdater, cls).add_options(parser)
+
+ parser.add_option("-t", "--test", action="store_true", dest="test",
+ default=False,
+ help="Run through the update without changing anything")
+ parser.add_option("-y", dest="password",
+ help="File containing the Directory Manager password")
+ parser.add_option("-l", '--ldapi', action="store_true", dest="ldapi",
+ default=False,
+ help="Connect to the LDAP server using the ldapi socket")
+ parser.add_option("-u", '--upgrade', action="store_true",
+ dest="upgrade", default=False,
+ help="Upgrade an installed server in offline mode")
+ parser.add_option("-p", '--plugins', action="store_true",
+ dest="plugins", default=False,
+ help="Execute update plugins. " +
+ "Always true when applying all update files.")
+ parser.add_option("-W", '--password', action="store_true",
+ dest="ask_password",
+ help="Prompt for the Directory Manager password")
+
+ @classmethod
+ def get_command_class(cls, options, args):
+ if options.upgrade:
+ return LDAPUpdater_Upgrade
+ else:
+ return LDAPUpdater_NonUpgrade
+
+ def validate_options(self):
+ options = self.options
+ super(LDAPUpdater, self).validate_options()
+
+ self.files = self.args
+
+ for filename in self.files:
+ if not os.path.exists(filename):
+ raise admintool.ScriptError(
+ "%s: file not found" % filename)
+
+ if os.getegid() == 0:
+ installutils.check_server_configuration()
+ elif not os.path.exists('/etc/ipa/default.conf'):
+ raise admintool.ScriptError(
+ "IPA is not configured on this system.")
+
+ if options.password:
+ pw = ipautil.template_file(options.password, [])
+ self.dirman_password = pw.strip()
+ else:
+ self.dirman_password = None
+
+ def setup_logging(self):
+ ipa_log_manager.standard_logging_setup(self.log_file_name,
+ verbose=True, debug=self.options.debug, filemode='a')
+ self.logger = ipa_log_manager.root_logger
+
+ def run(self):
+ super(LDAPUpdater, self).run()
+
+ api.bootstrap(
+ in_server=True,
+ context='updates',
+ debug=self.options.debug,
+ )
+ api.finalize()
+
+ def handle_error(self, exception):
+ return installutils.handle_error(exception, self.log_file_name)
+
+
+class LDAPUpdater_Upgrade(LDAPUpdater):
+ needs_root = True
+ log_file_name = '/var/log/ipaupgrade.log'
+
+ def validate_options(self):
+ if os.getegid() != 0:
+ raise admintool.ScriptError('Must be root to do an upgrade.', 1)
+
+ super(LDAPUpdater_Upgrade, self).validate_options()
+
+ def run(self):
+ super(LDAPUpdater_Upgrade, self).run()
+ options = self.options
+
+ updates = None
+ realm = krbV.default_context().default_realm
+ upgrade = IPAUpgrade(realm, self.files, live_run=not options.test)
+ upgrade.create_instance()
+ upgradefailed = upgrade.upgradefailed
+
+ if upgrade.badsyntax:
+ raise admintool.ScriptError(
+ 'Bad syntax detected in upgrade file(s).', 1)
+ elif upgrade.upgradefailed:
+ raise admintool.ScriptError('IPA upgrade failed.', 1)
+ elif upgrade.modified and options.test:
+ self.logger.info('Update complete, changes to be made, test mode')
+
+
+class LDAPUpdater_NonUpgrade(LDAPUpdater):
+ def validate_options(self):
+ super(LDAPUpdater_NonUpgrade, self).validate_options()
+ options = self.options
+
+ # Only run plugins if no files are given
+ self.run_plugins = not self.files or options.plugins
+
+ # Need root for running plugins
+ if self.run_plugins and os.getegid() != 0:
+ raise admintool.ScriptError('Plugins can only be run as root.', 1)
+
+ def ask_for_options(self):
+ super(LDAPUpdater_NonUpgrade, self).ask_for_options()
+ options = self.options
+ if not self.dirman_password:
+ if options.ask_password or not options.ldapi:
+ password = installutils.read_password("Directory Manager",
+ confirm=False, validate=False)
+ if password is None:
+ raise admintool.ScriptError(
+ "Directory Manager password required")
+ self.dirman_password = password
+
+ def run(self):
+ super(LDAPUpdater_NonUpgrade, self).run()
+ options = self.options
+
+ ld = LDAPUpdate(
+ dm_password=self.dirman_password,
+ sub_dict={},
+ live_run=not options.test,
+ ldapi=options.ldapi,
+ plugins=options.plugins or self.run_plugins)
+
+ if not self.files:
+ self.files = ld.get_all_files(UPDATES_DIR)
+
+ modified = ld.update(self.files)
+
+ if modified and options.test:
+ self.logger.info('Update complete, changes to be made, test mode')
diff --git a/ipaserver/install/ldapupdate.py b/ipaserver/install/ldapupdate.py
index e75ee804a1d201512f2770156eef73cf1bb1e7bb..c64139889d9f84866ac0cd358ed3a3a7d95af7dc 100644
--- a/ipaserver/install/ldapupdate.py
+++ b/ipaserver/install/ldapupdate.py
@@ -825,7 +825,7 @@ def update(self, files):
data = self.read_file(f)
except Exception, e:
print e
- sys.exit(1)
+ sys.exit(e)
(all_updates, dn_list) = self.parse_update_file(data, all_updates, dn_list)
--
1.7.10.2
_______________________________________________
Freeipa-devel mailing list
Freeipa-devel@redhat.com
https://www.redhat.com/mailman/listinfo/freeipa-devel
