"""Print a standard error message and throw a

rocks.util.CommandError"""

syslog.syslog(syslog.LOG_ERR, message)

"""An Interface class to add the ability to process os arguments."""

def getOSNames(self, args=None):

"""Returns a list of OS names. For each arg in the ARGS list

normalize the name to one of either 'linux' or 'sunos' as

they are the only supported OSes. If the ARGS list is empty

return a list of all supported OS names.

"""

list = []

for arg in args:

s = arg.lower()

if s == 'linux':

list.append(s)

elif s == 'sunos':

list.append(s)

else:

self.abort('unknown os "%s"' % arg)

if not list:

list.append('linux')

list.append('sunos')

"""An Interface class to add the ability to process membership

arguments."""

def getMembershipNames(self, args=None):

"""Returns a list of membership names from the database.

For each arg in the ARGS list find all the membership

names that match the arg (assume SQL regexp). If an

arg does not match anything in the database we Abort. If the

ARGS list is empty return all membership names.

"""

list = []

if not args:

args = [ '%' ] # find all memberships

for arg in args:

rows = self.db.execute("""select name from memberships

where name like '%s'""" % arg)

if rows == 0 and arg == '%': # empty table is OK

continue

if rows < 1:

self.abort('unknown membership "%s"' % arg)

for name, in self.db.fetchall():

list.append(name)

"""An Interface class to add the ability to process distribution

arguments."""

def getDistributionNames(self, args=None):

"""Returns a list of distribution names from the database.

For each arg in the ARGS list find all the distribution

names that match the arg (assume SQL regexp). If an

arg does not match anything in the database we Abort. If the

ARGS list is empty return all distribution names.

"""

list = []

if not args:

args = [ '%' ] # find all distributions

for arg in args:

rows = self.db.execute("""select name from

distributions where name like '%s'""" % arg)

if rows == 0 and arg == '%': # empty table is OK

continue

if rows < 1:

if arg == '%':

# special processing for when the table

# is empty

continue

else:

self.abort('unknown distribution "%s"' % arg)

for name, in self.db.fetchall():

list.append(name)

"""An Interface class to add the ability to process network (subnet)

argument."""

def getNetworkNames(self, args=None):

"""Returns a list of network (subnet) names from the database.

For each arg in the ARGS list find all the network

names that match the arg (assume SQL regexp). If an

arg does not match anything in the database we Abort. If the

ARGS list is empty return all network names.

"""

list = []

if not args:

args = [ '%' ] # find all networks

for arg in args:

rows = self.db.execute("""select name from subnets

where name like '%s'""" % arg)

if rows == 0 and arg == '%': # empty table is OK

continue

if rows < 1:

self.abort('unknown network "%s"' % arg)

for name, in self.db.fetchall():

list.append(name)

return list

def getNetworkName(self, netid):

"""Returns a network (subnet) name from the database that

is associated with the id 'netid'.

"""

if not netid:

return ''

rows = self.db.execute("""select name from subnets where

id = %s""" % netid)

if rows > 0:

netname, = self.db.fetchone()

else:

netname = ''

"""An Interface class to add the ability to process roll arguments."""

def getRollNames(self, args, params):

"""Returns a list of (name, version) tuples from the roll

table in the database. If the PARAMS['version'] is provided

only Rolls of that version are included otherwise no filtering

on version number is performed. If the ARGS list is empty then

all Roll names are returned. SQL regexps acan be used in

both the version parameter and arg list, but must expand to

something.

"""

if params.has_key('version'):

version = params['version']

else:

version = '%' # SQL wildcard

list = []

if not args:

args = [ '%' ] # find all roll names

for arg in args:

rows = self.db.execute("""select distinct name,version

from rolls where name like '%s' and

version like '%s'""" % (arg, version))

if rows == 0 and arg == '%': # empty table is OK

continue

if rows < 1:

self.abort('unknown roll name "%s"' % arg)

for (name, ver) in self.db.fetchall():

list.append((name, ver))

"""An Interface class to add the ability to process host arguments."""

def getHostnames(self, names=None, managed_only=0):

