def scaleout_choose_worker(request):
chosen_role = request.session[SESSION_VAR_ROLE]
if chosen_role == None:
return redirect('scaleout_choose_role')
text = "Please specify which worker you wish to use to add the " + \
"extra capacity:"
header = "Scale out Cloud - Choose Worker"
def on_form_valid(form, service, roles):
chosen_role = request.session[SESSION_VAR_ROLE]
worker = form.get_clean_worker()
if chosen_role == Role.NOVA_COMPUTE:
scaleout_task_id = svc.Compute.add_workers([worker], {})
request.session[SESSION_SCALEOUT_TASK_ID] = scaleout_task_id
elif chosen_role == Role.NOVA_API:
scaleout_task_id = svc.Compute.add_apis([worker], {})
request.session[SESSION_SCALEOUT_TASK_ID] = scaleout_task_id
return redirect('install_checklist')
def update_form(form, service, roles):
node_fqdns = service.Node.exclude_by_roles([chosen_role])
node_details = service.Node.get_details(node_fqdns)
form.add_workers_into_form(node_details)
return utils.generate_form_request_handler(header,
text,
on_form_valid=on_form_valid,
update_form=update_form,
svc_proxy=svc)(request)
def select_vpx(request):
text = ("Select two VPXs: the first one is the node whose roles "
"and configs need to be rolled over a brand new VPX.")
header = "Upgrade VPX - Select VPX Node"
def on_form_valid(form, service, roles):
o_vpx = form.cleaned_data['old_vpx']
n_vpx = form.cleaned_data['new_vpx']
request.session[SESSION_VAR_OLD_VPX] = o_vpx
request.session[SESSION_VAR_NEW_VPX] = n_vpx
return shortcuts.redirect('confirm_vpx')
def update_form(form, service, roles):
roles = request.session[SESSION_VAR_OS_WORKER_ROLES]
o_vpxs = service.Node.get_by_roles(eval(roles))
n_vpxs = _get_new_nodes()
form.load_nodes(service.Node.get_details(o_vpxs), n_vpxs)
return utils.generate_form_request_handler(
header,
text,
on_form_valid=on_form_valid,
django_form=upgrade.MigrationWizardForm,
update_form=update_form,
svc_proxy=svc)(request)
def setup_imaging(request):
header = "OpenStack Imaging"
text = "Please choose the node for the OpenStack Imaging API and" + \
" OpenStack Imaging Registry."
def on_form_valid(form, service, roles):
glance_store = form.cleaned_data["default_storage"]
extra_data = form.cleaned_data["extra_data"]
config = {}
config[ConfigClassParameter.GLANCE_STORE] = glance_store
if glance_store == "file":
config[ConfigClassParameter.GLANCE_FILE_STORE_SIZE_GB] = extra_data
else:
config[ConfigClassParameter.GLANCE_SWIFT_ADDRESS] = extra_data
worker = form.get_clean_worker()
config[ConfigClassParameter.GLANCE_HOSTNAME] = worker
imaging_task_id = service.Imaging.add_registry(worker, config)
request.session[IMAGING_TASK_ID] = imaging_task_id
return redirect('install_checklist')
def update_form(form, service, roles):
node_fqdns = service.Node.exclude_by_roles([Role.GLANCE_API])
node_details = service.Node.get_details(node_fqdns)
form.add_workers_into_form(node_details)
nodes = service.Node.get_by_role(Role.SWIFT_PROXY)
swift_proxy = nodes[0] if len(nodes) == 1 else ''
form.update_swift_api_hostname(swift_proxy)
return utils.generate_form_request_handler(header, text,
on_form_valid=on_form_valid,
django_form=SetupGlance,
update_form=update_form,
svc_proxy=svc)(request)
def setup_network_worker(request):
text = "Please choose the node for the OpenStack Compute Network " + \
"Worker. This is responsible for issuing IP addresses to " + \
"virtual machine instances."
header = "OpenStack Network Worker"
def on_form_valid(form, service, roles):
config = request.session["config"]
if config["MODE"] == "vlan" or config["MODE"] == "flatdhcp":
request.session[SESSION_NETWORK_WORKER] = form.get_clean_worker()
request.session["config"] = config
return redirect('setup_network_public_vif')
else:
#Nothing else to do!
_make_request(request, form, NOVA_MANAGEMENT_TASK_ID,
lambda s, w: s.Network.add_workers([w], config))
return redirect('setup_complete')
def update_form(form, service, roles):
_add_unused_workers(form, service, [Role.NOVA_NETWORK])
return utils.generate_form_request_handler(header, text,
on_form_valid=on_form_valid,
django_form=ChooseWorkerForm,
update_form=update_form,
svc_proxy=svc)(request)
def setup_worker(request):
text = "Please select which OpenStack VPX you want to be the " + \
"OpenStack Volume Worker, along with what type of block " + \
"storage you want."
header = "OpenStack Volume Worker"
def on_form_valid(form, service, roles):
storage_type = form.cleaned_data["storage_type"]
worker = form.get_clean_worker()
config = {}
config["TYPE"] = storage_type
request.session["config"] = config
if storage_type == "iscsi":
request.session[SESSION_VAR_BLOCK_WORKER] = worker
return redirect('setup_block_storage_iscsi')
elif storage_type == "xenserver_sm":
request.session[SESSION_VAR_BLOCK_WORKER] = worker
return redirect('setup_block_storage_sm')
else:
raise Exception("Invalid Storage Type")
def update_form(form, service, roles):
node_fqdns = service.Node.exclude_by_roles([Role.NOVA_VOLUME])
node_details = service.Node.get_details(node_fqdns)
form.add_workers_into_form(node_details)
return utils.generate_form_request_handler(header,
text,
on_form_valid=on_form_valid,
django_form=ChooseBlockStorage,
update_form=update_form,
svc_proxy=svc)(request)
def static_network(request):
geppetto_service = utils.get_geppetto_web_service_client()
text = "Please specify the static network settings for the VPX for " + \
"your public network."
header = "Publish Service - Static Network"
def on_form_valid(form, service, roles):
ipaddress = form.cleaned_data["ip_address"]
netmask = form.cleaned_data["netmask"]
worker = request.session[SESSION_VAR_WORKER]
overrides = {
ConfigClassParameter.PUBLIC_NW_VIF_IP: ipaddress,
ConfigClassParameter.PUBLIC_NW_VIF_NETMASK: netmask
}
service.Config.add_node_overrides(worker, overrides)
request.session[SESSION_VAR_WORKER] = None
return redirect('install_checklist')
def update_form(form, service, roles):
form.update_worker(request.session[SESSION_VAR_WORKER])
return utils.generate_form_request_handler(
header,
text,
on_form_valid=on_form_valid,
django_form=DefineStaticNetwork,
update_form=update_form,
svc_proxy=geppetto_service)(request)
def lbservice(request):
dummy_tenants = ["Administrator"]
text = "Please select what Load Balancer operation you require:"
header = "Load Balancer Service"
def on_form_valid(form, service, roles):
request.session[SESSION_LB_TENANT] = form.cleaned_data["tenant"]
operation = form.cleaned_data["operation"]
if operation == "list":
return redirect('lbservice_list')
if operation == "add":
return redirect('lbservice_select_vms')
if operation == "delete":
return redirect('lbservice_delete')
def update_form(form, service, roles):
form.add_tenants_into_form(dummy_tenants)
# TODO - need real list of tenants...
return utils.generate_form_request_handler(
header,
text,
on_form_valid=on_form_valid,
django_form=LoadBalancerAction,
update_form=update_form)(request)
def configure_lbaas(request):
text = ("Please choose a VPX which you want to deploy the LB Service "
"on. Also, insert the IP address of the NetScaler you are "
"using and the range of IP addresses which the LB Service is "
"going to allocate (e.g. 192.168.1.50-192.168.1.100).")
header = "LBaaS Setup - NetScaler Integration"
def on_form_valid(form, service, roles):
config = {ConfigClassParameter.\
NS_VPX_HOST: form.cleaned_data['netscaler'],
ConfigClassParameter.\
NS_VPX_VIPS: form.cleaned_data['virtual_ips'],
ConfigClassParameter.\
VPX_LABEL_PREFIX: 'Load Balancer'}
# FIXME(armandomi): track the task
service.LBaaS.add_api(form.cleaned_data["worker"], config)
return redirect('install_checklist')
def update_form(form, service, roles):
node_fqdns = service.Node.exclude_by_roles([Role.LBSERVICE])
node_details = service.Node.get_details(node_fqdns)
form.add_workers_into_form(node_details)
return utils.generate_form_request_handler(header,
text,
on_form_valid=on_form_valid,
django_form=ConfigureLBaaSForm,
update_form=update_form,
svc_proxy=svc)(request)
def setup_nova_ajax_console_proxy(request):
text = "Choose a node to run the OpenStack Text Console Proxy service."
header = "OpenStack Text Console Proxy"
def on_form_valid(form, service, roles):
_make_request(request, form, AJAX_CONSOLE_PROXY_TASK_ID,
lambda s, w: s.Compute.add_ajax_console_proxies([w], {}))
return redirect('install_checklist')
def update_form(form, service, roles):
_add_unused_workers(form, service, [Role.NOVA_AJAX_CONSOLE_PROXY])
return utils.generate_form_request_handler(header, text,
on_form_valid=on_form_valid,
update_form=update_form,
svc_proxy=svc)(request)
def lbservice_info(request):
text = "There has been an error during the communication with the " + \
"service: %s" % request.session['LBAAS_LAST_ERROR']
header = "LBaaS Communication Failure"
def on_form_valid(form, service, roles):
return redirect('install_checklist')
def update_form(form, service, roles):
pass
return utils.generate_form_request_handler(
header,
text,
on_form_valid=on_form_valid,
django_form=LBaaSInfoForm,
update_form=update_form)(request)
def setup_swift_storage_size(request):
text = ("Two identically sized disks will be added to each of your "
"Object Storage Workers. Please specify the size of those disks.")
header = "OpenStack Object Storage - Disk Size"
def on_form_valid(form, service, roles):
size = form.cleaned_data["size"]
request.session[SWIFT_DISK_SIZE] = size
return redirect('setup_swift_storage')
def update_form(form, service, roles):
pass
return utils.generate_form_request_handler(header, text,
on_form_valid=on_form_valid,
django_form=SwiftStorageSizeForm,
update_form=update_form)(request)
def setup_scheduler(request):
text = "Please choose the node for the OpenStack Compute Scheduler. " + \
"This is used by the cloud controller to pick which Compute " + \
"worker to use for new virtual machine instances."
header = "OpenStack Compute Scheduler"
def on_form_valid(form, service, roles):
_make_request(request, form, NOVA_SCHEDULER_TASK_ID,
lambda s, w: s.Scheduling.add_workers([w], {}))
return redirect('install_checklist')
def update_form(form, service, roles):
_add_unused_workers(form, service, [Role.NOVA_SCHEDULER])
return utils.generate_form_request_handler(header, text,
on_form_valid=on_form_valid,
update_form=update_form,
svc_proxy=svc)(request)
def setup_nova_api(request):
text = "Please choose the node for the OpenStack Compute API. This" + \
" worker will run both the OpenStack Compute API service and " + \
"the OpenStack Dashboard."
header = "OpenStack Compute API"
def on_form_valid(form, service, roles):
_make_request(request, form, NOVA_API_TASK_ID,
lambda s, w: s.Compute.add_apis([w], {}))
return redirect('setup_scheduler')
def update_form(form, service, roles):
_add_unused_workers(form, service, [Role.NOVA_API])
return utils.generate_form_request_handler(header, text,
on_form_valid=on_form_valid,
update_form=update_form,
svc_proxy=svc)(request)
def setup_swift_hash_path_suffix(request):
text = ("A suffix value should be set to some random string of text "
"to be used as a salt when hashing to determine mappings "
"in the swift ring. This should be the same on every node "
"in the cluster.")
header = "OpenStack Object Storage - Hash Path Suffix"
def on_form_valid(form, service, roles):
request.session[SWIFT_HASH_PATH_SUFFIX] = \
form.cleaned_data["hash_path_suffix"]
return redirect('setup_swift_storage_size')
def update_form(form, service, roles):
pass
return utils.generate_form_request_handler(header, text,
on_form_valid=on_form_valid,
django_form=SwiftHashPathSuffixForm,
update_form=update_form)(request)
def lbservice_finish(request):
text = "Your load balancer has now been setup. Below is the load " + \
"balanced URL."
header = "Publish Service - Added"
if request.session[SESSION_LB_URL] == None:
return redirect('lbservice')
def on_form_valid(form, service, roles):
request.session[SESSION_LB_URL] = None
return redirect('install_checklist')
def update_form(form, service, roles):
form.update_url(request.session[SESSION_LB_URL])
return utils.generate_form_request_handler(
header,
text,
on_form_valid=on_form_valid,
django_form=LoadBalancerURL,
update_form=update_form)(request)
def setup_iscsi(request):
text = "Please specify the disk size for the given worker."
header = "OpenStack Volume Worker - iSCSI Setup"
def on_form_valid(form, service, roles):
disk_size = form.cleaned_data["disk_size"]
config = request.session["config"]
config[ConfigClassParameter.VOLUME_DISK_SIZE_GB] = disk_size
request.session["config"] = config
return redirect('setup_block_complete')
def update_form(form, service, roles):
form.update_worker(request.session[SESSION_VAR_BLOCK_WORKER])
return utils.generate_form_request_handler(
header,
text,
on_form_valid=on_form_valid,
django_form=DefineISCSIDiskSize,
update_form=update_form)(request)
def setup_swift_storage(request):
text = ("Please choose which workers should be OpenStack Object Storage "
"Workers. You must choose a minimum of three nodes.")
header = "OpenStack Object Storage - Object Storage Workers"
def on_form_valid(form, service, roles):
workers = form.clean_workers()
request.session[SWIFT_STORAGE_NODE_HOSTNAMES] = workers
return redirect('setup_swift_api')
def update_form(form, service, roles):
node_fqdns = service.Node.exclude_by_roles([Role.SWIFT_OBJECT])
node_details = service.Node.get_details(node_fqdns)
form.add_workers_into_form(node_details)
return utils.generate_form_request_handler(header, text,
on_form_valid=on_form_valid,
django_form=MultipleChoiceWorkerForm,
update_form=update_form,
svc_proxy=svc)(request)
def scaleout_choose_role(request):
text = "Please specify for which role you wish to add extra capacity."
header = "Scale out Cloud - Choose Role"
def on_form_valid(form, service, roles):
type_of_node = form.cleaned_data["type_of_node"]
if type_of_node == "nova-compute":
request.session[SESSION_VAR_ROLE] = Role.NOVA_COMPUTE
elif type_of_node == "nova-api":
request.session[SESSION_VAR_ROLE] = Role.NOVA_API
return redirect('scaleout_choose_worker')
def update_form(form, service, roles):
pass
return utils.generate_form_request_handler(
header,
text,
on_form_valid=on_form_valid,
django_form=ScaleOutChooseRole,
update_form=update_form)(request)
def confirm_vpx(request):
text = ("You are about to migrate roles and configuration from "
"%s to %s. Please note, all roles will be migrated, and "
"%s will be no longer in use. Click Next to continue." %
(request.session[SESSION_VAR_OLD_VPX],
request.session[SESSION_VAR_NEW_VPX],
request.session[SESSION_VAR_OLD_VPX]))
header = "Upgrade VPX - Confirmation"
def on_form_valid(form, service, roles):
return shortcuts.redirect('migrate_vpx')
def update_form(form, service, roles):
pass
return utils.generate_form_request_handler(
header,
text,
on_form_valid=on_form_valid,
django_form=upgrade.WarningWizardForm,
update_form=update_form)(request)
def setup_identity(request):
header = "OpenStack Identity"
text = "Please choose which OpenStack-VPX will run the OpenStack " + \
"Identity service."
def on_form_valid(form, service, roles):
worker = form.get_clean_worker()
geppetto_service = utils.get_geppetto_web_service_client()
identity_task_id = geppetto_service.Identity.add_auth(worker, {})
request.session[IDENTITY_TASK_ID] = identity_task_id
return redirect('install_checklist')
def update_form(form, service, roles):
node_fqdns = service.Node.exclude_by_roles([Role.KEYSTONE_AUTH])
node_details = service.Node.get_details(node_fqdns)
form.add_workers_into_form(node_details)
return utils.generate_form_request_handler(header, text,
on_form_valid=on_form_valid,
update_form=update_form,
svc_proxy=svc)(request)
def setup_mysql(request):
header = "Database"
text = "Please choose which OpenStack-VPX will run the MySQL database" + \
". Alternatively, you can use an existing external server."
def update_form(form, service, roles):
node_fqdns = service.Node.exclude_by_roles([Role.MYSQL])
node_details = service.Node.get_details(node_fqdns)
form.add_workers_into_form_plus_external(node_details)
def on_form_valid(form, service, roles):
worker = form.get_clean_worker()
if worker == "external":
return redirect('setup_mysql_external')
request.session[MYSQL_WORKER] = worker
return utils.generate_form_request_handler(header, text,
on_form_valid=on_form_valid,
update_form=update_form,
finish_page="progress_mysql_rabbitmq",
svc_proxy=svc)(request)
def nova_manage_register(request):
text = "The upload process has succeded. \
Please, click the next button to start the \
registration process. This will import the \
images into the registry, and may take a while \
depending on your storage back-end (i.e. \
Swift, file system etc)."
header = "Community Images Registration"
def on_form_valid(form, service, roles):
geppetto_service = utils.get_geppetto_web_service_client()
auth_token = geppetto_service.Config.get(\
ConfigClassParameter.KEYSTONE_SUPERUSER_TOKEN)
requested_ostype = None
if ('kernel' in request.session) and ('ramdisk' in request.session):
_nova_manage_register(auth_token, request.session['label'],
request.session['machine'],
request.session['kernel'],
request.session['ramdisk'],
request.session['hypervisor'])
else:
if request.session['hypervisor'] == 'esx':
requested_ostype = request.session['ostype']
_nova_manage_register(auth_token, request.session['label'],
request.session['machine'], None, None,
request.session['hypervisor'],
requested_ostype)
return redirect('install_checklist')
def update_form(form, service, roles):
pass
return utils.generate_form_request_handler(
header,
text,
on_form_valid=on_form_valid,
django_form=ImportPrepForm,
update_form=update_form)(request)
def setup_network_public_vif_static(request):
text = "Please specify the static network settings for the public " \
"network on the OpenStack-VPX."
header = "OpenStack Network Worker - Static Network Settings"
def on_form_valid(form, service, roles):
ipaddress = form.cleaned_data["ip_address"]
netmask = form.cleaned_data["netmask"]
config = request.session["config"]
config[ConfigClassParameter.GUEST_NW_VIF_IP] = ipaddress
config[ConfigClassParameter.GUEST_NW_VIF_NETMASK] = netmask
request.session["config"] = config
return redirect('setup_network_service')
def update_form(form, service, roles):
form.update_worker(request.session.get(SESSION_NETWORK_WORKER,
'You should not see me!'))
return utils.generate_form_request_handler(header, text,
on_form_valid=on_form_valid,
django_form=DefineStaticNetwork,
update_form=update_form)(request)
def setup_rabbitmq(request):
header = "Message Queue"
text = "Please choose which OpenStack-VPX will run the RabbitMQ " + \
"message queue service. Alternatively, you can use an existing" + \
" external server."
def on_form_valid(form, service, roles):
worker = form.get_clean_worker()
if worker == "external":
return redirect('setup_rabbitmq_external')
request.session[RABBIT_WORKER] = worker
def update_form(form, service, roles):
node_fqdns = service.Node.exclude_by_roles([Role.RABBITMQ])
node_details = service.Node.get_details(node_fqdns)
form.add_workers_into_form_plus_external(node_details)
return utils.generate_form_request_handler(header, text,
on_form_valid=on_form_valid,
update_form=update_form,
finish_page="setup_mysql",
svc_proxy=svc)(request)
def setup_swift_api(request):
if (request.session[SWIFT_STORAGE_NODE_HOSTNAMES] == None) or \
(request.session[SWIFT_DISK_SIZE] == None):
return redirect('setup_swift_start')
text = ("Please choose the node to become the Object Storage API. This "
"server will give users, and the Imaging Service, access to "
"items stored in the Object Storage system. You will be able "
"to access this through the URL https://<hostname>/auth/v1.0")
header = "OpenStack Object Storage - Object Storage API"
def on_form_valid(form, service, roles):
hash_suff = request.session[SWIFT_HASH_PATH_SUFFIX]
service.Config.set(ConfigClassParameter.SWIFT_HASH_PATH_SUFFIX,
hash_suff)
proxy = form.get_clean_worker()
request.session[SWIFT_PROXY_SETUP_TASK_ID] = service.\
ObjectStorage.add_apis([proxy], {})
storage_nodes = request.session[SWIFT_STORAGE_NODE_HOSTNAMES]
disk_size = request.session[SWIFT_DISK_SIZE]
request.session[SWIFT_RING_SETUP_TASK_ID] = service.\
ObjectStorage.add_workers(storage_nodes,
{ConfigClassParameter.\
SWIFT_DISK_SIZE_GB: disk_size})
del request.session[SWIFT_STORAGE_NODE_HOSTNAMES]
del request.session[SWIFT_DISK_SIZE]
return redirect('setup_swift_progress')
def update_form(form, service, roles):
node_fqdns = service.Node.exclude_by_roles([Role.SWIFT_PROXY])
node_details = service.Node.get_details(node_fqdns)
form.add_workers_into_form(node_details)
return utils.generate_form_request_handler(header, text,
on_form_valid=on_form_valid,
update_form=update_form,
svc_proxy=svc)(request)
def add_compute_node(request):
text = "You need an OpenStack Compute Worker running on every " \
"Hypervisor on which you wish to run VM instances. There " \
"must be only one per physical machine."
header = "OpenStack Compute Worker"
svc = utils.get_geppetto_web_service_client()
def on_form_valid(form, service, roles):
worker = form.get_clean_worker()
copute_worker_task_id = service.Compute.add_workers([worker], {})
request.session[COMPUTE_WORKER_TASK_ID] = copute_worker_task_id
return redirect('install_checklist')
def update_form(form, service, roles):
node_fqdns = service.Node.exclude_by_roles([Role.NOVA_COMPUTE])
node_details = service.Node.get_details(node_fqdns)
form.add_workers_into_form(node_details)
return utils.generate_form_request_handler(header, text,
on_form_valid=on_form_valid,
update_form=update_form,
svc_proxy=svc)(request)
def setup_network(request):
text = "Please specify how virtual machine instance networking " \
"should be managed. The networking mode will determine the " \
"layer-2/layer-3 network model." \
"Enabling HA networking will limit the effect of " \
"failures to a single host, and reduce network traffic on " \
"network workers."
header = "OpenStack Network Configuration"
def on_form_valid(form, service, roles):
config = {}
mode = form.cleaned_data["networking_mode"]
multi_host = form.cleaned_data["multi_host"]
config["MULTI_HOST"] = multi_host
config["MODE"] = mode
request.session["config"] = config
next_header = "Settings for %s networking " \
"Virtual Interface" \
% (config["MODE"] == 'vlan' and
"vLAN" or "Flat DHCP")
request.session['next_header'] = next_header
redirect_to = 'setup_network_worker'
if multi_host:
redirect_to = (mode == 'flat') and 'setup_network_service' \
or 'setup_network_public_vif'
return redirect(redirect_to)
def update_form(form, service, roles):
#NOOP at the moment
#Put current value of multi_host here!
pass
return utils.generate_form_request_handler(header, text,
on_form_valid=on_form_valid,
django_form=SetupNetwork,
update_form=update_form)(request)
def setup_mysql_external(request):
header = "Database - External"
text = "Please specify the connection details for the MySQL server."
def on_form_valid(form, service, roles):
service.Config.set(ConfigClassParameter.MYSQL_TYPE, "external")
service.Config.set(ConfigClassParameter.MYSQL_HOST,
form.cleaned_data["hostname"])
service.Config.set(ConfigClassParameter.MYSQL_USER,
form.cleaned_data["username"])
service.Config.set(ConfigClassParameter.MYSQL_PASS,
form.cleaned_data["password"])
request.session[MYSQL_WORKER] = EXTERNAL_WORKER
def update_form(form, service, roles):
pass
return utils.generate_form_request_handler(header, text,
on_form_valid=on_form_valid,
django_form=ExternalMySQL,
update_form=update_form,
finish_page="progress_mysql_rabbitmq",
svc_proxy=svc)(request)
def select_role(request):
text = ("Please, select a role in order to choose which worker "
"you would like to upgrade.")
header = "Upgrade VPX - Select OpenStack Worker"
def on_form_valid(form, service, roles):
request.session[SESSION_VAR_OS_WORKER_ROLES] = \
form.cleaned_data['openstack_worker']
request.session[SESSION_VAR_OS_WORKER_LABEL] = \
form.get_openstack_worker_label(form.\
cleaned_data['openstack_worker'])
return shortcuts.redirect('select_vpx')
def update_form(form, service, roles):
form.load_worker_roles(service.Role.get_compositions())
return utils.generate_form_request_handler(
header,
text,
on_form_valid=on_form_valid,
django_form=upgrade.SelectWizardForm,
update_form=update_form,
svc_proxy=svc)(request)
def setup_rabbitmq_external(request):
header = "Message Queue - External"
text = "Please specify the connection details for the RabbitMQ server."
def on_form_valid(form, service, roles):
service.Config.set(ConfigClassParameter.RABBIT_HOST,
form.cleaned_data["hostname"])
service.Config.set(ConfigClassParameter.RABBIT_PORT,
form.cleaned_data["port"])
service.Config.set(ConfigClassParameter.RABBIT_USER,
form.cleaned_data["username"])
service.Config.set(ConfigClassParameter.RABBIT_PASS,
form.cleaned_data["password"])
request.session[RABBIT_WORKER] = EXTERNAL_WORKER
def update_form(form, service, roles):
pass
return utils.generate_form_request_handler(header, text,
on_form_valid=on_form_valid,
django_form=ExternalRabbitMQ,
update_form=update_form,
finish_page="setup_mysql",
svc_proxy=svc)(request)
