class NodeDatabaseBackupHistory(Base):
__tablename__ = 'node_dbbackup_history'
id = Column(Integer, primary_key=True)
dbbackup_id = Column(Integer, ForeignKey('node_dbbackups.id'))
backup_start = Column(TIMESTAMP, default=now())
backup_end = Column(TIMESTAMP, onupdate=now())
size = Column(String(16), default='0')
def atom(self):
yesterday = now()- datetime.timedelta(hours=18)
c.activity = Session.query(Activity)\
.filter(Activity.created_at < now())\
.filter(Activity.created_at > yesterday)\
.order_by(desc(Activity.created_at))\
.filter(Activity.parent == None)\
.all()
return render('/activity/atom.mako')
class LBPoolComments(Base):
__tablename__ = 'lb_pool_comments'
id = Column(Integer, primary_key=True)
created_at = Column(TIMESTAMP, default=now())
updated_at = Column(TIMESTAMP, onupdate=now())
user_id = Column(Integer, ForeignKey('users.id'))
user = relationship(User, primaryjoin=user_id == User.id)
comment = Column(String(255))
def atom(self):
yesterday = now() - datetime.timedelta(hours=18)
c.activity = (
Session.query(Activity)
.filter(Activity.created_at < now())
.filter(Activity.created_at > yesterday)
.order_by(desc(Activity.created_at))
.filter(Activity.parent == None)
.all()
)
return render("/activity/atom.mako")
class NodeComment(Base):
__tablename__ = 'node_comments'
id = Column(Integer, primary_key=True)
created_at = Column(TIMESTAMP, default=now())
updated_at = Column(TIMESTAMP, onupdate=now())
node_id = Column(Integer, ForeignKey('nodes.id'))
user_id = Column(Integer, ForeignKey('users.id'))
user = relationship(User, primaryjoin=user_id == User.id)
description = Column(Text)
def __repr__(self):
return self.description
class Disk(Base):
__tablename__ = 'disks'
id = Column(Integer, primary_key=True)
created_at = Column(TIMESTAMP, default=now())
serial_no = Column(String(50))
capacity = Column(String(50))
type = Column(String(20))
controller_id = Column(Integer, ForeignKey('disk_controllers.id'))
controller_slot = Column(Integer)
controller = relationship('DiskController',
primaryjoin=controller_id == DiskController.id)
@property
def get_capacity():
if not self.capacity:
return None
regex = '(\d+.\d+|\d+) GB'
cap_result = re.search(regex, self.capacity)
if not cap_result:
return None
else:
return float(cap_result.groups(0)[0])
def __repr__(self):
return '<Disk {"capacity": "%s", "serial_no": "%s", "type": "%s"} >' \
% (self.capacity, self.serial_no, self.type)
class NetworkDevice(Base):
__tablename__ = 'network_devices'
id = Column(Integer, primary_key=True)
created_at = Column(TIMESTAMP, default=now())
updated_at = Column(TIMESTAMP, onupdate=now())
_hostname = Column(String(50))
logical = Column(Boolean, default=False)
management_ip = Column(String(50))
mac_address = Column(String(50))
type = Column(String(50))
serial_number = Column(String(50))
part_number = Column(String(50))
parent_id = Column(Integer, ForeignKey('network_devices.id'))
parent = relationship('NetworkDevice',
remote_side=[id],
backref="children")
def _Get_hostname(self):
if self._hostname:
return self._hostname
return self.management_ip
def _Set_hostname(self, value):
if not value:
return False
self._hostname = str(value)
return True
hostname = property(_Get_hostname, _Set_hostname)
mac_address_list = relationship(
NetworkDeviceMacInfo,
primaryjoin=\
id==NetworkDeviceMacInfo.network_device_id)
ip_address_list = relationship(
NetworkDeviceIpInfo,
primaryjoin=\
id==NetworkDeviceIpInfo.network_device_id)
def get_activity_page(cls, date_from=None, date_to=None):
if not (date_from or date_to):
activity = Session.query(cls)\
.filter(and_(
cls.created_at < now(),
cls.created_at > now() - timedelta(days=3),
cls.parent_id == None)).all()
elif date_from:
if not date_to:
activity = Session.query(cls)\
.filter(and_(
cls.created_at < date_from,
cls.created_at > date_from - timedelta(days=3),
cls.parent_id == None)).all()
else:
activity = Session.query(cls)\
.filter(and_(
cls.created_at < date_from,
cls.created_at > date_to,
cls.parent_id == None)).all()
else:
return None
return activity
def get_activity_page(cls, date_from=None, date_to=None):
if not (date_from or date_to):
activity = Session.query(cls)\
.filter(and_(
cls.created_at < now(),
cls.created_at > now() - timedelta(days=3),
cls.parent_id == None)).all()
elif date_from:
if not date_to:
activity = Session.query(cls)\
.filter(and_(
cls.created_at < date_from,
cls.created_at > date_from - timedelta(days=3),
cls.parent_id == None)).all()
else:
activity = Session.query(cls)\
.filter(and_(
cls.created_at < date_from,
cls.created_at > date_to,
cls.parent_id == None)).all()
else:
return None
return activity
def index(self, format="html"):
c.title = "Nodetraq - Activity"
c.selected_page = "activity"
c.subpage = "index"
if request.params.has_key("from"):
c.end_date = request.params["from"]
if c.end_date == now().date():
c.last_page = True
else:
c.last_page = False
else:
c.last_page = True
c.end_date = now().date()
if request.params.has_key("to"):
c.start_date = request.params["to"]
else:
c.start_date = c.end_date - datetime.timedelta(days=3)
if (
not request.params.has_key("show_nodes")
and not request.params.has_key("show_groups")
and not request.params.has_key("show_inventory")
):
c.filters = {"show_nodes": True, "show_groups": True, "show_inventory": True}
else:
c.filters = {"show_nodes": False, "show_groups": False, "show_inventory": False}
for key in c.filters.keys():
if request.params.has_key(key):
c.filters[key] = request.params[key]
# add filters to be checked by sqlalchemy
filters = []
for k in c.filters:
if c.filters[k]:
if k[5:] == "groups" or k[5:] == "nodes":
filters.append(k[5:-1])
else:
filters.append(k[5:])
if filters:
activity_types = Session.query(ActivityType).filter(ActivityType.name.in_(filters)).all()
activity_type_ids = [a_type.id for a_type in activity_types]
c.activities = Activity.get_activity_page()
"""
c.activities = Session.query(Activity)\
.filter(
Activity.activity_type_id.in_(activity_type_ids))\
.order_by(desc(Activity.created_at))\
.filter(Activity.parent == None).all()
"""
else:
c.activities = Activity.get_activity_page()
if format == "html":
return render("/activity/index.mako")
elif format == "json":
response.content_type = "application/json"
return render("/activity/index.json")
elif format == "xml":
response.content_type = "application/xml"
return render("/activity/index.xml")
def index(self, format='html'):
c.title = 'Nodetraq - Activity'
c.selected_page = 'activity'
c.subpage = 'index'
if request.params.has_key('from'):
c.end_date = request.params['from']
if c.end_date == now().date():
c.last_page = True
else:
c.last_page = False
else:
c.last_page = True
c.end_date = now().date()
if request.params.has_key('to'):
c.start_date = request.params['to']
else:
c.start_date = c.end_date - datetime.timedelta(days=3)
if not request.params.has_key('show_nodes') and \
not request.params.has_key('show_groups') and \
not request.params.has_key('show_inventory'):
c.filters = {
'show_nodes': True,
'show_groups': True,
'show_inventory': True,
}
else:
c.filters = {
'show_nodes': False,
'show_groups': False,
'show_inventory': False,
}
for key in c.filters.keys():
if request.params.has_key(key):
c.filters[key] = request.params[key]
# add filters to be checked by sqlalchemy
filters = []
for k in c.filters:
if c.filters[k]:
if k[5:] == 'groups' or k[5:] == 'nodes':
filters.append(k[5:-1])
else:
filters.append(k[5:])
if filters:
activity_types = Session.query(ActivityType)\
.filter(
ActivityType.name.in_(filters)).all()
activity_type_ids = [a_type.id for a_type in activity_types]
c.activities = Activity.get_activity_page()
'''
c.activities = Session.query(Activity)\
.filter(
Activity.activity_type_id.in_(activity_type_ids))\
.order_by(desc(Activity.created_at))\
.filter(Activity.parent == None).all()
'''
else:
c.activities = Activity.get_activity_page()
if format == 'html':
return render('/activity/index.mako')
elif format == 'json':
response.content_type = "application/json"
return render('/activity/index.json')
elif format == 'xml':
response.content_type = "application/xml"
return render('/activity/index.xml')
class Node(Base):
__tablename__ = 'nodes'
id = Column(Integer, primary_key=True)
created_at = Column(TIMESTAMP, default=now())
updated_at = Column(TIMESTAMP, onupdate=now())
# Host info
hostname = Column(String(50))
reported_hostname = Column(String(50))
model_name = Column(String(50))
service_tag = Column(String(50))
location = Column(String(20))
rack = Column(Integer)
rack_u = Column(Integer)
xen_instance = Column(Integer)
description = Column(String(255))
firmware = Column(String(255))
root_password = Column(String(255))
# Network
primary_ip = Column(String(20))
reported_primary_ip = Column(String(20))
secondary_ip = Column(String(20))
reported_secondary_ip = Column(String(20))
primary_mac = Column(String(20))
reported_primary_mac = Column(String(20))
secondary_mac = Column(String(20))
reported_secondary_mac = Column(String(20))
drac_ip = Column(String(20))
reported_drac_ip = Column(String(20))
drac_switch = Column(String(20))
drac_port = Column(String(20))
vhosts = relationship('NodeVhost',
secondary=node_vhosts_lookup,
backref=backref('node', uselist=False))
lb_pools = relationship('LBPool',
secondary=node_lbpools_lookup,
backref=backref('nodes'))
# Cpu
cpu_processor = Column(String(50))
cpu_count = Column(Integer)
memory = Column(Float)
# Disk Information
disks = relationship('Disk',
secondary=node_disk_lookup,
backref=backref('node', uselist=False))
# Operating System
ssh_key = Column(Text)
puppet_key = Column(Text)
server_license = Column(String(255))
sql_license = Column(String(255))
# Database Info
db_backups = relationship('NodeDatabaseBackup',
secondary=node_dbbackup_lookup,
backref=backref('server', uselist=False),
lazy=True,
cascade='all, delete')
# Services
nagios = Column(Boolean, default=False)
puppet = Column(Boolean, default=True)
# Information
groups = relationship('Group',
secondary=node_groups,
backref=backref('nodes', lazy=True),
lazy=True)
flags = relationship('NodeFlagInfo',
secondary=node_flags_lookup,
backref=backref('node', lazy=True, uselist=False),
cascade="all, delete-orphan",
single_parent=True)
comments = relationship('NodeComment',
secondary=node_comments_lookup,
backref=backref('node', lazy=True, uselist=False),
cascade="all, delete-orphan",
single_parent=True)
@property
def server_id(self):
if self.rack == None:
self.rack = 0
if self.rack_u == None:
self.rack_u = 0
if self.xen_instance == None\
or self.xen_instance == ''\
or self.xen_instance == 0:
return '%s%03d%02d' % (self.location, self.rack, self.rack_u)
else:
return '%s%03d%02d.%02d' % (self.location, self.rack, self.rack_u,
self.xen_instance)
@property
def sync_issues(self):
issues = []
for item in [
(self.reported_hostname, self.hostname, 'hostname'),
(self.reported_primary_ip, self.primary_ip, 'primary ip'),
(self.reported_secondary_ip, self.secondary_ip, 'secondary ip'),
(self.reported_primary_mac, self.primary_mac, 'primary mac'),
(self.reported_secondary_mac, self.secondary_mac, 'secondary mac')
]:
reported = item[0] or None
value = item[1] or None
if item[2] in ['primary mac', 'secondary mac']:
value = str_to_mac(value)
if reported != value:
issues.append({
'reported': reported,
'value': value,
'type': item[2]
})
return issues
def _sanitize(self):
self.primary_mac = self.primary_mac.replace(':', '')
self.secondary_mac = self.secondary_mac.replace(':', '')
def update_disks(self, diskinfo):
if self.disks:
current_serials = [d.serial_no for d in self.disks]
new_serials = [d['serial_no'] for d in diskinfo['disks']]
diff_serials = list(set(new_serials) - set(current_serials))
remove_serials = [ serial for serial in current_serials \
if serial not in new_serials ]
for s in remove_serials:
for rd in self.disks:
if rd.serial_no == s:
self.disks.remove(rd)
Session.delete(rd)
for s in diff_serials:
for disk in diskinfo['disks']:
if disk['serial_no'] == s:
new_disk = Disk()
new_disk.serial_no = disk['serial_no']
new_disk.capacity = disk['capacity']
new_disk.type = disk['type']
new_disk.controller_slot = disk['controller_slot']
new_disk.controller_id = DiskController\
.grab_controller(disk['controller'])
Session.add(new_disk)
self.disks.append(new_disk)
else:
self.disks = []
for disk in diskinfo['disks']:
new_disk = Disk()
new_disk.serial_no = disk['serial_no']
new_disk.capacity = disk['capacity']
new_disk.type = disk['type']
new_disk.controller_slot = disk['controller_slot']
new_disk.controller_id = DiskController\
.grab_controller(disk['controller'])
Session.add(new_disk)
self.disks.append(new_disk)
Session.add(self)
Session.commit()
def __json__(self, format=False):
ignore_list = ('metadata', 'update_disks')
keys = [v for v in dir(self) if not v.startswith('_')]
keys = [v for v in keys if not v in ignore_list]
json_hash = {}
for key in keys:
if key == 'groups':
groups = []
for group in self.__getattribute__(key):
groups.append(group.name)
json_hash[key] = groups
else:
json_hash[key] = '%s' % self.__getattribute__(key)
if format:
return json.dumps(json_hash, sort_keys=True, indent=4)
return json_hash
def __xml__(self):
ignore_list = ('server_id', 'metadata')
root = ET.Element("node")
keys = [v for v in dir(self) if not v.startswith('_')]
keys = [v for v in keys if not v in ignore_list]
for key in keys:
elem = ET.SubElement(root, key)
elem.text = '%s' % getattr(self, key)
tree = ET.ElementTree(root)
txt = ET.tostring(root)
return parseString(txt).toprettyxml()
def __repr__(self):
return """<Node( { 'hostname': '%s',
'nagios': %s,
'primary_ip': %s,
'secondary_ip': %s,
'primary_mac': %s,
'secondary_mac': %s,
'description': %s,
'drac_ip': %s,
'rack': %s
'rack_u': %s,
})>
""" % ( self.hostname, self.nagios,\
self.primary_ip, self.secondary_ip, self.primary_mac, \
self.secondary_mac, self.description, \
self.drac_ip, self.rack, self.rack_u)
