def create(self,
gid,
name=None,
is_default=False,
securitygroup_rules=None):
"""
Create a securitygroup.
:param gid: ID of the group.
:param name: Name of the securitygroup.
:param is_default: Set to the default securitygroup of the group.
:param list securitygroup_rules: List of rules of the securitygroup.
"""
try:
is_default = strutils.bool_from_string(is_default, True)
except Exception:
raise exceptions.CommandError("is_default must be a boolean.")
if securitygroup_rules is not None:
if not isinstance(securitygroup_rules, list):
raise exceptions.CommandError(
"securitygroup_rules must be a list")
body = {
"securitygroup": {
"name": name,
"is_default": is_default,
"securitygrouprules": securitygroup_rules
}
}
return self._create("/groups/%s/securitygroups" % gid, body,
"securitygroup")
def create(self,
gid,
cidr,
name=None,
is_admin=False,
gateway=None,
dns_nameservers=None,
ext_router_id=None):
"""
Create a network.
:param gid: ID of the group.
:param cidr: CIDR of the new network.
:param name: Name of the new network.
:param is_admin: is_admin.
:param gateway: Gateway ip address of the new network.
:param list dns_nameservers: List of DNS servers for the new network.
:param ext_router_id: Router id the new network connect to.
"""
def _is_valid_cidr(address):
try:
netaddr.IPNetwork(address)
except netaddr.AddrFormatError:
return False
ip_segment = address.split('/')
if (len(ip_segment) <= 1 or ip_segment[1] == ''):
return False
return True
if not _is_valid_cidr(cidr):
raise exceptions.CommandError("cidr must be a CIDR.")
if is_admin:
try:
is_admin = strutils.bool_from_string(is_admin, True)
except Exception:
raise exceptions.CommandError("is_admin must be a boolean.")
if gateway and not netaddr.valid_ipv4(gateway):
raise exceptions.CommandError("gateway must be a IP address")
if dns_nameservers is not None and not isinstance(
dns_nameservers, list):
raise exceptions.CommandError("dns_nameservers must be a list")
body = {
"network": {
"cidr": cidr,
"name": name,
"is_admin": is_admin,
"gateway": gateway,
"dns_nameservers": dns_nameservers,
"ext_router_id": ext_router_id
}
}
return self._create("/groups/%s/networks" % gid, body, "network")
def check_options(self):
if self.options.rack_api_version != '1':
raise exceptions.CommandError(
"'rack-api-version' must be 1")
if not self.options.rack_url:
raise exceptions.CommandError(
"You must provide an RACK url "
"via either --rack-url or env[RACK_URL]")
def create(self, gid, ppid=None, **kwargs):
"""
Create a process.
If you give a ppid(Parent process ID),
all other parameters will be inherited to its child process,
but you can override them.
Parameters in kwargs:
:param name: Name of the new process
:param nova_flavor_id: ID of a flavor
:param glance_image_id: ID of a glance image
:param keypair_id: ID of a keypair
:param list securitygroup_ids: List of IDs of securitygroups
:param userdata: file type object or string of script
:param dict args: Dict of key-value pairs to be stored as metadata
"""
securitygroup_ids = kwargs.get('securitygroup_ids')
if securitygroup_ids is not None and not isinstance(
securitygroup_ids, list):
raise exceptions.CommandError("securitygroup_ids must be a list")
userdata = kwargs.get('userdata')
if userdata:
if hasattr(userdata, 'read'):
userdata = userdata.read()
userdata_b64 = base64.b64encode(userdata)
args = kwargs.get('args')
if args is not None and not isinstance(args, dict):
raise exceptions.CommandError("args must be a dict")
body = {
"process": {
"ppid": ppid,
"name": kwargs.get('name'),
"nova_flavor_id": kwargs.get('nova_flavor_id'),
"glance_image_id": kwargs.get('glance_image_id'),
"keypair_id": kwargs.get('keypair_id'),
"securitygroup_ids": securitygroup_ids,
"userdata": userdata_b64 if userdata else userdata,
"args": args
}
}
return self._create("/groups/%s/processes" % gid, body, "process")
def prepare_to_run_command(self, cmd):
commands = ['HelpCommand', 'ListGroups', 'ShowGroup',
'CreateGroup', 'UpdateGroup', 'DeleteGroup',
'InitGroup']
if cmd.__class__.__name__ not in commands:
if not self.options.gid:
raise exceptions.CommandError(
"You must provide a gid "
"via either --gid or env[RACK_GID]")
def create(self, gid, name=None, nova_flavor_id=None, glance_image_id=None,
keypair_id=None, securitygroup_ids=None, userdata=None,
args=None):
"""
Create a rack-proxy process.
:param gid: ID of a group
:param name: Name of the rack-proxy process
:param nova_flavor_id: ID of a flavor
:param glance_image_id: ID of a glance image
:param keypair_id: ID of a keypair
:param securitygroup_ids: List of IDs of securitygroups
:param userdata: file type object or string of script
:param dict args: Dict of key-value pairs to be stored as metadata
"""
if securitygroup_ids is not None and not isinstance(
securitygroup_ids, list):
raise exceptions.CommandError("securitygroup_ids must be a list")
if userdata:
if hasattr(userdata, 'read'):
userdata = userdata.read()
userdata_b64 = base64.b64encode(userdata)
if args is not None and not isinstance(args, dict):
raise exceptions.CommandError("args must be a dict")
body = {
"proxy": {
"name": name,
"nova_flavor_id": nova_flavor_id,
"glance_image_id": glance_image_id,
"keypair_id": keypair_id,
"securitygroup_ids": securitygroup_ids,
"userdata": userdata_b64 if userdata else userdata,
"args": args
}
}
return self._create("/groups/%s/proxy" % gid, body, "proxy")
def create(self, gid, name=None, is_default=False):
"""
Create a keypair.
:param gid: ID of the group.
:param name: Name of the keypair.
:param is_default: Set to the default keypair of the group.
"""
try:
is_default = strutils.bool_from_string(is_default, True)
except Exception:
raise exceptions.CommandError("is_default must be a boolean.")
body = {"keypair": {"name": name, "is_default": is_default}}
return self._create("/groups/%s/keypairs" % gid, body, "keypair")
def take_action(self, parsed_args):
userdata = None
if parsed_args.userdata:
try:
userdata = open(parsed_args.userdata)
except IOError:
raise exceptions.CommandError("Can't open '%s'" %
parsed_args.userdata)
process = self.client.processes.create(
gid=self.gid,
ppid=parsed_args.ppid,
name=parsed_args.name,
nova_flavor_id=parsed_args.flavor,
glance_image_id=parsed_args.image,
keypair_id=parsed_args.keypair,
securitygroup_ids=parsed_args.securitygroup_ids,
userdata=userdata,
args=parsed_args.args)
sg_ids = process.securitygroup_ids
if sg_ids:
sg_ids = ','.join(sg_ids)
process_args = process.args
if process_args:
s = ''
for k, v in sorted(process_args.items()):
s += k + '=' + v + '\n'
process_args = s.rstrip('\n')
return _make_print_data(
process.pid,
process.ppid,
process.name,
process.nova_instance_id,
process.nova_flavor_id,
process.glance_image_id,
process.keypair_id,
sg_ids,
process.networks,
process.userdata,
process_args,
process.app_status,
process.gid,
process.user_id,
process.project_id,
)
def update(self, gid, keypair_id, is_default):
"""
Update the status of keypair.
:param gid: ID of the group.
:param keypair_id: ID of the keypair to update.
:param is_default: Set to the default keypair of the group.
"""
try:
is_default = strutils.bool_from_string(is_default, True)
except Exception:
raise exceptions.CommandError("is_default must be a boolean.")
body = {"keypair": {"is_default": is_default}}
return self._update("/groups/%s/keypairs/%s" % (gid, keypair_id), body,
"keypair")
def update(self, gid, securitygroup_id, is_default=False):
"""
Update status of securitygroup.
:param gid: ID of the group.
:param securitygroup_id: ID of the securitygroup to update.
:param is_default: Set to the default securitygroup of the group.
"""
try:
is_default = strutils.bool_from_string(is_default, True)
except Exception:
raise exceptions.CommandError("is_default must be a boolean.")
body = {
"securitygroup": {
"is_default": is_default,
}
}
return self._update(
"/groups/%s/securitygroups/%s" % (gid, securitygroup_id), body,
"securitygroup")
def take_action(self, parsed_args):
config = ConfigParser()
config.read(parsed_args.config)
group_description = None
keypair_name = None
keypair_is_default = True
securitygroup_name = None
securitygroup_is_default = True
securitygroup_rules = None
network_name = None
network_is_admin = True
network_gateway_ip = None
network_dns_nameservers = []
proxy_name = None
# Required options
try:
group_name = config.get('group', 'name')
network_cidr = config.get('network', 'cidr')
network_ext_router_id = config.get('network', 'ext_router_id')
proxy_flavor = config.get('proxy', 'nova_flavor_id')
proxy_image = config.get('proxy', 'glance_image_id')
except NoOptionError as e:
msg = "%s in %s section is required." % (e.option, e.section)
raise exceptions.CommandError(msg)
try:
securitygroup_rules = config.get('securitygroup', 'rules').split()
securitygroup_rules = \
[utils.keyvalue_to_dict(r) for r in securitygroup_rules]
except argparse.ArgumentTypeError:
raise exceptions.CommandError(
"securitygroup rules are not valid formart")
except NoOptionError:
pass
try:
group_description = config.get('group', 'description')
except NoOptionError:
pass
try:
keypair_name = config.get('keypair', 'name')
except NoOptionError:
pass
try:
keypair_is_default = config.get('keypair', 'is_default')
except NoOptionError:
pass
try:
securitygroup_name = config.get('securitygroup', 'name')
except NoOptionError:
pass
try:
securitygroup_is_default = config.get('securitygroup',
'is_default')
except NoOptionError:
pass
try:
network_name = config.get('network', 'name')
except NoOptionError:
pass
try:
network_is_admin = config.get('network', 'is_admin')
except NoOptionError:
pass
try:
network_gateway_ip = config.get('network', 'gateway_ip')
except NoOptionError:
pass
try:
network_dns_nameservers = config.get(
'network',
'dns_nameservers').split()
except NoOptionError:
pass
try:
proxy_name = config.get('proxy', 'name')
except NoOptionError:
pass
group = self.client.groups.create(group_name, group_description)
keypair = self.client.keypairs.create(group.gid, keypair_name,
keypair_is_default)
securitygroup = self.client.securitygroups.create(
group.gid,
securitygroup_name,
securitygroup_is_default,
securitygroup_rules)
network = self.client.networks.create(
group.gid, network_cidr, network_name,
network_is_admin, network_gateway_ip,
network_dns_nameservers,
network_ext_router_id)
proxy = self.client.proxy.create(
group.gid, name=proxy_name,
nova_flavor_id=proxy_flavor,
glance_image_id=proxy_image,
keypair_id=keypair.keypair_id,
securitygroup_ids=[securitygroup.securitygroup_id])
columns = ['gid', 'keypair_id', 'securitygroup_id', 'network_id',
'proxy_pid', 'proxy_name']
data = [group.gid, keypair.keypair_id, securitygroup.securitygroup_id,
network.network_id, proxy.pid, proxy.name]
return columns, data