def __init__(self, request, *args, **kwargs):
super(AddNodesToHAClusterAction, self).__init__(request,
*args,
**kwargs)
err_msg = _('Unable to get the available hosts')
default_role_field_name = self.get_default_role_field_name()
self.fields[default_role_field_name] = forms.CharField(required=False)
self.fields[default_role_field_name].initial = 'member'
field_name = self.get_member_field_name('member')
self.fields[field_name] = forms.MultipleChoiceField(required=False)
hosts = []
try:
hosts = api.nova.host_list(request)
except Exception:
exceptions.handle(request, err_msg)
host_names = []
for host in hosts:
if host.host_name not in host_names and host.service == u'compute':
host_names.append(host.host_name)
host_names.sort()
self.fields[field_name].choices = [(host_name, host_name) for host_name in host_names]
def __init__(self, *args, **kwargs):
super(LaunchForm, self).__init__(*args, **kwargs)
flavorlist = kwargs.get('initial', {}).get('flavorlist', [])
self.fields['flavor'] = forms.ChoiceField(
choices=flavorlist,
label=_("Flavor"),
help_text="Size of Image to launch")
keynamelist = kwargs.get('initial', {}).get('keynamelist', [])
self.fields['key_name'] = forms.ChoiceField(
choices=keynamelist,
label=_("Key Name"),
required=False,
help_text="Which keypair to use for authentication")
securitygrouplist = kwargs.get('initial',
{}).get('securitygrouplist', [])
self.fields['security_groups'] = forms.MultipleChoiceField(
choices=securitygrouplist,
label=_("Security Groups"),
required=True,
initial=['default'],
widget=forms.SelectMultiple(attrs={
'class': 'chzn-select',
'style': "min-width: 200px"
}),
help_text="Launch instance in these Security Groups")
# setting self.fields.keyOrder seems to break validation,
# so ordering fields manually
field_list = ('name', 'user_data', 'flavor', 'key_name')
for field in field_list[::-1]:
self.fields.insert(0, field, self.fields.pop(field))
class SetNetworkAction(workflows.Action):
network = forms.MultipleChoiceField(label=_("Networks"),
widget=forms.CheckboxSelectMultiple(),
error_messages={
'required':
_("At least one network must"
" be specified.")
},
help_text=_("Launch instance with"
" these networks"))
if api.neutron.is_port_profiles_supported():
widget = None
else:
widget = forms.HiddenInput()
profile = forms.ChoiceField(label=_("Policy Profiles"),
required=False,
widget=widget,
help_text=_("Launch instance with "
"this policy profile"))
def __init__(self, request, *args, **kwargs):
super(SetNetworkAction, self).__init__(request, *args, **kwargs)
network_list = self.fields["network"].choices
if len(network_list) == 1:
self.fields['network'].initial = [network_list[0][0]]
if api.neutron.is_port_profiles_supported():
self.fields['profile'].choices = (
self.get_policy_profile_choices(request))
class Meta:
name = _("Networking")
permissions = ('openstack.services.network', )
help_text = _("Select networks for your instance.")
def populate_network_choices(self, request, context):
try:
tenant_id = self.request.user.tenant_id
networks = api.neutron.network_list_for_tenant(request, tenant_id)
for n in networks:
n.set_id_as_name_if_empty()
network_list = [(network.id, network.name) for network in networks]
except Exception:
network_list = []
exceptions.handle(request, _('Unable to retrieve networks.'))
return network_list
def get_policy_profile_choices(self, request):
profile_choices = [('', _("Select a profile"))]
for profile in self._get_profiles(request, 'policy'):
profile_choices.append((profile.id, profile.name))
return profile_choices
def _get_profiles(self, request, type_p):
profiles = []
try:
profiles = api.neutron.profile_list(request, type_p)
except Exception:
msg = _('Network Profiles could not be retrieved.')
exceptions.handle(request, msg)
return profiles
def __init__(self, request, *args, **kwargs):
super(ManageAggregateHostsAction,
self).__init__(request, *args, **kwargs)
err_msg = _('Unable to get the available hosts')
default_role_field_name = self.get_default_role_field_name()
self.fields[default_role_field_name] = forms.CharField(required=False)
self.fields[default_role_field_name].initial = 'member'
field_name = self.get_member_field_name('member')
self.fields[field_name] = forms.MultipleChoiceField(required=False)
aggregate_id = self.initial['id']
aggregate = api.nova.aggregate_get(request, aggregate_id)
current_aggregate_hosts = aggregate.hosts
hosts = []
try:
hosts = api.nova.host_list(request)
except Exception:
exceptions.handle(request, err_msg)
host_names = []
for host in hosts:
if host.host_name not in host_names and host.service == u'compute':
host_names.append(host.host_name)
host_names.sort()
self.fields[field_name].choices = \
[(host_name, host_name) for host_name in host_names]
self.fields[field_name].initial = current_aggregate_hosts
class SelectRoutersAction(workflows.Action):
router = forms.MultipleChoiceField(
label=_("Routers"),
required=False,
widget=forms.CheckboxSelectMultiple(),
help_text=_("Create a firewall with selected routers."))
class Meta(object):
name = _("Routers")
permissions = ('openstack.services.network', )
help_text = _("Select routers for your firewall.")
def populate_router_choices(self, request, context):
try:
tenant_id = self.request.user.tenant_id
routers_list = api.fwaas.firewall_unassociated_routers_list(
request, tenant_id)
except Exception as e:
routers_list = []
exceptions.handle(
request,
_('Unable to retrieve routers (%(error)s).') %
{'error': str(e)})
routers_list = [(router.id, router.name_or_id)
for router in routers_list]
return routers_list
class SelectRulesAction(workflows.Action):
rule = forms.MultipleChoiceField(
label=_("Rules"),
required=False,
widget=forms.CheckboxSelectMultiple(),
help_text=_("Create a policy with selected rules."))
class Meta:
name = _("Rules")
permissions = ('openstack.services.network', )
help_text = _("Select rules for your policy.")
def populate_rule_choices(self, request, context):
try:
tenant_id = self.request.user.tenant_id
rules = api.fwaas.rules_list(request, tenant_id=tenant_id)
for r in rules:
r.set_id_as_name_if_empty()
rules = sorted(rules, key=lambda rule: rule.name)
rule_list = [(rule.id, rule.name) for rule in rules
if not rule.firewall_policy_id]
except Exception as e:
rule_list = []
exceptions.handle(request, _('Unable to retrieve rules.') + str(e))
return rule_list
def __init__(self, request, *args, **kwargs):
super(BaseSecurityGroupsAction, self).__init__(request, *args,
**kwargs)
err_msg = _('Unable to retrieve security group list. '
'Please try again later.')
context = args[0]
default_role_name = self.get_default_role_field_name()
self.fields[default_role_name] = forms.CharField(required=False)
self.fields[default_role_name].initial = 'member'
# Get list of available security groups
all_groups = []
try:
# target_tenant_id is required when the form is used as admin.
# Owner of security group and port should match.
tenant_id = context.get('target_tenant_id')
all_groups = api.neutron.security_group_list(request,
tenant_id=tenant_id)
except Exception:
exceptions.handle(request, err_msg)
groups_list = [(group.id, group.name) for group in all_groups]
field_name = self.get_member_field_name('member')
self.fields[field_name] = forms.MultipleChoiceField(required=False)
self.fields[field_name].choices = groups_list
sec_groups = []
try:
sec_groups = self._get_initial_security_groups(context)
except Exception:
exceptions.handle(request, err_msg)
self.fields[field_name].initial = sec_groups
def anti_affinity_field():
return forms.MultipleChoiceField(
label=_("Use anti-affinity groups for: "),
required=False,
help_text=_("Use anti-affinity groups for processes"),
widget=forms.CheckboxSelectMultiple()
)
def __init__(self, request, *args, **kwargs):
super(SelectNodeProcessesAction, self).__init__(
request, *args, **kwargs)
plugin, hadoop_version = (
workflow_helpers.get_plugin_and_hadoop_version(request))
node_processes = {}
try:
version_details = saharaclient.plugin_get_version_details(
request, plugin, hadoop_version)
node_processes = version_details.node_processes
except Exception:
exceptions.handle(request,
_("Unable to generate process choices."))
process_choices = []
for service, processes in node_processes.items():
for process in processes:
choice_label = str(service) + ":" + str(process)
process_choices.append((choice_label, process))
self.fields["processes"] = forms.MultipleChoiceField(
label=_("Select Node Group Processes"),
widget=CheckboxSelectMultiple(),
choices=process_choices,
required=True)
class SetAccessControlsAction(workflows.Action):
keypair = forms.ThemableDynamicChoiceField(
label=_("Key Pair"),
help_text=_("Key pair to use for "
"authentication."),
add_item_link=KEYPAIR_IMPORT_URL)
admin_pass = forms.RegexField(
label=_("Admin Password"),
required=False,
widget=forms.PasswordInput(render_value=False),
regex=validators.password_validator(),
error_messages={'invalid': validators.password_validator_msg()})
confirm_admin_pass = forms.CharField(
label=_("Confirm Admin Password"),
required=False,
widget=forms.PasswordInput(render_value=False))
groups = forms.MultipleChoiceField(
label=_("Security Groups"),
required=False,
initial=["default"],
widget=forms.ThemableCheckboxSelectMultiple(),
help_text=_("Launch instance in these "
"security groups."))
class Meta(object):
name = _("Access & Security")
help_text = _("Control access to your instance via key pairs, "
"security groups, and other mechanisms.")
def __init__(self, request, *args, **kwargs):
super(SetAccessControlsAction, self).__init__(request, *args, **kwargs)
if not api.nova.can_set_server_password():
del self.fields['admin_pass']
del self.fields['confirm_admin_pass']
self.fields['keypair'].required = api.nova.requires_keypair()
def populate_keypair_choices(self, request, context):
keypairs = instance_utils.keypair_field_data(request, True)
if len(keypairs) == 2:
self.fields['keypair'].initial = keypairs[1][0]
return keypairs
def populate_groups_choices(self, request, context):
try:
groups = api.neutron.security_group_list(request)
security_group_list = [(sg.id, sg.name) for sg in groups]
except Exception:
exceptions.handle(request,
_('Unable to retrieve list of security groups'))
security_group_list = []
return security_group_list
def clean(self):
'''Check to make sure password fields match.'''
cleaned_data = super(SetAccessControlsAction, self).clean()
if 'admin_pass' in cleaned_data:
if cleaned_data['admin_pass'] != cleaned_data.get(
'confirm_admin_pass', None):
raise forms.ValidationError(_('Passwords do not match.'))
return cleaned_data
def __init__(self, request, *args, **kwargs):
super(UpdateInstanceSecurityGroupsAction,
self).__init__(request, *args, **kwargs)
err_msg = _('Unable to retrieve security group list. '
'Please try again later.')
context = args[0]
instance_id = context.get('instance_id', '')
default_role_name = self.get_default_role_field_name()
self.fields[default_role_name] = forms.CharField(required=False)
self.fields[default_role_name].initial = 'member'
# Get list of available security groups
all_groups = []
try:
all_groups = api.network.security_group_list(request)
except Exception:
exceptions.handle(request, err_msg)
groups_list = [(group.id, group.name) for group in all_groups]
instance_groups = []
try:
instance_groups = api.network.server_security_groups(
request, instance_id)
except Exception:
exceptions.handle(request, err_msg)
field_name = self.get_member_field_name('member')
self.fields[field_name] = forms.MultipleChoiceField(required=False)
self.fields[field_name].choices = groups_list
self.fields[field_name].initial = [
group.id for group in instance_groups
]
class SetNetworkAction(workflows.Action):
network = forms.MultipleChoiceField(label=_("Networks"),
widget=forms.CheckboxSelectMultiple(),
error_messages={
'required':
_("At least one network must"
" be specified.")
},
help_text=_("Launch instance with"
" these networks"))
def __init__(self, request, *args, **kwargs):
super(SetNetworkAction, self).__init__(request, *args, **kwargs)
network_list = self.fields["network"].choices
if len(network_list) == 1:
self.fields['network'].initial = [network_list[0][0]]
class Meta(object):
name = _("Networking")
permissions = ('openstack.services.network', )
help_text = _("Select networks for your instance.")
def populate_network_choices(self, request, context):
try:
tenant_id = self.request.user.tenant_id
networks = dash_api.neutron.network_list_for_tenant(
request, tenant_id)
network_list = [(network.id, network.name_or_id)
for network in networks]
except Exception:
network_list = []
exceptions.handle(request, _('Unable to retrieve networks.'))
return network_list
def __init__(self, request, *args, **kwargs):
super(AddProjectAction, self).__init__(request, *args, **kwargs)
default_role_field_name = self.get_default_role_field_name()
self.fields[default_role_field_name] = forms.CharField(required=False)
self.fields[default_role_field_name].initial = 'member'
field_name = self.get_member_field_name('member')
self.fields[field_name] = forms.MultipleChoiceField(required=False)
share_type_id = self.initial['id']
# Get list of existing projects
try:
projects, __ = keystone.tenant_list(request)
except Exception:
err_msg = _('Unable to get list of projects.')
exceptions.handle(request, err_msg)
# Get list of projects with access to this Share Type
try:
share_type = manila.share_type_get(request, share_type_id)
self.share_type_name = share_type.name
projects_initial = manila.share_type_access_list(
request, share_type)
except Exception:
err_msg = _('Unable to get information about share type access.')
exceptions.handle(request, err_msg)
self.fields[field_name].choices = [(project.id, project.name
or project.id)
for project in projects]
self.fields[field_name].initial = [
pr.project_id for pr in projects_initial
]
self.projects_initial = set(self.fields[field_name].initial)
class LaunchBlessedAction(workflows.Action):
name = forms.CharField(max_length="20", label=_("Launched Name"))
user_data = forms.CharField(widget=forms.Textarea,
label=_("Customization Script"),
required=False,
help_text=_("A script or set of "
"commands to be "
"executed after the "
"instance has been "
"built (max 16kb)."))
security_groups = forms.MultipleChoiceField(
label=_("Security Groups"),
required=True,
initial=["default"],
widget=forms.CheckboxSelectMultiple(),
help_text=_("Launch instance in these "
"security groups."))
class Meta:
name = _("Launch from Blessed Instance")
help_text = _("Enter the information for the new instance.")
def populate_security_groups_choices(self, request, context):
try:
groups = api.api.nova.security_group_list(request)
security_group_list = [(sg.name, sg.name) for sg in groups]
except:
exceptions.handle(request,
_('Unable to retrieve list of security groups'))
security_group_list = []
return security_group_list
class SetNetworkAction(workflows.Action):
network = forms.MultipleChoiceField(label=_("Networks"),
required=True,
widget=forms.CheckboxSelectMultiple(),
error_messages={
'required':
_("At least one network must"
" be specified.")
},
help_text=_("Launch instance with"
"these networks"))
class Meta:
name = _("Networking")
permissions = ('openstack.services.network', )
help_text = _("Select networks for your instance.")
def populate_network_choices(self, request, context):
try:
tenant_id = self.request.user.tenant_id
networks = api.quantum.network_list_for_tenant(request, tenant_id)
for n in networks:
n.set_id_as_name_if_empty()
network_list = [(network.id, network.name) for network in networks]
except:
network_list = []
exceptions.handle(request, _('Unable to retrieve networks.'))
return network_list
class SetNetworkAction(workflows.Action):
network = forms.MultipleChoiceField(
label=_("Networks"),
widget=forms.ThemableCheckboxSelectMultiple(),
error_messages={
'required': _("At least one network must"
" be specified.")
},
help_text=_("Launch instance with"
" these networks"))
def __init__(self, request, *args, **kwargs):
super(SetNetworkAction, self).__init__(request, *args, **kwargs)
# NOTE(e0ne): we don't need 'required attribute for networks
# checkboxes to be able to select only one network
# NOTE(e0ne): we need it for compatibility with different
# Django versions (prior to 1.11)
self.use_required_attribute = False
network_list = self.fields["network"].choices
if len(network_list) == 1:
self.fields['network'].initial = [network_list[0][0]]
class Meta(object):
name = _("Networking")
permissions = ('openstack.services.network', )
help_text = _("Select networks for your instance.")
def populate_network_choices(self, request, context):
return instance_utils.network_field_data(request, for_launch=True)
def __init__(self, request, *args, **kwargs):
super(EditTypeAccessForm, self).__init__(request, *args, **kwargs)
err_msg = _('Unable to retrieve volume type access list.')
self.fields["member"] = forms.MultipleChoiceField(
required=False, widget=forms.ThemableCheckboxSelectMultiple())
# Get list of available projects.
try:
all_projects, has_more = keystone.tenant_list(request)
except Exception:
exceptions.handle(request, err_msg)
projects_list = [(project.id, project.name)
for project in all_projects]
self.fields["member"].choices = projects_list
volume_type_id = self.initial.get('volume_type_id')
volume_type_access = []
try:
if volume_type_id:
volume_type = cinder.volume_type_get(request, volume_type_id)
if not volume_type.is_public:
volume_type_access = [
project.project_id
for project in cinder.volume_type_access_list(
request, volume_type_id)
]
except Exception:
exceptions.handle(request, err_msg)
self.fields["member"].initial = volume_type_access
class PolicyAddAction(workflows.Action):
id= forms.CharField(widget=forms.HiddenInput(),
required=False)
cloudids = forms.ChoiceField(
label=_("Cloud Name"),
required=True,
widget=fields.SelectWidget(
data_attrs=('platform','allowed'),
transform=lambda x: ("%s" % (x.name)))
)
providers = forms.ChoiceField(label=_("Provider"),
required=False,
help_text=_("Choose Your Provider" "."),
widget=fields.SelectWidget(data_attrs=('provider',),
transform=lambda x: ("%s" % (x.provider))))
regions = forms.ChoiceField(label=_("Region"),
required=False,
help_text=_("Choose Your Region" "."),
widget=fields.SelectWidget(data_attrs=('provider','name','allowed',),
transform=lambda x: ("%s(%s)" % ((x.name).title(),(x.provider).title()))))
allowed = forms.MultipleChoiceField(label=_("Allowed Actions"),
required=False,
initial=["default"],
widget=forms.CheckboxSelectMultiple(),
help_text=_("Allowed Action for the Role."))
def populate_cloudids_choices(self, request, context):
try:
cloudid = []
cloudlist = tenantclouds.objects(tenantid=self.request.user.tenantid.id)
roles = roledetail.objects(id = context['id']).first()
for cloud in cloudlist:
if roles.policy:
for a in roles.policy:
if cloud.name == a.cloudid.name:
if a.cloudid.platform != "Cnext":
cloud.__dict__['allowed'] = a.allowed
else:
pass
cloudid.append((cloud.id,cloud))
else:
cloudid.append((cloud.id,cloud))
else:
cloudid.append((cloud.id,cloud))
cloudid = set(cloudid)
cloudid = list(cloudid)
cloudid.insert(0, ("", _("Select Cloud")))
except Exception,e:
messages.error(request,_(e.message))
LOG.error(e.message)
cloudid = []
return cloudid
class ServiceActionForm(forms.SelfHandlingForm):
uuid = forms.CharField(label=_("Plugin ID"), widget=forms.HiddenInput)
name = forms.CharField(
label=_('Service Name'),
widget=forms.TextInput(attrs={'readonly': 'readonly'})
)
board_list = forms.MultipleChoiceField(
label=_("Boards List"),
widget=forms.SelectMultiple(
attrs={'class': 'switchable', 'data-slug': 'slug-select-boards'}),
help_text=_("Select boards in this pool")
)
action = forms.ChoiceField(
label=_("Action"),
choices=[('ServiceEnable', _('Enable')),
('ServiceDisable', _('Disable')),
('ServiceRestore', _('Restore'))],
widget=forms.Select(
attrs={'class': 'switchable', 'data-slug': 'slug-action'},
)
)
def __init__(self, *args, **kwargs):
super(ServiceActionForm, self).__init__(*args, **kwargs)
# input=kwargs.get('initial',{})
self.fields["board_list"].choices = kwargs["initial"]["board_list"]
def handle(self, request, data):
counter = 0
for board in data["board_list"]:
for key, value in self.fields["board_list"].choices:
if key == board:
try:
action = iotronic.service_action(request, key,
data["uuid"],
data["action"])
message_text = action
messages.success(request, _(message_text))
if counter != len(data["board_list"]) - 1:
counter += 1
else:
return True
except Exception:
message_text = "Unable to execute action on board " \
+ str(value) + "."
exceptions.handle(request, _(message_text))
break
class SetAccessControlsAction(workflows.Action):
keypair = forms.DynamicChoiceField(
label=_("Keypair"),
required=False,
help_text=_("Which keypair to use for "
"authentication."),
widget=fields.SelectWidget(data_attrs=('provider', 'region',
'instanceId'),
transform=lambda x:
("%s (%s)(%s)" %
(x.name, x.provider, x.region))),
add_item_link=KEYPAIR_IMPORT_URL)
admin_pass = forms.RegexField(
label=_("Admin Password"),
required=False,
widget=forms.PasswordInput(render_value=False),
regex=validators.password_validator(),
error_messages={'invalid': validators.password_validator_msg()})
confirm_admin_pass = forms.CharField(
label=_("Confirm Admin Password"),
required=False,
widget=forms.PasswordInput(render_value=False))
groups = forms.MultipleChoiceField(label=_("Security Groups"),
required=False,
initial=["default"],
widget=forms.CheckboxSelectMultiple(),
help_text=_("Launch instance in these "
"security groups."))
class Meta:
name = _("Access & Security")
help_text = _("Control access to your instance via keypairs, "
"security groups, and other mechanisms.")
def populate_keypair_choices(self, request, context):
try:
keypairs = capi.keypairs(request)
keypair_list = [(kp.id, kp) for kp in keypairs]
except Exception:
keypair_list = []
exceptions.handle(request, _('Unable to retrieve keypairs.'))
if keypair_list:
keypair_list.insert(0, ("", _("Select a keypair")))
else:
keypair_list = (("", _("No keypairs available.")), )
return keypair_list
def populate_groups_choices(self, request, context):
try:
groups = capi.securitygroups(request)
if groups:
security_group_list = [(sg.id, sg.name) for sg in groups]
else:
security_group_list = []
except Exception:
exceptions.handle(request,
_('Unable to retrieve list of security groups'))
security_group_list = []
return security_group_list
def __init__(self, request, *args, **kwargs):
super(UpdateProjectMembersAction,
self).__init__(request, *args, **kwargs)
err_msg = _('Unable to retrieve user list. Please try again later.')
project_id = ''
if 'project_id' in args[0]:
project_id = args[0]['project_id']
# Get the default role
try:
default_role = api.keystone.get_default_role(self.request)
# Default role is necessary to add members to a project
if default_role is None:
default = getattr(settings, "OPENSTACK_KEYSTONE_DEFAULT_ROLE",
None)
msg = _('Could not find default role "%s" in Keystone') % \
default
raise exceptions.NotFound(msg)
except:
exceptions.handle(self.request,
err_msg,
redirect=reverse(INDEX_URL))
self.fields['default_role'].initial = default_role.id
# Get list of available users
all_users = []
domain_context = request.session.get('domain_context', None)
try:
all_users = api.keystone.user_list(request, domain=domain_context)
except:
exceptions.handle(request, err_msg)
users_list = [(user.id, user.name) for user in all_users]
# Get list of roles
role_list = []
try:
role_list = api.keystone.role_list(request)
except:
exceptions.handle(request, err_msg, redirect=reverse(INDEX_URL))
for role in role_list:
field_name = "role_" + role.id
label = _(role.name)
self.fields[field_name] = forms.MultipleChoiceField(required=False,
label=label)
self.fields[field_name].choices = users_list
self.fields[field_name].initial = []
# Figure out users & roles
if project_id:
for user in all_users:
try:
roles = api.keystone.roles_for_user(
self.request, user.id, project_id)
except:
exceptions.handle(request,
err_msg,
redirect=reverse(INDEX_URL))
for role in roles:
self.fields["role_" + role.id].initial.append(user.id)
def __init__(self, request, *args, **kwargs):
super(GeneralConfigAction, self).__init__(request, *args, **kwargs)
hlps = helpers.Helpers(request)
plugin, hadoop_version = (
workflow_helpers.get_plugin_and_hadoop_version(request))
process_choices = []
try:
version_details = saharaclient.plugin_get_version_details(
request, plugin, hadoop_version)
for service, processes in version_details.node_processes.items():
for process in processes:
process_choices.append(
(str(service) + ":" + str(process), process))
except Exception:
exceptions.handle(request,
_("Unable to generate process choices."))
if not saharaclient.SAHARA_AUTO_IP_ALLOCATION_ENABLED:
pools = network.floating_ip_pools_list(request)
pool_choices = [(pool.id, pool.name) for pool in pools]
pool_choices.insert(0, (None, "Do not assign floating IPs"))
self.fields['floating_ip_pool'] = forms.ChoiceField(
label=_("Floating IP Pool"),
choices=pool_choices,
required=False)
self.fields["proxygateway"] = forms.BooleanField(
label=_("Proxy Gateway"),
widget=forms.CheckboxInput(),
help_text=_("Sahara will use instances of this node group to "
"access other cluster instances."),
required=False)
self.fields["processes"] = forms.MultipleChoiceField(
label=_("Processes"),
widget=forms.CheckboxSelectMultiple(),
help_text=_("Processes to be launched in node group"),
choices=process_choices)
self.fields["plugin_name"] = forms.CharField(
widget=forms.HiddenInput(), initial=plugin)
self.fields["hadoop_version"] = forms.CharField(
widget=forms.HiddenInput(), initial=hadoop_version)
node_parameters = hlps.get_general_node_group_configs(
plugin, hadoop_version)
for param in node_parameters:
self.fields[param.name] = workflow_helpers.build_control(param)
if request.REQUEST.get("guide_template_type"):
self.fields["guide_template_type"] = forms.CharField(
required=False,
widget=forms.HiddenInput(),
initial=request.REQUEST.get("guide_template_type"))
class CreateNetworkInfoAction(workflows.Action):
net_name = forms.CharField(max_length=255,
label=_("Network Name"),
required=False)
admin_state = forms.BooleanField(
label=_("Enable Admin State"),
initial=True,
required=False,
help_text=_("The state to start the network in."))
shared = forms.BooleanField(label=_("Shared"), initial=False,
required=False)
with_subnet = forms.BooleanField(label=_("Create Subnet"),
widget=forms.CheckboxInput(attrs={
'class': 'switchable',
'data-slug': 'with_subnet',
'data-hide-tab': 'create_network__'
'createsubnetinfo'
'action,'
'create_network__'
'createsubnetdetail'
'action',
'data-hide-on-checked': 'false'
}),
initial=True,
required=False)
az_hints = forms.MultipleChoiceField(
label=_("Availability Zone Hints"),
required=False,
help_text=_("Availability zones where the DHCP agents may be "
"scheduled. Leaving this unset is equivalent to "
"selecting all availability zones"))
def __init__(self, request, *args, **kwargs):
super(CreateNetworkInfoAction, self).__init__(request,
*args, **kwargs)
if not policy.check((("network", "create_network:shared"),), request):
self.fields['shared'].widget = forms.HiddenInput()
try:
if api.neutron.is_extension_supported(request,
'network_availability_zone'):
zones = api.neutron.list_availability_zones(
self.request, 'network', 'available')
self.fields['az_hints'].choices = [(zone['name'], zone['name'])
for zone in zones]
else:
del self.fields['az_hints']
except Exception:
msg = _('Failed to get availability zone list.')
messages.warning(request, msg)
del self.fields['az_hints']
class Meta(object):
name = _("Network")
help_text = _('Create a new network. '
'In addition, a subnet associated with the network '
'can be created in the following steps of this wizard.')
class AddRouterToFirewall(forms.SelfHandlingForm):
router_ids = forms.MultipleChoiceField(
label=_("Add Routers"),
required=False,
widget=forms.ThemableCheckboxSelectMultiple(),
help_text=_("Add selected router(s) to the firewall."))
failure_url = 'horizon:project:firewalls:index'
def __init__(self, request, *args, **kwargs):
super(AddRouterToFirewall, self).__init__(request, *args, **kwargs)
try:
router_choices = self.get_router_choices(request, kwargs)
self.fields['router_ids'].choices = router_choices
except Exception as e:
LOG.error('Failed to retrieve available routers: %s', e)
msg = _('Failed to retrieve available routers: %s') % e
redirect = reverse(self.failure_url)
exceptions.handle(request, msg, redirect=redirect)
def get_router_choices(self, request, kwargs):
tenant_id = self.request.user.tenant_id
routers_list = api.fwaas.firewall_unassociated_routers_list(
request, tenant_id)
return [(r.id, r.name_or_id) for r in routers_list]
def get_new_router_ids(self, context):
existing_router_ids = self.initial['router_ids']
add_router_ids = context['router_ids']
return add_router_ids + existing_router_ids
def handle(self, request, context):
firewall_id = self.initial['firewall_id']
firewall_name_or_id = self.initial['name'] or firewall_id
try:
body = {'router_ids': self.get_new_router_ids(context)}
firewall = api.fwaas.firewall_update(request, firewall_id, **body)
msg = (_('Router(s) was/were successfully added to firewall '
'%(firewall)s.') % {
'firewall': firewall_name_or_id
})
messages.success(request, msg)
return firewall
except Exception as e:
LOG.error('Failed to add router(s) to firewall %(id)s: %(reason)s',
{
'id': firewall_id,
'reason': e
})
msg = (_('Failed to add router(s) to firewall %(name)s: '
'%(reason)s') % {
'name': firewall_name_or_id,
'reason': e
})
redirect = reverse(self.failure_url)
exceptions.handle(request, msg, redirect=redirect)
class InjectPluginForm(forms.SelfHandlingForm):
uuid = forms.CharField(label=_("Plugin ID"), widget=forms.HiddenInput)
name = forms.CharField(
label=_('Plugin Name'),
widget=forms.TextInput(attrs={'readonly': 'readonly'})
)
onboot = forms.BooleanField(label=_("On Boot"), required=False)
board_list = forms.MultipleChoiceField(
label=_("Boards List"),
widget=forms.SelectMultiple(
attrs={'class': 'switchable', 'data-slug': 'slug-inject-boards'}),
help_text=_("Select boards in this pool ")
)
def __init__(self, *args, **kwargs):
super(InjectPluginForm, self).__init__(*args, **kwargs)
# input=kwargs.get('initial',{})
boardslist_length = len(kwargs["initial"]["board_list"])
self.fields["board_list"].choices = kwargs["initial"]["board_list"]
self.fields["board_list"].max_length = boardslist_length
def handle(self, request, data):
counter = 0
for board in data["board_list"]:
for key, value in self.fields["board_list"].choices:
if key == board:
try:
plugin = None
plugin = iotronic.plugin_inject(request, key,
data["uuid"],
data["onboot"])
# LOG.debug("API: %s %s", plugin, request)
message_text = "Plugin injected successfully on " \
"board " + str(value) + "."
messages.success(request, _(message_text))
if counter != len(data["board_list"]) - 1:
counter += 1
else:
return plugin
except Exception:
message_text = "Unable to inject plugin on board " \
+ str(value) + "."
exceptions.handle(request, _(message_text))
break
def __init__(self, request, *args, **kwargs):
super(UpdateProjectMembersAction, self).__init__(request,
*args,
**kwargs)
err_msg = _('Unable to retrieve user list. Please try again later.')
project_id = ''
if 'project_id' in args[0]:
project_id = args[0]['project_id']
# Get the default role
try:
default_role = api.get_default_role(self.request).id
except:
exceptions.handle(self.request,
err_msg,
redirect=reverse(INDEX_URL))
self.fields['default_role'].initial = default_role
# Get list of available users
all_users = []
try:
all_users = api.keystone.user_list(request)
except:
exceptions.handle(request, err_msg)
users_list = [(user.id, user.name) for user in all_users]
# Get list of roles
role_list = []
try:
role_list = api.keystone.role_list(request)
except:
exceptions.handle(request,
err_msg,
redirect=reverse(INDEX_URL))
for role in role_list:
field_name = "role_" + role.id
label = _(role.name)
self.fields[field_name] = forms.MultipleChoiceField(required=False,
label=label)
self.fields[field_name].choices = users_list
self.fields[field_name].initial = []
# Figure out users & roles
if project_id:
for user in all_users:
try:
roles = api.roles_for_user(self.request,
user.id,
project_id)
except:
exceptions.handle(request,
err_msg,
redirect=reverse(INDEX_URL))
if roles:
primary_role = roles[0].id
self.fields["role_" + primary_role].initial.append(user.id)
class CreateVPNInfoAction(workflows.Action):
#CHOICES = (('L2VPN', 'L2VPN (over Fiber, MetroEthernet, VPLS, MPLS, L3/GRE/L2TP, SSL)'), ('L3VPN', 'L3VPN (over Fiber, MetroEthernet, VPLS, MPLS, L3/GRE/L2TP, SSL)'))
CHOICES = (('L2VPN', 'L3VPN plugin'), ('L3VPN',
'L3VPN (plugin not implemented)'))
#vpntype = forms.ChoiceField(widget=forms.RadioSelect, required=True, label='Type', choices=CHOICES)
vpntype = forms.ChoiceField(required=True,
label='VPN Type',
choices=CHOICES)
net_name = forms.CharField(max_length=255,
label=_("VPN Name"),
help_text=_("VPN Name. This field is "
"optional."),
required=False)
private_network = forms.MultipleChoiceField(
label=
_("Private Networks to Connect to (Note: only non-Shared networks can be connected to by this VPN)"
),
required=True,
error_messages={
'required': _("At least one network must"
" be specified.")
},
help_text=_("Connect VPN to this private network"))
#bw = forms.IntegerField(label=_("Aggregate Bandwidth (Kbps)"), min_value=1000, initial=10000, help_text=_("Aggregate bandwidth (Kbps)"))
private = forms.BooleanField(
label=_("Private to this tenant (Isolated from other tenants)"),
initial=True,
required=False)
class Meta:
name = ("VPN")
permissions = ('openstack.services.network', )
help_text = _(
"From here you can create a new VPN from a Cloud Site to your Enterprise Branch Site.\n"
"A Provider Site and your Enterprise Site associated with this VPN "
"can be add in the next panel. All Enterprise Sites require to run OpenStack with a reacheable Keystone v2 Service."
)
def populate_private_network_choices(self, request, context):
try:
tenant_name = self.request.user.tenant_name
networks = api.neutron.network_list(request,
tenant_name=tenant_name,
shared=False)
for n in networks:
n.set_id_as_name_if_empty()
network_list = [(network.id, network.name) for network in networks]
except:
network_list = []
exceptions.handle(request, _('Unable to retrieve networks.'))
return network_list
class CreateUserAction(workflows.Action):
username = forms.CharField(max_length=80, label=_("User Name"),
validators=[RegexValidator(r'^[\w]*$',
message='Username must be alphanumeric without spaces',
code='Invalid Username')]
)
roles = forms.MultipleChoiceField(label=_("Roles"),
required=False,
initial=["default"],
widget=forms.CheckboxSelectMultiple(),
help_text=_("Create user with these "
"roles."))
password = forms.RegexField(
label=_("Password"),
required=False,
widget=forms.PasswordInput(render_value=False),
regex=validators.password_validator(),
error_messages={'invalid': validators.password_validator_msg()})
confirm_password = forms.CharField(
label=_("Confirm Password"),
required=False,
widget=forms.PasswordInput(render_value=False))
email = forms.EmailField(label=_("Email ID"),
required=True)
def populate_roles_choices(self, request, context):
roles = []
success = []
try:
if request.user.roles:
for role in request.user.roles:
if (role.name == "Tenant Admin") & (role.roletype == "Tenant Admin"):
success.append("Tenant Admin")
else:
success.append("Member")
if "Tenant Admin" in success:
rolelist = roledetail.objects(tenantid=request.user.tenantid.id)
roles = [(role.id, role.name) for role in rolelist]
else:
rolelist = roledetail.objects(tenantid=request.user.tenantid.id)
for role in rolelist:
if (role.name == "Tenant Admin") & (role.roletype == "Tenant Admin"):
pass
else:
roles.append((role.id, role.name))
else:
roles = []
except Exception, e:
messages.error(request,_(e.message))
LOG.error(e.message)
roles = []
return roles
def add_unit_combos(newprjform):
unit_table = get_unit_table()
org_table = settings.HORIZON_CONFIG.get('organization', {})
if len(unit_table) > 0:
avail_nets = get_avail_networks(newprjform.request)
choices_u = list()
for k, v in unit_table.items():
if len(avail_nets[k]) > 0:
choices_u.append((k,v['name']))
newprjform.fields['unit'] = forms.ChoiceField(
label=_('Available units'),
required=True,
choices=choices_u,
widget=forms.Select(attrs={
'class': 'switchable',
'data-slug': 'unitselector'
})
)
for unit_id, unit_data in unit_table.items():
if len(avail_nets[unit_id]) == 0:
continue
newprjform.fields["%s-net" % unit_id] = forms.ChoiceField(
label=_('Available networks'),
required=False,
choices=[ (k,k) for k in avail_nets[unit_id] ],
widget=forms.Select(attrs={
'class': 'switched',
'data-switch-on': 'unitselector',
'data-unitselector-%s' % unit_id : _('Available networks')
})
)
ou_list = org_table.get(unit_data.get('organization', ""), None)
if not ou_list:
continue
newprjform.fields["%s-ou" % unit_id] = forms.MultipleChoiceField(
label=_('Unit or department'),
required=False,
choices=[ x[:2] for x in ou_list ],
widget=forms.SelectMultiple(attrs={
'class': 'switched',
'data-switch-on': 'unitselector',
'data-unitselector-%s' % unit_id : _('Unit or department')
})
)
class LoadBalancerForm(forms.SelfHandlingForm):
lb_name = forms.CharField(label=_("Load Balancer Name"),
max_length=255,
error_messages={
'required':
_('This field is required.'),
'invalid':
_("The string may only contain"
" ASCII characters and numbers.")
})
pool_id = forms.CharField(label=_("Pool id"),
max_length=255,
error_messages={
'required':
_('This field is required.'),
'invalid':
_("The string may only contain"
" ASCII characters and numbers.")
})
protocol_port = forms.IntegerField(
label=_('Protocol_port'),
help_text=_(
'Port number on which the servers are running on the members'))
# base_choices = [('nano', _('m1.nano')),
# ('micro', _('m1.micro')),
# ('tiny', _('m1.tiny')),
# ('heat', _('m1.heat')),
# ('small', _('m1.small')),]
attributes = {'class': 'image_selector', 'data-slug': 'templatesource'}
members = forms.MultipleChoiceField(label=_('Instance Members'),
widget=forms.SelectMultiple,
choices=[])
def __init__(self, *args, **kwargs):
super(LoadBalancerForm, self).__init__(*args, **kwargs)
temp = project_api.get_lb_members()
#tkMessageBox.showinfo(title="Greetings", message="\n" + str(temp))
self.fields['members'].choices = temp
#tkMessageBox.showinfo(title="Greetings", message="\n" + str(temp))
def handle(self, request, data):
kwargs = {
'lb_name': data['lb_name'],
'pool_id': data['pool_id'],
'protocol_port': data['protocol_port'],
'members': data['members'],
}
project_api.create_ins(kwargs)
return True
