vstf/vstf/controller/database/tables.py

   1 #!/usr/bin/python
   2 # -*- coding: utf8 -*-
   3 # author: wly
   4 # date: 2015-07-29
   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     Provider = Column(String(const.PROVIDER_LEN))
 131     Type = Column(String(const.TYPE_LEN))
 132     Tools = Column(String(const.TOOLS_LEN))
 133
 134     def __init__(self, taskid, casetag, protocol, provider, typ, tools, **kwargs):
 135         """Table of test"""
 136         self.TaskID = taskid
 137         self.CaseTag = casetag
 138         self.Protocol = protocol
 139         self.Provider = provider
 140         self.Type = typ
 141         self.Tools = tools
 142
 143     def __repr__(self):
 144         return "<User(TaskID='%d', CaseTag='%s', Protocol='%s', Provider=%s, Type='%s', Tools='%s')>" % (
 145             self.TaskID, self.CaseTag, self.Protocol, self.Provider, self.Type, self.Tools)
 146
 147
 148 class TblThroughput(Base):
 149     __tablename__ = "TblThroughput"
 150     Index = Column(Integer, primary_key=True)
 151     TestID = Column(Integer, ForeignKey('TblTestList.TestID'))
 152     AvgFrameSize = Column(Integer)
 153     OfferedLoad = Column(Float)
 154     PercentLoss = Column(Float)
 155     Bandwidth = Column(Float)
 156     MinimumLatency = Column(Float)
 157     MaximumLatency = Column(Float)
 158     AverageLatency = Column(Float)
 159     TxFrameCount = Column(Float)
 160     RxFrameCount = Column(Float)
 161     Duration = Column(Float)
 162     CPU = Column(Float)
 163     MppspGhz = Column(Float)
 164
 165     def __init__(self, TestID, AvgFrameSize,
 166                  OfferedLoad, PercentLoss, Bandwidth,
 167                  MinimumLatency, MaximumLatency, AverageLatency,
 168                  TxFrameCount, RxFrameCount, Duration,
 169                  CPU, MppspGhz, **kwargs):
 170         """table of throughput"""
 171         self.TestID = TestID
 172         self.AvgFrameSize = AvgFrameSize
 173         self.OfferedLoad = OfferedLoad
 174         self.PercentLoss = PercentLoss
 175         self.Bandwidth = Bandwidth
 176         self.MinimumLatency = MinimumLatency
 177         self.MaximumLatency = MaximumLatency
 178         self.AverageLatency = AverageLatency
 179         self.TxFrameCount = TxFrameCount
 180         self.RxFrameCount = RxFrameCount
 181         self.Duration = Duration
 182         self.CPU = CPU
 183         self.MppspGhz = MppspGhz
 184
 185     def __repr__(self):
 186         return "<User(TestID='%d', AvgFrameSize='%d', OfferedLoad='%f', \
 187                       PercentLoss='%f', MinimumLatency='%f', AverageLatency='%f', MaximumLatency='%f',\
 188                       TxFrameCount='%f', RxFrameCount='%f', Duration='%f', CPU='%f', MppspGhz='%f', \
 189                       Bandwidth='%f')>" % (self.TestID,
 190                                            self.AvgFrameSize, self.OfferedLoad, self.PercentLoss,
 191                                            self.MinimumLatency, self.AverageLatency, self.MaximumLatency,
 192                                            self.TxFrameCount,
 193                                            self.RxFrameCount, self.Duration, self.CPU, self.MppspGhz, self.Bandwidth)
 194
 195
 196 class TblFrameloss(Base):
 197     __tablename__ = "TblFrameloss"
 198     Index = Column(Integer, primary_key=True)
 199     TestID = Column(Integer, ForeignKey('TblTestList.TestID'))
 200     AvgFrameSize = Column(Integer)
 201     OfferedLoad = Column(Float)
 202     PercentLoss = Column(Float)
 203     Bandwidth = Column(Float)
 204     MinimumLatency = Column(Float)
 205     MaximumLatency = Column(Float)
 206     AverageLatency = Column(Float)
 207     TxFrameCount = Column(Float)
 208     RxFrameCount = Column(Float)
 209     Duration = Column(Float)
 210     CPU = Column(Float)
 211     MppspGhz = Column(Float)
 212
 213     def __init__(self, TestID, AvgFrameSize,
 214                  OfferedLoad, PercentLoss, Bandwidth,
 215                  MinimumLatency, MaximumLatency, AverageLatency,
 216                  TxFrameCount, RxFrameCount, Duration,
 217                  CPU, MppspGhz, **kwargs):
 218         """table of frameloss"""
 219         self.TestID = TestID
 220         self.AvgFrameSize = AvgFrameSize
 221         self.OfferedLoad = OfferedLoad
 222         self.PercentLoss = PercentLoss
 223         self.Bandwidth = Bandwidth
 224         self.MinimumLatency = MinimumLatency
 225         self.MaximumLatency = MaximumLatency
 226         self.AverageLatency = AverageLatency
 227         self.TxFrameCount = TxFrameCount
 228         self.RxFrameCount = RxFrameCount
 229         self.Duration = Duration
 230         self.CPU = CPU
 231         self.MppspGhz = MppspGhz
 232
 233     def __repr__(self):
 234         return "<User(TestID='%d', AvgFrameSize='%d', OfferedLoad='%f', \
 235                       PercentLoss='%f', MinimumLatency='%f', AverageLatency='%f', MaximumLatency='%f',\
 236                       TxFrameCount='%f', RxFrameCount='%f', Duration='%f', CPU='%f', MppspGhz='%f', \
 237                       Bandwidth='%f')>" % (self.TestID,
 238                                            self.AvgFrameSize, self.OfferedLoad, self.PercentLoss,
 239                                            self.MinimumLatency, self.AverageLatency, self.MaximumLatency,
 240                                            self.TxFrameCount,
 241                                            self.RxFrameCount, self.Duration, self.CPU, self.MppspGhz, self.Bandwidth)
 242
 243
 244 class TblLatency(Base):
 245     __tablename__ = "TblLatency"
 246     Index = Column(Integer, primary_key=True)
 247     TestID = Column(Integer, ForeignKey('TblTestList.TestID'))
 248     AvgFrameSize = Column(Integer)
 249     OfferedLoad = Column(Float)
 250     MinimumLatency = Column(Float)
 251     MaximumLatency = Column(Float)
 252     AverageLatency = Column(Float)
 253
 254     def __init__(self, TestID, AvgFrameSize, OfferedLoad,
 255                  MinimumLatency, MaximumLatency, AverageLatency, **kwargs):
 256         """table of latency"""
 257         self.TestID = TestID
 258         self.AvgFrameSize = AvgFrameSize
 259         self.OfferedLoad = OfferedLoad
 260         self.MinimumLatency = MinimumLatency
 261         self.MaximumLatency = MaximumLatency
 262         self.AverageLatency = AverageLatency
 263
 264     def __repr__(self):
 265         return "<User(TestID='%d', AvgFrameSize='%d', OfferedLoad='%f', \
 266                       MinimumLatency='%f', AverageLatency='%f', MaximumLatency='%f')>" % (self.TestID,
 267                                                                                           self.AvgFrameSize,
 268                                                                                           self.OfferedLoad,
 269                                                                                           self.MinimumLatency,
 270                                                                                           self.AverageLatency,
 271                                                                                           self.MaximumLatency)
 272
 273
 274 class TblEXTInfo(Base):
 275     __tablename__ = "TblEXTInfo"
 276     Index = Column(Integer, primary_key=True)
 277     TaskID = Column(Integer)
 278     EXTName = Column(String(const.NORMAL_VAR_LEN))
 279     EXTContent = Column(String(const.DESC_LEN))
 280     Description = Column(String(const.NORMAL_VAR_LEN1))
 281
 282     def __init__(self, TaskID, EXTName, EXTContent, Description, **kwargs):
 283         """table extern info"""
 284         self.TaskID = TaskID
 285         self.EXTName = EXTName
 286         self.EXTContent = EXTContent
 287         self.Description = Description
 288
 289     def __repr__(self):
 290         return "<User(TaskID='%d', CodeType='%s', EXTContent='%s',Version='%s')>" % (
 291             self.TaskID, self.EXTName, self.EXTContent, self.Version)