def __init__(self, config):
DataInterface.__init__(self, config)
self.baseDataObject = instantiateImplementation(
config.get("LdapOverride", "baseData"), config)
self.users = {}
self.lastUserUpdate = 0.0
self.fetchThreshold = float(
config.get("LdapOverride", "fetchThreshold"))
self.nameKey = config.get("LdapOverride", "nameKey")
self.idKey = config.get("LdapOverride", "idKey")
self.ldapCommand = config.get("LdapOverride", "ldapCommand")
self.dfs = instantiateImplementation(
config.get("ClusterManager", "dfs"), config)
def __init__(self, config):
DataInterface.__init__(self, config)
self.log = logging.getLogger(__name__)
self.baseDataObject = instantiateImplementation(
config.get("GetentOverride", "baseData"), config)
self.dfs = instantiateImplementation(
config.get("ClusterManager", "dfs"), config)
self.useLocal = config.get("GetentOverride", "getentFromLocalFile")
self.localFileName = config.get("GetentOverride", "getentLocalFile")
self.users = {}
self.lastUserUpdate = 0.0
self.fetchThreshold = float(
config.get("GetentOverride", "fetchThreshold"))
def __init__(self, config, data):
self.config = config
self.data = data
self.log = logging.getLogger(__name__)
self.hardware = instantiateImplementation("zoni.hardware.systemmanagement.SystemManagement", self.config, self.data)
print self.data.conn
def __init__(self, config, client):
self.config = config
self.client = client
self.hooks = []
self.log = logging.getLogger(__file__)
self.scheduleDelay = float(self.config.get("Primitive", "scheduleDelay"))
self.densePack = boolean(self.config.get("Primitive", "densePack"))
self.hosts = {}
# Zoni
self.minServersOn = 3
self.shutdownDelay = 300
self.pcm = zoni.services.rpycservices.client("zoni", 12345).createConn()
self.zoniStateFile = "/var/tmp/zoniStateFile"
if os.path.exists(self.zoniStateFile):
self.zoniState = self.__loadZoniState(self.zoniStateFile)
else:
self.zoniState = {}
self.__initState()
items = self.config.items("Primitive")
items.sort()
for item in items:
(name, value) = item
name = name.lower()
if (name.startswith("hook")):
try:
self.hooks.append(instantiateImplementation(value, config, client, False))
except:
self.log.exception("Failed to load hook %s" % (value))
def __iterateHardware(self, nodeName, cmd, *args):
retries = 2
mycmd = "%s()" % (cmd)
self.host = self.__getHostInfo(nodeName)
hw = self.data.getHardwareCapabilities(nodeName)
# getHardwareCapabilities return a list of lists with
# [0] = hw method
# [1] = hw method userid
# [2] = hw method password
success = 0
for i in hw:
__inst = instantiateImplementation(self.config['hardwareControl'][i[0]]['class'], self.config, nodeName, self.host)
a = "inst.%s" % mycmd
for count in range(retries):
doit = eval(a)
if doit > 0:
self.log.info("%s method success (%s) on %s (attempt %s)", i[0], mycmd, nodeName, count + 1)
success = 1
# IF we use soft poweroff, start a thread to poweroff after 60 seconds to
# guarantee. If the node doesn't have acpi installed, powerOffSoft doesn't do
# anything
if "powerOffSoft" in mycmd:
threading.Thread(args=(i[0], nodeName), target=self.softPowerConfirm).start()
break
else:
self.log.error("%s method failed (%s) on %s (attempt %s)", i[0], mycmd, nodeName, count + 1)
if success:
break
return doit
def initAccountingServer(self):
service = instantiateImplementation(
self.config.get("Accounting", "service"), self.config)
#XXXstroucki: disabled authAndEncrypt for now
#if boolean(self.config.get("Security", "authAndEncrypt")):
if False:
pass
else:
# XXXstroucki: ThreadedServer is liable to have
# exceptions within if an endpoint is lost.
t = ThreadedServer(service=rpycservices.ManagerService,
hostname='0.0.0.0',
port=int(
self.config.get('AccountingService',
'port')),
auto_register=False)
t.logger.setLevel(logging.ERROR)
t.service.service = service
t.service._type = 'AccountingService'
debugConsole(globals())
t.start()
# shouldn't exit by itself
sys.exit(0)
def startClusterManager(config):
global service, data
dfs = instantiateImplementation(config.get("ClusterManager", "dfs"),
config)
data = instantiateImplementation(config.get("ClusterManager", "data"),
config)
service = instantiateImplementation(
config.get("ClusterManager", "service"), config, data, dfs)
if boolean(config.get("Security", "authAndEncrypt")):
users = {}
userDatabase = data.getUsers()
for user in userDatabase.values():
if user.passwd != None:
users[user.name] = user.passwd
users[config.get('AllowedUsers', 'nodeManagerUser')] = config.get(
'AllowedUsers', 'nodeManagerPassword')
users[config.get('AllowedUsers',
'agentUser')] = config.get('AllowedUsers',
'agentPassword')
authenticator = TlsliteVdbAuthenticator.from_dict(users)
# XXXstroucki ThreadedServer is liable to have exceptions
# occur within if an endpoint is lost.
t = ThreadedServer(service=rpycservices.ManagerService,
hostname='0.0.0.0',
port=int(config.get('ClusterManagerService',
'port')),
auto_register=False,
authenticator=authenticator)
else:
t = ThreadedServer(service=rpycservices.ManagerService,
hostname='0.0.0.0',
port=int(config.get('ClusterManagerService',
'port')),
auto_register=False)
t.logger.setLevel(logging.ERROR)
t.service.service = service
t.service._type = 'ClusterManagerService'
debugConsole(globals())
t.start()
# shouldn't exit by itself
return
def startZoniManager(config):
data = instantiateImplementation(
"zoni.data.resourcequerysql.ResourceQuerySql", config)
service = instantiateImplementation(
"zoni.services.pcvciservice.pcmService", config, data)
#hardware = instantiateImplementation("zoni.services.hardwareservice.HardwareService", config, data)
t = ThreadedServer(service=ManagerService,
hostname='0.0.0.0',
port=12345,
auto_register=False)
t.logger.quiet = True
t.service.service = service
#t.service.hardware = hardware
t.service._type = "pcmService"
debugConsole(globals())
t.start()
def main():
(config, configFiles) = getConfig(["Agent"])
publisher = instantiateImplementation(config.get("Agent", "publisher"), config)
tashi.publisher = publisher
client = createClient(config)
logging.config.fileConfig(configFiles)
agent = Primitive(config, client)
#agent.conservePower()
agent.start()
def softPowerConfirm(self, method, nodeName):
# using a sleep for now...
time.sleep(30)
__inst = instantiateImplementation(self.config['hardwareControl'][method]['class'], self.config, nodeName, self.host)
mycmd = "%s()" % ("powerOff")
a = "inst.%s" % mycmd
doit = eval(a)
if doit > 0:
self.log.info("%s method success after soft power off(%s))", method[0], mycmd, nodeName)
else:
self.log.error("%s method failed after soft power off(%s))", method[0], mycmd, nodeName)
exit()
def startNodeManager():
global config, dfs, vmm, service, server, log, notifier
publisher = instantiateImplementation(
config.get("NodeManager", "publisher"), config)
tashi.publisher = publisher
dfs = instantiateImplementation(config.get("NodeManager", "dfs"), config)
vmm = instantiateImplementation(config.get("NodeManager", "vmm"), config,
dfs, None)
service = instantiateImplementation(config.get("NodeManager", "service"),
config, vmm)
vmm.nm = service
if boolean(config.get("Security", "authAndEncrypt")):
users = {}
users[config.get('AllowedUsers', 'clusterManagerUser')] = config.get(
'AllowedUsers', 'clusterManagerPassword')
authenticator = TlsliteVdbAuthenticator.from_dict(users)
# XXXstroucki: ThreadedServer is liable to have exceptions
# occur within if an endpoint is lost.
t = ThreadedServer(service=rpycservices.ManagerService,
hostname='0.0.0.0',
port=int(config.get('NodeManagerService', 'port')),
auto_register=False,
authenticator=authenticator)
else:
t = ThreadedServer(service=rpycservices.ManagerService,
hostname='0.0.0.0',
port=int(config.get('NodeManagerService', 'port')),
auto_register=False)
t.logger.setLevel(logging.ERROR)
t.service.service = service
t.service._type = 'NodeManagerService'
debugConsole(globals())
t.start()
# shouldn't exit by itself
sys.exit(0)
def __init__(self, config):
self.log = logging.getLogger(__file__)
self.hooks = []
items = config.items("MauiWiki")
items.sort()
for item in items:
(name, value) = item
name = name.lower()
if (name.startswith("hook")):
try:
self.hooks.append(
instantiateImplementation(value, config, client,
transport, False))
except:
self.log.exception("Failed to load hook %s" % (value))
(self.client, self.transport) = createClient(config)
def __init__(self, config):
DataInterface.__init__(self, config)
self.uri = self.config.get("SQL", "uri")
self.log = logging.getLogger(__name__)
self.dfs = instantiateImplementation(
config.get("ClusterManager", "dfs"), config)
if (self.uri.startswith("sqlite://")):
import sqlite
self.dbEngine = "sqlite"
self.conn = sqlite.connect(self.uri[9:],
autocommit=1,
timeout=1500)
elif (self.uri.startswith("mysql://")):
import MySQLdb
self.dbEngine = "mysql"
uri = self.uri[8:]
(user, _, hostdb) = stringPartition(uri, '@')
(host, _, db) = stringPartition(hostdb, '/')
self.password = self.config.get('SQL', 'password')
self.conn = MySQLdb.connect(host=host,
user=user,
passwd=self.password,
db=db)
else:
raise TashiException, 'Unknown SQL database engine by URI: %s' % (
self.uri)
self.instanceOrder = [
'id', 'vmId', 'hostId', 'decayed', 'state', 'userId', 'name',
'cores', 'memory', 'disks', 'nics', 'hints', 'groupName'
]
self.hostOrder = [
'id', 'name', 'up', 'decayed', 'state', 'memory', 'cores',
'version', 'notes', 'reserved'
]
self.instanceLock = threading.Lock()
self.instanceIdLock = threading.Lock()
self.instanceLocks = {}
self.instanceBusy = {}
self.hostLock = threading.Lock()
self.hostLocks = {}
self.maxInstanceId = 1
self.idLock = threading.Lock()
self.sqlLock = threading.Lock()
self.verifyStructure()
def __init__(self, config):
self.config = config
self.cm = createClient(config)
self.hooks = []
self.log = logging.getLogger(__file__)
items = self.config.items("Accounting")
items.sort()
for item in items:
(name, value) = item
name = name.lower()
if (name.startswith("hook")):
try:
self.hooks.append(
instantiateImplementation(value, self.config, self.cm,
False))
except:
self.log.exception("Failed to load hook %s" % (value))
def main():
global log
# setup configuration and logging
config = Config(["ClusterManager"])
configFiles = config.getFiles()
publisher = instantiateImplementation(
config.get("ClusterManager", "publisher"), config)
tashi.publisher = publisher
logging.config.fileConfig(configFiles)
log = logging.getLogger(__file__)
log.info('Using configuration file(s) %s' % configFiles)
# bind the database
log.info('Starting cluster manager')
# handle keyboard interrupts (http://code.activestate.com/recipes/496735-workaround-for-missed-sigint-in-multithreaded-prog/)
child = os.fork()
if child == 0:
startClusterManager(config)
# shouldn't exit by itself
sys.exit(0)
else:
# main
try:
os.waitpid(child, 0)
except KeyboardInterrupt:
log.info("Exiting cluster manager after receiving a SIGINT signal")
os._exit(0)
except Exception:
log.exception("Abnormal termination of cluster manager")
os._exit(-1)
log.info("Exiting cluster manager after service thread exited")
os._exit(-1)
return
def main():
config = Config(["Accounting"])
configFiles = config.getFiles()
publisher = instantiateImplementation(
config.get("Accounting", "publisher"), config)
tashi.publisher = publisher
logging.config.fileConfig(configFiles)
log = logging.getLogger(__name__)
log.info('Using configuration file(s) %s' % configFiles)
accounting = Accounting(config)
# handle keyboard interrupts (http://code.activestate.com/recipes/496735-workaround-for-missed-sigint-in-multithreaded-prog/)
child = os.fork()
if child == 0:
accounting.initAccountingServer()
# shouldn't exit by itself
sys.exit(0)
else:
# main
try:
os.waitpid(child, 0)
except KeyboardInterrupt:
log.info(
"Exiting accounting service after receiving a SIGINT signal")
os._exit(0)
except Exception:
log.exception("Abnormal termination of accounting service")
os._exit(-1)
log.info("Exiting accounting service after service thread exited")
os._exit(-1)
return
def __init__(self, config):
self.log = logging.getLogger(__name__)
self.log.setLevel(logging.INFO)
self.config = config
self.hooks = []
self.pollSleep = None
# XXXstroucki new python has fallback values
try:
# load hooks
items = self.config.items("AccountingService")
items.sort()
for item in items:
(name, value) = item
name = name.lower()
if (name.startswith("hook")):
try:
self.hooks.append(instantiateImplementation(value, self.config))
except:
self.log.exception("Failed to load hook %s" % (value))
except:
pass
def main():
""" Main """
ver = version.split(" ")[0]
rev = revision
(configs, configFiles) = getConfig()
logging.config.fileConfig(configFiles)
#log = logging.getLogger(os.path.basename(__file__))
#logit(configs['logFile'], "Starting Zoni client")
#logit(configs['logFile'], "Loading config file")
parser = optparse.OptionParser(usage="%prog [-n] [-u] [--uid] [-v]",
version="%prog " + ver + " " + rev)
parser.add_option("-n", "--nodeName", dest="nodeName", help="Specify node")
parser.add_option("--switchPort",
"--switchport",
dest="switchPort",
help="Specify switchport switchname:portnum")
parser.add_option("-u",
"--userName",
dest="userName",
help="Specify user name")
parser.add_option("--uid", dest="uid", help="Specify user id")
parser.add_option("-v",
"--verbose",
dest="verbosity",
help="Be verbose",
action="store_true",
default=False)
parser.add_option("--Name",
"--name",
dest="Name",
help="Specify name of entry")
parser.add_option("--Show",
"--show",
dest="show",
help="Show something",
default=None,
action="store_true")
parser.add_option("-d",
"--domain",
dest="domain",
help="Work with this domain")
parser.add_option("--notes",
"--Notes",
dest="myNotes",
help="Notes",
default="")
parser.add_option("--force",
dest="forcefully",
help="Apply gentle pressure",
default=False,
action="store_true")
# Hardware controller
group = optparse.OptionGroup(parser, "Hardware control",
"Options for node power control")
group.add_option("--hw",
dest="hardwareType",
help="Make hardware call to ipmi|drac|pdu")
group.add_option("--powerStatus",
"--powerstatus",
dest="POWERSTATUS",
help="Get power status on node",
action="store_true",
default=False)
group.add_option("--reboot",
"--reboot",
dest="REBOOTNODE",
help="Reboot node (Soft)",
action="store_true",
default=False)
group.add_option("--powerCycle",
"--powercycle",
dest="POWERCYCLE",
help="Power Cycle (Hard)",
action="store_true",
default=False)
group.add_option("--powerOff",
"--poweroff",
dest="POWEROFF",
help="Power off node",
action="store_true",
default=False)
group.add_option("--powerOffSoft",
"--poweroffsoft",
dest="POWEROFFSOFT",
help="Power off node (soft)",
action="store_true",
default=False)
group.add_option("--powerOn",
"--poweron",
dest="POWERON",
help="Power on node",
action="store_true",
default=False)
group.add_option("--powerReset",
"--powerreset",
dest="POWERRESET",
help="Power reset node",
action="store_true",
default=False)
group.add_option("--console",
dest="CONSOLE",
help="Console mode",
action="store_true",
default=False)
# Extensions from MIMOS - specific only for HP Blades and HP c7000 Blade Enclosures
group.add_option(
"--powerOnNet",
"--poweronnet",
dest="POWERONENET",
help=
"Power on Node into PXE (Currently support on HP Blades through HP c7000 Blade Enclosure)",
action="store_true",
default=False)
parser.add_option_group(group)
# Query Interface
group = optparse.OptionGroup(parser, "Query Interface",
"Query current systems and allocations")
group.add_option("-R",
"--showReservation",
"--showreservation",
dest="showReservation",
help="Show current node reservations",
action="store_true",
default=False)
group.add_option("-A",
"--showAllocation",
"--showallocation",
dest="showAllocation",
help="Show current node allocation",
action="store_true",
default=False)
group.add_option("-S",
"--showResources",
dest="showResources",
help="Show available resources to choose from",
action="store_true",
default=False)
group.add_option("--getResources",
"--getresources",
dest="getResources",
help="Get available resources to choose from",
action="store_true",
default=False)
group.add_option("-p",
"--procs",
dest="numProcs",
help="Set number of processors")
group.add_option("-c",
"--clock",
dest="clockSpeed",
help="Processor clock")
group.add_option("--memory",
dest="numMemory",
help="Amount of memory (Bytes)")
group.add_option("-f", "--cpuflags", dest="cpuFlags", help="CPU flags")
group.add_option("--cores", dest="numCores", help="Number of Cores")
group.add_option("-I",
"--showPxeImages",
"--showpxeimages",
dest="showPxeImages",
help="Show available PXE images to choose from",
action="store_true",
default=False)
group.add_option("-M",
"--showPxeImageMap",
"--showpxeimagemap",
dest="showPxeImageMap",
help="Show PXE images host mapping",
action="store_true",
default=False)
parser.add_option_group(group)
#parser.add_option("-p", "--printResources", dest="printResources", help="Print available resources to choose from", action="store_true", default=False)
# Admin Interface
group = optparse.OptionGroup(parser, "Admin Interface",
"Administration Interface:")
group.add_option("--admin",
dest="ADMIN",
help="Enter Admin mode",
action="store_true",
default=False)
group.add_option("--setPortMode",
"--setportmode",
dest="setPortMode",
help="Set port mode to access, trunk, or general")
group.add_option("--enableHostPort",
"--enablehostport",
dest="enableHostPort",
help="Enable a switch port",
action="store_true",
default=False)
group.add_option("--disableHostPort",
"--disablehostport",
dest="disableHostPort",
help="Disable a switch port",
action="store_true",
default=False)
group.add_option("--destroyVlan",
"--destroyvlan",
dest="destroyVlanId",
help="Remove vlan from all switches")
group.add_option("--createVlan",
"--createvlan",
dest="createVlanId",
help="Create a vlan on all switches")
group.add_option("--addNodeToVlan",
"--addnodetovlan",
dest="add2Vlan",
help="Add node to a vlan (:tagged)")
group.add_option("--removeNodeFromVlan",
"--removenodefromvlan",
dest="removeFromVlan",
help="Remove node from a vlan")
group.add_option("--setNativeVlan",
"--setnativevlan",
dest="setNative",
help="Configure native vlan")
group.add_option("--restoreNativeVlan",
"--restorenativevlan",
dest="restoreNative",
help="Restore native vlan",
action="store_true",
default=False)
group.add_option("--removeAllVlans",
"--removeallvlans",
dest="removeAllVlans",
help="Removes all vlans from a switchport",
action="store_true",
default=False)
group.add_option(
"--sendSwitchCommand",
"--sendswitchcommand",
dest="sendSwitchCommand",
help=
"Send Raw Switch Command, VERY DANGEROUS. config;interface switchport ethernet g14;etc"
)
group.add_option("--interactiveSwitchConfig",
"--interactiveswitchconfig",
dest="interactiveSwitchConfig",
help="Interactively configure a switch. switchhname")
group.add_option("--showSwitchConfig",
"--showswitchconfig",
dest="showSwitchConfig",
help="Show switch config for node",
action="store_true",
default=False)
group.add_option("--register",
dest="register",
help="Register hardware to Zoni",
action="store_true",
default=False)
group.add_option("--labelPort",
dest="labelPort",
help="Label switch port",
action="store_true",
default=False)
group.add_option("--saveConfig",
dest="saveConfig",
help="SWITCHNAME - Save Switch Config")
parser.add_option_group(group)
# Switch
#group = optparse.OptionGroup(parser, "Switch Interface", "Switch Interface:")
#group.add_option("--rawswitch", dest="RAWSWITCH", help="Enter RAW Switch Admin mode", action="store_true", default=False)
#group.add_option("--enablePort", "--enableport", dest="enablePort", help="Enable a port on the switch")
#group.add_option("--disablePort", "--disableport", dest="disablePort", help="Disable a port on the switch")
#group.add_option("--addVlanToTrunks", "--addvlantotrunks", dest="addVlanToTrunks", help="")
# Domain Interface
group = optparse.OptionGroup(parser, "Domain Interface",
"Manage Zoni Domain:")
group.add_option("-D",
"--showDomains",
"--showdomains",
dest="showDomains",
help="Show Zoni domains",
action="store_true",
default=False)
group.add_option("--addDomain",
"--adddomain",
dest="addDomain",
help="Add new domain to Zoni",
action="store_true",
default=False)
group.add_option("--removeDomain",
"--removedomain",
dest="removeDomain",
help="remove a domain from Zoni",
action="store_true",
default=False)
group.add_option("-V",
"--showVlans",
"--showvlans",
dest="showVlans",
help="Show an from Zoni",
action="store_true",
default=False)
#group.add_option("--addVlan", "--addvlan", dest="addVlan", help="Add new vlan to Zoni", action="store_true", default=False)
#group.add_option("--removeVlan", "--removevlan", dest="removeVlan", help="Remove an from Zoni", action="store_true", default=False)
group.add_option("--assignVlan",
"--assignvlan",
dest="assignVlan",
help="Assign vlan to a domain")
parser.add_option_group(group)
# Allocation Interface
group = optparse.OptionGroup(parser, "Allocation Interface",
"Change current systems allocations:")
#group.add_option("--addReservation", "--addreservation", dest="addReservation", help="Add a Reservation", action="store_true", default=False)
group.add_option("--addImage",
"--addimage",
dest="addImage",
help="Add image to Zoni - amd64-image:dist:dist_ver")
group.add_option("--delImage",
"--delimage",
dest="delImage",
help="Delete PXE image")
#group.add_option("--addPxeImage", "--addpxeimage", dest="imageName", help="Add PXE image to database", action="store_true", default=False)
group.add_option("--assignImage",
"--assignimage",
dest="assignImage",
help="Assign image to resource")
group.add_option("--imageName",
"--imagename",
dest="imageName",
help="Assign image to resource")
group.add_option("--allocateNode",
"--allocatenode",
dest="allocateNode",
help="Assign node to a user",
action="store_true",
default=False)
group.add_option("--vlaninfo",
"--vlanInfo",
dest="vlanInfo",
help="Specify vlan info for allocation")
group.add_option("--vlanIsolate",
"--vlanisolate",
dest="vlanIsolate",
help="Specify vlan for network isolation")
group.add_option("--hostName",
"--hostname",
dest="hostName",
help="Specify hostname for node")
group.add_option("--ipaddr",
dest="ipAddr",
help="Specify ip address for node")
group.add_option("--releaseNode",
"--releasenode",
dest="releaseNode",
help="Release current node allocation",
action="store_true",
default=False)
group.add_option(
"--reservationDuration",
"--reservationduration",
dest="reservationDuration",
help="Specify duration of node reservation - YYYYMMDD format")
group.add_option("-r",
"--reservationId",
"--reservationid",
dest="reservationId",
help="Reservation ID")
group.add_option("--updateReservation",
"--updatereservation",
dest="updateReservation",
help="Update Reservation",
action="store_true",
default=False)
group.add_option("--delReservation",
"--delreservation",
dest="delReservation",
help="Delete Reservation")
group.add_option("--rgasstest",
dest="rgasstest",
help="Debug testing function",
action="store_true",
default=False)
parser.add_option_group(group)
group = optparse.OptionGroup(parser, "Reservation Interface",
"Change current systems reservations:")
group.add_option("--createReservation",
"--createreservation",
dest="createReservation",
help="Create a new Reservation",
action="store_true",
default=False)
parser.add_option_group(group)
# Zoni Helpers
group = optparse.OptionGroup(parser, "Zoni Helpers", "Helper functions:")
group.add_option("--addDns",
dest="addDns",
help="Add a DNS entry",
action="store_true",
default=False)
group.add_option("--removeDns",
dest="removeDns",
help="Remove a DNS entry",
action="store_true",
default=False)
group.add_option("--addCname",
dest="addCname",
help="Add a DNS Cname entry",
action="store_true",
default=False)
group.add_option("--removeCname",
dest="removeCname",
help="Remove a DNS Cname entry",
action="store_true",
default=False)
group.add_option("--addDhcp",
dest="addDhcp",
help="Add a DHCP entry",
action="store_true",
default=False)
group.add_option("--removeDhcp",
dest="removeDhcp",
help="Remove a DHCP entry",
action="store_true",
default=False)
parser.add_option_group(group)
# Extensions from MIMOS
group = optparse.OptionGroup(parser, "Zoni MIMOS Extensions",
"Special Functions created by MIMOS Lab:")
group.add_option(
"--addRole",
"--addrole",
dest="addRole",
help=
"Create a disk based installation default file for a node based on its role or function, e.g. one|oned|cc|clc|walrus|sc|nc|preseed|kickstart",
default=None,
action="store")
group.add_option("--removeRole",
"--removerole",
dest="removeRole",
help="Remove the default file of a node",
action="store_true",
default=False)
group.add_option("--showRoleMap",
dest="showRoleMap",
help="Show Role to Host Mapping",
action="store_true",
default=False)
group.add_option("--showKernel",
dest="showKernelInfo",
help="Show Kernel Info",
action="store_true",
default=False)
group.add_option("--showInitrd",
dest="showInitrdInfo",
help="Show Initrd Info",
action="store_true",
default=False)
group.add_option(
"--registerKernelInitrd",
dest="registerKernelInitrd",
help=
"Register Kernel and Initrd - vmlinuz:vmlinuz-ver:vmlinuz-arch:initrd:initrd-arch:imagename"
)
group.add_option(
"--getKernelInitrdID",
dest="getKernelInitrdID",
help="Get corresponding Kernel and Initrd Info - vmlinuz:initrd:arch")
group.add_option(
"--getConfig",
dest="getConfig",
help=
"Get a value from ZoniDefault.cfg - e.g. tftpRootDir, initrdRoot, kernelRoot, fsImagesBaseDir, etc.",
default=None,
action="store")
parser.add_option_group(group)
(options, args) = parser.parse_args()
cmdargs = {}
# setup db connection
#print "starting tread"
#threading.Thread(daemon=True, target=self.dbKeepAlive()).start()
#print "after tread"
data = instantiateImplementation(
"zoni.data.resourcequerysql.ResourceQuerySql", configs,
options.verbosity)
reservation = instantiateImplementation(
"zoni.data.reservation.reservationMysql", configs, data,
options.verbosity)
#query = zoni.data.resourcequerysql.ResourceQuerySql(configs, options.verbosity)
# Extensions from MIMOS
mimos = instantiateImplementation("zoni.extensions.m_extensions.mimos",
configs)
# Get host info
host = None
if options.nodeName:
host = data.getHostInfo(options.nodeName)
#print host
# Hardware control
if options.hardwareType and options.nodeName:
host = data.getHostInfo(options.nodeName)
if options.hardwareType == "ipmi":
#hardware = zoni.hardware.systemmanagement.SystemManagement(configs,data)
hw = Ipmi(configs, options.nodeName, host)
#
if options.hardwareType == "pdu":
hw = raritanDominionPx(configs, options.nodeName, host)
#
if options.hardwareType == "drac":
## Check if node has drac card
if "drac_name" in host:
hw = dellDrac(configs, options.nodeName, host)
else:
mesg = "Host (%s) does not have a DRAC card!!\n" % options.nodeName
sys.stdout.write(mesg)
exit(1)
## Extensions from MIMOS - For Dell Blades - calling Dell Blades via the Blade Enclosure, some DRAC commands are slightly different from the ones in blade enclosure when compared to those in the actual blade, this allow a bit more flexiblity and standard calls to the blades
if options.hardwareType == "dracblade":
hw = dellBlade(configs, options.nodeName, host)
## Extensions from MIMOS - For HP Blades - calling HP Blades via the HP c7000 Blade Enclosure instead of direct to the blade server itself, this allow a bit more flexiblity and standard calls to the blades
if options.hardwareType == "hpilo":
hw = hpILO(configs, options.nodeName, host)
if (options.REBOOTNODE or options.POWERCYCLE or options.POWEROFF or options.POWEROFFSOFT or \
options.POWERON or options.POWERSTATUS or options.CONSOLE or \
options.POWERONNET or options.POWERRESET) and options.nodeName: # Extensions from MIMOS - added POWERONNET
if options.verbosity:
hw.setVerbose(True)
if options.REBOOTNODE:
hw.powerReset()
exit()
if options.POWERCYCLE:
hw.powerCycle()
exit()
if options.POWEROFF:
hw.powerOff()
exit()
if options.POWEROFFSOFT:
hw.powerOffSoft()
exit()
if options.POWERON:
hw.powerOn()
exit()
if options.POWERRESET:
hw.powerReset()
exit()
if options.POWERSTATUS:
hw.getPowerStatus()
exit()
if options.CONSOLE:
hw.activateConsole()
exit()
## Extensions from MIMOS - For HP Blade via c7000 Blade Enclosure
if options.POWERONNET:
hw.powerOnNet()
exit()
hw.getPowerStatus()
exit()
else:
hw = zoni.hardware.systemmanagement.SystemManagement(configs, data)
if (options.REBOOTNODE or options.POWERCYCLE or options.POWEROFF or options.POWEROFFSOFT or \
options.POWERON or options.POWERSTATUS or options.CONSOLE or \
options.POWERRESET) and options.nodeName:
if options.verbosity:
hw.setVerbose(True)
if options.REBOOTNODE:
hw.powerReset(options.nodeName)
exit()
if options.POWERCYCLE:
hw.powerCycle(options.nodeName)
exit()
if options.POWEROFFSOFT:
hw.powerOffSoft(options.nodeName)
exit()
if options.POWEROFF:
hw.powerOff(options.nodeName)
exit()
if options.POWERON:
hw.powerOn(options.nodeName)
exit()
if options.POWERRESET:
hw.powerReset(options.nodeName)
exit()
if options.POWERSTATUS:
hw.getPowerStatus(options.nodeName)
exit()
if options.CONSOLE:
hw.activateConsole(options.nodeName)
exit()
hw.getPowerStatus(options.nodeName)
if (options.REBOOTNODE or options.POWERCYCLE or options.POWEROFF or \
options.POWERON or options.POWERSTATUS or options.CONSOLE or \
options.POWERRESET) and not options.nodeName:
parser.print_help()
mesg = "\nMISSSING OPTION: Node name required -n or --nodeName\n"
print mesg
exit()
# Query Interface
if (options.numProcs):
cmdargs["num_procs"] = options.numProcs
if (options.numMemory):
cmdargs["mem_total"] = options.numMemory
if (options.clockSpeed):
cmdargs["clock_speed"] = options.clockSpeed
if (options.numCores):
cmdargs["num_cores"] = options.numCores
if (options.cpuFlags):
cmdargs["cpu_flags"] = options.cpuFlags
if (options.nodeName):
cmdargs["sys_id"] = options.nodeName
if (options.numCores or options.clockSpeed or options.numMemory
or options.numProcs
or options.cpuFlags) and not options.showResources:
usage = "MISSING OPTION: When specifying hardware parameters, you need the -s or --showResources switch"
print usage
parser.print_help()
exit()
if options.getResources:
print "ALL resources"
print data.getAvailableResources()
key = "3Lf7Qy1oJZue1q/e3ZQbfg=="
print "Tashi Resources"
print data.getMyResources(key)
# Show current allocations
if (options.showAllocation) or (options.show
and re.match(".lloca.*", args[0])):
if options.uid:
nameorid = int(options.uid)
else:
nameorid = options.userName
data.showAllocation(nameorid)
exit()
# Show current reservation
if options.showReservation or (options.show
and re.match(".eserv.*", args[0])):
if options.uid:
nameorid = int(options.uid)
else:
nameorid = options.userName
data.showReservation(nameorid)
# Print all Resources
if options.showResources or (options.show
and re.match(".esour.*", args[0])):
data.showResources(cmdargs)
# Show PXE images
#if (options.show and re.match(".esour.*", args[0])):
if options.showPxeImages or (options.show and re.match("pxei.*", args[0])):
data.showPxeImages()
# Show machine to PXE image mapping
if options.showPxeImageMap or (options.show
and re.match("pxem.*", args[0])):
data.showPxeImagesToSystemMap(cmdargs)
if (len(sys.argv) == 1):
parser.print_help()
exit()
# Delete reservation
if (options.delReservation):
data.removeReservation(options.delReservation)
exit()
# Specify usermanagement, ldap or files
if configs['userManagement'] == "ldap":
usermgt = usermanagement.ldap()
elif configs['userManagement'] == "files":
usermgt = usermanagement.files()
else:
print "User management problem"
exit()
if (options.rgasstest):
#data.getHardwareCapabilities(options.nodeName)
#pdu = raritanDominionPx(host)
#print pdu
#bootit = pxe.Pxe(configs, options.verbosity)
#bootit.createPxeUpdateFile(data.getPxeImages())
#bootit.updatePxe()
#print "host is ", host
#drac = dellDrac("drac-r2r1c3", 1)
drac = dellDrac(configs, options.nodeName, host)
#drac.getPowerStatus()
#drac.powerOff()
#drac.powerOn()
#drac.powerCycle()
drac.setVerbose(options.verbosity)
drac.powerReset()
#drac.getPowerStatus()
#print "host is ", host
#pdu = raritanDominionPx(configs, options.nodeName, host)
#print "pdu", pdu
#pdu.getPowerStatus()
#exit()
# Create a reservation for a user
if (options.createReservation):
if not (options.userName or options.uid):
mesg = "ERROR: CreateReservation requires the following arguments...\n"
if not (options.userName or options.uid):
mesg += " Username: --userName=username or --uid 1000\n"
mesg += " Reservation Duration: --reservationDuration YYYYMMDD or numdays(optional, default 15 days)\n"
mesg += " Notes: --notes(optional)\n"
sys.stderr.write(mesg)
exit()
userId = options.uid
if not userId:
userId = usermgt.getUserId(options.userName)
if userId:
__reservationId = reservation.createReservation(
userId, options.reservationDuration,
options.myNotes + " " + str(string.join(args[0:len(args)])))
else:
print "user doesn't exist"
exit()
# Allocate node to user
if (options.allocateNode):
if options.reservationId and options.domain and options.vlanInfo and options.nodeName and options.imageName:
host = data.getHostInfo(options.nodeName)
# optparse does not pass multiple args that are quoted anymore?
# Used to work with python 2.5.2. Doesn't work with python 2.6.5.
data.allocateNode(
options.reservationId, options.domain, host['sys_id'],
options.vlanInfo, options.imageName, options.hostName,
options.myNotes + " " + str(string.join(args[0:len(args)])))
else:
mesg = "USAGE: %s --allocateNode --nodeName nodeName --domain domainname --reservationId ID --vlanInfo vlanNums:info, --imageName imagename [--notes]\n" % (
sys.argv[0])
mesg += "Options\n"
mesg += " --domain testdomain\n"
mesg += " --reservationId 10\n"
mesg += " --vlanInfo 999:native,1000:tagged,1001:tagged\n"
mesg += " --imageName imageName (see available images with 'zoni -I')\n"
mesg += " --hostName mynode01 (optional)\n"
mesg += " --notes \"your notes here \"(optional)\n"
sys.stdout.write(mesg)
exit()
if not (options.reservationId) or not options.nodeName:
mesg = "ERROR: AllocateNode requires the following arguments...\n"
if not (options.nodeName):
mesg += " NodeName: --nodeName r1r1u25 \n"
if not (options.reservationId):
mesg += " ReservationId: --reservationId IDNUM(add nodes to an existing reservation)\n"
mesg += " Hostname: --hostName mynode01\n"
mesg += " Domain: --vlanIsolate vlan_num(default 999)\n"
mesg += " IP address: --ipaddr 172.17.10.100\n"
mesg += " Notes: --notes(optional)\n"
sys.stderr.write(mesg)
exit()
# Reconfigure switchports
memberMap = data.getDomainMembership(host['sys_id'])
HwSwitch = HwDellSwitch
hwswitch = HwSwitch(configs, host)
for vlan, tag in memberMap.iteritems():
hwswitch.addNodeToVlan(vlan, tag)
# Register node in DNS
if options.hostName:
# Add cname
cmd = "zoni --addCname %s %s" % (options.hostName,
host['location'])
subprocess.Popen(string.split(cmd))
#data.allocateNode(options.reservationId, options.domain, host['sys_id'], options.vlanInfo, options.imageName, options.hostName, options.myNotes + " " + str(string.join(args[0:len(args)])))
#data.allocateNode(options.reservationId, host['sys_id'], options.hostName, vlanNum, options.ipAddr, options.myNotes)
exit()
# Update allocation
if (options.updateReservation):
if not options.reservationId:
mesg = "ERROR: UpdateReservation requires the following arguments...\n"
if not (options.reservationId):
mesg += " Reservation ID: --reservationId RES\n"
mesg += " NodeName: --nodeName r1r1u25 (optional)\n"
mesg += " Username: --userName=username or --uid 1000 (optional)\n"
mesg += " Reservation Duration: --reservationDuration YYYYMMDD or numdays (optional, default 15 days)\n"
mesg += " Vlan: --vlanIsolate vlan_num(optional)\n"
mesg += " Notes: --notes(optional)\n"
sys.stderr.write(mesg)
exit()
userId = None
if options.uid or options.userName:
# Get the username from uid
userId = options.uid
if not options.uid:
userId = usermgt.getUserId(options.userName)
data.updateReservation(options.reservationId, userId,
options.reservationDuration,
options.vlanIsolate, options.myNotes)
# Release node allocation
if (options.releaseNode):
if not options.nodeName:
mesg = "ERROR: releaseNode requires the following arguments...\n"
if not (options.nodeName):
mesg += " NodeName: --nodeName r1r1u25 \n"
sys.stderr.write(mesg)
exit()
data.releaseNode(options.nodeName)
# Assign image to host
if (options.assignImage):
if not options.nodeName:
usage = "Node not specified. Please specify a node with --nodeName or -n"
print usage
exit()
# need to fix this later
#if data.assignImagetoHost(host, options.assignImage):
#print "ERROR"
#exit()
# Update PXE
bootit = Pxe(configs, data, options.verbosity)
bootit.setBootImage(host['mac_addr'], options.assignImage)
#bootit.createPxeUpdateFile(data.getPxeImages())
#bootit.updatePxe()
# Add image to database
if (options.addImage):
data.addImage(options.addImage)
# Delete PXE image
if (options.delImage):
data.delImage(options.delImage)
# Domain interface
if (options.showDomains):
data.showDomains()
if (options.addDomain):
if len(args) > 2 and options.vlanInfo:
data.addDomain(args[0], string.join(args[1:len(args)]),
options.vlanInfo)
else:
mesg = "USAGE: %s --addDomain domainname \"domain desc\" --vlanInfo vlan:type,vlan:type\n" % (
sys.argv[0])
mesg += "Options\n\n --vlanInfo 999:native,1000:untagged,1001:tagged\n"
sys.stdout.write(mesg)
exit()
if (options.removeDomain):
if len(args) > 0:
data.removeDomain(args[0])
else:
mesg = "USAGE: %s --removeDomain domainname \n" % (sys.argv[0])
sys.stdout.write(mesg)
exit()
if (options.showVlans):
data.showVlans()
#if (options.addVlan):
#print len(args)
#if len(args) > 0:
#data.addVlan(args[0], string.join(args[1:len(args)]))
#else:
#mesg = "USAGE: %s --addVlan vlanNumber [VlanDesc]\n" % (sys.argv[0])
#sys.stdout.write(mesg)
#exit()
#if (options.removeVlan):
#if len(args) > 0:
#data.removeVlan(args[0])
#else:
#mesg = "USAGE: %s --removeVlan VlanNumber\n" % (sys.argv[0])
#sys.stdout.write(mesg)
#exit()
if (options.assignVlan):
print len(args)
if len(args) > 0:
data.assignVlan(options.assignVlan, args[0], options.forcefully)
else:
mesg = "USAGE: %s --assignVlan vlannum DomainName\n" % (
sys.argv[0])
sys.stdout.write(mesg)
exit()
# Admin Interface
# snmpwalk -v2c -c zoni-domain sw0-r1r1 .1.3.6.1.2.1.17.7.1.4.3.1.5
if (options.ADMIN):
if not options.nodeName and not options.createVlanId and not options.destroyVlanId and not options.switchPort and not options.interactiveSwitchConfig and not options.saveConfig:
mesg = "\nERROR: nodeName or switch not specified. Please specify nodename with -n or --nodeName or --switchport\n"
parser.print_help()
sys.stderr.write(mesg)
exit()
# We can specify port/switch combinations here
if options.switchPort:
host = data.getSwitchInfo(options.switchPort.split(":")[0])
if len(options.switchPort.split(":")) > 1:
host['hw_port'] = options.switchPort.split(":")[1]
host['location'] = options.switchPort
if options.interactiveSwitchConfig:
host = data.getSwitchInfo(options.interactiveSwitchConfig)
HwSwitch = HwDellSwitch
hwswitch = HwSwitch(configs, host)
if options.verbosity:
hwswitch.setVerbose(True)
if options.setPortMode:
hwswitch.setPortMode(options.setPortMode)
if options.saveConfig:
hwswitch.saveConfig(options.saveConfig, data)
if options.labelPort:
mydesc = None
if len(args) > 0:
mydesc = " ".join(["%s" % i for i in args])
hwswitch.labelPort(mydesc)
if options.enableHostPort and (options.nodeName or options.switchPort):
hwswitch.enableHostPort()
if options.disableHostPort and (options.nodeName
or options.switchPort):
hwswitch.disableHostPort()
# Create a new vlan on all switches and add to db
if options.createVlanId:
print options.createVlanId
hwswitch.createVlans(options.createVlanId, data.getAllSwitches(),
data)
data.addVlan(options.createVlanId, string.join(args[1:len(args)]))
# Remove vlan on all switches and remove from db
if options.destroyVlanId:
hwswitch.removeVlans(options.destroyVlanId, data.getAllSwitches(),
data)
data.removeVlan(options.destroyVlanId)
if options.add2Vlan and (options.nodeName or options.switchPort):
tag = "untagged"
vlan = options.add2Vlan
if ":" in options.add2Vlan:
print options.add2Vlan
vlan = options.add2Vlan.split(":")[0]
tag = options.add2Vlan.split(":")[1]
hwswitch.addNodeToVlan(vlan, tag)
data.addNodeToVlan(host['location'], vlan, tag)
exit()
if options.removeFromVlan and (options.nodeName or options.switchPort):
hwswitch.removeNodeFromVlan(options.removeFromVlan)
data.removeNodeFromVlan(options.nodeName, options.removeFromVlan)
if options.setNative and (options.nodeName or options.switchPort):
hwswitch.setNativeVlan(options.setNative)
data.addNodeToVlan(host['location'], options.setNative, "native")
if options.restoreNative and options.nodeName:
hwswitch.restoreNativeVlan()
if options.removeAllVlans and (options.nodeName or options.switchPort):
hwswitch.removeAllVlans()
if options.sendSwitchCommand and (options.nodeName
or options.switchPort):
hwswitch.sendSwitchCommand(options.sendSwitchCommand)
if options.interactiveSwitchConfig:
hwswitch.interactiveSwitchConfig()
if options.showSwitchConfig and (options.nodeName
or options.switchPort):
hwswitch.showInterfaceConfig()
# Register hardware
if options.register:
supported_hardware = ['dellswitch', 'raritan']
if len(args) < 3:
mesg = "ERROR: Expecting username and ip address of hardware to be registered\n"
mesg += os.path.basename(
sys.argv[0]) + " --register HARDWARE username ipaddr\n"
mesg += "Supported hardware " + str(supported_hardware) + "\n"
sys.stderr.write(mesg)
else:
if string.lower(args[0]) == "dellswitch":
HwSwitch = HwDellSwitch
hw = HwSwitch(configs)
elif string.lower(args[0]) == "raritan":
hw = raritanDominionPx(configs)
else:
mesg = "Undefined hardware type\nSupported Hardware" + str(
supported_hardware) + "\n"
sys.stderr.write(mesg)
exit()
if options.verbosity:
hw.setVerbose(True)
print args
password = getpass.getpass()
data = hw.registerToZoni(args[1], password, args[2])
# Register to DB
#data.registerHardware(data)
# Zoni Helper
if options.addDns or options.removeDns or options.addDhcp or options.removeDhcp or options.addCname or options.removeCname:
if options.addDns:
thisone = "--addDns"
if options.removeDns:
thisone = "--removeDns"
if options.removeDhcp:
thisone = "--removeDhcp"
if options.addDhcp:
thisone = "--addDhcp"
if options.addCname:
thisone = "--addCname"
if options.removeCname:
thisone = "--removeCname"
if options.addDns:
if len(args) < 2:
mesg = "ERROR: Incorrect number of arguments\n"
mesg += "Example: " + os.path.basename(
sys.argv[0]) + " " + thisone + " hostname IP_Address\n"
print mesg
exit()
hostName = args[0]
ip = args[1]
if validIp(ip):
mesg = "Adding DNS entry: %s (%s) " % (hostName, ip)
sys.stdout.write(mesg)
dhcpdns = DhcpDns(configs, verbose=options.verbosity)
dhcpdns.addDns(hostName, ip)
try:
socket.gethostbyname(hostName)
sys.stdout.write("[Success]\n")
except Exception:
sys.stdout.write("[Fail]\n")
else:
mesg = "ERROR: Malformed IP Address\n"
mesg += "Use the dotted quad notation, e.g. 10.0.0.10\n"
print mesg
exit()
if options.removeDns or options.removeDhcp or options.removeCname:
if len(args) < 1:
mesg = "ERROR: Incorrect number of arguments\n"
mesg += "Example: " + os.path.basename(
sys.argv[0]) + " " + thisone + " hostname\n"
sys.stdout.write(mesg)
exit()
hostName = args[0]
dhcpdns = DhcpDns(configs, verbose=options.verbosity)
if options.removeDns:
mesg = "Removing DNS entry: %s " % (hostName)
sys.stdout.write(mesg)
dhcpdns.removeDns(hostName)
try:
socket.gethostbyname(hostName)
sys.stdout.write("[Fail]\n")
except Exception:
sys.stdout.write("[Success]\n")
if options.removeDhcp:
dhcpdns.removeDhcp(hostName)
if options.removeCname:
mesg = "Removing DNS CNAME entry: %s " % (hostName)
sys.stdout.write(mesg)
dhcpdns.removeCname(hostName)
if dhcpdns.error:
mesg = "[FAIL] " + str(dhcpdns.error) + "\n"
sys.stdout.write(mesg)
else:
mesg = "[SUCCESS]" + "\n"
sys.stdout.write(mesg)
if options.addDhcp:
if len(args) < 3:
mesg = "ERROR: Incorrect number of arguments\n"
mesg += "Example: " + os.path.basename(
sys.argv[0]
) + " " + thisone + " hostname IP_Address Mac_Address\n"
print mesg
exit()
hostName = args[0]
ip = args[1]
mac = args[2]
if validIp(ip) and validMac(mac):
dhcpdns = DhcpDns(configs, verbose=options.verbosity)
dhcpdns.addDhcp(hostName, ip, mac)
if dhcpdns.error:
mesg = "ERROR: Add DHCP Error " + dhcpdns.error + "\n"
else:
if not validIp(ip):
mesg = "ERROR: Malformed IP Address\n"
mesg += "Use the dotted quad notation, e.g. 10.0.0.10\n"
print mesg
exit()
if not validMac(mac):
mesg = "ERROR: Malformed MAC Address\n"
mesg += "Example 10:20:30:40:50:60\n"
print mesg
exit()
if options.addCname:
if len(args) < 2:
mesg = "ERROR: Incorrect number of arguments\n"
mesg += "Example: %s %s cname existing_name" % (
os.path.basename(sys.argv[0]), thisone)
print mesg
exit()
hostName = args[1]
cname = args[0]
mesg = "Adding DNS CNAME entry: %s -> %s " % (cname, hostName)
sys.stdout.write(mesg)
dhcpdns = DhcpDns(configs, verbose=options.verbosity)
dhcpdns.addCname(cname, hostName)
if dhcpdns.error:
mesg = "[FAIL] \n %s\n" % str(dhcpdns.error)
sys.stdout.write(mesg)
else:
mesg = "[SUCCESS]\n"
sys.stdout.write(mesg)
## Extensions from MIMOS - functions are defined in m_extensions.py
if (options.addRole and options.nodeName) or (options.removeRole
and options.nodeName):
if options.addRole:
mimos.assignRoletoHost(host, options.addRole)
mimos.addRoletoNode(configs, host, options.nodeName,
options.addRole)
if options.removeRole:
mimos.unassignRolefromHost(host)
mimos.removeRolefromNode(configs, host, options.nodeName)
if (options.addRole
and not options.nodeName) or (options.removeRole
and not options.nodeName):
mesg = "Roles: Missing Parameter(s)!"
log.error(mesg)
if options.showRoleMap:
mimos.showRoletoHost(configs)
if options.showKernelInfo:
mimos.showKernelInfo()
if options.showInitrdInfo:
mimos.showInitrdInfo()
if options.registerKernelInitrd:
mimos.registerKernelInitrd(configs, options.registerKernelInitrd)
if options.getKernelInitrdID:
mimos.getKernelInitrdID(options.getKernelInitrdID)
if options.getConfig:
mimos.getConfig(configs, options.getConfig)
elif dat[0] == 'CMD=STARTJOB':
r = self.processStartJob(p)
elif dat[0] == 'CMD=CANCELJOB':
r = self.processCancelJob(p)
else:
print 'got unknown packet'
print p.prettyString()
r = MauiPacket()
r.set(['SC=-810', 'RESPONSE=command not supported'])
print r.prettyString()
self.ostream.write(str(r))
self.ostream.flush()
self.ostream.close()
self.ostream.close()
self.istream.close()
if __name__ == '__main__':
(config, configFiles) = getConfig(["Agent"])
publisher = instantiateImplementation(config.get("Agent", "publisher"),
config)
tashi.publisher = publisher
(client, transport) = createClient(config)
logging.config.fileConfig(configFiles)
tashiconnection = TashiConnection(config, client, transport)
tashiconnection.start()
HOST, PORT = '', 1717
server = SocketServer.TCPServer((HOST, PORT), MauiListener)
server.serve_forever()