sahara-dashboard/sahara_dashboard/content/data_processing/clusters/nodegroup_templates/forms/import_forms.py

# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#    http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
# implied.
# See the License for the specific language governing permissions and
# limitations under the License.

from django.utils.translation import ugettext_lazy as _

from horizon import exceptions
from horizon import forms
from openstack_dashboard.api import neutron
from openstack_dashboard.dashboards.project.instances \
    import utils as nova_utils
from oslo_serialization import jsonutils as json
from saharaclient.api import base as api_base

from sahara_dashboard.api import sahara as saharaclient

BASE_IMAGE_URL = "horizon:project:data_processing.clusters:register"


class ImportNodegroupTemplateFileForm(forms.SelfHandlingForm):

    class Meta(object):
        name = _("Import Node Group Template")

    def __init__(self, *args, **kwargs):
        self.next_view = kwargs.pop('next_view')
        super(ImportNodegroupTemplateFileForm, self).__init__(
            *args, **kwargs)

    template_upload = forms.FileField(
        label=_('Template File'),
        required=True)

    def handle(self, request, data):
        kwargs = {'template_upload': data['template_upload']}
        request.method = 'GET'
        return self.next_view.as_view()(request, **kwargs)


class ImportNodegroupTemplateDetailsForm(forms.SelfHandlingForm):

    class Meta(object):
        name = _("Import Node Group Template")

    template = forms.CharField(
        widget=forms.widgets.HiddenInput)

    name = forms.CharField(label=_("Name"),
                           required=False,
                           help_text=_("Name must be provided "
                                       "either here or in the template. If "
                                       "provided in both places, this one "
                                       "will be used."))

    security_groups = forms.MultipleChoiceField(
        label=_("Security Groups"),
        widget=forms.CheckboxSelectMultiple(),
        help_text=_("Launch instances in these security groups. "
                    "Auto security group will be determined by the "
                    "value present in the imported template."),
        required=False)

    floating_ip_pool = forms.ChoiceField(
        label=_("Floating IP Pool"),
        required=False)

    flavor = forms.ChoiceField(label=_("OpenStack Flavor"))

    image_id = forms.DynamicChoiceField(label=_("Base Image"),
                                        add_item_link=BASE_IMAGE_URL)

    def _populate_image_choices(self, request, plugin, hadoop_version):
        all_images = saharaclient.image_list(request)
        details = saharaclient.plugin_get_version_details(request,
                                                          plugin,
                                                          hadoop_version)
        return [(image.id, image.name) for image in all_images
                if (set(details.required_image_tags).
                issubset(set(image.tags)))]

    def __init__(self, *args, **kwargs):
        try:
            request = args[0]
            template_string = ""

            if "template_upload" in kwargs:
                template_upload = kwargs.pop('template_upload')
                super(ImportNodegroupTemplateDetailsForm, self).__init__(
                    *args, **kwargs)

                template_string = template_upload.read()
                self.fields["template"].initial = template_string

            else:
                super(ImportNodegroupTemplateDetailsForm, self).__init__(
                    *args, **kwargs)
                template_string = self.data["template"]

            template_json = json.loads(template_string)
            template_json = template_json["node_group_template"]

            security_group_list = neutron.security_group_list(request)
            security_group_choices = \
                [(sg.id, sg.name) for sg in security_group_list]
            self.fields["security_groups"].choices = security_group_choices

            pools = neutron.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"].choices = pool_choices

            flavors = nova_utils.flavor_list(request)
            if flavors:
                self.fields["flavor"].choices = nova_utils.sort_flavor_list(
                    request, flavors)
            else:
                self.fields["flavor"].choices = []

            version = (template_json.get("hadoop_version", None) or
                       template_json["plugin_version"])
            self.fields["image_id"].choices = \
                self._populate_image_choices(request,
                                             template_json["plugin_name"],
                                             version)
        except (ValueError, KeyError):
            raise exceptions.BadRequest(_("Could not parse template"))
        except Exception:
            exceptions.handle(request)

    def handle(self, request, data):
        try:
            template = data["template"]
            template = json.loads(template)
            template = template["node_group_template"]

            if not data["name"] and "name" not in template.keys():
                return False
            if data["name"]:
                template["name"] = data["name"]

            template["security_groups"] = data["security_groups"]
            template["floating_ip_pool"] = data["floating_ip_pool"]
            template["flavor_id"] = data["flavor"]
            template["image_id"] = data["image_id"]

            saharaclient.nodegroup_template_create(request, **template)
            return True
        except api_base.APIException as e:
            self.error_description = str(e)
            return False
        except Exception as e:
            if isinstance(e, TypeError):
                raise exceptions.BadRequest(
                    _("Template JSON contained invalid key"))
            else:
                raise exceptions.BadRequest(_("Could not parse template"))