资产表
# _*_coding:utf-8_*_
__author__ = \'jieli\'
from assets.myauth import UserProfile
from django.db import models
class Asset(models.Model):
asset_type_choices = (
(\'server\', u\'服务器\'),
(\'networkdevice\', u\'网络设备\'),
(\'storagedevice\', u\'存储设备\'),
(\'securitydevice\', u\'安全设备\'),
(\'securitydevice\', u\'机房设备\'),
# (\'switch\', u\'交换机\'),
# (\'router\', u\'路由器\'),
# (\'firewall\', u\'防火墙\'),
# (\'storage\', u\'存储设备\'),
# (\'NLB\', u\'NetScaler\'),
# (\'wireless\', u\'无线AP\'),
(\'software\', u\'软件资产\'),
# (\'others\', u\'其它类\'),
\'\'\'
为什么我不把这些删除？，我就想告诉你，经历了N次的改变才到这一步，这就是你交钱来学的意义
你写了5万行代码就是多少行代码的水平，首先有一个资产类型
\'\'\'
)
asset_type = models.CharField(choices=asset_type_choices, max_length=64, default=\'server\')
name = models.CharField(max_length=64, unique=True)
\'\'\'
这个资产名，是自己起的名字，这个可不可以重复？不可以重复
也不允许他重复，自己起是为了作为唯一标识的，
\'\'\'
sn = models.CharField(u\'资产SN号\', max_length=128, unique=True)
\'\'\'
sn号是比较唯一的
\'\'\'
manufactory = models.ForeignKey(\'Manufactory\', verbose_name=u\'制造商\', null=True, blank=True)
\'\'\'
制造商就那么几个，所以把他做成外键，blank=True是什么意思？null=True？收据库里可以为空，如果你在dgone里
数据库允许为空，但是admin不允许为空，如果你要想让这个字段不为一个必填，就必须null=True, blank=True这两个同时用
\'\'\'
# model = models.ForeignKey(\'ProductModel\', verbose_name=u\'型号\')
# model = models.CharField(u\'型号\',max_length=128,null=True, blank=True )
management_ip = models.GenericIPAddressField(u\'管理IP\', blank=True, null=True)
\'\'\'
我什么管理ip就没有写唯一？
因为为也不知道你要存什么，也可以通过外网ip连接，也可以通过管理皮地址连接，虚拟机和物理机关联起来
\'\'\'
contract = models.ForeignKey(\'Contract\', verbose_name=u\'合同\', null=True, blank=True)
\'\'\'
合同可能是买一批机器，我做了个外键，运维也不关注合同的具体条款
\'\'\'
trade_date = models.DateField(u\'购买时间\', null=True, blank=True)
expire_date = models.DateField(u\'过保修期\', null=True, blank=True)
\'\'\'
可以实现自动过保
\'\'\'
price = models.FloatField(u\'价格\', null=True, blank=True)
\'\'\'
运维关注价格干啥？成本核算，这些钱花那了，那些业务线花了我多钱，每个业务线到底用了我多少成本？
\'\'\'
business_unit = models.ForeignKey(\'BusinessUnit\', verbose_name=u\'所属业务线\', null=True, blank=True)
tags = models.ManyToManyField(\'Tag\', blank=True)
\'\'\'
允许给资产打标签，虽然你刚才你有一些业务线的划分，但是有一些资产你就是想随手做一些标记？
为了区分的时候好区分，一台机器可以加很多标记，以后从各个维度去看你的组织架构
\'\'\'
admin = models.ForeignKey(\'UserProfile\', verbose_name=u\'资产管理员\', null=True, blank=True)
\'\'\'
刚买来的资产，也可以没有资产管理员
\'\'\'
idc = models.ForeignKey(\'IDC\', verbose_name=u\'IDC机房\', null=True, blank=True)
\'\'\'
也可以为空，因为还没有进机房
\'\'\'
status_choices = ((0, \'在线\'),
(1, \'已下线\'),
(2, \'未知\'),
(3, \'故障\'),
(4, \'备用\'),
)
status = models.SmallIntegerField(choices=status_choices, default=0)
# status = models.ForeignKey(\'Status\', verbose_name = u\'设备状态\',default=1)
# Configuration = models.OneToOneField(\'Configuration\',verbose_name=\'配置管理\',blank=True,null=True)
memo = models.TextField(u\'备注\', null=True, blank=True)
create_date = models.DateTimeField(blank=True, auto_now_add=True)
update_date = models.DateTimeField(blank=True, auto_now=True)
\'\'\'
auto_now=True？每次变更自动更新
\'\'\'
class Meta:
verbose_name = \'资产总表\'
verbose_name_plural = "资产总表"
\'\'\'
先忘记它，你一会就知道了？
\'\'\'
def __str__(self):
return \'<id:%s name:%s>\' % (self.id, self.name)
服务器设备
class Server(models.Model):
"""服务器设备"""
asset = models.OneToOneField(\'Asset\')
\'\'\'
server和资产能一对多吗？一个资产只能属于一个server，不能属于多个server
一对一为什么不写一张表上了？
因为这样冗余字段就太多了，服务器和存储设备很多冗余字段不一样很多属性不一样
前十周就够写脚本用了，想往上走不能光靠忽悠
\'\'\'
sub_assset_type_choices = (
(0, \'PC服务器\'),
(1, \'刀片机\'),
(2, \'小型机\'),
)
created_by_choices = (
(\'auto\', \'Auto\'),
(\'manual\', \'Manual\'),
)
\'\'\'
为什么要区分手动还是自动？
1、默认自动添加的绝对准确不需要修改
2、手动添加的有可能错误允许修改，每个资产都有管理ip，但是机柜、软件没有
\'\'\'
sub_asset_type = models.SmallIntegerField(choices=sub_assset_type_choices, verbose_name="服务器类型", default=0)
\'\'\'
在汽车之家就没有区分，直接用服务器型号区分，
\'\'\'
created_by = models.CharField(choices=created_by_choices, max_length=32,
default=\'auto\') # auto: auto created, manual:created manually
hosted_on = models.ForeignKey(\'self\', related_name=\'hosted_on_server\', blank=True, null=True)
# for vitural server
\'\'\'
虚拟机和物理机关联起来,就是为了虚拟机做的，但是我一直没有用上这个，多少物理机上要多少台虚拟机，虚拟机也有
SN物理机上也有SN但是不一样，虚拟机有固定的ID 自动生成sn号抓不出来,关联自己
\'\'\'
# sn = models.CharField(u\'SN号\',max_length=128)
# management_ip = models.CharField(u\'管理IP\',max_length=64,blank=True,null=True)
# manufactory = models.ForeignKey(verbose_name=u\'制造商\',max_length=128,null=True, blank=True)
\'\'\'
每个资产都有生产厂商、管理IP、SN(但是机柜、软件没有)，所以我把他提成了公共信息
\'\'\'
model = models.CharField(verbose_name=u\'型号\', max_length=128, null=True, blank=True)
# 若有多个CPU，型号应该都是一致的，故没做ForeignKey
\'\'\'
model怎么存到了server？
每个资产都用型号，应该存到公共里面，那我为什么存到这里呢？
记住这？这里是有一个坑的，你先记住，后面你就明白了
\'\'\'
# nic = models.ManyToManyField(\'NIC\', verbose_name=u\'网卡列表\')
# disk
raid_type = models.CharField(u\'raid类型\', max_length=512, blank=True, null=True)
\'\'\'
服务器都有radi类型
\'\'\'
# physical_disk_driver = models.ManyToManyField(\'Disk\', verbose_name=u\'硬盘\',blank=True,null=True)
# raid_adaptor = models.ManyToManyField(\'RaidAdaptor\', verbose_name=u\'Raid卡\',blank=True,null=True)
# memory
# ram_capacity = models.IntegerField(u\'内存总大小GB\',blank=True)
# ram = models.ManyToManyField(\'Memory\', verbose_name=u\'内存配置\',blank=True,null=True)
\'\'\'
在汽车之家就是这关联的，硬盘椰丝直接和server表关联的 ？我真的忘记了，一会讲到硬盘的时候再来讲？？？？
之前写的多对多，是不是有问题呀！就会出现一个硬盘属于多个机器，应该是一对多，每个硬盘应该去关联server
\'\'\'
os_type = models.CharField(u\'操作系统类型\', max_length=64, blank=True, null=True)
os_distribution = models.CharField(u\'发型版本\', max_length=64, blank=True, null=True)
os_release = models.CharField(u\'操作系统版本\', max_length=64, blank=True, null=True)
class Meta:
verbose_name = \'服务器\'
verbose_name_plural = "服务器"
# together = ["sn", "asset"]
def __str__(self):
return \'%s sn:%s\' % (self.asset.name, self.asset.sn)
安全设备
class SecurityDevice(models.Model):
"""安全设备"""
asset = models.OneToOneField(\'Asset\')
sub_assset_type_choices = (
(0, \'防火墙\'),
(1, \'入侵检测设备\'),
(2, \'互联网网关\'),
(4, \'运维审计系统\'),
)
sub_asset_type = models.SmallIntegerField(choices=sub_assset_type_choices, verbose_name="服务器类型", default=0)
def __str__(self):
return self.asset.id
网络设备
class SecurityDevice(models.Model):
"""安全设备"""
asset = models.OneToOneField(\'Asset\')
sub_assset_type_choices = (
(0, \'防火墙\'),
(1, \'入侵检测设备\'),
(2, \'互联网网关\'),
(4, \'运维审计系统\'),
)
sub_asset_type = models.SmallIntegerField(choices=sub_assset_type_choices, verbose_name="服务器类型", default=0)
def __str__(self):
return self.asset.id
class NetworkDevice(models.Model):
"""网络设备"""
asset = models.OneToOneField(\'Asset\')
sub_assset_type_choices = (
(0, \'路由器\'),
(1, \'交换机\'),
(2, \'负载均衡\'),
(4, \'VPN设备\'),
)
sub_asset_type = models.SmallIntegerField(choices=sub_assset_type_choices, verbose_name="网络设备类型", default=0)
vlan_ip = models.GenericIPAddressField(u\'VlanIP\', blank=True, null=True)
intranet_ip = models.GenericIPAddressField(u\'内网IP\', blank=True, null=True)
"""
intranet_ip和内网IP有什么区别？这是我们网络工程师说让存两个
"""
# sn = models.CharField(u\'SN号\',max_length=128,unique=True)
# manufactory = models.CharField(verbose_name=u\'制造商\',max_length=128,null=True, blank=True)
model = models.CharField(u\'型号\', max_length=128, null=True, blank=True)
firmware = models.ForeignKey(\'Software\', blank=True, null=True)
"""
固件是寄生在资产上面的，
"""
port_num = models.SmallIntegerField(u\'端口个数\', null=True, blank=True)
device_detail = models.TextField(u\'设置详细配置\', null=True, blank=True)
class Meta:
verbose_name = \'网络设备\'
verbose_name_plural = "网络设备"
软件资产
class Software(models.Model):
\'\'\'
only save software which company purchased
花了钱的才叫资产
\'\'\'
sub_assset_type_choices = (
(0, \'OS\'),
(1, \'办公\开发软件\'),
(2, \'业务软件\'),
)
sub_asset_type = models.SmallIntegerField(choices=sub_assset_type_choices, verbose_name="服务器类型", default=0)
license_num = models.IntegerField(verbose_name="授权数")
# os_distribution_choices = ((\'windows\',\'Windows\'),
# (\'centos\',\'CentOS\'),
# (\'ubuntu\', \'Ubuntu\'))
# type = models.CharField(u\'系统类型\', choices=os_types_choice, max_length=64,help_text=u\'eg. GNU/Linux\',default=1)
# distribution = models.CharField(u\'发型版本\', choices=os_distribution_choices,max_length=32,default=\'windows\')
version = models.CharField(u\'软件/系统版本\', max_length=64, help_text=u\'eg. CentOS release 6.5 (Final)\', unique=True)
# language_choices = ((\'cn\',u\'中文\'),
# (\'en\',u\'英文\'))
# language = models.CharField(u\'系统语言\',choices = language_choices, default=\'cn\',max_length=32)
# #version = models.CharField(u\'版本号\', max_length=64,help_text=u\'2.6.32-431.3.1.el6.x86_64\' )
def __str__(self):
return self.version
class Meta:
verbose_name = \'软件/系统\'
verbose_name_plural = "软件/系统"
\'\'\'机柜和服务器是怎样关联的\'\'\'
CPU组件
class Software(models.Model):
\'\'\'
only save software which company purchased
花了钱的才叫资产
\'\'\'
sub_assset_type_choices = (
(0, \'OS\'),
(1, \'办公\开发软件\'),
(2, \'业务软件\'),
)
sub_asset_type = models.SmallIntegerField(choices=sub_assset_type_choices, verbose_name="服务器类型", default=0)
license_num = models.IntegerField(verbose_name="授权数")
# os_distribution_choices = ((\'windows\',\'Windows\'),
# (\'centos\',\'CentOS\'),
# (\'ubuntu\', \'Ubuntu\'))
# type = models.CharField(u\'系统类型\', choices=os_types_choice, max_length=64,help_text=u\'eg. GNU/Linux\',default=1)
# distribution = models.CharField(u\'发型版本\', choices=os_distribution_choices,max_length=32,default=\'windows\')
version = models.CharField(u\'软件/系统版本\', max_length=64, help_text=u\'eg. CentOS release 6.5 (Final)\', unique=True)
# language_choices = ((\'cn\',u\'中文\'),
# (\'en\',u\'英文\'))
# language = models.CharField(u\'系统语言\',choices = language_choices, default=\'cn\',max_length=32)
# #version = models.CharField(u\'版本号\', max_length=64,help_text=u\'2.6.32-431.3.1.el6.x86_64\' )
def __str__(self):
return self.version
class Meta:
verbose_name = \'软件/系统\'
verbose_name_plural = "软件/系统"
\'\'\'机柜和服务器是怎样关联的\'\'\'
class CPU(models.Model):
"""CPU组件"""
asset = models.OneToOneField(\'Asset\')
\'\'\'
CPU怎么没写ForeignKey？怎么写的OneToOneField
内存可以是不同型号，不同大小
但是cpu型号不一能，那肯定就炸了，
型号主频肯定一样的，还有必要存多条吗？
这样就节省了空间，一堆一关联资产
所以这里就不用一对多了
\'\'\'
cpu_model = models.CharField(u\'CPU型号\', max_length=128, blank=True)
cpu_count = models.SmallIntegerField(u\'物理cpu个数\')
cpu_core_count = models.SmallIntegerField(u\'cpu核数\')
memo = models.TextField(u\'备注\', null=True, blank=True)
create_date = models.DateTimeField(auto_now_add=True)
update_date = models.DateTimeField(blank=True, null=True)
\'\'\'
为什么没有联合唯一，因为我已经逐条唯一了
\'\'\'
class Meta:
verbose_name = \'CPU部件\'
verbose_name_plural = "CPU部件"
def __str__(self):
return self.cpu_model
内存组件
class RAM(models.Model):
"""内存组件"""
asset = models.ForeignKey(\'Asset\')
sn = models.CharField(u\'SN号\', max_length=128, blank=True, null=True)
model = models.CharField(u\'内存型号\', max_length=128)
slot = models.CharField(u\'插槽\', max_length=64)
capacity = models.IntegerField(u\'内存大小(MB)\')
memo = models.CharField(u\'备注\', max_length=128, blank=True, null=True)
create_date = models.DateTimeField(blank=True, auto_now_add=True)
update_date = models.DateTimeField(blank=True, null=True)
\'\'\'
内存:SN 内存 插槽
因为没有唯一，所以要进行联合唯一，没有唯一就无法区分
通过查槽和aseet联合唯一，可以是不同型号，不同大小
\'\'\'
def __str__(self):
return \'%s:%s:%s\' % (self.asset_id, self.slot, self.capacity)
class Meta:
verbose_name = \'RAM\'
verbose_name_plural = "RAM"
unique_together = ("asset", "slot")
auto_create_fields = [\'sn\', \'slot\', \'model\', \'capacity\']
硬盘组件
class Disk(models.Model):
"""硬盘组件"""
asset = models.ForeignKey(\'Asset\')
\'\'\'asset
硬盘我什么要关联asset?
统一调用的方式，你这个硬盘我还要判断从server表里面判断，
硬盘只有服务器有硬盘，网卡和硬盘配件是同一级别，
我掉网卡就知道通过asset，那硬盘也要从asset去掉
\'\'\'
sn = models.CharField(u\'SN号\', max_length=128, blank=True, null=True)
"""
硬盘里为什么要有SN，服务器有服务器的SN,硬盘有硬盘的SN，没有SN如何保修？，我都没写成比填
因为有时候SN有时候抓不到，尤其是虚拟机就更抓不到了，
"""
slot = models.CharField(u\'插槽位\', max_length=64)
"""
通过曹位和sn联合唯一索引,因为单独通过插槽是无法定位的
"""
# manufactory = models.CharField(u\'制造商\', max_length=64,blank=True,null=True)
model = models.CharField(u\'磁盘型号\', max_length=128, blank=True, null=True)
capacity = models.FloatField(u\'磁盘容量GB\')
disk_iface_choice = (
(\'SATA\', \'SATA\'),
(\'SAS\', \'SAS\'),
(\'SCSI\', \'SCSI\'),
(\'SSD\', \'SSD\'),
)
iface_type = models.CharField(u\'接口类型\', max_length=64, choices=disk_iface_choice, default=\'SAS\')
memo = models.TextField(u\'备注\', blank=True, null=True)
create_date = models.DateTimeField(blank=True, auto_now_add=True)
update_date = models.DateTimeField(blank=True, null=True)
"""
硬盘配件更新了，这个时间就更新，比如硬盘坏了，需要更换
"""
auto_create_fields = [\'sn\', \'slot\', \'manufactory\', \'model\', \'capacity\', \'iface_type\']
"""
硬件收集过来，有那些配件可以自动更新，这是我自己加的，程序里面没有
"""
class Meta:
unique_together = ("asset", "slot")
"""
unique_together联合唯一，如何保证disk是唯一的，如果更换硬盘如何判断硬盘
"""
verbose_name = \'硬盘\'
verbose_name_plural = "硬盘"
def __str__(self):
return \'%s:slot:%s capacity:%s\' % (self.asset_id, self.slot, self.capacity)
"""
硬盘里面为什么要有SN
"""
网卡组件
class NIC(models.Model):
"""网卡组件"""
asset = models.ForeignKey(\'Asset\')
\'\'\'
一台serveassetr有多个IP，网络设备，路由器、交换机、防火墙的
还是单独建一个表字段不一样，
不能用server，只能用asset的原因？
网络设备和网卡是一样的为什么不能存到一张表里面？
管理资产最好最大限度的存在一起，
什么是一对一？
一对一的限制只是在一张表里面不是两张表，
不会限制第二张表，程序层面上的限制，数据库层面不限制
onetonone只是限制一张表上的
\'\'\'
name = models.CharField(u\'网卡名\', max_length=64, blank=True, null=True)
sn = models.CharField(u\'SN号\', max_length=128, blank=True, null=True)
model = models.CharField(u\'网卡型号\', max_length=128, blank=True, null=True)
macaddress = models.CharField(u\'MAC\', max_length=64, unique=True)
\'\'\'
Mac不唯一就没有唯一，因为虚拟机的Mac地址经常重复，把虚拟机存进来就傻逼了，
\'\'\'
ipaddress = models.GenericIPAddressField(u\'IP\', blank=True, null=True)
\'\'\'
有很多网卡，有的网卡没IP，IP我什么不能唯一？虚拟IP，
\'\'\'
netmask = models.CharField(max_length=64, blank=True, null=True)
bonding = models.CharField(max_length=64, blank=True, null=True)
memo = models.CharField(u\'备注\', max_length=128, blank=True, null=True)
create_date = models.DateTimeField(blank=True, auto_now_add=True)
update_date = models.DateTimeField(blank=True, null=True)
def __str__(self):
return \'%s:%s\' % (self.asset_id, self.macaddress)
class Meta:
verbose_name = u\'网卡\'
verbose_name_plural = u"网卡"
# unique_together = ("asset_id", "slot")
unique_together = ("asset", "macaddress")
auto_create_fields = [\'name\', \'sn\', \'model\', \'macaddress\', \'ipaddress\', \'netmask\', \'bonding\']
Raid
class RaidAdaptor(models.Model):
"""
Raid卡
有的有，有的没有，一台机器上可以有多个Raid？可以有
"""
asset = models.ForeignKey(\'Asset\')
sn = models.CharField(u\'SN号\', max_length=128, blank=True, null=True)
slot = models.CharField(u\'插口\', max_length=64)
model = models.CharField(u\'型号\', max_length=64, blank=True, null=True)
memo = models.TextField(u\'备注\', blank=True, null=True)
create_date = models.DateTimeField(blank=True, auto_now_add=True)
update_date = models.DateTimeField(blank=True, null=True)
def __str__(self):
return self.name
class Meta:
unique_together = ("asset", "slot")
"""
asset和slot联合唯一
"""
厂商
class Manufactory(models.Model):
"""厂商"""
manufactory = models.CharField(u\'厂商名称\', max_length=64, unique=True)
support_num = models.CharField(u\'支持电话\', max_length=30, blank=True)
memo = models.CharField(u\'备注\', max_length=128, blank=True)
def __str__(self):
return self.manufactory
class Meta:
verbose_name = \'厂商\'
verbose_name_plural = "厂商"
业务线
class BusinessUnit(models.Model):
"""业务线"""
parent_unit = models.ForeignKey(\'self\', related_name=\'parent_level\', blank=True, null=True)
name = models.CharField(u\'业务线\', max_length=64, unique=True)
# contact = models.ForeignKey(\'UserProfile\',default=None)
memo = models.CharField(u\'备注\', max_length=64, blank=True)
def __str__(self):
return self.name
class Meta:
verbose_name = \'业务线\'
verbose_name_plural = "业务线"
合同
class Contract(models.Model):
"""合同"""
sn = models.CharField(u\'合同号\', max_length=128, unique=True)
name = models.CharField(u\'合同名称\', max_length=64)
memo = models.TextField(u\'备注\', blank=True, null=True)
price = models.IntegerField(u\'合同金额\')
detail = models.TextField(u\'合同详细\', blank=True, null=True)
start_date = models.DateField(blank=True)
end_date = models.DateField(blank=True)
license_num = models.IntegerField(u\'license数量\', blank=True)
create_date = models.DateField(auto_now_add=True)
update_date = models.DateField(auto_now=True)
class Meta:
verbose_name = \'合同\'
verbose_name_plural = "合同"
def __str__(self):
return self.name
IDC
class IDC(models.Model):
"""
机房
机房名称要不要唯一？肯定要唯一
"""
name = models.CharField(u\'机房名称\', max_length=64, unique=True)
memo = models.CharField(u\'备注\', max_length=128, blank=True, null=True)
def __str__(self):
return self.name
class Meta:
verbose_name = \'机房\'
verbose_name_plural = "机房"
资产标签
class Tag(models.Model):
"""
资产标签
打标签要不要唯一？肯定要唯一
"""
name = models.CharField(\'Tag name\', max_length=32, unique=True)
creator = models.ForeignKey(\'UserProfile\')
create_date = models.DateField(auto_now_add=True)
def __str__(self):
return self.name
事件日志
class EventLog(models.Model):
"""
事件
日志表 资产类型
什么是事件指向？
就是存这资产是硬盘、还是内存、还是网卡发生变更
一个资产可以有多个事件吗？
"""
name = models.CharField(u\'事件名称\', max_length=100)
event_type_choices = (
(1, u\'硬件变更\'),
(2, u\'新增配件\'),
(3, u\'设备下线\'),
(4, u\'设备上线\'),
(5, u\'定期维护\'),
(6, u\'业务上线\更新\变更\'),
(7, u\'其它\'),
)
event_type = models.SmallIntegerField(u\'事件类型\', choices=event_type_choices)
asset = models.ForeignKey(\'Asset\')
component = models.CharField(\'事件子项\', max_length=255, blank=True, null=True)
detail = models.TextField(u\'事件详情\')
date = models.DateTimeField(u\'事件时间\', auto_now_add=True)
user = models.ForeignKey(\'UserProfile\', verbose_name=u\'事件源\')
memo = models.TextField(u\'备注\', blank=True, null=True)
def __str__(self):
return self.name
class Meta:
verbose_name = \'事件纪录\'
verbose_name_plural = "事件纪录"
def colored_event_type(self):
if self.event_type == 1:
cell_html = \'<span style="background: orange;">%s</span>\'
elif self.event_type == 2:
cell_html = \'<span style="background: yellowgreen;">%s</span>\'
else:
cell_html = \'<span >%s</span>\'
return cell_html % self.get_event_type_display()
colored_event_type.allow_tags = True
colored_event_type.short_description = u\'事件类型\'
\'\'\'
自定义后台
\'\'\'