From 49da86e62cfd76626f39e2eccc7a8e7746252631 Mon Sep 17 00:00:00 2001 From: Michael Stone Date: Sun, 6 Mar 2011 17:04:06 -0500 Subject: Rename self._fields->self.env, me->my, and FIELDS->ENVIRON. --- lib/chutney/Templating.py | 2 +- lib/chutney/TorNet.py | 146 ++++++++++++++++++++++------------------------ 2 files changed, 70 insertions(+), 78 deletions(-) diff --git a/lib/chutney/Templating.py b/lib/chutney/Templating.py index eb8586f..3000512 100644 --- a/lib/chutney/Templating.py +++ b/lib/chutney/Templating.py @@ -27,7 +27,7 @@ ... def __init__(self, p=None, **kw): ... Environ.__init__(self, p, **kw) ... self._n_calls = 0 -... def _get_expensive_value(self, me): +... def _get_expensive_value(self, my): ... self._n_calls += 1 ... return "Let's pretend this is hard to compute" ... diff --git a/lib/chutney/TorNet.py b/lib/chutney/TorNet.py index f046e00..d403147 100644 --- a/lib/chutney/TorNet.py +++ b/lib/chutney/TorNet.py @@ -31,61 +31,59 @@ class Node(object): # Users are expected to call these: def __init__(self, parent=None, **kwargs): self._parent = parent - self._fields = self._createEnviron(parent, kwargs) + self.env = self._createEnviron(parent, kwargs) def getN(self, N): - return [ Node(self) for i in xrange(N) ] + return [ Node(self) for _ in xrange(N) ] def specialize(self, **kwargs): return Node(parent=self, **kwargs) + def expand(self, pat, includePath=(".",)): + return chutney.Templating.Template(pat, includePath).format(self.env) + + ####### # Users are NOT expected to call these: - def _getTorrcFname(self): - t = chutney.Templating.Template("${torrc_fname}") - return t.format(self._fields) + return self.expand("${torrc_fname}") def _createTorrcFile(self, checkOnly=False): - template = self._getTorrcTemplate() - env = self._fields fn_out = self._getTorrcFname() - output = template.format(env) + torrc_template = self._getTorrcTemplate() + output = torrc_template.format(self.env) if checkOnly: return with open(fn_out, 'w') as f: f.write(output) def _getTorrcTemplate(self): - env = self._fields - template_path = env['torrc_template_path'] - - t = "$${include:$torrc}" - return chutney.Templating.Template(t, includePath=template_path) + template_path = self.env['torrc_template_path'] + return chutney.Templating.Template("$${include:$torrc}", + includePath=template_path) def _getFreeVars(self): template = self._getTorrcTemplate() - env = self._fields - return template.freevars(env) + return template.freevars(self.env) def _createEnviron(self, parent, argdict): if parent: - parentfields = parent._fields + parentenv = parent.env else: - parentfields = self._getDefaultFields() - return TorEnviron(parentfields, **argdict) + parentenv = self._getDefaultEnviron() + return TorEnviron(parentenv, **argdict) - def _getDefaultFields(self): - return _BASE_FIELDS + def _getDefaultEnviron(self): + return _BASE_ENVIRON def _checkConfig(self, net): self._createTorrcFile(checkOnly=True) def _preConfig(self, net): self._makeDataDir() - if self._fields['authority']: + if self.env['authority']: self._genAuthorityKey() - if self._fields['relay']: + if self.env['relay']: self._genRouterKey() def _config(self, net): @@ -97,23 +95,21 @@ class Node(object): pass def _setnodenum(self, num): - self._fields['nodenum'] = num + self.env['nodenum'] = num def _makeDataDir(self): - env = self._fields - datadir = env['dir'] + datadir = self.env['dir'] mkdir_p(os.path.join(datadir, 'keys')) def _genAuthorityKey(self): - env = self._fields - datadir = env['dir'] - tor_gencert = env['tor_gencert'] - lifetime = env['auth_cert_lifetime'] + datadir = self.env['dir'] + tor_gencert = self.env['tor_gencert'] + lifetime = self.env['auth_cert_lifetime'] idfile = os.path.join(datadir,'keys',"authority_identity_key") skfile = os.path.join(datadir,'keys',"authority_signing_key") certfile = os.path.join(datadir,'keys',"authority_certificate") - addr = "%s:%s" % (env['ip'], env['dirport']) - passphrase = env['auth_passphrase'] + addr = self.expand("${ip}:${dirport}") + passphrase = self.env['auth_passphrase'] if all(os.path.exists(f) for f in [idfile, skfile, certfile]): return cmdline = [ @@ -125,15 +121,15 @@ class Node(object): '-c', certfile, '-m', str(lifetime), '-a', addr] - print "Creating identity key %s for %s with %s"%(idfile,env['nick']," ".join(cmdline)) + print "Creating identity key %s for %s with %s"%( + idfile,self.env['nick']," ".join(cmdline)) p = subprocess.Popen(cmdline, stdin=subprocess.PIPE) p.communicate(passphrase+"\n") assert p.returncode == 0 #XXXX BAD! def _genRouterKey(self): - env = self._fields - datadir = env['dir'] - tor = env['tor'] + datadir = self.env['dir'] + tor = self.env['tor'] idfile = os.path.join(datadir,'keys',"identity_key") cmdline = [ tor, @@ -147,14 +143,13 @@ class Node(object): stdout, stderr = p.communicate() fingerprint = "".join(stdout.split()[1:]) assert re.match(r'^[A-F0-9]{40}$', fingerprint) - env['fingerprint'] = fingerprint + self.env['fingerprint'] = fingerprint def _getDirServerLine(self): - env = self._fields - if not env['authority']: + if not self.env['authority']: return "" - datadir = env['dir'] + datadir = self.env['dir'] certfile = os.path.join(datadir,'keys',"authority_certificate") v3id = None with open(certfile, 'r') as f: @@ -166,16 +161,16 @@ class Node(object): assert v3id is not None return "DirServer %s v3ident=%s orport=%s %s %s:%s %s\n" %( - env['nick'], v3id, env['orport'], env['dirserver_flags'], - env['ip'], env['dirport'], env['fingerprint']) + self.env['nick'], v3id, self.env['orport'], + self.env['dirserver_flags'], self.env['ip'], self.env['dirport'], + self.env['fingerprint']) ##### Controlling a node. This should probably get split into its # own class. XXXX def getPid(self): - env = self._fields - pidfile = os.path.join(env['dir'], 'pid') + pidfile = os.path.join(self.env['dir'], 'pid') if not os.path.exists(pidfile): return None @@ -183,7 +178,6 @@ class Node(object): return int(f.read()) def isRunning(self, pid=None): - env = self._fields if pid is None: pid = self.getPid() if pid is None: @@ -196,19 +190,18 @@ class Node(object): return False raise - # okay, so the process exists. Say "True" for now. + # okay, so the process exists. Say "True" for now. # XXXX check if this is really tor! return True def check(self, listRunning=True, listNonRunning=False): - env = self._fields pid = self.getPid() running = self.isRunning(pid) - name = env['nick'] - dir = env['dir'] + nick = self.env['nick'] + dir = self.env['dir'] if running: if listRunning: - print "%s is running with PID %s"%(name,pid) + print "%s is running with PID %s"%(nick,pid) return True elif os.path.exists(os.path.join(dir, "core.%s"%pid)): if listNonRunning: @@ -223,7 +216,7 @@ class Node(object): def hup(self): pid = self.getPid() running = self.isRunning() - nick = self._fields['nick'] + nick = self.env['nick'] if self.isRunning(): print "Sending sighup to %s"%nick os.kill(pid, signal.SIGHUP) @@ -234,11 +227,11 @@ class Node(object): def start(self): if self.isRunning(): - print "%s is already running"%self._fields['nick'] + print "%s is already running"%self.env['nick'] return torrc = self._getTorrcFname() cmdline = [ - self._fields['tor'], + self.env['tor'], "--quiet", "-f", torrc, ] @@ -246,17 +239,16 @@ class Node(object): # XXXX this requires that RunAsDaemon is set. p.wait() if p.returncode != 0: - print "Couldn't launch %s (%s): %s"%(self._fields['nick'], + print "Couldn't launch %s (%s): %s"%(self.env['nick'], " ".join(cmdline), p.returncode) return False return True def stop(self, sig=signal.SIGINT): - env = self._fields pid = self.getPid() if not self.isRunning(pid): - print "%s is not running"%env['nick'] + print "%s is not running"%self.env['nick'] return os.kill(pid, sig) @@ -284,34 +276,34 @@ class TorEnviron(chutney.Templating.Environ): def __init__(self,parent=None,**kwargs): chutney.Templating.Environ.__init__(self, parent=parent, **kwargs) - def _get_orport(self, me): - return me['orport_base']+me['nodenum'] + def _get_orport(self, my): + return my['orport_base']+my['nodenum'] - def _get_controlport(self, me): - return me['controlport_base']+me['nodenum'] + def _get_controlport(self, my): + return my['controlport_base']+my['nodenum'] - def _get_socksport(self, me): - return me['socksport_base']+me['nodenum'] + def _get_socksport(self, my): + return my['socksport_base']+my['nodenum'] - def _get_dirport(self, me): - return me['dirport_base']+me['nodenum'] + def _get_dirport(self, my): + return my['dirport_base']+my['nodenum'] - def _get_dir(self, me): - return os.path.abspath(os.path.join(me['net_base_dir'], + def _get_dir(self, my): + return os.path.abspath(os.path.join(my['net_base_dir'], "nodes", - "%03d%s"%(me['nodenum'], me['tag']))) + "%03d%s"%(my['nodenum'], my['tag']))) - def _get_nick(self, me): - return "test%03d%s"%(me['nodenum'], me['tag']) + def _get_nick(self, my): + return "test%03d%s"%(my['nodenum'], my['tag']) - def _get_tor_gencert(self, me): - return me['tor']+"-gencert" + def _get_tor_gencert(self, my): + return my['tor']+"-gencert" - def _get_auth_passphrase(self, me): + def _get_auth_passphrase(self, my): return self['nick'] # OMG TEH SECURE! - def _get_torrc_template_path(self, me): - return [ os.path.join(me['privnet_dir'], 'torrc_templates') ] + def _get_torrc_template_path(self, my): + return [ os.path.join(my['privnet_dir'], 'torrc_templates') ] class Network(object): @@ -392,12 +384,12 @@ def ConfigureNodes(nodelist): network._addNode(n) def runConfigFile(verb, f): - global _BASE_FIELDS + global _BASE_ENVIRON global _THE_NETWORK - _BASE_FIELDS = TorEnviron(chutney.Templating.Environ(**DEFAULTS)) - _THE_NETWORK = Network(_BASE_FIELDS) + _BASE_ENVIRON = TorEnviron(chutney.Templating.Environ(**DEFAULTS)) + _THE_NETWORK = Network(_BASE_ENVIRON) - _GLOBALS = dict(_BASE_FIELDS= _BASE_FIELDS, + _GLOBALS = dict(_BASE_ENVIRON= _BASE_ENVIRON, Node=Node, ConfigureNodes=ConfigureNodes, _THE_NETWORK=_THE_NETWORK) -- cgit v1.2.3