def __init__(self, json_entity, args):
super(ContrailAnsiblePlaybooks, self).__init__()
try:
self.logger = ServerMgrlogger()
except:
f = open("/var/log/contrail-server-manager/debug.log", "a")
f.write("Ansible Callback Init - ServerMgrlogger init failed\n")
f.close()
#Initialize common stuff
self.json_entity = json_entity
self.args = args
self.hosts_in_inv = json_entity[0]["hosts_in_inv"]
if "kolla_inv" in json_entity[0]["parameters"]:
self.hosts_in_kolla_inv = \
SMAnsibleUtils(self.logger).hosts_in_kolla_inventory(\
json_entity[0]['parameters']['kolla_inv'])
self.tasks = re.split(r'[,\ ]+', json_entity[0]["tasks"])
#Initialize vars required for Ansible Playbook APIs
self.options = None
self.extra_vars = None
self.pbook_path = None
self.var_mgr = None
self.inventory = None
self.pb_executor = None
def run(self):
#create the logger
try:
self._smgr_log = ServerMgrlogger()
except:
print "Error Creating logger object"
# Connect to the cluster-servers database
try:
self._status_serverDb = db(
self._smgr_main._args.server_manager_base_dir +
self._smgr_main._args.database_name)
except:
self._smgr_log.log(
self._smgr_log.DEBUG,
"Error Connecting to Server Database %s" %
(self._smgr_main._args.server_manager_base_dir +
self._smgr_main._args.database_name))
exit()
#set the status related handlers
status_bottle_app = Bottle()
status_bottle_app.route('/server_status', 'POST',
self.put_server_status)
status_bottle_app.route('/server_status', 'PUT',
self.put_server_status)
self._base_obj = self._status_thread_config['base_obj']
try:
bottle.run(status_bottle_app,
host=self._status_thread_config['listen_ip'],
port=self._status_thread_config['listen_port'])
except Exception as e:
# cleanup gracefully
exit()
def __init__(self, serverdb=None, log_file=None):
if serverdb:
self._serverDb = serverdb
else:
self._serverDb = db(DEF_SERVER_DB_LOCATION)
self._smgr_log = ServerMgrlogger()
def __init__(self, vm_params):
global _smgr_log
_smgr_log = ServerMgrlogger()
_smgr_log.log(_smgr_log.DEBUG, "ContrailVM Init")
self.vm = vm_params['vm']
self.vmdk = vm_params['vmdk']
self.datastore = vm_params['datastore']
self.eth0_mac = vm_params['eth0_mac']
self.eth0_ip = vm_params['eth0_ip']
self.eth0_pg = vm_params['eth0_pg']
self.eth0_vswitch = vm_params['eth0_vswitch']
self.eth0_vlan = vm_params['eth0_vlan']
self.eth1_vswitch = vm_params['eth1_vswitch']
self.eth1_pg = vm_params['eth1_pg']
self.eth1_vlan = vm_params['eth1_vlan']
self.uplink_nic = vm_params['uplink_nic']
self.uplink_vswitch = vm_params['uplink_vswitch']
self.server = vm_params['server']
self.username = vm_params['username']
self.password = vm_params['password']
self.thindisk = vm_params['thindisk']
self.vm_domain = vm_params['domain']
self.vm_id = 0
self.smgr_ip = vm_params['smgr_ip']
self.vm_server = vm_params['vm_server']
self.vm_password = vm_params['vm_password']
self.vm_deb = vm_params['vm_deb']
self._create_networking()
print self._create_vm()
print self._install_contrailvm_pkg(self.eth0_ip, "root", self.vm_password, self.vm_domain, self.vm_server,
self.vm_deb, self.smgr_ip)
def __init__(self, base_dir=_DEF_BASE_DIR,
ip_address=_DEF_COBBLER_IP,
port=_DEF_COBBLER_PORT,
username=_DEF_USERNAME,
password=_DEF_PASSWORD):
self._smgr_log = ServerMgrlogger()
self._smgr_log.log(self._smgr_log.DEBUG, "ServerMgrCobbler Init")
# Store the passed in values
self._cobbler_ip = ip_address
self._cobbler_port = port
self._cobbler_username = username
self._cobbler_password = password
try:
if self._cobbler_port:
self._server = xmlrpclib.Server(
"http://" +
self._cobbler_ip + ":" +
self._cobbler_port + "/cobbler_api")
else:
self._server = xmlrpclib.Server(
"http://" +
self._cobbler_ip + "/cobbler_api")
self._token = self._server.login(self._cobbler_username,
self._cobbler_password)
except subprocess.CalledProcessError as e:
msg = ("Cobbler Init: error %d when executing"
"\"%s\"" %(e.returncode, e.cmd))
self.log_and_raise_exception(msg, ERR_OPR_ERROR)
except Exception as e:
raise e
def __init__(self, smgr_base_dir, puppet_dir):
self._smgr_log = ServerMgrlogger()
self._smgr_log.log(self._smgr_log.DEBUG, "ServerMgrPuppet Init")
self.smgr_base_dir = smgr_base_dir
self.puppet_directory = puppet_dir
if not os.path.exists(os.path.dirname(puppet_dir)):
os.makedirs(os.path.dirname(puppet_dir))
def __init__(self, db_file_name=def_server_db_file):
try:
self._smgr_log = ServerMgrlogger()
self._con = lite.connect(db_file_name)
with self._con:
cursor = self._con.cursor()
# Create cluster table.
cursor.execute("CREATE TABLE IF NOT EXISTS " + cluster_table +
""" (id TEXT PRIMARY KEY,
parameters TEXT,
email TEXT)""")
# Create image table
cursor.execute("CREATE TABLE IF NOT EXISTS " + image_table +
""" (id TEXT PRIMARY KEY,
version TEXT, type TEXT, path TEXT,
parameters TEXT)""")
# Create status table
cursor.execute("CREATE TABLE IF NOT EXISTS " +
server_status_table + """ (id TEXT PRIMARY KEY,
server_status TEXT)""")
# Create server table
cursor.execute("CREATE TABLE IF NOT EXISTS " + server_table +
""" (mac_address TEXT PRIMARY KEY NOT NULL,
id TEXT, host_name TEXT, static_ip varchar default 'N',
ip_address TEXT, subnet_mask TEXT, gateway TEXT, domain TEXT,
cluster_id TEXT, base_image_id TEXT,
package_image_id TEXT, password TEXT,
last_update TEXT, discovered varchar default 'false',
parameters TEXT, roles TEXT, ipmi_username TEXT,
ipmi_password TEXT, ipmi_address TEXT,
ipmi_type TEXT, intf_control TEXT,
intf_data TEXT, intf_bond TEXT,
email TEXT, status TEXT,
tag1 TEXT, tag2 TEXT, tag3 TEXT,
tag4 TEXT, tag5 TEXT, tag6 TAXT, tag7 TEXT,
UNIQUE (id))""")
# Create server tags table
cursor.execute("CREATE TABLE IF NOT EXISTS " +
server_tags_table +
""" (tag_id TEXT PRIMARY KEY NOT NULL,
value TEXT,
UNIQUE (tag_id),
UNIQUE (value))""")
self._get_table_columns()
self._smgr_log.log(self._smgr_log.DEBUG, "Created tables")
# During init, we check if any of the Cluster in DB are missing any Storage Parameters (Generated UUIDs)
cluster_list = self._get_items(cluster_table, None, None, True,
None)
for cluster in cluster_list:
# Check if storage parameters are present in Cluster, else generate them
if 'storage_fsid' not in set(
eval(cluster['parameters']
)) or 'storage_virsh_uuid' not in set(
eval(cluster['parameters'])):
self.update_cluster_uuids(cluster)
except e:
raise e
def __init__(self, json_entity, args):
super(ContrailAnsiblePlayBook, self).__init__()
lb = []
agent = []
inv_file = None
self.hosts_in_inv = json_entity[0]["hosts_in_inv"]
cluster_id = json_entity[0]["cluster_id"]
parameters = json_entity[0]["parameters"]
inventory = parameters["inventory"]
self.current_status = self.validate_provision_params(inventory, args)
self.pbook_path = inventory["[all:vars]"]["ansible_playbook"]
pbook_dir = os.path.dirname(self.pbook_path)
inv_dir = pbook_dir + '/inventory/'
inv_file = inv_dir + cluster_id + ".inv"
create_inv_file(inv_file, inventory)
self.var_mgr = VariableManager()
self.ldr = DataLoader()
self.args = args
self.inventory = Inventory(loader=self.ldr,
variable_manager=self.var_mgr,
host_list=inv_file)
self.var_mgr.set_inventory(self.inventory)
Options = namedtuple('Options', [
'connection', 'forks', 'module_path', 'become', 'become_method',
'become_user', 'check', 'listhosts', 'listtasks', 'listtags',
'syntax', 'verbosity'
])
self.options = Options(connection='ssh',
forks=100,
module_path=None,
become=True,
become_method='sudo',
become_user='******',
check=False,
listhosts=None,
listtasks=None,
listtags=None,
syntax=None,
verbosity=None)
self.pws = {}
self.pb_executor = PlaybookExecutor(playbooks=[self.pbook_path],
inventory=self.inventory,
variable_manager=self.var_mgr,
loader=self.ldr,
options=self.options,
passwords=self.pws)
try:
self._sm_logger = ServerMgrlogger()
except:
f = open("/var/log/contrail-server-manager/debug.log", "a")
f.write("Ansible Callback Init - ServerMgrlogger init failed\n")
f.close()
def __init__(self,
base_dir=_DEF_BASE_DIR,
ip_address=_DEF_COBBLER_IP,
port=_DEF_COBBLER_PORT,
username=_DEF_USERNAME,
password=_DEF_PASSWORD):
self._smgr_log = ServerMgrlogger()
self._smgr_log.log(self._smgr_log.DEBUG, "ServerMgrCobbler Init")
# Store the passed in values
self._cobbler_ip = ip_address
self._cobbler_port = port
self._cobbler_username = username
self._cobbler_password = password
try:
if self._cobbler_port:
self._server = xmlrpclib.Server("http://" + self._cobbler_ip +
":" + self._cobbler_port +
"/cobbler_api")
else:
self._server = xmlrpclib.Server("http://" + self._cobbler_ip +
"/cobbler_api")
self._token = self._server.login(self._cobbler_username,
self._cobbler_password)
# Copy contrail centos repo to cobber repos, so that target
# systems can install and run puppet agent from kickstart.
repo = self._server.find_repo({"name": _CONTRAIL_CENTOS_REPO})
if repo:
rid = self._server.get_repo_handle(_CONTRAIL_CENTOS_REPO,
self._token)
else:
rid = self._server.new_repo(self._token)
self._server.modify_repo(rid, "arch", "x86_64", self._token)
repo_dir = base_dir + "contrail-centos-repo"
self._server.modify_repo(rid, "name", _CONTRAIL_CENTOS_REPO,
self._token)
self._server.modify_repo(rid, "mirror", repo_dir, self._token)
self._server.modify_repo(rid, "keep_updated", True, self._token)
self._server.modify_repo(rid, "priority", "99", self._token)
self._server.modify_repo(rid, "rpm_list", [], self._token)
self._server.modify_repo(rid, "yumopts", {}, self._token)
self._server.modify_repo(rid, "mirror_locally", True, self._token)
self._server.modify_repo(rid, "environment", {}, self._token)
self._server.modify_repo(rid, "comment", "...", self._token)
self._server.save_repo(rid, self._token)
# Issue cobbler reposync for this repo
cmd = "cobbler reposync --only=" + _CONTRAIL_CENTOS_REPO
subprocess.check_call(cmd, shell=True)
except subprocess.CalledProcessError as e:
msg = ("Cobbler Init: error %d when executing"
"\"%s\"" % (e.returncode, e.cmd))
raise ServerMgrException(msg)
except Exception as e:
raise e
def __init__(self):
''' Constructor '''
self.MonitoringCfg = {
'monitoring_frequency': _DEF_MON_FREQ,
'monitoring_plugin': _DEF_MONITORING_PLUGIN
}
self.InventoryCfg = {'inventory_plugin': _DEF_INVENTORY_PLUGIN}
self._smgr_log = ServerMgrlogger()
self.monitoring_args = None
self.monitoring_config_set = False
self.inventory_args = None
self.inventory_config_set = False
self.server_monitoring_obj = None
self.server_inventory_obj = None
self.monitoring_gevent_thread_obj = None
def __init__(self):
self.log = ''
self.runtime = 0
self.defaults_file = "/etc/contrail/sm-client-config.ini"
config = ConfigParser.SafeConfigParser()
config.read([self.defaults_file])
self.default_config["smgr"] = dict(config.items("SERVER-MANAGER"))
self.smgr_ip = self.default_config["smgr"]["listen_ip_addr"]
f = open("/var/log/contrail-server-manager/debug.log", "a")
f.write("Ansible callback init - smgr_ip: %s" % self.smgr_ip)
try:
self._sm_logger = ServerMgrlogger()
except:
f = open("/var/log/contrail-server-manager/debug.log", "a")
f.write("Ansible Callback Init - ServerMgrlogger init failed\n")
f.close()
def __init__(self, args_str=None):
try:
self._smgr_log = ServerMgrlogger()
except:
print "Error Creating logger object"
self._smgr_log.log(self._smgr_log.INFO, "Starting SM Ansible Server")
if not args_str:
args_str = sys.argv[1:]
self._parse_args(args_str)
self.joinq = Queue.Queue()
self.joiner = Joiner(self.joinq)
self.joiner.start()
self._smgr_log.log(self._smgr_log.INFO, 'Initializing Bottle App')
self.app = bottle.app()
bottle.route('/run_ansible_playbooks', 'POST',
self.start_ansible_playbooks)
def __init__(self, package, v1 = 0, v2 = 0, v3 = 0, v4 = 0):
self.logger = ServerMgrlogger()
if package == None:
self.os_sku = 14
self.major_version = v1
self.moderate_version = v2
self.minor_version_1 = v3
self.minor_version_2 = v4
elif eval(str(package["parameters"])).get("playbooks_version", False) == False:
# Could not detect playbooks in image. Set version such
# that puppet gets triggered
self.os_sku = 14
self.major_version = 4
self.moderate_version = 0
self.minor_version_1 = 0
self.minor_version_2 = 0
else:
try:
version_list = re.split(r'[\.\-]',
eval(str(package["parameters"]))["playbooks_version"])
if "sku" in package["parameters"]:
# sku is of the following format:
# 2:14.0.2-0ubuntu1~cloud0.1contrail
# here, 14 represents the openstack sku - newton
sku_list = re.split(r'[:.]',
eval(str(package["parameters"]))["sku"])
self.os_sku = sku_list[1]
else:
self.os_sku = 14
self.major_version = version_list[0]
self.moderate_version = version_list[1]
self.minor_version_1 = version_list[2]
self.minor_version_2 = version_list[3]
except Exception as e:
self.logger.log(self.logger.ERROR,
"ContrailVersion failed: %s. Falling back to 14.4.0.0.0" % e)
# Could not detect SKU. Fall back to puppet scheme of things
self.os_sku = 14
self.major_version = 4
self.moderate_version = 0
self.minor_version_1 = 0
self.minor_version_2 = 0
def __init__(self, cluster_id):
self.log = ''
self.runtime = 0
self.defaults_file = "/etc/contrail/sm-client-config.ini"
config = ConfigParser.SafeConfigParser()
config.read([self.defaults_file])
self.default_config["smgr"] = dict(config.items("SERVER-MANAGER"))
self.smgr_ip = self.default_config["smgr"]["listen_ip_addr"]
self._sm_prov_logger = None
f = open("/var/log/contrail-server-manager/debug.log", "a")
f.write("Ansible callback init - smgr_ip: %s" % self.smgr_ip)
try:
self._sm_logger = ServerMgrlogger()
if cluster_id:
self._sm_prov_logger = ServerMgrProvlogger(cluster_id)
else:
self._sm_logger.log(self._sm_logger.ERROR,
"cluster_id not found in inventory - provision specific "\
"logging will not be done")
except:
f = open("/var/log/contrail-server-manager/debug.log", "a")
f.write("Ansible Callback Init - ServerMgrlogger init failed\n")
f.close()
def __init__(self, db_file_name=def_server_db_file):
try:
self._smgr_log = ServerMgrlogger()
self._con = lite.connect(db_file_name)
with self._con:
cursor = self._con.cursor()
# Create cluster table.
cursor.execute("CREATE TABLE IF NOT EXISTS " + cluster_table +
""" (id TEXT PRIMARY KEY,
parameters TEXT,
email TEXT)""")
# Create image table
cursor.execute("CREATE TABLE IF NOT EXISTS " + image_table +
""" (id TEXT PRIMARY KEY,
version TEXT, type TEXT, path TEXT,
parameters TEXT)""")
# Create status table
cursor.execute("CREATE TABLE IF NOT EXISTS " +
server_status_table + """ (id TEXT PRIMARY KEY,
server_status TEXT)""")
# Create server table
cursor.execute("CREATE TABLE IF NOT EXISTS " + server_table +
""" (mac_address TEXT PRIMARY KEY NOT NULL,
id TEXT, host_name TEXT, static_ip varchar default 'N',
ip_address TEXT, subnet_mask TEXT, gateway TEXT, domain TEXT,
cluster_id TEXT, base_image_id TEXT,
package_image_id TEXT, password TEXT,
last_update TEXT, discovered varchar default 'false',
parameters TEXT, roles TEXT, ipmi_username TEXT,
ipmi_password TEXT, ipmi_address TEXT,
ipmi_type TEXT, intf_control TEXT,
intf_data TEXT, intf_bond TEXT,
email TEXT, status TEXT,
tag1 TEXT, tag2 TEXT, tag3 TEXT,
tag4 TEXT, tag5 TEXT, tag6 TAXT, tag7 TEXT,
network TEXT, contrail TEXT, top_of_rack TEXT,
UNIQUE (id))""")
# Create inventory table
cursor.execute("CREATE TABLE IF NOT EXISTS " +
inventory_table +
""" (fru_description TEXT PRIMARY KEY NOT NULL,
id TEXT, board_serial_number TEXT, chassis_type TEXT,
chassis_serial_number TEXT, board_mfg_date TEXT,
board_manufacturer TEXT, board_product_name TEXT,
board_part_number TEXT, product_manfacturer TEXT,
product_name TEXT, product_part_number TEXT,
UNIQUE (fru_description))""")
# Create server tags table
cursor.execute("CREATE TABLE IF NOT EXISTS " +
server_tags_table +
""" (tag_id TEXT PRIMARY KEY NOT NULL,
value TEXT,
UNIQUE (tag_id),
UNIQUE (value))""")
# Add columns for image_table
self._add_table_column(cursor, image_table, "category", "TEXT")
# Add columns for cluster_table
self._add_table_column(cursor, cluster_table, "base_image_id",
"TEXT")
self._add_table_column(cursor, cluster_table,
"package_image_id", "TEXT")
self._add_table_column(cursor, cluster_table, "provisioned_id",
"TEXT")
self._add_table_column(cursor, cluster_table,
"provision_role_sequence", "TEXT")
# Add columns for server_table
self._add_table_column(cursor, server_table, "reimaged_id",
"TEXT")
self._add_table_column(cursor, server_table, "provisioned_id",
"TEXT")
self._add_table_column(cursor, server_table, "network", "TEXT")
self._add_table_column(cursor, server_table, "top_of_rack",
"TEXT")
self._add_table_column(cursor, server_table, "contrail",
"TEXT")
self._add_table_column(cursor, server_table, "ssh_public_key",
"TEXT")
self._add_table_column(cursor, server_table, "ssh_private_key",
"TEXT")
self._add_table_column(cursor, server_table, "ipmi_interface",
"TEXT")
self._smgr_log.log(self._smgr_log.DEBUG, "Created tables")
# During init, we check if any of the Cluster in DB are missing any Storage Parameters (Generated UUIDs)
cluster_list = self._get_items(cluster_table, None, None, True,
None)
for cluster in cluster_list:
# Check if storage parameters are present in Cluster, else generate them
if 'storage_fsid' not in set(
eval(cluster['parameters']
)) or 'storage_virsh_uuid' not in set(
eval(cluster['parameters'])):
self.update_cluster_uuids(cluster)
self.update_image_table()
except e:
raise e
def __init__(self):
self._smgr_log = ServerMgrlogger()
self._smgr_log.log(self._smgr_log.DEBUG, "ServerMgrValidations Init")
def __init__(self):
self._docker_client = Client(timeout=240)
self._smgr_log = ServerMgrlogger()
def __init__(self, q):
super(Joiner, self).__init__()
self._smgr_log = ServerMgrlogger()
self.queue = q
