def _get_netscaler_renameloadbalancer_task(self, loadBalancerId,
newLoadBalancerId,
loadBalancer):
if not all([loadBalancerId, newLoadBalancerId, loadBalancer
]) or not "name" in loadBalancer:
raise ImplementationError("programming error")
existing_name = NitroUtils.get_lbvservername_from_loadbalancerid(
loadBalancerId)
new_name = NitroUtils.get_lbvservername_from_loadbalancerid(
newLoadBalancerId)
task = {}
task["name"] = existing_name
task["type"] = "lbvserver"
task["operation"] = "RENAME"
obj = {}
obj["name"] = existing_name
obj["newname"] = new_name
task["state"] = obj
return task
def _get_netscaler_updateloadbalancer_task(self,
loadBalancerId,
loadBalancer,
newLoadBalancerId=None):
task_list = []
self.logger.debug("About to get lbvserver state")
if newLoadBalancerId:
lbvserver_name = NitroUtils.get_lbvservername_from_loadbalancerid(
newLoadBalancerId)
else:
lbvserver_name = NitroUtils.get_lbvservername_from_loadbalancerid(
loadBalancerId)
lbvserver = self._get_lbvserver_state(lbvserver_name, loadBalancer)
lbvserver = self._adjust_lbvserver_state_for_update(
loadBalancerId, lbvserver)
if not lbvserver:
return None
if len(lbvserver.keys()) <= 1:
""" There is no field to update on the lbvserver, so no need for an update task """
return None
task = {}
task["type"] = "lbvserver"
task["name"] = lbvserver_name
task["operation"] = "UPDATE"
task["state"] = lbvserver
return task
def get_netscaler_getservicebindings_task(self, loadBalancerId, loadBalancer):
lbvserver_name = NitroUtils.get_lbvservername_from_loadbalancerid(loadBalancerId)
task = {}
task["type"] = "lbvserver_service_binding"
task["name"] = lbvserver_name
task["operation"] = "GET"
task["state"] = None
return task
def _get_netscaler_removeloadbalancer_task(self, loadBalancerId):
lbvserver_name = NitroUtils.get_lbvservername_from_loadbalancerid(
loadBalancerId)
task = {}
task["type"] = "lbvserver"
task["name"] = lbvserver_name
task["operation"] = "REMOVE"
task["state"] = None
return task
def get_netscaler_getlbvserver_task(loadBalancerId):
lbvserver_name = NitroUtils.get_lbvservername_from_loadbalancerid(
loadBalancerId)
task = {}
task["type"] = "lbvserver"
task["name"] = lbvserver_name
task["operation"] = "GET"
task["state"] = None
return task
def _adjust_lbvserver_state_for_update(self, loadBalancerId, new_state):
""" First, we'll get from Netscaler the current lbvserver state """
""" XXX - In Netscaler, we haven't got IDs for resources so our assumption: loadBalancerId == loadBalancer.name """
resource_type = "lbvserver"
resource_name = NitroUtils.get_lbvservername_from_loadbalancerid(
loadBalancerId)
self.logger.debug(
"adjusting the lbvserver state to submit for an update operation. For this we need to get the existing lbvserver"
)
current_state = self.nitrowrapper.get_netscaler_entity(
resource_type, resource_name)
if "servicetype" in new_state.keys():
if new_state["servicetype"] != current_state["servicetype"]:
""" XXX - Netscaler doesn't support changing the servicetype of an lbvserver. """
raise NotImplementedException(
"Sorry, changing the protocol of the loadBalancer in the current implementation is not supported."
)
else:
""" Just remove it since it is the same """
del new_state["servicetype"]
if "port" in new_state.keys():
if type(current_state["port"]) is int:
new_state["port"] = int(new_state["port"])
if new_state["port"] != current_state["port"]:
""" XXX - Netscaler doesn't support changing the port of an lbvserver. """
raise NotImplementedException(
"Sorry, changing the port of the loadBalancer in the current implementation is not supported."
)
else:
del new_state["port"]
if "lbmethod" in new_state.keys():
if new_state["lbmethod"] == current_state["lbmethod"]:
del new_state["lbmethod"]
if self.extensions_enabled:
""" XXX - Also check for extended properties in the new_state dictionary """
self.logger.debug("Adjusted state for Updating lbvserver %s is: %s" %
(resource_name, str(new_state)))
return new_state
def get_netscaler_removeservicebinding_task(self, loadBalancerId, loadBalancer, nodeId):
lbvserver_name = NitroUtils.get_lbvservername_from_loadbalancerid(loadBalancerId)
servicename = NitroUtils.get_servicename_from_nodeid(loadBalancerId, nodeId)
args = "servicename:" + servicename
args += ","
args += "name:" + lbvserver_name
task = {}
task["type"] = "lbvserver_service_binding"
task["name"] = lbvserver_name + "?args=" + args
task["operation"] = "REMOVE"
task["state"] = None
return task
def extract_lbvserver_object_from_task_list(results, loadBalancerId):
lbvserver_name = NitroUtils.get_lbvservername_from_loadbalancerid(
loadBalancerId)
for task in results:
if task["type"] == "lbvserver" and task["operation"] == "GET":
if task["name"] == lbvserver_name:
state = task["result"]
""" XXX Nitro bug returns a list of one lbvserver, so workaround here """
if isinstance(state, list):
return state[0]
else:
return state
return None
def _get_netscaler_getservicebinding_task(self, loadBalancerId, loadBalancer, nodeId):
self.logger.debug("loadBalancer Id is: %s" % loadBalancerId)
self.logger.debug("node Id is: %s" % nodeId)
lbvserver_name = NitroUtils.get_lbvservername_from_loadbalancerid(loadBalancerId)
service_name = NitroUtils.get_servicename_from_nodeid(loadBalancerId, nodeId)
args = "servicename:" + service_name
task = {}
task["type"] = "lbvserver_service_binding"
task["name"] = lbvserver_name + "?filter=" + args
task["operation"] = "GET"
task["state"] = None
return task
def _get_netscaler_servicebinding_from_node(self, loadBalancerId, loadBalancer, nodeId, node):
service_binding_obj = {}
lbvserver_name = NitroUtils.get_lbvservername_from_loadbalancerid(loadBalancerId)
service_name = NitroUtils.get_servicename_from_nodeid(loadBalancerId, nodeId)
service_binding_obj["name"] = lbvserver_name
service_binding_obj["servicename"] = service_name
if "weight" in node and node.weight != 1 :
if not loadBalancer.algorithm.startswith("WEIGHTED_"):
raise BadRequestException("validation fault", "invalid object",
"LB algorithm in use doesn't allow for weighted nodes")
service_binding_obj["weight"] = node["weight"]
return service_binding_obj
def _get_netscaler_addloadbalancer_task(self, loadBalancerId,
loadBalancer):
task_list = []
if not "name" in loadBalancer:
raise ImplementationError(
"We should have caught this during validation phase.")
lbvserver_name = NitroUtils.get_lbvservername_from_loadbalancerid(
loadBalancerId)
task = {}
task["type"] = "lbvserver"
task["name"] = lbvserver_name
task["operation"] = "ADD"
lbvserver = self._get_lbvserver_state(lbvserver_name, loadBalancer)
task["state"] = lbvserver
task_list.append(task)
return task
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
