def setup_rca():
domain = settings.RCA_DOMAIN
# Create temp folder & namespace
settings.k8s.prereqs(domain)
if settings.K8S_TYPE == 'minikube':
storage_class = 'standard'
else:
storage_class = 'gp2'
dict_env = {
'ORG': domain,
'RCA_NAME': settings.RCA_NAME,
'FABRIC_ORGS': settings.ORGS,
'FABRIC_CA_TAG': settings.FABRIC_CA_TAG,
'EFS_SERVER': settings.EFS_SERVER,
'EFS_PATH': settings.EFS_PATH,
'EFS_EXTEND': settings.EFS_EXTEND,
'PVS_PATH': settings.PVS_PATH,
'STORAGE_CLASS': storage_class
}
k8s_template_file = '%s/rca/fabric-deployment-rca.yaml' % util.get_k8s_template_path()
settings.k8s.apply_yaml_from_template(
namespace=domain, k8s_template_file=k8s_template_file, dict_env=dict_env)
if settings.EXTERNAL_RCA_ADDRESSES != '':
# Deploy nlb
k8s_nlb_template_file = '%s/rca/fabric-deployment-rca-nlb.yaml' % util.get_k8s_template_path()
settings.k8s.apply_yaml_from_template(
namespace=domain, k8s_template_file=k8s_nlb_template_file, dict_env=dict_env)
def setup_orderer(orderer, index):
# Get domain
domain = util.get_domain(orderer)
# Create temp folder & namespace
settings.k8s.prereqs(domain)
dict_env = {
'ORDERER': orderer,
'ORDERER_DOMAIN': domain,
'ORDERER_INDEX': index,
'EFS_SERVER': settings.EFS_SERVER,
'EFS_PATH': settings.EFS_PATH,
'EFS_EXTEND': settings.EFS_EXTEND
}
orderer_stateful = '%s/orderer-sts/orderer-stateful.yaml' % util.get_k8s_template_path()
settings.k8s.apply_yaml_from_template(
namespace=domain, k8s_template_file=orderer_stateful, dict_env=dict_env)
orderer_service = '%s/orderer-sts/orderer-service.yaml' % util.get_k8s_template_path()
settings.k8s.apply_yaml_from_template(
namespace=domain, k8s_template_file=orderer_service, dict_env=dict_env)
if settings.EXTERNAL_ORDERER_ADDRESSES != '':
# Setup nlb
orderer_service_nlb = '%s/orderer-sts/orderer-service-nlb.yaml' % util.get_k8s_template_path()
settings.k8s.apply_yaml_from_template(
namespace=domain, k8s_template_file=orderer_service_nlb, dict_env=dict_env)
def setup_rca():
domain = settings.RCA_ORG
# Create temp folder & namespace
settings.k8s.prereqs(domain)
dict_env = {
'ORG': domain,
'RCA_NAME': settings.RCA_NAME,
'FABRIC_ORGS': settings.ORGS,
'EFS_SERVER': settings.EFS_SERVER,
'EFS_PATH': settings.EFS_PATH,
'EFS_EXTEND': settings.EFS_EXTEND
}
k8s_template_file = '%s/rca/fabric-deployment-rca.yaml' % util.get_k8s_template_path(
)
settings.k8s.apply_yaml_from_template(namespace=domain,
k8s_template_file=k8s_template_file,
dict_env=dict_env)
if settings.EXTERNAL_RCA_ADDRESSES != '':
# Deploy nlb
k8s_nlb_template_file = '%s/rca/fabric-deployment-rca-nlb.yaml' % util.get_k8s_template_path(
)
settings.k8s.apply_yaml_from_template(
namespace=domain,
k8s_template_file=k8s_nlb_template_file,
dict_env=dict_env)
def setup_explorer():
hiss.echo('Generate explorer config')
config = generate_explorer_config()
create_explorer_config_in_efs(json.dumps(config))
hiss.echo('Deploy explorer')
# Get domain
explorer_namespace = get_namespace()
# Create temp folder & namespace
settings.k8s.prereqs(explorer_namespace)
dict_env = {
'DOMAIN': explorer_namespace,
'DATABASE_PASSWORD': '******',
'EFS_SERVER': settings.EFS_SERVER,
'EFS_PATH': settings.EFS_PATH,
'EFS_EXTEND': settings.EFS_EXTEND
}
# Deploy explorer db sts
explorer_template = '%s/explorer/explorer-deployment.yaml' % util.get_k8s_template_path()
settings.k8s.apply_yaml_from_template(
namespace=explorer_namespace, k8s_template_file=explorer_template, dict_env=dict_env)
# Deploy explorer db svc
explorer_svc_template = '%s/explorer/explorer-service.yaml' % util.get_k8s_template_path()
settings.k8s.apply_yaml_from_template(
namespace=explorer_namespace, k8s_template_file=explorer_svc_template, dict_env=dict_env)
def setup_zookeeper():
domain = settings.KAFKA_NAMESPACE
# Create temp folder & namespace
settings.k8s.prereqs(domain)
dict_env = {'KAFKA_NAMESPACE': domain}
zk_cs_template_file = '%s/zookeeper/0zk-cs.yaml' % util.get_k8s_template_path(
)
settings.k8s.apply_yaml_from_template(
namespace=domain,
k8s_template_file=zk_cs_template_file,
dict_env=dict_env)
zk_hs_template_file = '%s/zookeeper/1zk-hs.yaml' % util.get_k8s_template_path(
)
settings.k8s.apply_yaml_from_template(
namespace=domain,
k8s_template_file=zk_hs_template_file,
dict_env=dict_env)
zk_set_template_file = '%s/zookeeper/2zk-set.yaml' % util.get_k8s_template_path(
)
settings.k8s.apply_yaml_from_template(
namespace=domain,
k8s_template_file=zk_set_template_file,
dict_env=dict_env)
def deploy_external_cc(peer, cc_name, cc_image, cc_package_id):
# Get domain
domain = util.get_domain(peer)
# Create temp folder & namespace
settings.k8s.prereqs(domain)
# Create config map
k8s_template_file = '%s/external-chaincode/chaincode-stateful.yaml' % util.get_k8s_template_path(
)
dict_env = {
'PEER_NAME': peer,
'PEER_DOMAIN': domain,
'CHAINCODE_NAME': cc_name,
'CHAINCODE_IMAGE': cc_image,
'CHAINCODE_PACKAGE_ID': cc_package_id
}
settings.k8s.apply_yaml_from_template(namespace=domain,
k8s_template_file=k8s_template_file,
dict_env=dict_env)
chaincode_service = '%s/external-chaincode/chaincode-service.yaml' % util.get_k8s_template_path(
)
settings.k8s.apply_yaml_from_template(namespace=domain,
k8s_template_file=chaincode_service,
dict_env=dict_env)
def setup_prometheus():
hiss.echo('Generate prometheus config')
config_path = generate_prom_config()
if not cp_config_efs(config_path):
return util.Result(success=False,
msg='Cannot copy prom config to efs pod')
hiss.echo('Deploy prometheus')
# Get domain
prom_namespace = get_namespace()
# Create temp folder & namespace
settings.k8s.prereqs(prom_namespace)
dict_env = {
'DOMAIN': prom_namespace,
'EFS_SERVER': settings.EFS_SERVER,
'EFS_PATH': settings.EFS_PATH,
'EFS_EXTEND': settings.EFS_EXTEND,
'PVS_PATH': settings.PVS_PATH
}
# Deploy prometheus sts
prom_template = '%s/prometheus/prometheus-stateful.yaml' % util.get_k8s_template_path(
)
settings.k8s.apply_yaml_from_template(namespace=prom_namespace,
k8s_template_file=prom_template,
dict_env=dict_env)
prom_svc_template = '%s/prometheus/prometheus-service-stateful.yaml' % util.get_k8s_template_path(
)
settings.k8s.apply_yaml_from_template(namespace=prom_namespace,
k8s_template_file=prom_svc_template,
dict_env=dict_env)
def setup_kafka():
domain = settings.KAFKA_NAMESPACE
# Create temp folder & namespace
settings.k8s.prereqs(domain)
dict_env = {'KAFKA_NAMESPACE': domain}
zk_cs_template_file = '%s/kafka/0kafka-hs.yaml' % util.get_k8s_template_path(
)
settings.k8s.apply_yaml_from_template(
namespace=domain,
k8s_template_file=zk_cs_template_file,
dict_env=dict_env)
zk_hs_template_file = '%s/kafka/1kafka-cs.yaml' % util.get_k8s_template_path(
)
settings.k8s.apply_yaml_from_template(
namespace=domain,
k8s_template_file=zk_hs_template_file,
dict_env=dict_env)
zk_set_template_file = '%s/kafka/2kafka-set.yaml' % util.get_k8s_template_path(
)
settings.k8s.apply_yaml_from_template(
namespace=domain,
k8s_template_file=zk_set_template_file,
dict_env=dict_env)
def setup_peer(peer, index):
# Get domain
domain = util.get_domain(peer)
# Create temp folder & namespace
settings.k8s.prereqs(domain)
dict_env = {
'PEER_ORG': peer,
'PEER_DOMAIN': domain,
'PEER_INDEX': index,
'EFS_SERVER': settings.EFS_SERVER,
'EFS_PATH': settings.EFS_PATH,
'EFS_EXTEND': settings.EFS_EXTEND
}
peer_stateful = '%s/peer-sts/peer-stateful.yaml' % util.get_k8s_template_path()
settings.k8s.apply_yaml_from_template(
namespace=domain, k8s_template_file=peer_stateful, dict_env=dict_env)
peer_service = '%s/peer-sts/peer-service-stateful.yaml' % util.get_k8s_template_path()
settings.k8s.apply_yaml_from_template(
namespace=domain, k8s_template_file=peer_service, dict_env=dict_env)
num_peers = int(settings.NUM_PEERS)
if (num_peers > 2):
hiss.echo('NUM_PEER > 2: Does not support deployment nlb service')
if (util.get_peer_external_domain(peer, index) != ''):
peer_service_nlb = '%s/peer-sts/peer-service-nlb.yaml' % util.get_k8s_template_path()
settings.k8s.apply_yaml_from_template(
namespace=domain, k8s_template_file=peer_service_nlb, dict_env=dict_env)
def setup_admin():
domains = settings.ORDERER_DOMAINS.split(' ')
if len(domains) == 0:
domains = settings.PEER_DOMAINS.split(' ')
# Create application artifact folder
hiss.echo('Create application artifact folder')
## Find efs pod
pods = settings.k8s.find_pod(namespace="default", keyword="test-efs")
if not pods:
return hiss.hiss('cannot find tiller pod')
mkdir_cmd = ('mkdir -p ' + settings.EFS_ROOT + '/admin/artifacts;'
'mkdir -p ' + settings.EFS_ROOT + '/admin/crypto-path;'
'mkdir -p ' + settings.EFS_ROOT + '/admin/crypto-store;')
## Exec command
exec_command = ['/bin/bash', '-c', '%s' % (mkdir_cmd)]
result_get_folder = settings.k8s.exec_pod(podName=pods[0],
namespace="default",
command=exec_command)
hiss.sub_echo(result_get_folder.data)
# Create temp folder & namespace
settings.k8s.prereqs(domains[0])
dict_env = {
'ORDERER_DOMAIN': domains[0],
'EFS_SERVER': settings.EFS_SERVER,
'EFS_PATH': settings.EFS_PATH,
'EFS_EXTEND': settings.EFS_EXTEND,
'PVS_PATH': settings.PVS_PATH
}
# Apply deployment
k8s_template_file = '%s/admin-v1/admin-deployment.yaml' % util.get_k8s_template_path(
)
settings.k8s.apply_yaml_from_template(namespace=domains[0],
k8s_template_file=k8s_template_file,
dict_env=dict_env)
# Apply service
k8s_template_file = '%s/admin-v1/admin-service.yaml' % util.get_k8s_template_path(
)
settings.k8s.apply_yaml_from_template(namespace=domains[0],
k8s_template_file=k8s_template_file,
dict_env=dict_env)
def setup_ica(ica_org):
# Get domain ica to create namespace
ica_domain = util.get_domain(ica_org)
if not ica_domain:
return hiss.hiss('Fail to get domain of %s ' % ica_org)
# Create temp folder & namespace
settings.k8s.prereqs(ica_domain)
ica_name = 'ica-%s' % ica_org
rca_host = settings.EXTERNAL_RCA_ADDRESSES
if not settings.EXTERNAL_RCA_ADDRESSES:
rca_host = '%s.%s' % (settings.RCA_NAME, settings.RCA_ORG)
k8s_template_file = '%s/ica/fabric-deployment-ica.yaml' % util.get_k8s_template_path()
dict_env = {
'ORG': ica_org,
'ICA_NAME': ica_name,
'ICA_DOMAIN': ica_domain,
'RCA_NAME': settings.RCA_NAME,
'RCA_HOST': rca_host,
'EFS_SERVER': settings.EFS_SERVER,
'EFS_PATH': settings.EFS_PATH,
'EFS_EXTEND': settings.EFS_EXTEND
}
settings.k8s.apply_yaml_from_template(
namespace=ica_domain, k8s_template_file=k8s_template_file, dict_env=dict_env)
def enroll_peer(peer, index):
# Get domain
domain = util.get_domain(peer)
# Get external domain
external_domain = util.get_peer_external_domain(peer, index)
# Create temp folder & namespace
settings.k8s.prereqs(domain)
k8s_template_file = '%s/enroll-peer/fabric-deployment-enroll-peer.yaml' % util.get_k8s_template_path(
)
dict_env = {
'PEER': peer,
'PEER_DOMAIN': domain,
'PEER_INDEX': index,
'EXTERNAL_PEER_HOST': external_domain,
'FABRIC_CA_TAG': settings.FABRIC_CA_TAG,
'EFS_SERVER': settings.EFS_SERVER,
'EFS_PATH': settings.EFS_PATH,
'EFS_EXTEND': settings.EFS_EXTEND,
'PVS_PATH': settings.PVS_PATH
}
settings.k8s.apply_yaml_from_template(namespace=domain,
k8s_template_file=k8s_template_file,
dict_env=dict_env)
def generate_prom_config():
prom_target = ''
# Get orderer target
orderers = settings.ORDERER_ORGS.split(' ')
for orderer in orderers:
domain = util.get_domain(orderer)
settings.k8s.prereqs(domain)
for peer in range(int(settings.NUM_ORDERERS)):
if len(prom_target) > 0:
prom_target += ','
prom_target += '\'orderer%s-%s.%s:10443\'' % (peer, orderer,
domain)
# Get peer target
peerorgs = settings.PEER_ORGS.split(' ')
for peerorg in peerorgs:
domain = util.get_domain(peerorg)
for peer in range(int(settings.NUM_PEERS)):
if len(prom_target) > 0:
prom_target += ','
prom_target += '\'peer%s-%s.%s:10443\'' % (peer, peerorg, domain)
dict_env = {'PROM_TARGET': prom_target}
# Load config
config_template = '%s/prometheus/prometheus-template.yml' % util.get_k8s_template_path(
)
yaml_path, config = util.load_yaml_config_template(
yaml_template_path=config_template, dict_env=dict_env)
print('config: ', config)
return yaml_path
def setup_peer(peer, index):
# Get domain
domain = util.get_domain(peer)
# Create temp folder & namespace
settings.k8s.prereqs(domain)
if settings.K8S_TYPE == 'minikube':
storage_class = 'standard'
else:
storage_class = 'gp2'
dict_env = {
'PEER_ORG': peer,
'PEER_DOMAIN': domain,
'PEER_INDEX': index,
'FABRIC_TAG': settings.FABRIC_TAG,
'COUCHDB_TAG': settings.COUCHDB_TAG,
'EFS_SERVER': settings.EFS_SERVER,
'EFS_PATH': settings.EFS_PATH,
'EFS_EXTEND': settings.EFS_EXTEND,
'PVS_PATH': settings.PVS_PATH,
'STORAGE_CLASS': storage_class
}
peer_stateful = '%s/peer-sts/peer-stateful.yaml' % util.get_k8s_template_path(
)
settings.k8s.apply_yaml_from_template(namespace=domain,
k8s_template_file=peer_stateful,
dict_env=dict_env)
peer_service = '%s/peer-sts/peer-service-stateful.yaml' % util.get_k8s_template_path(
)
settings.k8s.apply_yaml_from_template(namespace=domain,
k8s_template_file=peer_service,
dict_env=dict_env)
num_peers = int(settings.NUM_PEERS)
if (num_peers > 2):
hiss.echo('NUM_PEER > 2: Does not support deployment nlb service')
if (util.get_peer_external_domain(peer, index) != ''):
peer_service_nlb = '%s/peer-sts/peer-service-nlb.yaml' % util.get_k8s_template_path(
)
settings.k8s.apply_yaml_from_template(
namespace=domain,
k8s_template_file=peer_service_nlb,
dict_env=dict_env)
def setup_orderer(orderer, index):
# Get domain
domain = util.get_domain(orderer)
# Create temp folder & namespace
settings.k8s.prereqs(domain)
if settings.K8S_TYPE == 'minikube':
store_class = 'standard'
else:
store_class = 'gp2'
dict_env = {
'ORDERER': orderer,
'ORDERER_DOMAIN': domain,
'ORDERER_INDEX': index,
'FABRIC_TAG': settings.FABRIC_TAG,
'EFS_SERVER': settings.EFS_SERVER,
'EFS_PATH': settings.EFS_PATH,
'EFS_EXTEND': settings.EFS_EXTEND,
'PVS_PATH': settings.PVS_PATH,
'STORE_CLASS': store_class
}
orderer_stateful = '%s/orderer-sts/orderer-stateful.yaml' % util.get_k8s_template_path(
)
settings.k8s.apply_yaml_from_template(namespace=domain,
k8s_template_file=orderer_stateful,
dict_env=dict_env)
orderer_service = '%s/orderer-sts/orderer-service.yaml' % util.get_k8s_template_path(
)
settings.k8s.apply_yaml_from_template(namespace=domain,
k8s_template_file=orderer_service,
dict_env=dict_env)
if settings.EXTERNAL_ORDERER_ADDRESSES != '':
# Setup nlb
orderer_service_nlb = '%s/orderer-sts/orderer-service-nlb.yaml' % util.get_k8s_template_path(
)
settings.k8s.apply_yaml_from_template(
namespace=domain,
k8s_template_file=orderer_service_nlb,
dict_env=dict_env)
def setup_explorer_db():
# Get domain
explorer_db_namespace = get_namespace()
# Create temp folder & namespace
settings.k8s.prereqs(explorer_db_namespace)
dict_env = {
'DOMAIN': explorer_db_namespace,
'DATABASE_PASSWORD': '******'
}
# Deploy explorer db sts
explorer_db_template = '%s/explorer/explorer-db-deployment.yaml' % util.get_k8s_template_path(
)
settings.k8s.apply_yaml_from_template(
namespace=explorer_db_namespace,
k8s_template_file=explorer_db_template,
dict_env=dict_env)
# Deploy explorer db svc
explorer_db_svc_template = '%s/explorer/explorer-db-service.yaml' % util.get_k8s_template_path(
)
settings.k8s.apply_yaml_from_template(
namespace=explorer_db_namespace,
k8s_template_file=explorer_db_svc_template,
dict_env=dict_env)
# Create tables
## Find explorer_db pod
pods = settings.k8s.find_pod(namespace=explorer_db_namespace,
keyword="explorer-db")
if not pods:
return hiss.hiss('cannot find tiller pod')
create_tbl_cmd = 'chmod 700 /opt/createdb_new.sh; /opt/createdb_new.sh'
exec_command = ['/bin/bash', '-c', '%s' % (create_tbl_cmd)]
result_get_folder = settings.k8s.exec_pod(podName=pods[0],
namespace=explorer_db_namespace,
command=exec_command)
hiss.sub_echo(result_get_folder.data)
def setup_grafana():
hiss.echo('Deploy grafana')
namespace = get_namespace()
# Create temp folder & namespace
settings.k8s.prereqs(namespace)
dict_env = {
'DOMAIN': namespace
}
# Deploy grafana sts
grafana_template = '%s/grafana/grafana-stateful.yaml' % util.get_k8s_template_path()
settings.k8s.apply_yaml_from_template(
namespace=namespace, k8s_template_file=grafana_template, dict_env=dict_env)
# Deploy grafana svc
grafana_sv_template = '%s/grafana/grafana-service-stateful.yaml' % util.get_k8s_template_path()
settings.k8s.apply_yaml_from_template(
namespace=namespace, k8s_template_file=grafana_sv_template, dict_env=dict_env)
def modify_config(domain=None):
if not domain:
[_, domain] = get_working_orgs_domain()
dict_env = {
'ORG_DOMAIN': domain,
'NEW_ORG_NAME': settings.NEW_ORG_NAME,
'EFS_SERVER': settings.EFS_SERVER,
'EFS_PATH': settings.EFS_PATH,
'EFS_EXTEND': settings.EFS_EXTEND
}
k8s_template_file = '%s/add-org/3modifyingorgmaterial.yaml' % util.get_k8s_template_path()
settings.k8s.apply_yaml_from_template(
namespace=domain, k8s_template_file=k8s_template_file, dict_env=dict_env)
def config_peer(peer):
# Get domain
domain = util.get_domain(peer)
# Create temp folder & namespace
settings.k8s.prereqs(domain)
# Create config map
k8s_template_file = '%s/external-chaincode/builders-config.yaml' % util.get_k8s_template_path(
)
dict_env = {'PEER_DOMAIN': domain}
settings.k8s.apply_yaml_from_template(namespace=domain,
k8s_template_file=k8s_template_file,
dict_env=dict_env)
def create_config_update_pb(domain=None):
if not domain:
[_, domain] = get_working_orgs_domain()
dict_env = {
'ORG_DOMAIN': domain,
'CHANNEL_NAME': settings.CHANNEL_NAME,
'EFS_SERVER': settings.EFS_SERVER,
'EFS_PATH': settings.EFS_PATH,
'EFS_EXTEND': settings.EFS_EXTEND
}
k8s_template_file = '%s/add-org/4createconfigupdate.yaml' % util.get_k8s_template_path()
settings.k8s.apply_yaml_from_template(
namespace=domain, k8s_template_file=k8s_template_file, dict_env=dict_env)
def reg_org(org):
# Get domain
domain = util.get_domain(org)
# Create temp folder & namespace
settings.k8s.prereqs(domain)
k8s_template_file = '%s/register-org/fabric-deployment-register-org.yaml' % util.get_k8s_template_path()
dict_env = {
'ORG': org,
'REG_DOMAIN': domain,
'EFS_SERVER': settings.EFS_SERVER,
'EFS_PATH': settings.EFS_PATH,
'EFS_EXTEND': settings.EFS_EXTEND
}
settings.k8s.apply_yaml_from_template(
namespace=domain, k8s_template_file=k8s_template_file, dict_env=dict_env)
def update_channel_config(org=None, domain=None):
if not org or not domain:
[org, domain] = get_working_orgs_domain()
dict_env = {
'ORG_DOMAIN': domain,
'ORG_NAME': org,
'CHANNEL_NAME': settings.CHANNEL_NAME,
'ORDERER_NAME': settings.ORDERER_ORGS,
'ORDERER_DOMAIN': settings.ORDERER_DOMAINS,
'EFS_SERVER': settings.EFS_SERVER,
'EFS_PATH': settings.EFS_PATH,
'EFS_EXTEND': settings.EFS_EXTEND
}
k8s_template_file = '%s/add-org/6updatechannelconfig.yaml' % util.get_k8s_template_path()
settings.k8s.apply_yaml_from_template(
namespace=domain, k8s_template_file=k8s_template_file, dict_env=dict_env)
def generate_artifact():
domains = settings.ORDERER_DOMAINS.split(' ')
# Create temp folder & namespace
settings.k8s.prereqs(domains[0])
k8s_template_file = '%s/gen-artifacts/fabric-deployment-gen-artifacts.yaml' % util.get_k8s_template_path(
)
dict_env = {
'ORDERER_DOMAIN': domains[0],
'EFS_SERVER': settings.EFS_SERVER,
'EFS_PATH': settings.EFS_PATH,
'EFS_EXTEND': settings.EFS_EXTEND
}
settings.k8s.apply_yaml_from_template(namespace=domains[0],
k8s_template_file=k8s_template_file,
dict_env=dict_env)
def generate_ccp(org):
# Get domain
domain = util.get_domain(org)
# Create temp folder & namespace
settings.k8s.prereqs(domain)
k8s_template_file = '%s/connection-profile/generate-ccp-job.yaml' % util.get_k8s_template_path()
dict_env = {
'ORG_NAME': org,
'ORG_DOMAIN': domain,
'EFS_SERVER': settings.EFS_SERVER,
'EFS_PATH': settings.EFS_PATH,
'EFS_EXTEND': settings.EFS_EXTEND,
'PVS_PATH': settings.PVS_PATH
}
settings.k8s.apply_yaml_from_template(
namespace=domain, k8s_template_file=k8s_template_file, dict_env=dict_env)
def enroll_orderer(orderer):
# Get domain
domain = util.get_domain(orderer)
# Create temp folder & namespace
settings.k8s.prereqs(domain)
k8s_template_file = '%s/enroll-orderer/fabric-deployment-enroll-orderer.yaml' % util.get_k8s_template_path(
)
dict_env = {
'ORDERER': orderer,
'ENROLL_DOMAIN': domain,
'EFS_SERVER': settings.EFS_SERVER,
'EFS_PATH': settings.EFS_PATH,
'EFS_EXTEND': settings.EFS_EXTEND
}
settings.k8s.apply_yaml_from_template(namespace=domain,
k8s_template_file=k8s_template_file,
dict_env=dict_env)
def create(self):
# Load template file
k8s_template_file = '%s/namespace/namespaces.yaml' % util.get_k8s_template_path(
)
with open(k8s_template_file, 'r') as sources:
lines = sources.readlines()
out_data = []
# Replace variable
for line in lines:
out_line = re.sub(r'{{NAMESPACES}}', self.name, line)
out_data.append(out_line)
# Get current datetime (UTC)
current_time = datetime.datetime.utcnow().replace(
microsecond=0).isoformat().split('T')
# Make folder temp if it not exists
tmp_path = "%s/%s" % (util.get_temp_path(), current_time[0])
util.make_folder(tmp_path)
# Create yaml_path
yaml_path = '%s/%s/%s_namespaces.yaml' % (
util.get_temp_path(), current_time[0], current_time[1])
# Write yaml -> yaml_path
with open(yaml_path, "w") as sources:
for line in out_data:
sources.write(line)
# Execute yaml
with open(yaml_path) as f:
dep = yaml.safe_load(f)
try:
settings.k8s.coreApi.create_namespace(body=dep)
hiss.sub_echo('Create namespace successfully')
return True
except ApiException as e:
return hiss.hiss(
"Exception when calling CoreV1Api->create_namespace: %s\n"
% e)
def setup_admin(org):
# Get domain
domain = util.get_domain(org)
# Get orderer information
orderer_names = settings.ORDERER_ORGS.split(' ')
orderer_domains = settings.ORDERER_DOMAINS.split(' ')
if orderer_names == '' and settings.REMOTE_ORDERER_NAME != '':
orderer_names = settings.REMOTE_ORDERER_NAME.split(' ')
orderer_domains = settings.REMOTE_ORDERER_DOMAIN.split(' ')
# Build endorsement config
peer_orgs = '%s %s' % (settings.PEER_ORGS, settings.ENDORSEMENT_ORG_NAME)
peer_domains = '%s %s' % (settings.PEER_DOMAINS,
settings.ENDORSEMENT_ORG_DOMAIN)
print(peer_orgs)
# Create application artifact folder
hiss.echo('Create wallet folder')
## Find efs pod
pods = settings.k8s.find_pod(namespace="default", keyword="test-efs")
if not pods:
return hiss.hiss('cannot find tiller pod')
mkdir_cmd = ('mkdir -p ' + settings.EFS_ROOT + '/admin-v2/wallet;')
# Exec command
exec_command = ['/bin/bash', '-c', '%s' % (mkdir_cmd)]
result_get_folder = settings.k8s.exec_pod(podName=pods[0],
namespace="default",
command=exec_command)
hiss.sub_echo(result_get_folder.data)
# Create temp folder & namespace
settings.k8s.prereqs(domain)
dict_env = {
'ORG_NAME': org,
'ORG_DOMAIN': domain,
'PEER_NAMES': peer_orgs,
'PEER_DOMAINS': peer_domains,
'ORDERER_DOMAIN': orderer_domains[0],
'ORGDERER_NAME': orderer_names[0],
'EFS_SERVER': settings.EFS_SERVER,
'EFS_PATH': settings.EFS_PATH,
'EFS_EXTEND': settings.EFS_EXTEND,
'PVS_PATH': settings.PVS_PATH
}
# Apply deployment
k8s_template_file = '%s/admin/admin-deployment.yaml' % util.get_k8s_template_path(
)
settings.k8s.apply_yaml_from_template(namespace=domain,
k8s_template_file=k8s_template_file,
dict_env=dict_env)
# Apply service
k8s_template_file = '%s/admin/admin-service.yaml' % util.get_k8s_template_path(
)
settings.k8s.apply_yaml_from_template(namespace=domain,
k8s_template_file=k8s_template_file,
dict_env=dict_env)
def reg_orderer(orderer):
# Get domain
domain = util.get_domain(orderer)
# Create temp folder & namespace
settings.k8s.prereqs(domain)
k8s_template_file = '%s/register-orderer/fabric-deployment-register-orderer.yaml' % util.get_k8s_template_path(
)
dict_env = {
'ORDERER_ORG': orderer,
'ORDERER_DOMAIN': domain,
'FABRIC_CA_TAG': settings.FABRIC_CA_TAG,
'EFS_SERVER': settings.EFS_SERVER,
'EFS_PATH': settings.EFS_PATH,
'EFS_EXTEND': settings.EFS_EXTEND,
'PVS_PATH': settings.PVS_PATH
}
settings.k8s.apply_yaml_from_template(namespace=domain,
k8s_template_file=k8s_template_file,
dict_env=dict_env)
def create_new_org():
hiss.rattle('Create New Org')
# Copy scripts to EFS
copy_scripts()
# Phai co rca external address
# Create new Intermediate Certificate Authority services
setup_all_ica()
# Run jobs to register organizations
reg_all_org()
# Run jobs to register peers
reg_all_peer()
time.sleep(1)
# Run jobs to enroll peers
enroll_all_peer()
time.sleep(5)
# Create crypto-config folder to contains artifacts
update_folder()
# # Default value of ORDERER_DOMAINS = default, it needed to run processes below
# if (settings.ORDERER_DOMAINS == ''):
# settings.ORDERER_DOMAINS='default'
hiss.rattle('Config map for external chaincode')
config_all_peer()
# Create new StatefullSet peers
setup_all_peer()
# Run jobs to generate application artifacts
generate_artifact()
generate_all_ccp()
# Create secret if use private docker hub
if settings.PRIVATE_DOCKER_IMAGE == 'true':
create_docker_secret('default', 'mamba')
# # # Return value ORDERER_DOMAINS
# if (settings.ORDERER_DOMAINS == 'default'):
# settings.ORDERER_DOMAINS=''
# Create new a new Admin service
time.sleep(1)
setup_all_admin()
dict_env = {
'ORG_NAME': settings.PEER_ORGS,
'ORG_DOMAIN': settings.PEER_DOMAINS,
'FABRIC_TAG': settings.FABRIC_TAG,
'EFS_SERVER': settings.EFS_SERVER,
'EFS_PATH': settings.EFS_PATH,
'EFS_EXTEND': settings.EFS_EXTEND,
'PVS_PATH': settings.PVS_PATH
}
# Create configtx
create_config_template = '%s/add-org/0create-configtx.yaml' % util.get_k8s_template_path(
)
settings.k8s.apply_yaml_from_template(
namespace=settings.PEER_DOMAINS,
k8s_template_file=create_config_template,
dict_env=dict_env)
# Gen org.json
gen_artifact_template = '%s/add-org/1gen-artifacts.yaml' % util.get_k8s_template_path(
)
settings.k8s.apply_yaml_from_template(
namespace=settings.PEER_DOMAINS,
k8s_template_file=gen_artifact_template,
dict_env=dict_env)
return True
def bootstrap_network():
domains = settings.ORDERER_DOMAINS.split(' ')
# Create temp folder & namespace
settings.k8s.prereqs(domains[0])
k8s_template_file = '%s/bootstrap-network/fabric-deployment-bootstrap-network.yaml' % util.get_k8s_template_path(
)
dict_env = {
'ORDERER_DOMAIN': domains[0],
'EFS_SERVER': settings.EFS_SERVER,
'EFS_PATH': settings.EFS_PATH,
'EFS_EXTEND': settings.EFS_EXTEND
}
settings.k8s.apply_yaml_from_template(namespace=domains[0],
k8s_template_file=k8s_template_file,
dict_env=dict_env)
