Merge remote-tracking branch 'origin/master' into philip/fix-filter-callbacks

.gitignore

@@ -1,10 +1,2 @@
 service-configs/*
 !service-configs/.gitkeep
-**/node_modules/
-__pycache__
-*.pyc
-*.o
-gmon.out
-*.egg-info
-dist/
-build/

apps/cic-cache/cic_cache/runnable/daemons/filters/erc20.py

@@ -67,7 +67,6 @@ class ERC20TransferFilter(SyncFilter):
                 tx.status == Status.SUCCESS,
                 block.timestamp,
                 )
-        #db_session.flush()
-        db_session.commit()
+        db_session.flush()
 
         return True

apps/cic-cache/cic_cache/runnable/daemons/tracker.py

@@ -77,7 +77,7 @@ def main():
 
     if len(syncer_backends) == 0:
         logg.info('found no backends to resume')
-        syncer_backends.append(SQLBackend.initial(chain_spec, block_offset))
+        syncers.append(SQLBackend.initial(chain_spec, block_offset))
     else:
         for syncer_backend in syncer_backends:
             logg.info('resuming sync session {}'.format(syncer_backend))

apps/cic-cache/docker/start_tracker.sh

@@ -2,9 +2,4 @@
 
 . ./db.sh
 
-if [ $? -ne "0" ]; then
-	>&2 echo db migrate fail
-	exit 1
-fi
-
 /usr/local/bin/cic-cache-trackerd $@

apps/cic-eth/cic_eth/eth/meta.py

@@ -66,10 +66,10 @@ class ExtendedTx:
         self.status_code = n
 
 
-    def asdict(self):
+    def to_dict(self):
         o = {}
         for attr in dir(self):
-            if attr[0] == '_' or attr in ['set_actors', 'set_tokens', 'set_status', 'asdict', 'rpc']:
+            if attr[0] == '_' or attr in ['set_actors', 'set_tokens', 'set_status', 'to_dict']:
                 continue
             o[attr] = getattr(self, attr)
         return o 

apps/cic-eth/cic_eth/k8s/db.py

@@ -1,7 +0,0 @@
-from cic_eth.db.models.base import SessionBase
-
-def health(*args, **kwargs):
-    session = SessionBase.create_session()
-    session.execute('SELECT count(*) from alembic_version')
-    session.close()
-    return True

apps/cic-eth/cic_eth/runnable/daemons/filters/callback.py

@@ -78,19 +78,19 @@ class CallbackFilter(SyncFilter):
 
         o = c.amount(faucet_contract, sender_address=self.caller_address)
         r = conn.do(o)
-        transfer_data['value'] = c.parse_amount(r)
+        transfer_data['amount'] = add_0x(c.parse_amount(r))
 
         return ('tokengift', transfer_data)
 
 
     def call_back(self, transfer_type, result):
-        result['chain_spec'] = result['chain_spec'].asdict()
+        logg.debug('result {}'.format(result))
         s = celery.signature(
             self.method,
             [
                 result,
                 transfer_type,
-                int(result['status_code'] != 0),
+                int(result['status_code'] == 0),
             ],
             queue=self.queue,
             )
@@ -106,7 +106,7 @@ class CallbackFilter(SyncFilter):
 #        s_translate.link(s)
 #        s_translate.apply_async()
         t = s.apply_async()
-        return t
+        return s
 
 
     def parse_data(self, tx, conn):
@@ -167,9 +167,8 @@ class CallbackFilter(SyncFilter):
                     tokentx.set_status(1)
                 else:
                     tokentx.set_status(0)
-                result = tokentx.asdict()
-                t = self.call_back(transfer_type, result)
-                logg.info('callback success task id {} tx {} queue {}'.format(t, tx.hash, t.queue))
+                t = self.call_back(transfer_type, tokentx.to_dict())
+                logg.info('callback success task id {} tx {}'.format(t, tx.hash))
             except UnknownContractError:
                 logg.debug('callback filter {}:{} skipping "transfer" method on unknown contract {} tx {}'.format(tx.queue, tx.method, transfer_data['to'], tx.hash))
 

apps/cic-eth/cic_eth/runnable/daemons/tasker.py

@@ -15,7 +15,6 @@ from chainlib.connection import RPCConnection
 from chainlib.eth.connection import EthUnixSignerConnection
 from chainlib.chain import ChainSpec
 from chainqueue.db.models.otx import Otx
