Source Code for Module buildbot.pbutil

  1   
  2  """Base classes handy for use with PB clients. 
  3  """ 
  4   
  5  from twisted.spread import pb 
  6   
  7  from twisted.spread.pb import PBClientFactory 
  8  from twisted.internet import protocol 
  9  from twisted.python import log 
 10   
 11 -class NewCredPerspective(pb.Avatar): 
 12 -    def attached(self, mind): 
 13          return self 
 14 -    def detached(self, mind): 
 15          pass 
 16   
 17 -class ReconnectingPBClientFactory(PBClientFactory, 
 18                                    protocol.ReconnectingClientFactory): 
 19      """Reconnecting client factory for PB brokers. 
 20   
 21      Like PBClientFactory, but if the connection fails or is lost, the factory 
 22      will attempt to reconnect. 
 23   
 24      Instead of using f.getRootObject (which gives a Deferred that can only 
 25      be fired once), override the gotRootObject method. 
 26   
 27      Instead of using the newcred f.login (which is also one-shot), call 
 28      f.startLogin() with the credentials and client, and override the 
 29      gotPerspective method. 
 30   
 31      Instead of using the oldcred f.getPerspective (also one-shot), call 
 32      f.startGettingPerspective() with the same arguments, and override 
 33      gotPerspective. 
 34   
 35      gotRootObject and gotPerspective will be called each time the object is 
 36      received (once per successful connection attempt). You will probably want 
 37      to use obj.notifyOnDisconnect to find out when the connection is lost. 
 38   
 39      If an authorization error occurs, failedToGetPerspective() will be 
 40      invoked. 
 41   
 42      To use me, subclass, then hand an instance to a connector (like 
 43      TCPClient). 
 44      """ 
 45   
 46 -    def __init__(self): 
 47          PBClientFactory.__init__(self) 
 48          self._doingLogin = False 
 49          self._doingGetPerspective = False 
 50   
 51 -    def clientConnectionFailed(self, connector, reason): 
 52          PBClientFactory.clientConnectionFailed(self, connector, reason) 
 53          # Twisted-1.3 erroneously abandons the connection on non-UserErrors. 
 54          # To avoid this bug, don't upcall, and implement the correct version 
 55          # of the method here. 
 56          if self.continueTrying: 
 57              self.connector = connector 
 58              self.retry() 
 59   
 60 -    def clientConnectionLost(self, connector, reason): 
 61          PBClientFactory.clientConnectionLost(self, connector, reason, 
 62                                               reconnecting=True) 
 63          RCF = protocol.ReconnectingClientFactory 
 64          RCF.clientConnectionLost(self, connector, reason) 
 65   
 66 -    def clientConnectionMade(self, broker): 
 67          self.resetDelay() 
 68          PBClientFactory.clientConnectionMade(self, broker) 
 69          if self._doingLogin: 
 70              self.doLogin(self._root) 
 71          if self._doingGetPerspective: 
 72              self.doGetPerspective(self._root) 
 73          self.gotRootObject(self._root) 
 74   
 75 -    def __getstate__(self): 
 76          # this should get folded into ReconnectingClientFactory 
 77          d = self.__dict__.copy() 
 78          d['connector'] = None 
 79          d['_callID'] = None 
 80          return d 
 81   
 82      # oldcred methods 
 83   
 84 -    def getPerspective(self, *args): 
 85          raise RuntimeError, "getPerspective is one-shot: use startGettingPerspective instead" 
 86   
 87 -    def startGettingPerspective(self, username, password, serviceName, 
 88                                  perspectiveName=None, client=None): 
 89          self._doingGetPerspective = True 
 90          if perspectiveName == None: 
 91              perspectiveName = username 
 92          self._oldcredArgs = (username, password, serviceName, 
 93                               perspectiveName, client) 
 94   
 95 -    def doGetPerspective(self, root): 
 96          # oldcred getPerspective() 
 97          (username, password, 
 98           serviceName, perspectiveName, client) = self._oldcredArgs 
 99          d = self._cbAuthIdentity(root, username, password) 
100          d.addCallback(self._cbGetPerspective, 
101                        serviceName, perspectiveName, client) 
102          d.addCallbacks(self.gotPerspective, self.failedToGetPerspective) 
103   
104   
105      # newcred methods 
106   
107 -    def login(self, *args): 
108          raise RuntimeError, "login is one-shot: use startLogin instead" 
109   
110 -    def startLogin(self, credentials, client=None): 
111          self._credentials = credentials 
112          self._client = client 
113          self._doingLogin = True 
114   
115 -    def doLogin(self, root): 
116          # newcred login() 
117          d = self._cbSendUsername(root, self._credentials.username, 
118                                   self._credentials.password, self._client) 
119          d.addCallbacks(self.gotPerspective, self.failedToGetPerspective) 
120   
121   
122      # methods to override 
123   
124 -    def gotPerspective(self, perspective): 
125          """The remote avatar or perspective (obtained each time this factory 
126          connects) is now available.""" 
127          pass 
128   
129 -    def gotRootObject(self, root): 
130          """The remote root object (obtained each time this factory connects) 
131          is now available. This method will be called each time the connection 
132          is established and the object reference is retrieved.""" 
133          pass 
134   
135 -    def failedToGetPerspective(self, why): 
136          """The login process failed, most likely because of an authorization 
137          failure (bad password), but it is also possible that we lost the new 
138          connection before we managed to send our credentials. 
139          """ 
140          log.msg("ReconnectingPBClientFactory.failedToGetPerspective") 
141          if why.check(pb.PBConnectionLost): 
142              log.msg("we lost the brand-new connection") 
143              # retrying might help here, let clientConnectionLost decide 
144              return 
145          # probably authorization 
146          self.stopTrying() # logging in harder won't help 
147          log.err(why) 
148