def parse_args(args_str=None):
defaults = {
'old_rabbit_user': '******',
'old_rabbit_password': '******',
'old_rabbit_ha_mode': False,
'old_rabbit_q_name': 'vnc-config.issu-queue',
'old_rabbit_vhost': None,
'old_rabbit_port': '5672',
'old_rabbit_use_ssl': False,
'old_rabbit_ssl_version': None,
'old_rabbit_ssl_ca_certs': None,
'old_rabbit_ssl_keyfile': None,
'old_rabbit_ssl_certfile': None,
'new_rabbit_user': '******',
'new_rabbit_password': '******',
'new_rabbit_ha_mode': False,
'new_rabbit_q_name': 'vnc-config.issu-queue',
'new_rabbit_vhost': '',
'new_rabbit_port': '5672',
'new_rabbit_use_ssl': False,
'new_rabbit_ssl_version': None,
'new_rabbit_ssl_ca_certs': None,
'new_rabbit_ssl_keyfile': None,
'new_rabbit_ssl_certfile': None,
'odb_prefix': '',
'ndb_prefix': '',
'reset_config': None,
'old_cassandra_user': None,
'old_cassandra_password': None,
'old_cassandra_use_ssl': False,
'old_cassandra_ca_certs': None,
'new_cassandra_user': None,
'new_cassandra_password': None,
'new_cassandra_use_ssl': False,
'new_cassandra_ca_certs': None,
'old_cassandra_address_list': '10.84.24.35:9160',
'old_zookeeper_address_list': '10.84.24.35:2181',
'old_rabbit_address_list': '10.84.24.35',
'new_cassandra_address_list': '10.84.24.35:9160',
'new_zookeeper_address_list': '10.84.24.35:2181',
'new_rabbit_address_list': '10.84.24.35',
'new_api_info': '{"10.84.24.52": [("root"), ("c0ntrail123")]}'
}
if not args_str:
args_str = ' '.join(sys.argv[1:])
conf_parser = argparse.ArgumentParser(add_help=False)
conf_parser.add_argument(
"-c", "--conf_file", action='append',
help="Specify config file", metavar="FILE")
args, remaining_argv = conf_parser.parse_known_args(args_str.split())
if args.conf_file:
config = configparser.SafeConfigParser()
config.read(args.conf_file)
defaults.update(dict(config.items("DEFAULTS")))
# Override with CLI options
# Don't surpress add_help here so it will handle -h
parser = argparse.ArgumentParser(
# Inherit options from config_parser
parents=[conf_parser],
# print script description with -h/--help
description=__doc__,
# Don't mess with format of description
formatter_class=argparse.RawDescriptionHelpFormatter,
)
parser.set_defaults(**defaults)
parser.add_argument(
"--old_rabbit_user",
help="Old RMQ user name")
parser.add_argument(
"--old_rabbit_password",
help="Old RMQ passwd")
parser.add_argument(
"--old_rabbit_ha_mode",
help="Old RMQ HA mode")
parser.add_argument(
"--old_rabbit_q_name",
help="Q name in old RMQ")
parser.add_argument(
"--old_rabbit_vhost",
help="Old RMQ Vhost")
parser.add_argument(
"--old_rabbit_port",
help="Old RMQ port")
parser.add_argument(
"--old_rabbit_use_ssl",
help="Old RMQ use ssl flag")
parser.add_argument(
"--old_rabbit_ssl_ca_certs",
help="Old RMQ SSL CA certs file path")
parser.add_argument(
"--old_rabbit_ssl_keyfile",
help="Old RMQ SSL key file path")
parser.add_argument(
"--old_rabbit_ssl_certfile",
help="Old RMQ SSL certificate file path")
parser.add_argument(
"--old_rabbit_ssl_version",
help="Old RMQ SSL version")
parser.add_argument(
"--new_rabbit_user",
help="New RMQ user name")
parser.add_argument(
"--new_rabbit_password",
help="New RMQ passwd")
parser.add_argument(
"--new_rabbit_ha_mode",
help="New RMQ HA mode")
parser.add_argument(
"--new_rabbit_q_name",
help="Q name in new RMQ")
parser.add_argument(
"--new_rabbit_vhost",
help="New RMQ Vhost")
parser.add_argument(
"--new_rabbit_port",
help="New RMQ port")
parser.add_argument(
"--new_rabbit_use_ssl",
help="New RMQ use ssl flag")
parser.add_argument(
"--new_rabbit_ssl_ca_certs",
help="New RMQ SSL CA certs file path")
parser.add_argument(
"--new_rabbit_ssl_keyfile",
help="New RMQ SSL key file path")
parser.add_argument(
"--new_rabbit_ssl_certfile",
help="New RMQ SSL certificate file path")
parser.add_argument(
"--new_rabbit_ssl_version",
help="New RMQ SSL version")
parser.add_argument(
"--old_cassandra_user",
help="Old Cassandra user name")
parser.add_argument(
"--old_cassandra_password",
help="Old Cassandra passwd")
parser.add_argument(
"--new_cassandra_user",
help="New Cassandra user name")
parser.add_argument(
"--new_cassandra_password",
help="New Cassandra passwd")
parser.add_argument(
"--old_cassandra_use_ssl",
help="Old Cassandra use ssl flag")
parser.add_argument(
"--old_cassandra_ca_certs",
help="Old Cassandra CA certs file path")
parser.add_argument(
"--new_cassandra_use_ssl",
help="New Cassandra use ssl flag")
parser.add_argument(
"--new_cassandra_ca_certs",
help="New Cassandra CA certs file path")
parser.add_argument(
"--old_rabbit_address_list",
help="Old RMQ addresses")
parser.add_argument(
"--old_cassandra_address_list",
help="Old Cassandra addresses",
nargs='+')
parser.add_argument(
"--old_zookeeper_address_list",
help="Old zookeeper addresses")
parser.add_argument(
"--new_rabbit_address_list",
help="New RMQ addresses")
parser.add_argument(
"--new_cassandra_address_list",
help="New Cassandra addresses",
nargs='+')
parser.add_argument(
"--new_zookeeper_address_list",
help="New zookeeper addresses")
parser.add_argument(
"--old_db_prefix",
help="Old DB prefix")
parser.add_argument(
"--new_db_prefix",
help="New DB prefix")
parser.add_argument(
"--reset_config",
help="Reset config")
parser.add_argument(
"--new_api_info",
help="New API info",
nargs="+")
args_obj, remaining_argv = parser.parse_known_args(remaining_argv)
if args.conf_file:
args_obj.config_sections = config
if isinstance(args_obj.old_cassandra_address_list, string_types):
args_obj.old_cassandra_address_list =\
args_obj.old_cassandra_address_list.split()
if isinstance(args_obj.new_cassandra_address_list, string_types):
args_obj.new_cassandra_address_list =\
args_obj.new_cassandra_address_list.split()
args_obj.old_rabbit_use_ssl = (str(args_obj.old_rabbit_use_ssl).lower() == 'true')
args_obj.new_rabbit_use_ssl = (str(args_obj.new_rabbit_use_ssl).lower() == 'true')
args_obj.old_rabbit_ha_mode = (str(args_obj.old_rabbit_ha_mode).lower() == 'true')
args_obj.new_rabbit_ha_mode = (str(args_obj.new_rabbit_ha_mode).lower() == 'true')
args_obj.old_cassandra_use_ssl = (str(args_obj.old_cassandra_use_ssl).lower() == 'true')
args_obj.new_cassandra_use_ssl = (str(args_obj.new_cassandra_use_ssl).lower() == 'true')
return args_obj, remaining_argv
def parse_args(self):
"""
Eg. python stats.py --analytics-api-ip 127.0.0.1
--analytics-api-port 8181
--table NodeStatus.process_mem_cpu_usage
--where name=a6s40 cpu_info.module_id=Collector
--select "T=60 SUM(cpu_info.cpu_share)"
--sort "SUM(cpu_info.cpu_share)"
[--start-time now-10m --end-time now] | --last 10m
python stats.py --table NodeStatus.process_mem_cpu_usage
"""
defaults = {
'analytics_api_ip': '127.0.0.1',
'analytics_api_port': '8181',
'start_time': 'now-10m',
'end_time': 'now',
'select' : [],
'where' : ['Source=*'],
'sort': [],
'admin_user': '******',
'admin_password': '******',
'conf_file': '/etc/contrail/contrail-keystone-auth.conf',
}
conf_parser = argparse.ArgumentParser(add_help=False)
conf_parser.add_argument("--admin-user", help="Name of admin user")
conf_parser.add_argument("--admin-password", help="Password of admin user")
conf_parser.add_argument("--conf-file", help="Configuration file")
conf_parser.add_argument("--analytics-api-ip", help="IP address of Analytics API Server")
conf_parser.add_argument("--analytics-api-port", help="Port of Analytcis API Server")
args, remaining_argv = conf_parser.parse_known_args();
configfile = defaults['conf_file']
if args.conf_file:
configfile = args.conf_file
config = configparser.SafeConfigParser()
config.read(configfile)
if 'KEYSTONE' in config.sections():
if args.admin_user == None:
args.admin_user = config.get('KEYSTONE', 'admin_user')
if args.admin_password == None:
args.admin_password = config.get('KEYSTONE','admin_password')
if args.admin_user == None:
args.admin_user = defaults['admin_user']
if args.admin_password == None:
args.admin_password = defaults['admin_password']
if args.analytics_api_ip == None:
args.analytics_api_ip = defaults['analytics_api_ip']
if args.analytics_api_port == None:
args.analytics_api_port = defaults['analytics_api_port']
stat_table_list = [xx.stat_type + "." + xx.stat_attr for xx in _STAT_TABLES]
tab_url = "http://" + args.analytics_api_ip + ":" +\
args.analytics_api_port + "/analytics/tables"
tables = OpServerUtils.get_url_http(tab_url,
args.admin_user, args.admin_password)
if tables != {}:
if tables.status_code == 200:
table_list = json.loads(tables.text)
for table in table_list:
if table['type'] == 'STAT':
table_name = '.'.join(table['name'].split('.')[1:])
# append to stat_table_list only if not existing
if table_name not in stat_table_list:
stat_table_list.append(table_name)
parser = argparse.ArgumentParser(
# Inherit options from config_parser
parents=[conf_parser],
# print script description with -h/--help
description=__doc__,
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.set_defaults(**defaults)
parser.add_argument(
"--start-time", help="Logs start time (format now-10m, now-1h)")
parser.add_argument("--end-time", help="Logs end time")
parser.add_argument(
"--last", help="Logs from last time period (format 10m, 1d)")
parser.add_argument(
"--table", help="StatTable to query", choices=stat_table_list)
parser.add_argument(
"--dtable", help="Dynamic StatTable to query")
parser.add_argument(
"--select", help="List of Select Terms", nargs='+')
parser.add_argument(
"--where", help="List of Where Terms to be ANDed", nargs='+')
parser.add_argument(
"--sort", help="List of Sort Terms", nargs='+')
self._args = parser.parse_args(remaining_argv)
self._args.admin_user = args.admin_user
self._args.admin_password = args.admin_password
self._args.analytics_api_ip = args.analytics_api_ip
self._args.analytics_api_port = args.analytics_api_port
if self._args.table is None and self._args.dtable is None:
return -1
try:
self._start_time, self._end_time = \
OpServerUtils.parse_start_end_time(
start_time = self._args.start_time,
end_time = self._args.end_time,
last = self._args.last)
except:
return -1
return 0
sys.exit(5)
if CFG is None and COMMAND not in ['post_xml', 'get_sysprof', 'validate_xml']:
print('ERROR: -f <cfg> is a required argument')
sys.exit(6)
if COMMAND in ['load_records', 'export_records'] and XML_DIRPATH is None:
print('ERROR: -p </path/to/records> is a required argument')
sys.exit(7)
if COMMAND == 'gen_sitemap' and OUTPUT_FILE is None:
print('ERROR: -o </path/to/sitemap.xml> is a required argument')
sys.exit(8)
if COMMAND not in ['post_xml', 'get_sysprof', 'validate_xml']:
SCP = configparser.SafeConfigParser()
with open(CFG) as f:
SCP.readfp(f)
DATABASE = SCP.get('repository', 'database')
EXTRA_COLUMNS = []
try:
extra_columns = SCP.get('repository', 'extra_columns').split(",")
except configparser.NoOptionError:
extra_columns = None
if extra_columns is not None:
from sqlalchemy import Column, Text
def parce_confs(opts):
# configs
confs = configparser.SafeConfigParser()
confs.read(opts.config)
return confs
def _sync_latest(self):
base_url = self.url
checksum_file = base_url + "SHA256SUMS"
checksum_file = requests.get(checksum_file)
if checksum_file.status_code != 200:
LOG.error("Could not get checksums file %s" % checksum_file.url)
return
aux = dict([list(reversed(line.split()))
for line in checksum_file.text.splitlines()])
filename = None
for k, v in aux.items():
if k.endswith(".qcow2"):
filename = k
checksum = v
break
if filename is None:
LOG.error("Could not get image file")
return
LOG.info("Downloading %s", filename)
# Get the revision from the index file
index = requests.get(base_url + filename + ".index")
if not index.ok:
LOG.error("Cannot download image from server, got %s", index.status_code)
return
parser = configparser.SafeConfigParser()
parser.readfp(six.StringIO(index.text))
section = parser.sections()[0]
revision = parser.get(section, "revision")
url = base_url + filename
architecture = "x86_64"
file_format = "qcow2"
prefix = CONF.prefix
name = "%sDebian %s [%s]" % (prefix, self.version, revision)
image = self.glance.get_image_by_name(name)
if image:
if image.get("imgsync.sha256") != checksum:
LOG.error("Glance image chechsum (%s, %s)and official "
"checksum %s missmatch.",
image.id, image.get("imgsync.sha256"), checksum)
else:
LOG.info("Image already downloaded and synchroniced")
return
location = None
try:
location = self._download_one(url, ("sha256", checksum))
self.glance.upload(location,
name,
architecture=architecture,
file_format=file_format,
container_format="bare",
checksum={"sha256": checksum},
os_distro="ubuntu",
os_version=self.version)
LOG.info("Synchronized %s", name)
finally:
if location is not None:
os.remove(location.name)
def __init__(self):
self.config_parser = configparser.SafeConfigParser()
def read_config(self, config_file):
"""
Parses the specified configuration file and stores the values. Raises
an InvalidConfigurationFile exception if the file is not well-formed.
"""
cfg = ConfigParser.SafeConfigParser()
try:
cfg.read(config_file)
except ConfigParser.MissingSectionHeaderError as e:
# The file exists, but doesn't have the correct format.
raise exc.InvalidConfigurationFile(e)
def safe_get(section, option, default=None):
try:
return cfg.get(section, option)
except (ConfigParser.NoSectionError, ConfigParser.NoOptionError):
return default
# A common mistake is including credentials in the config file. If any
# values are found, issue a warning so that the developer can correct
# this problem.
creds_found = False
for section in cfg.sections():
if section == "settings":
section_name = "default"
self._default_set = True
else:
section_name = section
# Check for included credentials
for key in ("username", "password", "api_key"):
if creds_found:
break
if safe_get(section, key):
creds_found = True
dct = self._settings[section_name] = {}
dct["region"] = safe_get(section, "region", default_region)
ityp = safe_get(section, "identity_type")
if ityp:
dct["identity_type"] = _id_type(ityp)
dct["identity_class"] = _import_identity(ityp)
# Handle both the old and new names for this setting.
debug = safe_get(section, "debug")
if debug is None:
debug = safe_get(section, "http_debug", "False")
dct["http_debug"] = debug == "True"
verify_ssl = safe_get(section, "verify_ssl", "True")
dct["verify_ssl"] = verify_ssl == "True"
dct["keyring_username"] = safe_get(section, "keyring_username")
dct["encoding"] = safe_get(section, "encoding", default_encoding)
dct["auth_endpoint"] = safe_get(section, "auth_endpoint")
dct["tenant_name"] = safe_get(section, "tenant_name")
dct["tenant_id"] = safe_get(section, "tenant_id")
use_servicenet = safe_get(section, "use_servicenet", "False")
dct["use_servicenet"] = use_servicenet == "True"
app_agent = safe_get(section, "custom_user_agent")
if app_agent:
# Customize the user-agent string with the app name.
dct["user_agent"] = "%s %s" % (app_agent, USER_AGENT)
else:
dct["user_agent"] = USER_AGENT
# If this is the first section, make it the default
if not self._default_set:
self._settings["default"] = self._settings[section]
self._default_set = True
if creds_found:
warnings.warn("Login credentials were detected in your .pyrax.cfg "
"file. These have been ignored, but you should remove "
"them and either place them in a credential file, or "
"consider using another means of authentication. More "
"information on the use of credential files can be found "
"in the 'docs/getting_started.md' document.")
def get_config_parser():
import sys
python_version = sys.version_info.major
return configparser.ConfigParser(
) if python_version == 3 else configparser.SafeConfigParser()
def read_ini_settings(self):
''' Read ini file settings '''
scriptbasename = "ocp-on-vmware"
defaults = {
'vmware': {
'ini_path':
os.path.join(os.path.dirname(__file__),
'%s.ini' % scriptbasename),
'console_port':
'8443',
'container_storage':
'none',
'deployment_type':
'openshift-enterprise',
'openshift_vers':
'v3_4',
'vcenter_host':
'',
'vcenter_username':
'******',
'vcenter_password':
'',
'vcenter_template_name':
'ocp-server-template-2.0.2',
'vcenter_folder':
'ocp',
'vcenter_cluster':
'',
'vcenter_resource_pool':
'/Resources/OCP3',
'public_hosted_zone':
'',
'app_dns_prefix':
'apps',
'vm_dns':
'',
'vm_gw':
'',
'vm_netmask':
'',
'vm_network':
'VM Network',
'rhel_subscription_user':
'',
'rhel_subscription_pass':
'',
'rhel_subscription_server':
'',
'rhel_subscription_pool':
'Red Hat OpenShift Container Platform, Premium*',
'openshift_sdn':
'redhat/openshift-ovs-subnet',
'byo_lb':
'no',
'lb_host':
'haproxy-',
'byo_nfs':
'no',
'nfs_host':
'nfs-0',
'nfs_registry_mountpoint':
'/exports',
'master_nodes':
'3',
'infra_nodes':
'2',
'app_nodes':
'3',
'vm_ipaddr_start':
'',
'ocp_hostname_prefix':
'',
'auth_type':
'ldap',
'ldap_user':
'******',
'ldap_user_password':
'',
'node_type':
self.args.node_type,
'node_number':
self.args.node_number,
'ldap_fqdn':
''
}
}
if six.PY3:
config = configparser.ConfigParser()
else:
config = configparser.SafeConfigParser()
# where is the config?
vmware_ini_path = os.environ.get('VMWARE_INI_PATH',
defaults['vmware']['ini_path'])
vmware_ini_path = os.path.expanduser(
os.path.expandvars(vmware_ini_path))
config.read(vmware_ini_path)
# apply defaults
for k, v in defaults['vmware'].iteritems():
if not config.has_option('vmware', k):
config.set('vmware', k, str(v))
self.console_port = config.get('vmware', 'console_port')
self.container_storage = config.get('vmware', 'container_storage')
self.deployment_type = config.get('vmware', 'deployment_type')
self.openshift_vers = config.get('vmware', 'openshift_vers')
self.vcenter_host = config.get('vmware', 'vcenter_host')
self.vcenter_username = config.get('vmware', 'vcenter_username')
self.vcenter_password = config.get('vmware', 'vcenter_password')
self.vcenter_template_name = config.get('vmware',
'vcenter_template_name')
self.vcenter_folder = config.get('vmware', 'vcenter_folder')
self.vcenter_cluster = config.get('vmware', 'vcenter_cluster')
self.vcenter_datacenter = config.get('vmware', 'vcenter_datacenter')
self.vcenter_resource_pool = config.get('vmware',
'vcenter_resource_pool')
self.public_hosted_zone = config.get('vmware', 'public_hosted_zone')
self.app_dns_prefix = config.get('vmware', 'app_dns_prefix')
self.vm_dns = config.get('vmware', 'vm_dns')
self.vm_gw = config.get('vmware', 'vm_gw')
self.vm_netmask = config.get('vmware', 'vm_netmask')
self.vm_network = config.get('vmware', 'vm_network')
self.rhel_subscription_user = config.get('vmware',
'rhel_subscription_user')
self.rhel_subscription_pass = config.get('vmware',
'rhel_subscription_pass')
self.rhel_subscription_server = config.get('vmware',
'rhel_subscription_server')
self.rhel_subscription_pool = config.get('vmware',
'rhel_subscription_pool')
self.openshift_sdn = config.get('vmware', 'openshift_sdn')
self.byo_lb = config.get('vmware', 'byo_lb')
self.lb_host = config.get('vmware', 'lb_host')
self.byo_nfs = config.get('vmware', 'byo_nfs')
self.nfs_host = config.get('vmware', 'nfs_host')
self.nfs_registry_mountpoint = config.get('vmware',
'nfs_registry_mountpoint')
self.master_nodes = config.get('vmware', 'master_nodes')
self.infra_nodes = config.get('vmware', 'infra_nodes')
self.app_nodes = config.get('vmware', 'app_nodes')
self.vm_ipaddr_start = config.get('vmware', 'vm_ipaddr_start')
self.ocp_hostname_prefix = config.get('vmware', 'ocp_hostname_prefix')
self.auth_type = config.get('vmware', 'auth_type')
self.ldap_user = config.get('vmware', 'ldap_user')
self.ldap_user_password = config.get('vmware', 'ldap_user_password')
self.ldap_fqdn = config.get('vmware', 'ldap_fqdn')
self.node_type = config.get('vmware', 'node_type')
self.node_number = config.get('vmware', 'node_number')
err_count = 0
if 'storage' in self.node_type:
self.node_number = 3
required_vars = {
'public_hosted_zone': self.public_hosted_zone,
'vcenter_host': self.vcenter_host,
'vcenter_password': self.vcenter_password,
'vm_ipaddr_start': self.vm_ipaddr_start,
'ldap_fqdn': self.ldap_fqdn,
'ldap_user_password': self.ldap_user_password,
'vm_dns': self.vm_dns,
'vm_gw': self.vm_gw,
'vm_netmask': self.vm_netmask,
'vcenter_datacenter': self.vcenter_datacenter
}
for k, v in required_vars.items():
if v == '':
err_count += 1
print "Missing %s " % k
if err_count > 0:
print "Please fill out the missing variables in %s " % vmware_ini_path
exit(1)
self.wildcard_zone = "%s.%s" % (self.app_dns_prefix,
self.public_hosted_zone)
self.support_nodes = 0
print 'Configured inventory values:'
for each_section in config.sections():
for (key, val) in config.items(each_section):
print '\t %s: %s' % (key, val)
def _load_support_matrix(self):
"""Reads the support-matrix.ini file and populates an instance
of the SupportMatrix class with all the data.
:returns: SupportMatrix instance
"""
# SafeConfigParser was deprecated in Python 3.2
if sys.version_info >= (3, 2):
cfg = config_parser.ConfigParser()
else:
cfg = config_parser.SafeConfigParser()
env = self.state.document.settings.env
fname = self.options.get("support-matrix", "support-matrix.ini")
rel_fpath, fpath = env.relfn2path(fname)
with open(fpath) as fp:
cfg.readfp(fp)
# This ensures that the docs are rebuilt whenever the
# .ini file changes
env.note_dependency(rel_fpath)
matrix = SupportMatrix()
# The 'targets' section is special - it lists all the
# hypervisors that this file records data for
for item in cfg.options("backends"):
if not item.startswith("backend-impl-"):
continue
# The driver string will optionally contain
# a hypervisor and architecture qualifier
# so we expect between 1 and 3 components
# in the name
key = item[13:]
title = cfg.get("backends", item)
name = key.split("-")
try:
status = cfg.get("backends.%s" % item, "status")
except config_parser.NoOptionError:
if cfg.get("backends.%s" % item, "type") == "xfr":
backend = Backend.get_driver(name[0])
elif cfg.get("backends.%s" % item, "type") == "agent":
backend = AgentBackend.get_driver(name[0])
status = backend.__backend_status__
if len(name) == 1:
backend = SupportMatrixBackend(key, title, status, name[0])
elif len(name) == 2:
backend = SupportMatrixBackend(key,
title,
status,
name[0],
variations=name[1])
else:
raise Exception("'%s' field is malformed in '[%s]' section" %
(item, "DEFAULT"))
backend.in_tree = cfg.getboolean("backends.%s" % item, "in-tree")
backend.type = cfg.get("backends.%s" % item, "type")
backend.notes = cfg.get("backends.%s" % item, "notes")
backend.repository = cfg.get("backends.%s" % item, "repository")
backend.maintainers = cfg.get("backends.%s" % item, "maintainers")
matrix.backends[key] = backend
grades = cfg.get("grades", "valid-grades")
grades = grades.split(",")
for grade in grades:
title = cfg.get("grades.%s" % grade, "title")
notes = cfg.get("grades.%s" % grade, "notes")
in_tree = cfg.get("grades.%s" % grade, "in-tree")
css_class = cfg.get("grades.%s" % grade, "css-class")
matrix.grade_names[grade] = title
matrix.grade_classes[grade] = css_class
grade = SupportMatrixGrade(grade, title, notes, in_tree, css_class)
matrix.grades.append(grade)
return matrix
def get_config_parser():
return configparser.ConfigParser() if sys.version_info.major == 3 else configparser.SafeConfigParser()
def launch_refarch_env(console_port=8443,
deployment_type=None,
openshift_vers=None,
vcenter_host=None,
vcenter_username=None,
vcenter_password=None,
vcenter_template_name=None,
vcenter_folder=None,
vcenter_cluster=None,
vcenter_datacenter=None,
vcenter_resource_pool=None,
public_hosted_zone=None,
app_dns_prefix=None,
vm_dns=None,
vm_gw=None,
vm_netmask=None,
vm_network=None,
rhel_subscription_user=None,
rhel_subscription_pass=None,
rhel_subscription_server=None,
rhel_subscription_pool=None,
byo_lb=None,
lb_host=None,
byo_nfs=None,
nfs_host=None,
nfs_registry_mountpoint=None,
no_confirm=False,
tag=None,
verbose=0,
create_inventory=None,
master_nodes=None,
infra_nodes=None,
app_nodes=None,
vm_ipaddr_start=None,
ocp_hostname_prefix=None,
create_ocp_vars=None,
auth_type=None,
ldap_user=None,
ldap_user_password=None,
ldap_fqdn=None,
openshift_sdn=None,
containerized=None,
container_storage=None,
openshift_hosted_metrics_deploy=None,
clean=None):
# Open config file INI for values first
scriptbasename = __file__
scriptbasename = os.path.basename(scriptbasename)
scriptbasename = scriptbasename.replace('.py', '')
defaults = {
'vmware': {
'ini_path':
os.path.join(os.path.dirname(__file__), '%s.ini' % scriptbasename),
'console_port':
'8443',
'deployment_type':
'openshift-enterprise',
'openshift_vers':
'v3_5',
'vcenter_host':
'',
'vcenter_username':
'******',
'vcenter_password':
'',
'vcenter_template_name':
'ocp-server-template-2.0.2',
'vcenter_folder':
'ocp',
'vcenter_cluster':
'devel',
'vcenter_cluster':
'',
'vcenter_resource_pool':
'/Resources/OCP3',
'public_hosted_zone':
'',
'app_dns_prefix':
'apps',
'vm_dns':
'',
'vm_gw':
'',
'vm_netmask':
'',
'vm_network':
'VM Network',
'rhel_subscription_user':
'',
'rhel_subscription_pass':
'',
'rhel_subscription_server':
'',
'rhel_subscription_pool':
'Red Hat OpenShift Container Platform, Premium*',
'openshift_sdn':
'redhat/openshift-ovs-subnet',
'containerized':
'containerized',
'container_storage':
'none',
'openshift_hosted_metrics_deploy':
'false',
'byo_lb':
'no',
'lb_host':
'haproxy-',
'byo_nfs':
'no',
'nfs_host':
'nfs-0',
'nfs_registry_mountpoint':
'/exports',
'master_nodes':
'3',
'infra_nodes':
'2',
'app_nodes':
'3',
'vm_ipaddr_start':
'',
'ocp_hostname_prefix':
'',
'auth_type':
'ldap',
'ldap_user':
'******',
'ldap_user_password':
'',
'ldap_fqdn':
''
}
}
if six.PY3:
config = configparser.ConfigParser()
else:
config = configparser.SafeConfigParser()
# where is the config?
vmware_ini_path = os.environ.get('VMWARE_INI_PATH',
defaults['vmware']['ini_path'])
vmware_ini_path = os.path.expanduser(os.path.expandvars(vmware_ini_path))
config.read(vmware_ini_path)
# apply defaults
for k, v in defaults['vmware'].iteritems():
if not config.has_option('vmware', k):
config.set('vmware', k, str(v))
console_port = config.get('vmware', 'console_port')
deployment_type = config.get('vmware', 'deployment_type')
openshift_vers = config.get('vmware', 'openshift_vers')
vcenter_host = config.get('vmware', 'vcenter_host')
vcenter_username = config.get('vmware', 'vcenter_username')
vcenter_password = config.get('vmware', 'vcenter_password')
vcenter_template_name = config.get('vmware', 'vcenter_template_name')
vcenter_folder = config.get('vmware', 'vcenter_folder')
vcenter_cluster = config.get('vmware', 'vcenter_cluster')
vcenter_datacenter = config.get('vmware', 'vcenter_datacenter')
vcenter_resource_pool = config.get('vmware', 'vcenter_resource_pool')
public_hosted_zone = config.get('vmware', 'public_hosted_zone')
app_dns_prefix = config.get('vmware', 'app_dns_prefix')
vm_dns = config.get('vmware', 'vm_dns')
vm_gw = config.get('vmware', 'vm_gw')
vm_netmask = config.get('vmware', 'vm_netmask')
vm_network = config.get('vmware', 'vm_network')
rhel_subscription_user = config.get('vmware', 'rhel_subscription_user')
rhel_subscription_pass = config.get('vmware', 'rhel_subscription_pass')
rhel_subscription_server = config.get('vmware', 'rhel_subscription_server')
rhel_subscription_pool = config.get('vmware', 'rhel_subscription_pool')
openshift_sdn = config.get('vmware', 'openshift_sdn')
containerized = config.get('vmware', 'containerized')
container_storage = config.get('vmware', 'container_storage')
openshift_hosted_metrics_deploy = config.get(
'vmware', 'openshift_hosted_metrics_deploy')
byo_lb = config.get('vmware', 'byo_lb')
lb_host = config.get('vmware', 'lb_host')
byo_nfs = config.get('vmware', 'byo_nfs')
nfs_host = config.get('vmware', 'nfs_host')
nfs_registry_mountpoint = config.get('vmware', 'nfs_registry_mountpoint')
master_nodes = config.get('vmware', 'master_nodes')
infra_nodes = config.get('vmware', 'infra_nodes')
app_nodes = config.get('vmware', 'app_nodes')
vm_ipaddr_start = config.get('vmware', 'vm_ipaddr_start')
ocp_hostname_prefix = config.get('vmware', 'ocp_hostname_prefix')
auth_type = config.get('vmware', 'auth_type')
ldap_user = config.get('vmware', 'ldap_user')
ldap_user_password = config.get('vmware', 'ldap_user_password')
ldap_fqdn = config.get('vmware', 'ldap_fqdn')
err_count = 0
required_vars = {
'public_hosted_zone': public_hosted_zone,
'vcenter_host': vcenter_host,
'vcenter_password': vcenter_password,
'vm_ipaddr_start': vm_ipaddr_start,
'ldap_fqdn': ldap_fqdn,
'ldap_user_password': ldap_user_password,
'vm_dns': vm_dns,
'vm_gw': vm_gw,
'vm_netmask': vm_netmask,
'vcenter_datacenter': vcenter_datacenter
}
for k, v in required_vars.items():
if v == '':
err_count += 1
print "Missing %s " % k
if err_count > 0:
print "Please fill out the missing variables in %s " % vmware_ini_path
exit(1)
wildcard_zone = "%s.%s" % (app_dns_prefix, public_hosted_zone)
# fix nfs_host and lb_host vars with nfs_ocp_hostname_prefix
if 'no' in byo_lb:
if ocp_hostname_prefix is not None:
lb_host = ocp_hostname_prefix + "haproxy-0"
else:
lb_host = "haproxy-0"
if 'no' in byo_nfs:
if ocp_hostname_prefix is not None:
nfs_host = ocp_hostname_prefix + "nfs-0"
else:
nfs_host = "nfs-0"
tags = []
tags.append('setup')
# Our initial support node is the wildcard_ip
support_nodes = 1
if byo_nfs == "no":
support_nodes = support_nodes + 1
tags.append('nfs')
else:
if nfs_host == '':
nfs_host = click.prompt(
"Please enter the NFS Server fqdn for persistent registry:")
if nfs_registry_mountpoint is '':
nfs_registry_mountpoint = click.prompt(
"Please enter NFS share name for persistent registry:")
tags.append('prod')
if byo_lb == "no":
tags.append('haproxy')
else:
if lb_host == '':
lb_host = click.prompt(
"Please enter the load balancer hostname for installation:")
lb_host = lb_host + '.' + public_hosted_zone
if create_ocp_vars is True:
click.echo('Configured OCP variables:')
click.echo('\tauth_type: %s' % auth_type)
click.echo('\tldap_fqdn: %s' % ldap_fqdn)
click.echo('\tldap_user: %s' % ldap_user)
click.echo('\tldap_user_password: %s' % ldap_user_password)
click.echo('\tpublic_hosted_zone: %s' % public_hosted_zone)
click.echo('\tapp_dns_prefix: %s' % app_dns_prefix)
click.echo('\tbyo_lb: %s' % byo_lb)
click.echo('\tlb_host: %s' % lb_host)
click.echo('\tUsing values from: %s' % vmware_ini_path)
if not no_confirm:
click.confirm('Continue using these values?', abort=True)
if auth_type == 'ldap':
l_bdn = ""
for d in ldap_fqdn.split("."):
l_bdn = l_bdn + "dc=" + d + ","
l = ldap.initialize("ldap://" + ldap_fqdn)
try:
l.protocol_version = ldap.VERSION3
l.set_option(ldap.OPT_REFERRALS, 0)
bind = l.simple_bind_s(ldap_user, ldap_user_password)
base = l_bdn[:-1]
criteria = "(&(objectClass=user)(sAMAccountName=" + ldap_user + "))"
attributes = 'displayName', 'distinguishedName'
result = l.search_s(base, ldap.SCOPE_SUBTREE, criteria,
attributes)
results = [
entry for dn, entry in result if isinstance(entry, dict)
]
finally:
l.unbind()
for result in results:
bindDN = str(result['distinguishedName']).strip("'[]")
url_base = bindDN.replace(("CN=" + ldap_user + ","), "")
url = "ldap://" + ldap_fqdn + ":389/" + url_base + "?sAMAccountName"
install_file = "playbooks/openshift-install.yaml"
for line in fileinput.input(install_file, inplace=True):
# Parse our ldap url
if line.startswith(" url:"):
print " url: " + url
elif line.startswith(" bindPassword:"******" bindPassword: "******" bindDN:"):
print " bindDN: " + bindDN
elif line.startswith(" wildcard_zone:"):
print " wildcard_zone: " + app_dns_prefix + "." + public_hosted_zone
elif line.startswith(" load_balancer_hostname:"):
print " load_balancer_hostname: " + lb_host + "." + public_hosted_zone
elif line.startswith(" deployment_type:"):
print " deployment_type: " + deployment_type
elif line.startswith(
" openshift_hosted_registry_storage_host:"):
print " openshift_hosted_registry_storage_host: " + nfs_host + "." + public_hosted_zone
elif line.startswith(
" openshift_hosted_registry_storage_nfs_directory:"
):
print " openshift_hosted_registry_storage_nfs_directory: " + nfs_host + "." + public_hosted_zone
elif line.startswith(
" openshift_hosted_metrics_storage_host:"):
print " openshift_hosted_metrics_storage_host: " + nfs_host + "." + public_hosted_zone
elif line.startswith(
" openshift_hosted_metrics_storage_nfs_directory:"):
print " openshift_hosted_metrics_storage_nfs_directory: " + nfs_registry_mountpoint
else:
print line,
# Provide values for update and add node playbooks
update_file = "playbooks/minor-update.yaml"
for line in fileinput.input(update_file, inplace=True):
if line.startswith(" wildcard_zone:"):
print " wildcard_zone: " + app_dns_prefix + "." + public_hosted_zone
elif line.startswith(" load_balancer_hostname:"):
print " load_balancer_hostname: " + lb_host + "." + public_hosted_zone
elif line.startswith(" deployment_type:"):
print " deployment_type: " + deployment_type
else:
print line,
#End create_ocp_vars
exit(0)
if auth_type == 'none':
playbooks = [
"playbooks/openshift-install.yaml",
"playbooks/minor-update.yaml"
]
for ocp_file in playbooks:
for line in fileinput.input(ocp_file, inplace=True):
if line.startswith(
'#openshift_master_identity_providers:'):
line = line.replace('#', ' ')
print line
else:
print line,
exit(0)
if create_inventory is True:
click.echo('Configured inventory values:')
click.echo('\tmaster_nodes: %s' % master_nodes)
click.echo('\tinfra_nodes: %s' % infra_nodes)
click.echo('\tapp_nodes: %s' % app_nodes)
click.echo('\tpublic_hosted_zone: %s' % public_hosted_zone)
click.echo('\tapp_dns_prefix: %s' % app_dns_prefix)
click.echo('\tocp_hostname_prefix: %s' % ocp_hostname_prefix)
click.echo('\tbyo_nfs: %s' % byo_nfs)
if byo_nfs == "no":
click.echo('\tnfs_host: %s' % nfs_host)
click.echo('\tbyo_lb: %s' % byo_lb)
if byo_lb == "no":
click.echo('\tlb_host: %s' % lb_host)
click.echo('\tvm_ipaddr_start: %s' % vm_ipaddr_start)
click.echo('\tUsing values from: %s' % vmware_ini_path)
click.echo("")
if not no_confirm:
click.confirm('Continue using these values?', abort=True)
# Create the inventory file and exit
total_nodes = int(master_nodes) + int(app_nodes) + int(
infra_nodes) + int(support_nodes)
if vm_ipaddr_start is None:
vm_ipaddr_start = click.prompt("Starting IP address to use?")
ip4addr = []
for i in range(total_nodes):
p = iptools.ipv4.ip2long(vm_ipaddr_start) + i
ip4addr.append(iptools.ipv4.long2ip(p))
wild_ip = ip4addr.pop()
bind_entry = []
bind_entry.append("$ORIGIN " + app_dns_prefix + "." +
public_hosted_zone + ".")
bind_entry.append("*\tA\t" + wild_ip)
bind_entry.append("$ORIGIN " + public_hosted_zone + ".")
d = {}
d['host_inventory'] = {}
d['infrastructure_hosts'] = {}
support_list = []
if byo_nfs == "no":
if ocp_hostname_prefix not in nfs_host:
nfs_host = ocp_hostname_prefix + "nfs-0"
d['host_inventory'][nfs_host] = {}
d['host_inventory'][nfs_host]['guestname'] = nfs_host
d['host_inventory'][nfs_host]['ip4addr'] = ip4addr[0]
d['host_inventory'][nfs_host]['tag'] = "infra-nfs"
d['infrastructure_hosts']["nfs_server"] = {}
d['infrastructure_hosts']["nfs_server"]['guestname'] = nfs_host
d['infrastructure_hosts']["nfs_server"]['tag'] = "infra-nfs"
support_list.append(nfs_host)
bind_entry.append(nfs_host + "\tA\t" + ip4addr[0])
del ip4addr[0]
if byo_lb == "no":
if ocp_hostname_prefix not in lb_host:
lb_host = ocp_hostname_prefix + "haproxy-0"
d['host_inventory'][lb_host] = {}
d['host_inventory'][lb_host]['guestname'] = lb_host
d['host_inventory'][lb_host]['ip4addr'] = wild_ip
d['host_inventory'][lb_host]['tag'] = "loadbalancer"
d['infrastructure_hosts']["haproxy"] = {}
d['infrastructure_hosts']["haproxy"]['guestname'] = lb_host
d['infrastructure_hosts']["haproxy"]['tag'] = "loadbalancer"
support_list.append(lb_host)
bind_entry.append(lb_host + "\tA\t" + wild_ip)
master_list = []
d['production_hosts'] = {}
for i in range(0, int(master_nodes)):
if ocp_hostname_prefix is not None:
master_name = ocp_hostname_prefix + "master-" + str(i)
else:
master_name = "master-" + str(i)
d['host_inventory'][master_name] = {}
d['host_inventory'][master_name]['guestname'] = master_name
d['host_inventory'][master_name]['ip4addr'] = ip4addr[0]
d['host_inventory'][master_name]['tag'] = "master"
d['production_hosts'][master_name] = {}
d['production_hosts'][master_name]['guestname'] = master_name
d['production_hosts'][master_name]['tag'] = "master"
master_list.append(master_name)
bind_entry.append(master_name + "\tA\t" + ip4addr[0])
del ip4addr[0]
app_list = []
for i in range(0, int(app_nodes)):
if ocp_hostname_prefix is not None:
app_name = ocp_hostname_prefix + "app-" + str(i)
else:
app_name = "app-" + str(i)
d['host_inventory'][app_name] = {}
d['host_inventory'][app_name]['guestname'] = app_name
d['host_inventory'][app_name]['ip4addr'] = ip4addr[0]
d['host_inventory'][app_name]['tag'] = "app"
d['production_hosts'][app_name] = {}
d['production_hosts'][app_name]['guestname'] = app_name
d['production_hosts'][app_name]['tag'] = "app"
app_list.append(app_name)
bind_entry.append(app_name + "\tA\t" + ip4addr[0])
del ip4addr[0]
infra_list = []
for i in range(0, int(infra_nodes)):
if ocp_hostname_prefix is not None:
infra_name = ocp_hostname_prefix + "infra-" + str(i)
else:
infra_name = "infra-" + str(i)
d['host_inventory'][infra_name] = {}
d['host_inventory'][infra_name]['guestname'] = infra_name
d['host_inventory'][infra_name]['ip4addr'] = ip4addr[0]
d['host_inventory'][infra_name]['tag'] = "infra"
d['production_hosts'][infra_name] = {}
d['production_hosts'][infra_name]['guestname'] = infra_name
d['production_hosts'][infra_name]['tag'] = "infra"
infra_list.append(infra_name)
bind_entry.append(infra_name + " A " + ip4addr[0])
del ip4addr[0]
print "# Here is what should go into your DNS records"
print("\n".join(bind_entry))
print "# Please note, if you have chosen to bring your own loadbalancer and NFS Server you will need to ensure that these records are added to DNS and properly resolve. "
with open('infrastructure.json', 'w') as outfile:
json.dump(d, outfile)
exit(0)
# End create inventory
# Display information to the user about their choices
click.echo('Configured values:')
for each_section in config.sections():
for (key, val) in config.items(each_section):
print '\t %s: %s' % (key, val)
click.echo("")
if not no_confirm:
click.confirm('Continue using these values?', abort=True)
if not os.path.isfile('infrastructure.json'):
print "Please create your inventory file first by running the --create_inventory flag"
exit(1)
inventory_file = "inventory/vsphere/vms/vmware_inventory.ini"
# Add section here to modify inventory file based on input from user check your vmmark scripts for parsing the file and adding the values
for line in fileinput.input(inventory_file, inplace=True):
if line.startswith("server="):
print "server=" + vcenter_host
elif line.startswith("password="******"password="******"username="******"username="******"
command = 'cp -f ~/.ssh/id_rsa ssh_key/ocp3-installer'
os.system(command)
command = 'cp -f ~/.ssh/id_rsa ssh_key/ocp-installer'
os.system(command)
# make sure the ssh keys have the proper permissions
command = 'chmod 600 ssh_key/ocp-installer'
os.system(command)
# remove any cached facts to prevent stale data during a re-run
command = 'rm -rf .ansible/cached_facts'
os.system(command)
tags = ",".join(tags)
if clean is True:
# recreate inventory with added nodes to clean up
tags = 'clean'
command = './ocp-on-vmware --create_inventory --no-confirm'
os.system(command)
if tag:
tags = tag
#if local:
#command='ansible-playbook'
#else:
# command='docker run -t --rm --volume `pwd`:/opt/ansible:z -v ~/.ssh:/root/.ssh:z -v /tmp:/tmp:z --net=host ansible:2.2-latest'
command = 'ansible-playbook'
command = command + ' --extra-vars "@./infrastructure.json" --tags %s -e \'vcenter_host=%s \
vcenter_username=%s \
vcenter_password=%s \
vcenter_template_name=%s \
vcenter_folder=%s \
vcenter_cluster=%s \
vcenter_datacenter=%s \
vcenter_resource_pool=%s \
public_hosted_zone=%s \
app_dns_prefix=%s \
vm_dns=%s \
vm_gw=%s \
vm_netmask=%s \
vm_network=%s \
wildcard_zone=%s \
console_port=%s \
deployment_type=%s \
openshift_vers=%s \
rhel_subscription_user=%s \
rhel_subscription_pass=%s \
rhel_subscription_server=%s \
rhel_subscription_pool="%s" \
openshift_sdn=%s \
containerized=%s \
container_storage=%s \
openshift_hosted_metrics_deploy=%s \
lb_host=%s \
nfs_host=%s \
nfs_registry_mountpoint=%s \' %s' % (
tags, vcenter_host, vcenter_username, vcenter_password,
vcenter_template_name, vcenter_folder, vcenter_cluster,
vcenter_datacenter, vcenter_resource_pool, public_hosted_zone,
app_dns_prefix, vm_dns, vm_gw, vm_netmask, vm_network,
wildcard_zone, console_port, deployment_type, openshift_vers,
rhel_subscription_user, rhel_subscription_pass,
rhel_subscription_server, rhel_subscription_pool, openshift_sdn,
containerized, container_storage, openshift_hosted_metrics_deploy,
lb_host, nfs_host, nfs_registry_mountpoint, playbook)
if verbose > 0:
command += " -" + "".join(['v'] * verbose)
click.echo('We are running: %s' % command)
status = os.system(command)
if os.WIFEXITED(status) and os.WEXITSTATUS(status) != 0:
return os.WEXITSTATUS(status)
def _parse_args(self, args_str):
'''
Eg. python provision_control.py --host_name a3s30.contrail.juniper.net
--host_ip 10.1.1.1
--router_asn 64512
--enable_4byte_as
--ibgp_auto_mesh|--no_ibgp_auto_mesh
--api_server_ip 127.0.0.1
--api_server_port 8082
--api_server_use_ssl False
--oper <add | del>
--md5 <key value>|None(optional)
--bgp_server_port <port>|None(optional)
--local_autonomous_system <ASN value>|None(optional)
--graceful_restart_time 300
--long_lived_graceful_restart_time 300
--end_of_rib_timeout 300
--set_graceful_restart_parameters False
--graceful_restart_bgp_helper_enable False
--graceful_restart_xmpp_helper_enable False
--graceful_restart_enable False
'''
# Source any specified config/ini file
# Turn off help, so we print all options in response to -h
conf_parser = argparse.ArgumentParser(add_help=False)
conf_parser.add_argument("-c",
"--conf_file",
help="Specify config file",
metavar="FILE")
args, remaining_argv = conf_parser.parse_known_args(args_str.split())
defaults = {
'router_asn': '64512',
'enable_4byte_as': None,
'bgp_server_port': 179,
'local_autonomous_system': None,
'ibgp_auto_mesh': None,
'api_server_ip': '127.0.0.1',
'api_server_port': '8082',
'api_server_use_ssl': False,
'oper': None,
'admin_user': None,
'admin_password': None,
'admin_tenant_name': None,
'md5': None,
'graceful_restart_time': 300,
'long_lived_graceful_restart_time': 300,
'end_of_rib_timeout': 300,
'graceful_restart_bgp_helper_enable': False,
'graceful_restart_xmpp_helper_enable': False,
'graceful_restart_enable': False,
'set_graceful_restart_parameters': False,
'sub_cluster_name': None,
'peer_list': None,
}
if args.conf_file:
config = configparser.SafeConfigParser()
config.read([args.conf_file])
defaults.update(dict(config.items("DEFAULTS")))
# Override with CLI options
# Don't surpress add_help here so it will handle -h
parser = argparse.ArgumentParser(
# Inherit options from config_parser
parents=[conf_parser],
# print script description with -h/--help
description=__doc__,
# Don't mess with format of description
formatter_class=argparse.RawDescriptionHelpFormatter,
)
parser.set_defaults(**defaults)
parser.add_argument("--host_name",
help="hostname name of control-node")
parser.add_argument("--host_ip", help="IP address of control-node")
parser.add_argument("--router_asn",
help="AS Number the control-node is in",
required=True)
parser.add_argument("--enable_4byte_as",
help="If set, AS Number can be 4 byte wide",
dest='enable_4byte_as',
action='store_true')
parser.add_argument("--bgp_server_port",
help="BGP server port number (Default: 179)")
parser.add_argument(
"--local_autonomous_system",
help=
"Local autonomous-system number used to peer contrail-control bgp speakers across different geographic locations"
)
parser.add_argument("--address_families",
help="Address family list",
choices=[
"route-target", "inet-vpn", "e-vpn", "erm-vpn",
"inet6-vpn"
],
nargs="*",
default=[])
parser.add_argument("--md5", help="Md5 config for the node")
parser.add_argument("--ibgp_auto_mesh",
help="Create iBGP mesh automatically",
dest='ibgp_auto_mesh',
action='store_true')
parser.add_argument("--no_ibgp_auto_mesh",
help="Don't create iBGP mesh automatically",
dest='ibgp_auto_mesh',
action='store_false')
parser.add_argument("--api_server_port", help="Port of api server")
parser.add_argument("--api_server_use_ssl",
help="Use SSL to connect with API server")
parser.add_argument("--oper",
help="Provision operation to be done(add or del)")
parser.add_argument("--admin_user", help="Name of keystone admin user")
parser.add_argument("--admin_password",
help="Password of keystone admin user")
parser.add_argument("--admin_tenant_name",
help="Tenamt name for keystone admin user")
parser.add_argument("--graceful_restart_time",
help="Graceful Restart Time in seconds (0..4095)",
type=self.gr_time_type,
default=300,
required=False)
parser.add_argument(
"--long_lived_graceful_restart_time",
help="Long Lived Graceful Restart Time in seconds (0..16777215)",
type=self.llgr_time_type,
default=300,
required=False)
parser.add_argument("--end_of_rib_timeout",
help="EndOfRib timeout value in seconds (0..4095)",
type=self.gr_time_type,
default=300,
required=False)
parser.add_argument("--graceful_restart_bgp_helper_enable",
action='store_true',
help="Enable helper mode for BGP graceful restart")
parser.add_argument(
"--graceful_restart_xmpp_helper_enable",
action='store_true',
help="Enable helper mode for XMPP graceful restart")
parser.add_argument("--graceful_restart_enable",
action='store_true',
help="Enable Graceful Restart")
parser.add_argument("--set_graceful_restart_parameters",
action='store_true',
help="Set Graceful Restart Parameters")
parser.add_argument("--sub_cluster_name",
help="sub cluster to associate to",
required=False)
parser.add_argument("--peer_list",
help="list of control node names to peer",
required=False)
group = parser.add_mutually_exclusive_group(required=True)
group.add_argument("--api_server_ip",
help="IP address of api server",
nargs='+',
type=str)
group.add_argument("--use_admin_api",
default=False,
help="Connect to local api-server on admin port",
action="store_true")
self._args = parser.parse_args(remaining_argv)
def parse_args(argv, ipython_mode=False):
"""Parse list of arguments.
If a config file is provided (via -c), it will read in the
supplied options and overwrite any global defaults.
All other directly supplied arguments will overwrite the config
file settings.
Arguments:
* argv : list of strings
List of arguments, e.g. ['-c', 'my.conf']
* ipython_mode : bool <default=True>
Whether to parse IPython specific arguments
like --local_namespace
Notes:
Default settings can be found in zipline.utils.cli.DEFAULTS.
"""
# Parse any conf_file specification
# We make this parser with add_help=False so that
# it doesn't parse -h and print help.
conf_parser = argparse.ArgumentParser(
# Don't mess with format of description
formatter_class=argparse.RawDescriptionHelpFormatter,
# Turn off help, so we print all options in response to -h
add_help=False)
conf_parser.add_argument("-c",
"--conf_file",
help="Specify config file",
metavar="FILE")
args, remaining_argv = conf_parser.parse_known_args(argv)
defaults = copy(DEFAULTS)
if args.conf_file:
config = configparser.SafeConfigParser()
config.read([args.conf_file])
defaults.update(dict(config.items("Defaults")))
# Parse rest of arguments
# Don't suppress add_help here so it will handle -h
parser = argparse.ArgumentParser(
# Inherit options from config_parser
description="Zipline version %s." % zipline.__version__,
parents=[conf_parser])
parser.set_defaults(**defaults)
parser.add_argument('--algofile', '-f')
parser.add_argument('--data-frequency', choices=('minute', 'daily'))
parser.add_argument('--start', '-s')
parser.add_argument('--end', '-e')
parser.add_argument('--capital_base')
parser.add_argument('--source', '-d', choices=('yahoo', ))
parser.add_argument('--source_time_column', '-t')
parser.add_argument('--symbols')
parser.add_argument('--output', '-o')
parser.add_argument('--metadata_path', '-m')
parser.add_argument('--metadata_index', '-x')
parser.add_argument('--print-algo',
'-p',
dest='print_algo',
action='store_true')
parser.add_argument('--no-print-algo',
'-q',
dest='print_algo',
action='store_false')
if ipython_mode:
parser.add_argument('--local_namespace', action='store_true')
args = parser.parse_args(remaining_argv)
return (vars(args))
def read_settings(self):
''' Reads the settings from the ec2.ini file '''
if six.PY2:
config = configparser.SafeConfigParser()
else:
config = configparser.ConfigParser()
ec2_default_ini_path = os.path.join(
os.path.dirname(os.path.realpath(__file__)), 'ec2.ini')
ec2_ini_path = os.environ.get('EC2_INI_PATH', ec2_default_ini_path)
config.read(ec2_ini_path)
# is eucalyptus?
self.eucalyptus_host = None
self.eucalyptus = False
if config.has_option('ec2', 'eucalyptus'):
self.eucalyptus = config.getboolean('ec2', 'eucalyptus')
if self.eucalyptus and config.has_option('ec2', 'eucalyptus_host'):
self.eucalyptus_host = config.get('ec2', 'eucalyptus_host')
# Regions
self.regions = []
configRegions = config.get('ec2', 'regions')
configRegions_exclude = config.get('ec2', 'regions_exclude')
if (configRegions == 'all'):
if self.eucalyptus_host:
self.regions.append(
boto.connect_euca(host=self.eucalyptus_host).region.name)
else:
for regionInfo in ec2.regions():
if regionInfo.name not in configRegions_exclude:
self.regions.append(regionInfo.name)
else:
self.regions = configRegions.split(",")
# Destination addresses
self.destination_variable = config.get('ec2', 'destination_variable')
self.vpc_destination_variable = config.get('ec2',
'vpc_destination_variable')
# Route53
self.route53_enabled = config.getboolean('ec2', 'route53')
self.route53_excluded_zones = []
if config.has_option('ec2', 'route53_excluded_zones'):
self.route53_excluded_zones.extend(
config.get('ec2', 'route53_excluded_zones', '').split(','))
# Include RDS instances?
self.rds_enabled = True
if config.has_option('ec2', 'rds'):
self.rds_enabled = config.getboolean('ec2', 'rds')
# Return all EC2 and RDS instances (if RDS is enabled)
if config.has_option('ec2', 'all_instances'):
self.all_instances = config.getboolean('ec2', 'all_instances')
else:
self.all_instances = False
if config.has_option('ec2', 'all_rds_instances') and self.rds_enabled:
self.all_rds_instances = config.getboolean('ec2',
'all_rds_instances')
else:
self.all_rds_instances = False
# Cache related
cache_dir = os.path.expanduser(config.get('ec2', 'cache_path'))
if not os.path.exists(cache_dir):
os.makedirs(cache_dir)
self.cache_path_cache = cache_dir + "/ansible-ec2.cache"
self.cache_path_index = cache_dir + "/ansible-ec2.index"
self.cache_max_age = config.getint('ec2', 'cache_max_age')
# Configure nested groups instead of flat namespace.
if config.has_option('ec2', 'nested_groups'):
self.nested_groups = config.getboolean('ec2', 'nested_groups')
else:
self.nested_groups = False
# Configure which groups should be created.
group_by_options = [
'group_by_instance_id',
'group_by_region',
'group_by_availability_zone',
'group_by_ami_id',
'group_by_instance_type',
'group_by_key_pair',
'group_by_vpc_id',
'group_by_security_group',
'group_by_tag_keys',
'group_by_tag_none',
'group_by_route53_names',
'group_by_rds_engine',
'group_by_rds_parameter_group',
]
for option in group_by_options:
if config.has_option('ec2', option):
setattr(self, option, config.getboolean('ec2', option))
else:
setattr(self, option, True)
# Do we need to just include hosts that match a pattern?
try:
pattern_include = config.get('ec2', 'pattern_include')
if pattern_include and len(pattern_include) > 0:
self.pattern_include = re.compile(pattern_include)
else:
self.pattern_include = None
except configparser.NoOptionError as e:
self.pattern_include = None
# Do we need to exclude hosts that match a pattern?
try:
pattern_exclude = config.get('ec2', 'pattern_exclude')
if pattern_exclude and len(pattern_exclude) > 0:
self.pattern_exclude = re.compile(pattern_exclude)
else:
self.pattern_exclude = None
except configparser.NoOptionError as e:
self.pattern_exclude = None
# Instance filters (see boto and EC2 API docs). Ignore invalid filters.
self.ec2_instance_filters = defaultdict(list)
if config.has_option('ec2', 'instance_filters'):
for instance_filter in config.get('ec2', 'instance_filters',
'').split(','):
instance_filter = instance_filter.strip()
if not instance_filter or '=' not in instance_filter:
continue
filter_key, filter_value = [
x.strip() for x in instance_filter.split('=', 1)
]
if not filter_key:
continue
self.ec2_instance_filters[filter_key].append(filter_value)
def read_configuration(path):
cfg = configparser.SafeConfigParser()
cfg.read(path)
cfgdir = os.path.dirname(path)
result = {}
for fixed, keywords in options:
if 'dest' in keywords:
dest = keywords['dest']
else:
for opt in fixed:
if opt.startswith('--'):
dest = opt[2:].replace('-', '_')
else:
assert len(opt) == 2
dest = opt[1:]
if dest in 'tags_help lang_list lang_help version'.split():
continue
if not cfg.has_option('behave', dest):
continue
action = keywords.get('action', 'store')
if action == 'store':
use_raw_value = dest in raw_value_options
result[dest] = cfg.get('behave', dest, raw=use_raw_value)
elif action in ('store_true', 'store_false'):
result[dest] = cfg.getboolean('behave', dest)
elif action == 'append':
if dest == 'userdata_defines':
continue # -- SKIP-CONFIGFILE: Command-line only option.
result[dest] = \
[s.strip() for s in cfg.get('behave', dest).splitlines()]
else:
raise ValueError('action "%s" not implemented' % action)
if 'format' in result:
# -- OPTIONS: format/outfiles are coupled in configuration file.
formatters = result['format']
formatter_size = len(formatters)
outfiles = result.get('outfiles', [])
outfiles_size = len(outfiles)
if outfiles_size < formatter_size:
for formatter_name in formatters[outfiles_size:]:
outfile = "%s.output" % formatter_name
outfiles.append(outfile)
result['outfiles'] = outfiles
elif len(outfiles) > formatter_size:
print("CONFIG-ERROR: Too many outfiles (%d) provided." %
outfiles_size)
result['outfiles'] = outfiles[:formatter_size]
for paths_name in ('paths', 'outfiles'):
if paths_name in result:
# -- Evaluate relative paths relative to configfile location.
# NOTE: Absolute paths are preserved by os.path.join().
paths = result[paths_name]
result[paths_name] = \
[os.path.normpath(os.path.join(cfgdir, p)) for p in paths]
result['userdata'] = {}
if cfg.has_section('behave.userdata'):
result['userdata'].update(cfg.items('behave.userdata'))
return result
def read_timing_mode_waveform(mode_ini, iq_dir=None):
"""Read waveforms in timing mode format.
This class supports the loading of a timing mode. The mode configuration
file specifies the needed IQ data for each transmit sweep in the mode
sequence. This is then used to load and RF waveform IQ data.
Parameters
----------
mode_ini : str
Path to mode INI file. The '.iq.ini' extension can optionally be left
off.
iq_dir : str
Path to directory with binary IQ sweep files. If None, defaults to
'`os.path.dirname(mode_ini)`/../iq'.
Returns
-------
dict
Dictionary with entries::
waveform : np.complex64 array
Waveform (sequence) array.
samplerate : float
Waveform sample rate in Hz.
center_freq : float
Default waveform center frequency in Hz.
"""
# make sure mode_ini exists as named, or add extension
mode_ini = os.path.abspath(mode_ini)
if not os.path.isfile(mode_ini):
mode_ini = mode_ini + ".iq.ini"
# parse mode INI file (so we can fail early if it's bad)
cparser = configparser.SafeConfigParser()
try:
cparser.read(mode_ini)
except configparser.MissingSectionHeaderError:
raise ValueError("Cannot read timing mode INI file.")
if not cparser.has_section("mode"):
raise ValueError("Cannot read timing mode INI file.")
# get mode name and default iq directory if unspecified
mode_dir = os.path.dirname(mode_ini)
base_dir = os.path.dirname(mode_dir)
if iq_dir is None:
iq_dir = os.path.join(base_dir, "iq")
# extract waveform characteristics and default frequency from mode acronym
acronym = cparser.get("mode", "name")
name_segs = acronym.split("_")
# grp = name_segs[0]
# type_letter = name_segs[1]
# ipp_ms = int(name_segs[2])
# pulse_len_ms = int(name_segs[3])
if name_segs[4].startswith("f"):
if len(name_segs) > 5 and name_segs[5].startswith("f"):
# desc = 'chirp'
f0 = 1e5 * int(name_segs[4][1:])
f1 = 1e5 * int(name_segs[5][1:])
center_freq = (f0 + f1) / 2
else:
# desc = 'unc'
center_freq = 1e5 * int(name_segs[4][1:])
else:
# baud_length_us = int(name_segs[4])
# desc = name_segs[5]
center_freq = 1e5 * int(name_segs[6][1:])
# read sample rate from INI file
chip_ns = int(cparser.get("mode", "chip_length"))
samplerate_frac = Fraction(1000000000, chip_ns)
samplerate = float(samplerate_frac)
# now get list of iq data files from the mode sweep string
sweep_seq = cparser.get("mode", "sweeps").strip("[]").split(",")
sweep_files = [os.path.join(iq_dir, s + ".iq.dat") for s in sweep_seq]
# read the waveforms from the binary IQ files, stored as interleaved 16-bit
# integers
# keep each as a separate array initially since we may want to introduce
# an IPP between each
waveforms_int = [np.fromfile(f, dtype=np.int16) for f in sweep_files]
# cast to complex64 and scale integer range to [0, 1]
waveforms = [(w_i[0::2] + 1j * w_i[1::2]) / (2**15 - 1)
for w_i in waveforms_int]
# join waveform sequence into single waveform assuming no extra IPP
waveform = np.concatenate(waveforms)
return dict(waveform=waveform,
center_freq=center_freq,
samplerate=samplerate)
def read_settings(self):
''' Reads the settings from the vmware_inventory.ini file '''
scriptbasename = __file__
scriptbasename = os.path.basename(scriptbasename)
scriptbasename = scriptbasename.replace('.py', '')
defaults = {
'vmware': {
'server':
'',
'port':
443,
'username':
'',
'password':
'',
'ini_path':
os.path.join(os.path.dirname(__file__),
'%s.ini' % scriptbasename),
'cache_name':
'ansible-vmware',
'cache_path':
'~/.ansible/tmp',
'cache_max_age':
3600,
'max_object_level':
1,
'alias_pattern':
'{{ config.name + "_" + config.uuid }}',
'host_pattern':
'{{ guest.ipaddress }}',
'host_filters':
'{{ guest.gueststate == "running" }}',
'groupby_patterns':
'{{ guest.guestid }},{{ "templates" if config.template else "guests"}}',
'lower_var_keys':
True
}
}
if six.PY3:
config = configparser.ConfigParser()
else:
config = configparser.SafeConfigParser()
# where is the config?
vmware_ini_path = os.environ.get('VMWARE_INI_PATH',
defaults['vmware']['ini_path'])
vmware_ini_path = os.path.expanduser(
os.path.expandvars(vmware_ini_path))
config.read(vmware_ini_path)
# apply defaults
for k, v in defaults['vmware'].iteritems():
if not config.has_option('vmware', k):
config.set('vmware', k, str(v))
# where is the cache?
self.cache_dir = os.path.expanduser(config.get('vmware', 'cache_path'))
if self.cache_dir and not os.path.exists(self.cache_dir):
os.makedirs(self.cache_dir)
# set the cache filename and max age
cache_name = config.get('vmware', 'cache_name')
self.cache_path_cache = self.cache_dir + "/%s.cache" % cache_name
self.cache_max_age = int(config.getint('vmware', 'cache_max_age'))
# mark the connection info
self.server = os.environ.get('VMWARE_SERVER',
config.get('vmware', 'server'))
self.port = int(
os.environ.get('VMWARE_PORT', config.get('vmware', 'port')))
self.username = os.environ.get('VMWARE_USERNAME',
config.get('vmware', 'username'))
self.password = os.environ.get('VMWARE_PASSWORD',
config.get('vmware', 'password'))
# behavior control
self.maxlevel = int(config.get('vmware', 'max_object_level'))
self.lowerkeys = config.get('vmware', 'lower_var_keys')
if type(self.lowerkeys) != bool:
if str(self.lowerkeys).lower() in ['yes', 'true', '1']:
self.lowerkeys = True
else:
self.lowerkeys = False
self.host_filters = list(
config.get('vmware', 'host_filters').split(','))
self.groupby_patterns = list(
config.get('vmware', 'groupby_patterns').split(','))
# save the config
self.config = config
def _load():
global SW_VERSION, nodetype, subfunctions
# Read the build.info file
build_info = '/etc/build.info'
if not os.path.isfile(build_info):
# Assume that we are in a test environment. Dirty, dirty, dirty...
SW_VERSION = 'TEST.SW.VERSION'
nodetype = 'controller'
subfunctions = ['controller']
return
# The build.info file has no section headers, which causes problems
# for ConfigParser. So we'll fake it out.
ini_str = u'[build_info]\n' + open(build_info, 'r').read()
ini_fp = io.StringIO(ini_str)
config = configparser.SafeConfigParser()
config.readfp(ini_fp)
try:
value = str(config.get('build_info', 'SW_VERSION'))
SW_VERSION = value.strip('"')
except configparser.Error:
logging.exception("Failed to read SW_VERSION from /etc/build.info")
return False
# Read the platform.conf file
# The platform.conf file has no section headers, which causes problems
# for ConfigParser. So we'll fake it out.
ini_str = u'[platform_conf]\n' + open(PLATFORM_CONF_FILE, 'r').read()
ini_fp = io.StringIO(ini_str)
config.readfp(ini_fp)
try:
value = str(config.get('platform_conf', 'nodetype'))
nodetype = value
value = str(config.get('platform_conf', 'subfunction'))
subfunctions = value.split(",")
global region_config
if config.has_option('platform_conf', 'region_config'):
region_config = str(config.get('platform_conf', 'region_config'))
global region_1_name
if config.has_option('platform_conf', 'region_1_name'):
region_1_name = str(config.get('platform_conf', 'region_1_name'))
global region_2_name
if config.has_option('platform_conf', 'region_2_name'):
region_2_name = str(config.get('platform_conf', 'region_2_name'))
global vswitch_type
if config.has_option('platform_conf', 'vswitch_type'):
vswitch_type = str(config.get('platform_conf', 'vswitch_type'))
global management_interface
if config.has_option('platform_conf', 'management_interface'):
management_interface = str(
config.get('platform_conf', 'management_interface'))
global oam_interface
if config.has_option('platform_conf', 'oam_interface'):
oam_interface = str(config.get('platform_conf', 'oam_interface'))
global infrastructure_interface
if config.has_option('platform_conf', 'infrastructure_interface'):
infrastructure_interface = str(
config.get('platform_conf', 'infrastructure_interface'))
global sdn_enabled
if config.has_option('platform_conf', 'sdn_enabled'):
sdn_enabled = str(config.get('platform_conf', 'sdn_enabled'))
global host_uuid
if config.has_option('platform_conf', 'UUID'):
host_uuid = str(config.get('platform_conf', 'UUID'))
global install_uuid
if config.has_option('platform_conf', 'INSTALL_UUID'):
install_uuid = str(config.get('platform_conf', 'INSTALL_UUID'))
global system_type
if config.has_option('platform_conf', 'system_type'):
system_type = str(config.get('platform_conf', 'system_type'))
global system_mode
if config.has_option('platform_conf', 'system_mode'):
system_mode = str(config.get('platform_conf', 'system_mode'))
global security_profile
if config.has_option('platform_conf', 'security_profile'):
security_profile = str(
config.get('platform_conf', 'security_profile'))
global distributed_cloud_role
if config.has_option('platform_conf', 'distributed_cloud_role'):
distributed_cloud_role = str(
config.get('platform_conf', 'distributed_cloud_role'))
global security_feature
if config.has_option('platform_conf', 'security_feature'):
security_feature = str(
config.get('platform_conf', 'security_feature'))
global http_port
if config.has_option('platform_conf', 'http_port'):
http_port = str(config.get('platform_conf', 'http_port'))
except configparser.Error:
logging.exception("Failed to read platform.conf")
return False
def instances_to_inventory(self, instances):
''' Convert a list of vm objects into a json compliant inventory '''
inventory = self._empty_inventory()
inventory['all'] = {}
inventory['all']['hosts'] = []
last_idata = None
total = len(instances)
for idx, instance in enumerate(instances):
# make a unique id for this object to avoid vmware's
# numerous uuid's which aren't all unique.
thisid = str(uuid.uuid4())
idata = instance[1]
# Put it in the inventory
inventory['all']['hosts'].append(thisid)
inventory['_meta']['hostvars'][thisid] = idata.copy()
inventory['_meta']['hostvars'][thisid]['ansible_uuid'] = thisid
# Make a map of the uuid to the name the user wants
name_mapping = self.create_template_mapping(
inventory, self.config.get('vmware', 'alias_pattern'))
# Make a map of the uuid to the ssh hostname the user wants
host_mapping = self.create_template_mapping(
inventory, self.config.get('vmware', 'host_pattern'))
# Reset the inventory keys
for k, v in name_mapping.iteritems():
# set ansible_host (2.x)
inventory['_meta']['hostvars'][k]['ansible_host'] = host_mapping[k]
# 1.9.x backwards compliance
inventory['_meta']['hostvars'][k][
'ansible_ssh_host'] = host_mapping[k]
if k == v:
continue
# add new key
inventory['all']['hosts'].append(v)
inventory['_meta']['hostvars'][v] = inventory['_meta']['hostvars'][
k]
# cleanup old key
inventory['all']['hosts'].remove(k)
inventory['_meta']['hostvars'].pop(k, None)
self.debugl('PREFILTER_HOSTS:')
for i in inventory['all']['hosts']:
self.debugl(i)
# Create special host filter removing all the hosts which
# are not related to the configured cluster.
if six.PY3:
ocp_config = configparser.ConfigParser()
else:
ocp_config = configparser.SafeConfigParser()
default_ocp_config = os.path.join(os.path.dirname(__file__),
'../../../ocp-on-vmware.ini')
ocp_ini_path = os.environ.get('VMWARE_INI_PATH', default_ocp_config)
ocp_ini_path = os.path.expanduser(os.path.expandvars(ocp_ini_path))
ocp_config.read(ocp_ini_path)
cluster_id_filter = ("{{ config.annotation is not none and "
"'%s' in config.annotation }}") % ocp_config.get(
'vmware', 'cluster_id')
self.host_filters.append(cluster_id_filter)
# Apply host filters
for hf in self.host_filters:
if not hf:
continue
self.debugl('FILTER: %s' % hf)
filter_map = self.create_template_mapping(inventory,
hf,
dtype='boolean')
for k, v in filter_map.iteritems():
if not v:
# delete this host
inventory['all']['hosts'].remove(k)
inventory['_meta']['hostvars'].pop(k, None)
self.debugl('POSTFILTER_HOSTS:')
for i in inventory['all']['hosts']:
self.debugl(i)
# Create groups
for gbp in self.groupby_patterns:
groupby_map = self.create_template_mapping(inventory, gbp)
for k, v in groupby_map.iteritems():
if v not in inventory:
inventory[v] = {}
inventory[v]['hosts'] = []
if k not in inventory[v]['hosts']:
inventory[v]['hosts'].append(k)
return inventory
def run_test(testdir):
# Compile each 'input.c', using 'script.py'
# Assume success and empty stdout; compare against expected stderr, or empty if file not present
inputfiles = get_source_files(testdir)
outfile = os.path.join(testdir, 'output.o')
script_py = os.path.join(testdir, 'script.py')
out = TestStream(os.path.join(testdir, 'stdout.txt'))
err = TestStream(os.path.join(testdir, 'stderr.txt'))
cp = configparser.SafeConfigParser()
metadatapath = os.path.join(testdir, 'metadata.ini')
cp.read([metadatapath])
if cp.has_section('WhenToRun'):
if cp.has_option('WhenToRun', 'required_features'):
required_features = cp.get('WhenToRun',
'required_features').split()
for feature in required_features:
if feature not in features:
raise ValueError('%s in %s not found in %s' %
(feature, metadatapath, config_h))
if not features[feature]:
raise SkipTest('required feature %s not available in %s' %
(feature, config_h))
env = dict(os.environ)
env['LC_ALL'] = 'C'
# Generate the command-line for invoking gcc:
args = [CC]
if len(inputfiles) == 1:
args += ['-c'] # (don't run the linker)
else:
args += ['-fPIC', '-shared']
# Force LTO when there's more than one source file:
args += ['-flto', '-flto-partition=none']
if GCC_VERSION >= 4008:
# GCC 4.8 started showing the source line where the problem is,
# followed by another line showing a caret indicating column.
# This is a great usability feature, but totally breaks our "gold"
# output, so turn it off for running tests:
args += ['-fno-diagnostics-show-caret']
# Similarly, the macro expansion tracking is great for usability,
# but breaks the "gold" output, so we disable it during tests:
args += ['-ftrack-macro-expansion=0']
args += ['-o', outfile]
args += [
'-fplugin=%s' % os.path.abspath('%s.so' % PLUGIN_NAME),
'-fplugin-arg-%s-script=%s' % (PLUGIN_NAME, script_py)
]
# Force the signedness of char so that the tests have consistent
# behavior across all archs:
args += ['-fsigned-char']
# Special-case: add the python include dir (for this runtime) if the C code
# uses Python.h:
def uses_python_headers():
for inputfile in inputfiles:
with open(inputfile, 'r') as f:
code = f.read()
if '#include <Python.h>' in code:
return True
if uses_python_headers():
args += ['-I' + get_python_inc()]
# If there's a getopts.py, run it to get additional test-specific
# command-line options:
getopts_py = os.path.join(testdir, 'getopts.py')
if os.path.exists(getopts_py):
p = Popen([sys.executable, getopts_py], stdout=PIPE, stderr=PIPE)
opts_out, opts_err = p.communicate()
if six.PY3:
opts_out = opts_out.decode()
opts_err = opts_err.decode()
c = p.wait()
if c != 0:
raise CommandError()
args += opts_out.split()
# and the source files go at the end:
args += inputfiles
if uses_dg_directives(inputfiles):
dg_context = DgContext(inputfiles)
dg_context.echo_results = True
for inputfile in inputfiles:
dg_context.parse_directives(inputfile)
args += dg_context.get_args()
else:
dg_context = None
if options.show:
# Show the gcc invocation:
print(' '.join(args))
# Invoke the compiler:
p = Popen(args, env=env, stdout=PIPE, stderr=PIPE)
out.actual, err.actual = p.communicate()
if six.PY3:
out.actual = out.actual.decode()
err.actual = err.actual.decode()
#print 'out: %r' % out.actual
#print 'err: %r' % err.actual
exitcode_actual = p.wait()
if options.show:
# then the user wants to see the gcc invocation directly
sys.stdout.write(out.actual)
sys.stderr.write(err.actual)
if dg_context:
dg_context.check_result(out.actual, err.actual, exitcode_actual)
if dg_context.num_failures() > 0:
raise DejaGnuError(dg_context)
return
# Expected exit code
# By default, we expect success if the expected stderr is empty, and
# and failure if it's non-empty.
# This can be overridden if the test has a metadata.ini, by setting
# exitcode within the [ExpectedBehavior] section:
if err.expdata == '':
exitcode_expected = 0
else:
exitcode_expected = 1
if cp.has_section('ExpectedBehavior'):
if cp.has_option('ExpectedBehavior', 'exitcode'):
exitcode_expected = cp.getint('ExpectedBehavior', 'exitcode')
# Check exit code:
if exitcode_actual != exitcode_expected:
sys.stderr.write(out.diff('stdout'))
sys.stderr.write(err.diff('stderr'))
raise CompilationError(out.actual, err.actual, p, args)
if exitcode_expected == 0:
assert os.path.exists(outfile)
out.check_for_diff(out.actual, err.actual, p, args, 'stdout', WRITEBACK)
err.check_for_diff(out.actual, err.actual, p, args, 'stderr', WRITEBACK)
from collections import OrderedDict
import re
from oslo_config import cfg
from oslo_log import log as logging
from oslo_policy import policy
from six.moves import configparser
import glance.api.policy
from glance.common import exception
from glance.i18n import _, _LE
# NOTE(bourke): The default dict_type is collections.OrderedDict in py27, but
# we must set manually for compatibility with py26
CONFIG = configparser.SafeConfigParser(dict_type=OrderedDict)
LOG = logging.getLogger(__name__)
property_opts = [
cfg.StrOpt('property_protection_file',
help=_('The location of the property protection file.'
'This file contains the rules for property protections '
'and the roles/policies associated with it. If this '
'config value is not specified, by default, property '
'protections won\'t be enforced. If a value is '
'specified and the file is not found, then the '
'glance-api service will not start.')),
cfg.StrOpt('property_protection_rule_format',
default='roles',
choices=('roles', 'policies'),
help=_('This config value indicates whether "roles" or '
def read_settings(self):
''' Reads the settings from the packet_net.ini file '''
if six.PY3:
config = configparser.ConfigParser()
else:
config = configparser.SafeConfigParser()
packet_default_ini_path = os.path.join(
os.path.dirname(os.path.realpath(__file__)), 'packet_net.ini')
packet_ini_path = os.path.expanduser(
os.path.expandvars(
os.environ.get('PACKET_NET_INI_PATH',
packet_default_ini_path)))
config.read(packet_ini_path)
# items per page
self.items_per_page = 999
if config.has_option(ini_section, 'items_per_page'):
config.get(ini_section, 'items_per_page')
# Instance states to be gathered in inventory. Default is all of them.
packet_valid_device_states = [
'active', 'inactive', 'queued', 'provisioning'
]
self.packet_device_states = []
if config.has_option(ini_section, 'device_states'):
for device_state in config.get(ini_section,
'device_states').split(','):
device_state = device_state.strip()
if device_state not in packet_valid_device_states:
continue
self.packet_device_states.append(device_state)
else:
self.packet_device_states = packet_valid_device_states
# Cache related
cache_dir = os.path.expanduser(config.get(ini_section, 'cache_path'))
if not os.path.exists(cache_dir):
os.makedirs(cache_dir)
self.cache_path_cache = cache_dir + "/ansible-packet.cache"
self.cache_path_index = cache_dir + "/ansible-packet.index"
self.cache_max_age = config.getint(ini_section, 'cache_max_age')
# Configure nested groups instead of flat namespace.
if config.has_option(ini_section, 'nested_groups'):
self.nested_groups = config.getboolean(ini_section,
'nested_groups')
else:
self.nested_groups = False
# Replace dash or not in group names
if config.has_option(ini_section, 'replace_dash_in_groups'):
self.replace_dash_in_groups = config.getboolean(
ini_section, 'replace_dash_in_groups')
else:
self.replace_dash_in_groups = True
# Configure which groups should be created.
group_by_options = [
'group_by_device_id',
'group_by_facility',
'group_by_project',
'group_by_operating_system',
'group_by_plan_type',
'group_by_tags',
'group_by_tag_none',
]
for option in group_by_options:
if config.has_option(ini_section, option):
setattr(self, option, config.getboolean(ini_section, option))
else:
setattr(self, option, True)
# Do we need to just include hosts that match a pattern?
try:
pattern_include = config.get(ini_section, 'pattern_include')
if pattern_include and len(pattern_include) > 0:
self.pattern_include = re.compile(pattern_include)
else:
self.pattern_include = None
except configparser.NoOptionError:
self.pattern_include = None
# Do we need to exclude hosts that match a pattern?
try:
pattern_exclude = config.get(ini_section, 'pattern_exclude')
if pattern_exclude and len(pattern_exclude) > 0:
self.pattern_exclude = re.compile(pattern_exclude)
else:
self.pattern_exclude = None
except configparser.NoOptionError:
self.pattern_exclude = None
# Projects
self.projects = []
configProjects = config.get(ini_section, 'projects')
configProjects_exclude = config.get(ini_section, 'projects_exclude')
if (configProjects == 'all'):
for projectInfo in self.get_projects():
if projectInfo.name not in configProjects_exclude:
self.projects.append(projectInfo.name)
else:
self.projects = configProjects.split(",")
def submit(self,
job=None,
no_batch=False,
prereq=None,
allow_fail=False,
resubmit=False,
resubmit_immediate=False,
skip_pnl=False,
mail_user=None,
mail_type=None,
batch_args=None):
if resubmit_immediate and self.get_value("MACH") in ['mira', 'cetus']:
logger.warning(
"resubmit_immediate does not work on Mira/Cetus, submitting normally"
)
resubmit_immediate = False
if self.get_value("TEST"):
caseroot = self.get_value("CASEROOT")
casebaseid = self.get_value("CASEBASEID")
# This should take care of the race condition where the submitted job
# begins immediately and tries to set RUN phase. We proactively assume
# a passed SUBMIT phase. If this state is already PASS, don't set it again
# because then we'll lose RUN phase info if it's there. This info is important
# for system_tests_common to know if it needs to reinitialize the test or not.
with TestStatus(test_dir=caseroot, test_name=casebaseid) as ts:
phase_status = ts.get_status(SUBMIT_PHASE)
if phase_status != TEST_PASS_STATUS:
ts.set_status(SUBMIT_PHASE, TEST_PASS_STATUS)
# If this is a resubmit check the hidden file .submit_options for
# any submit options used on the original submit and use them again
caseroot = self.get_value("CASEROOT")
submit_options = os.path.join(caseroot, ".submit_options")
if resubmit and os.path.exists(submit_options):
config = configparser.SafeConfigParser()
config.read(submit_options)
if not skip_pnl and config.has_option('SubmitOptions', 'skip_pnl'):
skip_pnl = config.getboolean('SubmitOptions', 'skip_pnl')
if mail_user is None and config.has_option('SubmitOptions',
'mail_user'):
mail_user = config.get('SubmitOptions', 'mail_user')
if mail_type is None and config.has_option('SubmitOptions',
'mail_type'):
mail_type = str(config.get('SubmitOptions',
'mail_type')).split(',')
if batch_args is None and config.has_option('SubmitOptions',
'batch_args'):
batch_args = config.get('SubmitOptions', 'batch_args')
try:
functor = lambda: _submit(self,
job=job,
no_batch=no_batch,
prereq=prereq,
allow_fail=allow_fail,
resubmit=resubmit,
resubmit_immediate=resubmit_immediate,
skip_pnl=skip_pnl,
mail_user=mail_user,
mail_type=mail_type,
batch_args=batch_args)
run_and_log_case_status(
functor,
"case.submit",
caseroot=caseroot,
custom_success_msg_functor=verbatim_success_msg)
except:
# If something failed in the batch system, make sure to mark
# the test as failed if we are running a test.
if self.get_value("TEST"):
with TestStatus(test_dir=caseroot, test_name=casebaseid) as ts:
ts.set_status(SUBMIT_PHASE, TEST_FAIL_STATUS)
raise
def read_settings(self):
''' Reads the settings from the vmware_inventory.ini file '''
scriptbasename = __file__
scriptbasename = os.path.basename(scriptbasename)
scriptbasename = scriptbasename.replace('.py', '')
defaults = {'vmware': {
'server': '',
'port': 443,
'username': '',
'password': '',
'validate_certs': True,
'ini_path': os.path.join(os.path.dirname(__file__), '%s.yml' % scriptbasename),
#'ini_path': os.path.join(os.path.dirname(__file__), '../group_vars/vmware_inventory.ini'),
'cache_name': 'ansible-vmware',
'cache_path': '~/.ansible/tmp',
'cache_max_age': 3600,
'max_object_level': 1,
'skip_keys': 'declaredalarmstate,'
'disabledmethod,'
'dynamicproperty,'
'dynamictype,'
'environmentbrowser,'
'managedby,'
'parent,'
'childtype,'
'resourceconfig',
'alias_pattern': '{{ config.name + "_" + config.uuid }}',
'host_pattern': '{{ guest.ipaddress }}',
'host_filters': '{{ runtime.powerstate == "poweredOn" }}',
'groupby_patterns': '{{ guest.guestid }},{{ "templates" if config.template else "guests"}}',
'lower_var_keys': True,
'custom_field_group_prefix': 'vmware_tag_',
'groupby_custom_field_excludes': '',
'groupby_custom_field': False}
}
if PY3:
config = configparser.ConfigParser()
else:
config = configparser.SafeConfigParser()
# where is the config?
vmware_ini_path = os.environ.get('VMWARE_INI_PATH', defaults['vmware']['ini_path'])
vmware_ini_path = os.path.expanduser(os.path.expandvars(vmware_ini_path))
config.read(vmware_ini_path)
if 'vmware' not in config.sections():
config.add_section('vmware')
# apply defaults
for k, v in defaults['vmware'].items():
if not config.has_option('vmware', k):
config.set('vmware', k, str(v))
# where is the cache?
self.cache_dir = os.path.expanduser(config.get('vmware', 'cache_path'))
if self.cache_dir and not os.path.exists(self.cache_dir):
os.makedirs(self.cache_dir)
# set the cache filename and max age
cache_name = config.get('vmware', 'cache_name')
self.cache_path_cache = self.cache_dir + "/%s.cache" % cache_name
self.debugl('cache path is %s' % self.cache_path_cache)
self.cache_max_age = int(config.getint('vmware', 'cache_max_age'))
# mark the connection info
self.server = os.environ.get('VMWARE_SERVER', config.get('vmware', 'server'))
self.debugl('server is %s' % self.server)
self.port = int(os.environ.get('VMWARE_PORT', config.get('vmware', 'port')))
self.username = os.environ.get('VMWARE_USERNAME', config.get('vmware', 'username'))
self.debugl('username is %s' % self.username)
self.password = os.environ.get('VMWARE_PASSWORD', config.get('vmware', 'password', raw=True))
self.validate_certs = os.environ.get('VMWARE_VALIDATE_CERTS', config.get('vmware', 'validate_certs'))
if self.validate_certs in ['no', 'false', 'False', False]:
self.validate_certs = False
self.debugl('cert validation is %s' % self.validate_certs)
# behavior control
self.maxlevel = int(config.get('vmware', 'max_object_level'))
self.debugl('max object level is %s' % self.maxlevel)
self.lowerkeys = config.get('vmware', 'lower_var_keys')
if type(self.lowerkeys) != bool:
if str(self.lowerkeys).lower() in ['yes', 'true', '1']:
self.lowerkeys = True
else:
self.lowerkeys = False
self.debugl('lower keys is %s' % self.lowerkeys)
self.skip_keys = list(config.get('vmware', 'skip_keys').split(','))
self.debugl('skip keys is %s' % self.skip_keys)
temp_host_filters = list(config.get('vmware', 'host_filters').split('}},'))
for host_filter in temp_host_filters:
host_filter = host_filter.rstrip()
if host_filter != "":
if not host_filter.endswith("}}"):
host_filter += "}}"
self.host_filters.append(host_filter)
self.debugl('host filters are %s' % self.host_filters)
temp_groupby_patterns = list(config.get('vmware', 'groupby_patterns').split('}},'))
for groupby_pattern in temp_groupby_patterns:
groupby_pattern = groupby_pattern.rstrip()
if groupby_pattern != "":
if not groupby_pattern.endswith("}}"):
groupby_pattern += "}}"
self.groupby_patterns.append(groupby_pattern)
self.debugl('groupby patterns are %s' % self.groupby_patterns)
temp_groupby_custom_field_excludes = config.get('vmware', 'groupby_custom_field_excludes')
self.groupby_custom_field_excludes = [x.strip('"') for x in [y.strip("'") for y in temp_groupby_custom_field_excludes.split(",")]]
self.debugl('groupby exclude strings are %s' % self.groupby_custom_field_excludes)
# Special feature to disable the brute force serialization of the
# virtual machine objects. The key name for these properties does not
# matter because the values are just items for a larger list.
if config.has_section('properties'):
self.guest_props = []
for prop in config.items('properties'):
self.guest_props.append(prop[1])
# save the config
self.config = config
cfg.StrOpt('swift_store_config_file',
secret=True,
help=_('The config file that has the swift account(s)'
'configs.')),
]
_config_defaults = {
'user_domain_id': 'default',
'user_domain_name': None,
'project_domain_id': 'default',
'project_domain_name': None
}
# NOTE(bourke): The default dict_type is collections.OrderedDict in py27, but
# we must set manually for compatibility with py26
CONFIG = configparser.SafeConfigParser(defaults=_config_defaults,
dict_type=OrderedDict)
LOG = logging.getLogger(__name__)
def is_multiple_swift_store_accounts_enabled(conf):
if conf.glance_store.swift_store_config_file is None:
return False
return True
class SwiftParams(object):
def __init__(self, conf):
self.conf = conf
if is_multiple_swift_store_accounts_enabled(self.conf):
self.params = self._load_config()
else:
def read_ini_settings(self):
''' Read ini file settings '''
scriptbasename = "ocp-on-vmware"
defaults = {
'vmware': {
'ini_path':
os.path.join(os.path.dirname(__file__),
'%s.ini' % scriptbasename),
'console_port':
'8443',
'container_storage':
'none',
'container_storage_size':
'300',
'container_storage_disk_type':
'eagerZeroedThick',
'deployment_type':
'openshift-enterprise',
'openshift_vers':
'v3_4',
'vcenter_username':
'******',
'vcenter_template_name':
'ocp-server-template-2.0.2',
'vcenter_folder':
'ocp',
'vcenter_resource_pool':
'/Resources/OCP3',
'app_dns_prefix':
'apps',
'vm_network':
'VM Network',
'rhel_subscription_pool':
'Red Hat OpenShift Container Platform, Premium*',
'openshift_sdn':
'redhat/openshift-ovs-subnet',
'byo_lb':
'no',
'lb_host':
'haproxy-',
'byo_nfs':
'no',
'nfs_host':
'nfs-0',
'nfs_registry_mountpoint':
'/exports',
'master_nodes':
'3',
'infra_nodes':
'2',
'app_nodes':
'3',
'storage_nodes':
'0',
'vm_ipaddr_start':
'',
'vm_ipaddr_allocation_type':
'static',
'ocp_hostname_prefix':
'',
'auth_type':
'ldap',
'ldap_user':
'******',
'ldap_user_password':
'',
'node_type':
self.args.node_type,
'node_number':
self.args.node_number,
'tag':
self.args.tag,
'ldap_fqdn':
''
}
}
if six.PY3:
config = configparser.ConfigParser()
else:
config = configparser.SafeConfigParser()
# where is the config?
vmware_ini_path = os.environ.get('VMWARE_INI_PATH',
defaults['vmware']['ini_path'])
vmware_ini_path = os.path.expanduser(
os.path.expandvars(vmware_ini_path))
config.read(vmware_ini_path)
# apply defaults
for k, v in defaults['vmware'].iteritems():
if not config.has_option('vmware', k):
config.set('vmware', k, str(v))
self.console_port = config.get('vmware', 'console_port')
self.cluster_id = config.get('vmware', 'cluster_id')
self.container_storage = config.get('vmware', 'container_storage')
self.container_storage_size = config.get('vmware',
'container_storage_size')
self.container_storage_disk_type = config.get(
'vmware', 'container_storage_disk_type')
self.deployment_type = config.get('vmware', 'deployment_type')
self.openshift_vers = config.get('vmware', 'openshift_vers')
self.vcenter_host = config.get('vmware', 'vcenter_host')
self.vcenter_username = config.get('vmware', 'vcenter_username')
self.vcenter_password = config.get('vmware', 'vcenter_password')
self.vcenter_template_name = config.get('vmware',
'vcenter_template_name')
self.vcenter_folder = config.get('vmware', 'vcenter_folder')
self.vcenter_datastore = config.get('vmware', 'vcenter_datastore')
self.vcenter_datacenter = config.get('vmware', 'vcenter_datacenter')
self.vcenter_cluster = config.get('vmware', 'vcenter_cluster')
self.vcenter_datacenter = config.get('vmware', 'vcenter_datacenter')
self.vcenter_resource_pool = config.get('vmware',
'vcenter_resource_pool')
self.dns_zone = config.get('vmware', 'dns_zone')
self.app_dns_prefix = config.get('vmware', 'app_dns_prefix')
self.vm_dns = config.get('vmware', 'vm_dns')
self.vm_gw = config.get('vmware', 'vm_gw')
self.vm_netmask = config.get('vmware', 'vm_netmask')
self.vm_network = config.get('vmware', 'vm_network')
self.rhel_subscription_user = config.get('vmware',
'rhel_subscription_user')
self.rhel_subscription_pass = config.get('vmware',
'rhel_subscription_pass')
self.rhel_subscription_server = config.get('vmware',
'rhel_subscription_server')
self.rhel_subscription_pool = config.get('vmware',
'rhel_subscription_pool')
self.rhsm_katello_url = config.get('vmware', 'rhsm_katello_url')
self.rhsm_activation_key = config.get('vmware', 'rhsm_activation_key')
self.rhsm_org_id = config.get('vmware', 'rhsm_org_id')
self.openshift_sdn = config.get('vmware', 'openshift_sdn')
self.byo_lb = config.get('vmware', 'byo_lb')
self.lb_host = config.get('vmware', 'lb_host')
self.byo_nfs = config.get('vmware', 'byo_nfs')
self.nfs_host = config.get('vmware', 'nfs_host')
self.nfs_registry_mountpoint = config.get('vmware',
'nfs_registry_mountpoint')
self.master_nodes = config.get('vmware', 'master_nodes')
self.infra_nodes = config.get('vmware', 'infra_nodes')
self.app_nodes = config.get('vmware', 'app_nodes')
self.storage_nodes = config.get('vmware', 'storage_nodes')
self.vm_ipaddr_start = config.get('vmware', 'vm_ipaddr_start')
self.vm_ipaddr_allocation_type = config.get(
'vmware', 'vm_ipaddr_allocation_type')
self.ocp_hostname_prefix = config.get('vmware',
'ocp_hostname_prefix') or ''
self.auth_type = config.get('vmware', 'auth_type')
self.ldap_user = config.get('vmware', 'ldap_user')
self.ldap_user_password = config.get('vmware', 'ldap_user_password')
self.ldap_fqdn = config.get('vmware', 'ldap_fqdn')
self.node_type = config.get('vmware', 'node_type')
self.node_number = config.get('vmware', 'node_number')
self.tag = config.get('vmware', 'tag')
err_count = 0
if 'storage' in self.node_type:
self.node_number = 3
if self.container_storage is None:
print "Please specify crs or cns in container_storage in the %s." % vmware_ini_path
if 'crs' in self.container_storage:
self.rhel_subscription_pool = "Red Hat Gluster Storage , Standard (16 Nodes)"
self.inventory_file = "crs-inventory.json"
if 'cns' in self.container_storage:
self.inventory_file = "cns-inventory.json"
required_vars = {
'cluster_id': self.cluster_id,
'dns_zone': self.dns_zone,
'vcenter_host': self.vcenter_host,
'vcenter_password': self.vcenter_password,
'vm_ipaddr_start': self.vm_ipaddr_start,
'vm_ipaddr_allocation_type': self.vm_ipaddr_allocation_type,
'ldap_fqdn': self.ldap_fqdn,
'ldap_user_password': self.ldap_user_password,
'vm_dns': self.vm_dns,
'vm_gw': self.vm_gw,
'vm_netmask': self.vm_netmask,
'vcenter_datacenter': self.vcenter_datacenter,
}
for k, v in required_vars.items():
if v == '':
err_count += 1
print "Missing %s " % k
if required_vars['vm_ipaddr_allocation_type'] not in ('dhcp',
'static'):
err_count += 1
print(
"'vm_ipaddr_allocation_type' can take only "
"'dhcp' and 'static' values.")
if err_count > 0:
print "Please fill out the missing variables in %s " % vmware_ini_path
exit(1)
self.wildcard_zone = "%s.%s" % (self.app_dns_prefix, self.dns_zone)
self.support_nodes = 0
print 'Configured inventory values:'
for each_section in config.sections():
for (key, val) in config.items(each_section):
if 'pass' in key:
print '\t %s: ******' % (key)
else:
print '\t %s: %s' % (key, val)
print '\n'
def read_settings(self):
''' Reads the settings from the alicloud.ini file '''
config = configparser.SafeConfigParser()
if six.PY3:
config = configparser.ConfigParser()
ecs_default_ini_path = os.path.join(
os.path.dirname(os.path.realpath(__file__)), 'alicloud.ini')
ecs_ini_path = os.path.expanduser(
os.path.expandvars(
os.environ.get('ALICLOUD_INI_PATH', ecs_default_ini_path)))
config.read(ecs_ini_path)
access_key = os.environ.get(
'ALICLOUD_ACCESS_KEY',
os.environ.get('ALICLOUD_ACCESS_KEY_ID', None))
if not access_key:
access_key = self.get_option(config, 'credentials',
'alicloud_access_key')
secret_key = os.environ.get(
'ALICLOUD_SECRET_KEY',
os.environ.get('ALICLOUD_SECRET_ACCESS_KEY', None))
if not secret_key:
secret_key = self.get_option(config, 'credentials',
'alicloud_secret_key')
security_token = os.environ.get('ALICLOUD_SECURITY_TOKEN', None)
if not security_token:
security_token = self.get_option(config, 'credentials',
'alicloud_security_token')
self.credentials = {
'acs_access_key_id': access_key,
'acs_secret_access_key': secret_key,
'security_token': security_token,
}
# Regions
config_regions = self.get_option(config, 'ecs', 'regions')
if not config_regions or config_regions == 'all':
all_regions = self.connect_to_ecs(footmark.ecs,
"cn-beijing").get_all_regions()
exclude_regions = []
if self.get_option(config, 'ecs', 'regions_exclude'):
exclude_regions = [
ex.strip() for ex in self.get_option(
config, 'ecs', 'regions_exclude').split(',')
if ex.strip()
]
if all_regions and exclude_regions:
for region in all_regions:
if region.id not in exclude_regions:
self.regions.append(region.id)
else:
self.regions = config_regions.split(",")
# # Destination addresses
self.destination_variable = self.get_option(config, 'ecs',
'destination_variable', "")
self.hostname_variable = self.get_option(config, 'ecs',
'hostname_variable', "")
self.destination_format = self.get_option(config, 'ecs',
'destination_format', "")
self.destination_format_tags = self.get_option(
config, 'ecs', 'destination_format_tags', "")
# Instance states to be gathered in inventory. Default is 'running'.
ecs_valid_instance_states = [
'pending', 'running', 'starting', 'stopping', 'stopped'
]
if self.get_option(config, 'ecs', 'all_instances'):
self.ecs_instance_states.extend(ecs_valid_instance_states)
elif self.get_option(config, 'ecs', 'instance_states'):
for instance_state in self.get_option(
config, 'ecs', 'instance_states').split(","):
instance_state = instance_state.strip()
if instance_state not in ecs_valid_instance_states:
continue
self.ecs_instance_states.append(instance_state)
else:
self.ecs_instance_states.append('running')
# Cache related
cache_dir = os.path.expanduser(
self.get_option(config, 'ecs', 'cache_path'))
if not os.path.exists(cache_dir):
os.makedirs(cache_dir)
cache_name = 'ansible-alicloud'
self.cache_path_cache = cache_dir + "/%s.cache" % cache_name
self.cache_path_index = cache_dir + "/%s.index" % cache_name
self.cache_max_age = float(
self.get_option(config, 'ecs', 'cache_max_age'))
self.expand_csv_tags = self.get_option(config, 'ecs',
'expand_csv_tags')
# Configure nested groups instead of flat namespace.
self.nested_groups = self.get_option(config, 'ecs', 'nested_groups')
# Configure which groups should be created.
group_by_options = [
'group_by_instance_id', 'group_by_region',
'group_by_availability_zone', 'group_by_instance_type',
'group_by_image_id', 'group_by_vpc_id', 'group_by_vswitch_id',
'group_by_security_group', 'group_by_tag_keys', 'group_by_tag_none'
]
for option in group_by_options:
setattr(self, option, self.get_option(config, 'ecs', option))
# Do we need to just include hosts that match a pattern?
try:
pattern_include = self.get_option(config, 'ecs', 'pattern_include')
if pattern_include and len(pattern_include) > 0:
self.pattern_include = re.compile(pattern_include)
except configparser.NoOptionError:
raise
# Do we need to exclude hosts that match a pattern?
try:
pattern_exclude = self.get_option(config, 'ecs', 'pattern_exclude')
if pattern_exclude and len(pattern_exclude) > 0:
self.pattern_exclude = re.compile(pattern_exclude)
except configparser.NoOptionError:
raise
instance_filters = self.get_option(config, 'ecs', 'instance_filters')
if instance_filters and len(instance_filters) > 0:
tags = {}
for field in instance_filters.split(','):
field = field.strip()
if not field or '=' not in field:
continue
key, value = [x.strip() for x in field.split('=', 1)]
if not key:
continue
elif key.startswith("tag:"):
tags[key[4:]] = value
continue
self.ecs_instance_filters[key] = value
if tags:
self.ecs_instance_filters['instance_tags'] = tags
import sys
from oslo_config import cfg
from oslo_log import log as logging
from oslo_policy import policy
from six.moves import configparser
import glance.api.policy
from glance.common import exception
from glance.i18n import _, _LE, _LW
# SafeConfigParser was deprecated in Python 3.2
if sys.version_info >= (3, 2):
CONFIG = configparser.ConfigParser()
else:
CONFIG = configparser.SafeConfigParser()
LOG = logging.getLogger(__name__)
property_opts = [
cfg.StrOpt('property_protection_file',
help=_("""
The location of the property protection file.
Provide a valid path to the property protection file which contains
the rules for property protections and the roles/policies associated
with them.
A property protection file, when set, restricts the Glance image
properties to be created, read, updated and/or deleted by a specific
set of users that are identified by either roles or policies.
def _parse_args(self, args_str):
"""
Sample usage.
python provision_vrouter.py
--host_name a3s30.contrail.juniper.net
--host_ip 10.1.1.1
--api_server_ip 127.0.0.1
--api_server_port 8082
--api_server_use_ssl False
--oper <add | del>
[--ip_fabric_subnet 192.168.10.0/24]
[--dpdk-enabled]
[--sriov-physnets physnet1=eth0 physnet2=eth1]
"""
# Source any specified config/ini file
# Turn off help, so we print all options in response to -h
conf_parser = argparse.ArgumentParser(add_help=False)
conf_parser.add_argument("-c",
"--conf_file",
help="Specify config file",
metavar="FILE")
args, remaining_argv = conf_parser.parse_known_args(args_str.split())
defaults = {
'api_server_ip': '127.0.0.1',
'api_server_port': '8082',
'api_server_use_ssl': False,
'oper': 'add',
'control_names': [],
'router_type': None,
'dpdk_enabled': False,
'disable_vhost_vmi': False,
'enable_vhost_vmi_policy': False,
'sub_cluster_name': None,
'ip_fabric_subnet': None
}
ksopts = {
'admin_user': '******',
'admin_password': '******',
'admin_tenant_name': 'default-domain'
}
if args.conf_file:
config = configparser.SafeConfigParser()
config.read([args.conf_file])
defaults.update(dict(config.items("DEFAULTS")))
if 'KEYSTONE' in config.sections():
ksopts.update(dict(config.items("KEYSTONE")))
# Override with CLI options
# Don't surpress add_help here so it will handle -h
parser = argparse.ArgumentParser(
# Inherit options from config_parser
parents=[conf_parser],
# print script description with -h/--help
description=__doc__,
# Don't mess with format of description
formatter_class=argparse.RawDescriptionHelpFormatter,
)
defaults.update(ksopts)
parser.set_defaults(**defaults)
parser.add_argument("--host_name",
help="hostname name of compute-node",
required=True)
parser.add_argument("--host_ip",
help="IP address of compute-node",
required=True)
parser.add_argument(
"--control_names",
help="List of control-node names compute node connects to")
parser.add_argument("--api_server_port", help="Port of api server")
parser.add_argument("--api_server_use_ssl",
help="Use SSL to connect with API server")
parser.add_argument("--oper",
default='add',
help="Provision operation to be done(add or del)")
parser.add_argument("--admin_user", help="Name of keystone admin user")
parser.add_argument("--admin_password",
help="Password of keystone admin user")
parser.add_argument("--admin_tenant_name",
help="Tenamt name for keystone admin user")
parser.add_argument("--openstack_ip",
help="IP address of openstack node")
parser.add_argument(
"--router_type",
help="Type of the virtual router (tor-service-node,embedded,none)")
parser.add_argument(
"--dpdk_enabled",
action="store_true",
help="Whether forwarding mode on vrouter is DPDK based")
parser.add_argument("--disable_vhost_vmi",
action="store_true",
help="Do not create vhost0 vmi if flag is set")
parser.add_argument("--enable_vhost_vmi_policy",
action="store_true",
help="Enable vhost0 vmi policy if flag is set")
parser.add_argument("--sub_cluster_name",
help="Sub cluster this vrouter to be part of")
parser.add_argument("--ip_fabric_subnet",
help="Add the ip_fabric_subnet")
parser.add_argument("--sriov_physnets",
metavar="KEY=VALUE",
nargs='+',
action=SriovPhysNetAction,
help="physnet to vourter interface mapping")
group = parser.add_mutually_exclusive_group(required=True)
group.add_argument("--api_server_ip",
help="IP address of api server",
nargs='+',
type=str)
group.add_argument("--use_admin_api",
default=False,
help="Connect to local api-server on admin port",
action="store_true")
self._args = parser.parse_args(remaining_argv)
