| # Licensed to the Apache Software Foundation (ASF) under one |
| # or more contributor license agreements. See the NOTICE file |
| # distributed with this work for additional information |
| # regarding copyright ownership. The ASF licenses this file |
| # to you under the Apache License, Version 2.0 (the |
| # "License"); you may not use this file except in compliance |
| # with the License. You may obtain a copy of the License at |
| # |
| # http://www.apache.org/licenses/LICENSE-2.0 |
| # |
| # Unless required by applicable law or agreed to in writing, |
| # software distributed under the License is distributed on an |
| # "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| # KIND, either express or implied. See the License for the |
| # specific language governing permissions and limitations |
| # under the License. |
| # |
| # $Id$ |
| # |
| |
| import os |
| import sys |
| try: |
| import MySQLdb |
| import optparse |
| import getpass |
| except ImportError, e: |
| print "Module not installed : %s" % e |
| exit() |
| |
| |
| a = os.path.join("../") |
| sys.path.append(a) |
| a = os.path.join("../../") |
| sys.path.append(a) |
| a = os.path.join("../../..") |
| sys.path.append(a) |
| |
| from zoni.version import version, revision |
| from zoni.extra.util import getConfig |
| |
| |
| def main(): |
| ''' This file sets up the database for Zoni ''' |
| |
| ver = version.split(" ")[0] |
| rev = revision |
| |
| |
| parser = optparse.OptionParser(usage="%prog -u username ", version="%prog " + ver + " " + rev) |
| parser.add_option("-u", "--userName", "--username", dest="userName", help="Mysql username") |
| parser.add_option("-p", "--password", dest="password", help="Admin mysql password") |
| #parser.add_option("-v", "--verbose", dest="verbosity", help="Be verbose", action="store_true", default=False) |
| (options, __args) = parser.parse_args() |
| |
| if not options.userName: |
| parser.print_help() |
| exit(1) |
| |
| password = options.password |
| if not options.password: |
| password = getpass.getpass() |
| |
| (configs, __configFiles) = getConfig() |
| |
| CreateZoniDb(configs, options.userName, password) |
| |
| |
| def CreateZoniDb(config, adminUser, adminPassword): |
| config = config |
| host = config['dbHost'] |
| user = config['dbUser'] |
| adminUser = adminUser |
| adminPassword = adminPassword |
| passwd = config['dbPassword'] |
| #db = "`" + config['dbInst'] + "`" |
| db = config['dbInst'] |
| |
| if config['dbPort'] == "": |
| config['dbPort'] = 3306 |
| |
| port = config['dbPort'] |
| |
| try: |
| conn = connectDb(host, port, adminUser, adminPassword) |
| except e: |
| print "error here ", e |
| exit() |
| createDatabase(conn, adminUser, adminPassword, db) |
| setPriviledges(conn, user, passwd, db) |
| conn.close() |
| #conn = connectDb(host, port, adminUser, adminPassword, db) |
| conn = connectDb(host, port, user, passwd, db) |
| createTables(conn) |
| createRegistration(conn, config) |
| addInitialConfig(conn, config) |
| conn.commit() |
| conn.close() |
| sys.stdout.write("Finished\n") |
| |
| def connectDb (host, port, user, passwd, db=None): |
| # Connect to DB |
| try: |
| if db: |
| conn = MySQLdb.connect(host = host, port = port, user = user , passwd = passwd, db = db) |
| else: |
| conn = MySQLdb.connect(host = host, port = port, user = user , passwd = passwd) |
| |
| except MySQLdb.OperationalError, e: |
| if e[0] == 2005: |
| print "ERROR :" + str(e[1]) |
| exit(1) |
| else: |
| print "Connection Error : ", e |
| exit(1) |
| return conn |
| |
| |
| def createDatabase (conn, user, passwd, db): |
| sys.stdout.write("Creating database...") |
| cmd = "create database if not exists " + db + ";" |
| execQuery(conn, cmd) |
| sys.stdout.write("Success\n") |
| |
| |
| def setPriviledges(conn, user, passwd, db): |
| sys.stdout.write("Setting user priviledges...") |
| cmd = "grant create, select, insert, update, delete on " + db + ".* to " + user + "@\'%\' identified by \'" + passwd + "\';" |
| execQuery(conn, cmd) |
| sys.stdout.write("Success\n") |
| |
| |
| |
| def createTables(conn): |
| sys.stdout.write("Create Zoni Database Schema...\n") |
| ''' Create Tables ''' |
| # Create sysinfo |
| sys.stdout.write(" Creating sysinfo...") |
| execQuery(conn, "CREATE TABLE IF NOT EXISTS `sysinfo` (`sys_id` int(11) unsigned NOT NULL auto_increment, `mac_addr` char(64) NOT NULL, `num_procs` int(10) unsigned default NULL, `num_cores` int(10) unsigned default NULL, `mem_sticks` int(10) unsigned default NULL, `mem_slots` int(10) unsigned default NULL, `mem_total` int(10) unsigned default NULL, `mem_limit` int(10) unsigned default NULL, `clock_speed` int(10) unsigned default NULL, `sys_vendor` text, `sys_model` text, `proc_vendor` char(64) default NULL, `proc_model` char(128) default NULL, `proc_cache` char(32) default NULL, `system_serial_number` char(128) default NULL, `chassis_serial_number` char(128) default NULL, `system_uuid` char(254) default NULL, `cpu_flags` text, `location` text, `bios_rev` char(32) default NULL, `ip_addr` varchar(64) NOT NULL, `init_checkin` timestamp NOT NULL default 0, `last_update` timestamp not null default 0 on update CURRENT_TIMESTAMP, state_id int(11) DEFAULT 1,max_reservation int(10) default -1, PRIMARY KEY (`sys_id`))") |
| sys.stdout.write("Success\n") |
| |
| # Create hardwareinfo |
| sys.stdout.write(" Creating hardwareinfo...") |
| execQuery(conn, "CREATE TABLE IF NOT EXISTS `hardwareinfo` ( `hw_id` int(11) unsigned NOT NULL auto_increment, `hw_type` varchar(64) NOT NULL, `hw_mac` varchar(64) default NULL, `hw_name` varchar(256) NOT NULL, `hw_make` varchar(64), `hw_model` varchar(64), `hw_version_sw` varchar(64), `hw_version_fw` varchar(64), `hw_ipaddr` varchar(64) NOT NULL, `hw_userid` varchar(64) default NULL, `hw_password` varchar(64) default NULL, `hw_notes` longtext, PRIMARY KEY (`hw_id`))") |
| sys.stdout.write("Success\n") |
| # Create imageinfo |
| sys.stdout.write(" Creating imageinfo...") |
| execQuery(conn, "CREATE TABLE IF NOT EXISTS `imageinfo` ( `image_id` int(11) unsigned NOT NULL auto_increment, `image_name` varchar(256) NOT NULL, `dist` varchar(128), `dist_ver` varchar(128), `kernel_id` int(11), `initrd_id` int(11), PRIMARY KEY (`image_id`))") |
| sys.stdout.write("Success\n") |
| # Create reservationinfo |
| sys.stdout.write(" Creating reservationinfo...") |
| execQuery(conn, "CREATE TABLE IF NOT EXISTS `reservationinfo` ( `reservation_id` int(11) unsigned NOT NULL auto_increment, `user_id` int(11) NOT NULL, `reservation_date` timestamp NOT NULL default CURRENT_TIMESTAMP, `reservation_expiration` datetime NOT NULL, `notes` tinytext, PRIMARY KEY (`reservation_id`)) ENGINE=INNODB") |
| sys.stdout.write("Success\n") |
| # Create portmap |
| sys.stdout.write(" Creating portmap...") |
| execQuery(conn, "CREATE TABLE IF NOT EXISTS `portmap` (`hw_id` int(11) unsigned NOT NULL, `sys_id` int(11) unsigned NOT NULL, `port_num` int(11))") |
| sys.stdout.write("Success\n") |
| # Create vlan |
| sys.stdout.write(" Creating vlaninfo...") |
| execQuery(conn, "CREATE TABLE IF NOT EXISTS `vlaninfo` ( `vlan_id` int(11) unsigned NOT NULL auto_increment, `vlan_num` int(11) NOT NULL, `vlan_desc` varchar(256) NOT NULL, PRIMARY KEY (`vlan_id`))") |
| sys.stdout.write("Success\n") |
| # Create domaininfo |
| sys.stdout.write(" Creating domaininfo...") |
| #execQuery(conn, "CREATE TABLE IF NOT EXISTS `domaininfo` ( `domain_id` int(11) unsigned NOT NULL auto_increment, `domain_name` varchar(64) NOT NULL, `domain_key` varchar(1024) NULL, `domain_desc` varchar(256) NOT NULL, `reservation_id` int(11) unsigned NOT NULL, PRIMARY KEY (`domain_id`), INDEX (reservation_id), FOREIGN KEY (reservation_id) REFERENCES reservationinfo(reservation_id) on DELETE CASCADE) ENGINE=INNODB") |
| execQuery(conn, "CREATE TABLE IF NOT EXISTS `domaininfo` ( `domain_id` int(11) unsigned NOT NULL auto_increment, `domain_name` varchar(64) NOT NULL, `domain_key` varchar(1024) NULL, `domain_desc` varchar(256) NOT NULL, PRIMARY KEY (`domain_id`)) ENGINE=INNODB") |
| sys.stdout.write("Success\n") |
| # Create domainmap |
| sys.stdout.write(" Creating domainmembermap...") |
| execQuery(conn, "CREATE TABLE IF NOT EXISTS `domainmembermap` (`domain_id` int(11) unsigned NOT NULL, `vlan_id` int(11) unsigned NOT NULL, `vlan_type` varchar(20) NULL, INDEX (domain_id), FOREIGN KEY (domain_id) REFERENCES domaininfo(domain_id) on DELETE CASCADE) ENGINE=INNODB") |
| sys.stdout.write("Success\n") |
| # Create system, domain member map |
| sys.stdout.write(" Creating sysdomainmembermap...") |
| execQuery(conn, "CREATE TABLE IF NOT EXISTS `sysdomainmembermap` (`sys_id` int(11) unsigned NOT NULL, `domain_id` int(11) NOT NULL)") |
| sys.stdout.write("Success\n") |
| # Create allocationinfo |
| sys.stdout.write(" Creating allocationinfo...") |
| execQuery(conn, "CREATE TABLE IF NOT EXISTS `allocationinfo` ( `allocation_id` int(11) unsigned NOT NULL auto_increment, `sys_id` int(11) unsigned NOT NULL, `reservation_id` int(11) unsigned NOT NULL, `pool_id` int(11) unsigned NULL, `hostname` varchar(64) default NULL, `domain_id` int(11) unsigned NOT NULL, `notes` tinytext, `expire_time` timestamp default 0 NOT NULL, PRIMARY KEY (`allocation_id`)) ENGINE=INNODB") |
| sys.stdout.write("Success\n") |
| # Create imagemap |
| sys.stdout.write(" Creating imagemap...") |
| execQuery(conn, "CREATE TABLE IF NOT EXISTS `imagemap` ( `allocation_id` int(11) unsigned NOT NULL, `image_id` int(11) unsigned NOT NULL, INDEX(allocation_id), FOREIGN KEY (allocation_id) REFERENCES allocationinfo(allocation_id) on DELETE CASCADE)ENGINE=INNODB") |
| sys.stdout.write("Success\n") |
| # Create poolinfo |
| sys.stdout.write(" Creating poolinfo...") |
| execQuery(conn, "CREATE TABLE IF NOT EXISTS `poolinfo` (`pool_id` int(11) unsigned NOT NULL auto_increment, `pool_name` varchar(64) NOT NULL, `pool_ip_network` varchar(64) NOT NULL, PRIMARY KEY (`pool_id`))") |
| sys.stdout.write("Success\n") |
| # Create poolmap |
| sys.stdout.write(" Creating poolmap...") |
| execQuery(conn, "CREATE TABLE IF NOT EXISTS `poolmap` (`pool_id` int(11) NOT NULL, `vlan_id` int(11) unsigned NOT NULL)") |
| sys.stdout.write("Success\n") |
| ## Create allocationarchive |
| #sys.stdout.write(" Creating allocationarchive...") |
| #execQuery(conn, "CREATE TABLE IF NOT EXISTS `allocationarchive` ( `ar_id` int(11) unsigned NOT NULL auto_increment, `sys_id` int(11) NOT NULL, `ip_addr` varchar(64) NOT NULL, `hostname` varchar(64) NOT NULL, `domain_id` int(11) NOT NULL, `user_id` int(11) NOT NULL, `cur_time` timestamp NOT NULL default CURRENT_TIMESTAMP on update CURRENT_TIMESTAMP, `reservation_type` varchar(64) NOT NULL, `notes` tinytext, PRIMARY KEY (`ar_id`))") |
| #sys.stdout.write("Success\n") |
| # Create kernelinfo |
| sys.stdout.write(" Creating kernelinfo...") |
| execQuery(conn, "CREATE TABLE IF NOT EXISTS `kernelinfo` ( `kernel_id` int(11) unsigned NOT NULL auto_increment, `kernel_name` varchar(256) NOT NULL, `kernel_release` varchar(128) NOT NULL, `kernel_arch` varchar(128) NOT NULL, PRIMARY KEY (`kernel_id`))") |
| sys.stdout.write("Success\n") |
| # Create initrdinfo |
| sys.stdout.write(" Creating initrdinfo...") |
| execQuery(conn, "CREATE TABLE IF NOT EXISTS `initrdinfo` ( `initrd_id` int(11) unsigned NOT NULL auto_increment, `initrd_name` varchar(256) NOT NULL, `initrd_arch` varchar(128) NOT NULL, `initrd_options` varchar(1024) NOT NULL, PRIMARY KEY (`initrd_id`))") |
| sys.stdout.write("Success\n") |
| # Create diskinfo |
| sys.stdout.write(" Creating diskmap...") |
| execQuery(conn, "CREATE TABLE IF NOT EXISTS `diskmap` ( `disk_id` int(11) unsigned NOT NULL auto_increment, `sys_id` int(11) NOT NULL, `disk_name` varchar(128), `disk_size` varchar(256), PRIMARY KEY (`disk_id`))") |
| sys.stdout.write("Success\n") |
| # Create stateinfo |
| sys.stdout.write(" Creating stateinfo...") |
| execQuery(conn, "CREATE TABLE IF NOT EXISTS `stateinfo` ( `state_id` int(11) unsigned NOT NULL auto_increment, `state_name` varchar(256) NOT NULL, `state_extra` varchar(256), PRIMARY KEY (`state_id`))") |
| sys.stdout.write("Success\n") |
| # Create vlanmembermap |
| sys.stdout.write(" Creating vlanmembermap...") |
| execQuery(conn, "CREATE TABLE IF NOT EXISTS `vlanmembermap` (`vlanmember_id` int(11) unsigned NOT NULL auto_increment, `allocation_id` int(11) unsigned NOT NULL, `vlan_id` int(11) unsigned NOT NULL, vlan_type varchar(128) NOT NULL, PRIMARY KEY (`vlanmember_id`), INDEX(allocation_id), FOREIGN KEY (allocation_id) REFERENCES allocationinfo(allocation_id) on DELETE CASCADE) ENGINE=INNODB") |
| sys.stdout.write("Success\n") |
| |
| def createRegistration(conn, config): |
| |
| sys.stdout.write(" Inserting initial Registration info into DB...\n") |
| |
| # Check if already there... |
| checkVal = entryExists(conn, "kernelinfo", "kernel_name", "linux-2.6.24-19-server") |
| if checkVal: |
| sys.stdout.write(" Kernel already exists in DB...\n") |
| # Get the kernel_id |
| #kernelId = str(checkVal[1][0][0]) |
| else: |
| __r = execQuery(conn, "INSERT into `kernelinfo` (kernel_name, kernel_release, kernel_arch) values ('linux-2.6.24-19-server', '2.6.24-19-server', 'x86_64' )") |
| #kernelId = str(r.lastrowid) |
| sys.stdout.write(" Success\n") |
| |
| # Initrd |
| #checkVal = entryExists(conn, "initrdinfo", "initrd_name", "zoni-register-64") |
| #sys.stdout.write(" Checking existence of initrd...") |
| #if not checkVal: |
| #sys.stdout.write("No\n") |
| #1,'initrd.img-2.6.38-10-server','x86_64','pxeserver=10.10.0.10 imageserver=10.10.0.10 defaultimage=x86_64-natty-hadoop-tashi_nm registerfile=register_node mode=register zoniroot=zoni configipmi=1 verbose=0' |
| #optionList = "pxeserver=" + config['pxeServerIP'] + " imageserver=" + config['imageServerIP'] + " defaultimage=amd64-tashi_nm registerfile=register_node mode=register zoniroot=" + config['registrationBaseDir'] + "configipmi=1 verbose=0 |
| #sys.stdout.write(" Inserting default register image into DB...") |
| #r = execQuery(conn, "INSERT into `initrdinfo` (initrd_name, initrd_arch, initrd_options) values ('zoni-register-64','x86_64', '" + optionList + "')") |
| #initrdId = str(r.lastrowid) |
| #sys.stdout.write("Success\n") |
| #else: |
| #sys.stdout.write("Yes\n") |
| #initrdId = str(checkVal[1][0][0]) |
| |
| # Interactive Registration |
| #checkVal = entryExists(conn, "initrdinfo", "initrd_name", "zoni-register-64-interactive") |
| #sys.stdout.write(" Checking existence of interactive initrd...") |
| #if not checkVal: |
| #sys.stdout.write("No\n") |
| #sys.stdout.write(" Inserting default register-interactive image into DB...") |
| #optionList = "initrd=" + config['initrdRoot'] + "/x86_64/zoni-register-64-interactive.gz pxeserver=" + config['pxeServerIP'] + " imageserver=" + config['imageServerIP'] + " defaultimage=amd64-tashi_nm registerfile=register_node mode=register verbose=1" |
| #r = execQuery(conn, "INSERT into `initrdinfo` (initrd_name, initrd_arch, initrd_options) values ('zoni-register-64-interactive','x86_64', '" + optionList + "')") |
| #initrdIdInteractive = str(r.lastrowid) |
| #sys.stdout.write("Success\n") |
| #else: |
| #sys.stdout.write("Yes\n") |
| #initrdIdInteractive = str(checkVal[1][0][0]) |
| # |
| # Insert disk option |
| sys.stdout.write(" Adding Disk to imageinfo...") |
| query = "select * from imageinfo where image_name = 'disk'" |
| r = execQuery(conn, query) |
| if len(r.fetchall()) < 1: |
| execQuery(conn, "INSERT into `imageinfo` (image_name) values ('disk')") |
| sys.stdout.write("Success\n") |
| |
| # Link initrd and kernel to image |
| #sys.stdout.write(" Registering initrd and kernel to registration image...") |
| #query = "select * from imageinfo where image_name = 'zoni-register-64' and kernel_id = " + kernelId + " and initrd_id = " + initrdId |
| #r = execQuery(conn, query) |
| #if len(r.fetchall()) < 1: |
| #execQuery(conn, "INSERT into `imageinfo` (image_name, dist, dist_ver, kernel_id, initrd_id) values ('zoni-register-64', 'Ubuntu', 'Hardy', " + kernelId + ", " + initrdId + ")") |
| # |
| #query = "select * from imageinfo where image_name = 'zoni-register-64-interactive' and kernel_id = " + kernelId + " and initrd_id = " + initrdId |
| #r = execQuery(conn, query) |
| #if len(r.fetchall()) < 1: |
| #execQuery(conn, "INSERT into `imageinfo` (image_name, dist, dist_ver, kernel_id, initrd_id) values ('zoni-register-64-interactive', 'Ubuntu', 'Hardy', " + kernelId + ", " + initrdIdInteractive + ")") |
| #sys.stdout.write("Success\n") |
| # |
| |
| def addInitialConfig(conn, config): |
| sys.stdout.write(" Adding initial configuration info into DB...\n") |
| # Create Initial reservation |
| sys.stdout.write(" Adding zoni reservation...") |
| checkVal = entryExists(conn, "reservationinfo", "reservation_id", '1') |
| if checkVal: |
| sys.stdout.write("Reservation already exists in DB...\n") |
| # Get the domainId |
| vlanId = str(checkVal[1][0][0]) |
| else: |
| r = execQuery(conn, "INSERT into `reservationinfo` (user_id, reservation_expiration, notes) values (0, '9999-12-31', 'Zoni Default')") |
| vlanId = str(r.lastrowid) |
| sys.stdout.write("Success\n") |
| |
| # Add the home vlan |
| sys.stdout.write(" Adding vlan info...") |
| checkVal = entryExists(conn, "vlaninfo", "vlan_num", config['zoniHomeDomain']) |
| if checkVal: |
| sys.stdout.write("Vlan already exists in DB...\n") |
| # Get the domainId |
| vlanId = str(checkVal[1][0][0]) |
| else: |
| r = execQuery(conn, "INSERT into `vlaninfo` (vlan_num, vlan_desc) values (" + config['zoniHomeDomain'] + ", 'Zoni Home Vlan' )") |
| vlanId = str(r.lastrowid) |
| sys.stdout.write("Success\n") |
| |
| # Create the Zoni Home domain |
| sys.stdout.write(" Creating Zoni Home Domain...") |
| checkVal = entryExists(conn, "domaininfo", "domain_name", "Zoni") |
| if checkVal: |
| sys.stdout.write("Default Domain (ZoniHome) already exists in DB...\n") |
| # Get the domainId |
| domainId = str(checkVal[1][0][0]) |
| else: |
| r = execQuery(conn, "INSERT into `domaininfo` (domain_name, domain_desc) values ('Zoni', 'Zoni Home Domain')") |
| domainId = str(r.lastrowid) |
| sys.stdout.write("Success\n") |
| |
| # link the vlan and domain |
| sys.stdout.write(" Linking Domain and vlan...") |
| checkVal = entryExists(conn, "domainmembermap", "domain_id", domainId) |
| if checkVal: |
| sys.stdout.write("Default Domain (ZoniHome) already linked to vlan " + config['zoniHomeDomain'] + "...\n") |
| # Get the domainId |
| #valId = str(checkVal[1][0][0]) |
| else: |
| r = execQuery(conn, "INSERT into `domainmembermap` (domain_id, vlan_id) values (" + domainId + ", " + vlanId + ")") |
| domainId = str(r.lastrowid) |
| sys.stdout.write("Success\n") |
| |
| # Add the pools |
| sys.stdout.write(" Adding default pools (Zoni home) from config file...") |
| checkVal = entryExists(conn, "poolinfo", "pool_name", 'ZoniHome') |
| if checkVal: |
| sys.stdout.write("Default pool (ZoniHome) already exists...\n") |
| zoniPoolId = str(checkVal[1][0][0]) |
| else: |
| r = execQuery(conn, "INSERT into `poolinfo` (pool_name, pool_ip_network) values ('ZoniHome', '" + config['zoniHomeNetwork'] + "')") |
| zoniPoolId = str(r.lastrowid) |
| sys.stdout.write("Success\n") |
| |
| sys.stdout.write(" Adding default pools (IPMI home) from config file...") |
| checkVal = entryExists(conn, "poolinfo", "pool_name", 'IpmiHome') |
| if checkVal: |
| sys.stdout.write("Default pool (IpmiHome) already exists...\n") |
| zoniIpmiId = str(checkVal[1][0][0]) |
| else: |
| r = execQuery(conn, "INSERT into `poolinfo` (pool_name, pool_ip_network) values ('IpmiHome', '" + config['zoniIpmiNetwork'] + "')") |
| zoniIpmiId = str(r.lastrowid) |
| sys.stdout.write("Success\n") |
| |
| # link the pools |
| sys.stdout.write(" Linking default pools (Zoni home)...") |
| checkVal = entryExists(conn, "poolmap", "pool_id", zoniPoolId) |
| if checkVal: |
| sys.stdout.write("Default pool (ZoniHome) already exists...\n") |
| # Get the domainId |
| #poolId = str(checkVal[1][0][0]) |
| else: |
| r = execQuery(conn, "INSERT into `poolmap` (pool_id, vlan_id) values (" + zoniPoolId + ", " + vlanId + ")") |
| domainId = str(r.lastrowid) |
| sys.stdout.write("Success\n") |
| |
| sys.stdout.write(" Linking default pools (IPMI home)...") |
| checkVal = entryExists(conn, "poolmap", "pool_id", zoniIpmiId) |
| if checkVal: |
| sys.stdout.write("Default pool (ZoniHome) already exists...\n") |
| # XXX probably should delete first then add, do it later |
| # Get the domainId |
| #poolId = str(checkVal[1][0][0]) |
| else: |
| r = execQuery(conn, "INSERT into `poolmap` (pool_id, vlan_id) values (" + zoniIpmiId + ", " + vlanId + ")") |
| domainId = str(r.lastrowid) |
| sys.stdout.write("Success\n") |
| |
| # Add default states |
| sys.stdout.write(" Adding default states..") |
| checkVal = entryExists(conn, "stateinfo", "state_name", 'normal') |
| if checkVal: |
| sys.stdout.write("Default state (default) already exists...\n") |
| else: |
| r = execQuery(conn, "INSERT into `stateinfo` (state_name) values ('normal')") |
| r = execQuery(conn, "INSERT into `stateinfo` (state_name) values ('off')") |
| r = execQuery(conn, "INSERT into `stateinfo` (state_name) values ('drained')") |
| r = execQuery(conn, "INSERT into `stateinfo` (state_name) values ('reserved')") |
| r = execQuery(conn, "INSERT into `stateinfo` (state_name) values ('restricted')") |
| sys.stdout.write("Success\n") |
| |
| def execQuery(conn, query): |
| cursor = conn.cursor() |
| try: |
| cursor.execute (query) |
| conn.commit() |
| #except Exception: |
| #traceback.print_exc(sys.exc_info()) |
| except MySQLdb.OperationalError, e: |
| sys.stdout.write("Fail\n") |
| msg = "ERROR: " + e[1] |
| sys.stderr.write(msg) |
| #traceback.print_exc(sys.exc_info()) |
| exit() |
| return cursor |
| |
| def entryExists(conn, table, col, checkVal): |
| query = "select * from " + table + " where " + col + " = '" + checkVal + "'" |
| r = execQuery(conn, query) |
| res = r.fetchall() |
| if len(res) > 0: |
| return (1, res) |
| |
| return 0 |
| |
| |
| if __name__ == "__main__": |
| main() |
| |
