一个使用sqlalchemy定义的数据模型实例

#-*-coding:UTF-8-*-

import sysconf
#import models.db

import time
import datetime
import sqlalchemy
import sqlalchemy.orm
import sqlalchemy.ext.declarative

from sqlalchemy import Column,Integer,String,DateTime,Binary,ForeignKey,Float,BigInteger
from sqlalchemy.orm import relationship
from sqlalchemy.ext.declarative import declarative_base

#from models.db import check_and_create_schema

Base=declarative_base()

class User(Base):
__tablename__='user'
id=Column(Integer,primary_key=True)
name=Column(String(20),unique=True)
fullname=Column(String(50))
password=Column(String(20))
createtime=Column(DateTime())
updatetime=Column(DateTime())
isadmin=Column(Integer)
usergroups=relationship('UserGroupMapping',back_populates='user')
#permissions=relationship('HostUserPermission',back_populates='users')
def __repr__(self):
#return '<User id='+str(self.id)+',name='+self.name+',fullname='+self.fullname+'>'
return '<User id=%d,name=%s,fullname=%s>'%(self.id,self.name,self.fullname)

class Group(Base):
__tablename__='group'
id=Column(Integer,primary_key=True)
name=Column(String(20),unique=True)
createtime=Column(DateTime())
updatetime=Column(DateTime())
groupusers=relationship('UserGroupMapping',back_populates='group')
#permissions=relationship('HostGroupPermission',back_populates='groups')
groupsysids=relationship('SysidGroupMapping',back_populates='group')
def __repr__(self):
#return '<Group id=' + str(self.id) + ',name=' + self.name +'>'
return '<Group id=%d,name=%s>'%(self.id,self.name)

class UserGroupMapping(Base):
__tablename__='usergrouplink'
user_id= Column(Integer, ForeignKey('user.id'), primary_key=True)
group_id=Column(Integer, ForeignKey('group.id'), primary_key=True)
note=Column(String(100))
createtime=Column(DateTime())
updatetime=Column(DateTime())
user = relationship('User',back_populates='usergroups')
group = relationship('Group',back_populates='groupusers')
def __repr__(self):
#return '<UserGroupMapping user_id='+str(self.user_id)+', group_id='+str(self.group_id)+'>'
return '<UserGroupMapping user_id=%d, group_id=%d>'%(self.user_id,self.group_id)

class SysID(Base):
__tablename__='sysid'
id=Column(Integer,primary_key=True)
name=Column(String(20),unique=True)
appadmin=Column(String(20))
apppass=Column(String(20))
url=Column(String(512))
createtime=Column(DateTime())
updatetime=Column(DateTime())
slavenumber=Column(Integer)
wthome=Column(String(255))
localwthome=Column(String(255))
localbackup=Column(String(255))
envset=Column(Binary())
startcmd=Column(Binary())
stopcmd=Column(Binary())
hosts=relationship('Host',back_populates='sysid')
sysidgroups=relationship('SysidGroupMapping',back_populates='sysid')
def __repr__(self):
#return '<SysID id='+str(self.id)+',name='+self.name+',slavenumber='+str(self.slavenumber)+'>'
return '<SysID id=%d,name=%s,slavenumber=%d>'%(self.id,self.name,self.slavenumber)

class Host(Base):
__tablename__='host'
id=Column(Integer,primary_key=True)
ip=Column(String(20),unique=True)
name=Column(String(30))
systemid=Column(String(20))
servertype=Column(String(20)) # 'master':'master server','slave1':'slave 1','slave2':'slave 2','xxx':'aaa','yyy':'bbb'
createtime=Column(DateTime())
updatetime=Column(DateTime())
ostype=Column(String(10))
sysid_id=Column(Integer,ForeignKey('sysid.id'))
sysid=relationship('SysID',back_populates='hosts')
auths=relationship('Auth',back_populates='host')
cpustats=relationship('CPUStats',back_populates='host')
memstats=relationship('MemStats',back_populates='host')
diskstats=relationship('DiskStats',back_populates='host')
iostats=relationship('IOStats',back_populates='host')
#host_permissions =relationship('HostUserPermission',back_populates='hosts')
#gorup_permissions=relationship('HostGroupPermission',back_populates='hosts')
def __repr__(self):
#return '<Host id='+str(self.id)+',name='+self.name+',ip='+self.ip+',servertype='+self.servertype+'>'
return '<Host id=%d,name=%s,ip=%s,servertype=%s>'%(self.id,self.name,self.ip,self.servertype)

class Auth(Base):
__tablename__='auth'
id=Column(Integer,primary_key=True)
username=Column(String(20))
password=Column(String(20))
createtime=Column(DateTime())
updatetime=Column(DateTime())
can_sudo=Column(Integer)
host_id=Column(Integer,ForeignKey('host.id'))
host=relationship('Host',back_populates='auths')
def __repr__(self):
#return '<auth id='+str(self.id)+',username='+self.username+',sudo='+str(self.can_sudo)+'>'
return '<auth id=%d,username=%s,sudo=%d>'%(self.id,self.username,self.can_sudo)

