vstf/vstf/controller/database/tables.py

   1 #!/usr/bin/python
   2 # -*- coding: utf8 -*-
   3 # author: wly
   4 # date: 2015-12-25
   5 # see license for license details
   6 __version__ = ''' '''
   7 from sqlalchemy import Column, Integer, String, Float, ForeignKey
   8 from sqlalchemy.ext.declarative import declarative_base
   9 from vstf.controller.database import constants as const
  10
  11 Base = declarative_base()
  12
  13
  14 class TblScenarioInfo(Base):
  15     __tablename__ = "TblScenarioInfo"
  16     ScenarioID = Column(Integer, primary_key=True)
  17     ScenarioName = Column(String(const.SCENARIO_NAME_LEN), unique=True)
  18     FigurePath = Column(String(const.FIGURE_PATH_LEN))
  19     Description = Column(String(const.DESC_LEN))
  20
  21     def __init__(self, ScenarioName, FigurePath, Description, **kwargs):
  22         """
  23         :param ScenarioName: name of the scenario, like Tn
  24         :param FigurePath: ??
  25         :param Description: desc of scenario table
  26         """
  27         self.ScenarioName = ScenarioName
  28         self.FigurePath = FigurePath
  29         self.Description = Description
  30
  31     def __repr__(self):
  32         return "<User(ScenarioName='%s', FigurePath='%s', Description='%s')>" % (
  33             self.ScenarioName, self.FigurePath, self.Description)
  34
  35
  36 class TblCaseInfo(Base):
  37     __tablename__ = "TblCaseInfo"
  38     CaseID = Column(Integer, primary_key=True)
  39     CaseTag = Column(String(const.CASE_TAG_LEN), unique=True)
  40     CaseName = Column(String(const.CASE_NAME_LEN), unique=True)
  41     ScenarioName = Column(String(const.SCENARIO_NAME_LEN))
  42     FigurePath = Column(String(const.FIGURE_PATH_LEN))
  43     Direction = Column(String(const.DIRECTION_LEN))
  44     Directiontag = Column(String(const.DIRECTION_LEN))
  45     Configure = Column(String(const.CONF_LEN))
  46     Description = Column(String(const.DESC_LEN))
  47
  48     def __init__(self, CaseTag, CaseName,
  49                  ScenarioName, FigurePath, Direction, Directiontag,
  50                  Configure, Description, **kwargs):
  51         """
  52         :param CaseID:
  53         :param CaseTag: ??
  54         :param CaseName: name of case, like tester-vm
  55         :param ScenarioName: name of scenario, like Tn
  56         :param FigurePath:
  57         :param Direction: the test direction, Tx or Rx
  58         :param Configure:
  59         :param Description: desc of table case info
  60         """
  61         # CaseID will auto builded by db
  62         self.CaseTag = CaseTag
  63         self.CaseName = CaseName
  64         self.ScenarioName = ScenarioName
  65         self.FigurePath = FigurePath
  66         self.Direction = Direction
  67         self.Directiontag = Directiontag
  68         self.Configure = Configure
  69         self.Description = Description
  70
  71     def __repr__(self):
  72         return "<User(CaseTag='%s', CaseName='%s',ScenarioName='%s',FigurePath='%s', Direction='%s', \
  73             Directiontag='%s', Configure='%s', Description='%s')>" % (self.CaseTag, self.CaseName,
  74                                                                       self.ScenarioName, self.FigurePath,
  75                                                                       self.Direction, self.Directiontag, self.Configure,
  76                                                                       self.Description)
  77
  78
  79 class TblHostInfo(Base):
  80     __tablename__ = "TblHostInfo"
  81     Index = Column(Integer, primary_key=True)
  82     TaskID = Column(Integer, ForeignKey('TblTaskList.TaskID'))
  83     HostName = Column(String(const.HOST_NAME_LEN))
  84     Server = Column(String(const.NORMAL_VAR_LEN1))
  85     CPU = Column(String(const.CPU_INFO_LEN))
  86     MEM = Column(String(const.NORMAL_VAR_LEN))
  87     NIC = Column(String(const.NORMAL_VAR_LEN))
  88     OS = Column(String(const.NORMAL_VAR_LEN))
  89
  90     def __init__(self, TaskID, HostName, Server, CPU, MEM, NIC, OS, **kwargs):
  91         """table of host info
  92         """
  93         self.TaskID = TaskID
  94         self.HostName = HostName
  95         self.Server = Server
  96         self.CPU = CPU
  97         self.MEM = MEM
  98         self.NIC = NIC
  99         self.OS = OS
 100
 101     def __repr__(self):
 102         return "<User(HostName='%s',  Server='%s', CPU='%s', MEM='%s', NIC='%s',\
 103          OS='%s')>" % (self.HostName, self.Server, self.CPU, self.MEM, self.NIC, self.OS)
 104
 105
 106 class TblTaskList(Base):
 107     __tablename__ = "TblTaskList"
 108     TaskID = Column(Integer, primary_key=True)
 109     TaskName = Column(String(const.NORMAL_VAR_LEN1))
 110     Date = Column(String(const.NORMAL_VAR_LEN1))
 111     EXTInfo = Column(String(const.EXT_INFO_LEN))
 112
 113     def __init__(self, TaskName, Date, EXTInfo="", **kwargs):
 114         """Table of task"""
 115         self.TaskName = TaskName
 116         self.Date = Date
 117         self.EXTInfo = EXTInfo
 118
 119     def __repr__(self):
 120         return "<User(TaskID='%s', TaskName='%s', Date='%s', EXTInfo='%s')>" % (
 121             self.TaskID, self.TaskName, self.Date, self.EXTInfo)
 122
 123
 124 class TblTestList(Base):
 125     __tablename__ = "TblTestList"
 126     TestID = Column(Integer, primary_key=True)
 127     TaskID = Column(Integer, ForeignKey('TblTaskList.TaskID'))
 128     CaseTag = Column(String(const.CASE_TAG_LEN))
 129     Protocol = Column(String(const.PROTOCOL_LEN))
 130     Type = Column(String(const.TYPE_LEN))
 131     Switch = Column(String(const.SWITCH_LEN))
 132     Provider = Column(String(const.PROVIDER_LEN))
 133     Tools = Column(String(const.TOOLS_LEN))
 134
 135     def __init__(self, taskid, casetag, protocol, typ, switch, provider, tools, **kwargs):
 136         """Table of test"""
 137         self.TaskID = taskid
 138         self.CaseTag = casetag
 139         self.Protocol = protocol
 140         self.Type = typ
 141         self.Switch = switch
 142         self.Provider = provider
 143         self.Tools = tools
 144
 145     def __repr__(self):
 146         return "<User(TaskID='%d', CaseTag='%s', Protocol='%s', Type='%s', Switch=%s, Provider=%s, Tools='%s')>" % (
 147             self.TaskID, self.CaseTag, self.Protocol, self.Type, self.Switch, self.Provider, self.Tools)
 148
 149
 150 class TblThroughput(Base):
 151     __tablename__ = "TblThroughput"
 152     Index = Column(Integer, primary_key=True)
 153     TestID = Column(Integer, ForeignKey('TblTestList.TestID'))
 154     AvgFrameSize = Column(Integer)
 155     OfferedLoad = Column(Float)
 156     PercentLoss = Column(Float)
 157     Bandwidth = Column(Float)
 158     MinimumLatency = Column(Float)
 159     MaximumLatency = Column(Float)
 160     AverageLatency = Column(Float)
 161     TxFrameCount = Column(Float)
 162     RxFrameCount = Column(Float)
 163     Duration = Column(Float)
 164     CPU = Column(Float)
 165     MppspGhz = Column(Float)
 166
 167     def __init__(self, TestID, AvgFrameSize,
 168                  OfferedLoad, PercentLoss, Bandwidth,
 169                  MinimumLatency, MaximumLatency, AverageLatency,
 170                  TxFrameCount, RxFrameCount, Duration,
 171                  CPU, MppspGhz, **kwargs):
 172         """table of throughput"""
 173         self.TestID = TestID
 174         self.AvgFrameSize = AvgFrameSize
 175         self.OfferedLoad = OfferedLoad
 176         self.PercentLoss = PercentLoss
 177         self.Bandwidth = Bandwidth
 178         self.MinimumLatency = MinimumLatency
 179         self.MaximumLatency = MaximumLatency
 180         self.AverageLatency = AverageLatency
 181         self.TxFrameCount = TxFrameCount
 182         self.RxFrameCount = RxFrameCount
 183         self.Duration = Duration
 184         self.CPU = CPU
 185         self.MppspGhz = MppspGhz
 186
 187     def __repr__(self):
 188         return "<User(TestID='%d', AvgFrameSize='%d', OfferedLoad='%f', \
 189                       PercentLoss='%f', MinimumLatency='%f', AverageLatency='%f', MaximumLatency='%f',\
 190                       TxFrameCount='%f', RxFrameCount='%f', Duration='%f', CPU='%f', MppspGhz='%f', \
 191                       Bandwidth='%f')>" % (self.TestID,
 192                                            self.AvgFrameSize, self.OfferedLoad, self.PercentLoss,
 193                                            self.MinimumLatency, self.AverageLatency, self.MaximumLatency,
 194                                            self.TxFrameCount,
 195                                            self.RxFrameCount, self.Duration, self.CPU, self.MppspGhz, self.Bandwidth)
 196
 197
 198 class TblFrameloss(Base):
 199     __tablename__ = "TblFrameloss"
 200     Index = Column(Integer, primary_key=True)
 201     TestID = Column(Integer, ForeignKey('TblTestList.TestID'))
 202     AvgFrameSize = Column(Integer)
 203     OfferedLoad = Column(Float)
 204     PercentLoss = Column(Float)
 205     Bandwidth = Column(Float)
 206     MinimumLatency = Column(Float)
 207     MaximumLatency = Column(Float)
 208     AverageLatency = Column(Float)
 209     TxFrameCount = Column(Float)
 210     RxFrameCount = Column(Float)
 211     Duration = Column(Float)
 212     CPU = Column(Float)
 213     MppspGhz = Column(Float)
 214
 215     def __init__(self, TestID, AvgFrameSize,
 216                  OfferedLoad, PercentLoss, Bandwidth,
 217                  MinimumLatency, MaximumLatency, AverageLatency,
 218                  TxFrameCount, RxFrameCount, Duration,
 219                  CPU, MppspGhz, **kwargs):
 220         """table of frameloss"""
 221         self.TestID = TestID
 222         self.AvgFrameSize = AvgFrameSize
 223         self.OfferedLoad = OfferedLoad
 224         self.PercentLoss = PercentLoss
 225         self.Bandwidth = Bandwidth
 226         self.MinimumLatency = MinimumLatency
 227         self.MaximumLatency = MaximumLatency
 228         self.AverageLatency = AverageLatency
 229         self.TxFrameCount = TxFrameCount
 230         self.RxFrameCount = RxFrameCount
 231         self.Duration = Duration
 232         self.CPU = CPU
 233         self.MppspGhz = MppspGhz
 234
 235     def __repr__(self):
 236         return "<User(TestID='%d', AvgFrameSize='%d', OfferedLoad='%f', \
 237                       PercentLoss='%f', MinimumLatency='%f', AverageLatency='%f', MaximumLatency='%f',\
 238                       TxFrameCount='%f', RxFrameCount='%f', Duration='%f', CPU='%f', MppspGhz='%f', \
 239                       Bandwidth='%f')>" % (self.TestID,
 240                                            self.AvgFrameSize, self.OfferedLoad, self.PercentLoss,
 241                                            self.MinimumLatency, self.AverageLatency, self.MaximumLatency,
 242                                            self.TxFrameCount,
 243                                            self.RxFrameCount, self.Duration, self.CPU, self.MppspGhz, self.Bandwidth)
 244
 245
 246 class TblLatency(Base):
 247     __tablename__ = "TblLatency"
 248     Index = Column(Integer, primary_key=True)
 249     TestID = Column(Integer, ForeignKey('TblTestList.TestID'))
 250     AvgFrameSize = Column(Integer)
 251     OfferedLoad = Column(Float)
 252     MinimumLatency = Column(Float)
 253     MaximumLatency = Column(Float)
 254     AverageLatency = Column(Float)
 255
 256     def __init__(self, TestID, AvgFrameSize, OfferedLoad,
 257                  MinimumLatency, MaximumLatency, AverageLatency, **kwargs):
 258         """table of latency"""
 259         self.TestID = TestID
 260         self.AvgFrameSize = AvgFrameSize
 261         self.OfferedLoad = OfferedLoad
 262         self.MinimumLatency = MinimumLatency
 263         self.MaximumLatency = MaximumLatency
 264         self.AverageLatency = AverageLatency
 265
 266     def __repr__(self):
 267         return "<User(TestID='%d', AvgFrameSize='%d', OfferedLoad='%f', \
 268                       MinimumLatency='%f', AverageLatency='%f', MaximumLatency='%f')>" % (self.TestID,
 269                                                                                           self.AvgFrameSize,
 270                                                                                           self.OfferedLoad,
 271                                                                                           self.MinimumLatency,
 272                                                                                           self.AverageLatency,
 273                                                                                           self.MaximumLatency)
 274
 275
 276 class TblEXTInfo(Base):
 277     __tablename__ = "TblEXTInfo"
 278     Index = Column(Integer, primary_key=True)
 279     TaskID = Column(Integer)
 280     EXTName = Column(String(const.NORMAL_VAR_LEN))
 281     EXTContent = Column(String(const.DESC_LEN))
 282     Description = Column(String(const.NORMAL_VAR_LEN1))
 283
 284     def __init__(self, TaskID, EXTName, EXTContent, Description, **kwargs):
 285         """table extern info"""
 286         self.TaskID = TaskID
 287         self.EXTName = EXTName
 288         self.EXTContent = EXTContent
 289         self.Description = Description
 290
 291     def __repr__(self):
 292         return "<User(TaskID='%d', CodeType='%s', EXTContent='%s',Version='%s')>" % (
 293             self.TaskID, self.EXTName, self.EXTContent, self.Version)