130 lines
4.3 KiB
Python
Executable File
130 lines
4.3 KiB
Python
Executable File
#
|
|
# Copyright (c) 2016 Wind River Systems, Inc.
|
|
#
|
|
# The right to copy, distribute, modify, or otherwise make use
|
|
# of this software may be licensed only pursuant to the terms
|
|
# of an applicable Wind River license agreement.
|
|
#
|
|
|
|
import logging
|
|
import urlparse
|
|
|
|
from openstack_dashboard.api import base
|
|
|
|
from nfv_client.openstack import sw_update
|
|
|
|
LOG = logging.getLogger(__name__)
|
|
|
|
|
|
STRATEGY_SW_PATCH = 'sw-patch'
|
|
STRATEGY_SW_UPGRADE = 'sw-upgrade'
|
|
|
|
|
|
class Client(object):
|
|
def __init__(self, url, token_id):
|
|
self.url = url
|
|
self.token_id = token_id
|
|
|
|
def get_strategy(self, strategy_name):
|
|
return sw_update.get_strategies(self.token_id, self.url, strategy_name)
|
|
|
|
def create_strategy(
|
|
self, strategy_name, controller_apply_type, storage_apply_type,
|
|
swift_apply_type, compute_apply_type, max_parallel_compute_hosts,
|
|
default_instance_action, alarm_restrictions):
|
|
return sw_update.create_strategy(
|
|
self.token_id, self.url, strategy_name, controller_apply_type,
|
|
storage_apply_type,
|
|
swift_apply_type, compute_apply_type, max_parallel_compute_hosts,
|
|
default_instance_action, alarm_restrictions)
|
|
|
|
def delete_strategy(self, strategy_name, force):
|
|
return sw_update.delete_strategy(self.token_id, self.url,
|
|
strategy_name, force)
|
|
|
|
def apply_strategy(self, strategy_name, stage_id):
|
|
return sw_update.apply_strategy(self.token_id, self.url, strategy_name,
|
|
stage_id)
|
|
|
|
def abort_strategy(self, strategy_name, stage_id):
|
|
return sw_update.abort_strategy(self.token_id, self.url, strategy_name,
|
|
stage_id)
|
|
|
|
|
|
def _sw_update_client(request):
|
|
o = urlparse.urlparse(base.url_for(request, 'nfv'))
|
|
url = "://".join((o.scheme, o.netloc))
|
|
return Client(url, token_id=request.user.token.id)
|
|
|
|
|
|
def get_strategy(request, strategy_name):
|
|
strategy = _sw_update_client(request).get_strategy(strategy_name)
|
|
return strategy
|
|
|
|
|
|
def create_strategy(
|
|
request, strategy_name, controller_apply_type, storage_apply_type,
|
|
swift_apply_type, compute_apply_type, max_parallel_compute_hosts,
|
|
default_instance_action, alarm_restrictions):
|
|
strategy = _sw_update_client(request).create_strategy(
|
|
strategy_name, controller_apply_type, storage_apply_type,
|
|
swift_apply_type, compute_apply_type, max_parallel_compute_hosts,
|
|
default_instance_action, alarm_restrictions)
|
|
return strategy
|
|
|
|
|
|
def delete_strategy(request, strategy_name, force=False):
|
|
response = _sw_update_client(request).delete_strategy(strategy_name, force)
|
|
return response
|
|
|
|
|
|
def apply_strategy(request, strategy_name, stage_id=None):
|
|
response = _sw_update_client(request).apply_strategy(strategy_name,
|
|
stage_id)
|
|
return response
|
|
|
|
|
|
def abort_strategy(request, strategy_name, stage_id=None):
|
|
response = _sw_update_client(request).abort_strategy(strategy_name,
|
|
stage_id)
|
|
return response
|
|
|
|
|
|
def get_stages(request, strategy_name):
|
|
strategy = _sw_update_client(request).get_strategy(strategy_name)
|
|
if not strategy:
|
|
return []
|
|
stages = []
|
|
for stage in strategy.build_phase.stages:
|
|
phase = strategy.build_phase
|
|
phase.stages = None
|
|
stage.phase = phase
|
|
stages.append(stage)
|
|
for stage in strategy.apply_phase.stages:
|
|
phase = strategy.apply_phase
|
|
phase.stages = None
|
|
stage.phase = phase
|
|
stages.append(stage)
|
|
for stage in strategy.abort_phase.stages:
|
|
phase = strategy.abort_phase
|
|
phase.stages = None
|
|
stage.phase = phase
|
|
stages.append(stage)
|
|
|
|
return stages
|
|
|
|
|
|
def get_stage(request, strategy_name, phase_name, stage_id):
|
|
stages = get_stages(request, strategy_name)
|
|
for stage in stages:
|
|
if stage.phase.phase_name == phase_name and \
|
|
str(stage.stage_id) == str(stage_id):
|
|
return stage
|
|
|
|
|
|
def get_step(request, strategy_name, phase_name, stage_id, step_id):
|
|
stage = get_stage(request, strategy_name, phase_name, stage_id)
|
|
for step in stage.steps:
|
|
if str(step.step_id) == str(step_id):
|
|
return step
|