"""Expands the given list of names to valid cluster

hostnames. A name can be a hostname, IP address, our

group (membership name), or a MAC address. Any combination of

these is valid.

If the names list is empty a list of all hosts in the cluster

is returned.

The following groups are recognized:

rackN - All non-frontend host in rack N

appliancename - All appliances of a given type (e.g. compute)

select ... - an SQL statement that returns a list of hosts

The 'managed_only' flag means that the list of hosts will

*not* contain hosts that traditionally don't have ssh login

shells (for example, the following appliances usually don't

have ssh login access: 'Ethernet Switches', 'Power Units',

'Remote Management')

"""

# Handle the simple case first and just return a complete

# list of hosts in the cluster if no list of names was

# provided

list = []

if not names:

query = 'select name from nodes'

self.db.execute(query)

for host, in self.db.fetchall():

list.append(host)

# If we're looking for managed nodes only, filter out

# the unmanaged ones using host attributes

if managed_only:

managed_list = []

for hostname in list:

if self.db.getHostAttr(hostname,

'managed') == 'true':

managed_list.append(hostname)

return managed_list

return list

# The names list was not empty so we now need to build

# a list of acceptable group names based on the rack numbers

# and appliance names (not membership names). This

# convention follows the original idea (but not code) for

# "dbreport tentakel".

groups = {}

self.db.execute('select min(rack), max(rack) from nodes')

min,max = self.db.fetchone()

for i in range(min, max+1): # racks

self.db.execute("""select n.name from

nodes n, memberships m, appliances a where

n.membership=m.id and m.appliance=a.id and

a.name!="frontend" and n.rack=%d""" % i)

l = []

for node, in self.db.fetchall():

l.append(node)

groups['rack%d' % i] = l

self.db.execute('select name from appliances')

for name, in self.db.fetchall(): # appliances

self.db.execute("""select n.name from

nodes n, memberships m, appliances a where

n.membership=m.id and m.appliance=a.id and

a.name="%s" """ % name)

l = []

for node, in self.db.fetchall():

l.append(node)

groups[name] = l

# Iterate through the list and expand all names to a list of

# host names. Also handle any names that start with 'select'

# and expand them as an SQL queury. Populate a dictionary

# to make sure we only have one entry for each host.

# Then return a sorted list of keys.

#

# We may want to add other expansion rules like the old

# FDS style %d stuff here.

dict = {}

for name in names:

if name.find('select') == 0: # SQL select

self.db.execute(name)

for host, in self.db.fetchall():

dict[host] = 1

elif name.find('%') >= 0: # SQL % pattern

self.db.execute("""select name from nodes where

name like '%s'""" % name)

for h, in self.db.fetchall():

dict[h] = 1

elif groups.has_key(name): # group name

for host in groups[name]:

dict[host] = 1

else: # host name

dict[self.db.getHostname(name)] = 1

list = dict.keys()

list.sort()

"""An Interface class to add the ability to process Category=Member arguments."""

def getCategoryIndices(self, args=None, wildcard=0):

"""Returns a list of tuples (category,index),

based upon those available in the database

Special case: args=None, args[0]='global=',

args[0]='global' returns the tuple ('global','global').

An empty list signifies category or index not found

"""

indexList=[]

if args is None or len(args) == 0 :

if wildcard:

indexList.append(('%','%'))

else:

indexList.append(('global','global'))

return indexList

if len(args[0].split('=',1)) == 2:

(category,index) = args[0].split('=',1)

else:

category = args[0]

index=None

if wildcard:

indexList.append((category,'%'))

return indexList

if category == 'global':

indexList.append(('global','global'))

return indexList

if index is None:

self.abort('Cannot have a Null index for category:%s' % category)

# Check of category is valid

rows = self.db.execute("""SELECT ID FROM categories

WHERE name='%s'""" % category)

if rows < 1:

self.abort('unknown category "%s"' % category)

# Check if member of category is valid

# ?? handling of wild-carded hosts for category=host

#

if category == 'host':

hostlist=index.split()

print "host list:" ,hostlist

for index in self.getHostnames(hostlist):

print "checking for host" ,index

rows = self.db.execute("""SELECT ID FROM vcatindex

WHERE catindex='%s' and category='%s'""" % (index,category))

if rows < 1:

self.abort('Unknown index "%s" of category "%s"' % (index,category))

indexList.append((category,index))

else:

rows = self.db.execute("""SELECT ID FROM vcatindex

WHERE catindex='%s' and category='%s'""" % (index,category))

