# Module `src.onionrpeers.peerprofiles`

Onionr - Private P2P Communication

This file contains both the PeerProfiles class for network profiling of Onionr nodes

Expand source code

    '''
        Onionr - Private P2P Communication

        This file contains both the PeerProfiles class for network profiling of Onionr nodes
    '''
    '''
        This program is free software: you can redistribute it and/or modify
        it under the terms of the GNU General Public License as published by
        the Free Software Foundation, either version 3 of the License, or
        (at your option) any later version.

        This program is distributed in the hope that it will be useful,
        but WITHOUT ANY WARRANTY; without even the implied warranty of
        MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
        GNU General Public License for more details.

        You should have received a copy of the GNU General Public License
        along with this program.  If not, see <https://www.gnu.org/licenses/>.
    '''
    from coredb import keydb
    from onionrutils import epoch
    from onionrutils import stringvalidators
    from onionrblocks import onionrblacklist
    import onionrexceptions

    UPDATE_DELAY = 300

    class PeerProfiles:
        '''
            PeerProfiles
        '''
        def __init__(self, address):
            if not stringvalidators.validate_transport(address): raise onionrexceptions.InvalidAddress
            self.address = address # node address
            self.score = None
            self.friendSigCount = 0
            self.success = 0
            self.failure = 0
            self.connectTime = None

            self.loadScore()
            self.getConnectTime()

            self.last_updated = {'connect_time': UPDATE_DELAY, 'score': UPDATE_DELAY} # Last time a given value was updated

            if not address in keydb.listkeys.list_adders() and not onionrblacklist.OnionrBlackList().inBlacklist(address):
                keydb.addkeys.add_address(address)

        def loadScore(self):
            '''Load the node's score from the database'''
            try:
                self.success = int(keydb.transportinfo.get_address_info(self.address, 'success'))
            except (TypeError, ValueError) as e:
                self.success = 0
            self.score = self.success

        def getConnectTime(self):
            """set the connectTime variable for when we last connected to them, using the db value"""
            try:
                self.connectTime = int(keydb.transportinfo.get_address_info(self.address, 'lastConnect'))
            except (KeyError, ValueError, TypeError) as e:
                pass
            else:
                return self.connectTime

        def update_connect_time(self):
            if epoch.get_epoch() - self.last_updated['connect_time'] >= UPDATE_DELAY:
                self.last_updated['connect_time'] = epoch.get_epoch()
                keydb.transportinfo.set_address_info(self.address, 'lastConnect', epoch.get_epoch())

        def saveScore(self):
            '''Save the node's score to the database'''
            if epoch.get_epoch() - self.last_updated['score'] >= UPDATE_DELAY:
                self.last_updated['score'] = epoch.get_epoch()
                keydb.transportinfo.set_address_info(self.address, 'success', self.score)
            return

        def addScore(self, toAdd):
            '''Add to the peer's score (can add negative)'''
            self.score += toAdd
            self.saveScore()

## Classes

`class PeerProfiles (address)`

  PeerProfiles

  Expand source code

      class PeerProfiles:
          '''
              PeerProfiles
          '''
          def __init__(self, address):
              if not stringvalidators.validate_transport(address): raise onionrexceptions.InvalidAddress
              self.address = address # node address
              self.score = None
              self.friendSigCount = 0
              self.success = 0
              self.failure = 0
              self.connectTime = None

              self.loadScore()
              self.getConnectTime()

              self.last_updated = {'connect_time': UPDATE_DELAY, 'score': UPDATE_DELAY} # Last time a given value was updated

              if not address in keydb.listkeys.list_adders() and not onionrblacklist.OnionrBlackList().inBlacklist(address):
                  keydb.addkeys.add_address(address)

          def loadScore(self):
              '''Load the node's score from the database'''
              try:
                  self.success = int(keydb.transportinfo.get_address_info(self.address, 'success'))
              except (TypeError, ValueError) as e:
                  self.success = 0
              self.score = self.success

          def getConnectTime(self):
              """set the connectTime variable for when we last connected to them, using the db value"""
              try:
                  self.connectTime = int(keydb.transportinfo.get_address_info(self.address, 'lastConnect'))
              except (KeyError, ValueError, TypeError) as e:
                  pass
              else:
                  return self.connectTime

          def update_connect_time(self):
              if epoch.get_epoch() - self.last_updated['connect_time'] >= UPDATE_DELAY:
                  self.last_updated['connect_time'] = epoch.get_epoch()
                  keydb.transportinfo.set_address_info(self.address, 'lastConnect', epoch.get_epoch())

          def saveScore(self):
              '''Save the node's score to the database'''
              if epoch.get_epoch() - self.last_updated['score'] >= UPDATE_DELAY:
                  self.last_updated['score'] = epoch.get_epoch()
                  keydb.transportinfo.set_address_info(self.address, 'success', self.score)
              return

          def addScore(self, toAdd):
              '''Add to the peer's score (can add negative)'''
              self.score += toAdd
              self.saveScore()

  ### Methods

  `def addScore(self, toAdd)`

    Add to the peer's score (can add negative)

    Expand source code

        def addScore(self, toAdd):
            '''Add to the peer's score (can add negative)'''
            self.score += toAdd
            self.saveScore()

  `def getConnectTime(self)`

    set the connectTime variable for when we last connected to them, using the db value

    Expand source code

        def getConnectTime(self):
            """set the connectTime variable for when we last connected to them, using the db value"""
            try:
                self.connectTime = int(keydb.transportinfo.get_address_info(self.address, 'lastConnect'))
            except (KeyError, ValueError, TypeError) as e:
                pass
            else:
                return self.connectTime

  `def loadScore(self)`

    Load the node's score from the database

    Expand source code

        def loadScore(self):
            '''Load the node's score from the database'''
            try:
                self.success = int(keydb.transportinfo.get_address_info(self.address, 'success'))
            except (TypeError, ValueError) as e:
                self.success = 0
            self.score = self.success

  `def saveScore(self)`

    Save the node's score to the database

    Expand source code

        def saveScore(self):
            '''Save the node's score to the database'''
            if epoch.get_epoch() - self.last_updated['score'] >= UPDATE_DELAY:
                self.last_updated['score'] = epoch.get_epoch()
                keydb.transportinfo.set_address_info(self.address, 'success', self.score)
            return

  `def update_connect_time(self)`
    Expand source code

        def update_connect_time(self):
            if epoch.get_epoch() - self.last_updated['connect_time'] >= UPDATE_DELAY:
                self.last_updated['connect_time'] = epoch.get_epoch()
                keydb.transportinfo.set_address_info(self.address, 'lastConnect', epoch.get_epoch())