code: def requestBusName(self, newName,
                         allowReplacement=False,
                         replaceExisting=False,
                         doNotQueue=True,
                         errbackUnlessAcquired=True):
          
          flags = 0
          if allowReplacement:
              flags |= 0x1
          if replaceExisting:
              flags |= 0x2
          if doNotQueue:
              flags |= 0x4
  
          d = self.callRemote(
              '/org/freedesktop/DBus',
              'RequestName',
              interface='org.freedesktop.DBus',
              signature='su',
              body=[newName, flags],
              destination='org.freedesktop.DBus',
          )
  
          def on_result(r):
              if errbackUnlessAcquired and not (
                      r == NAME_ACQUIRED or r == NAME_ALREADY_OWNER):
                  raise error.FailedToAcquireName(newName, r)
              return r
  
          d.addCallback(on_result)
  
          return d
docs: Calls org.freedesktop.DBus.RequestName to request that the specified
          bus name be associated with the connection.
  
          @type newName: C{string}
          @param newName: Bus name to acquire
  
          @type allowReplacement: C{bool}
          @param allowReplacement: If True (defaults to False) and another
              application later requests this same name, the new requester will
              be given the name and this connection will lose ownership.
  
          @type replaceExisting: C{bool}
          @param replaceExisting: If True (defaults to False) and another
              application owns the name but specified allowReplacement at the
              time of the name acquisition, this connection will assume ownership
              of the bus name.
  
          @type doNotQueue: C{bool}
          @param doNotQueue: If True (defaults to True) the name request will
              fail if the name is currently in use. If False, the request will
              cause this connection to be queued for ownership of the requested
              name
  
          @type errbackUnlessAcquired: C{bool}
          @param errbackUnlessAcquired: If True (defaults to True) an
              L{twisted.python.failure.Failure} will be returned if the name is
              not acquired.
  
          @rtype: L{twisted.internet.defer.Deferred}
          @returns: a Deferred to