swift 2.23.2__py3-none-any.whl → 2.35.0__py3-none-any.whl

swift/common/manager.py

@@ -13,18 +13,19 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from __future__ import print_function
+
 import functools
 import errno
+from optparse import OptionParser
 import os
 import resource
 import signal
 import time
 import subprocess
 import re
-import six
-from swift import gettext_ as _
+import sys
 import tempfile
+from shutil import which
 
 from swift.common.utils import search_tree, remove_file, write_file, readconf
 from swift.common.exceptions import InvalidPidFileException
@@ -46,6 +47,7 @@ REST_SERVERS = [s for s in ALL_SERVERS if s not in MAIN_SERVERS]
 # aliases mapping
 ALIASES = {'all': ALL_SERVERS, 'main': MAIN_SERVERS, 'rest': REST_SERVERS}
 GRACEFUL_SHUTDOWN_SERVERS = MAIN_SERVERS
+SEAMLESS_SHUTDOWN_SERVERS = MAIN_SERVERS
 START_ONCE_SERVERS = REST_SERVERS
 # These are servers that match a type (account-*, container-*, object-*) but
 # don't use that type-server.conf file and instead use their own.
@@ -66,22 +68,22 @@ def setup_env():
         resource.setrlimit(resource.RLIMIT_NOFILE,
                            (MAX_DESCRIPTORS, MAX_DESCRIPTORS))
     except ValueError:
-        print(_("WARNING: Unable to modify file descriptor limit.  "
-                "Running as non-root?"))
+        print("WARNING: Unable to modify file descriptor limit.  "
+              "Running as non-root?")
 
     try:
         resource.setrlimit(resource.RLIMIT_DATA,
                            (MAX_MEMORY, MAX_MEMORY))
     except ValueError:
-        print(_("WARNING: Unable to modify memory limit.  "
-                "Running as non-root?"))
+        print("WARNING: Unable to modify memory limit.  "
+              "Running as non-root?")
 
     try:
         resource.setrlimit(resource.RLIMIT_NPROC,
                            (MAX_PROCS, MAX_PROCS))
     except ValueError:
-        print(_("WARNING: Unable to modify max process limit.  "
-                "Running as non-root?"))
+        print("WARNING: Unable to modify max process limit.  "
+              "Running as non-root?")
 
     # Set PYTHON_EGG_CACHE if it isn't already set
     os.environ.setdefault('PYTHON_EGG_CACHE', tempfile.gettempdir())
@@ -97,8 +99,10 @@ def command(func):
     func.publicly_accessible = True
 
     @functools.wraps(func)
-    def wrapped(*a, **kw):
-        rv = func(*a, **kw)
+    def wrapped(self, *a, **kw):
+        rv = func(self, *a, **kw)
+        if len(self.servers) == 0:
+            return 1
         return 1 if rv else 0
     return wrapped
 
@@ -173,6 +177,50 @@ def kill_group(pid, sig):
     os.kill(-pid, sig)
 
 
+def get_child_pids(pid):
+    """
+    Get the current set of all child PIDs for a PID.
+
+    :param pid: process id
+    """
+    output = subprocess.check_output(
+        ["ps", "--ppid", str(pid), "--no-headers", "-o", "pid"])
+    return {int(pid) for pid in output.split()}
+
+
+def format_server_name(servername):
+    """
+    Formats server name as swift compatible server names
+    E.g. swift-object-server
+
+    :param servername: server name
+    :returns: swift compatible server name and its binary name
+    """
+    if '.' in servername:
+        servername = servername.split('.', 1)[0]
+    if '-' not in servername:
+        servername = '%s-server' % servername
+    cmd = 'swift-%s' % servername
+    return servername, cmd
+
+
+def verify_server(server):
+    """
+    Check whether the server is among swift servers or not, and also
+    checks whether the server's binaries are installed or not.
+
+    :param server: name of the server
+    :returns: True, when the server name is valid and its binaries are found.
+              False, otherwise.
+    """
+    if not server:
+        return False
+    _, cmd = format_server_name(server)
+    if which(cmd) is None:
+        return False
+    return True
+
+
 class UnknownCommandError(Exception):
     pass
 
@@ -202,7 +250,8 @@ class Manager(object):
 
         self.servers = set()
         for name in self.server_names:
-            self.servers.add(Server(name, run_dir))
+            if verify_server(name):
+                self.servers.add(Server(name, run_dir))
 
     def __iter__(self):
         return iter(self.servers)
@@ -239,7 +288,7 @@ class Manager(object):
                 try:
                     status += server.interact(**kwargs)
                 except KeyboardInterrupt:
-                    print(_('\nuser quit'))
+                    print('\nuser quit')
                     self.stop(**kwargs)
                     break
         elif kwargs.get('wait', True):
@@ -276,7 +325,7 @@ class Manager(object):
         for server in self.servers:
             signaled_pids = server.stop(**kwargs)
             if not signaled_pids:
-                print(_('No %s running') % server)
+                print('No %s running' % server)
             else:
                 server_pids[server] = signaled_pids
 
@@ -289,7 +338,7 @@ class Manager(object):
         for server, killed_pid in watch_server_pids(server_pids,
                                                     interval=kill_wait,
                                                     **kwargs):
-            print(_("%(server)s (%(pid)s) appears to have stopped") %
+            print("%(server)s (%(pid)s) appears to have stopped" %
                   {'server': server, 'pid': killed_pid})
             killed_pids.add(killed_pid)
             if not killed_pids.symmetric_difference(signaled_pids):
@@ -302,15 +351,15 @@ class Manager(object):
             if not killed_pids.issuperset(pids):
                 # some pids of this server were not killed
                 if kill_after_timeout:
-                    print(_('Waited %(kill_wait)s seconds for %(server)s '
-                            'to die; killing') %
+                    print('Waited %(kill_wait)s seconds for %(server)s '
+                          'to die; killing' %
                           {'kill_wait': kill_wait, 'server': server})
                     # Send SIGKILL to all remaining pids
                     for pid in set(pids.keys()) - killed_pids:
-                        print(_('Signal %(server)s  pid: %(pid)s  signal: '
-                                '%(signal)s') % {'server': server,
-                                                 'pid': pid,
-                                                 'signal': signal.SIGKILL})
+                        print('Signal %(server)s  pid: %(pid)s  signal: '
+                              '%(signal)s' % {'server': server,
+                                              'pid': pid,
+                                              'signal': signal.SIGKILL})
                         # Send SIGKILL to process group
                         try:
                             kill_group(pid, signal.SIGKILL)
@@ -319,8 +368,8 @@ class Manager(object):
                             if e.errno != errno.ESRCH:
                                 raise
                 else:
-                    print(_('Waited %(kill_wait)s seconds for %(server)s '
-                            'to die; giving up') %
+                    print('Waited %(kill_wait)s seconds for %(server)s '
+                          'to die; giving up' %
                           {'kill_wait': kill_wait, 'server': server})
         return 1
 
@@ -365,6 +414,31 @@ class Manager(object):
             status += m.start(**kwargs)
         return status
 
+    @command
+    def reload_seamless(self, **kwargs):
+        """seamlessly re-exec, then shutdown of old listen sockets on
+           supporting servers
+        """
+        kwargs.pop('graceful', None)
+        kwargs['seamless'] = True
+        status = 0
+        for server in self.servers:
+            signaled_pids = server.stop(**kwargs)
+            if not signaled_pids:
+                print('No %s running' % server)
+                status += 1
+        return status
+
+    def kill_child_pids(self, **kwargs):
+        """kill child pids, optionally servicing accepted connections"""
+        status = 0
+        for server in self.servers:
+            signaled_pids = server.kill_child_pids(**kwargs)
+            if not signaled_pids:
+                print('No %s running' % server)
+                status += 1
+        return status
+
     @command
     def force_reload(self, **kwargs):
         """alias for reload
@@ -420,10 +494,8 @@ class Server(object):
             self.server, self.conf = self.server.rsplit('.', 1)
         else:
             self.conf = None
-        if '-' not in self.server:
-            self.server = '%s-server' % self.server
+        self.server, self.cmd = format_server_name(self.server)
         self.type = self.server.rsplit('-', 1)[0]
-        self.cmd = 'swift-%s' % self.server
         self.procs = []
         self.run_dir = run_dir
 
@@ -523,7 +595,7 @@ class Server(object):
 
         def dump_found_configs():
             if found_conf_files:
-                print(_('Found configs:'))
+                print('Found configs:')
             for i, conf_file in enumerate(found_conf_files):
                 print('  %d) %s' % (i + 1, conf_file))
 
@@ -531,18 +603,18 @@ class Server(object):
             # maybe there's a config file(s) out there, but I couldn't find it!
             if not kwargs.get('quiet'):
                 if number:
-                    print(_('Unable to locate config number %(number)s for'
-                            ' %(server)s') %
+                    print('Unable to locate config number %(number)s for'
+                          ' %(server)s' %
                           {'number': number, 'server': self.server})
                 else:
-                    print(_('Unable to locate config for %s') % self.server)
+                    print('Unable to locate config for %s' % self.server)
             if kwargs.get('verbose') and not kwargs.get('quiet'):
                 dump_found_configs()
         elif any(["object-expirer" in name for name in conf_files]) and \
                 not kwargs.get('quiet'):
-            print(_("WARNING: object-expirer.conf is deprecated. "
-                    "Move object-expirers' configuration into "
-                    "object-server.conf."))
+            print("WARNING: object-expirer.conf is deprecated. "
+                  "Move object-expirers' configuration into "
+                  "object-server.conf.")
             if kwargs.get('verbose'):
                 dump_found_configs()
 
@@ -578,6 +650,32 @@ class Server(object):
                 pid = None
             yield pid_file, pid
 
+    def _signal_pid(self, sig, pid, pid_file, verbose):
+        try:
+            if sig != signal.SIG_DFL:
+                print('Signal %(server)s  pid: %(pid)s  signal: '
+                      '%(signal)s' %
+                      {'server': self.server, 'pid': pid, 'signal': sig})
+            safe_kill(pid, sig, 'swift-%s' % self.server)
+        except InvalidPidFileException:
+            if verbose:
+                print('Removing pid file %(pid_file)s with wrong pid '
+                      '%(pid)d' % {'pid_file': pid_file, 'pid': pid})
+            remove_file(pid_file)
+            return False
+        except OSError as e:
+            if e.errno == errno.ESRCH:
+                # pid does not exist
+                if verbose:
+                    print("Removing stale pid file %s" % pid_file)
+                remove_file(pid_file)
+            elif e.errno == errno.EPERM:
+                print("No permission to signal PID %d" % pid)
+            return False
+        else:
+            # process exists
+            return True
+
     def signal_pids(self, sig, **kwargs):
         """Send a signal to pids for this server
 
@@ -589,33 +687,32 @@ class Server(object):
         pids = {}
         for pid_file, pid in self.iter_pid_files(**kwargs):
             if not pid:  # Catches None and 0
-                print(_('Removing pid file %s with invalid pid') % pid_file)
+                print('Removing pid file %s with invalid pid' % pid_file)
                 remove_file(pid_file)
                 continue
-            try:
-                if sig != signal.SIG_DFL:
-                    print(_('Signal %(server)s  pid: %(pid)s  signal: '
-                            '%(signal)s') %
-                          {'server': self.server, 'pid': pid, 'signal': sig})
-                safe_kill(pid, sig, 'swift-%s' % self.server)
-            except InvalidPidFileException as e:
-                if kwargs.get('verbose'):
-                    print(_('Removing pid file %(pid_file)s with wrong pid '
-                            '%(pid)d') % {'pid_file': pid_file, 'pid': pid})
-                remove_file(pid_file)
-            except OSError as e:
-                if e.errno == errno.ESRCH:
-                    # pid does not exist
-                    if kwargs.get('verbose'):
-                        print(_("Removing stale pid file %s") % pid_file)
-                    remove_file(pid_file)
-                elif e.errno == errno.EPERM:
-                    print(_("No permission to signal PID %d") % pid)
-            else:
-                # process exists
+            if self._signal_pid(sig, pid, pid_file, kwargs.get('verbose')):
                 pids[pid] = pid_file
         return pids
 
+    def signal_children(self, sig, **kwargs):
+        """Send a signal to child pids for this server
+
+        :param sig: signal to send
+
+        :returns: a dict mapping pids (ints) to pid_files (paths)
+
+        """
+        pids = {}
+        for pid_file, pid in self.iter_pid_files(**kwargs):
+            if not pid:  # Catches None and 0
+                print('Removing pid file %s with invalid pid' % pid_file)
+                remove_file(pid_file)
+                continue
+            for pid in get_child_pids(pid):
+                if self._signal_pid(sig, pid, pid_file, kwargs.get('verbose')):
+                    pids[pid] = pid_file
+        return pids
+
     def get_running_pids(self, **kwargs):
         """Get running pids
 
@@ -628,17 +725,40 @@ class Server(object):
         """Kill running pids
 
         :param graceful: if True, attempt SIGHUP on supporting servers
+        :param seamless: if True, attempt SIGUSR1 on supporting servers
 
         :returns: a dict mapping pids (ints) to pid_files (paths)
 
         """
         graceful = kwargs.get('graceful')
+        seamless = kwargs.get('seamless')
         if graceful and self.server in GRACEFUL_SHUTDOWN_SERVERS:
             sig = signal.SIGHUP
+        elif seamless and self.server in SEAMLESS_SHUTDOWN_SERVERS:
+            sig = signal.SIGUSR1
         else:
             sig = signal.SIGTERM
         return self.signal_pids(sig, **kwargs)
 
+    def kill_child_pids(self, **kwargs):
+        """Kill child pids, leaving server overseer to respawn them
+
+        :param graceful: if True, attempt SIGHUP on supporting servers
+        :param seamless: if True, attempt SIGUSR1 on supporting servers
+
+        :returns: a dict mapping pids (ints) to pid_files (paths)
+
+        """
+        graceful = kwargs.get('graceful')
+        seamless = kwargs.get('seamless')
+        if graceful and self.server in GRACEFUL_SHUTDOWN_SERVERS:
+            sig = signal.SIGHUP
+        elif seamless and self.server in SEAMLESS_SHUTDOWN_SERVERS:
+            sig = signal.SIGUSR1
+        else:
+            sig = signal.SIGTERM
+        return self.signal_children(sig, **kwargs)
+
     def status(self, pids=None, **kwargs):
         """Display status of server
 
@@ -655,15 +775,15 @@ class Server(object):
                 kwargs['quiet'] = True
                 conf_files = self.conf_files(**kwargs)
                 if conf_files:
-                    print(_("%(server)s #%(number)d not running (%(conf)s)") %
+                    print("%(server)s #%(number)d not running (%(conf)s)" %
                           {'server': self.server, 'number': number,
                            'conf': conf_files[0]})
             else:
-                print(_("No %s running") % self.server)
+                print("No %s running" % self.server)
             return 1
         for pid, pid_file in pids.items():
             conf_file = self.get_conf_file_name(pid_file)
-            print(_("%(server)s running (%(pid)s - %(conf)s)") %
+            print("%(server)s running (%(pid)s - %(conf)s)" %
                   {'server': self.server, 'pid': pid, 'conf': conf_file})
         return 0
 
@@ -719,10 +839,8 @@ class Server(object):
             if proc.stdout.closed:
                 output = ''
             else:
-                output = proc.stdout.read()
+                output = proc.stdout.read().decode('utf8', 'backslashreplace')
                 proc.stdout.close()
-                if not six.PY2:
-                    output = output.decode('utf8', 'backslashreplace')
 
             if kwargs.get('once', False):
                 # if you don't want once to wait you can send it to the
@@ -771,16 +889,16 @@ class Server(object):
             # any unstarted instances
             if conf_file in conf_files:
                 already_started = True
-                print(_("%(server)s running (%(pid)s - %(conf)s)") %
+                print("%(server)s running (%(pid)s - %(conf)s)" %
                       {'server': self.server, 'pid': pid, 'conf': conf_file})
             elif not kwargs.get('number', 0):
                 already_started = True
-                print(_("%(server)s running (%(pid)s - %(pid_file)s)") %
+                print("%(server)s running (%(pid)s - %(pid_file)s)" %
                       {'server': self.server, 'pid': pid,
                        'pid_file': pid_file})
 
         if already_started:
-            print(_("%s already started...") % self.server)
+            print("%s already started..." % self.server)
             return {}
 
         if self.server not in START_ONCE_SERVERS:
@@ -789,16 +907,16 @@ class Server(object):
         pids = {}
         for conf_file in conf_files:
             if kwargs.get('once'):
-                msg = _('Running %s once') % self.server
+                msg = 'Running %s once' % self.server
             else:
-                msg = _('Starting %s') % self.server
+                msg = 'Starting %s' % self.server
             print('%s...(%s)' % (msg, conf_file))
             try:
                 pid = self.spawn(conf_file, **kwargs)
             except OSError as e:
                 if e.errno == errno.ENOENT:
                     # TODO(clayg): should I check if self.cmd exists earlier?
-                    print(_("%s does not exist") % self.cmd)
+                    print("%s does not exist" % self.cmd)
                     break
                 else:
                     raise
@@ -813,3 +931,102 @@ class Server(object):
 
         """
         return self.kill_running_pids(**kwargs)
+
+
+USAGE = \
+    """%prog <server>[.<config>] [<server>[.<config>] ...] <command> [options]
+
+where:
+    <server>  is the name of a swift service e.g. proxy-server.
+              The '-server' part of the name may be omitted.
+              'all', 'main' and 'rest' are reserved words that represent a
+              group of services.
+              all: Expands to all swift daemons.
+              main: Expands to main swift daemons.
+                    (proxy, container, account, object)
+              rest: Expands to all remaining background daemons (beyond
+                    "main").
+                    (updater, replicator, auditor, etc)
+    <config>  is an explicit configuration filename without the
+              .conf extension. If <config> is specified then <server> should
+              refer to a directory containing the configuration file, e.g.:
+
+                  swift-init object.1 start
+
+              will start an object-server using the configuration file
+              /etc/swift/object-server/1.conf
+    <command> is a command from the list below.
+
+Commands:
+""" + '\n'.join(["%16s: %s" % x for x in Manager.list_commands()])
+
+
+def main():
+    parser = OptionParser(USAGE)
+    parser.add_option('-v', '--verbose', action="store_true",
+                      default=False, help="display verbose output")
+    parser.add_option('-w', '--no-wait', action="store_false", dest="wait",
+                      default=True, help="won't wait for server to start "
+                      "before returning")
+    parser.add_option('-o', '--once', action="store_true",
+                      default=False, help="only run one pass of daemon")
+    # this is a negative option, default is options.daemon = True
+    parser.add_option('-n', '--no-daemon', action="store_false", dest="daemon",
+                      default=True, help="start server interactively")
+    parser.add_option('-g', '--graceful', action="store_true",
+                      default=False, help="send SIGHUP to supporting servers")
+    parser.add_option('-c', '--config-num', metavar="N", type="int",
+                      dest="number", default=0,
+                      help="send command to the Nth server only")
+    parser.add_option('-k', '--kill-wait', metavar="N", type="int",
+                      dest="kill_wait", default=KILL_WAIT,
+                      help="wait N seconds for processes to die (default 15)")
+    parser.add_option('-r', '--run-dir', type="str",
+                      dest="run_dir", default=RUN_DIR,
+                      help="alternative directory to store running pid files "
+                      "default: %s" % RUN_DIR)
+    # Changing behaviour if missing config
+    parser.add_option('--strict', dest='strict', action='store_true',
+                      help="Return non-zero status code if some config is "
+                           "missing. Default mode if all servers are "
+                           "explicitly named.")
+    # a negative option for strict
+    parser.add_option('--non-strict', dest='strict', action='store_false',
+                      help="Return zero status code even if some config is "
+                           "missing. Default mode if any server is a glob or "
+                           "one of aliases `all`, `main` or `rest`.")
+    # SIGKILL daemon after kill_wait period
+    parser.add_option('--kill-after-timeout', dest='kill_after_timeout',
+                      action='store_true',
+                      help="Kill daemon and all children after kill-wait "
+                           "period.")
+
+    options, args = parser.parse_args()
+
+    if len(args) < 2:
+        parser.print_help()
+        print('ERROR: specify server(s) and command')
+        return 1
+
+    command = args[-1]
+    servers = args[:-1]
+
+    # this is just a silly swap for me cause I always try to "start main"
+    commands = dict(Manager.list_commands()).keys()
+    if command not in commands and servers[0] in commands:
+        servers.append(command)
+        command = servers.pop(0)
+
+    manager = Manager(servers, run_dir=options.run_dir)
+    try:
+        status = manager.run_command(command, **options.__dict__)
+    except UnknownCommandError:
+        parser.print_help()
+        print('ERROR: unknown command, %s' % command)
+        status = 1
+
+    return 1 if status else 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())