clicada/clicada/user/file.py

# standard imports
import stat
import os
import logging
import json
import urllib.parse
import datetime

# external imports
from hexathon import strip_0x
from cic_types.condiments import MetadataPointer
from cic_types.ext.metadata import MetadataRequestsHandler
from cic_types.models.person import Person
from cic_types.ext.requests import make_request
from cic_types.processor import generate_metadata_pointer
import requests.exceptions
import phonenumbers

# local imports
from clicada.encode import tx_normalize
from clicada.store.mem import MemDictStore
from clicada.error import ExpiredRecordError

logg = logging.getLogger(__name__)


class FileUserStore:

    def __init__(self, chain_spec, label, store_base_path, ttl):
        invalidate_before = datetime.datetime.now() - datetime.timedelta(seconds=ttl)
        self.invalidate_before = int(invalidate_before.timestamp())
        self.have_xattr = False
        self.label = label
        self.store_path = os.path.join(
                store_base_path,
                chain_spec.arch(),
                chain_spec.fork(),
                str(chain_spec.network_id()),
                self.label,
                )
        self.memstore_entity = MemDictStore()
        os.makedirs(self.store_path, exist_ok=True)
        self.__validate_dir()


    def __validate_dir(self):
        st = os.stat(self.store_path)
        if stat.S_ISDIR(st.st_mode):
            logg.debug('using existing file store {} for {}'.format(self.store_path, self.label))


    def put(self, k, v, force=False):
        have_file = False
        p = os.path.join(self.store_path, k)
        its_time = True
        try:
            st = os.stat(p)
            have_file = True
            its_time = st[stat.ST_MTIME] < self.invalidate_before
        except FileNotFoundError:
            pass

        if have_file and not its_time and not force:
            raise FileExistsError('user resolution already exists for {}'.format(k))

        f = open(p, 'w')
        f.write(v)
        f.close()

        logg.info('added user store {} record {} -> {}'.format(self.label, k, v))


    def stick(self, k):
        p = os.path.join(self.store_path, k)

        if self.have_xattr:
            os.setxattr(p, 'cic_sticky', b'1')
        else:
            (s_h, s_t) = os.path.split(p)
            sp = os.path.join(s_h, '.stick_' + s_t)
            f = open(sp, 'w')
            f.close()
            logg.debug('wrote {}'.format(sp))


    def __is_sticky(self, p):
        if self.have_xattr:
            if not os.getxattr(p, 'cic_sticky'):
                return False
        else:
            (s_h, s_t) = os.path.split(p)
            sp = os.path.join(s_h, '.stick_' + s_t)
            try:
                os.stat(sp)
            except FileNotFoundError:
                return False
        return True


    def __unstick(self, p):
        (s_h, s_t) = os.path.split(p)
        sp = os.path.join(s_h, '.stick_' + s_t)
        os.unlink(sp)


    def path(self, k):
        return os.path.join(self.store_path, k)


    def sticky(self, k):
        p = self.path(k)
        return self.__is_sticky(p)


    def check_expiry(self, p):
        st = os.stat(p)
        if st[stat.ST_MTIME] < self.invalidate_before:
            if self.__is_sticky(p):
                logg.debug('ignoring sticky record expiry for {}'.format(p))
                return
            raise ExpiredRecordError('record in {} is expired'.format(p))


    def get(self, k, ignore_expired=False):
        try:
            p = os.path.join(self.store_path, k)
        except FileNotFoundError as e:
            if self.__is_sticky(p):
                logg.warning('removed orphaned sticky record for ' + p)
                self.__unstick(p)
        self.check_expiry(p)

        f = open(p, 'r')
        r = f.read()
        f.close()
        return r.strip()


    def by_phone(self, phone, update=False):
        phone = phonenumbers.parse(phone, None)
        phone = phonenumbers.format_number(phone, phonenumbers.PhoneNumberFormat.E164)
        phone_file = phone.replace('+', '')

        ignore_expired = self.sticky(phone_file)

        if not update:
            try:
                v = self.get(phone_file, ignore_expired=ignore_expired)
                return v
            except FileNotFoundError:
                pass
            except ExpiredRecordError as e:
                logg.info(e)
                pass
            
        #getter = MetadataRequestsHandler(MetadataPointer.PHONE, phone.encode('utf-8'))
        r = None
        user_address = None
        try:
            ptr = generate_metadata_pointer(phone.encode('utf-8'), MetadataPointer.PHONE)
            url = urllib.parse.urljoin(MetadataRequestsHandler.base_url, ptr)
            r = make_request('GET', url)
            user_address = r.json()
        except requests.exceptions.HTTPError as e:
            logg.debug('no address found for phone {}: {}'.format(phone, e))
            return None

        self.put(phone_file, user_address)
        return user_address

    
    def by_address(self, address, update=False):
        add = tx_normalize.wallet_address(address)
        ignore_expired = self.sticky(address)

        if not update:
            try:
                v = self.get(address, ignore_expired=ignore_expired)
                v = json.loads(v)
                person = Person()
                try:
                    person_data = person.deserialize(person_data=v)
                except Exception as e:
                    person_data = v
                return str(person_data)
            except FileNotFoundError:
                pass
            except ExpiredRecordError as e:
                logg.info(e)
                pass

        address = strip_0x(address)
        getter = MetadataRequestsHandler(MetadataPointer.PERSON, bytes.fromhex(address))
        r = None
        try:
            r = getter.query()
        except requests.exceptions.HTTPError as e:
            logg.debug('no metadata found for {}: {}'.format(address, e))
            return address

        data = r.json()
        person = Person()
        person_data = person.deserialize(person_data=data)
        self.put(address, json.dumps(person_data.serialize()))
        return person_data