ResponseStatus codes and what they mean.
Build a SoftLayer_Container_Product_Order_Monitoring_Package object for a new monitoring order and pass it to the SoftLayer_Product_Order API service to order it In this care we’ll order a Basic (Hardware and OS) package with Basic Monitoring Package - Linux configuration.
Important manual pages:
"""
Order a Monitoring Package
"""
import SoftLayer
"""
Build a skeleton SoftLayer_Container_Product_Order_Monitoring_Package object
containing the order you wish to place.
"""
oderTemplate = {
'complexType': 'SoftLayer_Container_Product_Order_Monitoring_Package',
'packageId': 0, # the packageID for order monitoring packages is 0
'prices': [
{'id': 2302} # this is the price for Monitoring Package - Basic ((Hardware and OS))
],
'quantity': 0, # the quantity for order a service (in this case monitoring package) must be 0
'sendQuoteEmailFlag': True,
'useHourlyPricing': True,
'virtualGuests': [
{'id': 4906034} # the virtual guest ID where you want add the monitoring package
],
'configurationTemplateGroups': [
{'id': 3} # the templateID for the monitoring group (in this case Basic Monitoring package for Unix/Linux operating system.)
]
}
# Declare the API client to use the SoftLayer_Product_Order API service
client = SoftLayer.Client()
productOrderService = client['SoftLayer_Product_Order']
"""
verifyOrder() will check your order for errors. Replace this with a call to
placeOrder() when you're ready to order. Both calls return a receipt object
that you can use for your records.
Once your order is placed it'll go through SoftLayer's provisioning process.
"""
order = productOrderService.verifyOrder(oderTemplate)
print(order)
Important manual pages:
"""
Active an agent.
"""
import SoftLayer
import json
vsiIp = "169.45.98.148"
agentName = "DHCP Response Monitoring Agent"
client = SoftLayer.Client()
vsiService = client['SoftLayer_Virtual_Guest']
agentService = client['SoftLayer_Monitoring_Agent']
objectMask = "mask[monitoringRobot[id, robotStatus[name]], monitoringAgents[statusName, name, id], monitoringServiceEligibilityFlag, datacenter]"
vsi = vsiService.findByIpAddress(vsiIp, mask=objectMask)
if not vsi:
print("There is not a vsi with the IP address: " + vsiIp)
exit(1)
agent = {}
for agents in vsi['monitoringAgents']:
if agents['name'].strip().upper() == agentName.strip().upper():
agent = agents
break
if not 'id' in agent:
print("The VSI does not have a monitor agent with the name: " + agentName)
exit(1)
result = agentService.activate(id=agent['id'])
print(json.dumps(result, sort_keys=True, indent=2, separators=(',', ': ')))
The scripts adds subscribers to an arbitrary VSI machine.
Important manual pages:
"""
Add subscribers to a monitor
"""
import SoftLayer
hostnames = ["rctest", "rctest2"]
mailsToAdd = ["someone@test.com", "someone.else@test.com"]
client = SoftLayer.Client()
# Getting all virtual servers on the account
vServers = client['Account'].getVirtualGuests()
for hostname in hostnames:
for vServer in vServers:
if hostname == vServer['hostname']:
vSertverId = vServer['id']
# Getting all the agents in the virtual machine
agents = client['Virtual_Guest'].getMonitoringAgents(id=vSertverId)
for agent in agents:
agentId = agent['id']
agentName = agent['name']
elegibleSubscribers = client['SoftLayer_Monitoring_Agent'].getEligibleAlarmSubscibers(id=agentId)
for mailToAdd in mailsToAdd:
for elegibleSubscriber in elegibleSubscribers:
if 'id' in elegibleSubscriber:
suscriberId = elegibleSubscriber['id']
userData = client['SoftLayer_User_Customer'].getObject(id=suscriberId)
if mailToAdd.strip() == userData['email'].strip():
added = client['SoftLayer_Monitoring_Agent'].setActiveAlarmSubscriber(suscriberId, id=agentId)
# Use this to Remove
# removed = client['SoftLayer_Monitoring_Agent'].removeActiveAlarmSubscriber(suscriberId, id=agentId)
if added:
print("For hostname: " + hostname + " with ID " + str(vSertverId) + " in the agent for " + agentName + " the mail " + mailToAdd + " has been added.")
else:
print("ERROR - For hostname: " + hostname + " with ID " + str(vSertverId) + " in the agent for " + agentName + " the mail " + mailToAdd + " has not been added.")
The script clones an existing configuration template, performs a change in the configuration template, then creates a template group and adds the created configuration template to the new template group.
Important manual pages:
"""
Create a monitoring configuration template and a template group
"""
import SoftLayer
client = SoftLayer.Client()
configurationTemplateService = client['SoftLayer_Configuration_Template']
monitoringAgentConfigurationTemplateGroupService = client['SoftLayer_Monitoring_Agent_Configuration_Template_Group']
productPackageService = client['SoftLayer_Product_Package']
templates = configurationTemplateService.getAllObjects(limit=100, offset=0)
newTemplateId = -1
for template in templates:
if template['name'] == 'CDM Monitoring agent-MH-Linux v2':
# Creating an Skeleton SoftLayer_Configuration_Template for our new template
templateObject = {
'description': 'this is my clone test',
'name': 'clone for test',
'parentId': template['id']
}
newTemplate = configurationTemplateService.copyTemplate(templateObject, id=template['id'])
# Getting the definitions from the parent template to set in the new template e.g. CPU, Memory
objectMask = 'mask[configurationSections[subSections[definitions]]]'
definitions = configurationTemplateService.getObject(mask=objectMask, id=template['id'])
# The configuration values for our new template
configurationValues = []
"""
We are going to define the configuration for our template by default it has the
same configuration as the parent template.
we are looking a determinate configuration section in this case CPU section.
"""
for definition in definitions['configurationSections']:
if definition['name'] == 'CPU':
# We are looking for the subsection Graphing.
for subsection in definition['subSections']:
if subsection['name'] == 'Graphing':
for subdefinition in subsection['definitions']:
# We are looking the 'Graph Total CPU Usage' configuration option.
if subdefinition['name'] == 'Graph Total CPU Usage':
# Setting the configuration for our template
configurationValues.append({"definitionId": subdefinition['id'], "templateId": template['id'], "value": "FALSE"})
print(configurationValues)
# Updating the new configuration in our created template
result = configurationTemplateService.updateDefaultValues(configurationValues, id=newTemplate['id'])
newTemplateId = newTemplate['id']
print(result)
"""
Looking for a monitoring package in order to add our new template group
in that monitoring package. In this case we are going to add it to
"Monitoring Package - Basic"
"""
monitoringBasicId = -1
itemsPackage = productPackageService.getItems(id=0)
for item in itemsPackage:
if item['description'] == "Monitoring Package - Basic":
monitoringBasicId = item['id']
break
"""
To create a template group in "Monitoring package - Basic"
is necessary to specific a configuration template for
Cpu, Disk, and Memory Monitoring Agent
Process Monitoring Agent
Windows Services Monitoring Agent
Remote System Monitoring Agent
we are going to look for the IDs for those configuration templates
except for "Cpu, Disk, and Memory Monitoring Agent", for this we are going
to use the template that we created above
"""
templates = configurationTemplateService.getAllObjects(limit=100, offset=0)
cpuDiskMemoryMonitoringAgent = newTemplateId
processMonitoringAgent = -1
windowsServiceMonitoringAgent = -1
remoteMonitoringAgent = -1
for template in templates:
if template['name'] == "Process Monitoring Agent ":
proccesMonitoringAgent = template['id']
if template['name'] == "Windows Services Monitoring Agent":
windowsServiceMonitoringAgent = template['id']
if template['name'] == "Remote system monitoring agent - Linux V1":
remoteMonitoringAgent = template['id']
"""
Creating an skeleton SoftLayer_Monitoring_Agent_Configuration_Template_Group for our
new template group
"""
templateObject = {
"description": "this is my template group test",
"itemId": monitoringBasicId,
"name": "my template group test",
"configurationTemplateReferences": [
{"configurationTemplateId": newTemplateId},
{"configurationTemplateId": processMonitoringAgent},
{"configurationTemplateId": windowsServiceMonitoringAgent},
{"configurationTemplateId": remoteMonitoringAgent}
]
}
try:
result = monitoringAgentConfigurationTemplateGroupService.createObject(templateObject)
print(result)
except SoftLayer.SoftLayerAPIError as e:
print("Unable to create the object template for the monitoring agent. "
% (e.faultCode, e.faultString))
exit(1)
Important manual pages
"""
Configure the section 'CPU' from the 'Cpu, Disk, and Memory Monitoring Agent' agent.
"""
import SoftLayer
import json
# The IP address of the server or VSI to configure.
ipAddres = "23.246.195.66"
configuration = {
'Graph System CPU Usage': "False",
'Graph Total CPU Usage': "False",
'Graph User CPU Usage': "True",
'Graph I/O Wait CPU Usage': "True",
'Processor Queue Length Alarm': "True",
'CPU Usage Error Alarm': "True",
'CPU Usage Error Alarm Threshold': "99",
'CPU Usage Warning Alarm': "True",
'CPU Usage Warning Alarm Threshold': "82",
'Processor Queue Length Alarm': "True",
'Max Queue Length': "4"
}
# The agent's name we wish to configure.
agentName = 'Cpu, Disk, and Memory Monitoring Agent'
client = SoftLayer.Client()
vsiService = client['SoftLayer_Virtual_Guest']
hardwareService = client['SoftLayer_Hardware_Server']
monitoringService = client['SoftLayer_Monitoring_Agent']
# Getting the monitoring agents installed in the server or VSI.
try:
objectMask = 'mask[monitoringAgents[configurationValues[definition]]]'
server = vsiService.findByIpAddress(ipAddres, mask=objectMask)
if not 'id' in server:
server = hardwareService.findByIpAddress(ipAddres, mask=objectMask)
if not 'id' in server:
print("There is no a Server or VSI with the IP address: " + ipAddres)
exit(1)
except SoftLayer.SoftLayerAPIError as e:
print("Unable to get the server: faultCode=%s, faultString=%s"
% (e.faultCode, e.faultString))
exit(1)
# Getting the agent to configure.
agents = [agent for agent in server['monitoringAgents'] if agent['name'] == agentName]
if len(agents) == 0:
print("Unable to find the agent: " + agentName)
exit(1)
agent = agents[0]
# Creating an SoftLayer_Monitoring_Agent_Configuration_Value skeleton
# which contains the configuration for the agent.
configurationValues = []
for item in configuration.keys():
itemFound = False
for value in agent['configurationValues']:
if value['definition']['name'].strip().upper() == item.strip().upper():
itemFound = True
configurationValue = value
configurationValue['value'] = configuration[item].strip().upper()
configurationValues.append(configurationValue)
break
if not itemFound:
print("The configuration: " + item + " is not available for the agent.")
# Calling the SoftLayer_Monitoring_Agent::applyConfigurationValues method
# to apply the changes in the agent.
# Note: In case there is no changes in the agent configuration the method
# will return error.
try:
result = monitoringService.applyConfigurationValues(configurationValues, id=agent['id'])
print(json.dumps(result, sort_keys=True, indent=2, separators=(',', ': ')))
except SoftLayer.SoftLayerAPIError as e:
print("Unable to apply the configuration in the monitoring agent: faultCode=%s, faultString=%s"
% (e.faultCode, e.faultString))
exit(1)
Important manual pages
"""
Create a new 'Disk Profile' configuration for the 'Cpu, Disk, and Memory Monitoring Agent' agent.
"""
import SoftLayer
import json
# The IP address of the server or VSI to configure.
ipAddres = "23.246.195.66"
configuration = {
'Disk Path': "c:/",
'Description': "file system c:/",
'Graph Disk Usage': "TRUE",
'Graph Disk Usage as Percentage': "TRUE",
'Disk Usage Error Alarm': "TRUE",
'Usage Error Alarm Threshold': "90",
'Disk Usage Warning Alarm': "TRUE",
'Disk Usage Warning Threshold': "90",
}
# The agent's name we wish to configure.
agentName = 'Cpu, Disk, and Memory Monitoring Agent'
# The agent's section we wish to change
sectionName = "Disk Profile"
client = SoftLayer.Client()
vsiService = client['SoftLayer_Virtual_Guest']
hardwareService = client['SoftLayer_Hardware_Server']
monitoringService = client['SoftLayer_Monitoring_Agent']
# Getting the monitoring agents installed in the server or VSI.
try:
objectMask = 'mask[monitoringAgents[configurationTemplate[configurationSections[subSections[definitions]]]]]'
server = vsiService.findByIpAddress(ipAddres, mask=objectMask)
if not 'id' in server:
server = hardwareService.findByIpAddress(ipAddres, mask=objectMask)
if not 'id' in server:
print("There is no a Server or VSI with the IP address: " + ipAddres)
exit(1)
except SoftLayer.SoftLayerAPIError as e:
print("Unable to get the server: faultCode=%s, faultString=%s"
% (e.faultCode, e.faultString))
exit(1)
# Getting the agent to configure.
agents = [agent for agent in server['monitoringAgents'] if agent['name'] == agentName]
if len(agents) == 0:
print("Unable to find the agent: " + agentName)
exit(1)
agent = agents[0]
# Getting the section to configure
sections = [section for section in agent['configurationTemplate']['configurationSections'] if section['name'] == sectionName]
if len(sections) == 0:
print("Unable to find the section: " + sectionName)
exit(1)
section = sections[0]
# Creating the configuration for the agent.
configurationValues = []
for item in configuration.keys():
itemConfigured = False
for subsection in section['subSections']:
for definition in subsection['definitions']:
if definition['name'].strip().upper() == item.strip().upper():
configurationValue = {}
itemConfigured = True
configurationValue['configurationDefinitionId'] = definition['id']
configurationValue['agentId'] = agent['id']
configurationValue['value'] = configuration[item]
configurationValues.append(configurationValue)
if itemConfigured:
break
if not itemConfigured:
print ("Unable to configure: " + item + " the configuration name was not found.")
# Calling the SoftLayer_Monitoring_Agent::applyConfigurationValues method
# to apply the changes in the agent.
try:
result = monitoringService.addConfigurationProfile(configurationValues, id=agent['id'])
print(json.dumps(result, sort_keys=True, indent=2, separators=(',', ': ')))
except SoftLayer.SoftLayerAPIError as e:
print("Unable to apply the configuration in the monitoring agent: faultCode=%s, faultString=%s"
% (e.faultCode, e.faultString))
exit(1)
Important manual pages
"""
Configure the section 'Memory' from the 'Cpu, Disk, and Memory Monitoring Agent' agent.
"""
import SoftLayer
import json
# The IP address of the server or VSI to configure.
ipAddres = "5.153.59.197"
configuration = {
"Graph Memory Usage": "FALSE",
"Graph Memory Usage as Percentage": "TRUE",
"Graph Physical Memory Usage": "FALSE",
"Graph Physical Memory Usage as Percentage": "TRUE",
"Graph Swap Memory Usage": "FALSE",
"Graph Swap Memory Usage as Percentage": "TRUE",
"Graph System Paging in Kb/s": "TRUE",
"Graph System Paging in Pg/s": "FALSE",
"Total Memory Usage Error Alarm": "FALSE",
"Total Memory Usage Error Threshold": "90",
"Total Memory Usage Warning Alarm": "FALSE",
"Total Memory Usage Warning Threshold": "50",
"Physical Memory Usage Error Alarm": "FALSE",
"Physical Memory Usage Error Threshold": "95",
"Physical Memory Usage Warning Alarm": "FALSE",
"Physical Memory Usage Warning Threshold": "85",
"Swap Memory Usage Error Alarm": "FALSE",
"Swap Memory Usage Error Threshold": "85",
"Swap Memory Usage Warning Alarm": "FALSE",
"Swap Memory Usage Warning Threshold": "60",
"Paging Error Alarm Active": "FALSE",
"Paging Error Alarm Threshold": "400",
"Paging Warning Alarm Active": "FALSE",
"Paging Warning Alarm Threshold": "150"
}
# The agent's name we wish to configure.
agentName = 'Cpu, Disk, and Memory Monitoring Agent'
client = SoftLayer.Client()
vsiService = client['SoftLayer_Virtual_Guest']
hardwareService = client['SoftLayer_Hardware_Server']
monitoringService = client['SoftLayer_Monitoring_Agent']
# Getting the monitoring agents installed in the server or VSI.
try:
objectMask = 'mask[monitoringAgents[configurationValues[definition]]]'
server = vsiService.findByIpAddress(ipAddres, mask=objectMask)
if not 'id' in server:
server = hardwareService.findByIpAddress(ipAddres, mask=objectMask)
if not 'id' in server:
print("There is no a Server or VSI with the IP address: " + ipAddres)
exit(1)
except SoftLayer.SoftLayerAPIError as e:
print("Unable to get the server: faultCode=%s, faultString=%s"
% (e.faultCode, e.faultString))
exit(1)
# Getting the agent to configure.
agents = [agent for agent in server['monitoringAgents'] if agent['name'] == agentName]
if len(agents) == 0:
print("Unable to find the agent: " + agentName)
exit(1)
agent = agents[0]
# Creating an SoftLayer_Monitoring_Agent_Configuration_Value skeleton
# which contains the configuration for the agent.
configurationValues = []
for item in configuration.keys():
itemFound = False
for value in agent['configurationValues']:
if value['definition']['name'].strip().upper() == item.strip().upper():
itemFound = True
configurationValue = value
configurationValue['value'] = configuration[item].strip().upper()
configurationValues.append(configurationValue)
break
if not itemFound:
print("The configuration: " + item + " is not available for the agent.")
# Calling the SoftLayer_Monitoring_Agent::applyConfigurationValues method
# to apply the changes in the agent.
# Note: In case there is no changes in the agent configuration the method
# will return error.
try:
result = monitoringService.applyConfigurationValues(configurationValues, id=agent['id'])
print(json.dumps(result, sort_keys=True, indent=2, separators=(',', ': ')))
except SoftLayer.SoftLayerAPIError as e:
print("Unable to apply the configuration in the monitoring agent: faultCode=%s, faultString=%s"
% (e.faultCode, e.faultString))
exit(1)
Important manual pages
"""
Edit the configuration for the "Disk Profile" section
of a monitoring agent.
"""
import SoftLayer
import json
# The IP address of the server or VSI to configure.
ipAddres = "5.153.59.197"
configuration = {
'Disk Path': "c:/",
'Description': "file system c:/",
'Graph Disk Usage': "TRUE",
'Graph Disk Usage as Percentage': "TRUE",
'Disk Usage Error Alarm': "TRUE",
'Usage Error Alarm Threshold': "95",
'Disk Usage Warning Alarm': "TRUE",
'Disk Usage Warning Threshold': "90",
}
# The agent's name we will configure.
agentName = 'Cpu, Disk, and Memory Monitoring Agent'
client = SoftLayer.Client()
vsiService = client['SoftLayer_Virtual_Guest']
hardwareService = client['SoftLayer_Hardware_Server']
monitoringService = client['SoftLayer_Monitoring_Agent']
# Getting the monitoring agents installed in the server or VSI.
try:
objectMask = 'mask[monitoringAgents[configurationValues[definition]]]'
server = vsiService.findByIpAddress(ipAddres, mask=objectMask)
if not 'id' in server:
server = hardwareService.findByIpAddress(ipAddres, mask=objectMask)
if not 'id' in server:
print("There is no a Server or VSI with the IP address: " + ipAddres)
exit(1)
except SoftLayer.SoftLayerAPIError as e:
print("Unable to get the server: faultCode=%s, faultString=%s"
% (e.faultCode, e.faultString))
exit(1)
# Getting the agent to configure.
agents = [agent for agent in server['monitoringAgents'] if agent['name'] == agentName]
if len(agents) == 0:
print("Unable to find the agent: " + agentName)
exit(1)
agent = agents[0]
# Getting the profile id to edit.
if 'Disk Path' in configuration:
profileId = [value['profileId'] for value in agent['configurationValues']
if value['definition']['name'] == 'Disk Path' and
value['value'].strip().upper() == configuration['Disk Path'].strip().upper()]
profileId = profileId[0]
else:
print("It is required an Disk Path value in the configuration.")
exit(1)
# Creating an SoftLayer_Monitoring_Agent_Configuration_Value skeleton
# which contains the configuration for the agent.
configurationValues = []
for item in configuration.keys():
itemFound = False
for value in agent['configurationValues']:
if value['definition']['name'].strip().upper() == item.strip().upper() and value['profileId'] == profileId:
itemFound = True
configurationValue = value
configurationValue['value'] = configuration[item].strip().upper()
configurationValues.append(configurationValue)
break
if not itemFound:
print("The configuration: " + item + " is not available for the agent.")
# Calling the SoftLayer_Monitoring_Agent::applyConfigurationValues method
# to apply the changes in the agent.
# Note: In case there is no changes in the agent configuration the method
# will return error.
try:
result = monitoringService.addConfigurationProfile(configurationValues, id=agent['id'])
print(json.dumps(result, sort_keys=True, indent=2, separators=(',', ': ')))
except SoftLayer.SoftLayerAPIError as e:
print("Unable to apply the configuration in the monitoring agent: faultCode=%s, faultString=%s"
% (e.faultCode, e.faultString))
exit(1)
Important manual pages:
"""
Desactive an agent.
"""
import SoftLayer
import json
vsiIp = "169.45.98.148"
agentName = "DHCP Response Monitoring Agent"
client = SoftLayer.Client(
vsiService = client['SoftLayer_Virtual_Guest']
agentService = client['SoftLayer_Monitoring_Agent']
objectMask = """mask[monitoringRobot[id, robotStatus[name]], monitoringAgents[statusName, name, id], monitoringServiceEligibilityFlag, datacenter]"""
vsi = vsiService.findByIpAddress(vsiIp, mask=objectMask)
if not vsi:
print("There is no a vsi with the IP address: " + vsiIp)
exiΩt(1)
agent = {}
for agents in vsi['monitoringAgents']:
if agents['name'].strip().upper() == agentName.strip().upper():
agent = agents
break
if not 'id' in agent:
print("The VSI does not have a monitor agent with the name: " + agentName)
exit(1)
result = agentService.deactivate(id=agent['id'])
print(json.dumps(result, sort_keys=True, indent=2, separators=(',', ': ')))
"""
Get the configuration of the monitoring agent in a server or VSI.
"""
import SoftLayer
import json
ipAddres = "5.153.59.197"
client = SoftLayer.Client()
vsiService = client['SoftLayer_Virtual_Guest']
hardwareService = client['SoftLayer_Hardware_Server']
try:
objectMask = 'mask[monitoringAgents[configurationTemplate[configurationSections[subSections]],' \
'configurationValues[id, value, profileId, agentId, configurationDefinitionId,' \
'profile, definition[attributes, section, valueType]]]]'
server = vsiService.findByIpAddress(ipAddres, mask=objectMask)
if not 'id' in server:
server = hardwareService.findByIpAddress(ipAddres, mask=objectMask)
if not 'id' in server:
print("There is no a Server or VSI with the IP address: " + ipAddres)
exit(1)
except SoftLayer.SoftLayerAPIError as e:
print("Unable to get the server: faultCode=%s, faultString=%s"
% (e.faultCode, e.faultString))
exit(1)
# We will get the configuration of the active agents
agents = [agent for agent in server['monitoringAgents'] if agent['statusName'] == "Active"]
server['monitoringAgents'] = agents
configs = []
for agent in server['monitoringAgents']:
config = {}
config['agent'] = agent['name']
config['id'] = agent['id']
sections = []
for section in agent['configurationTemplate']['configurationSections']:
sect = {}
subsects = []
hasProfile = False
profileIds = []
confs = []
for subsection in section['subSections']:
values = [value for value in agent['configurationValues'] if
value['definition']['sectionId'] == subsection['id']]
for value in values:
conf = {}
if value['profileId'] == "":
conf[value['definition']['name']] = value['value']
confs.append(conf)
else:
hasProfile = True
profileIds.append(value['profileId'])
sect['name'] = section['name']
if not hasProfile:
sect['configuration'] = confs
sections.append(sect)
else:
profileIds = list(set(profileIds))
profiles = []
for profileId in profileIds:
profile = {}
valueConfs = []
valueProfiles = [value for value in agent['configurationValues'] if
value['profileId'] == profileId]
profile['name'] = valueProfiles[0]['profile']['name']
for valueProfile in valueProfiles:
value = {}
value[valueProfile['definition']['name']] = valueProfile['value']
valueConfs.append(value)
profile['configuration'] = valueConfs
profiles.append(profile)
sect['profiles'] = profiles
sections.append(sect)
config['sections'] = sections
configs.append(config)
print(json.dumps(configs, sort_keys=True, indent=2, separators=(',', ': ')))
The script gets the CPU usage in a selected date range.
Important manual pages.
"""
Get the graph data from a monitoring agent
"""
import SoftLayer
# This data can take a little while to obtain for long date ranges
TIMEOUT = 12000
"""
Creating an skeleton SoftLayer_Container_Metric_Data_Type object
which represent the metric data that we will get.
"""
metricDataTypes = [
{
"summaryType": "average",
"keyName": "CDM_CPU_USAGE",
"name": "cdm_cpu_usage_U3lzdGVt"
}
]
# The start date for the graph data
starDate = "2014-09-29T01:48:08.474Z"
# The end date for the graph data
endDate = "2014-09-29T01:53:08.474Z"
"""
The agent ID from where we want to get the graph data
to get the monitor agents in your virtual guest
call the SoftLayer_Virtual_Guest::getMonitoringAgents method
"""
agentId = 1448912
client = SoftLayer.Client(timeout=TIMEOUT)
monitorAgentService = client['SoftLayer_Monitoring_Agent']
# calling the Softlayer_Monitoring_Agent::getGraphData method
result = monitorAgentService.getGraphData(
metricDataTypes, starDate, endDate, id=agentId)
print(result)
Important manual pages
"""
View the reports for the "CPU" section from the
'Cpu, Disk, and Memory Monitoring Agent' monitor agent.
"""
import SoftLayer
import json
# The IP address of the server or VSI to configure.
ipAddres = "5.153.59.197"
startDate = '2016-01-02'
endDate = '2016-01-08'
# Set "True" the reports you wish to see.
reports = {
'Graph System CPU Usage': "False",
'Graph Total CPU Usage': "False",
'Graph User CPU Usage': "False",
'Graph I/O Wait CPU Usage': "True",
}
# The agent's name we wish to see the reports.
agentName = 'Cpu, Disk, and Memory Monitoring Agent'
client = SoftLayer.Client()
vsiService = client['SoftLayer_Virtual_Guest']
hardwareService = client['SoftLayer_Hardware_Server']
monitoringService = client['SoftLayer_Monitoring_Agent']
agentConfigurationService = client['Monitoring_Agent_Configuration_Value']
# Getting the monitoring agents installed in the server or VSI.
# Setting an object mask to retrieve information about the monitoring agents.
objectMask = 'mask[monitoringAgents[configurationValues[definition]]]'
server = vsiService.findByIpAddress(ipAddres, mask=objectMask)
if not 'id' in server:
server = hardwareService.findByIpAddress(ipAddres, mask=objectMask)
if not 'id' in server:
print("There is no a Server or VSI with the IP address: " + ipAddres)
exit(1)
# Getting the agent to see the reports.
agents = [agent for agent in server['monitoringAgents'] if agent['name'] == agentName]
if len(agents) == 0:
print("Unable to find the agent: " + agentName)
exit(1)
agent = agents[0]
# Creating the list of SoftLayer_Container_Metric_Data_Type objects
metricDataTypes = []
for item in reports.keys():
if reports[item].strip().upper() == "TRUE":
itemFound = False
for value in agent['configurationValues']:
if value['definition']['name'].strip().upper() == item.strip().upper():
itemFound = True
if value['value'].strip().upper() == "TRUE":
try:
metrics = agentConfigurationService.getMetricDataType(id=value['id'])
metricDataTypes.append(metrics)
except SoftLayer.SoftLayerAPIError as e:
print("Unable to get the metrics. " % (e.faultCode, e.faultString))
else:
print("The report: " + item + " is disable for the agent. Please review the agent configuration.")
exit(1)
break
if not itemFound:
print("The configuration: " + item + " is not available for the agent.")
# Getting the reports.
data = monitoringService.getGraphData(metricDataTypes, startDate, endDate, id=agent['id'])
print(json.dumps(data, sort_keys=True, indent=2, separators=(',', ': ')))
The script creates a Network Notification of type service ping and a notify wait of 5 minutes.
"""
Create Network Notification
"""
import SoftLayer
# Declare the API client
client = SoftLayer.Client()
networkMonitorService = client['SoftLayer_Network_Monitor_Version1_Query_Host']
objectTemplate = [
{
"guestId": 6143038,
"ipAddress": "10.104.50.118",
"queryTypeId": 1,
"responseActionId": 2,
"waitCycles": 1
}
]
result = networkMonitorService.createObjects(objectTemplate)
print(result)
"""
Re-deploy an agent.
"""
import SoftLayer
import json
vsiIp = "169.45.98.148"
agentName = "DHCP Response Monitoring Agent"
client = SoftLayer.Client()
vsiService = client['SoftLayer_Virtual_Guest']
agentService = client['SoftLayer_Monitoring_Agent']
objectMask = "mask[monitoringRobot[id, robotStatus[name]], monitoringAgents[statusName, name, id], monitoringServiceEligibilityFlag, datacenter]"
vsi = vsiService.findByIpAddress(vsiIp, mask=objectMask)
if not vsi:
print("There is no a vsi with the IP address: " + vsiIp)
exit(1)
agent = {}
for agents in vsi['monitoringAgents']:
if agents['name'].strip().upper() == agentName.strip().upper():
agent = agents
break
if not 'id' in agent:
print("The VSI does not have a monitor agent with the name: " + agentName)
exit(1)
configuration = agentService.getConfigurationTemplate(id=agent['id'])
result = agentService.deployMonitoringAgent(configuration['id'], id=agent['id'])
# Restarts the Agent instead
# result = agentService.restartMonitoringAgent(id=agent['id'])
print(json.dumps(result, sort_keys=True, indent=2, separators=(',', ': ')))
If this article contains any error, or leaves any of your questions unanswered, please help us out by
opening up a github issue.
Open an issue