def db_update_one(self, filter, operations, after=True, col="active"):
"""
Update the data into the active db
:param filter: Which instance to update, e.g., {"id": "xxx"}
:param operations: data to update to db, e.g., {"$set": {}}
:param after: return AFTER or BEFORE
:param col: collection to operate on
:return: The updated host json dict
"""
state = CLUSTER_STATE.active.name if col == "active" \
else CLUSTER_STATE.released.name
filter.update({"state": state})
logger.info("filter {} operations {}".format(filter, operations))
kwargs = dict(('set__' + k, v) for (k, v) in operations.items())
for k, v in kwargs.items():
logger.info("k={}, v={}".format(k, v))
try:
ClusterModel.objects(id=filter.get("id")).update(upsert=True,
**kwargs)
doc = ClusterModel.objects.get(id=filter.get("id"))
except Exception as exc:
logger.info("exception {}".format(exc.message))
return None
return doc
def db_update_one(self, filter, operations, after=True, col="active"):
"""
Update the data into the active db
:param filter: Which instance to update, e.g., {"id": "xxx"}
:param operations: data to update to db, e.g., {"$set": {}}
:param after: return AFTER or BEFORE
:param col: collection to operate on
:return: The updated host json dict
"""
state = CLUSTER_STATE.active.name if col == "active" \
else CLUSTER_STATE.released.name
filter.update({
"state": state
})
logger.info("filter {} operations {}".format(filter, operations))
kwargs = dict(('set__' + k, v) for (k, v) in operations.items())
for k, v in kwargs.items():
logger.info("k {} v {}".format(k, v))
try:
ClusterModel.objects(id=filter.get("id")).update(
upsert=True,
**kwargs
)
doc = ClusterModel.objects.get(id=filter.get("id"))
except Exception as exc:
logger.info("exception {}".format(exc.message))
return None
return doc
def apply_cluster(self, user_id, condition={}, allow_multiple=False):
""" Apply a cluster for a user
:param user_id: which user will apply the cluster
:param condition: the filter to select
:param allow_multiple: Allow multiple chain for each tenant
:return: serialized cluster or None
"""
if not allow_multiple: # check if already having one
filt = {"user_id": user_id, "release_ts": "", "health": "OK"}
filt.update(condition)
c = self.col_active.find_one(filt)
if c:
logger.debug("Already assigned cluster for " + user_id)
return self._schema(c)
logger.debug("Try find available cluster for " + user_id)
clusters = ClusterModel. \
Query.filter(user_id="",
network_type__regex="(?i)%s" %
condition.get("apply_type",
"fabric"),
size=condition.get("size", 0),
status=NETWORK_STATUS_RUNNING,
health="OK").limit(1)
cluster = clusters[0] if len(clusters) > 0 else None
if cluster:
update_cluster = ClusterModel(objectId=cluster.objectId,
user_id=user_id,
apply_ts=datetime.datetime.now())
update_cluster.save()
logger.info("Now have cluster {} at {} for user {}".format(
cluster.id, cluster.host.id, user_id))
return self._schema(cluster)
logger.warning("Not find matched available cluster for " + user_id)
return {}
def db_update_one(self, filter, operations, after=True, col="active"):
"""
Update the data into the active db
:param filter: Which instance to update, e.g., {"id": "xxx"}
:param operations: data to update to db, e.g., {"$set": {}}
:param after: return AFTER or BEFORE
:param col: collection to operate on
:return: The updated host json dict
"""
state = CLUSTER_STATE.active.name if col == "active" \
else CLUSTER_STATE.released.name
filter.update({"state": state})
logger.debug("filter {} operations {}".format(filter, operations))
try:
cluster_found = ClusterModel.Query.get(id=filter.get("id"))
cluster = ClusterModel(objectId=cluster_found.objectId,
**operations)
cluster.save()
if after:
cluster_found = ClusterModel.Query.get(id=filter.get("id"))
except Exception as exc:
logger.info("exception {}".format(exc.message))
return None
return cluster_found
def db_update_one(self, filter, operations, after=True, col="active"):
"""
Update the data into the active db
:param filter: Which instance to update, e.g., {"id": "xxx"}
:param operations: data to update to db, e.g., {"$set": {}}
:param after: return AFTER or BEFORE
:param col: collection to operate on
:return: The updated host json dict
"""
state = CLUSTER_STATE.active.name if col == "active" \
else CLUSTER_STATE.released.name
filter.update({
"state": state
})
logger.debug("filter {} operations {}".format(filter, operations))
try:
cluster_found = ClusterModel.Query.get(id=filter.get("id"))
cluster = ClusterModel(objectId=cluster_found.objectId,
**operations)
cluster.save()
if after:
cluster_found = ClusterModel.Query.get(id=filter.get("id"))
except Exception as exc:
logger.info("exception {}".format(exc.message))
return None
return cluster_found
def apply_cluster(self, user_id, condition={}, allow_multiple=False):
""" Apply a cluster for a user
:param user_id: which user will apply the cluster
:param condition: the filter to select
:param allow_multiple: Allow multiple chain for each tenant
:return: serialized cluster or None
"""
if not allow_multiple: # check if already having one
filt = {"user_id": user_id, "release_ts": "", "health": "OK"}
filt.update(condition)
c = self.col_active.find_one(filt)
if c:
logger.debug("Already assigned cluster for " + user_id)
return self._schema(c)
logger.debug("Try find available cluster for " + user_id)
clusters = ClusterModel. \
Query.filter(user_id="",
network_type__regex="(?i)%s" %
condition.get("apply_type",
"fabric"),
size=condition.get("size", 0),
status=NETWORK_STATUS_RUNNING,
health="OK").limit(1)
cluster = clusters[0] if len(clusters) > 0 else None
if cluster:
update_cluster = ClusterModel(objectId=cluster.objectId,
user_id=user_id,
apply_ts=datetime.datetime.now())
update_cluster.save()
logger.info("Now have cluster {} at {} for user {}".format(
cluster.id, cluster.host.id, user_id))
return self._schema(cluster)
logger.warning("Not find matched available cluster for " + user_id)
return {}
def list(self, user, page_no=1, page_size=10):
""" List clusters with given criteria
:param page_no: Image with the filter properties
:param page_size: Use data in which col_name
:return: list of serialized doc
"""
# result = []
# if col_name in [e.name for e in CLUSTER_STATE]:
# logger.debug("List all {} clusters".format(col_name))
# filter_data.update({
# "state": col_name
# })
# clusters = ClusterModel.objects(__raw__=filter_data)
# result = self._schema(clusters, many=True)
# else:
# logger.warning("Unknown cluster col_name=" + col_name)
offset = (page_no - 1) * page_size
if user.isAdmin:
clusters = ClusterModel.objects.skip(offset).limit(page_size).order_by('-create_ts')
cluster_count = ClusterModel.objects.all().count()
else:
clusters = ClusterModel.objects(user=user).skip(offset).limit(page_size).order_by('-create_ts')
cluster_count = ClusterModel.objects(user=user).count()
cluster_list = []
sequence_num = (page_no * page_size) - (page_size - 1)
for cluster in clusters:
channels = ChannelModel.objects.get(cluster=cluster)
cluster_info = {
'id': sequence_num,
"cluster_id": str(cluster.id),
'name': cluster.name,
'config': 'fabric-1.1基础配置',
'channel': channels.name,
'channel_id': str(channels.alias),
'username': cluster.user.username,
"consensus_plugin": cluster.consensus_plugin,
"host": str(cluster.host.name),
'domain': cluster.domain,
'create_ts': cluster.create_ts.strftime("%Y-%m-%d %H:%M:%S"),
'due_time': cluster.due_time.strftime("%Y-%m-%d %H:%M:%S"),
"status": cluster.status
}
cluster_list.append(cluster_info)
sequence_num += 1
result = {
'pageNo': page_no,
'pageSize': page_size,
'totalCount': cluster_count,
'clusters': cluster_list
}
return result
def delete(self):
request_debug(r, logger)
args = host_delete_parser.parse_args()
host_id = args.get('host_id')
# if "id" in r.form:
# host_id = r.form["id"]
# elif "id" in request_data:
# host_id = request_data.get("id")
# else:
# error_msg = "host delete without enough data"
# logger.warning(error_msg)
# return make_fail_resp(error=error_msg, data=r.form)
if not host_id:
error_msg = "缺少参数"
logger.warning(error_msg)
return make_fail_resp(error=error_msg)
logger.debug("host delete with id={0}".format(host_id))
try:
host = HostModel.objects.get(id=host_id)
except Exception:
logger.warning("Cannot delete non-existed host")
return make_fail_resp(error='无法删除不存在的主机')
if ClusterModel.objects(host=host).count() > 0:
return {'stat': 1000, 'msg': '主机存在已创建的区块链，无法删除'}
if host_handler.delete(host):
return make_ok_resp()
else:
error_msg = "Failed to delete host {}".format(host_id)
logger.warning(error_msg)
return make_fail_resp(error=error_msg)
def update(self, id, d):
""" Update a host's property
TODO: may check when changing host type
:param id: id of the host
:param d: dict to use as updated values
:return: serialized result or obj
"""
logger.debug("Get a host with id=" + id)
h_old = self.get_by_id(id)
if not h_old:
logger.warning("No host found with id=" + id)
return {}
if h_old.get("status") == "pending":
return {}
if "worker_api" in d and not d["worker_api"].startswith("tcp://"):
d["worker_api"] = "tcp://" + d["worker_api"]
if "capacity" in d:
d["capacity"] = int(d["capacity"])
if d["capacity"] < ClusterModel.objects(host=h_old).count():
logger.warning("Cannot set cap smaller than running clusters")
return {}
if "log_server" in d and "://" not in d["log_server"]:
d["log_server"] = "udp://" + d["log_server"]
if "log_type" in d and d["log_type"] == CLUSTER_LOG_TYPES[0]:
d["log_server"] = ""
self.db_set_by_id(id, **d)
h_new = self.get_by_id(id)
return self._schema(h_new)
def update(self, id, d):
""" Update a host's property
TODO: may check when changing host type
:param id: id of the host
:param d: dict to use as updated values
:return: serialized result or obj
"""
logger.debug("Get a host with id=" + id)
h_old = self.get_by_id(id)
if not h_old:
logger.warning("No host found with id=" + id)
return {}
if h_old.get("status") == "pending":
return {}
if "worker_api" in d and not d["worker_api"].startswith("tcp://"):
d["worker_api"] = "tcp://" + d["worker_api"]
if "capacity" in d:
d["capacity"] = int(d["capacity"])
if d["capacity"] < ClusterModel.objects(host=h_old).count():
logger.warning("Cannot set cap smaller than running clusters")
return {}
if "log_server" in d and "://" not in d["log_server"]:
d["log_server"] = "udp://" + d["log_server"]
if "log_type" in d and d["log_type"] == CLUSTER_LOG_TYPES[0]:
d["log_server"] = ""
self.db_set_by_id(id, **d)
h_new = self.get_by_id(id)
return self._schema(h_new)
def find_free_port(host, number):
logger.debug("Find {} start ports for host {}".format(number, host.id))
if number <= 0:
logger.warning("number {} <= 0".format(number))
return []
if not host:
logger.warning("Cannot find host")
return ""
ports_used = []
clusters_exists = ClusterModel.objects(host=host)
for cluster in clusters_exists:
ports_used.extend(cluster.ports)
logger.debug("The ports existed: {}".format(ports_used))
if len(ports_used) + number >= 1000:
logger.warning("Too much ports are already in used.")
return []
candidates = [
CLUSTER_PORT_START + i * CLUSTER_PORT_STEP
for i in range(len(ports_used) + number)
]
result = list(filter(lambda x: x not in ports_used, candidates))
logger.debug("Free ports are {}".format(result[:number]))
return result[:number]
def clean(self, id):
"""
Clean a host's free clusters.
:param id: host id
:return: True or False
"""
logger.debug("clean host with id = {}".format(id))
host = self.get_by_id(id)
if not host:
return False
clusters = ClusterModel.objects(host=host)
if host.status != "active":
return False
if len(clusters) <= 0:
return True
host = self.db_set_by_id(id, **{"autofill": False})
schedulable_status = host.schedulable
if schedulable_status:
host = self.db_set_by_id(id, **{"schedulable": False})
for cluster_item in clusters:
cid = str(cluster_item.id)
t = Thread(target=cluster.cluster_handler.delete, args=(cid,))
t.start()
time.sleep(0.2)
if schedulable_status:
self.db_set_by_id(id, **{"schedulable": schedulable_status})
return True
def clean(self, id):
"""
Clean a host's free clusters.
:param id: host id
:return: True or False
"""
logger.debug("clean host with id = {}".format(id))
host = self.get_by_id(id)
if not host:
return False
clusters = ClusterModel.objects(host=host)
if host.status != "active":
return False
if len(clusters) <= 0:
return True
host = self.db_set_by_id(id, **{"autofill": False})
schedulable_status = host.schedulable
if schedulable_status:
host = self.db_set_by_id(id, **{"schedulable": False})
for cluster_item in clusters:
cid = str(cluster_item.id)
t = Thread(target=cluster.cluster_handler.delete, args=(cid,))
t.start()
time.sleep(0.2)
if schedulable_status:
self.db_set_by_id(id, **{"schedulable": schedulable_status})
return True
def reset(self, id):
"""
Clean a host's free clusters.
:param id: host id
:return: True or False
"""
logger.debug("clean host with id = {}".format(id))
host = self.get_by_id(id)
if not host or ClusterModel.objects(host=host).count() < 0:
logger.warning("No find resettable host with id ={}".format(id))
return False
host_type = host.type
return self.host_agents[host_type].reset(host_type, host.worker_api)
def reset(self, id):
"""
Clean a host's free clusters.
:param id: host id
:return: True or False
"""
logger.debug("clean host with id = {}".format(id))
host = self.get_by_id(id)
if not host or ClusterModel.objects(host=host).count() < 0:
logger.warning("No find resettable host with id ={}".format(id))
return False
host_type = host.type
return self.host_agents[host_type].reset(host_type, host.worker_api)
def host_actions():
logger.info("/host_op, method=" + r.method)
request_debug(r, logger)
if r.content_type.startswith("application/json"):
body = dict(r.get_json(force=True, silent=True))
else:
body = r.form
host_id, action = body['id'], body['action']
if not host_id or not action:
error_msg = "host POST without enough data"
logger.warning(error_msg)
return make_fail_resp(error=error_msg, data=body)
else:
if action == "fillup":
if host_handler.fillup(host_id):
logger.debug("fillup successfully")
return make_ok_resp()
else:
error_msg = "Failed to fillup the host."
logger.warning(error_msg)
return make_fail_resp(error=error_msg, data=body)
elif action == "clean":
if host_handler.clean(host_id):
logger.debug("clean successfully")
return make_ok_resp()
else:
error_msg = "Failed to clean the host."
logger.warning(error_msg)
return make_fail_resp(error=error_msg, data=body)
elif action == "reset":
if host_handler.reset(host_id):
logger.debug("reset successfully")
try:
host_model = HostModel.objects.get(id=host_id)
clusters = ClusterModel.objects(host=host_model)
for cluster_item in clusters:
cluster_item.delete()
except Exception:
pass
return make_ok_resp()
else:
error_msg = "Failed to reset the host."
logger.warning(error_msg)
return make_fail_resp(error=error_msg, data=body)
error_msg = "unknown host action={}".format(action)
logger.warning(error_msg)
return make_fail_resp(error=error_msg, data=body)
def list(self, filter_data={}, col_name="active"):
""" List clusters with given criteria
:param filter_data: Image with the filter properties
:param col_name: Use data in which col_name
:return: list of serialized doc
"""
result = []
if col_name in [e.name for e in CLUSTER_STATE]:
logger.debug("List all {} clusters".format(col_name))
filter_data.update({"state": col_name})
clusters = ClusterModel.objects(__raw__=filter_data)
result = self._schema(clusters, many=True)
else:
logger.warning("Unknown cluster col_name=" + col_name)
return result
def fillup(self, id):
"""
Fullfil a host with clusters to its capacity limit
:param id: host id
:return: True or False
"""
logger.debug("Try fillup host {}".format(id))
host = self.get_by_id(id)
if not host:
return False
if host.status != "active":
logger.warning("host {} is not active".format(id))
return False
clusters = ClusterModel.objects(host=host)
num_new = host.capacity - len(clusters)
if num_new <= 0:
logger.warning("host {} already full".format(id))
return True
free_ports = cluster.cluster_handler.find_free_start_ports(id, num_new)
logger.debug("Free_ports = {}".format(free_ports))
def create_cluster_work(start_port):
cluster_name = "{}_{}".format(
host.name,
int((start_port - CLUSTER_PORT_START) / CLUSTER_PORT_STEP))
cluster_size = random.choice(NETWORK_SIZE_FABRIC_V1)
config = FabricV1NetworkConfig(
consensus_plugin=CONSENSUS_PLUGIN_SOLO, size=cluster_size)
config.network_type = NETWORK_TYPE_FABRIC_V1
cid = cluster.cluster_handler.create(name=cluster_name,
host_id=id,
config=config,
start_port=start_port)
if cid:
logger.debug("Create cluster {} with id={}".format(
cluster_name, cid))
else:
logger.warning("Create cluster failed")
for p in free_ports:
t = Thread(target=create_cluster_work, args=(p, ))
t.start()
time.sleep(0.2)
return True
def fillup(self, id):
"""
Fullfil a host with clusters to its capacity limit
:param id: host id
:return: True or False
"""
logger.debug("Try fillup host {}".format(id))
host = self.get_by_id(id)
if not host:
return False
if host.status != "active":
logger.warning("host {} is not active".format(id))
return False
clusters = ClusterModel.objects(host=host)
num_new = host.capacity - len(clusters)
if num_new <= 0:
logger.warning("host {} already full".format(id))
return True
free_ports = cluster.cluster_handler.find_free_start_ports(id, num_new)
logger.debug("Free_ports = {}".format(free_ports))
def create_cluster_work(start_port):
cluster_name = "{}_{}".format(
host.name,
int((start_port - CLUSTER_PORT_START) / CLUSTER_PORT_STEP))
consensus_plugin = CONSENSUS_PLUGIN_SOLO
cluster_size = random.choice(NETWORK_SIZE_FABRIC_V1)
config = FabricV1NetworkConfig(
consensus_plugin=consensus_plugin,
size=cluster_size)
cid = cluster.cluster_handler.create(name=cluster_name,
host_id=id, config=config,
start_port=start_port)
if cid:
logger.debug("Create cluster {} with id={}".format(
cluster_name, cid))
else:
logger.warning("Create cluster failed")
for p in free_ports:
t = Thread(target=create_cluster_work, args=(p,))
t.start()
time.sleep(0.2)
return True
def host_actions():
logger.info("/host_op, method=" + r.method)
request_debug(r, logger)
host_id, action = r.form['id'], r.form['action']
if not host_id or not action:
error_msg = "host POST without enough data"
logger.warning(error_msg)
return make_fail_resp(error=error_msg,
data=r.form)
else:
if action == "fillup":
if host_handler.fillup(host_id):
logger.debug("fillup successfully")
return make_ok_resp()
else:
error_msg = "Failed to fillup the host."
logger.warning(error_msg)
return make_fail_resp(error=error_msg, data=r.form)
elif action == "clean":
if host_handler.clean(host_id):
logger.debug("clean successfully")
return make_ok_resp()
else:
error_msg = "Failed to clean the host."
logger.warning(error_msg)
return make_fail_resp(error=error_msg, data=r.form)
elif action == "reset":
if host_handler.reset(host_id):
logger.debug("reset successfully")
try:
host_model = HostModel.objects.get(id=host_id)
clusters = ClusterModel.objects(host=host_model)
for cluster_item in clusters:
cluster_item.delete()
except Exception:
pass
return make_ok_resp()
else:
error_msg = "Failed to reset the host."
logger.warning(error_msg)
return make_fail_resp(error=error_msg, data=r.form)
error_msg = "unknown host action={}".format(action)
logger.warning(error_msg)
return make_fail_resp(error=error_msg, data=r.form)
def _get_cluster_info(self, cid, config):
cluster = ClusterModel.objects.get(id=cid)
cluster_name = cluster.name
kube_config = KubernetesOperation()._get_config_from_params(
cluster.host.k8s_param)
clusters_exists = ClusterModel.objects(host=cluster.host)
ports_index = [
service.port
for service in ServicePort.objects(cluster__in=clusters_exists)
]
nfsServer_ip = cluster.host.k8s_param.get('K8SNfsServer')
consensus = config['consensus_plugin']
return cluster, cluster_name, kube_config, ports_index, \
nfsServer_ip, consensus
def list(self, filter_data={}, col_name="active"):
""" List clusters with given criteria
:param filter_data: Image with the filter properties
:param col_name: Use data in which col_name
:return: list of serialized doc
"""
result = []
if col_name in [e.name for e in CLUSTER_STATE]:
logger.debug("List all {} clusters".format(col_name))
filter_data.update({
"state": col_name
})
clusters = ClusterModel.objects(__raw__=filter_data)
result = self._schema(clusters, many=True)
else:
logger.warning("Unknown cluster col_name=" + col_name)
return result
def find_free_start_ports(self, host_id, number):
""" Find the first available port for a new cluster api
This is NOT lock-free. Should keep simple, fast and safe!
Check existing cluster records in the host, find available one.
:param host_id: id of the host
:param number: Number of ports to get
:return: The port list, e.g., [7050, 7150, ...]
"""
logger.debug("Find {} start ports for host {}".format(number, host_id))
if number <= 0:
logger.warning("number {} <= 0".format(number))
return []
host = self.host_handler.get_by_id(host_id)
if not host:
logger.warning("Cannot find host with id={}", host_id)
return ""
clusters_exists = ClusterModel.objects(host=host)
# clusters_valid = list(filter(lambda c: c.get("service_url"),
# clusters_exists))
# ports_existed = list(map(
# lambda c: int(c["service_url"]["rest"].split(":")[-1]),
# clusters_valid))
ports_existed = [
service.port
for service in ServicePort.objects(cluster__in=clusters_exists)
]
logger.debug("The ports existed: {}".format(ports_existed))
if len(ports_existed) + number >= 1000:
logger.warning("Too much ports are already in used.")
return []
candidates = [
CLUSTER_PORT_START + i * CLUSTER_PORT_STEP
for i in range(len(ports_existed) + number)
]
result = list(filter(lambda x: x not in ports_existed, candidates))
logger.debug("Free ports are {}".format(result[:number]))
return result[:number]
def find_free_start_ports(self, host_id, number):
""" Find the first available port for a new cluster api
This is NOT lock-free. Should keep simple, fast and safe!
Check existing cluster records in the host, find available one.
:param host_id: id of the host
:param number: Number of ports to get
:return: The port list, e.g., [7050, 7150, ...]
"""
logger.debug("Find {} start ports for host {}".format(number, host_id))
if number <= 0:
logger.warning("number {} <= 0".format(number))
return []
host = self.host_handler.get_by_id(host_id)
if not host:
logger.warning("Cannot find host with id={}", host_id)
return ""
clusters_exists = ClusterModel.objects(host=host)
# clusters_valid = list(filter(lambda c: c.get("service_url"),
# clusters_exists))
# ports_existed = list(map(
# lambda c: int(c["service_url"]["rest"].split(":")[-1]),
# clusters_valid))
ports_existed = [service.port for service in
ServicePort.objects(cluster__in=clusters_exists)]
logger.debug("The ports existed: {}".format(ports_existed))
if len(ports_existed) + number >= 1000:
logger.warning("Too much ports are already in used.")
return []
candidates = [CLUSTER_PORT_START + i * CLUSTER_PORT_STEP
for i in range(len(ports_existed) + number)]
result = list(filter(lambda x: x not in ports_existed, candidates))
logger.debug("Free ports are {}".format(result[:number]))
return result[:number]
def delete(self, id):
""" Delete a host instance
:param id: id of the host to delete
:return:
"""
logger.debug("Delete a host with id={0}".format(id))
try:
h = HostModel.objects.get(id=id)
except Exception:
logger.warning("Cannot delete non-existed host")
return False
host_type = h.type
if ClusterModel.objects(host=h).count():
logger.warning("Host type not found.")
return False
elif (host_type == WORKER_TYPE_DOCKER or
host_type == WORKER_TYPE_SWARM):
self.host_agents[host_type].delete(h.worker_api)
elif host_type == WORKER_TYPE_VSPHERE:
if h.status == "pending":
return False
vmuuid = h.vcparam[utils.VMUUID]
vcip = h.vcparam[utils.VCIP]
vcusername = h.vcparam[utils.VCUSERNAME]
vcpwd = h.vcparam[utils.VCPWD]
vcport = h.vcparam[utils.VCPORT]
self.host_agents[host_type].delete(vmuuid,
vcip,
vcusername,
vcpwd,
vcport)
h.delete()
return True
def delete(self, id):
""" Delete a host instance
:param id: id of the host to delete
:return:
"""
logger.debug("Delete a host with id={0}".format(id))
try:
h = HostModel.objects.get(id=id)
except Exception:
logger.warning("Cannot delete non-existed host")
return False
host_type = h.type
if ClusterModel.objects(host=h).count():
logger.warning("Host type not found.")
return False
elif (host_type == WORKER_TYPE_DOCKER or
host_type == WORKER_TYPE_SWARM):
self.host_agents[host_type].delete(h.worker_api)
# elif host_type == WORKER_TYPE_VSPHERE:
# if h.status == "pending":
# return False
# vc_params = self.get_vc_params_by_id(id)
# vm_params = self.get_vm_params_by_id(id)
# logger.info(vc_params)
# self.host_agents[host_type].delete(vm_params.get(VMUUID),
# h.worker_api,
# vc_params.get(VCUSERNAME),
# vc_params.get(VCPWD),
# vc_params.get(VCPORT))
h.delete()
return True
def delete(self, id):
""" Delete a host instance
:param id: id of the host to delete
:return:
"""
logger.debug("Delete a host with id={0}".format(id))
try:
h = HostModel.objects.get(id=id)
except Exception:
logger.warning("Cannot delete non-existed host")
return False
host_type = h.type
if ClusterModel.objects(host=h).count():
logger.warning("Host type not found.")
return False
elif (host_type == WORKER_TYPE_DOCKER or
host_type == WORKER_TYPE_SWARM):
self.host_agents[host_type].delete(h.worker_api)
# elif host_type == WORKER_TYPE_VSPHERE:
# if h.status == "pending":
# return False
# vc_params = self.get_vc_params_by_id(id)
# vm_params = self.get_vm_params_by_id(id)
# logger.info(vc_params)
# self.host_agents[host_type].delete(vm_params.get(VMUUID),
# h.worker_api,
# vc_params.get(VCUSERNAME),
# vc_params.get(VCPWD),
# vc_params.get(VCPORT))
h.delete()
return True
def create(self, name, host_id, config, start_port=0,
user_id=""):
""" Create a cluster based on given data
TODO: maybe need other id generation mechanism
Args:
name: name of the cluster
host_id: id of the host URL
config: network configuration
start_port: first service port for cluster, will generate
if not given
user_id: user_id of the cluster if start to be applied
return: Id of the created cluster or None
"""
logger.info("Create cluster {}, host_id={}, config={}, start_port={}, "
"user_id={}".format(name, host_id, config.get_data(),
start_port, user_id))
worker = self.host_handler.get_active_host_by_id(host_id)
if not worker:
logger.error("Cannot find available host to create new network")
return None
if ClusterModel.Query.filter(host=worker.as_pointer).count() >= \
worker.capacity:
logger.warning("host {} is already full".format(host_id))
return None
peer_num = int(config.get_data().get("size", 4))
ca_num = 2 if peer_num > 1 else 1
cid = uuid4().hex
mapped_ports, peer_ports, ca_ports, orderer_ports = \
self.gen_ports_mapping(peer_num, ca_num, start_port, host_id)
if not mapped_ports:
logger.error("mapped_ports={}".format(mapped_ports))
return None
env_mapped_ports = dict(((k + '_port').upper(), str(v))
for (k, v) in mapped_ports.items())
network_type = config['network_type']
net = { # net is a blockchain network instance
'id': cid,
'name': name,
'user_id': user_id,
'worker_api': worker.worker_api,
'network_type': network_type, # e.g., fabric-1.0
'env': env_mapped_ports,
'status': NETWORK_STATUS_CREATING,
'mapped_ports': mapped_ports,
'state': CLUSTER_STATE.active.name,
'health': "",
'service_url': {}, # e.g., {rest: xxx:7050, grpc: xxx:7051}
}
net.update(config.get_data())
# try to start one cluster at the host
cluster = ClusterModel(**net)
cluster.host = worker.as_pointer
cluster.save()
# start cluster creation asynchronously for better user experience.
t = Thread(target=self._create_cluster, args=(cluster, cid,
mapped_ports, worker,
config, user_id,
peer_ports, ca_ports,
orderer_ports))
t.start()
return cid
def delete(self, id, record=False, forced=False):
""" Delete a cluster instance
Clean containers, remove db entry. Only operate on active host.
:param id: id of the cluster to delete
:param record: Whether to record into the released collections
:param forced: Whether to removing user-using cluster, for release
:return:
"""
logger.debug("Delete cluster: id={}, forced={}".format(id, forced))
try:
cluster = ClusterModel.Query.get(id=id)
except Exception:
logger.warning("Cannot find cluster {}".format(id))
return False
c = self.db_update_one({"id": id}, {"status": NETWORK_STATUS_DELETING},
after=False)
# we are safe from occasional applying now
user_id = c.user_id # original user_id
if not forced and user_id and user_id != "":
# not forced, and chain is used by normal user, then no process
logger.warning("Cannot delete cluster {} by "
"user {}".format(id, user_id))
cluster = ClusterModel(objectId=cluster.objectId, user_id=user_id)
cluster.save()
return False
else:
cluster = ClusterModel(objectId=cluster.objectId,
status=NETWORK_STATUS_DELETING)
cluster.save()
host_id, worker_api, network_type, consensus_plugin, cluster_size = \
str(c.host.id), c.worker_api, \
c.network_type if c.network_type else NETWORK_TYPE_FABRIC_PRE_V1, \
c.consensus_plugin if c.consensus_plugin else \
CONSENSUS_PLUGINS_FABRIC_V1[0], \
c.size if c.size else NETWORK_SIZE_FABRIC_PRE_V1[0]
# port = api_url.split(":")[-1] or CLUSTER_PORT_START
h = self.host_handler.get_active_host_by_id(host_id)
if not h:
logger.warning("Host {} inactive".format(host_id))
cluster = ClusterModel(objectId=cluster.objectId, user_id=user_id)
cluster.save()
return False
if network_type == NETWORK_TYPE_FABRIC_V1:
config = FabricV1NetworkConfig(consensus_plugin=consensus_plugin,
size=cluster_size)
elif network_type == NETWORK_TYPE_FABRIC_V1_1:
config = FabricV1NetworkConfig(consensus_plugin=consensus_plugin,
size=cluster_size)
config.network_type = NETWORK_TYPE_FABRIC_V1_1
elif network_type == NETWORK_TYPE_FABRIC_V1_2:
config = FabricV1NetworkConfig(consensus_plugin=consensus_plugin,
size=cluster_size)
config.network_type = NETWORK_TYPE_FABRIC_V1_2
elif network_type == NETWORK_TYPE_FABRIC_PRE_V1:
config = FabricPreNetworkConfig(consensus_plugin=consensus_plugin,
consensus_mode='',
size=cluster_size)
else:
return False
config.update({"env": c.env})
delete_result = self.cluster_agents[h.type].delete(
id, worker_api, config)
if not delete_result:
logger.warning("Error to run compose clean work")
cluster = ClusterModel(objectId=cluster.objectId, user_id=user_id)
cluster.save()
return False
# remove cluster info from host
logger.info("remove cluster from host, cluster:{}".format(id))
# h.update(pull__clusters=id)
# h = HostModel(objectId=h.objectId)
c.delete()
service_ports = ServicePort.Query.filter(cluster=c.as_pointer)
batcher = ParseBatcher()
batcher.batch_delete(service_ports)
containers = Container.Query.filter(cluster=c.as_pointer)
batcher.batch_delete(containers)
return True
def create(self, name, host_id, config, start_port=0,
user_id=""):
""" Create a cluster based on given data
TODO: maybe need other id generation mechanism
Args:
name: name of the cluster
host_id: id of the host URL
config: network configuration
start_port: first service port for cluster, will generate
if not given
user_id: user_id of the cluster if start to be applied
return: Id of the created cluster or None
"""
logger.info("Create cluster {}, host_id={}, config={}, start_port={}, "
"user_id={}".format(name, host_id, config.get_data(),
start_port, user_id))
worker = self.host_handler.get_active_host_by_id(host_id)
if not worker:
logger.error("Cannot find available host to create new network")
return None
if ClusterModel.objects(host=worker).count() >= worker.capacity:
logger.warning("host {} is already full".format(host_id))
return None
if worker.type == WORKER_TYPE_VSPHERE:
vm_params = self.host_handler.get_vm_params_by_id(host_id)
docker_daemon = vm_params.get(VMIP) + ":2375"
worker.update({"worker_api": "tcp://" + docker_daemon})
logger.info(worker)
peer_num = int(config.get_data().get("size", 4))
ca_num = 2 if peer_num > 1 else 1
cid = uuid4().hex
mapped_ports, peer_ports, ca_ports, orderer_ports, explorer_ports = \
self.gen_ports_mapping(peer_num, ca_num, start_port, host_id)
if not mapped_ports:
logger.error("mapped_ports={}".format(mapped_ports))
return None
env_mapped_ports = dict(((k + '_port').upper(),
str(v)) for (k, v) in mapped_ports.items())
network_type = config['network_type']
net = { # net is a blockchain network instance
'id': cid,
'name': name,
'user_id': user_id,
'worker_api': worker.worker_api,
'network_type': network_type, # e.g., fabric-1.0
'env': env_mapped_ports,
'status': NETWORK_STATUS_CREATING,
'mapped_ports': mapped_ports,
'service_url': {}, # e.g., {rest: xxx:7050, grpc: xxx:7051}
}
net.update(config.get_data())
# try to start one cluster at the host
cluster = ClusterModel(**net)
cluster.host = worker
cluster.save()
# start compose project, failed then clean and return
logger.debug("Start compose project with name={}".format(cid))
containers = self.cluster_agents[worker.type] \
.create(cid, mapped_ports, self.host_handler.schema(worker),
config=config, user_id=user_id)
if not containers:
logger.warning("failed to start cluster={}, then delete"
.format(name))
self.delete(id=cid, record=False, forced=True)
return None
# creation done, update the container table in db
for k, v in containers.items():
container = Container(id=v, name=k, cluster=cluster)
container.save()
# service urls can only be calculated after service is created
service_urls = self.gen_service_urls(cid, peer_ports, ca_ports,
orderer_ports, explorer_ports)
# update the service port table in db
for k, v in service_urls.items():
service_port = ServicePort(name=k, ip=v.split(":")[0],
port=int(v.split(":")[1]),
cluster=cluster)
service_port.save()
# update api_url, container, user_id and status
self.db_update_one(
{"id": cid},
{
"user_id": user_id,
'api_url': service_urls.get('rest', ""),
'service_url': service_urls,
'status': NETWORK_STATUS_RUNNING
}
)
def check_health_work(cid):
time.sleep(5)
self.refresh_health(cid)
t = Thread(target=check_health_work, args=(cid,))
t.start()
host = HostModel.objects.get(id=host_id)
host.update(add_to_set__clusters=[cid])
logger.info("Create cluster OK, id={}".format(cid))
return cid
def post(self):
user = utils._get_user()
user = user.dbUser
body = cluster_create_parser.parse_args()
cluster_name = body.get('cluster_name')
network_type = body.get('network_type')
consensus_plugin = body.get('consensus_plugin')
domain = body.get('domain')
channel = body.get('channel')
orderer = body.get('orderer')
peer_orgs = body.get('peer_orgs')
orderer_org = body.get('orderer_org')
if not all([cluster_name, network_type, peer_orgs, channel, domain]):
error_msg = "参数缺失"
logger.warning(error_msg)
return make_fail_resp(error=error_msg, data=body)
host_id = ''
try:
hosts = HostModel.objects.all()
for host in hosts:
if len(host.clusters) < host.capacity:
host_id = host.id
break
except Exception as e:
logger.error(e)
return make_fail_resp(error='db error')
if not host_id:
return {'stat': 401, 'msg': '服务器已满，请联系客服'}
if network_type not in NETWORK_TYPES:
error_msg = "Unknown network_type={}".format(network_type)
logger.warning(error_msg)
return make_fail_resp()
peer_org_list = []
orderer_org = {
'name': 'orderer',
'domain': domain,
'orderers': ['orderer']
}
for peer_org in peer_orgs:
peer_org = demjson.decode(peer_org)
if not all([peer_org.get('name'), peer_org.get('peers')]):
return make_fail_resp(error='参数缺失', data=body)
peer_org['peers'] = [
'peer{}'.format(i) for i in range(int(peer_org['peers']))
]
peer_org['domain'] = domain
peer_org['ca'] = 'ca'
peer_org_list.append(peer_org)
cluster = ClusterModel.objects(name=cluster_name)
if cluster:
return make_fail_resp(error='链名重复')
config = FabricNetworkConfig(consensus_plugin=consensus_plugin,
network_type=network_type,
channel=channel,
orderer_org=orderer_org,
peer_orgs=peer_org_list)
config.domain = domain
if not config.validate():
return make_fail_resp(error="config not validated",
data=config.get_data())
if cluster_handler.create(name=cluster_name,
host_id=host_id,
config=config,
user=user):
logger.debug("cluster POST successfully")
return make_ok_resp()
else:
logger.debug("cluster creation failed using handlder")
return make_fail_resp(
error="Failed to create cluster {}".format(cluster_name))
def create(self, name, host_id, config, user, start_port=0,
):
""" Create a cluster based on given data
TODO: maybe need other id generation mechanism
Args:
name: name of the cluster
host_id: id of the host URL
domain: domain of the cluster
channel: channel of the cluster
config: network configuration
start_port: first service port for cluster, will generate
if not given
user: user_id of the cluster if start to be applied
return: Id of the created cluster or None
"""
logger.info("Create cluster {}, host_id={}, config={}, start_port={}, "
"user_id={}".format(name, host_id, config,
start_port, user))
worker = self.host_handler.get_active_host_by_id(host_id)
if not worker:
logger.error("Cannot find available host to create new network")
return None
cid = uuid4().hex
orderer_services = []
ca_services = []
peer_services = []
orderer_org = config.get('orderer_org')
orderer_org_name = orderer_org.get('name')
orderers = orderer_org.get('orderers')
for orderer in orderers:
for k in orderer_service_ports.keys():
orderer_services.append(k.format(orderer, orderer_org_name))
for peer_org in config.peer_orgs:
ca_name = peer_org.get('ca')
org_name = peer_org.get('name')
peers = peer_org.get('peers')
for j in ca_service_ports.keys():
ca_services.append(j.format(ca_name, org_name))
for peer in peers:
for k in peer_service_ports.keys():
peer_services.append(k.format(peer, org_name))
mapped_ports, peer_ports, ca_ports, orderer_ports = \
self.gen_ports_mapping(orderer_services, ca_services, peer_services, start_port, host_id)
if not mapped_ports:
logger.error("mapped_ports={}".format(mapped_ports))
return None
worker.update(add_to_set__port_used=list(mapped_ports.values()))
env_mapped_ports = dict(((k + '_port').upper(), str(v))
for (k, v) in mapped_ports.items())
network_type = config['network_type']
consensus_plugin = config['consensus_plugin']
service_url = {}
host_ip = worker.worker_api.split(':')[1][2:]
for k, v in mapped_ports.items():
service_url[k] = "{}:{}".format(url_map[host_ip], v)
create_time = datetime.datetime.now()
net = {
'id': cid,
'name': name,
'host': worker,
'domain': config.get('domain'),
'network_type': network_type,
'consensus_plugin': consensus_plugin,
'ports': list(mapped_ports.values()),
'env': env_mapped_ports,
'status': NETWORK_STATUS_RUNNING,
# 'status': NETWORK_STATUS_CREATING,
# 'mapped_ports': mapped_ports,
'create_ts': create_time,
'due_time': create_time + datetime.timedelta(days=BLOCK_CHAIN_PROBATION_PERIOD),
'user': user,
'service_url': service_url, # e.g., {rest: xxx:7050, grpc: xxx:7051}
}
# try to start one cluster at the host
cluster = ClusterModel(**net)
cluster.host = worker
cluster.save()
channel = ChannelModel(
name=config.channel,
alias='channel1',
cluster=cluster
)
channel.save()
orderer_org = OrgModel(
name=orderer_org_name,
alias='orderer',
domain=config.orderer_org.get('domain'),
org_type='orderer',
cluster=cluster
)
orderer_org.save()
start = 0
for orderer in config.orderer_org.get('orderers'):
orderer = Node(
name=orderer,
alias='orderer{}'.format(start if start else ''),
ip=url_map[host_ip],
org=orderer_org,
node_type='orderer',
ports={'orderer': mapped_ports.get('{}_{}'.format(orderer, orderer_org.name))}
)
orderer.save()
channel.update(add_to_set__orderers=[orderer])
start += 1
org_start = 0
for peer_org in config.peer_orgs:
peer_org_name = peer_org.get('name')
_peer_org = OrgModel(
name=peer_org_name,
alias='org{}'.format(org_start+1),
domain=peer_org.get('domain'),
org_type='peer',
# users=[user],
cluster=cluster
)
_peer_org.save()
channel.update(add_to_set__orgs=[_peer_org])
org_start += 1
peer_start = 0
for peer in peer_org.get('peers'):
peer = Node(
name=peer,
alias='peer{}'.format(peer_start),
ip=url_map[host_ip],
org=_peer_org,
node_type='peer',
ports={
'grpc': mapped_ports.get("{}_{}_grpc".format(peer, _peer_org.name)),
'event': mapped_ports.get("{}_{}_event".format(peer, _peer_org.name))
}
)
peer.save()
peer_start += 1
ca_name = peer_org.get('ca')
ca = Node(
name=ca_name,
alias='ca',
ip=url_map[host_ip],
node_type='ca',
org=_peer_org,
ports={'ecap': mapped_ports.get('{}_{}_ecap'.format(ca_name, _peer_org.name))}
)
ca.save()
if self._create_cluster(cluster, cid, mapped_ports, worker, config, user, peer_ports, ca_ports, orderer_ports):
return cid
else:
cluster.delete()
return False
def create(self, name, host_id, config, start_port=0, user_id=""):
""" Create a cluster based on given data
TODO: maybe need other id generation mechanism
Args:
name: name of the cluster
host_id: id of the host URL
config: network configuration
start_port: first service port for cluster, will generate
if not given
user_id: user_id of the cluster if start to be applied
return: Id of the created cluster or None
"""
logger.info("Create cluster {}, host_id={}, config={}, start_port={}, "
"user_id={}".format(name, host_id, config.get_data(),
start_port, user_id))
worker = self.host_handler.get_active_host_by_id(host_id)
if not worker:
logger.error("Cannot find available host to create new network")
return None
if ClusterModel.objects(host=worker).count() >= worker.capacity:
logger.warning("host {} is already full".format(host_id))
return None
peer_num = int(config.get_data().get("size", 4))
ca_num = 2 if peer_num > 1 else 1
cid = uuid4().hex
mapped_ports, peer_ports, ca_ports, orderer_ports = \
self.gen_ports_mapping(peer_num, ca_num, start_port, host_id)
if not mapped_ports:
logger.error("mapped_ports={}".format(mapped_ports))
return None
env_mapped_ports = dict(
((k + '_port').upper(), str(v)) for (k, v) in mapped_ports.items())
network_type = config['network_type']
net = { # net is a blockchain network instance
'id': cid,
'name': name,
'user_id': user_id,
'worker_api': worker.worker_api,
'network_type': network_type, # e.g., fabric-1.0
'env': env_mapped_ports,
'status': NETWORK_STATUS_CREATING,
'mapped_ports': mapped_ports,
'service_url': {}, # e.g., {rest: xxx:7050, grpc: xxx:7051}
}
net.update(config.get_data())
# try to start one cluster at the host
cluster = ClusterModel(**net)
cluster.host = worker
cluster.save()
# start cluster creation asynchronously for better user experience.
t = Thread(target=self._create_cluster,
args=(cluster, cid, mapped_ports, worker, config, user_id,
peer_ports, ca_ports, orderer_ports))
t.start()
return cid
def create(self, name, host_id, config, start_port=0,
user_id=SYS_USER):
""" Create a cluster based on given data
TODO: maybe need other id generation mechanism
Args:
name: name of the cluster
host_id: id of the host URL
config: network configuration
start_port: first service port for cluster, will generate
if not given
user_id: user_id of the cluster if start to be applied
return: Id of the created cluster or None
"""
logger.info("Create cluster {}, host_id={}, config={}, start_port={}, "
"user_id={}".format(name, host_id, config.get_data(),
start_port, user_id))
size = int(config.get_data().get("size", 4))
worker = self.host_handler.get_active_host_by_id(host_id)
if not worker:
return None
if worker.type == WORKER_TYPE_VSPHERE:
vm_params = self.host_handler.get_vm_params_by_id(host_id)
docker_daemon = vm_params.get(VMIP) + ":2375"
worker.update({"worker_api": "tcp://" + docker_daemon})
logger.info(worker)
if ClusterModel.objects(host=worker).count() >= worker.capacity:
logger.warning("host {} is already full".format(host_id))
return None
worker_api = worker.worker_api
logger.debug("worker_api={}".format(worker_api))
ca_num = 1
request_port_num = \
len(ORDERER_SERVICE_PORTS.items()) + \
len(ca_service_ports.items()) * ca_num + \
size * (len(peer_service_ports.items()))
logger.debug("request port number {}".format(request_port_num))
if start_port <= 0:
ports = self.find_free_start_ports(host_id, request_port_num)
if not ports:
logger.warning("No free port is found")
return None
else:
ports = [i for i in
range(start_port, start_port + request_port_num)]
logger.debug("ports {}".format(ports))
peers_ports, ca_mapped_ports, orderer_service_ports,\
explorer_mapped_port, mapped_ports = \
{}, {}, {}, {}, {}
if size > 1:
org_num_list = [1, 2]
peer_num_end = int(size / 2)
else:
org_num_list = [1]
peer_num_end = 1
logger.debug("org num list {} peer_num_end {}".
format(org_num_list, peer_num_end))
pos = 0
for org_num in org_num_list:
for peer_num in range(0, peer_num_end):
for k, v in peer_service_ports.items():
peers_ports[k.format(peer_num, org_num)] = ports[pos]
logger.debug("pos {}".format(pos))
pos += 1
# for org_num in org_num_list:
for k, v in ca_service_ports.items():
ca_mapped_ports[k.format(1)] = ports[pos]
logger.debug("pos={}".format(pos))
pos += 1
for k, v in ORDERER_SERVICE_PORTS.items():
orderer_service_ports[k] = ports[pos]
logger.debug("pos={}".format(pos))
pos += 1
for k, v in EXPLORER_PORT.items():
explorer_mapped_port[k] = \
v - PEER_SERVICE_PORTS['rest'] + start_port
mapped_ports.update(peers_ports)
mapped_ports.update(ca_mapped_ports)
mapped_ports.update(orderer_service_ports)
mapped_ports.update(explorer_mapped_port)
env_mapped_ports = dict(((k + '_port').upper(),
str(v)) for (k, v) in mapped_ports.items())
network_type = config['network_type']
cid = uuid4().hex
net = { # net is a blockchain network instance
'id': cid,
'name': name,
'user_id': user_id or SYS_CREATOR, # avoid applied
'worker_api': worker_api,
'network_type': network_type, # e.g., fabric-1.0
'env': env_mapped_ports
}
if network_type == NETWORK_TYPE_FABRIC_V1: # TODO: fabric v1.0
net.update({
'mapped_ports': mapped_ports,
'service_url': {}, # e.g., {rest: xxx:7050, grpc: xxx:7051}
})
elif network_type == NETWORK_TYPE_FABRIC_PRE_V1: # fabric v0.6
net.update({
'mapped_ports': mapped_ports,
'service_url': {}, # e.g., {rest: xxx:7050, grpc: xxx:7051}
})
net.update(config.get_data())
# try to start one cluster at the host
cluster = ClusterModel(**net)
cluster.host = worker
cluster.save()
# from now on, we should be safe
# start compose project, failed then clean and return
logger.debug("Start compose project with name={}".format(cid))
containers = self.cluster_agents[worker.type] \
.create(cid, mapped_ports, self.host_handler.schema(worker),
config=config, user_id=user_id)
if not containers:
logger.warning("failed to start cluster={}, then delete"
.format(name))
self.delete(id=cid, record=False, forced=True)
return None
for k, v in containers.items():
container = Container(id=v, name=k, cluster=cluster)
container.save()
access_peer, access_ca = '', ''
if network_type == NETWORK_TYPE_FABRIC_V1: # fabric v1.0
access_peer = 'peer0.org1.example.com'
access_ca = 'ca.example.com'
# access_explorer = 'explorer'
elif network_type == NETWORK_TYPE_FABRIC_PRE_V1: # fabric v0.6
access_peer = 'vp0'
access_ca = 'membersrvc'
peer_host_ip = self._get_service_ip(cid, access_peer)
ca_host_ip = self._get_service_ip(cid, access_ca)
# explorer_host_ip = self._get_service_ip(cid, access_explorer)
# no api_url, then clean and return
if not peer_host_ip: # not valid api_url
logger.error("Error to find peer host url, cleanup")
self.delete(id=cid, record=False, forced=True)
return None
service_urls = {}
for k, v in peers_ports.items():
service_urls[k] = "{}:{}".format(peer_host_ip, v)
for k, v in ca_mapped_ports.items():
service_urls[k] = "{}:{}".format(ca_host_ip, v)
for k, v in orderer_service_ports.items():
service_urls[k] = "{}:{}".format(ca_host_ip, v)
for k, v in service_urls.items():
service_port = ServicePort(name=k, ip=v.split(":")[0],
port=int(v.split(":")[1]),
cluster=cluster)
service_port.save()
# update api_url, container, and user_id field
self.db_update_one(
{"id": cid},
{
"user_id": user_id,
'api_url': service_urls.get('rest', ""),
'service_url': service_urls
}
)
def check_health_work(cid):
time.sleep(5)
self.refresh_health(cid)
t = Thread(target=check_health_work, args=(cid,))
t.start()
logger.info("Create cluster OK, id={}".format(cid))
return cid
def delete(self, id, record=False, forced=False):
""" Delete a cluster instance
Clean containers, remove db entry. Only operate on active host.
:param id: id of the cluster to delete
:param record: Whether to record into the released collections
:param forced: Whether to removing user-using cluster, for release
:return:
"""
logger.debug("Delete cluster: id={}, forced={}".format(id, forced))
try:
cluster = ClusterModel.Query.get(id=id)
except Exception:
logger.warning("Cannot find cluster {}".format(id))
return False
c = self.db_update_one({"id": id}, {"status": NETWORK_STATUS_DELETING},
after=False)
# we are safe from occasional applying now
user_id = c.user_id # original user_id
if not forced and user_id and user_id != "":
# not forced, and chain is used by normal user, then no process
logger.warning("Cannot delete cluster {} by "
"user {}".format(id, user_id))
cluster = ClusterModel(objectId=cluster.objectId, user_id=user_id)
cluster.save()
return False
else:
cluster = ClusterModel(objectId=cluster.objectId,
status=NETWORK_STATUS_DELETING)
cluster.save()
host_id, worker_api, network_type, consensus_plugin, cluster_size = \
str(c.host.id), c.worker_api, \
c.network_type if c.network_type else NETWORK_TYPE_FABRIC_PRE_V1, \
c.consensus_plugin if c.consensus_plugin else \
CONSENSUS_PLUGINS_FABRIC_V1[0], \
c.size if c.size else NETWORK_SIZE_FABRIC_PRE_V1[0]
# port = api_url.split(":")[-1] or CLUSTER_PORT_START
h = self.host_handler.get_active_host_by_id(host_id)
if not h:
logger.warning("Host {} inactive".format(host_id))
cluster = ClusterModel(objectId=cluster.objectId, user_id=user_id)
cluster.save()
return False
if network_type == NETWORK_TYPE_FABRIC_V1:
config = FabricV1NetworkConfig(consensus_plugin=consensus_plugin,
size=cluster_size)
elif network_type == NETWORK_TYPE_FABRIC_V1_1:
config = FabricV1NetworkConfig(consensus_plugin=consensus_plugin,
size=cluster_size)
config.network_type = NETWORK_TYPE_FABRIC_V1_1
elif network_type == NETWORK_TYPE_FABRIC_V1_2:
config = FabricV1NetworkConfig(consensus_plugin=consensus_plugin,
size=cluster_size)
config.network_type = NETWORK_TYPE_FABRIC_V1_2
elif network_type == NETWORK_TYPE_FABRIC_PRE_V1:
config = FabricPreNetworkConfig(consensus_plugin=consensus_plugin,
consensus_mode='',
size=cluster_size)
else:
return False
config.update({
"env": c.env
})
delete_result = self.cluster_agents[h.type].delete(id, worker_api,
config)
if not delete_result:
logger.warning("Error to run compose clean work")
cluster = ClusterModel(objectId=cluster.objectId,
user_id=user_id)
cluster.save()
return False
# remove cluster info from host
logger.info("remove cluster from host, cluster:{}".format(id))
# h.update(pull__clusters=id)
# h = HostModel(objectId=h.objectId)
c.delete()
# service_ports = ServicePort.Query.filter(cluster=c.as_pointer)
# batcher = ParseBatcher()
# batcher.batch_delete(service_ports)
# containers = Container.Query.filter(cluster=c.as_pointer)
# batcher.batch_delete(containers)
return True
