Ticket #14332: 0001-Replace-printf-style-formatting-with-the-newer-str.f.patch

File 0001-Replace-printf-style-formatting-with-the-newer-str.f.patch, 20.6 KB (added by cypherpunks, 5 years ago)
  • lib/chutney/Templating.py

    From 80b96949a578ea5da6a1cf168bbb9e1389a0e4bf Mon Sep 17 00:00:00 2001
    From: cypherpunks <cypherpunks@torproject.org>
    Date: Fri, 16 Jan 2015 13:45:08 +0100
    Subject: [PATCH] Replace printf-style formatting with the newer str.format()
     interface.
    
    ---
     lib/chutney/Templating.py |   2 +-
     lib/chutney/TorNet.py     | 127 ++++++++++++++++++++++------------------------
     lib/chutney/Traffic.py    |  33 ++++++------
     3 files changed, 81 insertions(+), 81 deletions(-)
    
    diff --git a/lib/chutney/Templating.py b/lib/chutney/Templating.py
    index a8f638f..fb5b38d 100644
    a b class Environ(_DictWrapper): 
    209209        except KeyError:
    210210            pass
    211211
    212         fn = getattr(self, "_get_%s" % key, None)
     212        fn = getattr(self, "_get_{}".format(key), None)
    213213        if fn is not None:
    214214            try:
    215215                rv = fn(my)
  • lib/chutney/TorNet.py

    diff --git a/lib/chutney/TorNet.py b/lib/chutney/TorNet.py
    index 439aa10..c1c0e19 100644
    a b class LocalNodeBuilder(NodeBuilder): 
    250250            except OSError as e:
    251251                # only catch file not found error
    252252                if e.errno == errno.ENOENT:
    253                     print ("Cannot find tor binary %r. Use "
    254                            "CHUTNEY_TOR environment variable to set the "
    255                            "path, or put the binary into $PATH.") % tor
     253                    print("Cannot find tor binary {!r}. Use "
     254                          "CHUTNEY_TOR environment variable to set the "
     255                          "path, or put the binary into $PATH.".format(tor))
    256256                    sys.exit(0)
    257257                else:
    258258                    raise
    class LocalNodeBuilder(NodeBuilder): 
    286286                    # well, this could get spammy
    287287                    # TODO: warn once per option per tor binary
    288288                    # TODO: print tor version?
    289                     print (("The tor binary at %r does not support the "
    290                            "option in the torrc line:\n"
    291                            "%r") % (tor, line.strip()))
     289                    print("The tor binary at {!r} does not support the "
     290                          "option in the torrc line:\n{!r}".format(
     291                              tor, line.strip()))
    292292                    # we could decide to skip these lines entirely
    293293                    # TODO: write tor version?
    294294                    f.writelines(["# " + tor + " unsupported: " + line])
    class LocalNodeBuilder(NodeBuilder): 
    375375            '-c', certfile,
    376376            '-m', str(lifetime),
    377377            '-a', addr]
    378         print("Creating identity key %s for %s with %s" % (
     378        print("Creating identity key {} for {} with {}".format(
    379379            idfile, self._env['nick'], " ".join(cmdline)))
    380380        try:
    381381            p = subprocess.Popen(cmdline, stdin=subprocess.PIPE)
    382382        except OSError as e:
    383383            # only catch file not found error
    384384            if e.errno == errno.ENOENT:
    385                 print("Cannot find tor-gencert binary %r. Use "
     385                print("Cannot find tor-gencert binary {!r}. Use "
    386386                      "CHUTNEY_TOR_GENCERT environment variable to set the "
    387                       "path, or put the binary into $PATH.") % tor_gencert
     387                      "path, or put the binary into "
     388                      "$PATH.".format(tor_gencert))
    388389                sys.exit(0)
    389390            else:
    390391                raise
    class LocalNodeBuilder(NodeBuilder): 
    410411        except OSError as e:
    411412            # only catch file not found error
    412413            if e.errno == errno.ENOENT:
    413                 print("Cannot find tor binary %r. Use "
    414                       "CHUTNEY_TOR environment variable to set the "
    415                       "path, or put the binary into $PATH.") % tor
     414                print("Cannot find tor binary {!r}. Use CHUTNEY_TOR "
     415                      "environment variable to set the path, or put the "
     416                      "binary into $PATH.".format(tor))
    416417                sys.exit(0)
    417418            else:
    418419                raise
    419420        stdout, stderr = p.communicate()
    420421        fingerprint = "".join(stdout.split()[1:])
    421422        if not re.match(r'^[A-F0-9]{40}$', fingerprint):
    422             print (("Error when calling %r. It gave %r as a fingerprint "
    423                     " and %r on stderr.")%(" ".join(cmdline), stdout, stderr))
     423            print("Error when calling {!r}. It gave {!r} as a fingerprint "
     424                  " and {!r} on stderr.".format(
     425                      " ".join(cmdline), stdout, stderr))
    424426            sys.exit(1)
    425427        self._env['fingerprint'] = fingerprint
    426428
    class LocalNodeBuilder(NodeBuilder): 
    456458                options = ("AlternateDirAuthority",)
    457459            else:
    458460                options = ("DirAuthority",)
    459             self._env['dirserver_flags'] += " hs v3ident=%s" % v3id
     461            self._env['dirserver_flags'] += " hs v3ident={}".format(v3id)
    460462
    461463        authlines = ""
    462464        for authopt in options:
    463             authlines += "%s %s orport=%s %s %s:%s %s\n" % (
     465            authlines += "{} {} orport={} {} {}:{} {}\n".format(
    464466                authopt, self._env['nick'], self._env['orport'],
    465467                self._env['dirserver_flags'], self._env['ip'],
    466468                self._env['dirport'], self._env['fingerprint'])
    class LocalNodeBuilder(NodeBuilder): 
    473475        if not self._env['bridge']:
    474476            return ""
    475477
    476         bridgelines = "Bridge %s:%s\n" % (self._env['ip'],
    477                                           self._env['orport'])
     478        bridgelines = "Bridge {}:{}\n".format(self._env['ip'],
     479                                              self._env['orport'])
    478480        if self._env['ipv6_addr'] is not None:
    479             bridgelines += "Bridge %s:%s\n" % (self._env['ipv6_addr'],
    480                                                self._env['orport'])
     481            bridgelines += "Bridge {}:{}\n".format(self._env['ipv6_addr'],
     482                                                   self._env['orport'])
    481483        return bridgelines
    482484
    483485
    class LocalNodeController(NodeController): 
    531533        pid = self.getPid()
    532534        nick = self._env['nick']
    533535        datadir = self._env['dir']
    534         corefile = "core.%s" % pid
     536        corefile = "core.{}".format(pid)
    535537        if self.isRunning(pid):
    536538            if listRunning:
    537                 print("%s is running with PID %s" % (nick, pid))
     539                print("{} is running with PID {}".format(nick, pid))
    538540            return True
    539541        elif os.path.exists(os.path.join(datadir, corefile)):
    540542            if listNonRunning:
    541                 print("%s seems to have crashed, and left core file %s" % (
    542                     nick, corefile))
     543                print("{} seems to have crashed, and left core file "
     544                      "{}".format(nick, corefile))
    543545            return False
    544546        else:
    545547            if listNonRunning:
    546                 print("%s is stopped" % nick)
     548                print("{} is stopped".format(nick))
    547549            return False
    548550
    549551    def hup(self):
    class LocalNodeController(NodeController): 
    551553        pid = self.getPid()
    552554        nick = self._env['nick']
    553555        if self.isRunning(pid):
    554             print("Sending sighup to %s" % nick)
     556            print("Sending sighup to {}".format(nick))
    555557            os.kill(pid, signal.SIGHUP)
    556558            return True
    557559        else:
    558             print("%s is not running" % nick)
     560            print("{} is not running".format(nick))
    559561            return False
    560562
    561563    def start(self):
    class LocalNodeController(NodeController): 
    563565           already running, False if we failed."""
    564566
    565567        if self.isRunning():
    566             print("%s is already running" % self._env['nick'])
     568            print("{} is already running".format(self._env['nick']))
    567569            return True
    568570        tor_path = self._env['tor']
    569571        torrc = self._getTorrcFname()
    class LocalNodeController(NodeController): 
    577579        except OSError as e:
    578580            # only catch file not found error
    579581            if e.errno == errno.ENOENT:
    580                 print("Cannot find tor binary %r. Use CHUTNEY_TOR "
     582                print("Cannot find tor binary {!r}. Use CHUTNEY_TOR "
    581583                      "environment variable to set the path, or put the "
    582                       "binary into $PATH.") % tor_path
     584                      "binary into $PATH.".format(tor_path))
    583585                sys.exit(0)
    584586            else:
    585587                raise
    class LocalNodeController(NodeController): 
    602604            p.poll()
    603605        if p.returncode != None and p.returncode != 0:
    604606            if self._env['poll_launch_time'] is None:
    605                 print("Couldn't launch %s (%s): %s" % (self._env['nick'],
    606                                                        " ".join(cmdline),
    607                                                        p.returncode))
     607                print("Couldn't launch {} ({}): {}".format(
     608                    self._env['nick'], " ".join(cmdline), p.returncode))
    608609            else:
    609                 print("Couldn't poll %s (%s) "
    610                        "after waiting %s seconds for launch"
    611                        ": %s" % (self._env['nick'],
    612                                   " ".join(cmdline),
    613                                   self._env['poll_launch_time'],
    614                                   p.returncode))
     610                print("Couldn't poll {} ({}) after waiting {} seconds for "
     611                      "launch: {}".format(self._env['nick'], " ".join(cmdline),
     612                                          self._env['poll_launch_time'],
     613                                          p.returncode))
    615614            return False
    616615        return True
    617616
    class LocalNodeController(NodeController): 
    619618        """Try to stop this node by sending it the signal 'sig'."""
    620619        pid = self.getPid()
    621620        if not self.isRunning(pid):
    622             print("%s is not running" % self._env['nick'])
     621            print("{} is not running".format(self._env['nick']))
    623622            return
    624623        os.kill(pid, sig)
    625624
    626625    def cleanup_lockfile(self):
    627626        lf = self._env['lockfile']
    628627        if not self.isRunning() and os.path.exists(lf):
    629             print('Removing stale lock file for {0} ...'.format(
     628            print("Removing stale lock file for {} ...".format(
    630629                self._env['nick']))
    631630            os.remove(lf)
    632631
    class TorEnviron(chutney.Templating.Environ): 
    739738        return my['dirport_base'] + my['nodenum']
    740739
    741740    def _get_dir(self, my):
    742         return os.path.abspath(os.path.join(my['net_base_dir'],
    743                                             "nodes",
    744                                             "%03d%s" % (
    745                                                 my['nodenum'], my['tag'])))
     741        return os.path.abspath(os.path.join(my['net_base_dir'], "nodes",
     742                                            "{:03d}{}".format(my['nodenum'],
     743                                                              my['tag'])))
    746744
    747745    def _get_nick(self, my):
    748         return "test%03d%s" % (my['nodenum'], my['tag'])
     746        return "test{:03d}{}".format(my['nodenum'], my['tag'])
    749747
    750748    def _get_tor_gencert(self, my):
    751749        return my['tor-gencert'] or '{0}-gencert'.format(my['tor'])
    class TorEnviron(chutney.Templating.Environ): 
    778776                hostname = hostname.strip()
    779777                my['hs-hostname'] = hostname
    780778            except IOError as e:
    781                 print("Error: hs %r error %d: %r opening hostname file '%r'"
    782                       %(my['nick'], e.errno, e.strerror, hs_hostname_file))
     779                print("Error: hs {!r} error {:d}: {!r} opening hostname file "
     780                      "{!r}".format(
     781                          my['nick'], e.errno, e.strerror, hs_hostname_file))
    783782        return my['hs-hostname']
    784783
    785784
    class Network(object): 
    804803        if not os.path.exists(nodesdir):
    805804            return
    806805
    807         newdir = newdirbase = "%s.%d" % (nodesdir, time.time())
     806        newdir = newdirbase = "{}.{:f}".format(nodesdir, time.time())
    808807        i = 0
    809808        while os.path.exists(newdir):
    810809            i += 1
    811             newdir = "%s.%d" %(newdirbase, i)
     810            newdir = "{}.{:d}".format(newdirbase, i)
    812811
    813         print ("NOTE: renaming %r to %r"%(nodesdir, newdir))
     812        print("NOTE: renaming {!r} to {!r}".format(nodesdir, newdir))
    814813        os.rename(nodesdir, newdir)
    815814
    816815    def _checkConfig(self):
    class Network(object): 
    847846    def status(self):
    848847        statuses = [n.getController().check() for n in self._nodes]
    849848        n_ok = len([x for x in statuses if x])
    850         print("%d/%d nodes are running" % (n_ok, len(self._nodes)))
     849        print("{:d}/{:d} nodes are running".format(n_ok, len(self._nodes)))
    851850        return n_ok == len(self._nodes)
    852851
    853852    def restart(self):
    class Network(object): 
    878877        for sig, desc in [(signal.SIGINT, "SIGINT"),
    879878                          (signal.SIGINT, "another SIGINT"),
    880879                          (signal.SIGKILL, "SIGKILL")]:
    881             print("Sending %s to nodes" % desc)
     880            print("Sending {} to nodes".format(desc))
    882881            for c in controllers:
    883882                if c.isRunning():
    884883                    c.stop(sig=sig)
    class Network(object): 
    898897    def verify(self):
    899898        print("Verifying data transmission:")
    900899        status = self._verify_traffic()
    901         print("Transmission: %s" % ("Success" if status else "Failure"))
     900        print("Transmission: {}".format("Success" if status else "Failure"))
    902901        return status
    903902
    904903    def _verify_traffic(self):
    class Network(object): 
    922921            return False
    923922        # Each client binds directly to 127.0.0.1:LISTEN_PORT via an Exit relay
    924923        for op in client_list:
    925             print("  Exit to %s:%d via client %s:%s"
    926                    % ('127.0.0.1', LISTEN_PORT,
    927                       'localhost', op._env['socksport']))
     924            print("  Exit to {}:{:d} via client {}:{}".format(
     925                '127.0.0.1', LISTEN_PORT, 'localhost', op._env['socksport']))
    928926            tt.add(chutney.Traffic.Source(tt, bind_to, tmpdata,
    929927                                          ('localhost',
    930928                                           int(op._env['socksport']))))
    class Network(object): 
    940938            bind_to = (hs._env['hs_hostname'], HS_PORT)
    941939            # Just choose the first client
    942940            client = client_list[0]
    943             print("  HS to %s:%d (%s:%d) via client %s:%s"
    944                   % (hs._env['hs_hostname'], HS_PORT,
    945                      '127.0.0.1', LISTEN_PORT,
    946                      'localhost', client._env['socksport']))
     941            print("  HS to {}:{:d} ({}:{:d}) via client {}:{}".format(
     942                hs._env['hs_hostname'], HS_PORT, '127.0.0.1', LISTEN_PORT,
     943                'localhost', client._env['socksport']))
    947944            tt.add(chutney.Traffic.Source(tt, bind_to, tmpdata,
    948945                                          ('localhost',
    949946                                           int(client._env['socksport']))))
    def ConfigureNodes(nodelist): 
    961958
    962959def usage(network):
    963960    return "\n".join(["Usage: chutney {command} {networkfile}",
    964                       "Known commands are: %s" % (
     961                      "Known commands are: {}".format(
    965962                          " ".join(x for x in dir(network)
    966963                                   if not x.startswith("_")))])
    967964
    968965
    969966def exit_on_error(err_msg):
    970     print ("Error: {0}\n".format(err_msg))
    971     print (usage(_THE_NETWORK))
     967    print("Error: {}\n".format(err_msg))
     968    print(usage(_THE_NETWORK))
    972969    sys.exit(1)
    973970
    974971def runConfigFile(verb, data):
    def runConfigFile(verb, data): 
    982979
    983980    if not hasattr(network, verb):
    984981        print(usage(network))
    985         print("Error: I don't know how to %s." % verb)
     982        print("Error: I don't know how to {}.".format(verb))
    986983        return
    987984
    988985    return getattr(network, verb)()
  • lib/chutney/Traffic.py

    diff --git a/lib/chutney/Traffic.py b/lib/chutney/Traffic.py
    index 46db0f2..a97297f 100644
    a b debug_flag = False 
    3636def debug(s):
    3737    "Print a debug message on stdout if debug_flag is True."
    3838    if debug_flag:
    39         print("DEBUG: %s" % s)
     39        print("DEBUG: {}".format(s))
    4040
    4141
    4242def socks_cmd(addr_port):
    def socks_cmd(addr_port): 
    5555        addr = socket.inet_aton(host)
    5656    except socket.error:
    5757        addr = '\x00\x00\x00\x01'
    58         dnsname = '%s\x00' % host
    59     debug("Socks 4a request to %s:%d" % (host, port))
     58        dnsname = '{}\x00'.format(host)
     59    debug("Socks 4a request to {}:{:d}".format(host, port))
    6060    return struct.pack('!BBH', ver, cmd, port) + addr + user + dnsname
    6161
    6262
    class TestSuite(object): 
    8888        return self.not_done == 0
    8989
    9090    def status(self):
    91         return('%d/%d/%d' % (self.not_done, self.successes, self.failures))
     91        return '{:d}/{:d}/{:d}'.format(self.not_done, self.successes,
     92                                       self.failures)
    9293
    9394
    9495class Peer(object):
    class Listener(Peer): 
    129130
    130131    def accept(self):
    131132        newsock, endpoint = self.s.accept()
    132         debug("new client from %s:%s (fd=%d)" %
    133               (endpoint[0], endpoint[1], newsock.fileno()))
     133        debug("new client from {}:{} (fd={:d})".format(endpoint[0],
     134                                                       endpoint[1],
     135                                                       newsock.fileno()))
    134136        self.tt.add(Sink(self.tt, newsock))
    135137
    136138
    class Source(Peer): 
    197199            self.inbuf += self.s.recv(8 - len(self.inbuf))
    198200            if len(self.inbuf) == 8:
    199201                if ord(self.inbuf[0]) == 0 and ord(self.inbuf[1]) == 0x5a:
    200                     debug("proxy handshake successful (fd=%d)" % self.fd())
     202                    debug("proxy handshake successful "
     203                          "(fd={:d})".format(self.fd()))
    201204                    self.state = self.CONNECTED
    202205                    self.inbuf = ''
    203206                    self.outbuf = self.data
    204                     debug("successfully connected (fd=%d)" % self.fd())
     207                    debug("successfully connected (fd={:d})".format(self.fd()))
    205208                    return 1    # Keep us around for writing.
    206209                else:
    207                     debug("proxy handshake failed (0x%x)! (fd=%d)" %
    208                           (ord(self.inbuf[1]), self.fd()))
     210                    debug("proxy handshake failed (0x{:x})! (fd={:d})".format(
     211                        ord(self.inbuf[1]), self.fd()))
    209212                    self.state = self.NOT_CONNECTED
    210213                    return -1
    211214            assert(8 - len(self.inbuf) > 0)
    class Source(Peer): 
    225228            if self.proxy is None:
    226229                self.state = self.CONNECTED
    227230                self.outbuf = self.data
    228                 debug("successfully connected (fd=%d)" % self.fd())
     231                debug("successfully connected (fd={:d})".format(self.fd()))
    229232            else:
    230233                self.state = self.CONNECTING_THROUGH_PROXY
    231234                self.outbuf = socks_cmd(self.dest)
    class Source(Peer): 
    233236            n = self.s.send(self.outbuf)
    234237        except socket.error as e:
    235238            if e[0] == errno.ECONNREFUSED:
    236                 debug("connection refused (fd=%d)" % self.fd())
     239                debug("connection refused (fd={:d})".format(self.fd()))
    237240                return -1
    238241            raise
    239242        self.outbuf = self.outbuf[n:]
    class TrafficTester(): 
    258261        self.timeout = timeout
    259262        self.tests = TestSuite()
    260263        self.data = data
    261         debug("listener fd=%d" % self.listener.fd())
     264        debug("listener fd={:d}".format(self.listener.fd()))
    262265        self.peers = {}         # fd:Peer
    263266
    264267    def sinks(self):
    class TrafficTester(): 
    284287            rset = [self.listener.fd()] + list(self.peers)
    285288            wset = [p.fd() for p in
    286289                    filter(lambda x: x.want_to_write(), self.sources())]
    287             # debug("rset %s wset %s" % (rset, wset))
     290            # debug("rset {} wset {}".format(rset, wset))
    288291            sets = select.select(rset, wset, [], 1)
    289292            if all(len(s) == 0 for s in sets):
    290293                self.timeout -= 1
    class TrafficTester(): 
    297300                p = self.peers[fd]
    298301                n = p.on_readable()
    299302                if n > 0:
    300                     # debug("need %d more octets from fd %d" % (n, fd))
     303                    # debug("need {:d} more octets from fd {:d}".format(n, fd))
    301304                    pass
    302305                elif n == 0:  # Success.
    303306                    self.tests.success()