def set_acl_settings(self,
autoupdate=None,
autoinstall=None,
installtime=None):
if autoupdate is not None:
command = "setautoupdate"
key = "enable"
value = autoupdate
elif autoinstall is not None:
command = "setautoinstall"
key = "enable"
value = autoinstall
elif installtime is not None:
command = "setinstalltime"
key = "hour"
value = autoinstall
if value in [True, "yes", "y", "1"]:
value = "yes"
if value in [False, "no", "n", "0"]:
value = "no"
parameters = {
key: value
}
response = self._get("/geoacl/{}".format(command), parameters)
if is_successful(response):
pass
else:
raise KempTechApiException(get_error_msg(response))
def get_acl_settings(self):
response = self._get("/geoacl/getsettings")
if is_successful(response):
data = get_data(response)
data = data['GeoAcl']
else:
raise KempTechApiException(get_error_msg(response))
acl_settings = {}
for k, v in data.items():
if v == "yes":
v = True
elif v == "no":
v = False
elif v == "Never":
v = None
else:
try:
v = int(v) # pylint: disable=redefined-variable-type
except ValueError:
pass
acl_settings[k.lower()] = v
return acl_settings
def set_check_parameters(self,
retryinterval=None,
timeout=None,
retrycount=None):
parameters = {}
if timeout is not None:
try:
parameters['Timeout'] = int(timeout)
except ValueError:
raise LoadMasterParameterError(
"Timeout specified is not an integer",
timeout)
if retrycount is not None:
try:
parameters['RetryCount'] = int(retrycount)
except ValueError:
raise LoadMasterParameterError(
"RetryCount specified is not an integer",
retrycount)
if retryinterval is not None:
try:
parameters['RetryInterval'] = int(retryinterval)
except ValueError:
raise LoadMasterParameterError(
"RetryInterval specified is not an integer",
retryinterval)
response = self._get("/modhealth", parameters)
if not is_successful(response):
raise LoadMasterParameterError(self, parameters)
def set_adaptive_parameters(self,
adaptiveurl=None,
adaptiveport=None,
adaptiveinterval=None,
minpercent=None):
parameters = {}
if adaptiveurl is not None:
parameters['AdaptiveURL'] = adaptiveurl
if adaptiveport is not None:
validate_port(adaptiveport)
parameters['AdaptivePort'] = adaptiveport
if adaptiveinterval is not None:
try:
parameters['AdaptiveInterval'] = int(adaptiveinterval)
except ValueError:
raise LoadMasterParameterError(
"AdaptiveInterval specified is not an integer",
adaptiveinterval)
if minpercent is not None:
try:
parameters['MinPercent'] = int(minpercent)
except ValueError:
raise LoadMasterParameterError(
"MinPercent specified is not an integer",
minpercent)
response = self._get("/modadaptive", parameters)
if not is_successful(response):
raise LoadMasterParameterError(self, parameters)
def acl_install(self):
response = self._get("/geoacl/installnow")
if is_successful(response):
pass
else:
raise KempTechApiException(get_error_msg(response))
def refresh_dns(self):
api = "/resolvenow"
response = self._get(api)
if is_successful(response):
pass
else:
raise KempTechApiException(get_error_msg(response))
def acl_changes(self):
response = self._get("/geoacl/downloadchanges")
if is_successful(response):
pass
else:
raise KempTechApiException(get_error_msg(response))
return response
def get_eula(self):
api = "/readeula"
response = self._get(api)
if is_successful(response):
data = get_data(response)
else:
raise KempTechApiException(get_error_msg(response))
self.magic = data['Magic']
return data['Eula']
def remove_acl(self, type, value):
parameters = {
"type": type,
"addr": value
}
response = self._get("/geoacl/removecustom", parameters)
if is_successful(response):
pass
else:
raise KempTechApiException(get_error_msg(response))
def initial_password(self, password="******"):
api = "/set_initial_passwd"
parameters = {
"passwd": password
}
response = self._get(api, parameters=parameters)
if not is_successful(response):
raise KempTechApiException(get_error_msg(response))
self.password = password
def change_bal_password(self, new_password):
parameters = {
"currpassword": self.password,
"password": new_password
}
response = self._get("/usersetsyspassword", parameters=parameters)
if is_successful(response):
self.password = new_password
return True
else:
return False
def set_geo_parameter(self, parameter, value):
"""assign the value to the given loadmaster parameter
:param parameter: a valid LoadMaster parameter.
:type parameter: str.
:param value: the value to be assigned
:type value: str.
:raises: LoadMasterParameterError
"""
parameters = {
parameter: value
}
response = self._get('/modparams', parameters)
if not is_successful(response):
raise LoadMasterParameterError(self, parameters)
def accept_eula(self, license_type="trial"):
api = "/accepteula"
parameters = {
"type": license_type,
"magic": self.magic
}
response = self._get(api, parameters=parameters)
if is_successful(response):
data = get_data(response)
else:
raise KempTechApiException(get_error_msg(response))
self.magic = data['Magic']
def set_callhome(self, enabled=True):
api = "/accepteula2"
if enabled is True:
enabled = "yes"
else:
enabled = "no"
parameters = {
"accept": enabled,
"magic": self.magic
}
response = self._get(api, parameters=parameters)
if not is_successful(response):
raise KempTechApiException(get_error_msg(response))
def set_parameter(self, parameter, value):
"""Assign the value to the given loadmaster parameter
:param parameter: A valid LoadMaster parameter.
:type parameter: str.
:param value: The value to be assigned
:type value: str.
:raises: LoadMasterParameterError
"""
parameters = {
'param': parameter,
'value': value,
}
response = self._get('/set', parameters)
if not is_successful(response):
raise LoadMasterParameterError(self, parameters)
def apply_template(self, virtual_ip, port, protocol, template_name,
nickname=None):
params = {
'vs': virtual_ip,
'port': port,
'prot': protocol,
'name': template_name,
}
existing = self.vs.keys()
if nickname is not None:
params['nickname'] = nickname
response = self._get("/addvs", parameters=params)
if is_successful(response):
vs = {k: v for k, v in self.vs.items()
if k not in existing}
else:
raise KempTechApiException(get_error_msg(response))
return vs
def license(self):
"""Current license on the LoadMaster
:return: License information
"""
response = self._get("/licenseinfo")
if is_successful(response):
data = get_data(response)
license_info = {}
# Fix annoying API weirdness
for k, v in data.items():
k = k.lower()
try:
if v[0] == '"':
v = v[1:]
if v[-1] == '"':
v = v[:-1]
if v[-1] == "\n":
v = v[:-1]
except (IndexError, KeyError):
# Catch scenarios where there is no data
pass
if isinstance(v, str):
v = v.replace(" ", " ")
license_info[k] = v
else:
raise KempTechApiException(get_error_msg(response))
return license_info
def get_acl(self, type):
parameters = {
"type": type
}
response = self._get("/geoacl/listcustom", parameters)
if is_successful(response):
data = get_data(response)
else:
raise KempTechApiException(get_error_msg(response))
list_tag = "{}list".format(type).capitalize()
acl_list = data[list_tag]
if acl_list is None:
acl_list = []
elif isinstance(acl_list, dict):
acl_list = acl_list.get('addr')
if not isinstance(acl_list, list):
acl_list = [acl_list]
return acl_list
def update_firmware(self, file):
response = self._post('/installpatch', file)
self.version = None
return is_successful(response)
def reboot(self):
response = self._get('/reboot')
return is_successful(response)
def restore_firmware(self):
response = self._get("/restorepatch")
self.version = None
return is_successful(response)
def reset_logs(self):
response = self._get("/logging/resetlogs")
return is_successful(response)
def shutdown(self):
response = self._get('/shutdown')
return is_successful(response)
def disable_geo(self):
response = self._get('/disablegeo')
return is_successful(response)
def test_is_successful_None():
with patch.object(api_xml, 'get_success_msg') as get_success_msg:
get_success_msg.return_value = None
res = api_xml.is_successful('any_xml')
assert_equal(res, False)
def send_response(response):
parsed_resp = parse_to_dict(response)
if is_successful(parsed_resp):
return parsed_resp
else:
raise KempTechApiException(get_error_msg(parsed_resp))
def test_is_successful_str():
with patch.object(api_xml, 'get_success_msg') as get_success_msg:
get_success_msg.return_value = 'any string'
res = api_xml.is_successful('any_xml')
assert_equal(res, True)
