summaryrefslogtreecommitdiff
path: root/cloudinit/__init__.py
diff options
context:
space:
mode:
Diffstat (limited to 'cloudinit/__init__.py')
-rw-r--r--cloudinit/__init__.py296
1 files changed, 166 insertions, 130 deletions
diff --git a/cloudinit/__init__.py b/cloudinit/__init__.py
index d74a0f1f..0bf2da02 100644
--- a/cloudinit/__init__.py
+++ b/cloudinit/__init__.py
@@ -26,34 +26,33 @@ seeddir = varlibdir + "/seed"
cfg_env_name = "CLOUD_CFG"
cfg_builtin = """
-log_cfgs: [ ]
-datasource_list: [ "NoCloud", "OVF", "Ec2" ]
+log_cfgs: []
+datasource_list: ["NoCloud", "OVF", "Ec2"]
def_log_file: /var/log/cloud-init.log
syslog_fix_perms: syslog:adm
"""
logger_name = "cloudinit"
pathmap = {
- "handlers" : "/handlers",
- "scripts" : "/scripts",
- "sem" : "/sem",
- "boothooks" : "/boothooks",
- "userdata_raw" : "/user-data.txt",
- "userdata" : "/user-data.txt.i",
- "obj_pkl" : "/obj.pkl",
- "cloud_config" : "/cloud-config.txt",
- "data" : "/data",
- None : "",
+ "handlers": "/handlers",
+ "scripts": "/scripts",
+ "sem": "/sem",
+ "boothooks": "/boothooks",
+ "userdata_raw": "/user-data.txt",
+ "userdata": "/user-data.txt.i",
+ "obj_pkl": "/obj.pkl",
+ "cloud_config": "/cloud-config.txt",
+ "data": "/data",
+ None: "",
}
-per_instance="once-per-instance"
-per_always="always"
-per_once="once"
+per_instance = "once-per-instance"
+per_always = "always"
+per_once = "once"
-parsed_cfgs = { }
+parsed_cfgs = {}
import os
-from configobj import ConfigObj
import cPickle
import sys
@@ -62,32 +61,38 @@ import errno
import pwd
import subprocess
import yaml
-import util
import logging
import logging.config
import StringIO
import glob
import traceback
+import cloudinit.util as util
+
+
class NullHandler(logging.Handler):
- def emit(self,record): pass
+ def emit(self, record):
+ pass
+
log = logging.getLogger(logger_name)
log.addHandler(NullHandler())
+
def logging_set_from_cfg_file(cfg_file=system_config):
- logging_set_from_cfg(util.get_base_cfg(cfg_file,cfg_builtin,parsed_cfgs))
+ logging_set_from_cfg(util.get_base_cfg(cfg_file, cfg_builtin, parsed_cfgs))
+
def logging_set_from_cfg(cfg):
log_cfgs = []
- logcfg=util.get_cfg_option_str(cfg, "log_cfg", False)
+ logcfg = util.get_cfg_option_str(cfg, "log_cfg", False)
if logcfg:
# if there is a 'logcfg' entry in the config, respect
# it, it is the old keyname
- log_cfgs = [ logcfg ]
+ log_cfgs = [logcfg]
elif "log_cfgs" in cfg:
for cfg in cfg['log_cfgs']:
- if isinstance(cfg,list):
+ if isinstance(cfg, list):
log_cfgs.append('\n'.join(cfg))
else:
log_cfgs.append()
@@ -106,39 +111,40 @@ def logging_set_from_cfg(cfg):
raise Exception("no valid logging found\n")
-import DataSource
-import UserDataHandler
+import cloudinit.DataSource as DataSource
+import cloudinit.UserDataHandler as UserDataHandler
+
class CloudInit:
cfg = None
- part_handlers = { }
+ part_handlers = {}
old_conffile = '/etc/ec2-init/ec2-config.cfg'
- ds_deps = [ DataSource.DEP_FILESYSTEM, DataSource.DEP_NETWORK ]
+ ds_deps = [DataSource.DEP_FILESYSTEM, DataSource.DEP_NETWORK]
datasource = None
cloud_config_str = ''
datasource_name = ''
- builtin_handlers = [ ]
+ builtin_handlers = []
- def __init__(self, ds_deps = None, sysconfig=system_config):
+ def __init__(self, ds_deps=None, sysconfig=system_config):
self.builtin_handlers = [
- [ 'text/x-shellscript', self.handle_user_script, per_always ],
- [ 'text/cloud-config', self.handle_cloud_config, per_always ],
- [ 'text/upstart-job', self.handle_upstart_job, per_instance ],
- [ 'text/cloud-boothook', self.handle_cloud_boothook, per_always ],
+ ['text/x-shellscript', self.handle_user_script, per_always],
+ ['text/cloud-config', self.handle_cloud_config, per_always],
+ ['text/upstart-job', self.handle_upstart_job, per_instance],
+ ['text/cloud-boothook', self.handle_cloud_boothook, per_always],
]
if ds_deps != None:
self.ds_deps = ds_deps
- self.sysconfig=sysconfig
- self.cfg=self.read_cfg()
+ self.sysconfig = sysconfig
+ self.cfg = self.read_cfg()
def read_cfg(self):
if self.cfg:
return(self.cfg)
try:
- conf = util.get_base_cfg(self.sysconfig,cfg_builtin, parsed_cfgs)
+ conf = util.get_base_cfg(self.sysconfig, cfg_builtin, parsed_cfgs)
except Exception:
conf = get_builtin_cfg()
@@ -147,8 +153,9 @@ class CloudInit:
try:
from configobj import ConfigObj
oldcfg = ConfigObj(self.old_conffile)
- if oldcfg is None: oldcfg = { }
- conf = util.mergedict(conf,oldcfg)
+ if oldcfg is None:
+ oldcfg = {}
+ conf = util.mergedict(conf, oldcfg)
except:
pass
@@ -160,7 +167,7 @@ class CloudInit:
# by using the instance link, if purge_cache was called
# the file wont exist
cache = get_ipath_cur('obj_pkl')
- f=open(cache, "rb")
+ f = open(cache, "rb")
data = cPickle.load(f)
f.close()
self.datasource = data
@@ -175,23 +182,24 @@ class CloudInit:
except OSError as e:
if e.errno != errno.EEXIST:
return False
-
+
try:
- f=open(cache, "wb")
- cPickle.dump(self.datasource,f)
+ f = open(cache, "wb")
+ cPickle.dump(self.datasource, f)
f.close()
- os.chmod(cache,0400)
+ os.chmod(cache, 0400)
except:
raise
-
+
def get_data_source(self):
- if self.datasource is not None: return True
+ if self.datasource is not None:
+ return True
if self.restore_from_cache():
log.debug("restored from cache type %s" % self.datasource)
return True
- cfglist=self.cfg['datasource_list']
+ cfglist = self.cfg['datasource_list']
dslist = list_sources(cfglist, self.ds_deps)
dsnames = [f.__name__ for f in dslist]
@@ -206,7 +214,7 @@ class CloudInit:
log.debug("found data source %s" % ds)
return True
except Exception as e:
- log.warn("get_data of %s raised %s" % (ds,e))
+ log.warn("get_data of %s raised %s" % (ds, e))
util.logexc(log)
msg = "Did not find data source. searched classes: %s" % dsnames
log.debug(msg)
@@ -216,18 +224,19 @@ class CloudInit:
try:
os.unlink(cur_instance_link)
except OSError as e:
- if e.errno != errno.ENOENT: raise
+ if e.errno != errno.ENOENT:
+ raise
iid = self.get_instance_id()
os.symlink("./instances/%s" % iid, cur_instance_link)
idir = self.get_ipath()
dlist = []
- for d in [ "handlers", "scripts", "sem" ]:
+ for d in ["handlers", "scripts", "sem"]:
dlist.append("%s/%s" % (idir, d))
-
+
util.ensure_dirs(dlist)
- ds = "%s: %s\n" % ( self.datasource.__class__, str(self.datasource) )
+ ds = "%s: %s\n" % (self.datasource.__class__, str(self.datasource))
dp = self.get_cpath('data')
util.write_file("%s/%s" % (idir, 'datasource'), ds)
util.write_file("%s/%s" % (dp, 'previous-datasource'), ds)
@@ -252,68 +261,69 @@ class CloudInit:
util.write_file(self.get_ipath('userdata'),
self.datasource.get_userdata(), 0600)
- def sem_getpath(self,name,freq):
+ def sem_getpath(self, name, freq):
if freq == 'once-per-instance':
- return("%s/%s" % (self.get_ipath("sem"),name))
+ return("%s/%s" % (self.get_ipath("sem"), name))
return("%s/%s.%s" % (get_cpath("sem"), name, freq))
-
- def sem_has_run(self,name,freq):
- if freq == per_always: return False
- semfile = self.sem_getpath(name,freq)
+
+ def sem_has_run(self, name, freq):
+ if freq == per_always:
+ return False
+ semfile = self.sem_getpath(name, freq)
if os.path.exists(semfile):
return True
return False
-
- def sem_acquire(self,name,freq):
+
+ def sem_acquire(self, name, freq):
from time import time
- semfile = self.sem_getpath(name,freq)
-
+ semfile = self.sem_getpath(name, freq)
+
try:
os.makedirs(os.path.dirname(semfile))
except OSError as e:
if e.errno != errno.EEXIST:
raise e
-
+
if os.path.exists(semfile) and freq != per_always:
return False
-
+
# race condition
try:
- f = open(semfile,"w")
+ f = open(semfile, "w")
f.write("%s\n" % str(time()))
f.close()
except:
return(False)
return(True)
-
- def sem_clear(self,name,freq):
- semfile = self.sem_getpath(name,freq)
+
+ def sem_clear(self, name, freq):
+ semfile = self.sem_getpath(name, freq)
try:
os.unlink(semfile)
except OSError as e:
if e.errno != errno.ENOENT:
return False
-
+
return True
# acquire lock on 'name' for given 'freq'
# if that does not exist, then call 'func' with given 'args'
# if 'clear_on_fail' is True and func throws an exception
# then remove the lock (so it would run again)
- def sem_and_run(self,semname,freq,func,args=None,clear_on_fail=False):
+ def sem_and_run(self, semname, freq, func, args=None, clear_on_fail=False):
if args is None:
args = []
- if self.sem_has_run(semname,freq):
+ if self.sem_has_run(semname, freq):
log.debug("%s already ran %s", semname, freq)
return False
try:
- if not self.sem_acquire(semname,freq):
+ if not self.sem_acquire(semname, freq):
raise Exception("Failed to acquire lock on %s" % semname)
func(*args)
except:
if clear_on_fail:
- self.sem_clear(semname,freq)
+ self.sem_clear(semname, freq)
raise
return True
@@ -321,8 +331,8 @@ class CloudInit:
# get_ipath : get the instance path for a name in pathmap
# (/var/lib/cloud/instances/<instance>/name)<name>)
def get_ipath(self, name=None):
- return("%s/instances/%s%s"
- % (varlibdir,self.get_instance_id(), pathmap[name]))
+ return("%s/instances/%s%s"
+ % (varlibdir, self.get_instance_id(), pathmap[name]))
def consume_userdata(self, frequency=per_instance):
self.get_userdata()
@@ -333,18 +343,20 @@ class CloudInit:
# add the path to the plugins dir to the top of our list for import
# instance dir should be read before cloud-dir
- sys.path.insert(0,cdir)
- sys.path.insert(0,idir)
+ sys.path.insert(0, cdir)
+ sys.path.insert(0, idir)
- part_handlers = { }
+ part_handlers = {}
# add handlers in cdir
for fname in glob.glob("%s/*.py" % cdir):
- if not os.path.isfile(fname): continue
+ if not os.path.isfile(fname):
+ continue
modname = os.path.basename(fname)[0:-3]
try:
mod = __import__(modname)
handler_register(mod, part_handlers, data, frequency)
- log.debug("added handler for [%s] from %s" % (mod.list_types(), fname))
+ log.debug("added handler for [%s] from %s" % (mod.list_types(),
+ fname))
except:
log.warn("failed to initialize handler in %s" % fname)
util.logexc(log)
@@ -357,44 +369,46 @@ class CloudInit:
part_handlers, data, frequency)
# walk the data
- pdata = { 'handlers': part_handlers, 'handlerdir': idir,
- 'data' : data, 'frequency': frequency }
+ pdata = {'handlers': part_handlers, 'handlerdir': idir,
+ 'data': data, 'frequency': frequency}
UserDataHandler.walk_userdata(self.get_userdata(),
- partwalker_callback, data = pdata)
+ partwalker_callback, data=pdata)
# give callbacks opportunity to finalize
- called = [ ]
+ called = []
for (_mtype, mod) in part_handlers.iteritems():
if mod in called:
continue
handler_call_end(mod, data, frequency)
- def handle_user_script(self,_data,ctype,filename,payload, _frequency):
- if ctype == "__end__": return
+ def handle_user_script(self, _data, ctype, filename, payload, _frequency):
+ if ctype == "__end__":
+ return
if ctype == "__begin__":
# maybe delete existing things here
return
- filename=filename.replace(os.sep,'_')
+ filename = filename.replace(os.sep, '_')
scriptsdir = get_ipath_cur('scripts')
- util.write_file("%s/%s" %
- (scriptsdir,filename), util.dos2unix(payload), 0700)
+ util.write_file("%s/%s" %
+ (scriptsdir, filename), util.dos2unix(payload), 0700)
- def handle_upstart_job(self,_data,ctype,filename,payload, frequency):
+ def handle_upstart_job(self, _data, ctype, filename, payload, frequency):
# upstart jobs are only written on the first boot
if frequency != per_instance:
return
- if ctype == "__end__" or ctype == "__begin__": return
+ if ctype == "__end__" or ctype == "__begin__":
+ return
if not filename.endswith(".conf"):
- filename=filename+".conf"
+ filename = filename + ".conf"
- util.write_file("%s/%s" % ("/etc/init",filename),
+ util.write_file("%s/%s" % ("/etc/init", filename),
util.dos2unix(payload), 0644)
- def handle_cloud_config(self,_data,ctype,filename,payload, _frequency):
+ def handle_cloud_config(self, _data, ctype, filename, payload, _frequency):
if ctype == "__begin__":
- self.cloud_config_str=""
+ self.cloud_config_str = ""
return
if ctype == "__end__":
cloud_config = self.get_ipath("cloud_config")
@@ -405,37 +419,40 @@ class CloudInit:
## as CloudConfig does that also, merging it with this cfg
##
# ccfg = yaml.load(self.cloud_config_str)
- # if ccfg is None: ccfg = { }
+ # if ccfg is None: ccfg = {}
# self.cfg = util.mergedict(ccfg, self.cfg)
return
- self.cloud_config_str+="\n#%s\n%s" % (filename,payload)
+ self.cloud_config_str += "\n#%s\n%s" % (filename, payload)
- def handle_cloud_boothook(self,_data,ctype,filename,payload, _frequency):
- if ctype == "__end__": return
- if ctype == "__begin__": return
+ def handle_cloud_boothook(self, _data, ctype, filename, payload,
+ _frequency):
+ if ctype == "__end__":
+ return
+ if ctype == "__begin__":
+ return
- filename=filename.replace(os.sep,'_')
+ filename = filename.replace(os.sep, '_')
payload = util.dos2unix(payload)
- prefix="#cloud-boothook"
+ prefix = "#cloud-boothook"
start = 0
if payload.startswith(prefix):
start = len(prefix) + 1
-
+
boothooks_dir = self.get_ipath("boothooks")
- filepath = "%s/%s" % (boothooks_dir,filename)
+ filepath = "%s/%s" % (boothooks_dir, filename)
util.write_file(filepath, payload[start:], 0700)
try:
- env=os.environ.copy()
- env['INSTANCE_ID']= self.datasource.get_instance_id()
+ env = os.environ.copy()
+ env['INSTANCE_ID'] = self.datasource.get_instance_id()
subprocess.check_call([filepath], env=env)
except subprocess.CalledProcessError as e:
log.error("boothooks script %s returned %i" %
- (filepath,e.returncode))
+ (filepath, e.returncode))
except Exception as e:
log.error("boothooks unknown exception %s when running %s" %
- (e,filepath))
+ (e, filepath))
def get_public_ssh_keys(self):
return(self.datasource.get_public_ssh_keys())
@@ -449,71 +466,84 @@ class CloudInit:
def get_hostname(self, fqdn=False):
return(self.datasource.get_hostname(fqdn=fqdn))
- def device_name_to_device(self,name):
+ def device_name_to_device(self, name):
return(self.datasource.device_name_to_device(name))
# I really don't know if this should be here or not, but
# I needed it in cc_update_hostname, where that code had a valid 'cloud'
# reference, but did not have a cloudinit handle
# (ie, no cloudinit.get_cpath())
- def get_cpath(self,name=None):
+ def get_cpath(self, name=None):
return(get_cpath(name))
def initfs():
- subds = [ 'scripts/per-instance', 'scripts/per-once', 'scripts/per-boot',
- 'seed', 'instances', 'handlers', 'sem', 'data' ]
- dlist = [ ]
+ subds = ['scripts/per-instance', 'scripts/per-once', 'scripts/per-boot',
+ 'seed', 'instances', 'handlers', 'sem', 'data']
+ dlist = []
for subd in subds:
dlist.append("%s/%s" % (varlibdir, subd))
util.ensure_dirs(dlist)
- cfg = util.get_base_cfg(system_config,cfg_builtin,parsed_cfgs)
+ cfg = util.get_base_cfg(system_config, cfg_builtin, parsed_cfgs)
log_file = util.get_cfg_option_str(cfg, 'def_log_file', None)
perms = util.get_cfg_option_str(cfg, 'syslog_fix_perms', None)
if log_file:
- fp = open(log_file,"ab")
+ fp = open(log_file, "ab")
fp.close()
if log_file and perms:
- (u,g) = perms.split(':',1)
- if u == "-1" or u == "None": u = None
- if g == "-1" or g == "None": g = None
+ (u, g) = perms.split(':', 1)
+ if u == "-1" or u == "None":
+ u = None
+ if g == "-1" or g == "None":
+ g = None
util.chownbyname(log_file, u, g)
+
def purge_cache(rmcur=True):
- rmlist = [ boot_finished ]
- if rmcur: rmlist.append(cur_instance_link)
+ rmlist = [boot_finished]
+ if rmcur:
+ rmlist.append(cur_instance_link)
for f in rmlist:
try:
os.unlink(f)
except OSError as e:
- if e.errno == errno.ENOENT: continue
+ if e.errno == errno.ENOENT:
+ continue
return(False)
except:
return(False)
return(True)
+
# get_ipath_cur: get the current instance path for an item
def get_ipath_cur(name=None):
return("%s/%s%s" % (varlibdir, "instance", pathmap[name]))
+
# get_cpath : get the "clouddir" (/var/lib/cloud/<name>)
# for a name in dirmap
def get_cpath(name=None):
return("%s%s" % (varlibdir, pathmap[name]))
+
def get_base_cfg(cfg_path=None):
- if cfg_path is None: cfg_path = system_config
- return(util.get_base_cfg(cfg_path,cfg_builtin,parsed_cfgs))
+ if cfg_path is None:
+ cfg_path = system_config
+ return(util.get_base_cfg(cfg_path, cfg_builtin, parsed_cfgs))
+
def get_builtin_cfg():
return(yaml.load(cfg_builtin))
+
class DataSourceNotFoundException(Exception):
pass
+
def list_sources(cfg_list, depends):
- return(DataSource.list_sources(cfg_list,depends, ["cloudinit", "" ]))
+ return(DataSource.list_sources(cfg_list, depends, ["cloudinit", ""]))
+
def handler_register(mod, part_handlers, data, frequency=per_instance):
if not hasattr(mod, "handler_version"):
@@ -525,27 +555,30 @@ def handler_register(mod, part_handlers, data, frequency=per_instance):
handler_call_begin(mod, data, frequency)
return(mod)
+
def handler_call_begin(mod, data, frequency):
handler_handle_part(mod, data, "__begin__", None, None, frequency)
+
def handler_call_end(mod, data, frequency):
handler_handle_part(mod, data, "__end__", None, None, frequency)
+
def handler_handle_part(mod, data, ctype, filename, payload, frequency):
# only add the handler if the module should run
modfreq = getattr(mod, "frequency", per_instance)
- if not ( modfreq == per_always or
- ( frequency == per_instance and modfreq == per_instance)):
+ if not (modfreq == per_always or
+ (frequency == per_instance and modfreq == per_instance)):
return
if mod.handler_version == 1:
mod.handle_part(data, ctype, filename, payload)
else:
mod.handle_part(data, ctype, filename, payload, frequency)
-def partwalker_handle_handler(pdata, _ctype, _filename, payload):
+def partwalker_handle_handler(pdata, _ctype, _filename, payload):
curcount = pdata['handlercount']
- modname = 'part-handler-%03d' % curcount
+ modname = 'part-handler-%03d' % curcount
frequency = pdata['frequency']
modfname = modname + ".py"
@@ -561,6 +594,7 @@ def partwalker_handle_handler(pdata, _ctype, _filename, payload):
traceback.print_exc(file=sys.stderr)
return
+
def partwalker_callback(pdata, ctype, filename, payload):
# data here is the part_handlers array and then the data to pass through
if ctype == "text/part-handler":
@@ -573,18 +607,20 @@ def partwalker_callback(pdata, ctype, filename, payload):
handler_handle_part(pdata['handlers'][ctype], pdata['data'],
ctype, filename, payload, pdata['frequency'])
+
class InternalPartHandler:
freq = per_instance
- mtypes = [ ]
+ mtypes = []
handler_version = 1
handler = None
- def __init__(self, handler, mtypes, frequency, version = 2):
+
+ def __init__(self, handler, mtypes, frequency, version=2):
self.handler = handler
self.mtypes = mtypes
self.frequency = frequency
self.handler_version = version
- def __repr__():
+ def __repr__(self):
return("InternalPartHandler: [%s]" % self.mtypes)
def list_types(self):
generated by cgit v1.2.3 (git 2.39.1) at 2025-11-27 10:15:38 +0000