def zookeeperValidate():
serverAddress = config.get('RootContainerSection', 'serverAddress')
rootContainer = config.get('RootContainerSection', 'rootContainer')
jlkUserName = config.get('RootContainerSection', 'jlkUserName')
jlkUserPassword = config.get('RootContainerSection', 'jlkUserPassword')
admPort = config.get('RootContainerSection', rootContainer + '_adm_port')
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM,
socket.IPPROTO_TCP)
result = sock.connect_ex((serverAddress, int(admPort)))
if result == 0:
try:
j4p = Jolokia('http://' + serverAddress + ':' + admPort +
'/jolokia/')
j4p.auth(httpusername=decode(jlkUserName),
httppassword=decode(jlkUserPassword))
reqZookeeperStatus = j4p.request(
type='read',
mbean='org.apache.zookeeper:name0=*,name1=*',
attribute='State')
strZookeeperStatus = reqZookeeperStatus['value'].items(
)[0][1]['State']
if strZookeeperStatus == 'following' or strZookeeperStatus == 'leading':
zookeeperStatus = 0
else:
zookeeperStatus = 1
except Exception:
zookeeperStatus = 1
else:
zookeeperStatus = 1
print rootContainer + ' ' + str(zookeeperStatus)
def init_jolokia():
global JOLOKIA_CONNECTIONS
for connection in JOLOKIA_CONNECTIONS.keys():
j4p = Jolokia(connection)
for bean in JOLOKIA_CONNECTIONS[connection]['mbeans']:
j4p.add_request(type='read', mbean=bean)
JOLOKIA_CONNECTIONS[connection]['j4p'] = j4p
def __init__(self, url, user, pwd, beans=['*.*']):
self.j4p = Jolokia(url)
self.j4p.auth(httpusername=user, httppassword=pwd)
self.data = {}
for bean in beans:
d = JolokiaData(self.j4p, bean).get_data()
self.data.update(d)
def clusterValidate():
serverAddress = config.get('RootContainerSection', 'serverAddress')
rootContainer = config.get('RootContainerSection', 'rootContainer')
jlkUserName = config.get('RootContainerSection', 'jlkUserName')
jlkUserPassword = config.get('RootContainerSection', 'jlkUserPassword')
admPort = config.get('RootContainerSection', rootContainer + '_adm_port')
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM,
socket.IPPROTO_TCP)
result = sock.connect_ex((serverAddress, int(admPort)))
if result == 0:
try:
j4p = Jolokia('http://' + serverAddress + ':' + admPort +
'/jolokia/')
j4p.auth(httpusername=decode(jlkUserName),
httppassword=decode(jlkUserPassword))
strClusterStatus = j4p.request(type='read',
mbean='io.fabric8:service=Health',
attribute='CurrentStatus')
if strClusterStatus['value'] == 'Good':
clusterStatus = 0
else:
clusterStatus = 1
except Exception:
clusterStatus = 1
else:
clusterStatus = 1
print rootContainer + ' ' + str(clusterStatus)
def activeMQValidate():
serverAddress = config.get('RootContainerSection', 'serverAddress')
appContainers = config.get('AppContainerSection', 'appContainers')
jlkUserName = config.get('RootContainerSection', 'jlkUserName')
jlkUserPassword = config.get('RootContainerSection', 'jlkUserPassword')
arrayContainersInstances = []
arrayContainersInstances.extend(appContainers.split(','))
for contSplit in arrayContainersInstances:
admPort = config.get('AppContainerSection', contSplit + '_adm_port')
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM,
socket.IPPROTO_TCP)
result = sock.connect_ex((serverAddress, int(admPort)))
if result == 0:
try:
j4p = Jolokia('http://' + serverAddress + ':' + admPort +
'/jolokia/')
j4p.auth(httpusername=decode(jlkUserName),
httppassword=decode(jlkUserPassword))
reqActiveMQStatus = j4p.request(type='read', \
mbean='org.apache.activemq:brokerName=' + contSplit + ',service=Health,type=Broker', \
attribute='CurrentStatus')
strActiveMQStatus = reqActiveMQStatus['value']
if strActiveMQStatus == 'Good':
activeMQStatus = 0
else:
activeMQStatus = 1
except Exception:
activeMQStatus = 1
else:
activeMQStatus = 1
print contSplit + ' ' + str(activeMQStatus)
def clear_dil_cache(url):
"""Performs removeALL() operation in the DIL cache Mbean - (clears eh cache)
Test Suite variable ${mbean_cache} is used to access mbean attribute type "cache"
:param url: Jolokia Agent URL installed in the web-server under test.
Example : http://rome.lhs-systems.com:29001/jolokia/
"""
j_url = Jolokia(url)
j_response = j_url.request(
type='exec',
mbean=builtin.get_variable_value("${mbean_cache}"),
operation='removeAll()')
if j_response.get('status') != 200:
raise RuntimeError(
"Jolokia response status is not 200, please check response!!")
return json.dumps(j_response, indent=4)
def get_on_disk_miss(url):
"""Returns on disk miss attribute value from the DIL cache Mbean
Test Suite variable ${mbean_cache_stats} is used to access mbean attribute type "CacheStatistics"
:param url: Jolokia Agent URL installed in the web-server under test.
Example : http://rome.lhs-systems.com:29001/jolokia/
"""
j_url = Jolokia(url)
j_response = j_url.request(
type='read',
mbean=builtin.get_variable_value("${mbean_cache_stats}"),
attribute='OnDiskMisses')
if j_response.get('status') != 200:
raise RuntimeError(
"Jolokia response Status is not 200, please check response!!")
print json.dumps(j_response, indent=4)
return j_response.get('value')
def jolokia_request(self,
url,
mbean="java.lang:type=Memory",
attribute="HeapMemoryUsage"):
""" |Usage|
To get memory usage using Jolokia request.
|Argument|
'url' : Jolokia url
'mbean' : By default, java.lang:type=Memory
'attribute' : By default,HeapMemoryUsage
"""
j4p = Jolokia(url)
data = j4p.request(type='read', mbean=mbean, attribute=attribute)
logger.debug("Response {}".format(data['value']))
return data['value']
def servicesCXFValidation():
serverAddress = config.get('RootContainerSection', 'serverAddress')
appContainers = config.get('AppContainerSection', 'appContainers')
jlkUserName = config.get('RootContainerSection', 'jlkUserName')
jlkUserPassword = config.get('RootContainerSection', 'jlkUserPassword')
arrayContainersInstances = []
arrayContainersInstances.extend(appContainers.split(','))
for contSplit in arrayContainersInstances:
admPort = config.get('AppContainerSection', contSplit + '_adm_port')
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM,
socket.IPPROTO_TCP)
result = sock.connect_ex((serverAddress, int(admPort)))
if result == 0:
try:
j4p = Jolokia('http://' + serverAddress + ':' + admPort +
'/jolokia/')
j4p.auth(httpusername=decode(jlkUserName),
httppassword=decode(jlkUserPassword))
reqApacheCXFStatus = j4p.request(
type='read',
mbean=
'io.fabric8.cxf:*,instance.id=*,port=*,service=*,type=Bus.Service.Endpoint',
attribute='State')
serviceCXFStatus = 0
for apacheCXF in reqApacheCXFStatus['value'].items():
splitApacheCXF = apacheCXF[0].split(',')
apacheCXFState = apacheCXF[1]
splitApacheCXFApp = str(splitApacheCXF[2]).split('=')
apacheCXFApp = splitApacheCXFApp[1].replace('"', '')
statusCXF = str(apacheCXFApp) + '=' + str(
apacheCXFState['State'])
if ("STARTED" not in statusCXF):
serviceCXFStatus = serviceCXFStatus + 1
except Exception:
serviceCXFStatus = serviceCXFStatus + 1
print contSplit + ' ' + str(serviceCXFStatus)
def _set_monitors(self, monitors, tags):
self.j4p = Jolokia(self.url)
self.j4p.auth(httpusername=self.auth['username'], httppassword=self.auth['password'])
self.j4p.config(ignoreErrors=True)
self.monitors = copy.deepcopy(monitors)
for m in self.monitors:
if 'tags' in m:
m['tags'].update(tags)
else:
m['tags'] = tags
if 'tags' in m and len(m['tags']) > 0:
m['taglist'] = ["%s=%s" % (k, v) for k, v in m['tags'].items()]
else:
m['taglist'] = []
# set a default not_tags to '' to catch empty tag keys and append
# the value to metric name instead
m['not_tags'] += ['']
self.j4p.add_request(type='read', mbean=m['mbean'])
def __init__(self,
proxyhost='localhost',
proxyport=8888,
timeout=5,
debug=False):
''''''
self.proxyhost = proxyhost
self.proxyport = proxyport
self.debug = debug
self.proxyaddress = '%s:%s' % (self.proxyhost, self.proxyport)
self.proxy = Jolokia('http://%s/jolokia/' % self.proxyaddress)
self.proxy.timeout = timeout
self.order = ['RMI', 'REMOTING-JMX', 'JMXMP']
# these outputs indicate JMX available, but bad credentials
self.jmxReplies = [
#'Connection refused',
'Invalid credentials',
'Authentication failed',
'SecurityException',
'does not have administration access',
'com.sun.enterprise.security.LoginException',
]
self.jmx = None
def main():
global j4p
(options, args) = configure_options()
if len(args) != 2:
parser.print_help()
sys.exit(UNKNOWN)
if options.reset:
release_lock()
jolokia_endpoint = args[0]
bundle_name = args[1]
jolokia_username = options.user
jolokia_password = options.password
j4p = Jolokia(jolokia_endpoint)
j4p.auth(httpusername=jolokia_username, httppassword=jolokia_password)
if not dictionary_exists():
create_dictionary()
state = check_state(bundle_name)
if state == "ACTIVE":
print "OK - %s - %s" % (bundle_name, state)
sys.exit(OK)
elif state == "RESOLVED":
print "CRITICAL - %s - %s" % (bundle_name, state)
sys.exit(CRITICAL)
elif state == None:
print "UNKNOWN - Bundle %s not recognized" % bundle_name
sys.exit(UNKNOWN)
else:
print "WARNING - %s - %s" % (bundle_name, state)
sys.exit(WARNING)
def collect_common_data():
result = []
j4p = Jolokia(solr_config.jolokia_url)
#j4p.add_request(type='read', mbean='solr:id=NativeTrackerStats,type=NativeTrackerStats')
#data = j4p.getRequests()
#print(json.dumps(data, indent=4, separators=(',', ': ')))
#exit(1)
data = j4p.request(
type='read',
mbean='solr:id=NativeAllocatorStats,type=NativeAllocatorStats')
result.append(SolrKeyValue('numAlloc', data['value']['numAlloc'],
'derive'))
result.append(SolrKeyValue('numFree', data['value']['numFree'], 'derive'))
result.append(
SolrKeyValue('totalFreedMemoryInBytes',
data['value']['totalFreedMemoryInBytes'], 'derive'))
result.append(
SolrKeyValue('activeAllocatedMemoryInBytes',
data['value']['activeAllocatedMemoryInBytes']))
result.append(
SolrKeyValue('totalAllocatedMemoryInBytes',
data['value']['totalAllocatedMemoryInBytes'], 'derive'))
data = j4p.request(
type='read',
mbean='solr:id=NativeTrackerStats,type=NativeTrackerStats')
result.append(
SolrKeyValue('registeredThreads', data['value']['registeredThreads']))
result.append(
SolrKeyValue('trackedObjects', data['value']['trackedObjects']))
result.append(
SolrKeyValue('handedOffObjects', data['value']['handedOffObjects']))
return result
def apacheCamelValidate():
serverAddress = config.get('RootContainerSection', 'serverAddress')
appContainers = config.get('AppContainerSection', 'appContainers')
jlkUserName = config.get('RootContainerSection', 'jlkUserName')
jlkUserPassword = config.get('RootContainerSection', 'jlkUserPassword')
arrayContainersInstances = []
arrayContainersInstances.extend(appContainers.split(','))
for contSplit in arrayContainersInstances:
admPort = config.get('AppContainerSection', contSplit + '_adm_port')
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM,
socket.IPPROTO_TCP)
result = sock.connect_ex((serverAddress, int(admPort)))
if result == 0:
try:
j4p = Jolokia('http://' + serverAddress + ':' + admPort +
'/jolokia/')
j4p.auth(httpusername=decode(jlkUserName),
httppassword=decode(jlkUserPassword))
reqApacheCamelStatus = j4p.request(
type='read',
mbean='org.apache.camel:context=*,type=context,name=*',
attribute='State')
strApacheCamelStatus = reqApacheCamelStatus['value'].items(
)[0][1]['State']
if strApacheCamelStatus == 'Started':
apacheCamelStatus = 0
else:
apacheCamelStatus = 1
except Exception:
apacheCamelStatus = 1
else:
apacheCamelStatus = 1
print contSplit + ' ' + str(apacheCamelStatus)
#!/usr/bin/python
# -*- coding: utf-8 -*-
"""
author:Clay
Date:'15-11-20'
Description:Used to get jvm
"""
from __future__ import division
from pyjolokia import Jolokia
import time
import socket
import requests
import json
j4p = Jolokia('http://10.8.15.28:8778/jolokia/')
#------------------add request----------------------------
j4p.add_request(type='read',
mbean='java.lang:type=Threading',
attribute='ThreadCount')
j4p.add_request(type='read', mbean='java.lang:type=Memory')
hulb = j4p.getRequests()
threadcount = hulb[0]['value']
memhulb = hulb[1]['value']
#------------------------
#堆最大值
heapmem = memhulb['HeapMemoryUsage']
#堆当前分配值
Heapcommit = heapmem['committed']
def get_jolokia_inst(port):
"""Returns instance of jolokia"""
jolokia_url = "http://127.0.0.1:%s/jolokia/" % port
jolokiaclient = Jolokia(jolokia_url)
return jolokiaclient
sys.stdout.write("\n")
if len(newattributes) > 0:
f.write(bean['mbean'] + ";" + ";".join(newattributes) + "\n")
f.close()
def JolokiaQueryList():
'''
This function queries a jolokia for the list of all available beans.
'''
# Enter the jolokia url
JolokiaURL = '%s/%s' % (
config['Weblogic']['AdminURL'],
config['Weblogic']['JolokiaPath']
)
#print(JolokiaURL)
j4p = Jolokia(JolokiaURL)
j4p.auth(httpusername=config['Weblogic']['User'],
httppassword=config['Weblogic']['Password'])
# Put in the type, the mbean, or other options. Check the jolokia users guide for more info
# This then will return back a python dictionary of what happend to the request
#data = j4p.request(type = 'read', mbean='java.lang:type=Threading', attribute='ThreadCount')
data = j4p.request(type = 'list', path='')
return data
def JolokiaParseList(data):
'''
This function parses the jolokia list-document and applies black/whitelists.
'''
TheValues = data['value']
def memoryUsageStatus():
# type: () -> object
serverAddress = config.get('RootContainerSection', 'serverAddress')
rootContainer = config.get('RootContainerSection', 'rootContainer')
appContainers = config.get('AppContainerSection', 'appContainers')
gatewayContainers = config.get('GatewayContainerSection',
'gatewayContainer')
jlkUserName = config.get('RootContainerSection', 'jlkUserName')
jlkUserPassword = config.get('RootContainerSection', 'jlkUserPassword')
memoryTestTotal = config.get('RootContainerSection', 'memoryTestTotal')
arrayContainersInstances = []
arrayContainersInstances.append(rootContainer)
arrayContainersInstances.append(gatewayContainers)
arrayContainersInstances.extend(appContainers.split(','))
for contSplit in arrayContainersInstances:
if 'root' in contSplit:
# Setting adminPort
admPort = config.get('RootContainerSection',
contSplit + '_adm_port')
elif 'SIL' in contSplit:
admPort = config.get('AppContainerSection',
contSplit + '_adm_port')
elif 'gateway' in contSplit:
admPort = config.get('GatewayContainerSection',
contSplit + '_adm_port')
# Checking if adminPort is ok to execute test if not ok the test will be interrupted
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM,
socket.IPPROTO_TCP)
result = sock.connect_ex((serverAddress, int(admPort)))
# Looping to validate each admin port set in ConfigFile.properties
if result == 0:
# ###############################################
# ## Jolokia URL is based in serverAddress in ConfigFile.properties RootContainerSection
j4p = Jolokia('http://' + serverAddress + ':' + admPort +
'/jolokia/')
# # Using Jolokia Authentication
j4p.auth(httpusername=decode(jlkUserName),
httppassword=decode(jlkUserPassword))
# Request memory attributes
memory = j4p.request(type='read',
mbean='java.lang:type=Memory',
attribute='HeapMemoryUsage')
maxMemory = memory['value']['max']
usedMemory = memory['value']['used']
# Transform memory used in percentage of Max memory (Xmx)
memoryUsedPercentage = (usedMemory * 100) / maxMemory
fmemoControl = '/app/scripts/fuse-stats/control/.' + contSplit + '.txt'
if len((glob.glob(fmemoControl))) == 0:
with open(fmemoControl, 'wb') as csvfile:
csvWriter = csv.writer(csvfile)
csvWriter.writerow([
str(memoryUsedPercentage),
])
with open(fmemoControl, 'rb') as csvfile:
csvReader = csv.reader(csvfile)
calcMemAvg = 0
coutMemTest = 0
for rowMemValue in csvReader:
calcMemAvg = calcMemAvg + int(rowMemValue[0])
coutMemTest = coutMemTest + 1
memAvg = calcMemAvg / coutMemTest
print contSplit + ' ' + str(memAvg)
elif len((glob.glob(fmemoControl))) == 1:
with open(fmemoControl, 'a') as csvfile:
csvWriter = csv.writer(csvfile)
csvWriter.writerow([
str(memoryUsedPercentage),
])
teste = 0
with open(fmemoControl, 'rb') as csvfile:
csvReader = csv.reader(csvfile)
calcMemAvg = 0
countMemTest = 0
for rowMemValue in csvReader:
calcMemAvg = calcMemAvg + int(rowMemValue[0])
countMemTest = countMemTest + 1
if countMemTest >= int(memoryTestTotal):
os.remove(str(fmemoControl))
memAvg = calcMemAvg / coutMemTest
print contSplit + ' ' + str(memAvg)
else:
print contSplit + ' 0'
