CMDB--服务端
CMDB--服务端
服务端数据处理流程图：
比较好关于cmdb的文章：http://blog.uinnova.cn/articles/2015/04/23/1429791021932.html
一：服务端将客户端推送的数据写入临时表中：
关注的点：
1、客户端返回的数据：
A：cmdb服务端接收到数据的时候，需要对数据的进行合法性验证。防止非法数据的写入我们的数据库中。
主要是验证主要字段：['sn','asset_id','asset_type']
如果写入临时表中的数据，管理员并没有进行审批。如果下次客户端还进行推送的话，临时表是否需要实时更新？
可以将临时表内的数据，实时和客户端收集数据保持一致。
B:本文是如果临时表中有了该条数据之后，再次推送的时候，不接收该数据，直至管理员将该数据推送到正式库中的时候，在进行更新。
主要通过以下orm语句实现该方法：model.xxxx.objects.get_or_create()来实现，如果存在该条数据，不进行创建，只是查询。否则创建该条数据。
二：分析代码
客户端没有asset_id
整个流程：
首先我们看下view.py对于客户端第一次发送的数据的处理函数。
1 @csrf_exempt
2 def asset_with_no_asset_id(request):
3 '''
4 处理客户端没有会写asset_id的数据。
5 :param request:请求句柄。
6 :return: 返回客户端数据。
7 '''
8 if request.method == 'POST':#处理POST请求
9 ass_handler = core.Asset(request)#实例化core模块里的Asset类的对象。
10 res = ass_handler.get_asset_id_by_sn()#对推送的数据进行比对，判断数据是否合法、写入、临时表中有数据的不进行更新和插入。并返回用户的信息。
11
12 # return render(request,'assets/acquire_asset_id_test.html',{'response':res})
13 return HttpResponse(json.dumps(res))#给客户端返回数据，不报错则返回的是带有asset_id和提示信息。
该函数主要做了2件事情：
1、初始化对象：初始化core模块的中Asset类的对象，我们来看下初始化都做了什么？
1 class Asset(object):
2 def __init__(self,request):
3 '''
4 功能：该函数主要是客户端推送数据进行处理。
5 :param request: 客户端请求句柄
6 '''
7 self.request = request#客户端请求句柄
8 self.mandatory_fields = ['sn','asset_id','asset_type'] #must contains 'sn' , 'asset_id' and 'asset_type' 合法验证字段。
9 self.field_sets = {
10 'asset':['manufactory'],
11 'server':['model','cpu_count','cpu_core_count','cpu_model','raid_type','os_type','os_distribution','os_release'],
12 'networkdevice':[]
13 }
14 self.response = {#客户端回馈信息。包含错误信息以及其他。
15 'error':[],
16 'info':[],
17 'warning':[]
18 }
并没有操作什么。
2、通过上面初始化的对象调用：get_asset_id_by_sn函数，一起看下该函数都做什么。
1 def get_asset_id_by_sn(self):
2 '''
3 功能：该函数主要检测客户端推送数据有效性以及如果合法插入对应的临时表中操作。
4 :return: 返回客户端信息。
5 '''
6 '''When the client first time reports it's data to Server,it doesn't know it's asset id yet,so it will come to the server asks for the asset it first,then report the data again '''
7 data = self.request.POST.get("asset_data")#获取客户端推送信息。
8 response = {}#客户端返回信息。
9 if data:#判断data数据是否为空。
10 try:
11 data = json.loads(data)#json反序列化。
12 if self.mandatory_check(data,only_check_sn=True): # 检测数据推送合法性，是否有我们要字段。the asset is already exist in DB,just return it's asset id to client
13 response = {'asset_id': self.asset_obj.id}#第一推送的数据，上面检测函数（mandatory_check）返回false。
14 else:
15 if hasattr(self,'waiting_approval'):#判断当前类中是否有字段：waiting_approval，经过if的检测之后，第一次推送数据最后会设置标识：self.waiting_approval = True
16 response = {'needs_aproval': "this is a new asset,needs IT admin's approval to create the new asset id."}
17 self.clean_data = data#获取数据。
18 self.save_new_asset_to_approval_zone()#写入临时表中。
19 print(response)#返回客户端信息。
20 else:#处理不含有：waiting_approval标识位，返回客户端推送数据中数据非法(不含有对应的必需字段。)
21 response = self.response#返回给客户端。
22 except ValueError as e:#如果进行data反序列化的时候报ValueError处理。
23 self.response_msg('error','AssetDataInvalid', str(e))#给客户端返回对用错误信息。
24 response = self.response
25
26 else:#如果推送的数据是空的，处理。
27 self.response_msg('error','AssetDataInvalid', "The reported asset data is not valid or provided")
28 response = self.response
29 return response#返回对应客户端的回执信息。
更新小知识点：for else。
如果for部分正常执行完，而不是break 等异常退出的时候，就会执行else部分的内容。
如上函数用：mandatory_check ——>该函数主要作用是检测客户端推送数据的合法性验证。
1 def mandatory_check(self,data,only_check_sn=False):
2 '''
3 该函数主要检测客户端推送的数据是否合法即：是否包含我们定义的字段：['sn','asset_id','asset_type']
4 :param data: 客户端推送的数据。
5 :param only_check_sn: 标识位：第一次数据检测。
6 :return: 返回错误信息或者True or False。
7 '''
8 for field in self.mandatory_fields:#循环必需关键字段。
9 if field not in data:#如果必需关键字段不在客户端推送数据key中，表示客户端推送数据含有非法数据。并返回错误。注意：是所有检测完，也就是说给客户端返回多条错误信息。
10 self.response_msg('error','MandatoryCheckFailed', "The field [%s] is mandatory and not provided in your reporting data" % field)
11 else:
12 if self.response['error']:return False#response字段中 error有错误信息，给前端返回错误信息。终止函数。
13 try:
14
15 if not only_check_sn:#如果客户端推送带有asset_id的话，检测正式数据库中是否有该对象。
16 self.asset_obj = models.Asset.objects.get(id=int(data['asset_id']),sn=data['sn'])#获取对象
17 else:
18 self.asset_obj = models.Asset.objects.get(sn=data['sn'])#当标识位：only_check_sn为True的时候，尝试获取相应的对象。
19 return True#存在该对象返回True
20 except ObjectDoesNotExist as e:#第一次推送的数据肯定在正式库中不存在，所以会抛出如下异常。
21 self.response_msg('error','AssetDataInvalid', "Cannot find asset object in DB by using asset id [%s] and SN [%s] " % (data['asset_id'],data['sn']))
22 self.waiting_approval = True#设置待审批标识位。
23 return False#返回false。
如上函数还调用：save_new_asset_to_approval_zone——>该函数主要作用是将第一次客户端推送的数据，写入临时表中。
1 def save_new_asset_to_approval_zone(self):
2 '''
3 功能：该函数主要作用是将前面函数判定第一次客户端推送的数据写入临时表中。需要注意：该函数用orm插入语句是：get_or_create，
4 表示如果临时表中有该条数据，不进行重复和更新插入。如果没有就插入。至于更新当审批进行正式库的时候，进行更新。
5 :return: 返回True。
6 '''
7 '''When find out it is a new asset, will save the data into approval zone to waiting for IT admin's approvals'''
8 asset_sn = self.clean_data.get('sn')
9 asset_already_in_approval_zone = models.NewAssetApprovalZone.objects.get_or_create(sn=asset_sn,
10 data=json.dumps(self.clean_data),
11 manufactory=self.clean_data.get('manufactory'),
12 model=self.clean_data.get('model'),
13 asset_type=self.clean_data.get('asset_type'),
14 ram_size=self.clean_data.get('ram_size'),
15 cpu_model=self.clean_data.get('cpu_model'),
16 cpu_count=self.clean_data.get('cpu_count'),
17 cpu_core_count=self.clean_data.get('cpu_core_count'),
18 os_distribution=self.clean_data.get('os_distribution'),
19 os_release=self.clean_data.get('os_release'),
20 os_type=self.clean_data.get('os_type'),
21
22 )
23 return True
对于客户端没有asset_id的情况推送数据流程：
服务器端->接收数据->检测数据是否为空->不为空-->检测数据合法性（是否包含必需字段）-->检测客户端推送的数据是否在正式库asset中存在
如果不存在-->设置self.waiting_approval 带审批的标志位为true。--->然后检测标识位self.waiting_approval，插入对应的临时表中。
---------------------------->self.waiting_approval标识位不存在或者为false--->返回数据不合法错误（必须字段不包含。）
如果存在-->给客户端返回asset_id（response = {'asset_id': self.asset_obj.id}）--->下次客户端推送直接推送到/asset/report/。进行数据的检测更新。
客户端有asset_id
临时表的数据写入正式库
首先需要管理员进行批准才能让临时表的数据写入正式库中，首先看下后台页面：
上节博客，我们介绍django_admin的定制，当我们勾选需要入库的资产的时候，点击GO的时候执行我们在后台admin.py定义的action，代码如下：
1 def approve_selected_rows(self,request,queryset):
2 '''
3 功能:该函数主要管理员在后台进行数据提交的时候，处理action数据的提交的处理，以后后台接收的url。
4 :param request: 请求对象。
5 :param queryset: orm的查询对象。
6 :return: 重定向到后台一个页面和视图函数。
7 '''
8 selected = request.POST.getlist(admin.ACTION_CHECKBOX_NAME)#获取当前action提交的数据。
9 print("---select",selected)
10 return HttpResponseRedirect("/asset/new_assets/approval/?ids=%s" % (",".join(selected)))
11 # def approve_selected_objects(modeladmin, request, queryset):
12 # selected = request.POST.getlist(admin.ACTION_CHECKBOX_NAME)
13 # ct = ContentType.objects.get_for_model(queryset.model)
14 # return HttpResponseRedirect("/asset/new_assets/approval/？ids=%s" % ( ",".join(selected)))
15 approve_selected_rows.short_description = "批准入库"
当我们点击GO的图标的时候，后台处理的url为：/asset/new_assets/approval/?ids=%s 以GET请求进行传递参数。
查看后台视图处理的函数：因为这次get请求，所以只注释get部分
1 def new_assets_approval(request):
2 '''
3 功能:该函数主要作用是处理我们提交的数据写入正式库中。
4 :param request: 客户端请求对象。
5 :return:
6 '''
7 if request.method == 'POST':
8 request.POST = request.POST.copy()##如果想修改request.POST中的数据时候，直接无法修改，否则报错。可以拷贝一份进行修改。
9 approved_asset_list = request.POST.getlist('approved_asset_list')#获取客户端
10 approved_asset_list = models.NewAssetApprovalZone.objects.filter(id__in=approved_asset_list)
11
12 response_dic = {}
13 for obj in approved_asset_list:
14 request.POST['asset_data'] = obj.data
15 ass_handler = core.Asset(request)
16 if ass_handler.data_is_valid_without_id():
17 ass_handler.data_inject()
18 obj.approved = True
19 obj.save()
20
21 response_dic[obj.id] = ass_handler.response
22 return render(request, 'assets/new_assets_approval.html',
23 {'new_assets': approved_asset_list, 'response_dic': response_dic})
24 else:#处理get请求的。
25 ids = request.GET.get('ids')#获取ids数值。
26 id_list = ids.split(',')#后去推送过来的临时表中的id值。
27 new_assets = models.NewAssetApprovalZone.objects.filter(id__in=id_list)#查询符合id_list的id值得临时表中的对象。
28 return render(request, 'assets/new_assets_approval.html', {'new_assets': new_assets})#返回客户端资产列表页面以及批准的资产清单。
转到的页面如下：
当点击yes的时候，会向/asset/new_assets/approval 以表单，POST方式发送请求。即上面函数的POST部分将被执行。
代码如下：
1 def new_assets_approval(request):
2 '''
3 功能:该函数主要作用是处理我们提交的数据写入正式库中。
4 :param request: 客户端请求对象。
5 :return:
6 '''
7 if request.method == 'POST':
8 request.POST = request.POST.copy()##如果想修改request.POST中的数据时候，直接无法修改，否则报错。可以拷贝一份进行修改。
9 approved_asset_list = request.POST.getlist('approved_asset_list')#获取客户端推送过来的临时表中的对象id值。
10 approved_asset_list = models.NewAssetApprovalZone.objects.filter(id__in=approved_asset_list)#去临时表中查询对应的数据对象。
11
12 response_dic = {}#客户端返回信息。
13 for obj in approved_asset_list:#循环对象。
14 request.POST['asset_data'] = obj.data#设置请求对象request的asset_data字段为：临时表中的对应的对象的data值。
15 '''
16 为什么要设置这个request对象呢？而不是直接调用obj呢？
17 是因为之前客户端推送数据是命令行，进行推送，而且是通过request对象来获取对应的对应数据，而我们审批的过程的都是
18 通过浏览器的get或者post进行，为了同时兼容浏览器和命令行推送数据，所以对request对象的设置。
19 '''
20 ass_handler = core.Asset(request)#初始化对象。将我们定义的request传入对象中。
21 if ass_handler.data_is_valid_without_id():#正常检测通过返回的是True
22 ass_handler.data_inject()#将上面函数创建的字段：self.clean_data包含asset_id的分别插入不同的表中。
23 obj.approved = True#临时表中，批准一栏显示通过。
24 obj.save()#写入数据库。
25
26 response_dic[obj.id] = ass_handler.response#将id写入回馈信息。临时表的id
27 return render(request, 'assets/new_assets_approval.html',
28 {'new_assets': approved_asset_list, 'response_dic': response_dic})#并将结果反馈到批准页面。
29 else:#处理get请求的。
30 ids = request.GET.get('ids')#获取ids数值。
31 id_list = ids.split(',')#后去推送过来的临时表中的id值。
32 new_assets = models.NewAssetApprovalZone.objects.filter(id__in=id_list)#查询符合id_list的id值得临时表中的对象。
33 return render(request, 'assets/new_assets_approval.html', {'new_assets': new_assets})#返回客户端资产列表页面以及批准的资产清单。
然后看下调用函数：data_is_valid_without_id
1 def data_is_valid_without_id(self):
2 '''when there's no asset id in reporting data ,goes through this function fisrt'''
3 '''
4 功能：设置字段：self.asset_obj elf.clean_data 检测数据的合法性。
5 '''
6 data = self.request.POST.get("asset_data")#上个函数已经设置了asset_data的属性。即临时表的数据。
7 if data:#如果数据不为空。
8 try:
9 data = json.loads(data)#获取数据。
10 asset_obj = models.Asset.objects.get_or_create(sn=data.get('sn'),name=data.get('sn')) #往asset表中插入数据，当没有asset_id。push asset id into reporting data before doing the mandatory check
11 ''''
12 如上语句只是，为获取asset_id ，name而插入表中值，方便其他关联的表，进行调用asset_id ，asset表中只有asset_id和name是唯一必须有的值。
13 '''
14 data['asset_id'] = asset_obj[0].id#给asset_data 设置asset_id，方便关联表的调用。
15 self.mandatory_check(data)#检测数据的有效性。并给对象建立字段：self.asset_obj 即目前要插入正式库的asset对象。
16 self.clean_data = data#设置字段，包含asset_id
17 if not self.response['error']:#mandatory_check函数的设置的错误信息字段，验证没问题。该字段为空。
18 return True#返回True.
19 except ValueError as e:#如果data不是json格式处理方式。
20 self.response_msg('error','AssetDataInvalid', str(e))#返回错误信息，
21 else:
22 self.response_msg('error','AssetDataInvalid', "The reported asset data is not valid or provided")#数据为空的情况。
调用函数：mandatory_check
1 def mandatory_check(self,data,only_check_sn=False):
2 for field in self.mandatory_fields:
3 if field not in data:
4 self.response_msg('error','MandatoryCheckFailed', "The field [%s] is mandatory and not provided in your reporting data" % field)
5 else:
6 if self.response['error']:return False
7 try:
8 if not only_check_sn:
9 self.asset_obj = models.Asset.objects.get(id=int(data['asset_id']),sn=data['sn'])
10 else:
11 self.asset_obj = models.Asset.objects.get(sn=data['sn'])
12 return True
13
14 except ObjectDoesNotExist as e:
15 self.response_msg('error','AssetDataInvalid', "Cannot find asset object in DB by using asset id [%s] and SN [%s] " % (data['asset_id'],data['sn']))
16 self.waiting_approval = True #设置这条资产为等待批准
17 return False
接下来我们看比较重要的调用函数：data_inject--->数据的注入。即将self.cleandata写入我们的正式表中。
1 def data_inject(self):
2 '''
3 当函数：data_is_valid_without_id返回true，该函数被执行，该函数主要判断self.clean_data是否为新数据需要插入正式表还是旧数据需要更新数据库。
4 :return: 无。
5 '''
6 '''save data into DB,the data_is_valid() must returns True before call this function'''
7 #self.reformat_components('slot',self.clean_data.get('ram'))
8 #self.reformat_components('name',self.clean_data.get('nic'))
9 if self.__is_new_asset():#执行方法：__is_new_asset 判断 self.clean_data是需要插入还是更新操作。true表示需要插入。
10 print('\033[32;1m---new asset,going to create----\033[0m')
11 self.create_asset()#执行插入函数。
12 else:#asset already already exist , just update it，执行更新操作。
13 print('\033[33;1m---asset already exist ,going to update----\033[0m')
14
15 self.update_asset()#更新数据库中数据。
然后我们一起看下：__is_new_asset做了什么判断：
1 def __is_new_asset(self): 2 ''' 3 功能：该函数主要使用反射原理和django的orm反向查询（反向查询的另一张表时，查询的隐藏的列是另一张表的名字。） 4 :return: True表示数据需要插入，反之为数据需要更新。 5 ''' 6 if not hasattr(self.asset_obj, self.clean_data['asset_type']):#new asset 7 #利用反射，检测self.asset_obj的是否有隐藏列：server、networkdevice等设备类型，如果有说明他不是新数据，他已经写入数据库了，需要更新。反之是新数据需要插入。 8 #@if not hasattr(self.asset_obj, 'server'):#new asset 9 return True#True表示数据需要插入 10 else: 11 return False#False表示数据需要更新。
在看下函数：create_asset和update_asset
create_asset---->创建新的资产：
1 def create_asset(self): 2 ''' 3 相当于路由系统，通过反射来找到对应的插入函数，并执行该函数。 4 invoke asset create function according to it's asset type 5 :return:无。 6 ''' 7 func = getattr(self,'_create_%s' % self.clean_data['asset_type'])#通过self.clean_data中的asset_type字段判断获取那个函数并执行该函数。 8 #func = getattr(self,'_create_server' % self.clean_data['asset_type']) 9 create_obj =func()#执行该函数。
比如执行：_create_server方法，如下：
1 def _create_server(self): 2 ''' 3 功能：该函数主要作用是插入asset_type为server的各个资产信息的函数。 4 :return: 无。 5 ''' 6 self.__create_server_info()#插入server表。 7 self.__create_or_update_manufactory() 8 9 self.__create_cpu_component() 10 self.__create_disk_component() 11 self.__create_nic_component() 12 self.__create_ram_component()
其中：self.__create_server_info()
1 def __create_server_info(self,ignore_errs=False):
2 '''
3 插入server表的功能函数。
4 :param ignore_errs: 是否忽略错误的标识位。
5 :return: 返回插入server表的对象。
6 '''
7 try:
8 self.__verify_field(self.clean_data,'model',str)#对必要字段进行检测，并初始化我们想要的数据类型。
9 #self.__verify_field(self.clean_data,'test_key',str)
10 if not len(self.response['error']) or ignore_errs == True: #如果没有返回错误信息时候，将进行数据的插入。 no processing when there's no error happend
11 data_set = {
12 'asset_id' : self.asset_obj.id,
13 'raid_type': self.clean_data.get('raid_type'),
14 'model': self.clean_data.get('model'),
15 'os_type':self.clean_data.get('os_type'),
16 'os_distribution':self.clean_data.get('os_distribution'),
17 'os_release':self.clean_data.get('os_release'),
18 }
19
20 obj = models.Server(**data_set)
21 #obj.asset.model = self.clean_data.get('model')
22 obj.save()
23 return obj#返回插入数据的对象。
24 except Exception as e:
25 self.response_msg('error','ObjectCreationException','Object [server] %s' % str(e) )#插入报错，
如上是插入server表信息。
更新manufactory（厂商）的表的代码：如果临时表中有该字段，如果正式表中无字段则插入。
1 def __create_or_update_manufactory(self,ignore_errs=False):
2 '''
3 该函数是：更新和插入厂商表格。
4 :param ignore_errs: 忽略错误的标识位。
5 :return: 无。
6 '''
7 try:
8 self.__verify_field(self.clean_data,'manufactory',str)#对manufactory必须字段的检测，并建立相应的数据类型。
9 manufactory = self.clean_data.get('manufactory')#上面不抛错误，表示该字段存在。
10 if not len(self.response['error']) or ignore_errs == True: # 错误信息中无错误字段，或者忽略错误。no processing when there's no error happend
11 obj_exist = models.Manufactory.objects.filter(manufactory=manufactory)#获取对应的厂商对象。
12 if obj_exist:#如果正式表中厂商表中有该对象。
13 obj = obj_exist[0]#该对象赋值给obj
14 else:#create a new one 如果该厂商的是新的字段，需要往对应的厂商表中插入该值。
15 obj = models.Manufactory(manufactory=manufactory)#创建对象，
16 obj.save()#写入数据库中。
17 self.asset_obj.manufactory = obj#建立厂商字段。
18 self.asset_obj.save()# 更新正式库：asset表中对应的厂商字段。
19 except Exception as e:#如果在上面的检测的过程中报错。
20 self.response_msg('error','ObjectCreationException','Object [manufactory] %s' % str(e) )#页面回馈的相应的错误信息。
写入cpu表数据：
1 def __create_cpu_component(self,ignore_errs=False):
2 '''
3 cpu 表的数据插入。
4 :param ignore_errs: 忽视错误标识位。
5 :return: 返回想的cpu对象。
6 '''
7 try:
8 self.__verify_field(self.clean_data,'model',str)#分别对型号‘cpu个数核核心数进行合法性验证以及初始化相应的类型。
9 self.__verify_field(self.clean_data,'cpu_count',int)
10 self.__verify_field(self.clean_data,'cpu_core_count',int)
11 if not len(self.response['error']) or ignore_errs == True: # 上面的合法性检测通过之后。no processing when there's no error happend
12 data_set = {
13 'asset_id' : self.asset_obj.id,
14 'cpu_model': self.clean_data.get('cpu_model'),
15 'cpu_count':self.clean_data.get('cpu_count'),
16 'cpu_core_count':self.clean_data.get('cpu_core_count'),
17 }#数据类型。
18
19 obj = models.CPU(**data_set)#创建对象
20 obj.save()#写入数据库。
21 log_msg = "Asset[%s] --> has added new [cpu] component with data [%s]" %(self.asset_obj,data_set)
22 self.response_msg('info','NewComponentAdded',log_msg)
23 return obj
写入disk表代码：
1 def __create_disk_component(self):
2 '''
3 功能：该函数主要功能是插入磁盘表数据。
4 :return:
5 '''
6 disk_info = self.clean_data.get('physical_disk_driver')#获取磁盘接口
7 if disk_info:
8 for disk_item in disk_info:#因为是多个磁盘，所以需要循环。
9 try:
10 self.__verify_field(disk_item,'slot',str)
11 self.__verify_field(disk_item,'capacity',float)
12 self.__verify_field(disk_item,'iface_type',str)
13 self.__verify_field(disk_item,'model',str)
14 if not len(self.response['error']): #no processing when there's no error happend
15 data_set = {
16 'asset_id' : self.asset_obj.id,
17 'sn': disk_item.get('sn'),
18 'slot':disk_item.get('slot'),
19 'capacity':disk_item.get('capacity'),
20 'model':disk_item.get('model'),
21 'iface_type':disk_item.get('iface_type'),
22 'manufactory':disk_item.get('manufactory'),
23 }
24
25 obj = models.Disk(**data_set)#创建对象。
26 obj.save()#写入数据库中。
27
28 except Exception as e:#初始化相应的数据报错。并返回相应的错误信息。
29 self.response_msg('error','ObjectCreationException','Object [disk] %s' % str(e) )
30 else:#磁盘列表为空。
31 self.response_msg('error','LackOfData','Disk info is not provied in your reporting data' )
网卡的数据的录入：
1 def __create_nic_component(self):
2 '''
3 该函数主要是内存表的数据的写入。
4 :return:
5 '''
6 nic_info = self.clean_data.get('nic')#获取网卡信息字典。
7 if nic_info:#不为空。
8 for nic_item in nic_info:#一台服务器有可能多个网卡。
9 try:
10 self.__verify_field(nic_item,'macaddress',str)#mac地址的检测和数据类型转换。
11 if not len(self.response['error']): #无返回错误信息。no processing when there's no error happend
12 data_set = {
13 'asset_id' : self.asset_obj.id,
14 'name': nic_item.get('name'),
15 'sn': nic_item.get('sn'),
16 'macaddress':nic_item.get('macaddress'),
17 'ipaddress':nic_item.get('ipaddress'),
18 'bonding':nic_item.get('bonding'),
19 'model':nic_item.get('model'),
20 'netmask':nic_item.get('netmask'),
21 }#数据类型。
22
23 obj = models.NIC(**data_set)#建立对象，
24 obj.save()#存入数据库
25
26 except Exception as e:#检测合法的错误信息。
27 self.response_msg('error','ObjectCreationException','Object [nic] %s' % str(e) )
28 else:#如果网卡信息为空，输出的报错信息。
29 self.response_msg('error','LackOfData','NIC info is not provied in your reporting data' )
内存表数据的插入：
1 def __create_ram_component(self):
2 '''
3 功能：该函数主要是内存的信息的录入。
4 :return: 无。
5 '''
6 ram_info = self.clean_data.get('ram')#获取对应的内存信息。
7 if ram_info:#信息不为空。
8 for ram_item in ram_info:#循环内存信息。
9 try:
10 self.__verify_field(ram_item,'capacity',int)#对容量进行检测和数据转换。
11 if not len(self.response['error']): #无错误信息时。no processing when there's no error happend
12 data_set = {
13 'asset_id' : self.asset_obj.id,
14 'slot': ram_item.get("slot"),
15 'sn': ram_item.get('sn'),
16 'capacity':ram_item.get('capacity'),
17 'model':ram_item.get('model'),
18 }
19
20 obj = models.RAM(**data_set)#建立对象
21 obj.save()#插入数据库
22
23 except Exception as e:#如果检测内存合法报错，
24 self.response_msg('error','ObjectCreationException','Object [ram] %s' % str(e) )
25 else:#如果内存信息为空，返回相应的错误信息。
26 self.response_msg('error','LackOfData','RAM info is not provied in your reporting data' )
至此临时表的数据写入，结束。
浙公网安备 33010602011771号