def _iaas_nimbus_validate(svc, log):
rc = 0
msg = None
if svc._s.securitygroups:
rc = 1
msg = "The Nimbus IaaS platform does not support security groups as of 2.7"
cloudinitd.log(log, logging.WARN, msg)
return (rc, msg)
def boot_validate(self):
bo = self._bo
connnections = {}
for level in bo.levels:
for s in level.services:
svc = self._boot_top.get_service(s.name)
cb_iaas.iaas_validate(svc, self._log)
hash_str = ""
iaas_url = svc.get_dep("iaas_url")
if iaas_url:
hash_str = hash_str + iaas_url
hash_str = hash_str + "/"
iaas = svc.get_dep("iaas")
if iaas:
hash_str = hash_str + iaas
hash_str = hash_str + "/"
key = svc.get_dep("iaas_key")
if key:
hash_str = hash_str + key
hash_str = hash_str + "/"
secret = svc.get_dep("iaas_secret")
if secret:
hash_str = hash_str + secret
if hash_str not in connnections.keys():
con = cb_iaas.iaas_get_con(svc, key=key, secret=secret, iaasurl=iaas_url)
#con = cb_iaas.iaas_get_con(svc)
connnections[hash_str] = (con, [svc])
else:
(con, svc_list) = connnections[hash_str]
svc_list.append(svc)
exception_list = []
for (con, svc_list) in connnections.values():
try:
con.get_all_instances()
except Exception, ex:
# this means that there is a problem connection with all the associated services
names = ""
d = ""
for svc in svc_list:
exception_list.append((svc, ex,))
names = names + d + svc.name
d = ","
msg = "The following services have problems with their IaaS configuration. Please check the launch plan to verify the iaas configuration is correct. %s || %s" % (names, str(ex))
cloudinitd.log(self._log, logging.ERROR, msg)
def test_logging(self):
cloudinitd.log(logging, logging.DEBUG, "testmessage")
cloudinitd.log(None, logging.DEBUG, "testmessage")
try:
raise Exception("TESTER")
except:
cloudinitd.log(logging, logging.DEBUG, "test stack", traceback)
def __init__(self, db_dir, config_file=None, db_name=None, log_level="warn", logdir=None, level_callback=None, service_callback=None, boot=True, ready=True, terminate=False, continue_on_error=False, fail_if_db_present=False):
"""
db_dir: a path to a directories where databases can be stored.
config_file: the top_level config file describing this boot plan.
if this parameter is given then it is assumed that this
is a new launch plan. if it is not given the db_name
parameter is required and the plan is loaded from an
existing database
db_name: the name of the database. this is not an actual path
to a file, it is the run name given when the plan is
launched. The run name can be found in self.name
level_callback: a callback function that is invoked whenever
a level completes or a new level is started. The signature of the callback is:
def func_name(cloudinitd, action, current_level)
action is a string from the set
["starting", "transition", "complete", "error"]
service callback: a callbackfunciton that is invoked whenever
a service is started, progresses, or finishes. The signature is:
def func_name(cloudservice, action, msg)
action is a string from the set:
["starting", "transition", "complete", "error"]
boot=True: instructs the object to contextualized the service or now
ready=True: instructs the service to run the ready program or not
terminate=False: instructs the service to run the shutdown program or not
fail_if_db_present=False: instructs the constructor that the caller expects DB present already
When this object is configured with a config_file a new sqlite
database is created under @db_dir and a new name is picked for it.
the data base ends up being called <db_dir>/cloudinitd-<name>.db,
but the user has no real need to know this.
The contructor does not actually launch a run. It simply loads up
the database with the information in the config file (in the case
of a new launch) and then builds the inmemory data structures.
"""
if not db_name and not config_file:
raise APIUsageException("Cloud boot must have a db_name or a config file to load")
if not os.path.exists(db_dir):
raise APIUsageException("Path to the db directory does not exist: %s" % (db_dir))
self._level_callback = level_callback
self._service_callback = service_callback
if not db_name:
db_name = str(uuid.uuid4()).split("-")[0]
db_path = "/%s/cloudinitd-%s.db" % (db_dir, db_name)
self._db_path = db_path
if config_file is None:
if not os.path.exists(db_path):
raise APIUsageException("Path to the db does not exist %s. New dbs must be given a config file" % (db_path))
if fail_if_db_present and os.path.exists(db_path):
raise APIUsageException("Already exists: '%s'" % db_path)
(self._log, logfile) = cloudinitd.make_logger(log_level, db_name, logdir=logdir)
self._started = False
self.run_name = db_name
dburl = "sqlite://%s" % (db_path)
self._db = CloudInitDDB(dburl)
os.chmod(db_path, stat.S_IRUSR | stat.S_IWUSR)
if config_file:
self._bo = self._db.load_from_conf(config_file)
else:
self._bo = self._db.load_from_db()
self._levels = []
self._boot_top = BootTopLevel(log=self._log, level_callback=self._mp_cb, service_callback=self._svc_cb, boot=boot, ready=ready, terminate=terminate, continue_on_error=continue_on_error)
for level in self._bo.levels:
level_list = []
for s in level.services:
try:
(s_log, logfile) = cloudinitd.make_logger(log_level, self.run_name, logdir=logdir, servicename=s.name)
svc = self._boot_top.new_service(s, self._db, log=s_log, logfile=logfile, run_name=self.run_name)
# if boot is not set we assume it was already booted and we expand
if not boot:
svc._do_attr_bag()
level_list.append(svc)
except Exception, svcex:
if not continue_on_error:
raise
action = cloudinitd.callback_action_error
msg = "ERROR creating SVC object %s, but continue on error set: %s" % (s.name, str(svcex))
if self._service_callback:
cs = CloudService(self, None, name=s.name)
self._service_callback(self, cs, action, msg)
cloudinitd.log(self._log, logging.ERROR, msg)
self._boot_top.add_level(level_list)
self._levels.append(level_list)