if rows < 1:

self.abort('Unknown index "%s" of category "%s"' % (index,category))

indexList.append((category,index))

handler.DTDHandler,

handler.EntityResolver,

handler.ErrorHandler):

def __init__(self, name='', users=[]):

handler.ContentHandler.__init__(self)

self.text = ''

self.name = name

self.users = users

self.section = {}

self.section['description'] = ''

self.section['arg'] = []

self.section['param'] = []

self.section['example'] = []

self.section['related'] = []

self.parser = make_parser()

self.parser.setContentHandler(self)

def getDocbookText(self):

s = ''

s += '<section id="rocks-%s" xreflabel="%s">\n' % \

(string.join(self.name.split(' '), '-'), self.name)

s += '<title>%s</title>\n' % self.name

s += '<cmdsynopsis>\n'

s += '\t<command>rocks %s</command>\n' % self.name

for ((name, type, opt, rep), txt) in self.section['arg']:

if opt:

choice = 'opt'

else:

choice = 'req'

if rep:

repeat = 'repeat'

else:

repeat = 'norepeat'

s += '\t<arg rep="%s" choice="%s">%s</arg>\n' % \

(repeat, choice, name)

for ((name, type, opt, rep), txt) in self.section['param']:

if opt:

choice = 'opt'

else:

choice = 'req'

if rep:

repeat = 'repeat'

else:

repeat = 'norepeat'

s += '\t<arg rep="%s" choice="%s">' % (repeat, choice)

s += '%s=<replaceable>%s</replaceable>' % (name, type)

s += '</arg>\n'

s += '</cmdsynopsis>\n'

s += '<para>\n'

s += saxutils.escape(self.section['description'])

s += '\n</para>\n'

if self.section['arg']:

s += '<variablelist><title>arguments</title>\n'

for ((name, type, opt, rep), txt) in \

self.section['arg']:

s += '\t<varlistentry>\n'

if opt:

term = '<optional>%s</optional>' % name

else:

term = name

s += '\t<term>%s</term>\n' % term

s += '\t<listitem>\n'

s += '\t<para>\n'

s += saxutils.escape(txt)

s += '\n\t</para>\n'

s += '\t</listitem>\n'

s += '\t</varlistentry>\n'

s += '</variablelist>\n'

if self.section['param']:

s += '<variablelist><title>parameters</title>\n'

for ((name, type, opt, rep), txt) in \

self.section['param']:

s += '\t<varlistentry>\n'

if opt:

optStart = '<optional>'

optEnd = '</optional>'

else:

optStart = ''

optEnd = ''

key = '%s=' % name

val = '<replaceable>%s</replaceable>' % type

s += '\t<term>%s%s%s%s</term>\n' % \

(optStart, key, val, optEnd)

s += '\t<listitem>\n'

s += '\t<para>\n'

s += saxutils.escape(txt)

s += '\n\t</para>\n'

s += '\t</listitem>\n'

s += '\t</varlistentry>\n'

s += '</variablelist>\n'

if self.section['example']:

s += '<variablelist><title>examples</title>\n'

for (cmd, txt) in self.section['example']:

s += '\t<varlistentry>\n'

s += '\t<term>\n'

if 'root' in self.users:

s += '# '

else:

s += '$ '

s += 'rocks %s' % cmd

s += '\n\t</term>\n'

s += '\t<listitem>\n'

s += '\t<para>\n'

s += saxutils.escape(txt)

s += '\n\t</para>\n'

s += '\t</listitem>\n'

s += '\t</varlistentry>\n'

s += '</variablelist>\n'

if self.section['related']:

s += '<variablelist><title>related commands</title>\n'

for related in self.section['related']:

s += '\t<varlistentry>\n'

s += '\t<term>'

s += '<xref linkend="rocks-%s">' % \

string.join(related.split(' '), '-')

s += '</term>\n'

s += '\t<listitem>\n'

s += '\t<para>\n'

s += '\n\t</para>\n'

s += '\t</listitem>\n'

s += '\t</varlistentry>\n'

s += '</variablelist>\n'

s += '</section>'

return s

def getUsageText(self):

s = ''

for ((name, type, opt, rep), txt) in self.section['arg']:

if opt:

s += '[%s]' % name

else: