def _get_netscaler_tasks_for_update_op(self, loadBalancerId,
updatedLoadBalancer):
self.logger.debug("Assembling required tasks for update operation")
task_list = []
if not all([loadBalancerId, updatedLoadBalancer]):
raise ImplementationErrorException("Programming error")
newLoadBalancerId = None
if "name" in updatedLoadBalancer:
existing_name = NitroUtils.get_loadBalancer_name(loadBalancerId)
if updatedLoadBalancer.name != existing_name:
self.logger.debug("We need to queue a name change task")
""" Because the internal ID depends on the name, a name change results in a new ID """
newLoadBalancerId = NitroUtils.get_new_internal_loadBalancerId(
loadBalancerId, updatedLoadBalancer)
namechange_task = self._get_netscaler_renameloadbalancer_task(
loadBalancerId, newLoadBalancerId, updatedLoadBalancer)
task_list.append(namechange_task)
self.logger.debug("Adding an lbvserver update task")
task = self._get_netscaler_updateloadbalancer_task(
loadBalancerId, updatedLoadBalancer, newLoadBalancerId)
task_list.append(task)
""" We also may need to change the services and other affected Netscaler resources """
tasks = self._get_netscaler_updatenodes_tasks(loadBalancerId,
updatedLoadBalancer,
newLoadBalancerId)
task_list.extend(tasks)
return task_list
def _get_loadbalancer_object_from_lbvserver_entity(self, loadBalancerId,
dict_obj):
lbvserver_name = str(dict_obj["name"])
expected_name = NitroUtils.get_lbvservername_from_loadbalancerid(
loadBalancerId)
if lbvserver_name != expected_name:
raise ImplementationError("resource returned not expected...")
loadBalancer = self._get_new_loadBalancer_object()
loadBalancer.name = NitroUtils.get_loadBalancer_name(loadBalancerId)
servicetype = str(dict_obj["servicetype"])
loadBalancer.protocol = NitroUtils.get_protocol_from_servicetype(
servicetype)
port = str(dict_obj["port"])
loadBalancer.port = port
lbmethod = str(dict_obj["lbmethod"])
loadBalancer.algorithm = NitroUtils.get_algorithm_from_lbmethod(
lbmethod)
effectivestate = str(dict_obj["effectivestate"])
loadBalancer.status = NitroUtils.get_loadbalancerstatus_from_state(
effectivestate)
i = 1
loadBalancer.virtualIps = []
virtualIP = LBVirtualIPState(self.lbresource)
ipaddress = str(dict_obj["ipv46"])
virtualIP.address = ipaddress
self.logger.debug("VIP for loadbalancer %s is %s" %
(loadBalancer.name, ipaddress))
loadBalancer.virtualIps.append(virtualIP)
""" Get Session Persistence data """
persistencetype = str(dict_obj["persistencetype"])
self.logger.debug("persistencetype of lbvserver is %s" %
persistencetype)
if persistencetype != 'NONE':
if self.extensions_enabled:
sessionPersistence = NetScalerLBSessionPersistenceState(
self.lbresource)
else:
sessionPersistence = LBSessionPersistenceState(self.lbresource)
persistencevalue = NitroUtils.get_persistencetype_from_nspersistencetype(
persistencetype)
if persistencevalue:
sessionPersistence.persistenceType = persistencevalue
if self.extensions_enabled:
timeout = str(dict_obj["timeout"])
if timeout != None:
sessionPersistence.timeout = timeout
loadBalancer.sessionPersistence = sessionPersistence
""" Get Connection Logging data """
"""
if self.extensions_enabled:
loadBalancer.connectionLogging = NetScalerLBConnectionLoggingState(self.lbresource)
else:
loadBalancer.connectionLogging = LBConnectionLoggingState(self.lbresource)
appflow = str(dict_obj["appflowlog"])
if appflow == "ENABLED":
loadBalancer.connectionLogging.enabled="true"
else:
loadBalancer.connectionLogging.enabled="false"
loadBalancer.connectionThrottle = LBConnectionThrottleState(self.lbresource)
loadBalancer.connectionThrottle.minConnections = "10"
loadBalancer.connectionThrottle.maxConnections = "100"
loadBalancer.connectionThrottle.maxConnectionRate = "50"
loadBalancer.connectionThrottle.rateInterval = "60"
"""
if self.lbservice.cluster:
loadBalancer.cluster = {}
loadBalancer.cluster["name"] = self.lbservice.cluster
else:
loadBalancer.cluster = {}
loadBalancer.cluster["name"] = "none"
if self.extensions_enabled:
sc = str(dict_obj["sc"])
if sc == "ON":
loadBalancer.sureConnect = "true"
else:
loadBalancer.sureConnect = "false"
"""
if appflow == "ENABLED":
loadBalancer.connectionLogging.type="appflow"
"""
return loadBalancer
