class IntfUsagePerf(db.Model, PerfMixin):
'''接口占用指标'''
__tablename__ = 'perf_intfusage'
intftype = db.Column(db.Integer)
intftotal = db.Column(db.Integer)
intfused = db.Column(db.Integer)
intfusage = db.Column(db.Float)
class AlarmVar(db.Model):
__tablename__ = 'alarm_vars'
id = db.Column(db.Integer, primary_key=True)
alarm_id = db.Column(db.Integer, db.ForeignKey("alarms.id"))
name = db.Column(db.String(60))
value = db.Column(db.String(100))
alarm = db.relationship('Alarm', backref=db.backref('vars', order_by=id))
class PonUsagePerf(db.Model, PerfMixin):
"""PON口占用率"""
__tablename__ = 'perf_ponusage'
pontotal = db.Column(db.Integer)
ponused = db.Column(db.Integer)
ponusage = db.Column(db.Float)
@property
def ponfree(self):
return 1.0 - self.ponusage
class NodeEoc(NodeMixin, db.Model):
""" Eocs """
__tablename__ = 'node_eocs'
esn = db.Column(db.String(50)) # ESN
contact_tel = db.Column(db.String(50)) # 联系电话
install_time = db.Column(db.DateTime) # 安装时间
ctrl_id = db.Column(db.Integer, db.ForeignKey('node_onus.id'))
cpes = db.relationship("NodeCpe", backref="eoc")
ports = db.relationship("PortEoc", backref="eoc")
@property
def cpe_count_plan(self):
return object_session(self).\
scalar(
select([func.count(NodeCpe.id)]).\
where(and_(NodeCpe.ctrl_id==self.id, NodeCpe.area_id != None))
)
@property
def cpe_count_unplan(self):
return object_session(self).\
scalar(
select([func.count(NodeCpe.id)]).\
where(and_(NodeCpe.ctrl_id==self.id, NodeCpe.area_id == None))
)
def __unicode__(self):
return u'<EOC %s>' % self.alias
@staticmethod
def export_columns():
return [
'name', 'alias', 'addr', 'area.branch_name', 'vendor.alias',
'mask', 'snmp_comm', 'snmp_wcomm', 'snmp_ver', 'remark'
]
@staticmethod
def eoc_entrance():
eoc_entrance = db.session.query(NodeEoc.addr, Area.alias).outerjoin(
Area,
Area.branch == NodeEoc.area_id).filter(Area.area_type == 4).all()
eoc_entrance_dict = {}
for ip, entrance_name in eoc_entrance:
if eoc_entrance_dict.get(ip):
eoc_entrance_dict[ip] = eoc_entrance_dict[ip] + [entrance_name]
else:
eoc_entrance_dict[ip] = [entrance_name]
return eoc_entrance_dict
class Manager(db.Model):
"""EMS"""
__tablename__ = 'managers'
id = db.Column(db.Integer, primary_key=True)
cityid = db.Column(db.Integer)
dn = db.Column(db.String(100))
name = db.Column(db.String(40))
alias = db.Column(db.String(100))
addr = db.Column(db.String(100))
status = db.Column(db.Integer)
created_at = db.Column(db.DateTime)
updated_at = db.Column(db.DateTime)
class OperationLog(db.Model):
__tablename__ = 'oplogs'
id = db.Column(db.Integer, primary_key=True)
session = db.Column(db.String(50))
uid = db.Column(db.Integer, db.ForeignKey("users.id"))
action = db.Column(db.String(200))
success = db.Column(db.Integer)
summary = db.Column(db.String(200))
module = db.Column(db.String(200))
terminal_ip = db.Column(db.String(20))
created_at = db.Column(db.DateTime, default=datetime.now)
updated_at = db.Column(db.DateTime, default=datetime.now)
user = db.relationship("User")
def __unicode__(self):
return u'<操作日志 %s>' % self.user.name
class Role(db.Model):
"""角色表"""
__tablename__ = 'roles'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(50), unique=True)
description = db.Column(db.String(100))
created_at = db.Column(db.DateTime, default=datetime.now)
updated_at = db.Column(db.DateTime, default=datetime.now)
permissions = db.relation('Permission', backref="roles", secondary=roles_permissions)
def __repr__(self):
return '<Role%r>' % self.name
def __unicode__(self):
return u'<角色 %s>' % self.name
class CpuMemPerf(db.Model, PerfMixin):
'''节点CPU内存指标'''
__tablename__ = 'perf_cpumem'
cpuavg = db.Column(db.Float)
cpumax = db.Column(db.Float)
memavg = db.Column(db.Float)
memmax = db.Column(db.Float)
tempavg = db.Column(db.Float)
tempmax = db.Column(db.Float)
powerstate = db.Column(db.Integer)
fanstate = db.Column(db.Integer)
class BoardPerf(db.Model, PerfMixin):
'''版卡指标'''
__tablename__ = 'perf_board'
boardidx = db.Column(db.Integer)
boardtype = db.Column(db.Integer)
cpuavg = db.Column(db.Float)
cpumax = db.Column(db.Float)
memavg = db.Column(db.Float)
memmax = db.Column(db.Float)
tempavg = db.Column(db.Float)
tempmax = db.Column(db.Float)
class NodeCpe(NodeMixin, db.Model):
""" Cpes """
__tablename__ = 'node_cpes'
esn = db.Column(db.String(50)) # ESN
contact_tel = db.Column(db.String(50)) # 联系电话
install_time = db.Column(db.DateTime) # 安装时间
card_id = db.Column(db.String(50)) # 身份证号
ctrl_id = db.Column(db.Integer, db.ForeignKey('node_eocs.id'))
def __unicode__(self):
return u'<CPE %s>' % self.alias
@staticmethod
def export_columns():
return [
'name', 'alias', 'mac', 'eoc.addr', 'area.entrance_name',
'snmp_comm', 'snmp_wcomm', 'snmp_ver', 'remark'
]
class SubSystem(db.Model):
""" 子采集 """
__tablename__ = 'subsystems'
id = db.Column(db.Integer, primary_key=True)
rdn = db.Column(db.String(100))
name = db.Column(db.String(100))
alias = db.Column(db.String(100))
host = db.Column(db.String(100))
status = db.Column(db.Integer)
descr = db.Column(db.String(200))
started_at = db.Column(db.DateTime) # 启动采集的时间
updated_at = db.Column(db.DateTime, onupdate=datetime.now)
def __unicode__(self):
return u'<子采集 %s>' % self.alias
class Vendor(db.Model):
"""Device Vendor"""
__tablename__ = 'vendors'
id = db.Column(db.Integer, primary_key=True)
cityid = db.Column(db.Integer)
type_id = db.Column(db.Integer) # 貌似没用?
name = db.Column(db.String(100))
alias = db.Column(db.String(100))
url = db.Column(db.String(100)) # 厂商主页
is_valid = db.Column(db.Integer)
models = db.relationship("Model", backref="vendor")
@property
def node_count(self):
return object_session(self).\
scalar(
select([func.count(Node.id)]).\
where(Node.vendor_id==self.id)
)
@property
def node_status1_count(self):
return object_session(self).\
scalar(
select([func.count(Node.id)]).\
where(and_(Node.vendor_id==self.id, Node.status == 1))
)
@property
def node_status2_count(self):
return object_session(self).\
scalar(
select([func.count(Node.id)]).\
where(and_(Node.vendor_id==self.id, Node.status == 2))
)
@property
def node_status3_count(self):
return object_session(self).\
scalar(
select([func.count(Node.id)]).\
where(and_(Node.vendor_id==self.id, Node.status == 3))
)
@property
def node_status4_count(self):
return object_session(self).\
scalar(
select([func.count(Node.id)]).\
where(and_(Node.vendor_id==self.id, Node.status == 4))
)
def __unicode__(self):
return u'<厂商 %s>' % self.alias
class Metric(db.Model):
''' 指标管理 '''
__tablename__ = 'metrics'
id = db.Column(db.Integer, primary_key=True)
grp = db.Column(db.String(60))
name = db.Column(db.String(60))
alias = db.Column(db.String(100))
calc = db.Column(db.String(60))
unit = db.Column(db.String(200))
format = db.Column(db.String(200))
descr = db.Column(db.String(200))
def __unicode__(self):
return u'<指标 %s>' % self.alias
class Miboid(db.Model):
"""Mib 文件"""
__tablename__ = 'miboids'
id = db.Column(db.Integer, primary_key=True)
mib = db.Column(db.String(100))
grp = db.Column(db.String(40))
name = db.Column(db.String(100))
alias = db.Column(db.String(100))
oid = db.Column(db.String(100))
is_valid = db.Column(db.Integer)
remark = db.Column(db.String(100))
def __unicode__(self):
return u'<Mib %s>' % self.alias
class PingPerf(db.Model, PerfMixin):
'''节点PING指标'''
__tablename__ = 'perf_ping'
rtavg = db.Column(db.Float)
rtmax = db.Column(db.Float)
rtmin = db.Column(db.Float)
lossavg = db.Column(db.Float)
lossmax = db.Column(db.Float)
stdevavg = db.Column(db.Float)
stdevmax = db.Column(db.Float)
class NodeHost(NodeMixin, db.Model):
""" Hosts """
__tablename__ = 'node_hosts'
os_type = db.Column(db.String(100))
ifaces = db.Column(db.String(200)) #
cpu_info = db.Column(db.String(200))
mem_info = db.Column(db.String(200))
swap_info = db.Column(db.String(200))
disk_info = db.Column(db.String(200))
worker_num = db.Column(db.Integer) # 采集进程数
def __unicode__(self):
return u'<服务器 %s>' % self.alias
class AlarmKnowledge(db.Model):
__tablename__ = 'alarm_knowledges'
id = db.Column(db.Integer, primary_key=True)
class_id = db.Column(db.Integer, db.ForeignKey("alarm_classes.id"))
probable_cause = db.Column(db.String(200))
resolvent = db.Column(db.String(200))
probability = db.Column(db.Integer)
apply_count = db.Column(db.Integer)
created_at = db.Column(db.DateTime)
updated_at = db.Column(db.DateTime)
alarm_class = db.relation('AlarmClass')
def __unicode__(self):
return u'<告警知识库 %s>'% self.alarm_alias
class Module(db.Model):
"""采集模块表"""
__tablename__ = 'modules'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(20))
alias = db.Column(db.String(40))
period = db.Column(db.Integer) # 采集周期, 单位: minute
retries = db.Column(db.Integer) # 重试次数, 单位: 次
timeout = db.Column(db.Integer) # 超时, 单位: second
remark = db.Column(db.String(100))
def __unicode__(self):
return u'<采集模块 %s>' % self.alias
class Monitor(db.Model):
"""监控器表"""
__tablename__ = 'monitors'
id = db.Column(db.Integer, primary_key=True)
category = db.Column(db.String(20)) # 分类, 不关联
vendor = db.Column(db.String(20)) # 厂商,
sysoid = db.Column(db.String(100)) # 不关联
match = db.Column(db.String(100)) # 匹配规则
modid = db.Column(db.Integer, db.ForeignKey('modules.id'))
mib = db.Column(db.String(20))
remark = db.Column(db.String(100))
module = db.relation('Module')
def __unicode__(self):
return u'<监控器>'
class NodeOnu(NodeMixin, db.Model):
""" ONU """
__tablename__ = 'node_onus'
ctrl_id = db.Column(db.Integer, db.ForeignKey('node_olts.id'))
eocs = db.relationship("NodeEoc", backref="onu")
ports = db.relationship("PortOnu", backref="onu")
def __unicode__(self):
return u'<ONU %s>' % self.alias
@staticmethod
def export_columns():
return [
'name', 'alias', 'addr', 'mac', 'olt.addr', 'area.entrance_name',
'snmp_comm', 'snmp_wcomm', 'snmp_ver', 'remark'
]
class AlarmJournal(db.Model):
__tablename__ = 'alarm_journals'
id = db.Column(db.Integer, primary_key=True)
uid = db.Column(db.Integer, db.ForeignKey("users.id"))
alarm_id = db.Column(db.Integer, db.ForeignKey("alarms.id"))
title = db.Column(db.String(200))
summary = db.Column(db.String(200))
created_at = db.Column(db.DateTime)
user = db.relationship('User')
alarm = db.relationship('Alarm', backref=db.backref('journals', order_by=id))
class PerfMixin(object):
id = db.Column(db.Integer, primary_key=True)
@declared_attr
def nodeid(cls):
return db.Column(db.Integer, db.ForeignKey("nodes.id"))
@declared_attr
def node(cls):
return db.relation('Node')
sampleyear = db.Column(db.Integer)
samplemonth = db.Column(db.Integer)
sampleday = db.Column(db.Integer)
sampleweekday = db.Column(db.Integer)
samplehour = db.Column(db.Integer)
sampletime = db.Column(db.DateTime)
class SecurityLog(db.Model):
__tablename__ = 'seclogs'
id = db.Column(db.Integer, primary_key=True)
session = db.Column(db.String(50))
uid = db.Column(db.Integer, db.ForeignKey("users.id"))
success = db.Column(db.Integer)
summary = db.Column(db.String(200))
terminal_ip = db.Column(db.String(20))
login_at = db.Column(db.DateTime)
logout_at = db.Column(db.DateTime)
user = db.relationship("User")
@hybrid_property
def time(self):
if u'登录' in self.summary:
return self.login_at
else:
return self.logout_at
def __unicode__(self):
return u'<安全日志 %s>' % self.user.name
class UserGroup(db.Model):
"""用户组"""
__tablename__ = 'user_groups'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100))
role_id = db.Column(db.Integer, db.ForeignKey('roles.id'))
domain_id = db.Column(db.Integer, db.ForeignKey('domains.id'))
created_at = db.Column(db.DateTime, default=datetime.now)
updated_at = db.Column(db.DateTime, default=datetime.now)
role = db.relation('Role')
domain = db.relation('Domain')
def __unicode__(self):
return u'<用户组 %s>' % self.name
class SysOid(db.Model):
"""设备系统OID"""
__tablename__ = 'sysoids'
id = db.Column(db.Integer, primary_key=True)
sysoid = db.Column(db.String(100))
model_id = db.Column(db.Integer, db.ForeignKey('models.id'))
disco = db.Column(db.String(20)) # 发现模块
mib = db.Column(db.String(20)) # mib文件, 从 miboids.mib 中选
remark = db.Column(db.String(100))
model = db.relation('Model')
def __unicode__(self):
return u'<SysOid %s>' % self.sysoid
class AlarmSeverity(db.Model):
__tablename__ = 'alarm_severities'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(60))
alias = db.Column(db.String(60))
color = db.Column(db.String(60))
sound = db.Column(db.String(60))
remark = db.Column(db.String(60))
@property
def count(self):
from tango.login import current_user
from nodes.models import Node, Area
query = object_session(self).query(func.count(Alarm.id)).filter(Alarm.severity == self.id)
if not current_user.is_province_user:
query = query.outerjoin(Node, Node.id == Alarm.node_id)
query = query.outerjoin(Area, Area.id == Node.area_id)
query = query.filter(current_user.domain.clause_permit)
return query.scalar()
@staticmethod
def name2id(name):
name_dict = {
'clear' : 0,
'indeterminate' : 1,
'warning' : 2,
'minor' : 3,
'major' : 4,
'critical' : 5
}
return name_dict[name] if name in name_dict else -1
def __repr__(self):
return '<Severity%r>' % self.name
def __unicode__(self):
return u'<告警级别 %s>' % self.alias
class IntfTrafficPerf(db.Model, PerfMixin):
'''接口流量流速指标'''
__tablename__ = 'perf_intftraffic'
intfidx = db.Column(db.Integer)
intftype = db.Column(db.Integer)
ifspeed = db.Column(db.Integer) # 带宽
# 接收
inoctets = db.Column(db.Float) # 均值速率
inoctetsmax = db.Column(db.Float) # 峰值速率
inpkts = db.Column(db.Integer) # 报文均值
inpktsmax = db.Column(db.Integer) # 报文峰值
inucastpkts = db.Column(db.Integer) # 单播报文
inmulticastpkts = db.Column(db.Float) # 多播报文
inbroadcastpkts = db.Column(db.Float) # 广播报文
innucastpkts = db.Column(db.Float) # 非单播报文
indiscards = db.Column(db.Float) # 丢包
inerrors = db.Column(db.Float) # 错误包
inunknownprotos = db.Column(db.Float) # 未知协议包
# 发送
outoctets = db.Column(db.Float)
outoctetsmax = db.Column(db.Float)
outpkts = db.Column(db.Float)
outpktsmax = db.Column(db.Float)
outucastpkts = db.Column(db.Float)
outmulticastpkts = db.Column(db.Float)
outbroadcastpkts = db.Column(db.Float)
outnucastpkts = db.Column(db.Float)
outdiscards = db.Column(db.Float)
outerrors = db.Column(db.Float)
#====================================
# 定义计算指标
#====================================
# <流量>
@property #接收流量
def inoctetstotal(self):
return self.inoctets * 3600 / 8
@property #发送流量
def outoctetstotal(self):
return self.outoctets * 3600 / 8
@property #总流量
def octetstotal(self):
return self.inoctetstotal + self.outoctetstotal
# <速率>
@property #总峰值速率
def octets(self):
return self.inoctets + self.outoctets
@property #总均值速率
def octetsmax(self):
return self.inoctetsmax + self.outoctetsmax
# <带宽利用率>
@property #接收带宽利用率
def inbwusage(self):
return (self.inoctets / self.ifspeed) * 100
@property #发送带宽利用率
def outbwusage(self):
return (self.outoctets / self.ifspeed) * 100
@property # 总带宽利用率
def bwusage(self):
return self.inbwusage + self.outbwusage
@property #接收带宽利用率峰值
def inbwusagemax(self):
return (self.inoctetsmax / self.ifspeed) * 100
@property #发送带宽利用率峰值
def outbwusagemax(self):
return (self.outoctetsmax / self.ifspeed) * 100
@property # 总带宽利用率峰值
def bwusagemax(self):
return self.inbwusagemax + self.outbwusagemax
class History(db.Model):
__tablename__ = 'histories'
id = db.Column(db.Integer, primary_key=True)
alarm_key = db.Column(db.String(200))
alarm_class = db.Column(db.String(60))
alarm_name = db.Column(db.String(60))
alarm_alias = db.Column(db.String(200))
alarm_state = db.Column(db.Integer)
manager = db.Column(db.String(60))
agent = db.Column(db.String(60))
node_id = db.Column(db.Integer, db.ForeignKey('nodes.id'))
node_class = db.Column(db.Integer)
node_alias = db.Column(db.String(200))
node_addr = db.Column(db.String(100))
node_managed_state = db.Column(db.Integer)
node_prod_state = db.Column(db.Integer)
source = db.Column(db.String(60))
source_class = db.Column(db.String(60))
severity = db.Column(db.Integer)
summary = db.Column(db.String(200))
state_change = db.Column(db.DateTime)
first_occurrence = db.Column(db.DateTime)
last_occurrence = db.Column(db.DateTime)
occur_count = db.Column(db.Integer)
priority = db.Column(db.Integer)
graded = db.Column(db.Integer)
location = db.Column(db.String(100))
service = db.Column(db.String(100))
customer = db.Column(db.String(100))
sequence_no = db.Column(db.Integer)
x733_type = db.Column(db.Integer)
probable_cause = db.Column(db.String(200))
specific_problem = db.Column(db.String(200))
additional_information = db.Column(db.String(200))
proposed_repaire_action = db.Column(db.String(200))
acked = db.Column(db.Integer)
acked_user = db.Column(db.String(60))
acked_time = db.Column(db.DateTime)
acked_note = db.Column(db.String(60))
cleared = db.Column(db.Integer)
cleared_user = db.Column(db.String(60))
cleared_time = db.Column(db.DateTime)
cleared_note = db.Column(db.String(100))
order_state = db.Column(db.Integer)
root_cause = db.Column(db.Integer)
cause_type = db.Column(db.Integer)
extended_attrs = db.Column(db.Text)
created_at = db.Column(db.DateTime)
updated_at = db.Column(db.DateTime)
#node = db.relation('Node', backref=db.backref("histories"))
def __unicode__(self):
return u'<历史告警 %s>'% self.alarm_alias
class AlarmClass(db.Model):
"""告警类型表"""
__tablename__ = 'alarm_classes'
id = db.Column(db.Integer, primary_key=True)
category_id = db.Column(db.Integer, db.ForeignKey('categories.id'))
name = db.Column(db.String(60))
alias = db.Column(db.String(60))
severity = db.Column(db.Integer)
probable_cause = db.Column(db.String(200))
specific_problem = db.Column(db.String(200))
additional_info = db.Column(db.String(200))
remark = db.Column(db.String(100))
created_at = db.Column(db.DateTime)
updated_at = db.Column(db.DateTime)
category = db.relation('Category')
def __repr__(self):
return '<AlarmClass %r>' % self.name
def __unicode__(self):
return u'<告警类型 %s>'% self.alias
class PonPowerPerf(db.Model, PerfMixin):
""" PON口光功率 """
__tablename__ = 'perf_ponpower'
ponidx = db.Column(db.Integer)
rxpoweravg = db.Column(db.Float)
rxpowermax = db.Column(db.Float)
rxpowermin = db.Column(db.Float)
txpoweravg = db.Column(db.Float)
txpowermax = db.Column(db.Float)
txpowermin = db.Column(db.Float)
currentavg = db.Column(db.Float)
currentmax = db.Column(db.Float)
currentmin = db.Column(db.Float)
voltageavg = db.Column(db.Float)
voltagemax = db.Column(db.Float)
voltagemin = db.Column(db.Float)
tempavg = db.Column(db.Float)
tempmax = db.Column(db.Float)
tempmin = db.Column(db.Float)
