def setUp(self):
"""
Setup the test saturn host (where the storage is provisioned)
Assuming a VG exists on that host, run VGscan
This means that the SSH key should be on that host already
"""
print "Here is where we can set some state"
#Dummy super user for interfaces test
self.config = ConfigReader('saturn.ini')
self.saturnringip = self.config.get('tests', 'saturnringip')
self.saturnringport = self.config.get('tests', 'saturnringport')
self.iscsiserver = self.config.get('tests', 'saturniscsiserver')
my_admin = User.objects.create_superuser('myuser', '*****@*****.**',
'password')
testhost = StorageHost(dnsname=self.iscsiserver,
ipaddress=self.iscsiserver,
storageip1=self.iscsiserver)
testhost.save()
outStr = check_output([
"curl", "-X", "GET", "http://" + self.saturnringip + ":" +
self.saturnringport + "/api/vgscan/", "-d",
"saturnserver=" + self.iscsiserver
])
for eachElement in literal_eval(outStr):
vguuid = eachElement['vguuid']
vg = VG(vghost=testhost,
vguuid=vguuid,
vgpesize=1.0,
vgtotalpe=10.0,
vgsize=1.0)
vg.save()
self.host = literal_eval(outStr)[0]['vghost']
self.psrvr = PollServer(self.host)
def DeleteTarget(requestDic,owner):
'''
Delete iSCSI target
This function dispatches a request to the worker queue of the Saturn host
to delete the object (iSCSI target object).
R: RequestDic - which may contain one of the following
iqntarget name,
initiator name (all targets provisioned for that initiator),
targethost (DNS name of Saturn server).
'''
logger = getLogger(__name__)
queryset = None
if 'iqntar' in requestDic:
queryset=Target.objects.filter(iqntar=requestDic['iqntar'],owner=owner)
if 'iqnini' in requestDic:
if queryset is None:
queryset=Target.objects.filter(iqnini=requestDic['iqnini'],owner=owner)
else:
queryset=queryset.objects.filter(iqnini=requestDic['iqnini'])
if 'targethost' in requestDic:
if queryset is None:
queryset=Target.objects.filter(targethost=requestDic['targethost'],owner=owner)
else:
queryset=queryset.objects.filter(targethost=requestDic['targethost'])
if queryset is None:
return (1,"No targets to delete, or check delete API call")
config = ConfigReader()
numqueues = config.get('saturnring','numqueues')
jobs =[]
logger.info("DeleteTarget has %d targets to delete" % (queryset.count()))
for obj in queryset:
logger.info("DeleteTarget Working on deleting target %s" % (obj.iqntar,))
queuename = 'queue'+str(hash(obj.targethost)%int(numqueues))
queue = get_queue(queuename)
jobs = []
jobs.append( (queue.enqueue(DeleteTargetObject,obj), obj.iqntar) )
logger.info("Using queue %s for deletion" %(queuename,))
rtnStatus= {}
rtnFlag=0
numDone=0
while numDone < len(jobs):
ii=0
sleep(1)
for ii in range(0,len(jobs)):
if jobs[ii] == 0:
continue
(job,target) = jobs[ii]
if (job.result == 0) or (job.result == 1) or job.is_failed:
if job.result==1 or job.is_failed:
logger.error("Failed deletion of " + target)
rtnStatus[target] = "Failed deletion of " + target
rtnFlag=rtnFlag + job.result + int(job.is_failed)
jobs[ii]=0
numDone=numDone+1
else:
logger.info('...Working on deleting target '+target)
break
return (rtnFlag,str(rtnStatus))
def setUp(self):
#rows = sys.path
#for row in rows:
# print row
cfg = ConfigReader()
cfg.read("../config.xml")
Database.Open(cfg.GetPath(), cfg.GetUsername(), cfg.GetPassword())
def get(self, request):
config = ConfigReader()
numqueues = config.get('saturnring', 'numqueues')
allhosts = StorageHost.objects.filter(enabled=True)
for eachhost in allhosts:
queuename = 'queue' + str(hash(eachhost) % int(numqueues))
queue = get_queue(queuename)
queue.enqueue(UpdateOneState, eachhost)
return Response("Ok, enqueued state update request")
def OnInit(self):
if os.name == 'posix':
print os.environ['PWD']
cfg = ConfigReader()
cfg.read("../main/config.xml")
Database.Open(cfg.GetPath(), cfg.GetUsername(), cfg.GetPassword())
frame = MainFrame(None, title="The Main Frame")
self.SetTopWindow(frame)
frame.Show(True)
return True
def __init__(self, serverDNS):
"""
The init script for the class
"""
self.serverDNS = str(serverDNS)
BASE_DIR = dirname(dirname(__file__))
config = ConfigReader()
self.userName = config.get('saturnnode', 'user')
self.keyFile = join(BASE_DIR, config.get('saturnring',
'privatekeyfile'))
self.rembashpath = config.get('saturnnode', 'bashpath')
self.rempypath = config.get('saturnnode', 'pythonpath')
self.iscsiconfdir = join(BASE_DIR,
config.get('saturnring', 'iscsiconfigdir'))
self.remoteinstallLoc = config.get('saturnnode', 'install_location')
self.localbashscripts = join(BASE_DIR,
config.get('saturnring', 'bashscripts'))
try:
self.srv = Connection(self.serverDNS, self.userName, self.keyFile)
except:
logger.critical(
"Failed SSH-exec connection on Saturn server %s; possible cause: %s"
% (self.serverDNS, format_exc()))
def get(self, request):
try:
error = StatMaker()
if error != 0:
logger.error('Stat creation returned' + str(error))
raise IOError
config = ConfigReader()
thefile = join(config.get('saturnring', 'iscsiconfigdir'),
config.get('saturnring', 'clustername') + '.xls')
filename = basename(thefile)
response = HttpResponse(FileWrapper(open(thefile)),
content_type=guess_type(thefile)[0])
response['Content-Length'] = getsize(thefile)
response[
'Content-Disposition'] = "attachment; filename=%s" % filename
return response
except:
var = format_exc()
logger.warn("Stat error: %s" % (var, ))
return Response(
strftime('%c') +
": Stat creation error: contact administrator")
appName = wx.GetApp().GetAppName()
assert appName, "No App Name Set"
config = wx.Config(appName)
perspective = config.Read("perspective")
if perspective:
self._mgr.LoadPerspective(perspective)
def Quit(self):
self._mgr.UnInit()
self.Destroy()
class IAPanel(wx.Panel):
def __init__(self, *args, **keys):
wx.Panel.__init__(self, *args, **keys)
self.test1 = wx.TextCtrl(self, wx.ID_ANY, 'Pane 1 - simple text')
if __name__ == "__main__":
#str=os.path.curdir
#new
if os.name == 'posix':
print os.environ['PWD']
print platform.system()
cfg = ConfigReader()
cfg.read("config.xml")
Database.Open(cfg.GetPath(), cfg.GetUsername(), cfg.GetPassword())
# end new
app = MyApp(False)
app.MainLoop()
def setUp(self):
print "Here is where we can set some state"
config = ConfigReader('saturn.ini')
self.saturnringip = config.get('tests', 'saturnringip')
self.saturnringport = config.get('tests', 'saturnringport')
self.iscsiserver = config.get('tests', 'saturniscsiserver')
def MakeTarget(requestDic,owner):
"""
Actual maketarget orchestrator
"""
logger = getLogger(__name__)
clientiqn = requestDic['clientiqn']
serviceName = requestDic['serviceName']
storageSize = requestDic['sizeinGB']
aagroup =''
subnet=''
if 'clumpgroup' not in requestDic:
clumpgroup = "noclump"
else:
clumpgroup = requestDic['clumpgroup']
if 'aagroup' not in requestDic:
aagroup = "random"
else:
aagroup = requestDic['aagroup']
if 'subnet' in requestDic:
subnet = requestDic['subnet']
else:
subnet = "public"
if 'storemedia' in requestDic:
storemedia = requestDic['storemedia']
else:
storemedia = 'randommedia'
if 'provisiontype' in requestDic:
provisiontype = requestDic['provisiontype']
else:
provisiontype = 'any'
logger.info("Provisioner - request received: ClientIQN: %s, Service: %s, Size(GB) %s, AAGroup: %s, Clumpgroup: %s, Subnet: %s, Storemedia: %s, ProvisionType: %s " %(clientiqn, serviceName, str(storageSize), aagroup, clumpgroup, subnet, storemedia, provisiontype))
try:
while 1:
globallock = Lock.objects.get(lockname='allvglock')
if globallock.locked==False:
globallock.locked=True
globallock.save()
break
else:
sleep(0.2)
except: #This is to create the lock the first time
globallock = Lock(lockname='allvglock',locked=True)
globallock.save()
globallock = Lock.objects.get(lockname='allvglock')
try:
chosenVG = VGFilter(storageSize,aagroup,owner,clumpgroup,subnet,storemedia,provisiontype)
except:
logger.error("VGFilter broke")
logger.error(format_exc())
chosenVG = -1
if chosenVG != -1:
chosenVG.is_locked = True
chosenVG.save(update_fields=['is_locked'])
sleep(0.1) #Safety net to make sure the save did complete on the DB
globallock.locked=False
globallock.save()
targetHost = str(chosenVG.vghost)
targetvguuid = str(chosenVG.vguuid)
config = ConfigReader()
numqueues = config.get('saturnring','numqueues')
queuename = 'queue'+str(hash(targetHost)%int(numqueues))
queue = get_queue(queuename)
logger.info("Launching create target job into queue %s" %(queuename,) )
storemedia = chosenVG.storemedia
job = queue.enqueue(ExecMakeTarget,storemedia,targetvguuid,targetHost,clientiqn,serviceName,storageSize,aagroup,clumpgroup,subnet,owner)
while 1:
if job.result or job.is_failed:
chosenVG.is_locked = False
chosenVG.save(update_fields=['is_locked'])
if job.is_failed:
return (-1,"Provisioner failed, check syntax or contact admin")
return job.result
else:
sleep(0.25)
else:
globallock.locked=False
globallock.save()
try:
clientiqnHash = hashlib.sha1(clientiqn).hexdigest()[:8]
targets = Target.objects.filter(iqntar__contains="".join([serviceName,":",clientiqnHash]))
if len(targets) != 0:
for t in targets:
iqnComponents = t.iqntar.split(':')
if ((serviceName==iqnComponents[1]) and (clientiqnHash==iqnComponents[2])):
logger.info('Target already exists for (serviceName=%s,clientiqn=%s) tuple' % (serviceName,clientiqn))
return (1,t.iqntar)
except:
logger.warn("Something went wrong while checking for pre-existing target")
logger.warn('VG filtering did not return a choice')
return (-1, "Are Saturnservers online and adequate, contact admin")
def get_clustername():
try:
config = ConfigReader()
return config.get('saturnring', 'clustername')
except:
return 'undefined'
