146 lines
4.1 KiB
Python
146 lines
4.1 KiB
Python
# standard imports
|
|
import importlib
|
|
import logging
|
|
import os
|
|
from typing import Optional
|
|
|
|
# external imports
|
|
from cic_types.ext.metadata import MetadataRequestsHandler
|
|
from cic_types.ext.metadata.signer import Signer as MetadataSigner
|
|
|
|
# local imports
|
|
from cic.contract.processor import ContractProcessor
|
|
from cic.contract.components.proof import Proof
|
|
from cic.contract.components.attachment import Attachment
|
|
from cic.contract.components.meta import Meta
|
|
from cic.contract.network import Network
|
|
from cic.contract.components.token import Token
|
|
from cic.writers import HTTPWriter, KeyedWriterFactory, MetadataWriter
|
|
|
|
logg = logging.getLogger(__name__)
|
|
|
|
|
|
def process_args(argparser):
|
|
argparser.add_argument(
|
|
"-d", "--directory", type=str, dest="directory", default=".", help="directory"
|
|
)
|
|
argparser.add_argument(
|
|
"-o",
|
|
"--output-directory",
|
|
type=str,
|
|
dest="output_directory",
|
|
help="output directory",
|
|
)
|
|
argparser.add_argument(
|
|
"--metadata-endpoint",
|
|
dest="metadata_endpoint",
|
|
type=str,
|
|
help="metadata endpoint to interact with",
|
|
)
|
|
argparser.add_argument(
|
|
"-y",
|
|
"--signer",
|
|
type=str,
|
|
dest="y",
|
|
help="target-specific signer to use for export",
|
|
)
|
|
argparser.add_argument("-p", type=str, help="RPC endpoint")
|
|
argparser.add_argument("target", type=str, help="target network type")
|
|
|
|
|
|
def validate_args(args):
|
|
pass
|
|
|
|
|
|
def init_writers_from_config(config):
|
|
w = {
|
|
"meta": None,
|
|
"attachment": None,
|
|
"proof": None,
|
|
"ext": None,
|
|
}
|
|
for v in w.keys():
|
|
k = "CIC_CORE_{}_WRITER".format(v.upper())
|
|
(d, c) = config.get(k).rsplit(".", maxsplit=1)
|
|
m = importlib.import_module(d)
|
|
o = getattr(m, c)
|
|
w[v] = o
|
|
|
|
return w
|
|
|
|
|
|
ExtraArgs = {
|
|
"target": str,
|
|
"directory": str,
|
|
"output_directory": str,
|
|
"metadata_endpoint": Optional[str],
|
|
"y": str,
|
|
}
|
|
|
|
|
|
def execute(config, eargs: ExtraArgs):
|
|
modname = f"cic.ext.{eargs.target}"
|
|
cmd_mod = importlib.import_module(modname)
|
|
|
|
writers = init_writers_from_config(config)
|
|
|
|
output_writer_path_meta = eargs.output_directory
|
|
if eargs.metadata_endpoint != None:
|
|
MetadataRequestsHandler.base_url = eargs.metadata_endpoint
|
|
MetadataSigner.gpg_path = os.path.join("/tmp")
|
|
MetadataSigner.key_file_path = config.get("AUTH_KEYFILE_PATH")
|
|
MetadataSigner.gpg_passphrase = config.get("AUTH_PASSPHRASE")
|
|
writers["proof"] = KeyedWriterFactory(MetadataWriter, HTTPWriter).new
|
|
writers["attachment"] = KeyedWriterFactory(None, HTTPWriter).new
|
|
writers["meta"] = MetadataWriter
|
|
output_writer_path_meta = eargs.metadata_endpoint
|
|
|
|
ct = Token(path=eargs.directory)
|
|
cm = Meta(
|
|
path=eargs.directory, writer=writers["meta"](path=output_writer_path_meta)
|
|
)
|
|
ca = Attachment(
|
|
path=eargs.directory, writer=writers["attachment"](path=output_writer_path_meta)
|
|
)
|
|
cp = Proof(
|
|
path=eargs.directory,
|
|
attachments=ca,
|
|
writer=writers["proof"](path=output_writer_path_meta),
|
|
)
|
|
cn = Network(path=eargs.directory)
|
|
|
|
ca.load()
|
|
ct.load()
|
|
cp.load()
|
|
cm.load()
|
|
cn.load()
|
|
|
|
chain_spec = None
|
|
try:
|
|
chain_spec = config.get("CHAIN_SPEC")
|
|
except KeyError:
|
|
chain_spec = cn.chain_spec
|
|
config.add(chain_spec, "CHAIN_SPEC", exists_ok=True)
|
|
logg.debug(f"CHAIN_SPEC config set to {str(chain_spec)}")
|
|
|
|
# signer = cmd_mod.parse_signer(eargs.y)
|
|
(rpc, signer) = cmd_mod.parse_adapter(config, eargs.y)
|
|
|
|
ref = cn.resource(eargs.target)
|
|
chain_spec = cn.chain_spec(eargs.target)
|
|
logg.debug(
|
|
f"found reference {ref['contents']} chain spec {chain_spec} for target {eargs.target}"
|
|
)
|
|
c = getattr(cmd_mod, "new")(
|
|
chain_spec,
|
|
ref["contents"],
|
|
cp,
|
|
signer_hint=signer,
|
|
rpc=rpc,
|
|
outputs_writer=writers["ext"](path=eargs.output_directory),
|
|
)
|
|
c.apply_token(ct)
|
|
|
|
p = ContractProcessor(proof=cp, attachment=ca, metadata=cm, extensions=[c])
|
|
p.process()
|