144 lines
4.7 KiB
Python
144 lines
4.7 KiB
Python
# standard imports
|
|
import json
|
|
import logging
|
|
import os
|
|
|
|
# external imports
|
|
from chainlib.chain import ChainSpec
|
|
# local imports
|
|
from cic.contract.base import Data, data_dir
|
|
|
|
logg = logging.getLogger(__name__)
|
|
|
|
|
|
class Network(Data):
|
|
"""Contains network settings for token deployments across extensions.
|
|
|
|
Extension targets are defined by the keys immediately following the "resources" key in the network settings file.
|
|
|
|
:param path: Path to settings directory
|
|
:type path: str
|
|
:param targets: Extension targets to execute
|
|
:type targets: list of str
|
|
"""
|
|
def __init__(self, path='.', targets=[]):
|
|
super(Network, self).__init__()
|
|
self.resources = None
|
|
self.path = path
|
|
self.targets = targets
|
|
self.network_path = os.path.join(self.path, 'network.json')
|
|
|
|
|
|
def load(self):
|
|
"""Load network settings from file.
|
|
"""
|
|
super(Network, self).load()
|
|
|
|
with open(self.network_path, 'r', encoding='utf-8') as f:
|
|
o = json.load(f)
|
|
|
|
self.resources = o['resources']
|
|
|
|
self.inited = True
|
|
|
|
|
|
def start(self):
|
|
"""Initialize network settings with targets chosen at object instantiation.
|
|
|
|
Will save to network settings file.
|
|
"""
|
|
super(Network, self).load()
|
|
|
|
network_template_file_path = os.path.join(data_dir, f'network_template_v{self.version()}.json')
|
|
|
|
with open(network_template_file_path, encoding='utf-8') as f:
|
|
o_part = json.load(f)
|
|
|
|
self.resources = {}
|
|
for v in self.targets:
|
|
self.resources[v] = o_part
|
|
|
|
self.save()
|
|
|
|
|
|
def save(self):
|
|
"""Save network settings to file.
|
|
"""
|
|
with open(self.network_path, 'w', encoding='utf-8') as f:
|
|
json.dump({
|
|
'resources': self.resources,
|
|
}, f, sort_keys=True, indent="\t")
|
|
|
|
|
|
def resource(self, k):
|
|
"""Get settings definitions for a given extension.
|
|
|
|
:param k: Extension key
|
|
:type k: str
|
|
:rtype: dict
|
|
:return: Extension settings
|
|
"""
|
|
v = self.resources.get(k)
|
|
if v is None:
|
|
raise AttributeError(f'No defined reference for {k}')
|
|
return v
|
|
|
|
|
|
def resource_set(self, resource_key, content_key, reference, key_account=None):
|
|
"""Set the values a content part of an extension setting.
|
|
|
|
The content parts define network application resources. Each entry is keyed by the name of the application. Each value consists of a key_account used to write/deploy to the contract, and the reference (address) of the application resource. If no application resource yet exists on the network for the part, the reference value will be None.
|
|
|
|
:param resource_key: Extension key
|
|
:type resource_key: str
|
|
:param content_key: Resource name (e.g. smart contract name)
|
|
:type content_key: str
|
|
:param reference: Reference to resource on network (e.g. smart contract address)
|
|
:type reference: str
|
|
:param key_account: Address of account to sign transaction for the resource with
|
|
:type key_account: str
|
|
|
|
"""
|
|
self.resources[resource_key]['contents'][content_key]['reference'] = reference
|
|
self.resources[resource_key]['contents'][content_key]['key_account'] = key_account
|
|
|
|
|
|
def chain_spec(self, k):
|
|
"""Retrieve chain spec for the given extension
|
|
|
|
:param k: Extension key
|
|
:type k: str
|
|
:rtype: chainlib.chain.ChainSpec
|
|
:return: Chain spec object
|
|
"""
|
|
v = self.resource(k)
|
|
return ChainSpec.from_dict(v['chain_spec'])
|
|
|
|
|
|
def set(self, resource_key, chain_spec):
|
|
"""Set chain spec for resource.
|
|
|
|
:param resource_key: Extension key
|
|
:type resource_key: str
|
|
:param chain_spec: Chain spec to set
|
|
:type chain_spec: chainlib.chain.ChainSpec
|
|
"""
|
|
chain_spec_dict = chain_spec.asdict()
|
|
for k in chain_spec_dict.keys():
|
|
logg.debug(f'resources: {self.resources}')
|
|
self.resources[resource_key]['chain_spec'][k] = chain_spec_dict[k]
|
|
|
|
|
|
def __str__(self):
|
|
s = ''
|
|
for resource in self.resources.keys():
|
|
chainspec = ChainSpec.from_dict(self.resources[resource]['chain_spec'])
|
|
s += f'{resource}.chain_spec: {str(chainspec)}\n'
|
|
for content_key in self.resources[resource]['contents'].keys():
|
|
content_value = self.resources[resource]['contents'][content_key]
|
|
if content_value is None:
|
|
content_value = ''
|
|
s += f'{resource}.contents.{content_key} = {json.dumps(content_value, indent=4, sort_keys=True)}\n'
|
|
|
|
return s
|