-import liveness.linux
 
 # local imports
 from cic_eth.eth import (
@@ -40,7 +39,6 @@ from cic_eth.queue import (
 from cic_eth.callbacks import (
         Callback,
         http,
-        noop,
         #tcp,
         redis,
         )
@@ -53,7 +51,6 @@ from cic_eth.registry import (
         connect_token_registry,
         )
 
-
 logging.basicConfig(level=logging.WARNING)
 logg = logging.getLogger()
 
@@ -92,15 +89,14 @@ config.censor('PASSWORD', 'DATABASE')
 config.censor('PASSWORD', 'SSL')
 logg.debug('config loaded from {}:\n{}'.format(args.c, config))
 
-health_modules = config.get('CIC_HEALTH_MODULES', [])
-if len(health_modules) != 0:
-    health_modules = health_modules.split(',')
-logg.debug('health mods {}'.format(health_modules))
-
 # connect to database
 dsn = dsn_from_config(config)
 SessionBase.connect(dsn, pool_size=int(config.get('DATABASE_POOL_SIZE')), debug=config.true('DATABASE_DEBUG'))
 
+# verify database connection with minimal sanity query
+session = SessionBase.create_session()
+session.execute('select version_num from alembic_version')
+session.close()
 
 # set up celery
 current_app = celery.Celery(__name__)
@@ -142,7 +138,6 @@ RPCConnection.register_location(config.get('SIGNER_SOCKET_PATH'), chain_spec, 's
 
 Otx.tracing = config.true('TASKS_TRACE_QUEUE_STATUS')
 
-liveness.linux.load(health_modules)
 
 def main():
     argv = ['worker']
@@ -177,10 +172,8 @@ def main():
         logg.info('using trusted address {}'.format(address))
     connect_declarator(rpc, chain_spec, trusted_addresses)
     connect_token_registry(rpc, chain_spec)
-   
-    liveness.linux.set()
+    
     current_app.worker_main(argv)
-    liveness.linux.reset()
 
 
 @celery.signals.eventlet_pool_postshutdown.connect

apps/cic-eth/config/cic.ini

@@ -3,4 +3,3 @@ registry_address =
 chain_spec = evm:bloxberg:8996
 tx_retry_delay = 
 trust_address =
-health_modules = cic_eth.k8s.db

apps/cic-eth/docker/Dockerfile

@@ -53,5 +53,3 @@ COPY cic-eth/crypto_dev_signer_config/ /usr/local/etc/crypto-dev-signer/
 RUN git clone https://gitlab.com/grassrootseconomics/cic-contracts.git && \
 	mkdir -p /usr/local/share/cic/solidity && \
 	cp -R cic-contracts/abis /usr/local/share/cic/solidity/abi
-
-COPY util/liveness/health.sh /usr/local/bin/health.sh

apps/cic-eth/requirements.txt

@@ -1,4 +1,4 @@
-cic-base==0.1.2a79+build.35e442bc
+cic-base~=0.1.2a76
 celery==4.4.7
 crypto-dev-signer~=0.4.14b2
 confini~=0.3.6rc3

apps/cic-eth/setup.cfg

@@ -38,7 +38,6 @@ packages =
 	cic_eth.runnable.daemons.filters
 	cic_eth.callbacks
 	cic_eth.sync
-	cic_eth.k8s
 scripts =
 	./scripts/migrate.py
 

apps/cic-notify/cic_notify/runnable/tasker.py

@@ -33,9 +33,7 @@ elif args.v:
 
 config = confini.Config(args.c, args.env_prefix)
 config.process()
-config.add(args.q, '_CELERY_QUEUE', True)
 config.censor('PASSWORD', 'DATABASE')
-logg.debug('config loaded from {}:\n{}'.format(args.c, config))
 
 # connect to database
 dsn = dsn_from_config(config)

apps/cic-notify/cic_notify/version.py

@@ -6,10 +6,11 @@ import time
 import semver
 
 # local imports
+from cic_notify.error import PleaseCommitFirstError
 
 logg = logging.getLogger()
 
-version = (0, 4, 0, 'alpha.4')
+version = (0, 4, 0, 'alpha.3')
 
 version_object = semver.VersionInfo(
         major=version[0],
@@ -17,4 +18,27 @@ version_object = semver.VersionInfo(
         patch=version[2],
         prerelease=version[3],
         )
+
 version_string = str(version_object)
+
+
+def git_hash():
+    import subprocess
+
+    git_hash = subprocess.run(['git', 'rev-parse', 'HEAD'], capture_output=True)
+    git_hash_brief = git_hash.stdout.decode('utf-8')[:8]
+    return git_hash_brief
+
+
+try:
+    version_git = git_hash()
+    version_string += '+build.{}'.format(version_git)
+except FileNotFoundError:
+    time_string_pair = str(time.time()).split('.')
+    version_string += '+build.{}{:<09d}'.format(
+        time_string_pair[0],
+        int(time_string_pair[1]),
+    )
+logg.info(f'Final version string will be {version_string}')
+
+__version_string__ = version_string

apps/cic-notify/setup.cfg

@@ -1,5 +1,6 @@
 [metadata]
 name = cic-notify
+version= 0.4.0a3
 description = CIC notifications service
 author = Louis Holbrook
 author_email = dev@holbrook.no

apps/cic-notify/setup.py

@@ -1,31 +1,9 @@
 # standard imports
-import logging
-import subprocess
-import time
 from setuptools import setup
 
+# third-party imports
+
 # local imports
-from cic_notify.version import version_string
-
-logg = logging.getLogger()
-
-
-def git_hash():
-    git_hash = subprocess.run(['git', 'rev-parse', 'HEAD'], capture_output=True)
-    git_hash_brief = git_hash.stdout.decode('utf-8')[:8]
-    return git_hash_brief
-
-
-try:
-    version_git = git_hash()
-    version_string += '+build.{}'.format(version_git)
-except FileNotFoundError:
-    time_string_pair = str(time.time()).split('.')
-    version_string += '+build.{}{:<09d}'.format(
-            time_string_pair[0],
-            int(time_string_pair[1]),
-            )
-logg.info(f'Final version string will be {version_string}')
 
 
 requirements = []
@@ -47,6 +25,6 @@ while True:
 test_requirements_file.close()
 
 setup(
-    version=version_string,
     install_requires=requirements,
-    tests_require=test_requirements)
+    tests_require=test_requirements,
+)

apps/cic-ussd/.config/redis.ini

@@ -1,6 +1,6 @@
 [celery]
-BROKER_URL=redis://
-RESULT_URL=redis://
+BROKER_URL=redis://redis:6379
+RESULT_URL=redis://redis:6379
 
 [redis]
 HOSTNAME=redis

apps/cic-ussd/cic_ussd/account.py

@@ -8,12 +8,12 @@ from cic_types.processor import generate_metadata_pointer
 
 # local imports
 from cic_ussd.chain import Chain
-from cic_ussd.db.models.account import Account
+from cic_ussd.db.models.user import User
 from cic_ussd.metadata import blockchain_address_to_metadata_pointer
 from cic_ussd.redis import get_cached_data
 
 
-def define_account_tx_metadata(user: Account):
+def define_account_tx_metadata(user: User):
     # get sender metadata
     identifier = blockchain_address_to_metadata_pointer(
         blockchain_address=user.blockchain_address

apps/cic-ussd/cic_ussd/db/migrations/default/versions/f289e8510444_.py

@@ -1,4 +1,4 @@
-"""Create account table
+"""Create user table
 
 Revision ID: f289e8510444
 Revises: 
@@ -17,7 +17,7 @@ depends_on = None
 
 
 def upgrade():
-    op.create_table('account',
+    op.create_table('user',
                     sa.Column('id', sa.Integer(), nullable=False),
                     sa.Column('blockchain_address', sa.String(), nullable=False),
                     sa.Column('phone_number', sa.String(), nullable=False),
@@ -29,11 +29,11 @@ def upgrade():
                     sa.Column('updated', sa.DateTime(), nullable=False),
                     sa.PrimaryKeyConstraint('id')
                     )
-    op.create_index(op.f('ix_account_phone_number'), 'account', ['phone_number'], unique=True)
-    op.create_index(op.f('ix_account_blockchain_address'), 'account', ['blockchain_address'], unique=True)
+    op.create_index(op.f('ix_user_phone_number'), 'user', ['phone_number'], unique=True)
+    op.create_index(op.f('ix_user_blockchain_address'), 'user', ['blockchain_address'], unique=True)
 
 
 def downgrade():
-    op.drop_index(op.f('ix_account_blockchain_address'), table_name='account')
-    op.drop_index(op.f('ix_account_phone_number'), table_name='account')
-    op.drop_table('account')
+    op.drop_index(op.f('ix_user_blockchain_address'), table_name='user')
+    op.drop_index(op.f('ix_user_phone_number'), table_name='user')
+    op.drop_table('user')

apps/cic-ussd/cic_ussd/db/models/user.py

@@ -16,12 +16,12 @@ class AccountStatus(IntEnum):
     RESET = 4
 
 
-class Account(SessionBase):
+class User(SessionBase):
     """
     This class defines a user record along with functions responsible for hashing the user's corresponding password and
      subsequently verifying a password's validity given an input to compare against the persisted hash.
     """
-    __tablename__ = 'account'
+    __tablename__ = 'user'
 
     blockchain_address = Column(String)
     phone_number = Column(String)
@@ -38,7 +38,7 @@ class Account(SessionBase):
         self.account_status = AccountStatus.PENDING.value
 
     def __repr__(self):
-        return f'<Account: {self.blockchain_address}>'
+        return f'<User: {self.blockchain_address}>'
 
     def create_password(self, password):
         """This method takes a password value and hashes the value before assigning it to the corresponding

apps/cic-ussd/cic_ussd/operations.py

@@ -10,7 +10,7 @@ from tinydb.table import Document
 from typing import Optional
 
 # local imports
-from cic_ussd.db.models.account import Account
+from cic_ussd.db.models.user import User
 from cic_ussd.db.models.ussd_session import UssdSession
 from cic_ussd.db.models.task_tracker import TaskTracker
 from cic_ussd.menu.ussd_menu import UssdMenu
@@ -143,10 +143,10 @@ def get_account_status(phone_number) -> str:
     :return: The user account status.
     :rtype: str
     """
-    user = Account.session.query(Account).filter_by(phone_number=phone_number).first()
+    user = User.session.query(User).filter_by(phone_number=phone_number).first()
     status = user.get_account_status()
-    Account.session.add(user)
-    Account.session.commit()
+    User.session.add(user)
+    User.session.commit()
 
     return status
 
@@ -269,12 +269,12 @@ def cache_account_creation_task_id(phone_number: str, task_id: str):
     redis_cache.persist(name=task_id)
 
 
-def process_current_menu(ussd_session: Optional[dict], user: Account, user_input: str) -> Document:
+def process_current_menu(ussd_session: Optional[dict], user: User, user_input: str) -> Document:
     """This function checks user input and returns a corresponding ussd menu
     :param ussd_session: An in db ussd session object.
     :type ussd_session: UssdSession
     :param user: A user object.
-    :type user: Account
+    :type user: User
     :param user_input: The user's input.
     :type user_input: str
     :return: An in memory ussd menu object.
@@ -324,7 +324,7 @@ def process_menu_interaction_requests(chain_str: str,
 
     else:
         # get user
-        user = Account.session.query(Account).filter_by(phone_number=phone_number).first()
+        user = User.session.query(User).filter_by(phone_number=phone_number).first()
 
         # find any existing ussd session
         existing_ussd_session = UssdSession.session.query(UssdSession).filter_by(
@@ -390,10 +390,10 @@ def reset_pin(phone_number: str) -> str:
     :return: The status of the pin reset.
     :rtype: str
     """
-    user = Account.session.query(Account).filter_by(phone_number=phone_number).first()
+    user = User.session.query(User).filter_by(phone_number=phone_number).first()
     user.reset_account_pin()
-    Account.session.add(user)
-    Account.session.commit()
+    User.session.add(user)
+    User.session.commit()
 
     response = f'Pin reset for user {phone_number} is successful!'
     return response

apps/cic-ussd/cic_ussd/phone_number.py

@@ -5,7 +5,7 @@ from typing import Optional
 import phonenumbers
 
 # local imports
-from cic_ussd.db.models.account import Account
+from cic_ussd.db.models.user import User
 
 
 def process_phone_number(phone_number: str, region: str):
@@ -30,14 +30,14 @@ def process_phone_number(phone_number: str, region: str):
     return parsed_phone_number
 
 
-def get_user_by_phone_number(phone_number: str) -> Optional[Account]:
+def get_user_by_phone_number(phone_number: str) -> Optional[User]:
     """This function queries the database for a user based on the provided phone number.
     :param phone_number: A valid phone number.
     :type phone_number: str
     :return: A user object matching a given phone number
-    :rtype: Account|None
+    :rtype: User|None
     """
     # consider adding region to user's metadata
     phone_number = process_phone_number(phone_number=phone_number, region='KE')
-    user = Account.session.query(Account).filter_by(phone_number=phone_number).first()
+    user = User.session.query(User).filter_by(phone_number=phone_number).first()
     return user

apps/cic-ussd/cic_ussd/processor.py

@@ -13,7 +13,7 @@ from tinydb.table import Document
 from cic_ussd.account import define_account_tx_metadata, retrieve_account_statement
 from cic_ussd.balance import BalanceManager, compute_operational_balance, get_cached_operational_balance
 from cic_ussd.chain import Chain
-from cic_ussd.db.models.account import AccountStatus, Account
+from cic_ussd.db.models.user import AccountStatus, User
 from cic_ussd.db.models.ussd_session import UssdSession
 from cic_ussd.error import MetadataNotFoundError
 from cic_ussd.menu.ussd_menu import UssdMenu
@@ -28,13 +28,13 @@ from cic_types.models.person import generate_metadata_pointer, get_contact_data_
 logg = logging.getLogger(__name__)
 
 
-def process_pin_authorization(display_key: str, user: Account, **kwargs) -> str:
+def process_pin_authorization(display_key: str, user: User, **kwargs) -> str:
     """
     This method provides translation for all ussd menu entries that follow the pin authorization pattern.
     :param display_key: The path in the translation files defining an appropriate ussd response
     :type display_key: str
     :param user: The user in a running USSD session.
-    :type user: Account
+    :type user: User
     :param kwargs: Any additional information required by the text values in the internationalization files.
     :type kwargs
     :return: A string value corresponding the ussd menu's text value.
@@ -55,13 +55,13 @@ def process_pin_authorization(display_key: str, user: Account, **kwargs) -> str:
         )
 
 
-def process_exit_insufficient_balance(display_key: str, user: Account, ussd_session: dict):
+def process_exit_insufficient_balance(display_key: str, user: User, ussd_session: dict):
     """This function processes the exit menu letting users their account balance is insufficient to perform a specific
     transaction.
     :param display_key: The path in the translation files defining an appropriate ussd response
     :type display_key: str
     :param user: The user requesting access to the ussd menu.
-    :type user: Account
+    :type user: User
     :param ussd_session: A JSON serialized in-memory ussd session object
     :type ussd_session: dict
     :return: Corresponding translation text response
@@ -90,12 +90,12 @@ def process_exit_insufficient_balance(display_key: str, user: Account, ussd_sess
     )
 
 
-def process_exit_successful_transaction(display_key: str, user: Account, ussd_session: dict):
+def process_exit_successful_transaction(display_key: str, user: User, ussd_session: dict):
     """This function processes the exit menu after a successful initiation for a transfer of tokens.
     :param display_key: The path in the translation files defining an appropriate ussd response
     :type display_key: str
     :param user: The user requesting access to the ussd menu.
-    :type user: Account
+    :type user: User
     :param ussd_session: A JSON serialized in-memory ussd session object
     :type ussd_session: dict
     :return: Corresponding translation text response
@@ -118,11 +118,11 @@ def process_exit_successful_transaction(display_key: str, user: Account, ussd_se
     )
 
 
-def process_transaction_pin_authorization(user: Account, display_key: str, ussd_session: dict):
+def process_transaction_pin_authorization(user: User, display_key: str, ussd_session: dict):
     """This function processes pin authorization where making a transaction is concerned. It constructs a
     pre-transaction response menu that shows the details of the transaction.
     :param user: The user requesting access to the ussd menu.
-    :type user: Account
+    :type user: User
     :param display_key: The path in the translation files defining an appropriate ussd response
     :type display_key: str
     :param ussd_session: The USSD session determining what user data needs to be extracted and added to the menu's
@@ -151,7 +151,7 @@ def process_transaction_pin_authorization(user: Account, display_key: str, ussd_
     )
 
 
-def process_account_balances(user: Account, display_key: str, ussd_session: dict):
+def process_account_balances(user: User, display_key: str, ussd_session: dict):
     """
     :param user:
     :type user:
@@ -205,7 +205,7 @@ def format_transactions(transactions: list, preferred_language: str):
         return formatted_transactions
 
 
-def process_display_user_metadata(user: Account, display_key: str):
+def process_display_user_metadata(user: User, display_key: str):
     """
     :param user:
     :type user:
@@ -238,7 +238,7 @@ def process_display_user_metadata(user: Account, display_key: str):
         raise MetadataNotFoundError(f'Expected person metadata but found none in cache for key: {key}')
 
 
-def process_account_statement(user: Account, display_key: str, ussd_session: dict):
+def process_account_statement(user: User, display_key: str, ussd_session: dict):
     """
     :param user:
     :type user:
@@ -301,12 +301,12 @@ def process_account_statement(user: Account, display_key: str, ussd_session: dic
         )
 
 
-def process_start_menu(display_key: str, user: Account):
+def process_start_menu(display_key: str, user: User):
     """This function gets data on an account's balance and token in order to append it to the start of the start menu's
     title. It passes said arguments to the translation function and returns the appropriate corresponding text from the
     translation files.
     :param user: The user requesting access to the ussd menu.
-    :type user: Account
+    :type user: User
     :param display_key: The path in the translation files defining an appropriate ussd response
     :type display_key: str
     :return: Corresponding translation text response
@@ -361,13 +361,13 @@ def retrieve_most_recent_ussd_session(phone_number: str) -> UssdSession:
     return last_ussd_session
 
 
-def process_request(user_input: str, user: Account, ussd_session: Optional[dict] = None) -> Document:
+def process_request(user_input: str, user: User, ussd_session: Optional[dict] = None) -> Document:
     """This function assesses a request based on the user from the request comes, the session_id and the user's
     input. It determines whether the request translates to a return to an existing session by checking whether the
     provided  session id exists in the database or whether the creation of a new ussd session object is warranted.
     It then returns the appropriate ussd menu text values.
     :param user: The user requesting access to the ussd menu.
-    :type user: Account
+    :type user: User
     :param user_input: The value a user enters in the ussd menu.
     :type user_input: str
     :param ussd_session: A JSON serialized in-memory ussd session object
@@ -415,14 +415,14 @@ def process_request(user_input: str, user: Account, ussd_session: Optional[dict]
                 return UssdMenu.find_by_name(name='initial_pin_entry')
 
 
-def next_state(ussd_session: dict, user: Account, user_input: str) -> str:
+def next_state(ussd_session: dict, user: User, user_input: str) -> str:
     """This function navigates the state machine based on the ussd session object and user inputs it receives.
     It checks the user input and provides the successive state in the state machine. It then updates the session's
     state attribute with the new state.
     :param ussd_session: A JSON serialized in-memory ussd session object
     :type ussd_session: dict
     :param user: The user requesting access to the ussd menu.
-    :type user: Account
+    :type user: User
     :param user_input: The value a user enters in the ussd menu.
     :type user_input: str
     :return: A string value corresponding the successive give a specific state in the state machine.
@@ -438,7 +438,7 @@ def custom_display_text(
         display_key: str,
         menu_name: str,
         ussd_session: dict,
-        user: Account) -> str:
+        user: User) -> str:
     """This function extracts the appropriate session data based on the current menu name. It then inserts them as
     keywords in the i18n function.
     :param display_key: The path in the translation files defining an appropriate ussd response
@@ -446,7 +446,7 @@ def custom_display_text(
     :param menu_name: The name by which a specific menu can be identified.
     :type menu_name: str
     :param user: The user in a running USSD session.
-    :type user: Account
+    :type user: User
     :param ussd_session: A JSON serialized in-memory ussd session object
     :type ussd_session: dict
     :return: A string value corresponding the ussd menu's text value.

apps/cic-ussd/cic_ussd/requests.py

@@ -10,7 +10,7 @@ from urllib.parse import urlparse, parse_qs
 from sqlalchemy import desc
 
 # local imports
-from cic_ussd.db.models.account import AccountStatus, Account
+from cic_ussd.db.models.user import AccountStatus, User
 from cic_ussd.operations import get_account_status, reset_pin
 from cic_ussd.validator import check_known_user
 
@@ -123,9 +123,9 @@ def process_locked_accounts_requests(env: dict) -> tuple:
             else:
                 limit = r[1]
 
-        locked_accounts = Account.session.query(Account.blockchain_address).filter(
-            Account.account_status == AccountStatus.LOCKED.value,
-            Account.failed_pin_attempts >= 3).order_by(desc(Account.updated)).offset(offset).limit(limit).all()
+        locked_accounts = User.session.query(User.blockchain_address).filter(
+            User.account_status == AccountStatus.LOCKED.value,
+            User.failed_pin_attempts >= 3).order_by(desc(User.updated)).offset(offset).limit(limit).all()
 
         # convert lists to scalar blockchain addresses
         locked_accounts = [blockchain_address for (blockchain_address, ) in locked_accounts]

apps/cic-ussd/cic_ussd/runnable/server.py

@@ -57,17 +57,19 @@ arg_parser.add_argument('--env-prefix',
                         help='environment prefix for variables to overwrite configuration')
 args = arg_parser.parse_args()
 
+# parse config
+config = Config(config_dir=args.c, env_prefix=args.env_prefix)
+config.process()
+config.censor('PASSWORD', 'DATABASE')
+
 # define log levels
 if args.vv:
     logging.getLogger().setLevel(logging.DEBUG)
 elif args.v:
     logging.getLogger().setLevel(logging.INFO)
 
-# parse config
-config = Config(config_dir=args.c, env_prefix=args.env_prefix)
-config.process()
-config.censor('PASSWORD', 'DATABASE')
-logg.debug('config loaded from {}:\n{}'.format(args.c, config))
+# log config vars
+logg.debug(config)
 
 # initialize elements
 # set up translations

apps/cic-ussd/cic_ussd/runnable/tasker.py

@@ -6,7 +6,6 @@ import tempfile
 
 # third party imports
 import celery
-import i18n
 import redis
 from confini import Config
 
@@ -34,18 +33,18 @@ arg_parser.add_argument('-vv', action='store_true', help='be more verbose')
 arg_parser.add_argument('--env-prefix', default=os.environ.get('CONFINI_ENV_PREFIX'), dest='env_prefix', type=str, help='environment prefix for variables to overwrite configuration')
 args = arg_parser.parse_args()
 
+# parse config
+config = Config(config_dir=args.c, env_prefix=args.env_prefix)
+config.process()
+config.censor('PASSWORD', 'DATABASE')
+
 # define log levels
 if args.vv:
     logging.getLogger().setLevel(logging.DEBUG)
 elif args.v:
     logging.getLogger().setLevel(logging.INFO)
 
-# parse config
-config = Config(args.c, args.env_prefix)
-config.process()
-config.add(args.q, '_CELERY_QUEUE', True)
-config.censor('PASSWORD', 'DATABASE')
-logg.debug('config loaded from {}:\n{}'.format(args.c, config))
+logg.debug(config)
 
 # connect to database
 data_source_name = dsn_from_config(config)
@@ -78,10 +77,6 @@ if key_file_path:
     validate_presence(path=key_file_path)
 Signer.key_file_path = key_file_path
 
-# set up translations
-i18n.load_path.append(config.get('APP_LOCALE_PATH'))
-i18n.set('fallback', config.get('APP_LOCALE_FALLBACK'))
-
 # set up celery
 current_app = celery.Celery(__name__)
 

apps/cic-ussd/cic_ussd/state_machine/logic/balance.py

@@ -5,12 +5,12 @@ from typing import Tuple
 # third-party imports
 
 # local imports
-from cic_ussd.db.models.account import Account
+from cic_ussd.db.models.user import User
 
 logg = logging.getLogger(__file__)
 
 
-def process_mini_statement_request(state_machine_data: Tuple[str, dict, Account]):
+def process_mini_statement_request(state_machine_data: Tuple[str, dict, User]):
     """This function compiles a brief statement of a user's last three inbound and outbound transactions and send the
     same as a message on their selected avenue for notification.
     :param state_machine_data: A tuple containing user input, a ussd session and user object.

apps/cic-ussd/cic_ussd/state_machine/logic/menu.py

@@ -6,10 +6,10 @@ ussd menu facilitating the return of appropriate menu responses based on said us
 from typing import Tuple
 
 # local imports
-from cic_ussd.db.models.account import Account
+from cic_ussd.db.models.user import User
 
 
-def menu_one_selected(state_machine_data: Tuple[str, dict, Account]) -> bool:
+def menu_one_selected(state_machine_data: Tuple[str, dict, User]) -> bool:
     """This function checks that user input matches a string with value '1'
     :param state_machine_data: A tuple containing user input, a ussd session and user object.
     :type state_machine_data: str
@@ -20,7 +20,7 @@ def menu_one_selected(state_machine_data: Tuple[str, dict, Account]) -> bool:
     return user_input == '1'
 
 
-def menu_two_selected(state_machine_data: Tuple[str, dict, Account]) -> bool:
+def menu_two_selected(state_machine_data: Tuple[str, dict, User]) -> bool:
     """This function checks that user input matches a string with value '2'
     :param state_machine_data: A tuple containing user input, a ussd session and user object.
     :type state_machine_data: tuple
@@ -31,7 +31,7 @@ def menu_two_selected(state_machine_data: Tuple[str, dict, Account]) -> bool:
     return user_input == '2'
 
 
-def menu_three_selected(state_machine_data: Tuple[str, dict, Account]) -> bool:
+def menu_three_selected(state_machine_data: Tuple[str, dict, User]) -> bool:
     """This function checks that user input matches a string with value '3'
     :param state_machine_data: A tuple containing user input, a ussd session and user object.
     :type state_machine_data: tuple
@@ -42,7 +42,7 @@ def menu_three_selected(state_machine_data: Tuple[str, dict, Account]) -> bool:
     return user_input == '3'
 
 
-def menu_four_selected(state_machine_data: Tuple[str, dict, Account]) -> bool:
+def menu_four_selected(state_machine_data: Tuple[str, dict, User]) -> bool:
     """
     This function checks that user input matches a string with value '4'
     :param state_machine_data: A tuple containing user input, a ussd session and user object.
@@ -54,7 +54,7 @@ def menu_four_selected(state_machine_data: Tuple[str, dict, Account]) -> bool:
     return user_input == '4'
 
 
-def menu_five_selected(state_machine_data: Tuple[str, dict, Account]) -> bool:
+def menu_five_selected(state_machine_data: Tuple[str, dict, User]) -> bool:
     """
     This function checks that user input matches a string with value '5'
     :param state_machine_data: A tuple containing user input, a ussd session and user object.
@@ -66,7 +66,7 @@ def menu_five_selected(state_machine_data: Tuple[str, dict, Account]) -> bool:
     return user_input == '5'
 
 
-def menu_zero_zero_selected(state_machine_data: Tuple[str, dict, Account]) -> bool:
+def menu_zero_zero_selected(state_machine_data: Tuple[str, dict, User]) -> bool:
     """
     This function checks that user input matches a string with value '00'
     :param state_machine_data: A tuple containing user input, a ussd session and user object.
@@ -78,7 +78,7 @@ def menu_zero_zero_selected(state_machine_data: Tuple[str, dict, Account]) -> bo
     return user_input == '00'
 
 
-def menu_ninety_nine_selected(state_machine_data: Tuple[str, dict, Account]) -> bool:
+def menu_ninety_nine_selected(state_machine_data: Tuple[str, dict, User]) -> bool:
     """
     This function checks that user input matches a string with value '99'
     :param state_machine_data: A tuple containing user input, a ussd session and user object.

apps/cic-ussd/cic_ussd/state_machine/logic/pin.py

@@ -12,7 +12,7 @@ from typing import Tuple
 import bcrypt
 
 # local imports
-from cic_ussd.db.models.account import AccountStatus, Account
+from cic_ussd.db.models.user import AccountStatus, User
 from cic_ussd.encoder import PasswordEncoder, create_password_hash
 from cic_ussd.operations import persist_session_to_db_task, create_or_update_session
 from cic_ussd.redis import InMemoryStore
@@ -21,7 +21,7 @@ from cic_ussd.redis import InMemoryStore
 logg = logging.getLogger(__file__)
 
 
-def is_valid_pin(state_machine_data: Tuple[str, dict, Account]) -> bool:
+def is_valid_pin(state_machine_data: Tuple[str, dict, User]) -> bool:
     """This function checks a pin's validity by ensuring it has a length of for characters and the characters are
     numeric.
     :param state_machine_data: A tuple containing user input, a ussd session and user object.
@@ -37,7 +37,7 @@ def is_valid_pin(state_machine_data: Tuple[str, dict, Account]) -> bool:
     return pin_is_valid
 
 
-def is_authorized_pin(state_machine_data: Tuple[str, dict, Account]) -> bool:
+def is_authorized_pin(state_machine_data: Tuple[str, dict, User]) -> bool:
     """This function checks whether the user input confirming a specific pin matches the initial pin entered.
     :param state_machine_data: A tuple containing user input, a ussd session and user object.
     :type state_machine_data: tuple
@@ -48,7 +48,7 @@ def is_authorized_pin(state_machine_data: Tuple[str, dict, Account]) -> bool:
     return user.verify_password(password=user_input)
 
 
-def is_locked_account(state_machine_data: Tuple[str, dict, Account]) -> bool:
+def is_locked_account(state_machine_data: Tuple[str, dict, User]) -> bool:
     """This function checks whether a user's account is locked due to too many failed attempts.
     :param state_machine_data: A tuple containing user input, a ussd session and user object.
     :type state_machine_data: tuple
@@ -59,7 +59,7 @@ def is_locked_account(state_machine_data: Tuple[str, dict, Account]) -> bool:
     return user.get_account_status() == AccountStatus.LOCKED.name
 
 
-def save_initial_pin_to_session_data(state_machine_data: Tuple[str, dict, Account]):
+def save_initial_pin_to_session_data(state_machine_data: Tuple[str, dict, User]):
     """This function hashes a pin and stores it in session data.
     :param state_machine_data: A tuple containing user input, a ussd session and user object.
     :type state_machine_data: tuple
@@ -94,7 +94,7 @@ def save_initial_pin_to_session_data(state_machine_data: Tuple[str, dict, Accoun
     persist_session_to_db_task(external_session_id=external_session_id, queue='cic-ussd')
 
 
-def pins_match(state_machine_data: Tuple[str, dict, Account]) -> bool:
+def pins_match(state_machine_data: Tuple[str, dict, User]) -> bool:
     """This function checks whether the user input confirming a specific pin matches the initial pin entered.
     :param state_machine_data: A tuple containing user input, a ussd session and user object.
     :type state_machine_data: tuple
@@ -108,7 +108,7 @@ def pins_match(state_machine_data: Tuple[str, dict, Account]) -> bool:
     return bcrypt.checkpw(user_input.encode(), initial_pin)
 
 
-def complete_pin_change(state_machine_data: Tuple[str, dict, Account]):
+def complete_pin_change(state_machine_data: Tuple[str, dict, User]):
     """This function persists the user's pin to the database
     :param state_machine_data: A tuple containing user input, a ussd session and user object.
     :type state_machine_data: tuple
@@ -116,11 +116,11 @@ def complete_pin_change(state_machine_data: Tuple[str, dict, Account]):
     user_input, ussd_session, user = state_machine_data
     password_hash = ussd_session.get('session_data').get('initial_pin')
     user.password_hash = password_hash
-    Account.session.add(user)
-    Account.session.commit()
+    User.session.add(user)
+    User.session.commit()
 
 
-def is_blocked_pin(state_machine_data: Tuple[str, dict, Account]) -> bool:
+def is_blocked_pin(state_machine_data: Tuple[str, dict, User]) -> bool:
     """This function checks whether the user input confirming a specific pin matches the initial pin entered.
     :param state_machine_data: A tuple containing user input, a ussd session and user object.
     :type state_machine_data: tuple
@@ -131,7 +131,7 @@ def is_blocked_pin(state_machine_data: Tuple[str, dict, Account]) -> bool:
     return user.get_account_status() == AccountStatus.LOCKED.name
 
 
-def is_valid_new_pin(state_machine_data: Tuple[str, dict, Account]) -> bool:
+def is_valid_new_pin(state_machine_data: Tuple[str, dict, User]) -> bool:
     """This function checks whether the user's new pin is a valid pin and that it isn't the same as the old one.
     :param state_machine_data: A tuple containing user input, a ussd session and user object.
     :type state_machine_data: tuple

apps/cic-ussd/cic_ussd/state_machine/logic/sms.py

@@ -3,21 +3,21 @@ import logging
 from typing import Tuple
 
 # local imports
-from cic_ussd.db.models.account import Account
+from cic_ussd.db.models.user import User
 
 logg = logging.getLogger()
 
 
-def send_terms_to_user_if_required(state_machine_data: Tuple[str, dict, Account]):
+def send_terms_to_user_if_required(state_machine_data: Tuple[str, dict, User]):
     user_input, ussd_session, user = state_machine_data
     logg.debug('Requires integration to cic-notify.')
 
 
-def process_mini_statement_request(state_machine_data: Tuple[str, dict, Account]):
+def process_mini_statement_request(state_machine_data: Tuple[str, dict, User]):
     user_input, ussd_session, user = state_machine_data
     logg.debug('Requires integration to cic-notify.')
 
 
-def upsell_unregistered_recipient(state_machine_data: Tuple[str, dict, Account]):
+def upsell_unregistered_recipient(state_machine_data: Tuple[str, dict, User]):
     user_input, ussd_session, user = state_machine_data
     logg.debug('Requires integration to cic-notify.')

apps/cic-ussd/cic_ussd/state_machine/logic/transaction.py

@@ -9,7 +9,7 @@ import celery
 # local imports
 from cic_ussd.balance import BalanceManager, compute_operational_balance
 from cic_ussd.chain import Chain
-from cic_ussd.db.models.account import AccountStatus, Account
+from cic_ussd.db.models.user import AccountStatus, User
 from cic_ussd.operations import save_to_in_memory_ussd_session_data
 from cic_ussd.phone_number import get_user_by_phone_number
 from cic_ussd.redis import create_cached_data_key, get_cached_data
@@ -19,7 +19,7 @@ from cic_ussd.transactions import OutgoingTransactionProcessor
 logg = logging.getLogger(__file__)
 
 
-def is_valid_recipient(state_machine_data: Tuple[str, dict, Account]) -> bool:
+def is_valid_recipient(state_machine_data: Tuple[str, dict, User]) -> bool:
     """This function checks that a user exists, is not the initiator of the transaction, has an active account status
     and is authorized to perform  standard transactions.
     :param state_machine_data: A tuple containing user input, a ussd session and user object.
@@ -34,7 +34,7 @@ def is_valid_recipient(state_machine_data: Tuple[str, dict, Account]) -> bool:
     return is_not_initiator and has_active_account_status and recipient is not None
 
 
-def is_valid_transaction_amount(state_machine_data: Tuple[str, dict, Account]) -> bool:
+def is_valid_transaction_amount(state_machine_data: Tuple[str, dict, User]) -> bool:
     """This function checks that the transaction amount provided is valid as per the criteria for the transaction
     being attempted.
     :param state_machine_data: A tuple containing user input, a ussd session and user object.
@@ -49,7 +49,7 @@ def is_valid_transaction_amount(state_machine_data: Tuple[str, dict, Account]) -
         return False
 
 
-def has_sufficient_balance(state_machine_data: Tuple[str, dict, Account]) -> bool:
+def has_sufficient_balance(state_machine_data: Tuple[str, dict, User]) -> bool:
     """This function checks that the transaction amount provided is valid as per the criteria for the transaction
     being attempted.
     :param state_machine_data: A tuple containing user input, a ussd session and user object.
@@ -72,7 +72,7 @@ def has_sufficient_balance(state_machine_data: Tuple[str, dict, Account]) -> boo
     return int(user_input) <= operational_balance
 
 
-def save_recipient_phone_to_session_data(state_machine_data: Tuple[str, dict, Account]):
+def save_recipient_phone_to_session_data(state_machine_data: Tuple[str, dict, User]):
     """This function saves the phone number corresponding the intended recipients blockchain account.
     :param state_machine_data: A tuple containing user input, a ussd session and user object.
     :type state_machine_data: str
@@ -85,7 +85,7 @@ def save_recipient_phone_to_session_data(state_machine_data: Tuple[str, dict, Ac
     save_to_in_memory_ussd_session_data(queue='cic-ussd', session_data=session_data, ussd_session=ussd_session)
 
 
-def retrieve_recipient_metadata(state_machine_data: Tuple[str, dict, Account]):
+def retrieve_recipient_metadata(state_machine_data: Tuple[str, dict, User]):
     """
     :param state_machine_data:
     :type state_machine_data:
@@ -104,7 +104,7 @@ def retrieve_recipient_metadata(state_machine_data: Tuple[str, dict, Account]):
     s_query_person_metadata.apply_async(queue='cic-ussd')
 
 
-def save_transaction_amount_to_session_data(state_machine_data: Tuple[str, dict, Account]):
+def save_transaction_amount_to_session_data(state_machine_data: Tuple[str, dict, User]):
     """This function saves the phone number corresponding the intended recipients blockchain account.
     :param state_machine_data: A tuple containing user input, a ussd session and user object.
     :type state_machine_data: str
@@ -117,7 +117,7 @@ def save_transaction_amount_to_session_data(state_machine_data: Tuple[str, dict,
     save_to_in_memory_ussd_session_data(queue='cic-ussd', session_data=session_data, ussd_session=ussd_session)
 
 
-def process_transaction_request(state_machine_data: Tuple[str, dict, Account]):
+def process_transaction_request(state_machine_data: Tuple[str, dict, User]):
     """This function saves the phone number corresponding the intended recipients blockchain account.
     :param state_machine_data: A tuple containing user input, a ussd session and user object.
     :type state_machine_data: str

apps/cic-ussd/cic_ussd/state_machine/logic/user.py

@@ -10,7 +10,7 @@ from cic_types.models.person import generate_vcard_from_contact_data, manage_ide
 
 # local imports
 from cic_ussd.chain import Chain
-from cic_ussd.db.models.account import Account
+from cic_ussd.db.models.user import User
 from cic_ussd.error import MetadataNotFoundError
 from cic_ussd.metadata import blockchain_address_to_metadata_pointer
 from cic_ussd.operations import save_to_in_memory_ussd_session_data
@@ -19,40 +19,40 @@ from cic_ussd.redis import get_cached_data
 logg = logging.getLogger(__file__)
 
 
-def change_preferred_language_to_en(state_machine_data: Tuple[str, dict, Account]):
+def change_preferred_language_to_en(state_machine_data: Tuple[str, dict, User]):
     """This function changes the user's preferred language to english.
     :param state_machine_data: A tuple containing user input, a ussd session and user object.
     :type state_machine_data: tuple
     """
     user_input, ussd_session, user = state_machine_data
     user.preferred_language = 'en'
-    Account.session.add(user)
-    Account.session.commit()
+    User.session.add(user)
+    User.session.commit()
 
 
-def change_preferred_language_to_sw(state_machine_data: Tuple[str, dict, Account]):
+def change_preferred_language_to_sw(state_machine_data: Tuple[str, dict, User]):
     """This function changes the user's preferred language to swahili.
     :param state_machine_data: A tuple containing user input, a ussd session and user object.
     :type state_machine_data: tuple
     """
     user_input, ussd_session, user = state_machine_data
     user.preferred_language = 'sw'
-    Account.session.add(user)
-    Account.session.commit()
+    User.session.add(user)
+    User.session.commit()
 
 
-def update_account_status_to_active(state_machine_data: Tuple[str, dict, Account]):
+def update_account_status_to_active(state_machine_data: Tuple[str, dict, User]):
     """This function sets user's account to active.
     :param state_machine_data: A tuple containing user input, a ussd session and user object.
     :type state_machine_data: tuple
     """
     user_input, ussd_session, user = state_machine_data
     user.activate_account()
-    Account.session.add(user)
-    Account.session.commit()
+    User.session.add(user)
+    User.session.commit()
 
 
-def process_gender_user_input(user: Account, user_input: str):
+def process_gender_user_input(user: User, user_input: str):
     """
     :param user:
     :type user:
@@ -74,7 +74,7 @@ def process_gender_user_input(user: Account, user_input: str):
     return gender
 
 
-def save_metadata_attribute_to_session_data(state_machine_data: Tuple[str, dict, Account]):
+def save_metadata_attribute_to_session_data(state_machine_data: Tuple[str, dict, User]):
     """This function saves first name data to the ussd session in the redis cache.
     :param state_machine_data: A tuple containing user input, a ussd session and user object.
     :type state_machine_data: tuple
@@ -109,7 +109,7 @@ def save_metadata_attribute_to_session_data(state_machine_data: Tuple[str, dict,
     save_to_in_memory_ussd_session_data(queue='cic-ussd', session_data=session_data, ussd_session=ussd_session)
 
 
-def format_user_metadata(metadata: dict, user: Account):
+def format_user_metadata(metadata: dict, user: User):
     """
     :param metadata:
     :type metadata:
@@ -150,7 +150,7 @@ def format_user_metadata(metadata: dict, user: Account):
     }
 
 
-def save_complete_user_metadata(state_machine_data: Tuple[str, dict, Account]):
+def save_complete_user_metadata(state_machine_data: Tuple[str, dict, User]):
     """This function persists elements of the user metadata stored in session data
     :param state_machine_data: A tuple containing user input, a ussd session and user object.
     :type state_machine_data: tuple
@@ -171,7 +171,7 @@ def save_complete_user_metadata(state_machine_data: Tuple[str, dict, Account]):
     s_create_person_metadata.apply_async(queue='cic-ussd')
 
 
-def edit_user_metadata_attribute(state_machine_data: Tuple[str, dict, Account]):
+def edit_user_metadata_attribute(state_machine_data: Tuple[str, dict, User]):
     user_input, ussd_session, user = state_machine_data
     blockchain_address = user.blockchain_address
     key = generate_metadata_pointer(
@@ -218,7 +218,7 @@ def edit_user_metadata_attribute(state_machine_data: Tuple[str, dict, Account]):
     s_edit_person_metadata.apply_async(queue='cic-ussd')
 
 
-def get_user_metadata(state_machine_data: Tuple[str, dict, Account]):
+def get_user_metadata(state_machine_data: Tuple[str, dict, User]):
     user_input, ussd_session, user = state_machine_data
     blockchain_address = user.blockchain_address
     s_get_user_metadata = celery.signature(

apps/cic-ussd/cic_ussd/state_machine/logic/validator.py

@@ -7,14 +7,14 @@ from typing import Tuple
 from cic_types.models.person import generate_metadata_pointer
 
 # local imports
-from cic_ussd.db.models.account import Account
+from cic_ussd.db.models.user import User
 from cic_ussd.metadata import blockchain_address_to_metadata_pointer
 from cic_ussd.redis import get_cached_data
 
 logg = logging.getLogger()
 
 
-def has_cached_user_metadata(state_machine_data: Tuple[str, dict, Account]):
+def has_cached_user_metadata(state_machine_data: Tuple[str, dict, User]):
     """This function checks whether the attributes of the user's metadata constituting a profile are filled out.
     :param state_machine_data: A tuple containing user input, a ussd session and user object.
     :type state_machine_data: str
@@ -29,7 +29,7 @@ def has_cached_user_metadata(state_machine_data: Tuple[str, dict, Account]):
     return user_metadata is not None
 
 
-def is_valid_name(state_machine_data: Tuple[str, dict, Account]):
+def is_valid_name(state_machine_data: Tuple[str, dict, User]):
     """This function checks that a user provided name is valid
     :param state_machine_data: A tuple containing user input, a ussd session and user object.
     :type state_machine_data: str
@@ -43,7 +43,7 @@ def is_valid_name(state_machine_data: Tuple[str, dict, Account]):
         return False
 
 
-def is_valid_gender_selection(state_machine_data: Tuple[str, dict, Account]):
+def is_valid_gender_selection(state_machine_data: Tuple[str, dict, User]):
     """
     :param state_machine_data:
     :type state_machine_data:

apps/cic-ussd/cic_ussd/state_machine/state_machine.py

@@ -13,7 +13,7 @@ class UssdStateMachine(Machine):
     """This class describes a finite state machine responsible for maintaining all the states that describe the ussd
     menu  as well as providing a means for navigating through these states based on different user inputs.
     It defines different helper functions that co-ordinate with the stakeholder components of the ussd menu: i.e  the
-    Account, UssdSession, UssdMenu to facilitate user interaction with ussd menu.
+    User, UssdSession, UssdMenu to facilitate user interaction with ussd menu.
     :cvar states: A list of pre-defined states.
     :type states: list
     :cvar transitions: A list of pre-defined transitions.

apps/cic-ussd/cic_ussd/tasks/callback_handler.py

@@ -9,7 +9,7 @@ import celery
 # local imports
 from cic_ussd.conversions import from_wei
 from cic_ussd.db.models.base import SessionBase
-from cic_ussd.db.models.account import Account
+from cic_ussd.db.models.user import User
 from cic_ussd.account import define_account_tx_metadata
 from cic_ussd.error import ActionDataNotFoundError
 from cic_ussd.redis import InMemoryStore, cache_data, create_cached_data_key
@@ -49,7 +49,7 @@ def process_account_creation_callback(self, result: str, url: str, status_code:
             phone_number = account_creation_data.get('phone_number')
 
             # create user
-            user = Account(blockchain_address=result, phone_number=phone_number)
+            user = User(blockchain_address=result, phone_number=phone_number)
             session.add(user)
             session.commit()
             session.close()
@@ -83,12 +83,12 @@ def process_incoming_transfer_callback(result: dict, param: str, status_code: in
         # collect result data
         recipient_blockchain_address = result.get('recipient')
         sender_blockchain_address = result.get('sender')
-        token_symbol = result.get('destination_token_symbol')
-        value = result.get('destination_token_value')
+        token_symbol = result.get('token_symbol')
+        value = result.get('destination_value')
 
         # try to find users in system
-        recipient_user = session.query(Account).filter_by(blockchain_address=recipient_blockchain_address).first()
-        sender_user = session.query(Account).filter_by(blockchain_address=sender_blockchain_address).first()
+        recipient_user = session.query(User).filter_by(blockchain_address=recipient_blockchain_address).first()
+        sender_user = session.query(User).filter_by(blockchain_address=sender_blockchain_address).first()
 
         # check whether recipient is in the system
         if not recipient_user:
@@ -188,8 +188,8 @@ def process_statement_callback(result, param: str, status_code: int):
                 processed_transaction = {}
 
                 # check if sender is in the system
-                sender: Account = session.query(Account).filter_by(blockchain_address=sender_blockchain_address).first()
-                owner: Account = session.query(Account).filter_by(blockchain_address=param).first()
+                sender: User = session.query(User).filter_by(blockchain_address=sender_blockchain_address).first()
+                owner: User = session.query(User).filter_by(blockchain_address=param).first()
                 if sender:
                     processed_transaction['sender_phone_number'] = sender.phone_number
 
@@ -205,7 +205,7 @@ def process_statement_callback(result, param: str, status_code: int):
                     processed_transaction['sender_phone_number'] = 'GRASSROOTS ECONOMICS'
 
                 # check if recipient is in the system
-                recipient: Account = session.query(Account).filter_by(blockchain_address=recipient_address).first()
+                recipient: User = session.query(User).filter_by(blockchain_address=recipient_address).first()
                 if recipient:
                     processed_transaction['recipient_phone_number'] = recipient.phone_number
 

apps/cic-ussd/cic_ussd/translation.py

@@ -8,7 +8,7 @@ from typing import Optional
 def translation_for(key: str, preferred_language: Optional[str] = None, **kwargs) -> str:
     """
     Translates text mapped to a specific YAML key into the user's set preferred language.
-    :param preferred_language: Account's preferred language in which to view the ussd menu.
+    :param preferred_language: User's preferred language in which to view the ussd menu.
     :type preferred_language str
     :param key: Key to a specific YAML test entry
     :type key: str

apps/cic-ussd/cic_ussd/validator.py

@@ -8,7 +8,7 @@ import ipaddress
 from confini import Config
 
 # local imports
-from cic_ussd.db.models.account import Account
+from cic_ussd.db.models.user import User
 
 logg = logging.getLogger(__file__)
 
@@ -68,7 +68,7 @@ def check_known_user(phone: str):
     :return: Is known phone number
     :rtype: boolean
     """
-    user = Account.session.query(Account).filter_by(phone_number=phone).first()
+    user = User.session.query(User).filter_by(phone_number=phone).first()
     return user is not None
 
 

apps/cic-ussd/cic_ussd/version.py

@@ -1,7 +1,7 @@
 # standard imports
 import semver
 
-version = (0, 3, 0, 'alpha.9')
+version = (0, 3, 0, 'alpha.8')
 
 version_object = semver.VersionInfo(
         major=version[0],

apps/cic-ussd/requirements.txt

@@ -1,4 +1,4 @@
 cic_base[full_graph]~=0.1.2a68
 cic-eth~=0.11.0b3
-cic-notify~=0.4.0a4
+cic-notify~=0.4.0a3
 cic-types~=0.1.0a10

apps/cic-ussd/tests/cic_ussd/db/models/test_user.py

@@ -4,19 +4,19 @@
 import pytest
 
 # platform imports
-from cic_ussd.db.models.account import Account
+from cic_ussd.db.models.user import User
 
 
 def test_user(init_database, set_fernet_key):
-    user = Account(blockchain_address='0x417f5962fc52dc33ff0689659b25848680dec6dcedc6785b03d1df60fc6d5c51',
-                   phone_number='+254700000000')
+    user = User(blockchain_address='0x417f5962fc52dc33ff0689659b25848680dec6dcedc6785b03d1df60fc6d5c51',
+                phone_number='+254700000000')
     user.create_password('0000')
 
-    session = Account.session
+    session = User.session
     session.add(user)
     session.commit()
 
-    queried_user = session.query(Account).get(1)
+    queried_user = session.query(User).get(1)
     assert queried_user.blockchain_address == '0x417f5962fc52dc33ff0689659b25848680dec6dcedc6785b03d1df60fc6d5c51'
     assert queried_user.phone_number == '+254700000000'
     assert queried_user.failed_pin_attempts == 0
@@ -25,7 +25,7 @@ def test_user(init_database, set_fernet_key):
 
 def test_user_state_transition(create_pending_user):
     user = create_pending_user
-    session = Account.session
+    session = User.session
 
     assert user.get_account_status() == 'PENDING'
     user.activate_account()

apps/cic-ussd/tests/cic_ussd/tasks/test_callback_handler_tasks.py

@@ -8,7 +8,7 @@ import celery
 import pytest
 
 # local imports
-from cic_ussd.db.models.account import Account
+from cic_ussd.db.models.user import User
 from cic_ussd.error import ActionDataNotFoundError
 from cic_ussd.conversions import from_wei
 
@@ -29,7 +29,7 @@ def test_successful_process_account_creation_callback_task(account_creation_acti
     # WARNING: [THE SETTING OF THE ROOT ID IS A HACK AND SHOULD BE REVIEWED OR IMPROVED]
     mocked_task_request.root_id = task_id
 
-    user = init_database.query(Account).filter_by(phone_number=phone_number).first()
+    user = init_database.query(User).filter_by(phone_number=phone_number).first()
     assert user is None
 
     redis_cache = init_redis_cache
@@ -48,7 +48,7 @@ def test_successful_process_account_creation_callback_task(account_creation_acti
     )
     s_process_callback_request.apply_async().get()
 
-    user = init_database.query(Account).filter_by(phone_number=phone_number).first()
+    user = init_database.query(User).filter_by(phone_number=phone_number).first()
     assert user.blockchain_address == result
 
     action_data = redis_cache.get(task_id)

apps/cic-ussd/tests/cic_ussd/test_requests.py

@@ -2,7 +2,7 @@
 import json
 
 # local imports
-from cic_ussd.db.models.account import Account
+from cic_ussd.db.models.user import User
 from cic_ussd.requests import (get_query_parameters,
                                get_request_endpoint,
                                get_request_method,
@@ -58,8 +58,8 @@ def test_process_locked_accounts_requests(create_locked_accounts, valid_locked_a
     assert len(locked_account_addresses) == 10
 
     # check that blockchain addresses are ordered by most recently accessed
-    user_1 = Account.session.query(Account).filter_by(blockchain_address=locked_account_addresses[2]).first()
-    user_2 = Account.session.query(Account).filter_by(blockchain_address=locked_account_addresses[7]).first()
+    user_1 = User.session.query(User).filter_by(blockchain_address=locked_account_addresses[2]).first()
+    user_2 = User.session.query(User).filter_by(blockchain_address=locked_account_addresses[7]).first()
 
     assert user_1.updated > user_2.updated
 

apps/cic-ussd/tests/fixtures/user.py

@@ -9,7 +9,7 @@ from cic_types.models.person import generate_metadata_pointer
 from faker import Faker
 
 # local imports
-from cic_ussd.db.models.account import AccountStatus, Account
+from cic_ussd.db.models.user import AccountStatus, User
 from cic_ussd.redis import cache_data
 from cic_ussd.metadata import blockchain_address_to_metadata_pointer
 
@@ -19,7 +19,7 @@ fake = Faker()
 
 @pytest.fixture(scope='function')
 def create_activated_user(init_database, set_fernet_key):
-    user = Account(
+    user = User(
         blockchain_address='0xFD9c5aD15C72C6F60f1a119A608931226674243f',
         phone_number='+25498765432'
     )
@@ -33,7 +33,7 @@ def create_activated_user(init_database, set_fernet_key):
 
 @pytest.fixture(scope='function')
 def create_valid_tx_recipient(init_database, set_fernet_key):
-    user = Account(
+    user = User(
         blockchain_address='0xd6204101012270Bf2558EDcFEd595938d1847bf0',
         phone_number='+25498765432'
     )
@@ -47,7 +47,7 @@ def create_valid_tx_recipient(init_database, set_fernet_key):
 
 @pytest.fixture(scope='function')
 def create_valid_tx_sender(init_database, set_fernet_key):
-    user = Account(
+    user = User(
         blockchain_address='0xd6204101012270Bf2558EDcFEd595938d1847bf1',
         phone_number='+25498765433'
     )
@@ -61,7 +61,7 @@ def create_valid_tx_sender(init_database, set_fernet_key):
 
 @pytest.fixture(scope='function')
 def create_pending_user(init_database, set_fernet_key):
-    user = Account(
+    user = User(
         blockchain_address='0x0ebdea8612c1b05d952c036859266c7f2cfcd6a29842d9c6cce3b9f1ba427588',
         phone_number='+25498765432'
     )
@@ -72,7 +72,7 @@ def create_pending_user(init_database, set_fernet_key):
 
 @pytest.fixture(scope='function')
 def create_pin_blocked_user(init_database, set_fernet_key):
-    user = Account(
+    user = User(
         blockchain_address='0x0ebdea8612c1b05d952c036859266c7f2cfcd6a29842d9c6cce3b9f1ba427588',
         phone_number='+25498765432'
     )
@@ -90,7 +90,7 @@ def create_locked_accounts(init_database, set_fernet_key):
         blockchain_address = str(uuid.uuid4())
         phone_number = fake.phone_number()
         pin = f'{randint(1000, 9999)}'
-        user = Account(phone_number=phone_number, blockchain_address=blockchain_address)
+        user = User(phone_number=phone_number, blockchain_address=blockchain_address)
         user.create_password(password=pin)
         user.failed_pin_attempts = 3
         user.account_status = AccountStatus.LOCKED.value

apps/contract-migration/scripts/cic_eth/import_balance.py

@@ -25,13 +25,13 @@ from chainlib.eth.block import (
         block_by_number,
         Block,
         )
-from chainlib.hash import keccak256_string_to_hex
+from chainlib.eth.hash import keccak256_string_to_hex
 from chainlib.eth.address import to_checksum_address
 from chainlib.eth.erc20 import ERC20
 from chainlib.eth.gas import OverrideGasOracle
 from chainlib.eth.nonce import RPCNonceOracle
 from chainlib.eth.tx import TxFactory
-from chainlib.jsonrpc import jsonrpc_template
+from chainlib.eth.rpc import jsonrpc_template
 from chainlib.eth.error import EthException
 from chainlib.chain import ChainSpec
 from crypto_dev_signer.eth.signer import ReferenceSigner as EIP155Signer

apps/contract-migration/scripts/eth/import_balance.py

@@ -25,13 +25,13 @@ from chainlib.eth.block import (
         block_by_number,
         Block,
         )
-from chainlib.hash import keccak256_string_to_hex
+from chainlib.eth.hash import keccak256_string_to_hex
 from chainlib.eth.address import to_checksum_address
 from chainlib.eth.erc20 import ERC20
 from chainlib.eth.gas import OverrideGasOracle
 from chainlib.eth.nonce import RPCNonceOracle
 from chainlib.eth.tx import TxFactory
-from chainlib.jsonrpc import jsonrpc_template
+from chainlib.eth.rpc import jsonrpc_template
 from chainlib.eth.error import EthException
 from chainlib.chain import ChainSpec
 from crypto_dev_signer.eth.signer import ReferenceSigner as EIP155Signer

apps/contract-migration/scripts/eth/import_users.py

@@ -24,7 +24,7 @@ from chainlib.eth.gas import RPCGasOracle
 from chainlib.eth.nonce import RPCNonceOracle
 from cic_types.processor import generate_metadata_pointer
 from eth_accounts_index import AccountRegistry
-from eth_contract_registry import Registry
+from contract_registry import Registry
 from crypto_dev_signer.keystore.dict import DictKeystore
 from crypto_dev_signer.eth.signer.defaultsigner import ReferenceSigner as EIP155Signer
 from crypto_dev_signer.keystore.keyfile import to_dict as to_keyfile_dict

apps/contract-migration/scripts/package.json

@@ -1,6 +1,6 @@
 {
   "dependencies": {
-    "cic-client-meta": "0.0.7-alpha.6",
+    "cic-client-meta": "^0.0.7-alpha.6",
     "vcard-parser": "^1.0.0"
   }
 }

apps/contract-migration/scripts/verify.py

@@ -22,7 +22,7 @@ from hexathon import (
         strip_0x,
         add_0x,
         )
-from chainsyncer.backend.memory import MemBackend
+from chainsyncer.backend import MemBackend
 from chainsyncer.driver import HeadSyncer
 from chainlib.chain import ChainSpec
 from chainlib.eth.connection import EthHTTPConnection
@@ -32,7 +32,7 @@ from chainlib.eth.block import (
         block_by_number,
         Block,
         )
-from chainlib.hash import keccak256_string_to_hex
+from chainlib.eth.hash import keccak256_string_to_hex
 from chainlib.eth.address import to_checksum_address
 from chainlib.eth.erc20 import ERC20
 from chainlib.eth.gas import (
@@ -40,7 +40,7 @@ from chainlib.eth.gas import (
         balance,
         )
 from chainlib.eth.tx import TxFactory
-from chainlib.jsonrpc import jsonrpc_template
+from chainlib.eth.rpc import jsonrpc_template
 from chainlib.eth.error import EthException
 from cic_types.models.person import (
         Person,
@@ -57,7 +57,6 @@ custodial_tests = [
         'local_key',
         'gas',
         'faucet',
-        'ussd'
         ]
 
 metadata_tests = [

apps/util/liveness/MANIFEST.in

@@ -1 +0,0 @@
-include *health*.sh

apps/util/liveness/Makefile

@@ -1,10 +0,0 @@
-docs:
-	mkdir -p doc/texinfo/html
-	makeinfo doc/texinfo/index.texi --html -o doc/texinfo/html/
-
-markdown: doc
-	pandoc -f html -t markdown --standalone doc/texinfo/html/liveness.html -o README.md
-
-
-.PHONY dist:
-	python setup.py sdist

apps/util/liveness/README.md

@@ -1,105 +0,0 @@
----
-description: liveness (Untitled Document)
-distribution: global
-Generator: makeinfo
-keywords: liveness (Untitled Document)
-lang: en
-resource-type: document
-title: liveness (Untitled Document)
----
-
-[]{#liveness}[]{#liveness-1}
-
-## 1 liveness {#liveness .chapter}
-
-[]{#ilveness_005foverview}[]{#Overview}
-
-### 1.1 Overview {#overview .section}
-
-This is a cluster-specific convenience setup for enabling a
-Kubernetes-style liveness/readiness test as outlined in
-<https://kubernetes.io/docs/tasks/configure-pod-container/configure-liveness-readiness-startup-probes/>.
-
-Conceptually, it provides an application with means to:
-
--   Run a collection of functions to validate sanity of the environment
--   Set a no-error state before execution of the main routine
--   Modify the error state during execution
--   Invalidating all state when execution ends
-
-[]{#Python-module}
-
-### 1.2 Python module {#python-module .section}
-
-Three python methods are provided.
-
-[]{#load}
-
-#### 1.2.1 load {#load .subsection}
-
-This is meant to be called after configurations and environment has been
-set up, but before the execution logic has commenced.
-
-It receives a list of externally defined fully-qualified python modules.
-Each of these modules must implement the method `health(*args,**kwargs)`
-in its global namespace.
-
-Any module returning `False` will cause a `RuntimeException`.
-
-The component will not trap any other exception from the modules.
-
-If successful, it will write the `pid` of the application to the
-specified run data folder. By default this is `/run/<HOSTNAME>`, but the
-path can be modified if desired.
-
-[]{#set}
-
-#### 1.2.2 set {#set .subsection}
-
-This is meant to be called during the execution of the main program
-routine begins.
-
-[]{#at-startup}
-
-#### 1.2.2.1 at startup {#at-startup .subsubsection}
-
-It should be called once at the *start* of execution of the main program
-routine.
-
-For one-shot routines, this would mean the start of any code only run
-when the module name is `__main__`.
-
-For daemons, it would be just before handing over execution to the main
-loop.
-
-[]{#during-execution}
-
-#### 1.2.2.2 during execution {#during-execution .subsubsection}
-
-Call `set(error_code=<error>, ...` any time the health state temporarily
-changes. Any `error` value other than `0` is considered an unhealthy
-state.
-
-[]{#at-shutdown}
-
-#### 1.2.2.3 at shutdown {#at-shutdown .subsubsection}
-
-Call `reset(...)`, which will indicate that the state is to be
-considered the same as at startup.
-
-[]{#shell}
-
-### 1.3 shell {#shell .section}
-
-A bash script is provided for *Kubernetes* to perform the health check.
-
-It performs the following checks:
-
-1.  A numeric value exists in `<rundir>/<unitname>/pid`{.sample}.
-2.  The numeric value is a directory in `/proc`{.sample} (a valid pid)
-3.  The file `<rundir>/<unitname>/error`{.sample} contains \"0\"
-
-If any of these checks fail should inditcate that the container is
-unhealthy.
-
-------------------------------------------------------------------------

apps/util/liveness/doc/texinfo/index.texi

@@ -1,71 +0,0 @@
-@node liveness
-@chapter liveness
-
-@anchor{ilveness_overview}
-@section Overview
-
-This is a cluster-specific convenience setup for enabling a Kubernetes-style liveness/readiness test as outlined in @url{https://kubernetes.io/docs/tasks/configure-pod-container/configure-liveness-readiness-startup-probes/}.
-
-Conceptually, it provides an application with means to:
-
-@itemize
-@item Run a collection of functions to validate sanity of the environment
-@item Set a no-error state before execution of the main routine
-@item Modify the error state during execution
-@item Invalidating all state when execution ends
-@end itemize
-
-
-@section Python module
-
-Three python methods are provided.
-
-@subsection load
-
-This is meant to be called after configurations and environment has been set up, but before the execution logic has commenced.
-
-It receives a list of externally defined fully-qualified python modules. Each of these modules must implement the method @code{health(*args,**kwargs)} in its global namespace.
-
-Any module returning @code{False} will cause a @code{RuntimeException}.
-
-The component will not trap any other exception from the modules.
-
-If successful, it will write the @code{pid}  of the application to the specified run data folder. By default this is @code{/run/<HOSTNAME>}, but the path can be modified if desired.
-
-
-@subsection set
-
-This is meant to be called during the execution of the main program routine begins.
-
-@subsubsection at startup
-
-It should be called once at the @emph{start} of execution of the main program routine.
-
-For one-shot routines, this would mean the start of any code only run when the module name is @code{__main__}. 
-
-For daemons, it would be just before handing over execution to the main loop.
-
-
-@subsubsection during execution
-
-Call @code{set(error_code=<error>, ...} any time the health state temporarily changes. Any @code{error} value other than @code{0} is considered an unhealthy state.
-
-
-@subsubsection at shutdown
-
-Call @code{reset(...)}, which will indicate that the state is to be considered the same as at startup.
-
-
-@section shell
-
-A bash script is provided for @emph{Kubernetes} to perform the health check. 
-
-It performs the following checks:
-
-@enumerate
-@item A numeric value exists in @file{<rundir>/<unitname>/pid}.
-@item The numeric value is a directory in @file{/proc} (a valid pid)
-@item The file @file{<rundir>/<unitname>/error} contains "0"
-@end enumerate
-
-If any of these checks fail should inditcate that the container is unhealthy.

apps/util/liveness/health.sh

@@ -1,35 +0,0 @@
-#!/bin/bash
-
-rundir=${CIC_RUNDIR:-/run}
-unit=${CIC_UNIT:-$HOSTNAME}
-
-read p < $rundir/$unit/pid
-
-if [ -z $p ]; then
-	>&2 echo unit $unit has no pid
-	exit 1
-fi
-
-if [ ! -d /proc/$p ]; then
-	>&2 echo unit $unit reports non-existent pid $p
-	exit 1
-fi	
-
->&2 echo unit $unit has pid $p
-
-if [ ! -f $rundir/$unit/error ]; then
-	>&2 echo unit $unit has unspecified state
-	exit 1
-fi
-
-read e 2> /dev/null < $rundir/$unit/error 
-if [ -z $e ]; then
-	>&2 echo unit $unit has unspecified state
-	exit 1
-fi
-
->&2 echo unit $unit has error $e
-
-if [ $e -gt 0 ]; then
-	exit 1;
-fi

apps/util/liveness/liveness/linux.py

@@ -1,61 +0,0 @@
-# standard imports
-import importlib
-import sys
-import os
-import logging
-
-logg = logging.getLogger().getChild(__name__)
-
-pid = os.getpid()
-
-default_namespace = os.environ.get('LIVENESS_UNIT_NAME')
-if default_namespace == None:
-    import socket
-    default_namespace = socket.gethostname()
-
-
-def check_by_module(checks, *args, **kwargs):
-    for check in checks:
-        r = check.health(args, kwargs)
-        if r == False:
-            raise RuntimeError('liveness check {} failed'.format(str(check)))
-        logg.info('liveness check passed: {}'.format(str(check)))
-
-
-def check_by_string(check_strs, *args, **kwargs):
-    checks = []
-    for m in check_strs:
-        logg.debug('added liveness check: {}'.format(str(m)))
-        module = importlib.import_module(m)
-        checks.append(module)
-    return check_by_module(checks, args, kwargs)
-   
-
-def load(check_strs, namespace=default_namespace, rundir='/run', *args, **kwargs):
-
-    if namespace == None:
-        import socket
-        namespace = socket.gethostname()
-
-    check_by_string(check_strs)
-
-    logg.info('pid ' + str(pid))
-
-    app_rundir = os.path.join(rundir, namespace)
-    os.makedirs(app_rundir, exist_ok=True) # should not already exist
-    f = open(os.path.join(app_rundir, 'pid'), 'w')
-    f.write(str(pid))
-    f.close()
-
-
-def set(error=0, namespace=default_namespace, rundir='/run'):
-    app_rundir = os.path.join(rundir, namespace)
-    f = open(os.path.join(app_rundir, 'error'), 'w')
-    f.write(str(error))
-    f.close()
-
-
-def reset(namespace=default_namespace, rundir='/run'):
-    app_rundir = os.path.join(rundir, namespace)
-    os.unlink(os.path.join(app_rundir, 'pid'))
-    os.unlink(os.path.join(app_rundir, 'error'))

apps/util/liveness/setup.py

@@ -1,7 +0,0 @@
-from setuptools import setup
-setup(
-        name='liveness',
-        version='0.0.1a6',
-        packages=['liveness'],
-        include_package_data=True,
-        )

apps/util/liveness/test_health.sh

@@ -1,17 +0,0 @@
-#!/bin/bash
-
-export CIC_RUNDIR=`realpath ./tests/testdata/run`
-t=`mktemp -d -p $CIC_RUNDIR`
-export CIC_UNIT=`basename $t`
-
->&2 echo test pid $$
-echo $$ > $t/pid
-echo 0 > $t/error
-
-. health.sh
-
-echo 1 > $t/error
-#unlink $t/error
-. health.sh
-
-echo if error this is not printed

apps/util/liveness/tests/imports/import_args.py

@@ -1,8 +0,0 @@
-a = ['foo']
-kw = {
-    'bar': 42,
-        }
-
-def health(*args, **kwargs):
-    args[0] == a[0]
-    kwargs['bar'] = kw['bar']

apps/util/liveness/tests/imports/import_false.py

@@ -1,2 +0,0 @@
-def health(*args, **kwargs):
-    return False

apps/util/liveness/tests/imports/import_true.py

@@ -1,2 +0,0 @@
-def health(*args, **kwargs):
-    return True

apps/util/liveness/tests/test_imports.py

@@ -1,127 +0,0 @@
-# standard imports
-import os
-import unittest
-import logging
-import tempfile
-import socket
-
-# local imports
-import liveness.linux 
-
-## test imports
-import tests.imports
-
-
-logging.basicConfig(level=logging.DEBUG)
-logg = logging.getLogger()
-script_dir = os.path.realpath(os.path.dirname(__file__))
-data_dir = os.path.join(script_dir, 'testdata')
-run_base_dir = os.path.join(data_dir, 'run')
-
-
-class TestImports(unittest.TestCase):
-
-    def setUp(self):
-        os.makedirs(run_base_dir, exist_ok=True)
-        self.run_dir = tempfile.mkdtemp(dir=run_base_dir)
-        self.unit = 'unittest'
-        self.unit_dir = os.path.join(self.run_dir, self.unit)
-        self.pid_path = os.path.join(self.unit_dir, 'pid')
-        self.error_path = os.path.join(self.unit_dir, 'error')
-        self.host_path = os.path.join(self.run_dir, socket.gethostname())
-
-
-    def test_no_import(self):
-        liveness.linux.load([], namespace=self.unit, rundir=self.run_dir)
-        f = open(self.pid_path, 'r')
-        r = f.read()
-        f.close()
-        self.assertEqual(str(os.getpid()), r)
-
- 
-    def test_hostname(self):
-        liveness.linux.load([], rundir=self.run_dir)
-        f = open(os.path.join(self.host_path, 'pid'), 'r')
-        r = f.read()
-        f.close()
-        self.assertEqual(str(os.getpid()), r)
-
-   
-    def test_import_single_true(self):
-        checks = ['tests.imports.import_true']
-        liveness.linux.load(checks, namespace=self.unit, rundir=self.run_dir)
-        f = open(self.pid_path, 'r')
-        r = f.read()
-        f.close()
-        self.assertEqual(str(os.getpid()), r)
-
-
-    def test_import_single_false(self):
-        checks = ['tests.imports.import_false']
-        with self.assertRaises(RuntimeError):
-            liveness.linux.load(checks, namespace=self.unit, rundir=self.run_dir)
-        with self.assertRaises(FileNotFoundError):
-            os.stat(self.pid_path)
-
-
-    def test_import_false_then_true(self):
-        checks = ['tests.imports.import_false', 'tests.imports.import_true']
-        with self.assertRaises(RuntimeError):
-            liveness.linux.load(checks, namespace=self.unit, rundir=self.run_dir)
-        with self.assertRaises(FileNotFoundError):
-            os.stat(self.pid_path)
-
-
-    def test_import_multiple_true(self):
-        checks = ['tests.imports.import_true', 'tests.imports.import_true']
-        liveness.linux.load(checks, namespace=self.unit, rundir=self.run_dir)
-        f = open(self.pid_path, 'r')
-        r = f.read()
-        f.close()
-        self.assertEqual(str(os.getpid()), r)
-
-
-    def test_set(self):
-        liveness.linux.load([], namespace='unittest', rundir=self.run_dir)
-        liveness.linux.set(namespace='unittest', rundir=self.run_dir)
-        f = open(self.error_path, 'r')
-        r = f.read()
-        f.close()
-        self.assertEqual('0', r)
-
-        liveness.linux.set(error=42, namespace='unittest', rundir=self.run_dir)
-        f = open(self.error_path, 'r')
-        r = f.read()
-        f.close()
-        self.assertEqual('42', r)
-
-        liveness.linux.reset(namespace='unittest', rundir=self.run_dir)
-        with self.assertRaises(FileNotFoundError):
-            os.stat(self.error_path)
-            
-
-    def test_set_hostname(self):
-        liveness.linux.load([], rundir=self.run_dir)
-        liveness.linux.set(rundir=self.run_dir)
-        error_path = os.path.join(self.host_path, 'error')
-        f = open(error_path, 'r')
-        r = f.read()
-        f.close()
-        self.assertEqual('0', r)
-
-        liveness.linux.reset(rundir=self.run_dir)
-        with self.assertRaises(FileNotFoundError):
-            os.stat(error_path)
-    
-
-    def test_args(self):
-        checks = ['tests.imports.import_args']
-        liveness.linux.load(checks, namespace=self.unit, rundir=self.run_dir, args=['foo'], kwargs={'bar': 42})
-        f = open(self.pid_path, 'r')
-        r = f.read()
-        f.close()
-        self.assertEqual(str(os.getpid()), r)
-
-
-if __name__ == '__main__':
-    unittest.main()

ci_templates/.cic-template.yml

@@ -24,7 +24,7 @@ variables:
       IMAGE_TAG_BASE: $CI_REGISTRY_IMAGE/$APP_NAME:$CI_COMMIT_BRANCH-$CI_COMMIT_SHORT_SHA
       LATEST_TAG: $CI_REGISTRY_IMAGE/$APP_NAME:latest
   script:
-    - export IMAGE_TAG="$IMAGE_TAG_BASE-$(date +%s)"
+    - export IMAGE_TAG="$IMAGE_TAG_BASE-$(date +%F.%H%M%S)"
     - mkdir -p /kaniko/.docker
     - echo "{\"auths\":{\"$CI_REGISTRY\":{\"username\":\"$CI_REGISTRY_USER\",\"password\":\"$CI_REGISTRY_PASSWORD\"}}}" > "/kaniko/.docker/config.json"
     # - /kaniko/executor --context $CONTEXT --dockerfile $DOCKERFILE_PATH $KANIKO_CACHE_ARGS --destination $IMAGE_TAG

docker-compose.yml

@@ -446,7 +446,7 @@ services:
     deploy:
       restart_policy:
         condition: on-failure
-    command: "/root/start_tasker.sh -q cic-notify -vv"
+    command: "/root/start_tasker.sh -q cic-notify"
 
 
   cic-meta-server:
@@ -494,8 +494,6 @@ services:
       DATABASE_NAME: cic_ussd
       DATABASE_ENGINE: postgresql
       DATABASE_DRIVER: psycopg2
-      CELERY_BROKER_URL: ${CELERY_BROKER_URL:-redis://redis}
-      CELERY_RESULT_URL: ${CELERY_BROKER_URL:-redis://redis}
       PGP_PASSPHRASE: merman
       SERVER_PORT: 9000
       CIC_META_URL: ${CIC_META_URL:-http://meta:8000}

scripts/initdb/create_db.sql

@@ -5,7 +5,6 @@ CREATE DATABASE "cic_notify";
 CREATE DATABASE "cic_meta";
 CREATE DATABASE "cic_signer";
 CREATE DATABASE "cic_ussd";
-CREATE DATABASE "chain_sync";
 GRANT ALL PRIVILEGES 
-ON DATABASE "cic_cache", "cic_eth", "cic_notify", "cic_meta", "cic_signer", "cic_ussd", "chain_sync"
+ON DATABASE "cic_cache", "cic_eth", "cic_notify", "cic_meta", "cic_signer", "cic_ussd"
 TO grassroots;