def _create_node(self, org, num, nodeType):
"""
create node
:param org: organization
:param num: the number of node
:param nodeType: the type of node
:return: null
"""
for i in range(num):
nodeName = "peer" + str(
i) if nodeType == "peer" else "orderer" + str(i)
self._generate_config(nodeType, org.name, nodeName)
msp, tls, cfg = self._conversion_msp_tls_cfg(
nodeType, org.name, nodeName)
urls = "{}.{}".format(nodeName, org.name)
node = Node(name=nodeName,
org=org,
urls=urls,
type=nodeType,
msp=msp,
tls=tls,
agent=None,
config_file=cfg)
node.save()
def create(self, request):
"""
Create Node
Create node
"""
serializer = NodeCreateBody(data=request.data)
if serializer.is_valid(raise_exception=True):
self._validate_organization(request)
agent_type = serializer.validated_data.get("agent_type")
network_type = serializer.validated_data.get("network_type")
network_version = serializer.validated_data.get("network_version")
agent = serializer.validated_data.get("agent")
node_type = serializer.validated_data.get("type")
if agent is None:
available_agents = (Agent.objects.annotate(
network_num=Count("node__network")).annotate(
node_num=Count("node")).filter(
schedulable=True,
type=agent_type,
network_num__lt=F("capacity"),
node_num__lt=F("node_capacity"),
organization=request.user.organization,
).order_by("node_num"))
if len(available_agents) > 0:
agent = available_agents[0]
else:
raise NoResource
else:
if not request.user.is_operator:
raise PermissionDenied
node_count = Node.objects.filter(agent=agent).count()
if node_count >= agent.node_capacity or not agent.schedulable:
raise NoResource
node = Node(
network_type=network_type,
agent=agent,
network_version=network_version,
user=request.user,
organization=request.user.organization,
type=node_type,
)
node.save()
agent_config_file = (request.build_absolute_uri(
agent.config_file.url), )
node_update_api = reverse("node-detail", args=[str(node.id)])
node_update_api = request.build_absolute_uri(node_update_api)
if isinstance(agent_config_file, tuple):
agent_config_file = list(agent_config_file)[0]
create_node.delay(
str(node.id),
agent.image,
agent_config_file=agent_config_file,
node_update_api=node_update_api,
)
response = NodeIDSerializer(data={"id": str(node.id)})
if response.is_valid(raise_exception=True):
return Response(response.validated_data,
status=status.HTTP_201_CREATED)
def create(self, request):
"""
Create Node
:param request: create parameter
:return: node ID
:rtype: uuid
"""
try:
serializer = NodeCreateBody(data=request.data)
if serializer.is_valid(raise_exception=True):
node_name = serializer.validated_data.get("name")
node_type = serializer.validated_data.get("type")
num = serializer.validated_data.get("num")
organization = request.user.organization
agent = organization.agent.get()
if agent:
nodes = Node.objects.filter(name=node_name + "0",
organization=organization,
type=node_type)
if nodes:
raise ResourceExists
else:
raise NoResource
for n in range(num):
name = node_name + str(n)
urls = "http://{}.{}".format(name, organization.name)
nodes = {"type": node_type, "Specs": [name]}
CryptoConfig(organization.name).update(nodes)
CryptoGen(organization.name).extend()
self._generate_config(node_type, organization.name, name)
msp, tls, cfg = self._conversion_msp_tls_cfg(
node_type, organization.name, name)
node = Node(name=name,
organization=organization,
urls=urls,
type=node_type,
msp=msp,
tls=tls,
agent=agent,
config_file=cfg)
node.save()
self._set_port(node_type, node, agent)
response = NodeIDSerializer(data=node.__dict__)
if response.is_valid(raise_exception=True):
return Response(ok(response.validated_data),
status=status.HTTP_201_CREATED)
except (ResourceExists, NoResource) as e:
raise e
except Exception as e:
return Response(err(e.args), status=status.HTTP_400_BAD_REQUEST)
def create(self, request):
serializer = NodeCreateBody(data=request.data)
if serializer.is_valid(raise_exception=True):
node_name = serializer.validated_data.get("name")
node_type = serializer.validated_data.get("type")
node_urls = serializer.validated_data.get("urls")
organization = serializer.validated_data.get("organization")
org_name = organization["name"]
try:
Node.objects.get(name=node_name)
except ObjectDoesNotExist:
pass
org = Organization.objects.get(name=org_name)
nodes = {
"type": node_type,
"Specs": [node_name]
}
CryptoConfig(org_name).update(nodes)
CryptoGen(org_name).extend()
if node_type == "peer":
dir_msp = "{}/{}/crypto-config/peerOrganizations/{}/peers/{}/msp"\
.format(CELLO_HOME, org_name, org_name, node_name+"."+org_name)
else:
dir_msp = "{}/{}/crypto-config/ordererOrganizations/{}/orderers/{}/msp"\
.format(CELLO_HOME, org_name, org_name.split(".", 1)[1], node_name+"."+org_name)
zipDir(dir_msp, "/opt/msp.zip")
f_msp = open("/opt/msp.zip", "rb")
print(chardet.detect(f_msp.readline()))
if node_type == "peer":
dir_tls = "{}/{}/crypto-config/peerOrganizations/{}/peers/{}/tls" \
.format(CELLO_HOME, org_name, org_name, node_name + "." + org_name)
else:
dir_tls = "{}/{}/crypto-config/ordererOrganizations/{}/orderers/{}/msp"\
.format(CELLO_HOME, org_name, org_name.split(".", 1)[1], node_name+"."+org_name)
zipDir(dir_tls, "/opt/tls.zip")
f_tls = open("/opt/tls.zip", "rb")
node = Node(name=node_name, organization=org, urls=node_urls, type=node_type)
node.msp.save("msp.zip", File(f_msp))
node.tls.save("tls.zip", File(f_tls))
node.save()
f_msp.close()
f_tls.close()
response = NodeIDSerializer(data=node.__dict__)
if response.is_valid(raise_exception=True):
return Response(
response.validated_data, status=status.HTTP_201_CREATED
)
def create(self, request):
"""
Create Node
Create node
"""
serializer = NodeCreateBody(data=request.data)
if serializer.is_valid(raise_exception=True):
self._validate_organization(request)
agent_type = serializer.validated_data.get("agent_type")
network_type = serializer.validated_data.get("network_type")
network_version = serializer.validated_data.get("network_version")
agent = serializer.validated_data.get("agent")
node_type = serializer.validated_data.get("type")
if agent is None:
available_agents = (
Agent.objects.annotate(network_num=Count("node__network"))
.annotate(node_num=Count("node"))
.filter(
schedulable=True,
type=agent_type,
network_num__lt=F("capacity"),
node_num__lt=F("node_capacity"),
organization=request.user.organization,
)
.order_by("node_num")
)
if len(available_agents) > 0:
agent = available_agents[0]
else:
raise NoResource
else:
if not request.user.is_operator:
raise PermissionDenied
node_count = Node.objects.filter(agent=agent).count()
if node_count >= agent.node_capacity or not agent.schedulable:
raise NoResource
node = Node(
network_type=network_type,
agent=agent,
network_version=network_version,
user=request.user,
organization=request.user.organization,
type=node_type,
)
node.save()
create_node.delay(str(node.id))
response = NodeIDSerializer(data={"id": str(node.id)})
if response.is_valid(raise_exception=True):
return Response(
response.validated_data, status=status.HTTP_201_CREATED
)
def create(self, request):
"""
Create Node
:param request: create parameter
:return: node ID
:rtype: uuid
"""
serializer = NodeCreateBody(data=request.data)
if serializer.is_valid(raise_exception=True):
#self._validate_organization(request)
name = serializer.validated_data.get("name")
type = serializer.validated_data.get("type")
urls = serializer.validated_data.get("urls")
organization = serializer.validated_data.get("organization")
org = Organization.objects.get(id=organization)
if org:
pass
else:
raise NoResource
nodes = {
"type": type,
"Specs": [name]
}
CryptoConfig(org.name).update(nodes)
CryptoGen(org.name).extend()
self._generate_config(type, org.name, name, urls.split(":")[2])
msp, tls, cfg = self._conversion_msp_tls_cfg(type, org.name, name)
node = Node(
name=name,
org=org,
urls=urls,
type=type,
msp=msp,
tls=tls,
config_file=cfg
)
node.save()
response = NodeIDSerializer(data=node.__dict__)
if response.is_valid(raise_exception=True):
return Response(
response.validated_data, status=status.HTTP_201_CREATED
)
def create(self, request):
"""
Create Node
Create node
"""
serializer = NodeCreateBody(data=request.data)
if serializer.is_valid(raise_exception=True):
self._validate_organization(request)
agent_type = serializer.validated_data.get("agent_type")
network_type = serializer.validated_data.get("network_type")
network_version = serializer.validated_data.get("network_version")
agent = serializer.validated_data.get("agent")
node_type = serializer.validated_data.get("type")
ca = serializer.validated_data.get("ca", {})
if agent is None:
available_agents = (Agent.objects.annotate(
network_num=Count("node__network")).annotate(
node_num=Count("node")).filter(
schedulable=True,
type=agent_type,
network_num__lt=F("capacity"),
node_num__lt=F("node_capacity"),
organization=request.user.organization,
).order_by("node_num"))
if len(available_agents) > 0:
agent = available_agents[0]
else:
raise NoResource
else:
if not request.user.is_operator:
raise PermissionDenied
node_count = Node.objects.filter(agent=agent).count()
if node_count >= agent.node_capacity or not agent.schedulable:
raise NoResource
fabric_ca = None
if node_type == FabricNodeType.Ca.name.lower():
ca_body = {}
admin_name = ca.get("admin_name")
admin_password = ca.get("admin_password")
# If found tls type ca server under this organization,
# will cause resource exists error
ca_server_type = ca.get("type",
FabricCAServerType.Signature.value)
if ca_server_type == FabricCAServerType.TLS.value:
exist_ca_server = Node.objects.filter(
organization=request.user.organization,
ca__type=FabricCAServerType.TLS.value,
).count()
if exist_ca_server > 0:
raise ResourceExists
hosts = ca.get("hosts", [])
if admin_name:
ca_body.update({"admin_name": admin_name})
if admin_password:
ca_body.update({"admin_password": admin_password})
fabric_ca = FabricCA(**ca_body,
hosts=hosts,
type=ca_server_type)
fabric_ca.save()
node = Node(
network_type=network_type,
agent=agent,
network_version=network_version,
user=request.user,
organization=request.user.organization,
type=node_type,
ca=fabric_ca,
)
node.save()
agent_config_file = request.build_absolute_uri(
agent.config_file.url)
node_detail_url = reverse("node-detail", args=[str(node.id)])
node_detail_url = request.build_absolute_uri(node_detail_url)
node_file_upload_api = reverse("node-files", args=[str(node.id)])
node_file_upload_api = request.build_absolute_uri(
node_file_upload_api)
operate_node.delay(
str(node.id),
AgentOperation.Create.value,
agent_config_file=agent_config_file,
node_detail_url=node_detail_url,
node_file_upload_api=node_file_upload_api,
)
response = NodeIDSerializer({"id": str(node.id)})
return Response(response.data, status=status.HTTP_201_CREATED)
def save_rawpoint(request):
out = []
status_code = 200
if request.method != 'POST':
pretty_json = json.dumps(
{
'error':
str(request.method) + ' call does not exist on this URI'
},
indent=4)
response = HttpResponse(pretty_json,
content_type="application/json",
status=400)
response['Access-Control-Allow-Origin'] = '*'
return response
try:
data = json.loads(request.body)
except Exception as e:
out = {
'satus': 3,
'status': str(e.args),
'status_explain': 'unable to parse json from POST payload'
}
status_code = 400
return JsonResponse(out, safe=False, status=status_code)
i = 0
for d in data:
i = i + 1
try:
point = Rawpoint()
point.payload = d['payload']
try:
point.gw = Gateway.objects.get(mac=d['gw_mac'])
except Exception as e:
pass
try:
point.gateway_serial = d['gateway_serial']
except Exception as e:
pass
try:
node = Node.objects.get(node_id=d['node_id'])
node.last_rawpoint = timezone.now()
node.save()
except Exception as e:
print("Creating new Node with node_id " + d['node_id'])
node = Node(node_id=d['node_id'],
nodetype=NodeType.objects.get(name='unknown'),
owner=User.objects.get(username='******'))
node.last_rawpoint = timezone.now()
node.save()
point.node = node
try:
d['rssi']
point.rssi = d['rssi']
except Exception as e:
point.rssi = None
try:
point.seq_number = d['seq_number']
except Exception as e:
point.seq_number = None
try:
d['snr']
point.snr = d['snr']
except Exception as e:
point.snr = None
try:
d['rowid']
except Exception as e:
d['rowid'] = i
point.timestamp = datetime.fromtimestamp(d['timestamp'], pytz.utc)
point.save()
out.append({
'rowid': d['rowid'],
'status': 1,
'status_human': 'OK'
})
except Exception as e:
out.append({
'status': 2,
'status_explain': str(e.args),
'point_data': d,
'rowid': i
})
status_code = 400
return JsonResponse(out, safe=False, status=status_code)
def create(self, request):
"""
Create Node
Create node
"""
serializer = NodeCreateBody(data=request.data)
if serializer.is_valid(raise_exception=True):
self._validate_organization(request)
agent_type = serializer.validated_data.get("agent_type")
network_type = serializer.validated_data.get("network_type")
network_version = serializer.validated_data.get("network_version")
agent = serializer.validated_data.get("agent")
node_type = serializer.validated_data.get("type")
ca = serializer.validated_data.get("ca")
peer = serializer.validated_data.get("peer")
if agent is None:
available_agents = (Agent.objects.annotate(
network_num=Count("node__network")).annotate(
node_num=Count("node")).filter(
schedulable=True,
type=agent_type,
network_num__lt=F("capacity"),
node_num__lt=F("node_capacity"),
organization=request.user.organization,
).order_by("node_num"))
if len(available_agents) > 0:
agent = available_agents[0]
else:
raise NoResource
else:
if not request.user.is_operator:
raise PermissionDenied
node_count = Node.objects.filter(agent=agent).count()
if node_count >= agent.node_capacity or not agent.schedulable:
raise NoResource
fabric_ca = None
fabric_peer = None
peer_ca_list = []
if node_type == FabricNodeType.Ca.name.lower():
fabric_ca = self._save_fabric_ca(request, ca)
elif node_type == FabricNodeType.Peer.name.lower():
fabric_peer, peer_ca_list = self._save_fabric_peer(
request, peer)
node = Node(
network_type=network_type,
agent=agent,
network_version=network_version,
user=request.user,
organization=request.user.organization,
type=node_type,
ca=fabric_ca,
peer=fabric_peer,
)
node.save()
agent_config_file = request.build_absolute_uri(
agent.config_file.url)
node_detail_url = reverse("node-detail", args=[str(node.id)])
node_detail_url = request.build_absolute_uri(node_detail_url)
node_file_upload_api = reverse("node-files", args=[str(node.id)])
node_file_upload_api = request.build_absolute_uri(
node_file_upload_api)
operate_node.delay(
str(node.id),
AgentOperation.Create.value,
agent_config_file=agent_config_file,
node_detail_url=node_detail_url,
node_file_upload_api=node_file_upload_api,
peer_ca_list=json.dumps(peer_ca_list),
)
response = NodeIDSerializer({"id": str(node.id)})
return Response(response.data, status=status.HTTP_201_CREATED)
