def __init__(self, uuid, record):
self.__uuid = uuid
# First check this class implements all the correct methods:
for attr_ro in self.getAttrRO() + self.getAttrRW():
if not hasattr(self, "get_%s" % attr_ro):
raise ImplementationError(self.getClass(),"get_%s" % attr_ro)
for attr_rw in self.getAttrRW():
if not hasattr(self, "set_%s" % attr_rw):
raise ImplementationError(self.getClass(),"set_%s" % attr_rw)
for method in self.getMethods():
if not hasattr(self, method):
raise ImplementationError(self.getClass(), method)
for func in self.getFuncs():
if not hasattr(self.__class__, func):
raise ImplementationError(self.getClass(),func)
# Next check that the class is being created with the correct
# parameters
if not isinstance(record, dict):
raise CreateUnspecifiedAttributeError("record" , self.getClass())
for attr_inst in self.getAttrInst():
if attr_inst not in record:
raise CreateUnspecifiedAttributeError(attr_inst, self.getClass())
setattr(self, attr_inst, record[attr_inst])
# Finally register it
MaestroStore.register(uuid, self.getClass(), self)
def __init__(self, uuid, record):
self.__uuid = uuid
# First check this class implements all the correct methods:
for attr_ro in self.getAttrRO() + self.getAttrRW():
if not hasattr(self, "get_%s" % attr_ro):
raise ImplementationError(self.getClass(), "get_%s" % attr_ro)
for attr_rw in self.getAttrRW():
if not hasattr(self, "set_%s" % attr_rw):
raise ImplementationError(self.getClass(), "set_%s" % attr_rw)
for method in self.getMethods():
if not hasattr(self, method):
raise ImplementationError(self.getClass(), method)
for func in self.getFuncs():
if not hasattr(self.__class__, func):
raise ImplementationError(self.getClass(), func)
# Next check that the class is being created with the correct
# parameters
if not isinstance(record, dict):
raise CreateUnspecifiedAttributeError("record", self.getClass())
for attr_inst in self.getAttrInst():
if attr_inst not in record:
raise CreateUnspecifiedAttributeError(attr_inst,
self.getClass())
setattr(self, attr_inst, record[attr_inst])
# Finally register it
MaestroStore.register(uuid, self.getClass(), self)
def start(self):
# Initialize grid services
self.user_service_id = UserService.create({})
self.user_service = store.get(self.user_service_id, "UserService")
self.messaging_service_id = MessagingService.create({})
self.messaging_service = store.get(self.messaging_service_id,
"MessagingService")
self.aperture_service_id = ApertureService.create({})
self.aperture_service = store.get(self.aperture_service_id,
"ApertureService")
#if we should be hosting a grid service, fire that up too
if self.props.hostingResource.flags & ComputeResource.Flags.GridServiceHost == ComputeResource.Flags.GridServiceHost:
self.grid_service_id = GridService.create({})
self.grid_service = store.get(self.grid_service_id, "GridService")
else:
self.grid_service = None
# Initialize regions
for slot in range(self.maxRegionSlots):
if not provision.IsSlotProvisioned(slot):
continue
regionInfo = provision.GetSlotConfiguration(slot)
for region_uuid in regionInfo.keys():
record = regionInfo[region_uuid]
record['slot_number'] = slot
record['master_avatar_uuid'] = User.User.FindByName(
record["master_avatar_first"],
record["master_avatar_last"])
try:
region = Region.recreate(record, region_uuid)
self.region_add(region)
except:
import traceback
exc_type, exc_value, exc_traceback = sys.exc_info()
traceback.print_exception(exc_type, exc_value,
exc_traceback)
pass
self.work_queue = Queue.Queue()
self.queue_runner = threading.Thread(target=self._processQueue,
name="QueueRunner")
self.queue_runner.start()
self.poll_interval = 10.0
self.monitor = threading.Thread(target=self._regionMonitor,
name="RegionMonitor")
self.monitor.start()
def _processQueue(self):
print "QueueRunner Starting"
while True:
try:
objid = self.work_queue.get()
service = None
for classname in [
"ApertureService", "UserService", "MessagingService",
"GridService", "Region"
]:
service = store.get(objid, classname)
if (service != None):
break
if service:
if service.ShouldBeRunning():
service.Start()
time.sleep(
2
) #prevents mono addins problems when services rapid-fire start
else:
print "QueueRunner: Unknown object type queued for service"
except:
import traceback
exc_type, exc_value, exc_traceback = sys.exc_info()
traceback.print_exception(exc_type, exc_value, exc_traceback)
pass
finally:
self.work_queue.task_done()
def _processQueue(self):
print "QueueRunner Starting"
while True:
try:
objid = self.work_queue.get()
service = None
for classname in ["ApertureService", "UserService", "MessagingService", "GridService", "Region"]:
service = store.get(objid, classname)
if (service != None):
break
if service:
if service.ShouldBeRunning():
service.Start()
time.sleep(2) #prevents mono addins problems when services rapid-fire start
else:
print "QueueRunner: Unknown object type queued for service"
except:
import traceback
exc_type, exc_value, exc_traceback = sys.exc_info()
traceback.print_exception(exc_type, exc_value, exc_traceback)
pass
finally:
self.work_queue.task_done()
def AssignEstate(self, estate_uuid):
estate = store.get(estate_uuid, "Estate")
if (estate == None):
ServiceError("AssignEstate: Invalid Estate Reference")
estate.AssignRegion(self.get_sim_uuid())
self.estate = estate
self.estate_id = self.estate.get_estate_id()
def get_by_uuid(cls, uuid):
# Sanity check the uuid is one of us
me = MaestroStore.get(uuid, cls.getClass())
if me is not None and me.getClass() == cls.getClass():
# In OSS, ref == uuid
return uuid
else:
raise "Big Error.. TODO!"
def get_by_uuid(cls, uuid):
# Sanity check the uuid is one of us
me = MaestroStore.get(uuid, cls.getClass())
if me is not None and me.getClass() == cls.getClass():
# In OSS, ref == uuid
return uuid
else:
raise "Big Error.. TODO!"
def instance(cls):
global inst
try:
inst
except:
hostid = RegionHost.create({})
inst = store.get(hostid, RegionHost.getClass())
inst.start()
return inst
def instance(cls):
global inst
try:
inst
except:
hostid = RegionHost.create({})
inst = store.get(hostid, RegionHost.getClass())
inst.start()
return inst
def start(self):
# Initialize grid services
self.user_service_id = UserService.create({})
self.user_service = store.get(self.user_service_id, "UserService")
self.messaging_service_id = MessagingService.create({})
self.messaging_service = store.get(self.messaging_service_id, "MessagingService")
self.aperture_service_id = ApertureService.create({})
self.aperture_service = store.get(self.aperture_service_id, "ApertureService")
#if we should be hosting a grid service, fire that up too
if self.props.hostingResource.flags & ComputeResource.Flags.GridServiceHost == ComputeResource.Flags.GridServiceHost:
self.grid_service_id = GridService.create({})
self.grid_service = store.get(self.grid_service_id, "GridService")
else:
self.grid_service = None
# Initialize regions
for slot in range(self.maxRegionSlots):
if not provision.IsSlotProvisioned(slot):
continue
regionInfo = provision.GetSlotConfiguration(slot)
for region_uuid in regionInfo.keys():
record = regionInfo[region_uuid]
record['slot_number'] = slot
record['master_avatar_uuid'] = User.User.FindByName(record["master_avatar_first"],
record["master_avatar_last"])
try:
region = Region.recreate(record, region_uuid)
self.region_add(region)
except:
import traceback
exc_type, exc_value, exc_traceback = sys.exc_info()
traceback.print_exception(exc_type, exc_value, exc_traceback)
pass
self.work_queue = Queue.Queue()
self.queue_runner = threading.Thread(target=self._processQueue, name="QueueRunner")
self.queue_runner.start()
self.poll_interval = 10.0;
self.monitor = threading.Thread(target=self._regionMonitor, name="RegionMonitor")
self.monitor.start()
def valid_object(class_name):
"""Decorator to verify if object is valid before calling
method.
@param func: function with params: (self, session, pif_ref)
@rtype: callable object
"""
return lambda func: \
lambda *args, **kwargs: \
_check_ref(lambda r: \
MaestroStore.get(r, class_name) is not None,
class_name, func, *args, **kwargs)
def valid_object(class_name):
"""Decorator to verify if object is valid before calling
method.
@param func: function with params: (self, session, pif_ref)
@rtype: callable object
"""
return lambda func: \
lambda *args, **kwargs: \
_check_ref(lambda r: \
MaestroStore.get(r, class_name) is not None,
class_name, func, *args, **kwargs)
def _regionMonitor(self):
print "RegionMonitor Starting"
while True:
try:
if (self.maintenance_mode == True):
continue
if (self.aperture_service.IsRunning() == False
and self.aperture_service.ShouldBeRunning()):
self.work_queue.put(self.aperture_service_id)
if (self.user_service.IsRunning() == False
and self.user_service.ShouldBeRunning()):
self.work_queue.put_nowait(self.user_service_id)
if (self.grid_service != None
and self.grid_service.IsRunning() == False
and self.grid_service.ShouldBeRunning()):
self.work_queue.put_nowait(self.grid_service_id)
if (self.messaging_service.IsRunning() == False
and self.messaging_service.ShouldBeRunning()):
self.work_queue.put_nowait(self.messaging_service_id)
with self.regions_lock:
for region_uuid in self.regions:
region = store.get(region_uuid, "Region")
regionEntry = self.props.hostingResource.findHostedRegionByUUID(
region_uuid)
if region == None or regionEntry == None:
continue
if regionEntry.state != RegionState.DeployedRunning:
continue
if (region.IsRunning() == False):
self.work_queue.put(region_uuid)
except:
import traceback
exc_type, exc_value, exc_traceback = sys.exc_info()
traceback.print_exception(exc_type, exc_value, exc_traceback)
pass
finally:
time.sleep(self.poll_interval)
def UpdateRegionToLatest(self, region_uuid):
""" Update the region to the latest revision. """
region = store.get(region_uuid, Region.getClass())
if (region == None):
raise ServiceError("Invalid Region Specified")
if (region.IsRunning()):
raise ServiceError("Cannot update a running region.")
try:
target = region.get_slot_directory()
gridshare_path = self.props.getValue("gridshare_path")
(username, password) = self.props.getGridShareCredentials()
ConnectUNCShare(gridshare_path, username, password)
return (provision.ProvisionFromLatest(gridshare_path, target))
except:
import traceback
exc_type, exc_value, exc_traceback = sys.exc_info()
traceback.print_exception(exc_type, exc_value, exc_traceback)
raise ServiceError(exc_value)
def UpdateRegionToLatest(self, region_uuid):
""" Update the region to the latest revision. """
region = store.get(region_uuid, Region.getClass())
if (region == None):
raise ServiceError("Invalid Region Specified")
if (region.IsRunning()):
raise ServiceError("Cannot update a running region.")
try:
target = region.get_slot_directory()
gridshare_path = self.props.getValue("gridshare_path")
(username, password) = self.props.getGridShareCredentials()
ConnectUNCShare(gridshare_path, username, password)
return (provision.ProvisionFromLatest(gridshare_path, target))
except:
import traceback
exc_type, exc_value, exc_traceback = sys.exc_info()
traceback.print_exception(exc_type, exc_value, exc_traceback)
raise ServiceError(exc_value)
def _regionMonitor(self):
print "RegionMonitor Starting"
while True:
try:
if (self.maintenance_mode == True):
continue
if (self.aperture_service.IsRunning() == False and self.aperture_service.ShouldBeRunning()):
self.work_queue.put(self.aperture_service_id)
if (self.user_service.IsRunning() == False and self.user_service.ShouldBeRunning()):
self.work_queue.put_nowait(self.user_service_id)
if (self.grid_service != None and self.grid_service.IsRunning() == False and self.grid_service.ShouldBeRunning()):
self.work_queue.put_nowait(self.grid_service_id)
if (self.messaging_service.IsRunning() == False and self.messaging_service.ShouldBeRunning()):
self.work_queue.put_nowait(self.messaging_service_id)
with self.regions_lock:
for region_uuid in self.regions:
region = store.get(region_uuid, "Region")
regionEntry = self.props.hostingResource.findHostedRegionByUUID(region_uuid)
if region == None or regionEntry == None:
continue
if regionEntry.state != RegionState.DeployedRunning:
continue
if (region.IsRunning() == False):
self.work_queue.put(region_uuid)
except:
import traceback
exc_type, exc_value, exc_traceback = sys.exc_info()
traceback.print_exception(exc_type, exc_value, exc_traceback)
pass
finally:
time.sleep(self.poll_interval)
def syncOwnerInfoToMasterAvatarId(self):
self.owner_uuid = User.FindByUserID(self.master_avatar_uuid)
self.owner = store.get(self.owner_uuid, 'User')
self.master_avatar_first = self.owner.get_first_name()
self.master_avatar_last = self.owner.get_last_name()
def get_all(cls):
return MaestroStore.get_all_uuid(cls.getClass())
def destroy(self):
MaestroStore.deregister(self.get_uuid(), self.getClass())
def get_all_records(cls):
return dict([(inst.get_uuid(), inst.get_record())
for inst in MaestroStore.get_all(cls.getClass())])
def get_all_records(cls):
return dict([(inst.get_uuid(), inst.get_record())
for inst in MaestroStore.get_all(cls.getClass())])
def getter(ref, type):
return MaestroStore.get(ref, type)
def FindByEstateID(cls, estate_id):
# First Look in active Estates
for instance in store.get_all("Estate"):
if (instance.get_estate_id() == estate_id):
return (instance.get_uuid())
return (cls.recreate({'estate_id': estate_id}, genuuid.createString()))
def ReconfigureRegion(self, region_uuid):
""" Retrieves the most up to date configuration templates, and regenerates
configuration files. The region must be down for this to succeed. """
region = store.get(region_uuid, Region.getClass())
if (region == None):
raise ServiceError("Invalid Region Specified")
if (region.IsRunning()):
raise ServiceError("Cannot reconfigure a running region.")
region_record = region.get_record()
slotnum = region.get_slot_number()
regionBaseDir = os.path.join(region.get_slot_directory(), "bin")
regionConfigDir = os.path.join(region.get_slot_directory(), "bin",
"Regions")
try:
os.makedirs(regionConfigDir)
except OSError as exc:
if exc.errno == errno.EEXIST and os.path.isdir(regionConfigDir):
pass
else:
raise ServiceError(
"Region destination directory doesn't exist")
dbconfig = self.props.getCoreDbConfig()
region_uuid = region.get_sim_uuid()
rdbHost = GetRdbHost(dbconfig, region_uuid)
if (rdbHost == None):
# no info? that's ok in this case we assign
print "RDB server not assigned for {0}, assigning new slot".format(
region_uuid)
rdbHost = AssignBestRdbHost(dbconfig, region_uuid)
if ((not 'http_listener_port' in region_record)
or (region_record['http_listener_port'] == "{REQUIRE}")):
region_record['http_listener_port'] = str(
self.props.getInteger('starting_http_port') + slotnum)
if ((not 'internal_ip_port' in region_record)
or (region_record['internal_ip_port'] == "{REQUIRE}")):
region_record['internal_ip_port'] = str(
self.props.getInteger('starting_udp_port') + slotnum)
if ((not 'rdb_host' in region_record)
or (region_record['rdb_host'] == "{REQUIRE}")):
region_record['rdb_host'] = rdbHost
# Check for REQUIRE items and do the replacements if needed
keys = dict(self.props.getItems(vars=region_record))
# Map the source drive and figure out if its on GridShare
regionConfigName = region.get_name_label() + ".xml"
(username, password) = self.props.getGridShareCredentials()
templateBaseDir = self.props.getValue("template_basedir")
try:
ConnectUNCShare(templateBaseDir, username, password)
""" Read in Region Config Settings """
keys = provision.GetConfiguration(templateBaseDir,
"simulation.config",
"simulation", keys)
""" Update the Region Configuration First """
provision.ReconfigureRegion(templateBaseDir, regionConfigDir,
regionConfigName, keys)
""" Now do the Simulator Configuration Files """
provision.ReconfigureSimulator(templateBaseDir, regionBaseDir,
keys)
""" Done"""
return True
except Exception, e:
raise ServiceError("Reconfiguration failed: " + str(e))
def destroy(self):
MaestroStore.deregister(self.get_uuid(), self.getClass())
def FindByUserID(cls, user_id):
# First Look in active Estates
for instance in store.get_all("User"):
if (instance.get_user_id() == user_id):
return (instance.get_uuid())
return (cls.recreate({'user_id': user_id}, user_id))
def FindByEstateID(cls, estate_id):
# First Look in active Estates
for instance in store.get_all("Estate"):
if (instance.get_estate_id() == estate_id):
return (instance.get_uuid())
return (cls.recreate({'estate_id' : estate_id}, genuuid.createString()))
def get_all(cls):
return MaestroStore.get_all_uuid(cls.getClass())
def syncEstateInfoToEstateId(self):
estate_uuid = Estate.FindByEstateID(self.estate_id)
self.estate = store.get(estate_uuid, 'Estate')
def getter(ref, type):
return MaestroStore.get(ref, type)
def ReconfigureRegion(self, region_uuid):
""" Retrieves the most up to date configuration templates, and regenerates
configuration files. The region must be down for this to succeed. """
region = store.get(region_uuid, Region.getClass())
if (region == None):
raise ServiceError("Invalid Region Specified")
if (region.IsRunning()):
raise ServiceError("Cannot reconfigure a running region.")
region_record = region.get_record()
slotnum = region.get_slot_number()
regionBaseDir = os.path.join(region.get_slot_directory(), "bin")
regionConfigDir = os.path.join(region.get_slot_directory(), "bin", "Regions")
try:
os.makedirs(regionConfigDir)
except OSError as exc:
if exc.errno == errno.EEXIST and os.path.isdir(regionConfigDir):
pass
else:
raise ServiceError("Region destination directory doesn't exist")
dbconfig = self.props.getCoreDbConfig()
region_uuid = region.get_sim_uuid()
rdbHost = GetRdbHost(dbconfig, region_uuid)
if (rdbHost == None):
# no info? that's ok in this case we assign
print "RDB server not assigned for {0}, assigning new slot".format(region_uuid)
rdbHost = AssignBestRdbHost(dbconfig, region_uuid)
if ((not 'http_listener_port' in region_record) or (region_record['http_listener_port'] == "{REQUIRE}")):
region_record['http_listener_port'] = str(self.props.getInteger('starting_http_port') + slotnum)
if ((not 'internal_ip_port' in region_record) or (region_record['internal_ip_port'] == "{REQUIRE}")):
region_record['internal_ip_port'] = str(self.props.getInteger('starting_udp_port') + slotnum)
if ((not 'rdb_host' in region_record) or (region_record['rdb_host'] == "{REQUIRE}")):
region_record['rdb_host'] = rdbHost
# Check for REQUIRE items and do the replacements if needed
keys = dict(self.props.getItems(vars=region_record))
# Map the source drive and figure out if its on GridShare
regionConfigName = region.get_name_label() + ".xml"
(username, password) = self.props.getGridShareCredentials()
templateBaseDir = self.props.getValue("template_basedir")
try:
ConnectUNCShare(templateBaseDir, username, password)
""" Read in Region Config Settings """
keys = provision.GetConfiguration(templateBaseDir, "simulation.config", "simulation", keys)
""" Update the Region Configuration First """
provision.ReconfigureRegion(templateBaseDir, regionConfigDir, regionConfigName, keys)
""" Now do the Simulator Configuration Files """
provision.ReconfigureSimulator(templateBaseDir, regionBaseDir, keys)
""" Done"""
return True
except Exception, e:
raise ServiceError("Reconfiguration failed: " + str(e))
def FindByUserID(cls, user_id):
# First Look in active Estates
for instance in store.get_all("User"):
if (instance.get_user_id() == user_id):
return (instance.get_uuid())
return (cls.recreate({'user_id' : user_id}, user_id))