diff options
Diffstat (limited to 'python_pgms/cloud-on-fly/src/cloud-seed_nfs.py')
-rwxr-xr-x | python_pgms/cloud-on-fly/src/cloud-seed_nfs.py | 1509 |
1 files changed, 1509 insertions, 0 deletions
diff --git a/python_pgms/cloud-on-fly/src/cloud-seed_nfs.py b/python_pgms/cloud-on-fly/src/cloud-seed_nfs.py new file mode 100755 index 0000000..28a29ca --- /dev/null +++ b/python_pgms/cloud-on-fly/src/cloud-seed_nfs.py @@ -0,0 +1,1509 @@ +#!/usr/bin/env python +# - coding: utf-8 -*- +import getopt, sys, os, string,glob +from optparse import OptionParser,OptionGroup,make_option + +default=1 +##vol_files=None +nfs="on" +overflow=False +#dbpath="/home/lakshmipathi/cloud_db.sqlite" +dbpath="/usr/share/cloud/cloud_db.sqlite" +opt_mount_path="/usr/share/cloud/mount_opt.sh" +cmd_pdsh ="/usr/local/bin/pdsh -R exec -w " +#cmd_pdsh ="/opt/pdsh-2.18/bin/pdsh -R exec -w " +cmd_pdsh2=" ssh -x -l %u %h " + +cmd_mkdir = "/bin/mkdir -p " +cmd_kaput = "kaput -n " + + +cmd_cat = "/bin/cat " +cmd_mount = "/bin/mount " +cmd_umount = "/bin/umount " +cmd_mv = "/bin/mv " +cmd_kill="/bin/kill -9 " +cmd_rm="/bin/rm -rf " +cmd_cp="cp " + + +cmd_pid1="ps -p " +cmd_pid2=" -o comm=" + + +cloud_seed_trash=" /tmp/.cloud_seed_trash" +glusterfs_version="gnfs-git" # default gluster version +pdsh_user="root@" + +#base of client mont pts +cloud_dir="/mnt/export/gluster/cloud/mnt/" +#cloud_export_dir="/home/lakshmipathi/mnt/export/" +#cloud_spec_dir="/home/lakshmipathi/mnt/specs_dir/" + +cloud_export_dir="/ebs-raid/export/gluster/cloud/export/" +cloud_spec_dir="/ebs-raid/export/gluster/cloud/specs_dir/" + + +#SQL Stmts +SQL_STMT_INIT_CLOUD = "insert into cloud_seed (cloud_id,cloud_name,status,version) values (?,?,?,?)" +SQL_STMT_ACTIVATE_CLOUD ="update cloud_seed set status='active',type=? where cloud_id=?" +#SQL_STMT_DEACTIVATE_CLOUD="update cloud_seed set status='free' where cloud_id=?" + +SQL_STMT_DEACTIVATE_CLOUD="delete from cloud_seed where cloud_id=?" + + +SQL_STMT_GET_S_MAX="select max(rowid) from server_pool" +SQL_STMT_GET_C_MAX="select max(rowid) from client_pool" + +SQL_STMT_GET_S_POOL="select * from server_pool limit (?)" +SQL_STMT_GET_C_POOL="select * from client_pool limit (?)" + +SQL_STMT_INSERT_S_PROCESS="insert into server_process(server,status,cloud_id,snum) values (?,?,?,?)" +SQL_STMT_INSERT_C_PROCESS="insert into client_process(client,status,cloud_id,cnum) values (?,?,?,?)" + +SQL_STMT_S_PROCESS_GETBY_CLOUDID="select * from server_process where cloud_id=?" +SQL_STMT_C_PROCESS_GETBY_CLOUDID="select * from client_process where cloud_id=?" + +SQL_STMT_S_PROCESS_GETBY_CLOUDID2="select * from server_process where status='running' and cloud_id=? " +SQL_STMT_C_PROCESS_GETBY_CLOUDID2="select * from client_process where status='running' and cloud_id=? " + + + + +SQL_STMT_UPDATE_S_PROCESS="update server_process set export_dir =? where cloud_id=? and snum=? and server=?" +SQL_STMT_UPDATE_C_PROCESS="update client_process set mount_pt =? where cloud_id=? and cnum=? and client=?" + +SQL_STMT_UPDATEPID_S_PROCESS="update server_process set server_pid =?,logfile=?,status='running' where cloud_id=? and snum=? and server=?" +SQL_STMT_UPDATEPID_C_PROCESS="update client_process set client_pid =?,logfile=?,status='running' where cloud_id=? and cnum=? and client=?" + +SQL_STMT_UPDATE_DEFPORT_S_PROCESS="update server_process set port=? where cloud_id=?" +SQL_STMT_UPDATEPORT_S_PROCESS="update server_process set port =? where cloud_id=? and snum=? and server=?" +#cloud stop queries +SQL_STMT_CHECK_CLOUD = "select status,type,cloud_id,version from cloud_seed where cloud_name=?" +#SQL_STMT_UPDATESTATUS_C_PROCESS="update client_process set status='not_running' where cloud_id=?" +#SQL_STMT_UPDATESTATUS_S_PROCESS="update server_process set status='not_running' where cloud_id=?" + +SQL_STMT_UPDATESTATUS_C_PROCESS="delete from client_process where cloud_id=?" +SQL_STMT_UPDATESTATUS_S_PROCESS="delete from server_process where cloud_id=?" + +SQL_STMT_CHECKALL_CLOUD = "select cloud_id,type,cloud_name,version from cloud_seed where status='active'" +#update status +SQL_STMT_CSTATUS_CHECK_UPDATE="update client_process set status='not-running' where cloud_id=? and cnum=? and client=?" +SQL_STMT_SSTATUS_CHECK_UPDATE="update server_process set status='not-running' where cloud_id=? and snum=? and server=?" + + +import os +import sqlite3 +import time +import sys +import fileinput + +#Logging + +log_file = open("/var/log/cloud.log","a") +def logging_start(): + global log_file + log_file = open("/var/log/cloud.log","a") + + old_stdout = sys.stdout + sys.stdout = log_file + print time.asctime( time.localtime(time.time()) ) + return old_stdout + +def logging_stop(old_stdout): + sys.stdout = old_stdout + log_file.close() + + +class Cloud_db: + db=None + cursor=None + i=5 + cloud_id=1000 + server_pool_max=0 + client_pool_max=0 + #create a empty list + server_pool_list=[] + client_pool_list=[] + #create a empty list + server_process_list=[] + client_process_list=[] + # get from table and put values in dict + server_dict={} + exportdir_dict={} + client_dict={} + mntpt_dict={} + + dummy_server_files=[] + def __init__(self): + self.db=None + self.cursor=None + self.server_pool_list=[] + self.client_pool_list=[] + self.server_process_list=[] + self.client_process_list=[] + self.dummy_server_files=[] + self.server_dict={} + self.exportdir_dict={} + # put values in dict from process_table + self.client_dict={} + self.mntpt_dict={} + + self.cloud_id=1000 + self.server_pool_max=0 + self.client_pool_max=0 + + self.num_servers=4 + self.num_clients=1 + self.port=6196 + self.glusterfs_version=glusterfs_version + self.default_glusterfs_path="/opt/glusterfs/"+self.glusterfs_version + self.cmd_glfs_start=self.default_glusterfs_path+"/sbin/glusterfsd -f " + + self.run_file = " " + ################# + num_replica = 2 + name = "cluster" + clients = 1 + version = "latest_git" + #num_servers = 4 + total_servers_stripe = 4 + total_servers_afr=2 + total_servers_dht=2 + num_stripe = 4 + #num_servers = '' + default_port = 6196 + port_min = 1024 + + + usage_str1="To start: cloud-seed.py --start <CLUSTER_TYPE> --name <CLUSTER_NAME> [-s <NUM_OF_SERVERS>][-c <NUM_OF_CLIENTS>][-v <VERSION>][-p <PORT>]" + usage_str2="To stop cluster : cloud-seed.py --stop <CLOUD_ID>" + usage_str3="To display cluster status : cloud-seed.py --status <CLOUD_ID>" + usage_str4="To display all clusters : cloud-seed.py --show all " + usage_str5="To run commands on client : cloud-seed.py --run <CLOUD_SCRIPT> --name <CLUSTER_NAME>" + + usage_str="\n"+usage_str1+"\n\n"+usage_str2+"\n\n"+usage_str3+"\n\n"+usage_str4+"\n\n"+usage_str5 + + desc_str = "Takes the arguments from user and builds a cluster specified by the user in the command" + + parser = OptionParser(usage=usage_str, description=desc_str) + + #parse.add_option_group(group) + #(options, args) = parse.parse_args() + + # Basic option list + group = OptionGroup(parser, "Basic Options") + + group.add_option("-t", "--start", dest="cluster_type", + help="<cluster-type afr|dht|stripe>") + group.add_option("-n", "--name", dest="cluster_name", + help="clustername which will be used to control(stop/verify) cluster") + group.add_option("-s", "--servers", dest="num_servers", + type="int", help="number of servers. default: 2 if afr or dht and 4 if stripe ") + group.add_option("-c", "--clients", dest="num_clients", + type="int", help="number of clients") + group.add_option("-p", "--port", dest="port", + type="int", help="port number to connect to") + group.add_option("-v", "--version", dest="version", + default=glusterfs_version, help="version of the glusterfs to be used. ") + group.add_option("-S","--stop", dest="stop_cluster", + help="will stop the cluster and removes export dirs and mount pts") + group.add_option("-D","--status",dest="status_cluster",help="display status of a cluster") + group.add_option("-A","--show",dest="show_cluster",help="display cluster environment") + group.add_option("-r","--run",dest="run_file",help="will execute the script on cluster's client mount pts") + + + parser.add_option_group(group) + (options, args) = parser.parse_args() + + + if options.stop_cluster is None: + if options.run_file is not None: + self.retval='e' + self.run_file = options.run_file + self.cloud_name = options.cluster_name + " " + return + if options.show_cluster is not None: + self.retval='d' + return + if options.status_cluster is not None: + self.retval='c' + #self.cloud_id=options.status_cluster + self.cloud_name=options.status_cluster + " " + return + + + old_std=logging_start() + if options.cluster_type is None or options.cluster_name is None: + logging_stop(old_std) + print "Error: Cluster type is mandatory. Please provide a cluster type (afr|dht|stripe)" + print usage_str + #raise ValueError + sys.exit(2) + + elif str(options.cluster_type) == "afr": + print('You have asked for mirroring cluster') + logging_stop(old_std) + + elif str(options.cluster_type) == "stripe": + print('You have asked for a stripe cluster') + logging_stop(old_std) + + elif str(options.cluster_type) == "dht": + print('You have asked for a distributed cluster') + logging_stop(old_std) + + else: + logging_stop(old_std) + print "Invalid cluster type . Please provide a valid cluster type (afr|dht|stripe)" + #raise ValueError + sys.exit(2) + + + + if options.num_servers is not None: + if str(options.cluster_type) == "afr": + if (options.num_servers % num_replica) != 0: + print "Error: AFR takes only multiples of 2 servers. Please provide valid number of servers" + # raise ValueError + sys.exit(2) + else: + #num_replica = options.num_servers + print 'AFR: Number of servers provoded is valid' + elif str(options.cluster_type) == "stripe": + if (options.num_servers % num_stripe) != 0: + print "Error: stripe takes multiple of 4 servers. Please provide valid numner of servers" + #raise ValueError + sys.exit(2) + else: + #num_stripe = options.num_servers + print 'stripe: Number of servers provided is valid' + elif str(options.cluster_type) == "dht": + print('Distributing the files across', options.num_servers, 'volumes') + else: + if str(options.cluster_type) == "afr": + #print "Number of servers is kept as default" + #print options.num_servers + options.num_servers = total_servers_afr + + elif str(options.cluster_type) == "stripe": + options.num_servers=total_servers_stripe + + else: + options.num_servers=total_servers_dht + if options.num_clients is None: + options.num_clients = clients + + if options.port is None: + options.port = default_port + elif options.port < port_min: + print 'Error:port number should be greater than', port_min + sys.exit(2) + + if options.version is None: + print "No version number provoded. Hence continuing with the default version(latest)." + options.version = version + else: + print " " #Building the storage cluster with glusterfs version", options.version + + #print 'The options provided are:\ncluster type:', options.cluster_type, 'Cluster name:', options.cluster_name, 'Number of servers:', options.num_servers, 'Number of clients:', options.num_clients, 'Port Number:', options.port, 'Version:', options.version + self.retval='a' + else: + + self.cloud_name=options.stop_cluster + " " + self.retval='b' + return + + + self.cloud_type=options.cluster_type + self.cloud_name=options.cluster_name+" " + self.num_servers=options.num_servers + self.num_clients=options.num_clients + self.port=options.port + self.glusterfs_version=options.version + #reset path and start cmd + self.default_glusterfs_path="/opt/glusterfs/"+self.glusterfs_version + self.cmd_glfs_start=self.default_glusterfs_path+"/sbin/glusterfsd -f " + + old_std=logging_start() + print "\n----------------------" + print "Cloud-type : ",self.cloud_type,"\ncloud-name : ",self.cloud_name,"\nnum-servers",self.num_servers,"\nnum-clients",self.num_clients + print "port",self.port,"version:",self.glusterfs_version + print "path is " ,self.default_glusterfs_path,"cmd",self.cmd_glfs_start + print '\n----------------------' + logging_stop(old_std) + + def open_connection(self,path): + try: + old_std=logging_start() + print "open_connection:start" + self.db=sqlite3.connect(path) + self.cursor=self.db.cursor() + except Exception,e: + print "Failed : Connecting to database",path + logging_stop(old_std) + self.db,self.cursor=None,None + print e.args + else: + print "Connected to database successfully:",path + logging_stop(old_std) + return self.db,self.cursor + + + def initialize_processtables(self): + try: + old_std=logging_start() + print "initialize_processtables:start" + + + n=self.num_servers + m=self.num_clients + + overflow=False + #generate cloud id + print "running query:","select count(*) from cloud_seed where cloud_name=",self.cloud_name + self.cursor.execute("select count(*) from cloud_seed where cloud_name=?",(self.cloud_name,)) + for row in self.cursor: + if row[0] == 0: + print "okay" + else: + logging_stop(old_std) + print self.cloud_name,"already exists - Please select unique cloud name." + sys.exit(2) + + self.cursor.execute("select max(rowid) from cloud_seed") + for row in self.cursor: + print row[0] + + if row[0] == None: + print "it's empty" + self.cloud_id=1000 + print "cloud-id",self.cloud_id + else: + print "it has this value :",row[0] + self.cloud_id=1000 + print "new self.cloud_id:",self.cloud_id,"+",row[0],"=",self.cloud_id+row[0] + self.cloud_id=self.cloud_id+row[0] + + #create record in cloud_seed + self.cursor.execute(SQL_STMT_INIT_CLOUD,(self.cloud_id,self.cloud_name,"init",self.glusterfs_version,)) + + + s=(n,) + t=(m,) + #get total records from server_pool and client_pool + self.cursor.execute(SQL_STMT_GET_S_MAX) + + self.server_pool_max=0 + # get the max. rowid + for row in self.cursor: + self.server_pool_max=row[0] + print "max records in serverl pool:",self.server_pool_max + + + #Fetch records from server_pool + if n <= self.server_pool_max : + self.cursor.execute(SQL_STMT_GET_S_POOL,s) + # read values + for row in self.cursor: + self.server_pool_list.append(row) + + else: + print "overflow set as true" + overflow=True + counter=n/self.server_pool_max + while(counter > 0): + print counter + counter=counter - 1 + + self.cursor.execute(SQL_STMT_GET_S_POOL,(self.server_pool_max,)) + # read values + for row in self.cursor: + self.server_pool_list.append(row) + #fetch any remaining records + self.cursor.execute(SQL_STMT_GET_S_POOL,(n%self.server_pool_max,)) + # read values + for row in self.cursor: + self.server_pool_list.append(row) + + print self.server_pool_list + + # get the max. rowid + self.client_pool_max=0 + self.cursor.execute(SQL_STMT_GET_C_MAX) + + for row in self.cursor: + self.client_pool_max=row[0] + + print self.client_pool_max + + #Fetch records from client_pool + if m <= self.client_pool_max : + self.cursor.execute(SQL_STMT_GET_C_POOL,t) + # read values + for row in self.cursor: + self.client_pool_list.append(row) + + else: + counter=m/self.client_pool_max + while(counter > 0): + print counter + counter=counter - 1 + + self.cursor.execute(SQL_STMT_GET_C_POOL,(self.client_pool_max,)) + # read values + for row in self.cursor: + self.client_pool_list.append(row) + #fetch any remaining records + self.cursor.execute(SQL_STMT_GET_C_POOL,(m%self.client_pool_max,)) + # read values + for row in self.cursor: + self.client_pool_list.append(row) + + + if nfs == "on" : + #make nfsserver as unique + nfsserver=self.client_pool_list[0] + nfs_count = self.client_pool_list.count(nfsserver) + tmp=nfs_count + while tmp > 0 : + self.client_pool_list.remove(nfsserver) + tmp = tmp -1 + #insert to top + self.client_pool_list.insert(0,nfsserver) + bkup=self.client_pool_list[1] + tmp=nfs_count - 1 + while tmp > 0 : + self.client_pool_list.append(bkup) + tmp = tmp -1 + + print self.client_pool_list + + #insert into server_process + count=1 + for record in self.server_pool_list: + self.cursor.execute(SQL_STMT_INSERT_S_PROCESS,(record[0],record[1],self.cloud_id,count,)); + count=count+1 + + #insert into client_process + count=1 + for record in self.client_pool_list: + self.cursor.execute(SQL_STMT_INSERT_C_PROCESS,(record[0],record[1],self.cloud_id,count,)); + count=count+1 + + except Exception,e: + print e.args + print "** failed**:initialize_processtables:while copying records from pool table to process table" + logging_stop(old_std) + else: + print "client/server records retrived from pool and inserted into process table." + logging_stop(old_std) + return overflow + + + def commit_changes(self): + try: + old_std=logging_start() + print "commit_changes:start" + self.db.commit() + except Exception,e: + print e.args + print "commit failed" + logging_stop(old_std) + else: + print "Changes are committed to database" + logging_stop(old_std) + + def mount_remote_server(self): + try: + old_std=logging_start() + print "mount_remote_server:start" + # get records from server_process table + self.cursor.execute(SQL_STMT_S_PROCESS_GETBY_CLOUDID,(self.cloud_id,)) + # read values + counter=0 + for row in self.cursor: + self.server_process_list.append(row) + + + for record in self.server_process_list: + print "\nRunning pdsh on server ",record[0] + print "Creating Export directories for server",record[0],":",record[5],"with cloud_id",record[1] + + #type case int into string + str_cloud_id = str(record[1]) + str_snum = str(record[5]) + + #create export dirs + export_dir=cloud_export_dir+str_cloud_id + "/export"+str_snum + cmd=cmd_pdsh + pdsh_user + record[0] +cmd_pdsh2+ cmd_mkdir + export_dir + print "Running cmd:",cmd + os.system(cmd) + + #create spec dir for volume files + cmd=cmd_pdsh + pdsh_user + record[0] +cmd_pdsh2+ cmd_mkdir + cloud_spec_dir + str_cloud_id +"/server"+ str_snum + print "Running cmd:",cmd + os.system(cmd) + + + + print "update server_process table" + self.cursor.execute(SQL_STMT_UPDATE_S_PROCESS,(export_dir,record[1],record[5],record[0],)); + #add it in dictionary key:value == > key=cloud_id+snum , value=server + self.server_dict[str_cloud_id+"-"+str_snum]=record[0] + + + #second dictionary for export dirs + self.exportdir_dict[str_cloud_id+"-"+str_snum]=export_dir.strip() + + print self.server_dict + print self.exportdir_dict + + #TODO check free port + + + except Exception,e: + print e.args + print "**FAILED**:mount_remote_server: While creating export dirs with pdsh in remote server ." + logging_stop(old_std) + else: + print "Creating export dirctories in remote server .done" + logging_stop(old_std) + + def mount_remote_client(self): + try: + old_std=logging_start() + print "mount_remote_client:start" + self.cursor.execute(SQL_STMT_C_PROCESS_GETBY_CLOUDID,(self.cloud_id,)) + # read values + counter=0 + for row in self.cursor: + self.client_process_list.append(row) + + + for record in self.client_process_list: + print "\nRunning pdsh on client",record[0] + print "Creating mount points for client:",record[0],":",record[5],"with cloud_id",record[1] + + #type case int into string + str_cloud_id = str(record[1]) + str_cnum=str(record[5]) + + mnt_pt=cloud_dir +str_cloud_id + "/"+str_cnum + cmd=cmd_pdsh + pdsh_user + record[0] +cmd_pdsh2+ cmd_mkdir + mnt_pt + print "Running cmd:",cmd + os.system(cmd) + + + print "Running mkdir cmd:",cmd + self.cursor.execute(SQL_STMT_UPDATE_C_PROCESS,(mnt_pt,record[1],record[5],record[0],)); + os.system(cmd) + + #create spec dir for volume files + cmd=cmd_pdsh + pdsh_user + record[0] +cmd_pdsh2+ cmd_mkdir + cloud_spec_dir+ str_cloud_id +"/client"+ str_cnum + print "Running cmd:",cmd + os.system(cmd) + + #add it in dictionary key:value == > key=cloud_id+cnum , value=client + self.client_dict[str_cloud_id+"-"+str_cnum]=record[0] + #second dictionary for mnt_pts + self.mntpt_dict[str_cloud_id+"-"+str_cnum]=mnt_pt.strip() + + print self.client_dict + print self.mntpt_dict + + + except Exception,e: + print e.args + print "**FAILED**:mount_remote_client: While creating mount points with pdsh in remote client ." + logging_stop(old_std) + else: + print "Creating mount points with pdsh in remote client .done" + logging_stop(old_std) + + + def create_config_files(self,overflow): + try: + old_std=logging_start() + print "create_config_files:start" + + #create local temp vol file dir. + cmd= cmd_mkdir + "/tmp/" + str(self.cloud_id) + print "Running cmd:",cmd + os.system(cmd) + + + #things todo incase of num_server > server_pool_max : START + + if overflow==True: + print "True" + server_export="" + dummy="_dummy_" + for snum in range(1,self.num_servers+1): + print snum + key=str(self.cloud_id)+"-"+str(snum) + print self.server_dict[key]+":"+self.exportdir_dict[key] + + if snum <= self.server_pool_max: + server_export += self.server_dict[key]+":"+self.exportdir_dict[key]+" " + else: + print "It's greater now" + server_export += self.server_dict[key]+dummy+str(snum)+":"+self.exportdir_dict[key]+" " + self.dummy_server_files.append(self.server_dict[key]+dummy+str(snum)) + + + print server_export + else: + print "false" + + + #END:things todo incase of num_server > server_pool_max + + print "Going to creat config file with " ,self.num_servers ," servers" ,self.num_clients,"clients" + print "Fetch self.server_dict and export_dict" + + + server_export="" + for snum in range(1,self.num_servers+1): + print snum + key=str(self.cloud_id)+"-"+str(snum) + print self.server_dict[key]+":"+self.exportdir_dict[key] + + server_export += self.server_dict[key]+":"+self.exportdir_dict[key]+" " + + + + #Run volgen + + if self.cloud_type == "afr": + type="-r 1" + elif self.cloud_type == "stripe": + type="-r 0" + else: + type=" " + + + cmd_volgen=self.default_glusterfs_path + "/bin/glusterfs-volgen -n " +self.cloud_name + cmd=cmd_volgen +type+" -p "+str(self.port)+" "+server_export +" -c " +"/tmp/"+ str(self.cloud_id) + + print cmd + os.system(cmd) + + #: change port in serv files & port+hostname in client file + text="transport.socket.listen-port " + search =text + str(self.port) + newport=self.port + #first set default port value and overwrite it below if needed. + self.cursor.execute(SQL_STMT_UPDATE_DEFPORT_S_PROCESS,(newport,self.cloud_id,)); + if overflow == True: + print "Changing server port in :" + for f in self.dummy_server_files: + fn="/tmp/"+str(self.cloud_id)+"/"+f+"-"+self.cloud_name.strip()+"-export.vol" + print fn + #Change port number + newport = newport + 1 + replace=text + str(newport)+" " + #replace + for line in fileinput.FileInput(fn,inplace=1): + line = line.replace(search,replace) + print line + print "update port for ",self.cloud_id,f ,"as :",newport + s_port=f.split("_dummy_") + print "for server :",s_port[0],"snum is",s_port[1] + + #update port in table + print "updating table:" + self.cursor.execute(SQL_STMT_UPDATEPORT_S_PROCESS,(newport,self.cloud_id,s_port[1],s_port[0],)); + + + + print "change remote-hostname in client vol files" + newport=self.port + text="remote-host " + for serv in self.dummy_server_files: + cflag=0 + s1=str(serv) + end=s1.index("_") + + search=text + s1 + replace=text + s1[0:end] + + print "search string is " ,search ,"and replace is ",replace + + client_f="/tmp/"+str(self.cloud_id)+"/"+self.cloud_name.strip()+"-tcp.vol" + print "client file : ",client_f + for line in fileinput.FileInput(client_f,inplace=1): + if "option remote-host" in line and s1 in line: + line = line.replace(search,replace) + cflag=1 + #Now change the port number + if cflag and "transport.remote-port" in line: + a=line.rstrip().split(" ") + newport = newport + 1 + #a[-1]=str(int(a[-1])+1) + a[-1]=str(newport) + line=' '.join(a) + cflag=0 + print line + fileinput.close() + #format client file=>remove blank lines + for lines in fileinput.FileInput(client_f, inplace=1): + lines = lines.strip() + if lines == '': continue + print lines + fileinput.close() + + # + for lines in fileinput.FileInput(client_f, inplace=1): + lines=lines.strip() + ret = lines.find("end-volume") + if ret == -1: + print lines + else: + print lines + print "\n" + fileinput.close() + + time.sleep(5) + + #Now vol files are available under /tmp/self.cloud_id move it to respective server and client machines. + #T0D0 -- if nfs is set, add acl to server and append nfs-xlator to client + if nfs == "on": + root="/tmp/" + #edit client files + path=os.path.join(root,str(self.cloud_id)) + alines=["\nvolume nfs\n"," type nfs/server\n"," option rpc-auth.addr.allow *\n"," subvolumes statprefetch\n","end-volume\n"] + os.chdir(path) + for clientfile in glob.glob("*-tcp.vol"): + data=open(clientfile).readlines() + data+=alines + open("temp","w").write(''.join(data)) + os.rename("temp",clientfile) + #edit server files + + for svrfile in glob.glob("*-export.vol"): + for line in fileinput.FileInput(svrfile,inplace=1): + line = line.replace("subvolumes posix1","subvolumes posix-ac") + print line + #add ac + alines2=["\nvolume posix-ac\n"," type features/access-control\n"," subvolumes posix1 \n","end-volume\n"] + for svrfile in glob.glob("*-export.vol"): + f=0 + for line in fileinput.FileInput(svrfile,inplace=1): + ind=line.find("end-volume") + if ind!=-1 and not f: + line=line[:ind+10] + ''.join(alines2) + line[ind+10:] + f=1 + print line + + if overflow == False: + for snum in range(1,self.num_servers+1): + print snum + key=str(self.cloud_id)+"-"+str(snum) + print self.server_dict[key] + #move volfiles + src= "/tmp/"+str(self.cloud_id)+"/"+ self.server_dict[key]+"-"+self.cloud_name.strip()+"-export.vol" + dest=cloud_spec_dir + str(self.cloud_id) +"/server"+ str(snum) + cmd=cmd_kaput + self.server_dict[key] +" "+src+" " + dest + print "\nMoving server vol.files.Running cmd:",cmd + os.system(cmd) + #TODO:Move mount.sh - automount /opt- and run it using pdsh + cmd=cmd_kaput + self.server_dict[key] +" "+opt_mount_path+" /tmp" + os.system(cmd) + + cmd=cmd_pdsh + pdsh_user + self.server_dict[key] +cmd_pdsh2+ "/tmp/mount_opt.sh" + print "Running cmd:",cmd + os.system(cmd) + + + else: + dummy="_dummy_" + for snum in range(1,self.num_servers+1): + print snum + key=str(self.cloud_id)+"-"+str(snum) + print self.server_dict[key] + #move volfiles + + if snum <= self.server_pool_max: + src= "/tmp/"+str(self.cloud_id)+"/"+self.server_dict[key]+"-"+self.cloud_name.strip()+"-export.vol" + else: + src= "/tmp/"+str(self.cloud_id)+"/"+self.server_dict[key]+dummy+str(snum)+"-"+self.cloud_name.strip()+"-export.vol" + dest=cloud_spec_dir + str(self.cloud_id) +"/server"+ str(snum) + cmd=cmd_kaput + self.server_dict[key] +" "+src+" " + dest + print "\nMoving server vol.files.Running cmd:",cmd + os.system(cmd) + #TODO: move mount.sh to /tmp - automount /opt if not exits and run it using pdsh + cmd=cmd_kaput + self.server_dict[key] +" "+opt_mount_path+" /tmp" + os.system(cmd) + + cmd=cmd_pdsh + pdsh_user + self.server_dict[key] +cmd_pdsh2+ "/tmp/mount_opt.sh" + print "Running cmd:",cmd + os.system(cmd) + + + for cnum in range(1,self.num_clients+1) : + print cnum + key=str(self.cloud_id)+"-"+str(cnum) + print self.client_dict[key] + + print "Moving client vol.files." + src="/tmp/"+str(self.cloud_id)+"/"+self.cloud_name.strip()+"-tcp.vol" + dest=cloud_spec_dir+str(self.cloud_id)+"/client"+str(cnum) + cmd=cmd_kaput +self.client_dict[key]+" "+src+" "+dest + print "Running cmd:",cmd + os.system(cmd) + #TODO:move mount.sh to clients /tmp and run it using pdsh + cmd=cmd_kaput + self.client_dict[key] +" "+opt_mount_path+" /tmp" + os.system(cmd) + cmd=cmd_pdsh + pdsh_user + self.client_dict[key] +cmd_pdsh2+ "/tmp/mount_opt.sh" + print "Running cmd:",cmd + os.system(cmd) + if nfs=="on": + cmd1=" /etc/init.d/rpcbind start" + cmd=cmd_pdsh + pdsh_user + self.client_dict[key] +cmd_pdsh2+ cmd1 + os.system(cmd) + cmd1=" /etc/init.d/portmap start" + cmd=cmd_pdsh + pdsh_user + self.client_dict[key] +cmd_pdsh2+ cmd1 + os.system(cmd) + cmd1=" /etc/init.d/nfslock start" + cmd=cmd_pdsh + pdsh_user + self.client_dict[key] +cmd_pdsh2+ cmd1 + os.system(cmd) + + + + + except Exception,e: + print e.args + print "**ERROR**:create_config_files: while moving vol files" + logging_stop(old_std) + else: + print "vol. files are moved to appropriate server/client machines" + logging_stop(old_std) + + return + + + def start_server(self): + try: + old_std=logging_start() + print "start_server:start" + print self.server_dict + dummy="_dummy_" + #Now vol files are available servers.So start it + for snum in range(1,self.num_servers+1): + print snum + key=str(self.cloud_id)+"-"+str(snum) + print self.server_dict[key] + #start servers + logfile=cloud_spec_dir+ str(self.cloud_id) +"/server"+ str(snum)+"/"+"gs.log" + + if snum <= self.server_pool_max: + servfile= str(self.cloud_id) +"/server"+ str(snum)+"/"+ self.server_dict[key]+"-"+self.cloud_name.strip()+"-export.vol" + else: + + servfile1= str(self.cloud_id) +"/server"+ str(snum)+"/"+ self.server_dict[key]+dummy+str(snum)+"-" + servfile=servfile1+self.cloud_name.strip()+"-export.vol" + pidfile= " -L NONE --pid-file=/tmp/server.pid" + + cmd=cmd_pdsh + pdsh_user + self.server_dict[key] +cmd_pdsh2+self.cmd_glfs_start+ cloud_spec_dir+servfile+" -l "+logfile+pidfile + print "\nStarting server.Running cmd:",cmd + os.system(cmd) + + #pid and log file in server_process table + cmd=cmd_pdsh + pdsh_user + self.server_dict[key] + cmd_pdsh2 + cmd_cat + "/tmp/server.pid > /tmp/gs.pid" + print "Recording pid",cmd + os.system(cmd) + cmd=cmd_cat + "/tmp/gs.pid" + print "server pid is :" + os.system(cmd) + f = open("/tmp/gs.pid", "r") + for line in f: + pid = line.strip().split()[1].lower() + print " -->", pid + f.close() + #update pid in table + print "updating table:" + self.cursor.execute(SQL_STMT_UPDATEPID_S_PROCESS,(pid,logfile,self.cloud_id,snum,self.server_dict[key],)); + + except Exception,e: + print e.args + print " **ERROR**start_server: Starting servers and updating pid in server_process table" + logging_stop(old_std) + else: + print "Done.Servers are started and pids recorded" + logging_stop(old_std) + + def start_client(self): + + try: + old_std=logging_start() + print "start_client:start" + print self.client_dict + #if nfs == "on": + #cmd="/bin/echo '128' > /proc/sys/sunrpc/tcp_slot_table_entries" + #print cmd + #os.system("echo '128' > /proc/sys/sunrpc/tcp_slot_table_entries") + #Now vol files are available client.So start it + #If nfs is set - for the first client - start it as nfs/server and for other mount it. + run = 1 + skip = 0 + nfsserver=" " + for cnum in range(1,self.num_clients+1): + print cnum + key=str(self.cloud_id)+"-"+str(cnum) + print "client is ==>",self.client_dict[key] + #start client + #logfile=cloud_spec_dir+ str(self.cloud_id) +"/client"+ str(cnum)+"/"+"gc.log" + logfile="/mnt/gc.log" + + if nfs == "on" and run == 1: + print "nfs=on run=1 skip=0",self.client_dict[key] + clientfile=str(self.cloud_id)+"/client"+str(cnum)+"/"+self.cloud_name.strip()+"-tcp.vol " + #reset run --if needed + if cnum == self.num_servers: + run = 0 + skip = 0 + nfsserver = self.client_dict[key] + #make sure rpcbin/portmap started before nfs server + cmd1=" /etc/init.d/rpcbind start" + cmd=cmd_pdsh + pdsh_user + self.client_dict[key] +cmd_pdsh2+ cmd1 + os.system(cmd) + cmd1=" /etc/init.d/portmap start" + cmd=cmd_pdsh + pdsh_user + self.client_dict[key] +cmd_pdsh2+ cmd1 + os.system(cmd) + + + elif nfs == "on" and run == 0: + print "nfs=on run=0 skip=1",self.client_dict[key] + #mount these here itself and skip the 'other mount' below + #nfsserver_set will tell - how many nfs servers are there. + nfsserver_set=(self.num_clients - self.num_servers) / self.num_servers + + pos = cnum % self.num_servers + if pos==0: + pos=self.num_servers + + #if nfsserver_set > 1: + # if cnum == 1: + # key_dummy=str(self.cloud_id)+"-"+str(pos) + # nfsserver=self.client_dict[key_dummy] + # elif cnum % nfsserver_set != 0: + # key_dummy=str(self.cloud_id)+"-"+str(pos) + # nfsserver=self.client_dict[key_dummy] + #else: + key_dummy=str(self.cloud_id)+"-"+str(pos) + nfsserver=self.client_dict[key_dummy] + + + print "client_dict=",self.client_dict + print "nfsserver=",nfsserver,"++",cnum,"++",self.cloud_id + cmd1=cmd_mount+" "+nfsserver+":/statprefetch " +self.mntpt_dict[key] + cmd=cmd_pdsh + pdsh_user + self.client_dict[key] +cmd_pdsh2+ cmd1 + print "running nfs mount:",cmd + os.system(cmd) + skip = 1 + else: + clientfile=str(self.cloud_id)+"/client"+str(cnum)+"/"+self.cloud_name.strip()+"-tcp.vol "+self.mntpt_dict[key] + + if skip != 1: + pidfile= " -L NONE --pid-file=/tmp/client.pid" + cmd1=cmd_pdsh + pdsh_user + self.client_dict[key] +cmd_pdsh2+self.cmd_glfs_start+cloud_spec_dir+clientfile+" -l " + #cmd1=cmd_pdsh + pdsh_user + self.client_dict[key] +cmd_pdsh2+" /opt/glusterfs/3.0.4avail3_32bit/sbin/glusterfsd -f "+cloud_spec_dir+clientfile+" -l " + cmd=cmd1+logfile+pidfile + print "\nStarting client.Running cmd:",cmd + os.system(cmd) + + #record client-pid and log file in client table. + cmd=cmd_pdsh + pdsh_user + self.client_dict[key] + cmd_pdsh2 + cmd_cat + "/tmp/client.pid > /tmp/gc.pid" + print "Recording pid",cmd + os.system(cmd) + cmd=cmd_cat + "/tmp/gc.pid" + print "client pid is :" + os.system(cmd) + f = open("/tmp/gc.pid", "r") + for line in f: + pid = line.strip().split()[1].lower() + print " -->", pid + f.close() + #update pid in table + self.cursor.execute(SQL_STMT_UPDATEPID_C_PROCESS,(pid,logfile,self.cloud_id,cnum,self.client_dict[key],)); + + #sleep for 5 seconds + time.sleep(5) + os.system("/bin/sync") + + except Exception,e: + print e.args + print " **ERROR**:start_client: Starting client and updating pid in client_process table" + + + logging_stop(old_std) + else: + print "Clients started and pid recorded" + logging_stop(old_std) + + def active_cloud(self): + + try: + old_std=logging_start() + print "active_cloud:start" + #update cloud_id as active + self.cursor.execute(SQL_STMT_ACTIVATE_CLOUD,(self.cloud_type,self.cloud_id,)); + except Exception,e: + print e.args + print "**ERROR** :active_cloud: while trying to change cloud status from init to active" + logging_stop(old_std) + else: + logging_stop(old_std) + print "-----------------------------------------------------------------------------------------------------------------------" + print self.cloud_type," cloud",self.cloud_name,"with",self.num_servers,"server(s) and",self.num_clients,"client(s) is active now." + print "------------------------------------------------------------------------------------------------------------------------" + + + + #Cloud stop functions + def check_valid(self): + try: + #self.cloud_id=raw_input("Cloud id ?") + self.cursor.execute(SQL_STMT_CHECK_CLOUD,(self.cloud_name,)); + for row in self.cursor: + state=str(row[0]) + type=str(row[1]) + self.cloud_id=row[2] + self.glusterfs_version=row[3] + if state=="active": + print "----------------------------------------------" + print "The",type," cloud ",self.cloud_name," is active and running glusterfs-",self.glusterfs_version + return True + else: + if state=="init": + print "Cloud is in init state" + else: + print "Cloud not found.Call 911." + return False + + except Exception,e: + old_std=logging_start() + print ' ' #e.args + print "**ERROR** :check_valid: while retriving cloud id",SQL_STMT_CHECK_CLOUD,self.cloud_name + logging_stop(old_std) + else: + print " " + + def stop_client(self): + try: + old_std=logging_start() + print "stop_client:start" + nfs_run=1 + self.cursor.execute(SQL_STMT_C_PROCESS_GETBY_CLOUDID,(self.cloud_id,)); + for row in self.cursor: + print "name:",row[0],"cloudid:",row[1],"pid:",row[2] + print "mntpt:",row[3],"prt",row[4] + print "cnum:",row[5],"state:",row[6],"log:",row[7] + + if str(row[6]) == "running" or nfs == "on": + #if nfs=="on" and nfs_run == 1: + # #kill this pid + # nfs_run=0 + # cmd=cmd_pdsh + pdsh_user + str(row[0]) +cmd_pdsh2+ cmd_kill + str(row[2]) + # print "Running cmd:",cmd + # os.system(cmd) + + #else: + cmd=cmd_pdsh + pdsh_user + str(row[0]) +cmd_pdsh2+ cmd_umount + str(row[3]) + print "Running cmd:",cmd + os.system(cmd) + nfs_run = 0 + print " Removing spec files " + cmd=cmd_pdsh + pdsh_user + str(row[0]) + cmd_pdsh2+ cmd_mv + cloud_spec_dir+str(self.cloud_id) + cloud_seed_trash + print cmd + os.system(cmd) + #empty cloud_seed trash + cmd=cmd_pdsh + pdsh_user + str(row[0]) + cmd_pdsh2+ cmd_rm + cloud_seed_trash +"/"+ str(self.cloud_id) + print "removing spec from trash ",cmd + os.system(cmd) + + + print " Removing mnt dirs " + cmd=cmd_pdsh + pdsh_user + str(row[0]) + cmd_pdsh2+ cmd_mv + cloud_dir+str(self.cloud_id) + cloud_seed_trash + print cmd + os.system(cmd) + + #empty tmp dir + cmd=cmd_pdsh + pdsh_user + str(row[0]) + cmd_pdsh2+ cmd_rm + " /tmp/" + str(self.cloud_id) + os.system(cmd) + #empty cloud_seed trash -again + cmd=cmd_pdsh + pdsh_user + str(row[0]) + cmd_pdsh2+ cmd_rm + cloud_seed_trash +"/" + str(self.cloud_id) + print "removing mnt from trash",cmd + os.system(cmd) + #update in table + print SQL_STMT_UPDATESTATUS_C_PROCESS,self.cloud_id + self.cursor.execute(SQL_STMT_UPDATESTATUS_C_PROCESS,(self.cloud_id,)); + + + + except Exception,e: + print e.args + print "**ERROR** :stop_client: while retriving cloud id from client process" + logging_stop(old_std) + else: + print "done." + logging_stop(old_std) + + def stop_server(self): + try: + old_std=logging_start() + print "stop_server:start" + self.cursor.execute(SQL_STMT_S_PROCESS_GETBY_CLOUDID,(self.cloud_id,)); + + s_list=[] + for row in self.cursor: + print "name:",row[0],"cloudid:",row[1],"pid:",row[2] + print "export:",row[3],"prt",row[4] + print "snum:",row[5],"state:",row[6],"log:",row[7] + #s_list.append(row[0]) + if str(row[6]) == "running": + cmd=cmd_pdsh + pdsh_user + str(row[0]) +cmd_pdsh2+ cmd_kill + str(row[2]) + print "Running cmd:",cmd + os.system(cmd) + #add servers to list and rm/mv directories -iff it not already done. + if s_list.count(row[0]) == 0: + s_list.append(row[0]) + cmd=cmd_pdsh + pdsh_user + str(row[0]) + cmd_pdsh2+ cmd_mv + cloud_spec_dir+str(self.cloud_id) + cloud_seed_trash + print " Removing spec files and export pts,Cmd:",cmd + os.system(cmd) + cmd=cmd_pdsh + pdsh_user + str(row[0]) + cmd_pdsh2+ cmd_rm + cloud_seed_trash +"/"+ str(self.cloud_id) + print "run1:",cmd + os.system(cmd) + cmd=cmd_pdsh + pdsh_user + str(row[0]) + cmd_pdsh2+ cmd_mv + cloud_export_dir+str(self.cloud_id) + cloud_seed_trash + print "run2",cmd + os.system(cmd) + cmd=cmd_pdsh + pdsh_user + str(row[0]) + cmd_pdsh2+ cmd_rm + cloud_seed_trash +"/"+ str(self.cloud_id) + print "run3",cmd + os.system(cmd) + + #update table + self.cursor.execute(SQL_STMT_UPDATESTATUS_S_PROCESS,(self.cloud_id,)); + + + except Exception,e: + print e.args + print "**ERROR** :stop_server: while retriving cloud id" + logging_stop(old_std) + else: + print "done." + logging_stop(old_std) + + + def deactivate_cloud(self): + try: + old_std=logging_start() + print "deactivate_cloud" + #update cloud_id as free + self.cursor.execute(SQL_STMT_DEACTIVATE_CLOUD,(self.cloud_id,)); + + except Exception,e: + print e.args + print "**ERROR** :deactivate_cloud: while retriving cloud id" + logging_stop(old_std) + else: + print "done." + logging_stop(old_std) + + def client_status(self): + try: + old_std=logging_start() + print "client_status:start" + print SQL_STMT_C_PROCESS_GETBY_CLOUDID,self.cloud_id + logging_stop(old_std) + self.cursor.execute(SQL_STMT_C_PROCESS_GETBY_CLOUDID,(self.cloud_id,)); + print "---------------------------------------------------------------" + print "client:\tmount-point:\tlogfile:\tstatus:\tpid" + print "---------------------------------------------------------------" + nfs_check="yes" + update_clients=[] + update_clients_dict={} + for row in self.cursor: + if nfs_check == "yes": + #check status of pid in remote + cmd=cmd_pdsh + pdsh_user + str(row[0]) +cmd_pdsh2+cmd_pid1+str(row[2])+cmd_pid2 +" > /tmp/pname2" + #print "checking pid status :",cmd + os.system(cmd) + time.sleep(2) + + # + if os.stat("/tmp/pname2")[6] == 0: + pname = -1 + else: + f = open("/tmp/pname2", "r") + for line in f: + pname = line.find("glusterfs") + f.close() + + #turn off status check for nfs-clients -- since mount has no pid + if nfs == "on": + nfs_check="no" #don't check for mounts + pname = 1 + if pname == -1: + #print "glusterfs not running" + + val=row[5] + update_clients.append(val) + str_cloudid=str(self.cloud_id) + str_cnum=str(row[5]) + update_clients_dict[str_cloudid+"-"+str_cnum]=str(row[0]) + + print row[0],": ---- :",row[7],": not-running : --" + else: + + print row[0],":",row[3],":",row[7],":",row[6],":",row[2] + + + + #fetch cnum from list and client name from dict + old_std=logging_start() + for record in update_clients: + name= update_clients_dict[str_cloudid+"-"+str(record)] + self.cursor.execute(SQL_STMT_CSTATUS_CHECK_UPDATE,(self.cloud_id,record,name,)) + print SQL_STMT_CSTATUS_CHECK_UPDATE,self.cloud_id,name,record + + except Exception,e: + print e.args + print "**ERROR** :client_status: while retriving cloud id" + logging_stop(old_std) + else: + logging_stop(old_std) + return None + + def server_status(self): + try: + old_std=logging_start() + print "server_status:start" + print "running query:",SQL_STMT_S_PROCESS_GETBY_CLOUDID,self.cloud_id + logging_stop(old_std) + self.cursor.execute(SQL_STMT_S_PROCESS_GETBY_CLOUDID,(self.cloud_id,)); + print "----------------------------------------" + print "server:directory:port:logfile:status:pid" + print "----------------------------------------" + + update_servers=[] + update_servers_dict={} + + for row in self.cursor: + old_std=logging_start() + print "check status of pid in remote ",row[0],"==>",row[5] + cmd=cmd_pdsh + pdsh_user + str(row[0]) +cmd_pdsh2+cmd_pid1+str(row[2])+cmd_pid2 +" > /tmp/pname" + print "checking pid status :",cmd + os.system(cmd) + logging_stop(old_std) + time.sleep(2) + + # + if os.stat("/tmp/pname")[6] == 0: + pname = -1 + else: + f = open("/tmp/pname", "r") + for line in f: + pname = line.find("glusterfs") + f.close() + + if pname == -1: + #print "glusterfs not running" + #update db status + #self.cursor.execute(SQL_STMT_SSTATUS_CHECK_UPDATE,(self.cloud_id,row[5],row[0],)); + val=row[5] + update_servers.append(val) + str_cloudid=str(self.cloud_id) + str_snum=str(row[5]) + update_servers_dict[str_cloudid+"-"+str_snum]=str(row[0]) + + print row[0],":",row[3],":",row[4],":",row[7],": not-running : --" + else: + print row[0],":",row[3],":",row[4],":",row[7],":",row[6],":",row[2] + #fetch snum from list and server name from dict + + old_std=logging_start() + for record in update_servers: + print update_servers_dict[str_cloudid+"-"+str(record)] + name= update_servers_dict[str_cloudid+"-"+str(record)] + self.cursor.execute(SQL_STMT_SSTATUS_CHECK_UPDATE,(self.cloud_id,record,name,)) + + print SQL_STMT_SSTATUS_CHECK_UPDATE,self.cloud_id,record,name + logging_stop(old_std) + except Exception,e: + old_std=logging_start() + print e.args + print "**ERROR** :server_status: while retriving cloud id" + logging_stop(old_std) + else: + return None + + def checkall_valid(self): + try: + old_std=logging_start() + print "checkall_valid:start" + logging_stop(old_std) + cloud_ids=[] + cloud_ids_type={} + cloud_ids_name={} + cloud_ids_version={} + self.cursor.execute(SQL_STMT_CHECKALL_CLOUD); + for row in self.cursor: + cid=str(row[0]) + cloud_ids.append(cid) + cloud_ids_type[str(cid)]=str(row[1]) + cloud_ids_name[str(cid)]=str(row[2]) + cloud_ids_version[str(cid)]=str(row[3]) + + for id in cloud_ids: + print "\t\t~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~" + print "\t\t\tcloud :",cloud_ids_name[id]," :type:",cloud_ids_type[id],": glusterfs:",cloud_ids_version[id] + print "\t\t~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~" + self.cloud_id=int(id) + self.server_status() + self.client_status() + + except Exception,e: + old_std=logging_start() + print e.args + print "**ERROR** :checkall_valid: while retriving cloud id" + logging_stop(old_std) + else: + print " " + + #get client records + + def get_client_info(self): + try: + old_std=logging_start() + print "get_client_info:start" + logging_stop(old_std) + self.cursor.execute(SQL_STMT_CHECK_CLOUD,(self.cloud_name,)); + for row in self.cursor: + state=str(row[0]) + type=str(row[1]) + self.cloud_id=row[2] + + + self.cursor.execute(SQL_STMT_C_PROCESS_GETBY_CLOUDID,(self.cloud_id,)) + # read values + counter=0 + for row in self.cursor: + self.client_process_list.append(row) + + if nfs == "on": + #remove nfs-server + self.client_process_list.pop(0) + + for record in self.client_process_list: + print " mount points for client:",record[0],":",record[3],"with cloud_id",record[1] + + + except Exception,e: + old_std=logging_start() + print e.args + print "**ERROR** : get_client_info:while retriving cloud id" + logging_stop(old_std) + + + else: + print " " + + + def run_on_mount_pt(self): + try: + old_std=logging_start() + print "run_on_mount_ptstart" + print "clients are : ",self.client_process_list + + + #before moving the script edit it - added mntpt to run_file and + #move the file to remote clients and execute the script at mount pt + cmd = cmd_cp+self.run_file+" /tmp" + os.system(cmd) + for record in self.client_process_list: + #Edit the file + for line in fileinput.FileInput(self.run_file,inplace=1): + line = line.replace("CLOUD_MNT_PT",str(record[3])) + print line + + + cmd=cmd_kaput + str(record[0])+" "+self.run_file+" " +str(record[3]) + print "running:",cmd + os.system(cmd) + + #copy the original file from tmp + cmd= cmd_mv + self.run_file +" " +cloud_seed_trash + os.system(cmd) + + cmd= cmd_cp +"/tmp/"+self.run_file+" ." + os.system(cmd) + + #now files are move to remove client mnt pt - now execute the script + #for record in self.client_process_list: - execute the file before someone modifies it :) + cmd=cmd_pdsh + pdsh_user + str(record[0]) +cmd_pdsh2+ str(record[3])+"/"+ self.run_file +" &" + #cmd=cmd_pdsh + pdsh_user + str(record[0]) +cmd_pdsh2+ "/tmp/"+ self.run_file + print "Running script:",cmd,"on client",str(record[0]) + os.system(cmd) + logging_stop(old_std) + + + except Exception,e: + old_std=logging_start() + print e.args + print "**ERROR** : run_on_mount_pt:while processing run file" + logging_stop(old_std) + + + else: + print " " + +###############MAIN PART############# + + +obj1=Cloud_db() +CONN,CURSOR=obj1.open_connection(dbpath) +ans=obj1.retval +if ans == 'a': + overflow=obj1.initialize_processtables() + obj1.mount_remote_server() + obj1.mount_remote_client() + obj1.commit_changes() + obj1.create_config_files(overflow) + obj1.start_server() + obj1.start_client() + obj1.active_cloud() + obj1.commit_changes() + #TODO : create save points are appropriate places and then commit. +elif ans == 'b': + if obj1.check_valid(): + print "stopping client(s)." + obj1.stop_client() + print "stoppping server(s)." + obj1.stop_server() + obj1.deactivate_cloud() + obj1.commit_changes() + print "cloud stopped." + + else: + print "nothing to kill" + +elif ans == 'c': + if obj1.check_valid(): + obj1.server_status() + obj1.client_status() + obj1.commit_changes() + else: + print "Cloud not found.Blown away?" +elif ans == 'd': + obj1.checkall_valid() + obj1.commit_changes() + +elif ans == 'e': + obj1.get_client_info() + obj1.run_on_mount_pt() + +else: + print "Invalid input ?" + + |