class SysidGroupMapping(Base):
__tablename__='sysidgrouplink'
createtime=Column(DateTime())
updatetime=Column(DateTime())
permission=Column(String(10))
sysid_id=Column(Integer,ForeignKey('sysid.id'),primary_key=True)
group_id=Column(Integer,ForeignKey('group.id'),primary_key=True)
sysid=relationship('SysID',back_populates='sysidgroups')
group=relationship('Group',back_populates='groupsysids')
def __repr__(self):
#return '<SysidGroupMapping group_id='+str(self.group_id)+', sysid_id='+str(self.sysid_id)+'>'
return '<SysidGroupMapping group_id=%d, sysid_id=%d>'%(self.group_id,self.sysid_id)

class CPUStats(Base):
__tablename__='cpustats'
id=Column(Integer,primary_key=True)
createtime=Column(DateTime())
datatime=Column(DateTime())
host_id=Column(Integer,ForeignKey('host.id'),primary_key=True)
host=relationship('Host',back_populates='cpustats')
###
cpucount=Column(Integer)
lcpucount=Column(Integer)
interval=Column(Integer)
user=Column(Float)
system=Column(Float)
idle=Column(Float)
interrupt=Column(Float)
dpc=Column(Float)
iowait=Column(Float)
nice=Column(Float)
irq=Column(Float)
softirq=Column(Float)
steal=Column(Float)
guest=Column(Float)
ctx_switches=Column(BigInteger)
interrupts=Column(BigInteger)
soft_interrupts=Column(BigInteger)
syscalls=Column(BigInteger)
###
def __repr__(self):
#return '<CPUStats id='+str(self.id)+', user='+str(self.user)+', system='+str(self.system)+'>'
return '<CPUStats id=%d, user=%f system=%f>'%(self.id,self.user,self.system)

class MemStats(Base):
__tablename__='memstats'
id=Column(Integer,primary_key=True)
createtime=Column(DateTime())
datatime=Column(DateTime())
host_id=Column(Integer,ForeignKey('host.id'),primary_key=True)
host=relationship('Host',back_populates='memstats')
###
total=Column(BigInteger)
used=Column(BigInteger)
percent=Column(Float)
active=Column(BigInteger)
inactive=Column(BigInteger)
buffers=Column(BigInteger)
cached=Column(BigInteger)
shared=Column(BigInteger)
swap_total=Column(BigInteger)
swap_used=Column(BigInteger)
swap_free=Column(BigInteger)
swap_percent=Column(Float)
swap_sin=Column(BigInteger)
swap_sout=Column(BigInteger)
###
def __repr__(self):
#return '<MemStats id='+str(self.id)+', used='+str(self.used)+', swap_used='+str(self.swap_used)+'>'
return '<MemStats id=%d, used=%d, swap_used=%d>'%(self.id,self.used,self.swap_used)

class DiskStats(Base):
__tablename__='diskstats'
id=Column(Integer,primary_key=True)
createtime=Column(DateTime())
datatime=Column(DateTime())
host_id=Column(Integer,ForeignKey('host.id'),primary_key=True)
host=relationship('Host',back_populates='diskstats')
###
usage=Column(Binary())
read_count=Column(BigInteger)
write_count=Column(BigInteger)
read_bytes=Column(BigInteger)
write_bytes=Column(BigInteger)
read_time=Column(BigInteger)
write_time=Column(BigInteger)
read_merged_count=Column(BigInteger)
write_merged_count=Column(BigInteger)
busy_time=Column(BigInteger)
###
def __repr__(self):
#return '<DiskStats id='+str(self.id)+', read_count='+str(self.read_count)+', write_count='+str(self.write_count)+'>'
return '<DiskStats id=%d, read_count=%d, write_count=%d>'%(self.id,self.read_count,self.write_count)

class IOStats(Base):
__tablename__='iostats'
id=Column(Integer,primary_key=True)
createtime=Column(DateTime())
datatime=Column(DateTime())
host_id=Column(Integer,ForeignKey('host.id'),primary_key=True)
host=relationship('Host',back_populates='iostats')
###
bytes_recv=Column(BigInteger)
bytes_sent=Column(BigInteger)
packets_sent=Column(BigInteger)
packets_recv=Column(BigInteger)
errin=Column(BigInteger)
errout=Column(BigInteger)
dropin=Column(BigInteger)
dropout=Column(BigInteger)
###
def __repr__(self):
#return '<IOStats id='+str(self.id)+', bytes_recv='+str(self.bytes_recv)+'>'
return '<IOStats id=%d, bytes_recv=%d'%(self.id,self.bytes_recv)

'''
class HostUserPermission(Base):
__tablename__='hostuserlink'
createtime=Column(DateTime())
updatetime=Column(DateTime())
permission=Column(String(10))
host_id=Column(Integer,ForeignKey('host.id'),primary_key=True)
user_id=Column(Integer,ForeignKey('user.id'),primary_key=True)
hosts=relationship('Host',back_populates='host_permissions')
users=relationship('User',back_populates='permissions')

class HostGroupPermission(Base):
__tablename__='hostgrouplink'
createtime=Column(DateTime())
updatetime=Column(DateTime())
permission=Column(String(10))
host_id=Column(Integer,ForeignKey('host.id'),primary_key=True)
group_id=Column(Integer,ForeignKey('group.id'),primary_key=True)
hosts=relationship('Host',back_populates='gorup_permissions')
groups=relationship('Group',back_populates='permissions')
'''

'''
class Category(Base):
__tablename__='category'
id=Column(Integer,primary_key=True)
name=Column(String(30))
createtime=Column(DateTime())
updatetime=Column(DateTime())
def __repr__(self):
return '<Category id='+str(self.id)+',name='+self.name+'>'
'''