# http://www.apache.org/licenses/LICENSE-2.0
##############################################################################
-from django.contrib import messages
from django.utils import timezone
from datetime import timedelta
context['form'] = BookingMetaForm(initial=initial, user_initial=default, owner=owner)
return context
- def post_render(self, request):
- form = BookingMetaForm(data=request.POST, owner=request.user)
+ def post(self, post_data, user):
+ form = BookingMetaForm(data=post_data, owner=user)
forms = self.repo_get(self.repo.BOOKING_FORMS, {})
self.repo_put(self.repo.BOOKING_MODELS, models)
self.repo_put(self.repo.CONFIRMATION, confirm)
- messages.add_message(request, messages.SUCCESS, 'Form Validated', fail_silently=True)
self.set_valid("Step Completed")
else:
- messages.add_message(request, messages.ERROR, "Form didn't validate", fail_silently=True)
self.set_invalid("Please complete the fields highlighted in red to continue")
- return self.render(request)
##############################################################################
-from django.shortcuts import render
-from django.contrib import messages
+from django.template.loader import get_template
from django.http import HttpResponse
from django.utils import timezone
return context
def render(self, request):
- self.context = self.get_context()
- return render(request, self.template, self.context)
+ return HttpResponse(self.render_to_string(request))
+
+ def render_to_string(self, request):
+ template = get_template(self.template)
+ return template.render(self.get_context(), request)
def post_render(self, request):
+ self.post(request.POST, request.user)
return self.render(request)
+ def post(self, post_content, user):
+ raise Exception("WorkflowStep subclass of type " + str(type(self)) + " has no concrete post() method")
+
def test_render(self, request):
if request.method == "POST":
return self.post_render(request)
def alert_bundle_missing(self): # override in subclasses to change message if field isn't filled out
self.set_invalid("Please select a valid bundle")
- def post_render(self, request):
- context = self.get_context()
- form = self.form(request.POST, queryset=self.get_form_queryset())
+ def post(self, post_data, user):
+ form = self.form(post_data, queryset=self.get_form_queryset())
if form.is_valid():
bundle = form.get_validated_bundle()
if not bundle:
self.alert_bundle_missing()
- return render(request, self.template, context)
+ return
self.repo_put(self.select_repo_key, bundle)
self.put_confirm_info(bundle)
self.set_valid("Step Completed")
else:
self.alert_bundle_missing()
- messages.add_message(request, messages.ERROR, "Form Didn't Validate", fail_silently=True)
-
- return self.render(request)
def get_context(self):
default = []
if errors:
return errors
- def post_render(self, request):
- form = ConfirmationForm(request.POST)
+ def post(self, post_data, user):
+ form = ConfirmationForm(post_data)
if form.is_valid():
data = form.cleaned_data['confirm']
context = self.get_context()
context["bypassed"] = "true"
errors = self.flush_to_db()
if errors:
- messages.add_message(request, messages.ERROR, "ERROR OCCURRED: " + errors)
+ self.set_invalid("ERROR OCCURRED: " + errors)
else:
- messages.add_message(request, messages.SUCCESS, "Confirmed")
+ self.set_valid("Confirmed")
- return HttpResponse('')
elif data == "False":
context["bypassed"] = "true"
- messages.add_message(request, messages.SUCCESS, "Canceled")
- return render(request, self.template, context)
+ self.set_valid("Canceled")
else:
- pass
+ self.set_invalid("Bad Form Contents")
else:
- pass
+ self.set_invalid("Bad Form Contents")
class Repository():
context["form"] = OPNFVSelectionForm(initial=initial)
return context
- def post_render(self, request):
- form = OPNFVSelectionForm(request.POST)
+ def post(self, post_data, user):
+ form = OPNFVSelectionForm(post_data)
if form.is_valid():
installer = form.cleaned_data['installer']
scenario = form.cleaned_data['scenario']
else:
self.set_invalid("Please select an Installer and Scenario")
- return self.render(request)
-
class Assign_Network_Roles(WorkflowStep):
template = 'config_bundle/steps/assign_network_roles.html'
confirm['network roles'][role['role']] = role['network'].name
self.repo_put(self.repo.CONFIRMATION, confirm)
- def post_render(self, request):
+ def post(self, post_data, user):
models = self.repo_get(self.repo.OPNFV_MODELS, {})
config_bundle = self.repo_get(self.repo.SELECTED_CONFIG_BUNDLE)
roles = OPNFV_SETTINGS.NETWORK_ROLES
- net_role_formset = self.create_netformset(roles, config_bundle, data=request.POST)
+ net_role_formset = self.create_netformset(roles, config_bundle, data=post_data)
if net_role_formset.is_valid():
results = []
for form in net_role_formset:
self.update_confirmation()
else:
self.set_invalid("Please complete all fields")
- return self.render(request)
class Assign_Host_Roles(WorkflowStep): # taken verbatim from Define_Software in sw workflow, merge the two?
confirm['host roles'][role['host_name']] = role['role'].name
self.repo_put(self.repo.CONFIRMATION, confirm)
- def post_render(self, request):
- formset = self.create_host_role_formset(data=request.POST)
+ def post(self, post_data, user):
+ formset = self.create_host_role_formset(data=post_data)
models = self.repo_get(self.repo.OPNFV_MODELS, {})
host_roles = models.get("host_roles", [])
else:
self.set_invalid("Please complete all fields")
- return self.render(request)
-
class MetaInfo(WorkflowStep):
template = 'config_bundle/steps/config_software.html'
confirm['description'] = meta['description']
self.repo_put(self.repo.CONFIRMATION, confirm)
- def post_render(self, request):
+ def post(self, post_data, user):
models = self.repo_get(self.repo.OPNFV_MODELS, {})
info = models.get("meta", {})
- form = BasicMetaForm(request.POST)
+ form = BasicMetaForm(post_data)
if form.is_valid():
info['name'] = form.cleaned_data['name']
info['description'] = form.cleaned_data['description']
self.set_valid("Complete")
else:
self.set_invalid("Please correct the errors shown below")
-
self.repo_put(self.repo.OPNFV_MODELS, models)
- return self.render(request)
##############################################################################
-from django.shortcuts import render
-from django.forms import formset_factory
from django.conf import settings
import json
HardwareDefinitionForm,
NetworkDefinitionForm,
ResourceMetaForm,
- GenericHostMetaForm
)
from resource_inventory.models import (
GenericResourceBundle,
confirm['resource']['lab'] = models['lab'].lab_user.username
self.repo_put(self.repo.CONFIRMATION, confirm)
- def post_render(self, request):
+ def post(self, post_data, user):
try:
- self.form = HardwareDefinitionForm(request.POST)
+ self.form = HardwareDefinitionForm(post_data)
if self.form.is_valid():
self.update_models(self.form.cleaned_data)
self.update_confirmation()
self.set_invalid("Please complete the fields highlighted in red to continue")
except Exception as e:
self.set_invalid(str(e))
- self.context = self.get_context()
- return render(request, self.template, self.context)
class Define_Nets(WorkflowStep):
return context
- def post_render(self, request):
+ def post(self, post_data, user):
models = self.repo_get(self.repo.GRESOURCE_BUNDLE_MODELS, {})
if 'hosts' in models:
host_set = set([h.resource.name + "*" + h.profile.name for h in models['hosts']])
self.repo_put(self.repo.GRB_LAST_HOSTLIST, host_set)
try:
- xmlData = request.POST.get("xml")
+ xmlData = post_data.get("xml")
self.updateModels(xmlData)
# update model with xml
self.set_valid("Networks applied successfully")
self.set_invalid("Public network not availble")
except Exception as e:
self.set_invalid("An error occurred when applying networks: " + str(e))
- return self.render(request)
def updateModels(self, xmlData):
models = self.repo_get(self.repo.GRESOURCE_BUNDLE_MODELS, {})
context['form'] = ResourceMetaForm(initial={"bundle_name": name, "bundle_description": desc})
return context
- def post_render(self, request):
- form = ResourceMetaForm(request.POST)
+ def post(self, post_data, user):
+ form = ResourceMetaForm(post_data)
if form.is_valid():
models = self.repo_get(self.repo.GRESOURCE_BUNDLE_MODELS, {})
name = form.cleaned_data['bundle_name']
confirm_info["description"] = tmp
self.repo_put(self.repo.CONFIRMATION, confirm)
self.set_valid("Step Completed")
-
else:
self.set_invalid("Please correct the fields highlighted in red to continue")
- pass
- return self.render(request)
-
-
-class Host_Meta_Info(WorkflowStep):
- template = "resource/steps/host_info.html"
- title = "Host Info"
- description = "We need a little bit of information about your chosen machines"
- short_title = "host info"
-
- def __init__(self, *args, **kwargs):
- super(Host_Meta_Info, self).__init__(*args, **kwargs)
- self.formset = formset_factory(GenericHostMetaForm, extra=0)
-
- def get_context(self):
- context = super(Host_Meta_Info, self).get_context()
- GenericHostFormset = self.formset
- models = self.repo_get(self.repo.GRESOURCE_BUNDLE_MODELS, {})
- initial_data = []
- if "hosts" not in models:
- context['error'] = "Please go back and select your hosts"
- else:
- for host in models['hosts']:
- profile = host.profile.name
- name = host.resource.name
- if not name:
- name = ""
- initial_data.append({"host_profile": profile, "host_name": name})
- context['formset'] = GenericHostFormset(initial=initial_data)
- return context
-
- def post_render(self, request):
- models = self.repo_get(self.repo.GRESOURCE_BUNDLE_MODELS, {})
- if 'hosts' not in models:
- models['hosts'] = []
- hosts = models['hosts']
- i = 0
- confirm_hosts = []
- GenericHostFormset = self.formset
- formset = GenericHostFormset(request.POST)
- if formset.is_valid():
- for form in formset:
- host = hosts[i]
- host.resource.name = form.cleaned_data['host_name']
- i += 1
- confirm_hosts.append({"name": host.resource.name, "profile": host.profile.name})
- models['hosts'] = hosts
- self.repo_put(self.repo.GRESOURCE_BUNDLE_MODELS, models)
- confirm = self.repo_get(self.repo.CONFIRMATION, {})
- if "resource" not in confirm:
- confirm['resource'] = {}
- confirm['resource']['hosts'] = confirm_hosts
- self.repo_put(self.repo.CONFIRMATION, confirm)
- else:
- pass
- return self.render(request)
context['chosen'] = chosen
return context
- def post_render(self, request):
- host_data = request.POST.get("host")
+ def post(self, post_data, user):
+ host_data = post_data.get("host")
if not host_data:
self.set_invalid("Please select a host")
- return self.render(request)
+ return
host = json.loads(host_data)
if 'name' not in host or 'booking' not in host:
self.set_invalid("Invalid host selected")
- return self.render(request)
+ return
name = host['name']
booking_id = host['booking']
booking = Booking.objects.get(pk=booking_id)
confirm['snapshot'] = snap_confirm
self.repo_put(self.repo.CONFIRMATION, confirm)
self.set_valid("Success")
- return self.render(request)
class Image_Meta_Step(WorkflowStep):
context['form'] = form
return context
- def post_render(self, request):
- form = BasicMetaForm(request.POST)
+ def post(self, post_data, user):
+ form = BasicMetaForm(post_data)
if form.is_valid():
name = form.cleaned_data['name']
self.repo_put(self.repo.SNAPSHOT_NAME, name)
self.set_valid("Success")
else:
self.set_invalid("Please Fill out the Form")
-
- return self.render(request)
return context
- def post_render(self, request):
+ def post(self, post_data, user):
models = self.repo_get(self.repo.CONFIG_MODELS, {})
if "bundle" not in models:
models['bundle'] = ConfigBundle(owner=self.repo_get(self.repo.SESSION_USER))
confirm = self.repo_get(self.repo.CONFIRMATION, {})
hosts = self.get_host_list()
- models['headnode_index'] = request.POST.get("headnode", 1)
- formset = self.create_hostformset(hosts, data=request.POST)
+ models['headnode_index'] = post_data.get("headnode", 1)
+ formset = self.create_hostformset(hosts, data=post_data)
has_headnode = False
if formset.is_valid():
models['host_configs'] = []
if not has_headnode:
self.set_invalid('Must have one "Headnode" per POD')
- return self.render(request)
+ return
self.repo_put(self.repo.CONFIG_MODELS, models)
if "configuration" not in confirm:
else:
self.set_invalid("Please complete all fields")
- return self.render(request)
-
class Config_Software(WorkflowStep):
template = 'config_bundle/steps/config_software.html'
context["form"] = BasicMetaForm(initial=initial)
return context
- def post_render(self, request):
+ def post(self, post_data, user):
models = self.repo_get(self.repo.CONFIG_MODELS, {})
if "bundle" not in models:
models['bundle'] = ConfigBundle(owner=self.repo_get(self.repo.SESSION_USER))
if "configuration" not in confirm:
confirm['configuration'] = {}
- form = BasicMetaForm(request.POST)
+ form = BasicMetaForm(post_data)
if form.is_valid():
models['bundle'].name = form.cleaned_data['name']
models['bundle'].description = form.cleaned_data['description']
self.repo_put(self.repo.CONFIG_MODELS, models)
self.repo_put(self.repo.CONFIRMATION, confirm)
-
- return self.render(request)
from workflow.tests import constants
from workflow.workflow_factory import WorkflowFactory
from workflow.models import Repository
-from workflow.resource_bundle_workflow import Define_Hardware, Define_Nets, Resource_Meta_Info, Host_Meta_Info
+from workflow.resource_bundle_workflow import Define_Hardware, Define_Nets, Resource_Meta_Info
from workflow.sw_bundle_workflow import SWConf_Resource_Select, Define_Software, Config_Software
from workflow.booking_workflow import Booking_Resource_Select, SWConfig_Select, Booking_Meta
from django.http import QueryDict, HttpRequest
OPNFVRole,
Image,
GenericResourceBundle,
- GenericHost,
- HostProfile,
- GenericResource,
ConfigBundle
)
response, context = self.step_test(Define_Hardware, data)
-class HostMetaInfoTestCase(BaseStepTestCase):
-
- def makeRepo(self):
- """
- override to provide step with needed host info
- """
- repo = super(HostMetaInfoTestCase, self).makeRepo()
- # get models
- models = {}
- models['bundle'] = GenericResourceBundle()
- # make generic hosts
- gres1 = GenericResource(bundle=models['bundle'])
- prof1 = HostProfile.objects.get(name="Test profile 0")
- ghost1 = GenericHost(profile=prof1, resource=gres1)
-
- gres2 = GenericResource(bundle=models['bundle'])
- prof2 = HostProfile.objects.get(name="Test profile 3")
- ghost2 = GenericHost(profile=prof2, resource=gres2)
- models['hosts'] = [ghost1, ghost2]
- repo.el[repo.GRESOURCE_BUNDLE_MODELS] = models
- return repo
-
- def test_step_with_good_data(self):
- data = {"form-INITIAL_FORMS": 2, "form-MAX_NUM_FORMS": 1000}
- data["form-MIN_NUM_FORMS"] = 0
- data["form-TOTAL_FORMS"] = 2
- data['form-0-host_name'] = "first host"
- data['form-1-host_name'] = "second host"
- response, context = self.step_test(Host_Meta_Info, data)
-
- def test_step_with_bad_data(self): # TODO
- data = {"form-INITIAL_FORMS": 0, "form-MAX_NUM_FORMS": 1000}
- data["form-MIN_NUM_FORMS"] = 0
- data["form-TOTAL_FORMS"] = 0
- response, context = self.step_test(Host_Meta_Info, data)
-
- def test_step_with_empty_data(self):
- data = {"form-INITIAL_FORMS": 0, "form-MAX_NUM_FORMS": 1000}
- data["form-MIN_NUM_FORMS"] = 0
- data["form-TOTAL_FORMS"] = 0
- response, context = self.step_test(Host_Meta_Info, data)
-
-
class DefineNetsTestCase(BaseStepTestCase):
def test_step_with_good_data(self):
Code Review / laas.git / commitdiff