ceph/src/brag/server/ceph_brag/model/db.py

   1 import json
   2 from datetime import datetime
   3 from sqlalchemy.orm import sessionmaker, scoped_session
   4 from sqlalchemy import Column, Integer, String, \
   5      DateTime, ForeignKey, BigInteger
   6 from sqlalchemy import PrimaryKeyConstraint
   7 from sqlalchemy.ext.declarative import declarative_base
   8 from sqlalchemy.ext.declarative import declared_attr
   9
  10 Base = declarative_base()
  11 Session = scoped_session(sessionmaker())
  12
  13 class cluster_info(Base):
  14   __tablename__ = 'cluster_info'
  15
  16   index = Column(Integer, primary_key=True)
  17   uuid = Column(String(36), unique=True)
  18   organization = Column(String(64))
  19   contact_email = Column(String(32))
  20   cluster_name = Column(String(32))
  21   cluster_creation_date = Column(DateTime)
  22   description = Column(String(32))
  23   num_versions = Column(Integer)
  24
  25 class version_info(Base):
  26   __tablename__ = 'version_info'
  27
  28   index = Column(Integer, primary_key=True)
  29   cluster_id = Column(ForeignKey('cluster_info.index'))
  30   version_number = Column(Integer)
  31   version_date = Column(DateTime)
  32
  33 class components_info(Base):
  34   __tablename__ = 'components_info'
  35
  36   index = Column(Integer, primary_key=True)
  37   vid = Column(ForeignKey('version_info.index'))
  38   num_data_bytes = Column(BigInteger)
  39   num_bytes_total = Column(BigInteger)
  40   num_osds = Column(Integer)
  41   num_objects = Column(Integer)
  42   num_pgs = Column(Integer)
  43   num_pools = Column(Integer)
  44   num_mdss = Column(Integer)
  45   num_mons = Column(Integer)
  46
  47 class crush_types(Base):
  48   __tablename__ = 'crush_types'
  49
  50   index = Column(Integer, primary_key=True)
  51   vid = Column(ForeignKey('version_info.index'))
  52   crush_type = Column(String(16))
  53   crush_count = Column(Integer)
  54
  55 class pools_info(Base):
  56   __tablename__ = 'pools_info'
  57
  58   index = Column(Integer, primary_key=True)
  59   vid = Column(ForeignKey('version_info.index'))
  60   pool_id = Column(Integer)
  61   pool_type = Column(Integer)
  62   pool_rep_size = Column(Integer)
  63
  64 class os_info(Base):
  65   __tablename__ = 'os_info'
  66
  67   index = Column(Integer, primary_key=True)
  68   vid = Column(ForeignKey('version_info.index'))
  69   os = Column(String(16))
  70   count = Column(Integer)
  71
  72 class kernel_versions(Base):
  73   __tablename__ = 'kernel_versions'
  74
  75   index = Column(Integer, primary_key=True)
  76   vid = Column(ForeignKey('version_info.index'))
  77   version = Column(String(16))
  78   count = Column(Integer)
  79
  80 class kernel_types(Base):
  81   __tablename__ = 'kernel_types'
  82
  83   index = Column(Integer, primary_key=True)
  84   vid = Column(ForeignKey('version_info.index'))
  85   type = Column(String(64))
  86   count = Column(Integer)
  87
  88 class distros(Base):
  89   __tablename__ = 'distros'
  90
  91   index = Column(Integer, primary_key=True)
  92   vid = Column(ForeignKey('version_info.index'))
  93   distro = Column(String(64))
  94   count = Column(Integer)
  95
  96 class cpus(Base):
  97   __tablename__ = 'cpus'
  98
  99   index = Column(Integer, primary_key=True)
 100   vid = Column(ForeignKey('version_info.index'))
 101   cpu = Column(String(16))
 102   count = Column(Integer)
 103
 104 class cpu_archs(Base):
 105   __tablename__ = 'cpu_archs'
 106
 107   index = Column(Integer, primary_key=True)
 108   vid = Column(ForeignKey('version_info.index'))
 109   arch = Column(String(16))
 110   count = Column(Integer)
 111
 112 class ceph_versions(Base):
 113   __tablename__ = 'ceph_versions'
 114
 115   index = Column(Integer, primary_key=True)
 116   vid = Column(ForeignKey('version_info.index'))
 117   version = Column(String(16))
 118   count = Column(Integer)
 119
 120 class sysinfo(object):
 121   def __init__(self, vindex):
 122     self.os = Session.query(os_info).filter_by(vid=vindex).all()
 123     self.kern_vers = Session.query(kernel_versions).filter_by(vid=vindex).all()
 124     self.kern_types = Session.query(kernel_types).filter_by(vid=vindex).all()
 125     self.distros = Session.query(distros).filter_by(vid=vindex).all()
 126     self.cpus = Session.query(cpus).filter_by(vid=vindex).all()
 127     self.cpu_archs = Session.query(cpu_archs).filter_by(vid=vindex).all()
 128     self.ceph_vers = Session.query(ceph_versions).filter_by(vid=vindex).all()
 129
 130 class brag(object):
 131   def __init__(self, uuid, version_number):
 132     self.ci = Session.query(cluster_info).filter_by(uuid=uuid).first()
 133     if self.ci is not None:
 134       self.vi = Session.query(version_info).filter_by(cluster_id=self.ci.index, version_number=version_number).first()
 135
 136     if self.ci is not None and self.vi is not None:
 137       self.comps = Session.query(components_info).filter_by(vid=self.vi.index).first()
 138       self.crush = Session.query(crush_types).filter_by(vid=self.vi.index).all()
 139       self.pools = Session.query(pools_info).filter_by(vid=self.vi.index).all()
 140       self.sysinfo = sysinfo(self.vi.index)
 141
 142 def put_new_version(data):
 143   info = json.loads(data)
 144   def add_cluster_info():
 145     ci = Session.query(cluster_info).filter_by(uuid=info['uuid']).first()
 146     if ci is None:
 147       dt = datetime.strptime(info['cluster_creation_date'], "%Y-%m-%d %H:%M:%S.%f")
 148       ci = cluster_info(uuid=info['uuid'],
 149                         organization=info['ownership']['organization'],
 150                         contact_email=info['ownership']['email'],
 151                         cluster_name=info['ownership']['name'],
 152                         description=info['ownership']['description'],
 153                         cluster_creation_date=dt,
 154                         num_versions=1)
 155       Session.add(ci)
 156       Session.commit()
 157     else:
 158       ci.num_versions += 1
 159
 160     return ci
 161
 162   def add_version_info(ci):
 163     vi = version_info(cluster_id=ci.index,
 164                       version_number=ci.num_versions,
 165                       version_date=datetime.now())
 166     Session.add(vi)
 167     return vi
 168
 169   def add_components_info(vi):
 170     comps_count= info['components_count']
 171     comps_info = components_info(vid=vi.index,
 172                          num_data_bytes=comps_count['num_data_bytes'],
 173                          num_bytes_total=comps_count['num_bytes_total'],
 174                          num_osds=comps_count['num_osds'],
 175                          num_objects=comps_count['num_objects'],
 176                          num_pgs=comps_count['num_pgs'],
 177                          num_pools=comps_count['num_pools'],
 178                          num_mdss=comps_count['num_mdss'],
 179                          num_mons=comps_count['num_mons'])
 180     Session.add(comps_info)
 181
 182   def add_crush_types(vi):
 183     for c in info['crush_types']:
 184       Session.add(crush_types(vid=vi.index,
 185                             crush_type=c['type'],
 186                             crush_count=c['count']))
 187
 188   def add_pools_info(vi):
 189     pools = info['pool_metadata']
 190     for p in pools:
 191       Session.add(pools_info(vid=vi.index,
 192                              pool_id=p['id'],
 193                              pool_type=p['type'],
 194                              pool_rep_size=p['size']))
 195
 196   def add_sys_info(vi):
 197     si = info['sysinfo']
 198     while si:
 199       k,v = si.popitem()
 200       if k == 'os_info':
 201         for o in v:
 202           Session.add(os_info(vid=vi.index,
 203                               os=o['os'],
 204                               count=o['count']))
 205       elif k == 'kernel_versions':
 206         for k in v:
 207           Session.add(kernel_versions(vid=vi.index,
 208                                       version=k['version'],
 209                                       count=k['count']))
 210       elif k == 'kernel_types':
 211         for k in v:
 212           Session.add(kernel_types(vid=vi.index,
 213                                    type=k['type'],
 214                                    count=k['count']))
 215       elif k == 'distros':
 216         for d in v:
 217           Session.add(distros(vid=vi.index,
 218                               distro=d['distro'],
 219                               count=d['count']))
 220       elif k == 'cpus':
 221         for c in v:
 222           Session.add(cpus(vid=vi.index,
 223                            cpu=c['cpu'],
 224                            count=c['count']))
 225       elif k == 'cpu_archs':
 226         for c in v:
 227           Session.add(cpu_archs(vid=vi.index,
 228                                 arch=c['arch'],
 229                                 count=c['count']))
 230       elif k == 'ceph_versions':
 231         for c in v:
 232           Session.add(ceph_versions(vid=vi.index,
 233                                     version=c['version'],
 234                                     count=c['count']))
 235
 236   ci = add_cluster_info()
 237   add_version_info(ci)
 238   vi = Session.query(version_info).filter_by(cluster_id=ci.index,
 239                                              version_number=ci.num_versions).first()
 240   add_components_info(vi)
 241   add_crush_types(vi)
 242   add_pools_info(vi)
 243   add_sys_info(vi)
 244
 245 def delete_uuid(uuid):
 246   ci = Session.query(cluster_info).filter_by(uuid=uuid).first()
 247   if ci is None:
 248     return {'status':400, 'msg':'No information for this UUID'}
 249
 250   for v in Session.query(version_info).filter_by(cluster_id=ci.index).all():
 251     Session.query(components_info).filter_by(vid=v.index).delete()
 252     Session.query(crush_types).filter_by(vid=v.index).delete()
 253     Session.query(pools_info).filter_by(vid=v.index).delete()
 254     Session.query(os_info).filter_by(vid=v.index).delete()
 255     Session.query(kernel_versions).filter_by(vid=v.index).delete()
 256     Session.query(kernel_types).filter_by(vid=v.index).delete()
 257     Session.query(distros).filter_by(vid=v.index).delete()
 258     Session.query(cpus).filter_by(vid=v.index).delete()
 259     Session.query(cpu_archs).filter_by(vid=v.index).delete()
 260     Session.query(ceph_versions).filter_by(vid=v.index).delete()
 261
 262     Session.flush()
 263     Session.delete(v)
 264     Session.flush()
 265
 266   Session.delete(ci)
 267   return None
 268
 269 def get_uuids():
 270   return Session.query(cluster_info).all()
 271
 272 def get_versions(uuid):
 273   ci = Session.query(cluster_info).filter_by(uuid=uuid).first()
 274   if ci is None:
 275     return None
 276
 277   return Session.query(version_info).filter_by(cluster_id=ci.index).all()
 278
 279 def get_brag(uuid, version_id):
 280   b = brag(uuid, version_id)
 281   if b.ci is None or b.vi is None:
 282     return None
 283
 284   return b