def you_are_next_ca(argv):
'''
destination of ca migration
'''
cakeyString = argv[0]
cacertString = argv[1]
mode = argv[2]
result = subprocess.Popen(shlex.split("mkdir -p %s" % (setting.CA_PATH)),
stdout=subprocess.PIPE)
result.wait()
cakeyFile = open(setting.CA_PATH + 'cakey.pem', 'w')
cakeyFile.write(cakeyString)
cakeyFile.close()
cacertFile = open(setting.CA_PATH + 'cacert.pem', 'w')
cacertFile.write(cacertString)
cacertFile.close()
infoHost = cacheFile.getDatabaseIP()
db = MySQLdb.connect(infoHost, setting.DB_USERNAME, setting.DB_PASSWORD,
setting.DB_NAME)
cursor = db.cursor()
if mode == 'migrate':
cursor.execute("UPDATE `hosts` SET `isCA`=1 WHERE `IPAddress`='%s';" %
(str(network.getMyIPAddr())))
elif mode == 'makeSlave':
cursor.execute("UPDATE `hosts` SET `isCA`=2 WHERE `IPAddress`='%s';" %
(str(network.getMyIPAddr())))
db.close()
return "OK"
def destroy_slave_host_info(argv):
'''
dest = slave only
'''
myIP = network.getMyIPAddr()
db = MySQLdb.connect("localhost", "root", setting.DB_ROOT_PASSWORD)
cursor = db.cursor()
cursor.execute("SLAVE STOP;")
cursor.execute("DROP DATABASE IF EXISTS %s" %
(setting.DB_NAME)) #this line was added later
db.close()
dbController.stop()
infoHost = cacheFile.getDatabaseIP()
db = MySQLdb.connect(infoHost, setting.DB_USERNAME, setting.DB_PASSWORD,
setting.DB_NAME)
cursor = db.cursor()
cursor.execute(
"UPDATE `hosts` SET `isInformationServer`=0 WHERE `IPAddress`='%s'" %
(str(myIP)))
db.close()
dbController.broadcastNewSlaveInformationServer('-')
return 'OK'
def clone_ca(argv):
'''
only real ca can do this method
(source of ca migration)
'''
targetHostIP = argv[0]
mode = argv[1]
cakeyString = open(setting.CA_PATH + 'cakey.pem', 'r').read()
cacertString = open(setting.CA_PATH + 'cacert.pem', 'r').read()
result = connection.socketCall(targetHostIP, setting.LOCAL_PORT,
"you_are_next_ca",
[cakeyString, cacertString, mode])
if mode == 'migrate':
infoHost = cacheFile.getDatabaseIP()
db = MySQLdb.connect(infoHost, setting.DB_USERNAME,
setting.DB_PASSWORD, setting.DB_NAME)
cursor = db.cursor()
cursor.execute("UPDATE `hosts` SET `isCA`=0 WHERE `IPAddress`='%s';" %
(str(network.getMyIPAddr())))
db.close()
elif mode == 'makeSlave':
pass
return result
def are_you_running_dhcpd(argv):
'''
if i am running dhcpd, i will reply "yes"
'''
myIP = network.getMyIPAddr()
globalControllerIP = cacheFile.getGlobalControllerIP()
if globalControllerIP == None:
return 'no'
if str(myIP) != str(globalControllerIP):
return 'no'
else:
try:
infoHost = cacheFile.getDatabaseIP()
db = MySQLdb.connect(infoHost, setting.DB_USERNAME,
setting.DB_PASSWORD, setting.DB_NAME)
cursor = db.cursor()
cursor.execute(
"SELECT `IPAddress` FROM `hosts` WHERE `isGlobalController`=1")
result = cursor.fetchone()
db.close()
if result == None or result[0] != str(myIP):
return 'no'
else:
return 'yes'
except MySQLdb.Error, e:
return 'no'
def get_local_raw_guest_data(argv):
'''
send raw data of every guest from libvirt api
'''
myIP = network.getMyIPAddr()
result = []
conn = libvirt.open(None)
if conn == None:
print 'Failed to open connection to the hypervisor'
return
domainIDList = conn.listDomainsID()
for domainID in domainIDList:
domainDict = {}
dm = conn.lookupByID(domainID)
dom = minidom.parseString(dm.XMLDesc(0))
domainDict['MACAddress'] = getValue(dom, 'mac', 'address')
domainDict['UUID'] = dm.UUIDString().replace('-', '')
domainDict['runningState'] = dm.info()[0]
domainDict['name'] = dm.name()
domainDict['isActive'] = dm.isActive()
domainDict['hostIP'] = str(myIP)
result.append(domainDict)
return json.dumps(result)
def check_nfs_migrate_destination_area(argv):
'''
for nfs migration destination only
argv[0] is json of list of [filename(path),size]
'''
#check required additional area on this host
allFileData = json.loads(argv[0])
requireMore = 0
for fileData in allFileData:
try:
oldFileSize = os.path.getsize(fileData[0])
except os.error:
oldFileSize = 0
requireMore += (fileData[1] - oldFileSize)
#check the free area from monitoring service
myIP = str(network.getMyIPAddr())
data = connection.socketCall("localhost", setting.MONITOR_PORT,
"get_current_storage_info", [myIP])
print "##data from z##", data
data = json.loads(data)
if len(data) == 0:
return "data is not ready"
else:
data = data[0]
free = data['storage_info']['free'] * 1024
if free < requireMore:
return "not enough free space on target host"
else:
return "OK"
def ask_your_spec(argv):
'''
answer my spec (for init host, so cannot use complex things in this method)
'''
myIP = network.getMyIPAddr()
specData = connection.socketCall("localhost", setting.MONITOR_PORT,
"get_my_spec", [])
return specData
def create_your_slave_db(argv):
'''
dest = master only
and should be call after finish NFS system
'''
targetHostIP = argv[0]
db = MySQLdb.connect("localhost", "root", setting.DB_ROOT_PASSWORD)
cursor = db.cursor()
cursor.execute("FLUSH TABLES WITH READ LOCK;")
cursor.execute("SHOW MASTER STATUS;")
data = cursor.fetchone()
fileData = data[0]
positionData = data[1]
myIP = network.getMyIPAddr()
result = subprocess.Popen(
shlex.split("mysqldump %s -u root --password='******'" %
(setting.DB_NAME, setting.DB_ROOT_PASSWORD)),
stdout=subprocess.PIPE)
#result.wait()
output = result.communicate()[0]
#print "before write file"
#dumpFile=open(setting.DB_DUMP_FILE,'w')
#dumpFile.write(output)
#dumpFile.close()
result = connection.socketCall(targetHostIP, setting.LOCAL_PORT,
'you_are_slave_db', [
'{socket_connection}',
str(myIP), fileData,
str(positionData), output
])
print "~~~", result
cursor.execute("UNLOCK TABLES;")
db.close()
if result == 'OK':
#this is the first transaction that will be replicated to slave automaticaly
db = MySQLdb.connect("localhost", "root", setting.DB_ROOT_PASSWORD,
setting.DB_NAME)
cursor = db.cursor()
cursor.execute(
"UPDATE `hosts` SET `isInformationServer`=2 WHERE `IPAddress`='%s'"
% (str(targetHostIP)))
db.close()
#tell slave ip to every host (it will be used when master down)
dbController.broadcastNewSlaveInformationServer(
slaveHostIP=targetHostIP, masterHostIP=str(myIP))
return result
def setMasterConfig():
'''
must restart mysqld after this method
'''
configFile = open('/etc/my.cnf', 'w')
writtenString = open(setting.MAIN_PATH + 'info/masterTemplate_my.cnf',
'r').read()
configFile.write(writtenString % {
'MY_IP_ADDRESS': str(network.getMyIPAddr()),
'DB_NAME': setting.DB_NAME
})
configFile.close()
return True
def update_cloud_info(argv):
'''
get info and update
'''
conn=argv[0][0]
s=argv[0][1]
dataDict=json.loads(argv[1])
if 'masterDB' not in dataDict.keys():
dataDict['masterDB']=None
if 'masterDB_MAC' not in dataDict.keys():
dataDict['masterDB_MAC']=None
if 'slaveDB' not in dataDict.keys():
dataDict['slaveDB']=None
if 'globalController' not in dataDict.keys():
dataDict['globalController']=None
if 'network' not in dataDict.keys():
dataDict['network']=None
newDataDict=cacheFile.setValue(masterDB=dataDict['masterDB'],masterDB_MAC=dataDict['masterDB_MAC'],slaveDB=dataDict['slaveDB'],globalController=dataDict['globalController'],network=dataDict['network'])
infoHost=newDataDict['masterDB']
myIP=network.getMyIPAddr()
#if INFO_HOST is not me and i am not slave , i should stop mysqld service
#if infoHost!=str(myIP):
# dbController.stop()
if 'nfs' in argv:
#connect to database to get data of NFS Server to mount (may call updateLocal() to make everything)
db = MySQLdb.connect(infoHost, setting.DB_USERNAME, setting.DB_PASSWORD, setting.DB_NAME )
cursor = db.cursor()
cursor.execute('''SELECT `IPAddress` FROM `hosts` WHERE `isStorageHolder`=1;''')
storageHost=str(cursor.fetchone()[0])
db.close()
#debugger.countdown(10,"before local unmount and mount")
print "Umount:",nfsController.umount()
print "Mount :",nfsController.mount(storageHost)
if 'planner' in argv:
general.runDaemonCommand("service mkplanner restart",conn,s,True) #can be True in log system
if 'dynamic' in argv:
network.configToAuto() #(conn,s)
return 'OK'
def waitLocalPort(self):
print "Waiting for port . .",
while True:
result = subprocess.Popen(shlex.split("netstat -p -a -t"),
stdout=subprocess.PIPE)
result.wait()
output = result.communicate()[0]
found = re.search(
r"%s:%s\s" %
(str(network.getMyIPAddr()), str(setting.LOCAL_PORT)), output)
if found == None:
break
time.sleep(1)
print '.',
print '.'
def setSlaveConfig(masterIP):
'''
must restart mysqld after this method
'''
configFile = open('/etc/my.cnf', 'w')
writtenString = open(setting.MAIN_PATH + 'info/slaveTemplate_my.cnf',
'r').read()
configFile.write(
writtenString % {
'MY_IP_ADDRESS': str(network.getMyIPAddr()),
'MASTER_IP_ADDRESS': str(masterIP),
'SLAVE_USER': setting.DB_USERNAME,
'SLAVE_PASSWORD': setting.DB_PASSWORD,
'DB_NAME': setting.DB_NAME
})
configFile.close()
return True
def deleteUser(username):
db = MySQLdb.connect("localhost", "root", rootpassword)
cursor = db.cursor()
dataDict = {'USERNAME': username, 'MY_IP': network.getMyIPAddr()}
cursor.execute(
"revoke all privileges, grant option from '%(USERNAME)s'@'%(MY_IP)s';"
% dataDict)
cursor.execute(
"revoke all privileges, grant option from '%(USERNAME)s'@'%%';" %
dataDict)
cursor.execute(
"revoke all privileges, grant option from '%(USERNAME)s'@'localhost';"
% dataDict)
cursor.execute("FLUSH PRIVILEGES;")
db.close()
return True
''' #these lines work but fool
def you_are_db_migration_destination(argv):
'''
migrate from source to dest of socketCall
'''
conn = argv[0][0]
s = argv[0][1]
#targetFile=setting.DB_NFS_DUMP_FILE
targetFile = setting.DB_DUMP_TEMP_FILE
dumpString = argv[1]
dumpFile = open(targetFile, 'w')
dumpFile.write(dumpString)
dumpFile.close()
myIP = network.getMyIPAddr()
dbController.setMasterConfig(
) #very important for make it can be connected via remote host
dbController.start(setting.DB_ROOT_PASSWORD, conn, s)
dbController.createDB(setting.DB_ROOT_PASSWORD, setting.DB_NAME,
True) #drop and create new database
dbController.createUser(setting.DB_ROOT_PASSWORD, setting.DB_USERNAME,
setting.DB_PASSWORD)
dumpResult = dbController.runSQL(targetFile, "root",
setting.DB_ROOT_PASSWORD, setting.DB_NAME,
"localhost")
if dumpResult == False:
return "runSQL error, please check .sql file"
db = MySQLdb.connect("localhost", "root", setting.DB_ROOT_PASSWORD,
setting.DB_NAME)
cursor = db.cursor()
cursor.execute(
"UPDATE `hosts` SET `isInformationServer`=1 WHERE `IPAddress`='%s'" %
(str(myIP)))
db.close()
os.remove(targetFile)
return 'OK'
def createUser(rootpassword, newusername, newpassword):
db = MySQLdb.connect("localhost", "root", rootpassword)
cursor = db.cursor()
dataDict = {
'USERNAME': newusername,
'PASSWORD': newpassword,
'MY_IP': network.getMyIPAddr()
}
cursor.execute(
"grant all on *.* to '%(USERNAME)s'@'%%' identified by '%(PASSWORD)s';"
% dataDict)
cursor.execute(
"grant all on *.* to '%(USERNAME)s'@'%(MY_IP)s' identified by '%(PASSWORD)s';"
% dataDict)
cursor.execute(
"grant all on *.* to '%(USERNAME)s'@'localhost' identified by '%(PASSWORD)s';"
% dataDict)
cursor.execute("FLUSH PRIVILEGES;")
db.close()
return True
''' #these lines work but fool
def turn_slave_to_master_db(argv):
'''
dest = slave only
1. turn
2. update db
3. tell every host
'''
conn = argv[0][0]
s = argv[0][1]
myIP = network.getMyIPAddr()
myMAC = network.getMyMACAddr()
db = MySQLdb.connect("localhost", "root", setting.DB_ROOT_PASSWORD)
cursor = db.cursor()
cursor.execute("SLAVE STOP;")
db.close()
dbController.setMasterConfig()
dbController.stop()
dbController.start(setting.DB_ROOT_PASSWORD, conn, s)
dbController.createUser(setting.DB_ROOT_PASSWORD, setting.DB_USERNAME,
setting.DB_PASSWORD)
db = MySQLdb.connect("localhost", "root", setting.DB_ROOT_PASSWORD)
cursor = db.cursor()
cursor.execute(
"UPDATE `hosts` SET `isInformationServer`=1 WHERE `IPAddress`='%s'" %
(str(myIP)))
db.close()
dbController.broadcastNewMasterInformationServer(str(myIP), str(myMAC))
#should create new slave if there is another active host
return 'OK'
def runCollector():
jiffyPerSec = float(os.sysconf(os.sysconf_names['SC_CLK_TCK']))
cpu_count = int(multiprocessing.cpu_count())
myMAC = network.getMyMACAddr()
myIP = network.getMyIPAddr()
while myIP == None:
time.sleep(1.5)
myIP = network.getMyIPAddr()
i_am_global_controller = False #it will be changed during working
hostID = None #will be know while working
isHost = None #will be know while working
timeCounter = -5 #start at 1 so everything will start slowly
while True:
#new system no need to check ip all the time
#if timeCounter%setting.IP_CHECKING_PERIOD == 0:
# myIP=network.getMyIPAddr()
# if myIP==None:
# myIP=network.renewIPAddr(allowStatic=True)
if timeCounter % setting.PLANNER_COLLECTING_PERIOD == 0:
#get host data
timestamp = getCurrentTime()
f = open('/proc/stat', 'r')
while True:
data = f.readline().split(' ')
if data[0] == 'cpu':
if '' in data:
data.remove('')
idleTime = float(data[4]) / jiffyPerSec
elif data[0] == 'btime':
btime = int(data[1])
break
f.close()
#get guest data (like mmond)
guestError = False
try:
conn = libvirt.open(None)
if conn == None:
print "cannot connect to hypervisor"
guestError = True
else:
domains = conn.listDomainsID()
guestData = []
for id in domains:
dom = conn.lookupByID(id)
guestData.append({
'UUID':
dom.UUIDString().replace('-', ''),
'timestamp':
getCurrentTime(),
'cpuTime':
float(dom.info()[4]) / float(1000000000),
})
except:
print "have error while getting guest load information"
guestError = True
try:
db = MySQLdb.connect(cacheFile.getDatabaseIP(),
setting.DB_USERNAME, setting.DB_PASSWORD,
setting.DB_NAME)
cursor = db.cursor()
if hostID == None:
cursor.execute(
"SELECT `hostID`,`isHost` FROM `hosts` WHERE `MACAddress`='%s'"
% (myMAC))
hostID, isHost = cursor.fetchone()
#put host data in database
cursor.execute(
"INSERT INTO `hostLoad` (`hostID`,`timestamp`,`idleTime`,`btime`) VALUES ('%s','%s','%s','%s')"
% (str(hostID), str(timestamp), str(idleTime), str(btime)))
#put guest data in database
haveActiveGuest = False
if guestError == False:
for element in guestData:
cursor.execute(
"SELECT `guestID` FROM `guests` WHERE `lastUUID`='%s'"
% (element['UUID']))
result = cursor.fetchone()
if result == None:
continue
else:
guestID = result[0]
cursor.execute(
"INSERT INTO `guestLoad` (`guestID`,`timestamp`,`cpuTime`) VALUES ('%s','%s','%s')"
% (str(guestID), str(element['timestamp']),
str(element['cpuTime'])))
haveActiveGuest = True
if haveActiveGuest and isHost == 0:
#should evacuate
allowEvacuate = True
cursor.execute(
"SELECT `detail` FROM `tasks` WHERE `opcode`=2005 AND `status`<>2"
)
tmpDetail = cursor.fetchone()
while tmpDetail != None:
detailDict = json.loads(tmpDetail[0])
if str(detailDict['hostID']) == str(hostID):
allowEvacuate = False
break
else:
tmpDetail = cursor.fetchone()
if allowEvacuate:
taskID = queue.enqueue({
'command': 'host_evacuate_mission',
'hostID': hostID
})
if taskID == None:
print "enqueue host_evacuate_mission error"
db.close()
except:
print "error: timeCounter=", timeCounter
traceback.print_exc()
if timeCounter % setting.LOG_CLEANING_PERIOD == 0 and i_am_global_controller:
#delete log in database that older than setting.LOG_CLEANING_PERIOD
thresholdTime = getCurrentTime() - float(
setting.LOG_CLEANING_PERIOD)
try:
db = MySQLdb.connect(cacheFile.getDatabaseIP(),
setting.DB_USERNAME, setting.DB_PASSWORD,
setting.DB_NAME)
cursor = db.cursor()
#check permission of moving old log to another table
cursor.execute(
"SELECT `value` FROM `cloud_variables` WHERE `key`='hold_all_log'"
)
if cursor.fetchone()[0] == '0':
#just delete it
cursor.execute(
"DELETE FROM `hostLoad` WHERE `timestamp`<'%s'" %
(str(thresholdTime)))
cursor.execute(
"DELETE FROM `guestLoad` WHERE `timestamp`<'%s'" %
(str(thresholdTime)))
else:
#must move log to another 2 tables before delete
cursor.execute(
"SELECT `hostLoadID`,`hostID`,`timestamp`,`idleTime`,`btime` FROM `hostLoad` WHERE `timestamp`<'%s'"
% (str(thresholdTime)))
maxID = 0
tmpData = cursor.fetchall()
valueList = []
for row in tmpData:
valueList.append("('%s','%s','%s','%s','%s')" % row)
if row[0] > maxID:
maxID = row[0]
if len(valueList) > 0:
cursor.execute(
"INSERT INTO `oldHostLoad` (`hostLoadID`,`hostID`,`timestamp`,`idleTime`,`btime`) VALUES %s"
% (','.join(valueList)))
cursor.execute(
"DELETE FROM `hostLoad` WHERE `hostLoadID`<=%s" %
(maxID))
###############
cursor.execute(
"SELECT `guestLoadID`,`guestID`,`timestamp`,`cpuTime` FROM `guestLoad` WHERE `timestamp`<'%s'"
% (str(thresholdTime)))
maxID = 0
tmpData = cursor.fetchall()
valueList = []
for row in tmpData:
valueList.append("('%s','%s','%s','%s')" % row)
if row[0] > maxID:
maxID = row[0]
if len(valueList) > 0:
cursor.execute(
"INSERT INTO `oldGuestLoad` (`guestLoadID`,`guestID`,`timestamp`,`cpuTime`) VALUES %s"
% (','.join(valueList)))
cursor.execute(
"DELETE FROM `guestLoad` WHERE `guestLoadID`<=%s" %
(maxID))
db.close()
except:
print "error: timeCounter=", timeCounter
traceback.print_exc()
if timeCounter % setting.PLANNER_ACTION_PERIOD in [
setting.PLANNER_ACTION_PERIOD / 2, 0
]:
#update i_am_global_controller
i_am_global_controller = (
str(myIP) == cacheFile.getGlobalControllerIP())
if timeCounter % setting.PLANNER_ACTION_PERIOD == setting.PLANNER_ACTION_PERIOD / 2 and i_am_global_controller:
#guest action here
#1.check auto_mode in database (can do in mode 1 and 2)
#2.check that old mission was end
#3.put guest balance mission in queue
canDo = False
try:
db = MySQLdb.connect(cacheFile.getDatabaseIP(),
setting.DB_USERNAME, setting.DB_PASSWORD,
setting.DB_NAME)
cursor = db.cursor()
cursor.execute(
"SELECT `value` FROM `cloud_variables` WHERE `key`='auto_mode'"
)
currentMode = cursor.fetchone()[0]
if currentMode in ['1', '2']:
#check old mission
cursor.execute(
"SELECT `taskID` FROM `tasks` WHERE `opcode`='4001' AND (`status`=0 OR `status`=1)"
)
if cursor.fetchone() == None:
canDo = True
db.close()
except:
print "error: timeCounter=", timeCounter
traceback.print_exc()
if canDo:
taskID = queue.enqueue({
'command': 'guest_balance_mission',
})
if taskID == None:
print "enqueue error"
if timeCounter % setting.PLANNER_ACTION_PERIOD == 0 and i_am_global_controller:
#host action here
#1.check auto_mode in database (can do in mode 2 only)
#2.check that old mission was end
#3.put host balance mission in queue
canDo = False
try:
db = MySQLdb.connect(cacheFile.getDatabaseIP(),
setting.DB_USERNAME, setting.DB_PASSWORD,
setting.DB_NAME)
cursor = db.cursor()
cursor.execute(
"SELECT `value` FROM `cloud_variables` WHERE `key`='auto_mode'"
)
currentMode = cursor.fetchone()[0]
if currentMode == '2':
#check old mission
cursor.execute(
"SELECT `taskID` FROM `tasks` WHERE `opcode`='4002' AND (`status`=0 OR `status`=1)"
)
if cursor.fetchone() == None:
canDo = True
db.close()
except:
print "error: timeCounter=", timeCounter
traceback.print_exc()
if canDo:
taskID = queue.enqueue({
'command': 'host_balance_mission',
})
if taskID == None:
print "enqueue error"
#print "\033[A\r"+"end:",timeCounter
#print "end:",timeCounter
timeCounter += 1
time.sleep(1)
from service import caService, dbService, nfsService, globalService
from shell.shellUtil import requestAndWait
from util.xmlUtil import getValue
if len(sys.argv) != 2:
print "python backupCreate.py <backup_directory_path>"
sys.exit()
else:
backupPath = sys.argv[1]
print "Checking..."
if not backupPath.endswith('/'):
backupPath = backupPath + '/'
myIP = network.getMyIPAddr()
dbIP = cacheFile.getDatabaseIP()
db = MySQLdb.connect(dbIP, setting.DB_USERNAME, setting.DB_PASSWORD,
setting.DB_NAME)
cursor = db.cursor()
#check host activity
cursor.execute(
"SELECT `hostID` FROM `hosts` WHERE `status`=1 and `activity`<>0")
if cursor.fetchone() != None:
print "There are host(s) doing some activity, please wait until they finish"
sys.exit()
#check task queue
cursor.execute("SELECT `taskID` FROM `tasks` WHERE `status`<>2")
def update_pki(argv):
'''
argv[0]=[conn,s,event] #socket
argv[1]=cerHostIP (optional)
'''
conn = argv[0][0]
s = argv[0][1]
#add later for testing
#print "service libvirtd stop"
#general.runDaemonCommand("service libvirtd stop",conn,s)
#find cerHostIP
if len(argv) == 1:
#find CA Server from database
infoHost = cacheFile.getDatabaseIP()
db = MySQLdb.connect(infoHost, setting.DB_USERNAME,
setting.DB_PASSWORD, setting.DB_NAME)
cursor = db.cursor()
cursor.execute('''SELECT
`IPAddress`
FROM `hosts`
WHERE `isCA`=1;''')
tmpData = cursor.fetchone()
if tmpData == None:
return 'CA Server not found.'
cerHostIP = tmpData[0]
else:
cerHostIP = argv[1]
#create directory
result = subprocess.Popen(
shlex.split("mkdir -p /etc/pki/libvirt/private/"),
stdout=subprocess.PIPE)
result.wait()
#generate private key
result = subprocess.Popen(shlex.split(
"certtool --generate-privkey --outfile /etc/pki/libvirt/private/serverkey.pem"
),
stdout=subprocess.PIPE)
result.wait()
#get cacert from CA to install at /etc/pki/CA/cacert.pema
cacertString = connection.socketCall(cerHostIP, setting.LOCAL_PORT,
'request_cacert')
cacertFile = open('/etc/pki/CA/cacert.pem', 'w')
cacertFile.write(cacertString)
cacertFile.close()
''' not secure
#send private key to sign at CA server
cerString = connection.socketCall(cerHostIP, setting.LOCAL_PORT, 'request_sign_certificate',[str(network.getMyIPAddr()),open("/etc/pki/libvirt/private/serverkey.pem",'r').read()])
'''
#more secure (sending request)
serverIP = str(network.getMyIPAddr())
#create template file
infoString = '''
organization = Maekin
cn = "%s"
tls_www_server
tls_www_client
encryption_key
signing_key
''' % (serverIP)
infoFile = open('/etc/pki/libvirt/' + serverIP + '.info', 'w')
infoFile.write(infoString)
infoFile.close()
#generate request from private key
result = subprocess.Popen(shlex.split(
"certtool --generate-request --load-privkey /etc/pki/libvirt/private/serverkey.pem --template /etc/pki/libvirt/%s.info --outfile /etc/pki/libvirt/%s.req"
% (serverIP, serverIP)),
stdout=subprocess.PIPE)
result.wait()
requestString = open('/etc/pki/libvirt/' + serverIP + '.req', 'r').read()
cerString = connection.socketCall(cerHostIP, setting.LOCAL_PORT,
'request_sign_certificate',
[serverIP, infoString, requestString])
#write to file
cerFile = open('/etc/pki/libvirt/servercert.pem', 'w')
cerFile.write(cerString)
cerFile.close()
#copy (already test : this command doesn't ask when must overwrite)
shutil.copy2('/etc/pki/libvirt/private/serverkey.pem',
'/etc/pki/libvirt/private/clientkey.pem')
shutil.copy2('/etc/pki/libvirt/servercert.pem',
'/etc/pki/libvirt/clientcert.pem')
#delete temporary file
os.remove('/etc/pki/libvirt/' + serverIP + '.info')
os.remove('/etc/pki/libvirt/' + serverIP + '.req')
#then restart libvirtd (very important)
#*step should be like this
#general.runDaemonCommand("service mklocm stop") #do not stop because mklocm can resist error of libvirtd restart
#debugger.countdown(10,"before restart libvirtd")
print "service libvirtd restart"
general.runDaemonCommand("service libvirtd stop", conn, s)
general.runDaemonCommandUntilOK("service libvirtd start", conn, s)
#time.sleep(2)
#debugger.countdown(10,"after restart libvirtd")
print "wait conn"
vconn = libvirt.open(None)
while vconn == None:
time.sleep(1)
vconn = libvirt.open(None)
vconn.close()
#debugger.countdown(10,"vconn.close()")
#general.runDaemonCommand("service mklocm start",conn,s) #do not stop because mklocm can resist error of libvirtd restart
return 'OK'
def migrate_database_to(argv):
'''
this method must be called at master database only
and should be call after finish NFS system
1. destroy slave
2. dump and send to targetHost to create new master
3. stop mysqld service
'''
targetHostIP = argv[0]
#find slave to destroy from my database
db = MySQLdb.connect("localhost", "root", setting.DB_ROOT_PASSWORD,
setting.DB_NAME)
cursor = db.cursor()
cursor.execute(
"SELECT `IPAddress` FROM `hosts` WHERE `isInformationServer`=2")
activeSlave = cursor.fetchone()
if activeSlave != None:
slaveIP = activeSlave[0]
connection.socketCall(targetHostIP, setting.LOCAL_PORT,
'destroy_slave_host_info')
myIP = network.getMyIPAddr()
cursor.execute("FLUSH TABLES WITH READ LOCK;")
result = subprocess.Popen(
shlex.split("mysqldump %s -u root --password='******'" %
(setting.DB_NAME, setting.DB_ROOT_PASSWORD)),
stdout=subprocess.PIPE)
#result.wait()
output = result.communicate()[0]
#dumpFile=open(setting.DB_NFS_DUMP_FILE,'w')
#dumpFile.write(output)
#dumpFile.close()
result = connection.socketCall(targetHostIP, setting.LOCAL_PORT,
'you_are_db_migration_destination',
['{socket_connection}', output])
cursor.execute("UNLOCK TABLES;")
cursor.execute("DROP DATABASE IF EXISTS %s" %
(setting.DB_NAME)) #this line was added later
db.close()
if result == 'OK':
dbController.stop()
db = MySQLdb.connect(targetHostIP, setting.DB_USERNAME,
setting.DB_PASSWORD, setting.DB_NAME)
cursor = db.cursor()
cursor.execute(
"UPDATE `hosts` SET `isInformationServer`=0 WHERE `IPAddress`='%s'"
% (str(myIP)))
db.close()
dbController.broadcastNewMasterInformationServer(targetHostIP)
return 'OK'
else:
return result
def you_are_next_global_controller(argv):
'''
promote myself to be global_controller and DHCP server
'''
conn = argv[0][0]
s = argv[0][1]
mode = argv[1]
whitelistString = argv[2]
#config and start dhcp server
dhcpInfo=dhcpController.getDHCPInfoFromDatabase()
dhcpController.configAll(dhcpInfo['networkID'],dhcpInfo['subnetMask'],dhcpInfo['defaultRoute'],dhcpInfo['dns'],dhcpInfo['hostBindings'],conn,s)
#network.configToStaticFromCacheFile() #(conn,s) #new system no need to do this
#generate whitelist file
aFile=open(setting.API_WHITELIST_FILE,'w')
aFile.write(whitelistString)
aFile.close()
#start global controller (mkapi and mkworker and [scheduler])
general.runDaemonCommand(command="service mkapi start",conn=conn,sock=s,pipe=True) #can be True in log system
#general.runDaemonCommand("service mkworker start debug",conn,s)
infoHost=cacheFile.getDatabaseIP()
db = MySQLdb.connect(infoHost, setting.DB_USERNAME, setting.DB_PASSWORD, setting.DB_NAME )
cursor = db.cursor()
if mode=='migrate':
#must tell old GlobalController to stop service
cursor.execute("SELECT `IPAddress` FROM `hosts` WHERE `isGlobalController`=1;")
hostData=cursor.fetchone()
if hostData!=None:
result=connection.socketCall(hostData[0],setting.LOCAL_PORT,"close_global_controller_and_dhcp_server",['{socket_connection}'])
if result!='OK':
print 'close_global_controller_and_dhcp_server was not complete.(can leave it, no problem)'
cursor.execute("UPDATE `hosts` SET `isGlobalController`=1 WHERE `IPAddress`='%s';"%(str(network.getMyIPAddr())))
db.close()
return "OK"
def close_global_controller_and_dhcp_server(argv):
'''
close and update database for move to other place
'''
dhcpController.stop()
dhcpController.clearConfigFile()
time.sleep(1)
result = subprocess.Popen(shlex.split("service mkapi stop"), stdout=subprocess.PIPE)
result.wait()
#update database
infoHost=cacheFile.getDatabaseIP()
db = MySQLdb.connect(infoHost, setting.DB_USERNAME, setting.DB_PASSWORD, setting.DB_NAME )
cursor = db.cursor()
cursor.execute("UPDATE `hosts` SET `isGlobalController`=0 WHERE `IPAddress`='%s';"%(str(network.getMyIPAddr())))
db.close()
#network.configToAuto() #no need to do like this
return 'OK'
