def publish_proc_events_filtered(result, jp_expr, expt_value, debug=False):
if jp_expr is not None:
if not isinstance(jp_expr, list):
jp_expr = [jp_expr]
for expr in jp_expr:
if callable(expt_value):
_pass = expt_value(jp.match1(f"$[?({expr})]", [result]))
else:
_pass = (jp.match1(f"$[?({expr})]", [result]) == expt_value)
if not _pass:
return
data = result
event_info = data["event_info"]
result_subject = subject_factory(data[RuleConst.RULENAME],
event_info=event_info)
if debug and result["type"] != RULE_PROC_EVENT:
dispatch_policy = DispatchPolicyConst.NEVER
else:
dispatch_policy = DispatchPolicyConst.DIRECT
event_router_factory().route(RULE_PROC_EVENT,
result_subject,
data,
dispatch_policy=dispatch_policy)
def create_issue(self, issue_type_Id, project_Id, summary, description):
end_point = "rest/api/2/issue"
payload = {
"fields": {
"project": {
"id": project_Id
},
"summary": summary,
"description": description,
"issuetype": {
"id": issue_type_Id
}
}
}
response = requests.post(self.url + end_point,
auth=(self.user, self.token),
json=payload)
if self.is_json(response.text):
# JSON RESPONSE: convert response to JSON
json_result = json.loads(response.text)
# PRINT RESPONSE: pretty print with 4 indent
print(json.dumps(json_result, indent=4, sort_keys=True))
issue_Key = jp.match1("key", json_result)
issue_Id = jp.match1("id", json_result)
print("Issure create with key {} and ID {}".format(
issue_Key, issue_Id))
return (issue_Key, issue_Id)
def get_cycle_with_name(self, version_Id, project_Id, cycle_name):
end_point = "cycles/search"
canonical_path = 'GET&' + self.RELATIVE_PATH + end_point + '&expand=executionSummaries&projectId=' + project_Id + '&versionId=' + version_Id
token = self.jwt.generate_jwt(canonical_path)
# REQUEST HEADER: to create cycle
headers = {
'Authorization': 'JWT ' + token,
'Content-Type': 'text/plain',
'zapiAccessKey': self.access_key
}
print("Getting list of Cycles")
raw_result = requests.get(self.ZAPI_CLOUD_URL + self.RELATIVE_PATH +
end_point + '?versionId=' + version_Id +
'&expand=executionSummaries' +
'&projectId=' + project_Id,
headers=headers)
if self.is_json(raw_result.text):
# JSON RESPONSE: convert response to JSON
json_result = json.loads(raw_result.text)
# PRINT RESPONSE: pretty print with 4 indent
# print(json.dumps(json_result, indent=4, sort_keys=True))
#Get cycle id with name
cycle_Id = jp.match1("$[?(name='" + cycle_name + "')].id",
json_result)
print(cycle_Id)
return cycle_Id
def create_cycle(self, cycle_name, project_id, version_id):
end_point = 'cycle?expand=executionSummaries&clonedCycleId='
canonical_path = 'POST&' + self.RELATIVE_PATH + 'cycle' + '&clonedCycleId=&expand=executionSummaries'
token = self.jwt.generate_jwt(canonical_path)
# REQUEST HEADER: to create cycle
headers = {
'Authorization': f"JWT {token}",
'Content-Type': 'application/json',
'zapiAccessKey': self.access_key
}
# REQUEST PAYLOAD: to create cycle
cycle = {
'name': cycle_name,
'projectId': project_id,
'versionId': version_id
}
# MAKE REQUEST:
print("Creating Cycle")
raw_result = requests.post(self.ZAPI_CLOUD_URL + self.RELATIVE_PATH +
end_point,
headers=headers,
json=cycle)
json_result = tools.get_json_results(raw_result)
if json_result:
cycle_id = jp.match1("id", json_result)
print(f"Cycle created with ID: {cycle_id}")
return cycle_id
else:
raise Exception(f"An error was detected. Details in: {raw_result}")
def check_string_response(response, json_path_value):
'''Function will check string in response['response']'''
response = response.json()
response = json.loads(response['response'])
for jsonpath, expected_value in json_path_value.items():
assert expected_value == jp.match1(jsonpath, response)
def get_cycle_with_name(self, version_id, project_id, cycle_name):
end_point = "cycles/search"
canonical_path = f"GET&{self.RELATIVE_PATH}{end_point}&expand=executionSummaries&projectId={project_id}" \
f"&versionId={version_id}"
token = self.jwt.generate_jwt(canonical_path)
# REQUEST HEADER: to create cycle
headers = {
'Authorization': f"JWT {token}",
'Content-Type': 'text/plain',
'zapiAccessKey': self.access_key
}
print("Getting list of Cycles")
raw_result = requests.get(
f"{self.ZAPI_CLOUD_URL}{self.RELATIVE_PATH}{end_point}?versionId={version_id}"
f"&expand=executionSummaries&projectId={project_id}",
headers=headers)
json_result = tools.get_json_results(raw_result)
if json_result:
cycle_id = jp.match1("$[?(name='" + cycle_name + "')].id",
json_result)
print(cycle_id)
return cycle_id
else:
raise Exception(f"An error was detected. Details in: {raw_result}")
def publish_proc_events_filtered(result, jp_expr, expt_value):
if callable(expt_value):
_pass = expt_value(jp.match1(jp_expr, result))
else:
_pass = (jp.match1(jp_expr, result) == expt_value)
if not _pass:
return
data = result
# data = json.loads(json.dumps(result, cls=_JSONEncoder).encode("utf-8"))
event_info = data["event_info"]
result_subject = subject_factory(data[RuleConst.RULENAME], event_info=event_info)
event_router_factory().route(
RULE_PROC_EVENT, result_subject, data, dispatch_policy=DispatchPolicyConst.DIRECT
)
def process(self, latitude, longitude):
action = getattr(self, self.method)
logger.info(f"Processing {self.name}: {self.method}")
data = action(latitude, longitude)
logger.info(f"Result: {data.status_code}")
if data.status_code == requests.codes.ok:
answer = float(jp.match1(self.path, data.json()))
if not answer:
raise ValueError("Didn't found a correct value or unknown answer")
logger.error(f"{self.name} error no correct value found")
return answer
def update_execution(self, execution_id, project_id, version_id, cycle_id,
issue_id, status):
end_point = 'execution/'
canonical_path = f"PUT&{self.RELATIVE_PATH}{end_point}{execution_id}&"
token = self.jwt.generate_jwt(canonical_path)
headers = {
'Authorization': f'JWT {token}',
'Content-Type': 'application/json',
'zapiAccessKey': self.access_key
}
# REQUEST PAYLOAD: to update execution
update_test = {
'status': {
"id": status
},
'issueId': int(issue_id),
'projectId': int(project_id),
'versionId': int(version_id),
'cycleId': cycle_id
}
counter = 0
status_flag = 0
raw_result = None
while status_flag != 200 and counter < 3:
raw_result = requests.put(self.ZAPI_CLOUD_URL +
self.RELATIVE_PATH + end_point +
execution_id,
headers=headers,
json=update_test)
status_flag = raw_result.status_code
counter = counter + 1
# print(raw_result.text)
if raw_result:
if tools.is_json(raw_result.text):
# JSON RESPONSE: convert response to JSON
json_result = json.loads(raw_result.text)
status_code = jp.match1("$.execution.status.id", json_result)
assert status_code == status
print("Test run updated successfully for issue id {}".format(
issue_id))
# PRINT RESPONSE: pretty print with 4 indent
# print(json.dumps(json_result, indent=4, sort_keys=True))
else:
print("The request didn't run")
def get_issue_id_with_issue_name(self, issue_name):
end_point = f"/rest/api/latest/issue/{issue_name}"
response = requests.get(self.url + end_point,
auth=(self.user, self.token))
assert response.status_code == 200
if tools.is_json(response.text):
# JSON RESPONSE: convert response to JSON
json_result = json.loads(response.text)
# PRINT RESPONSE: pretty print with 4 indent
# print(json.dumps(json_result, indent=4, sort_keys=True))
issue_id = jp.match1("id", json_result)
print(f"Issue id for key {issue_name} is:{issue_id}")
return issue_id
def get_issue_id_with_key(self, key):
end_point = '/rest/api/2/search'
response = requests.get(self.url + end_point,
auth=(self.user, self.token))
assert response.status_code == 200
if self.is_json(response.text):
# JSON RESPONSE: convert response to JSON
json_result = json.loads(response.text)
# PRINT RESPONSE: pretty print with 4 indent
# print(json.dumps(json_result, indent=4, sort_keys=True))
issue_id = jp.match1("$.issues[?(key='" + key + "')].id",
json_result)
print("Issue id for key {} is:{}".format(key, issue_id))
return issue_id
def get_project_id_with_name(self, project_name):
end_point = "rest/api/2/project"
response = requests.get(self.url + end_point,
auth=(self.user, self.token))
assert response.status_code == 200
if tools.is_json(response.text):
# JSON RESPONSE: convert response to JSON
json_result = json.loads(response.text)
# PRINT RESPONSE: pretty print with 4 indent
# print(json.dumps(json_result, indent=4, sort_keys=True))
project_id = jp.match1("$[?(name='" + project_name + "')].id",
json_result)
print(f"Project ID {project_id} with Name {project_name}")
return project_id
def get_version_id_with_name(self, version_name, project_id):
end_point = "rest/api/2/project/" + project_id + "/version"
response = requests.get(self.url + end_point,
auth=(self.user, self.token))
assert response.status_code == 200
if self.is_json(response.text):
# JSON RESPONSE: convert response to JSON
json_result = json.loads(response.text)
# PRINT RESPONSE: pretty print with 4 indent
# print(json.dumps(json_result, indent=4, sort_keys=True))
version_id = jp.match1(
"$.values[?(name='" + version_name + "')].id", json_result)
print("Version ID {} with Name {}".format(version_id,
version_name))
return version_id
def update_execution(self, execution_Id, project_Id, version_Id, cycle_Id,
issue_Id, status):
end_point = 'execution/'
canonical_path = 'PUT&' + self.RELATIVE_PATH + end_point + execution_Id + '&'
token = self.jwt.generate_jwt(canonical_path)
headers = {
'Authorization': 'JWT ' + token,
'Content-Type': 'application/json',
'zapiAccessKey': self.access_key
}
# REQUEST PAYLOAD: to update execution
updateTest = {
'status': {
"id": status
},
'issueId': int(issue_Id),
'projectId': int(project_Id),
'versionId': int(version_Id),
'cycleId': cycle_Id
}
counter = 0
status_flag = 0
while (status_flag != 200 and counter < 3):
raw_result = requests.put(self.ZAPI_CLOUD_URL +
self.RELATIVE_PATH + end_point +
execution_Id,
headers=headers,
json=updateTest)
status_flag = raw_result.status_code
counter = counter + 1
#print(raw_result.text)
if self.is_json(raw_result.text):
# JSON RESPONSE: convert response to JSON
json_result = json.loads(raw_result.text)
status_code = jp.match1("$.execution.status.id", json_result)
assert status_code == status
print("Test run updated successfully for issue id {}".format(
issue_Id))
def create_cycle(self, cycle_name, project_Id, version_Id):
end_point = 'cycle?expand=executionSummaries&clonedCycleId='
canonical_path = 'POST&' + self.RELATIVE_PATH + 'cycle' + '&clonedCycleId=&expand=executionSummaries'
token = self.jwt.generate_jwt(canonical_path)
# REQUEST HEADER: to create cycle
headers = {
'Authorization': 'JWT ' + token,
'Content-Type': 'application/json',
'zapiAccessKey': self.access_key
}
# REQUEST PAYLOAD: to create cycle
cycle = {
'name': cycle_name,
'projectId': project_Id,
'versionId': version_Id
}
# MAKE REQUEST:
print("Creating Cycle")
raw_result = requests.post(self.ZAPI_CLOUD_URL + self.RELATIVE_PATH +
end_point,
headers=headers,
json=cycle)
if self.is_json(raw_result.text):
# JSON RESPONSE: convert response to JSON
json_result = json.loads(raw_result.text)
# PRINT RESPONSE: pretty print with 4 indent
#print(json.dumps(json_result, indent=4, sort_keys=True))
#Get cycle ID
cycle_id = jp.match1("id", json_result)
print("Cycle created with ID: {}".format(cycle_id))
return cycle_id
def get_value_path():
return jp.match1("$.[0].mappings[0].source", TOPICS)
def _get_path_id(self, path):
return jp.match1(path + ".id", self.schema)
## do something when success...,
# eg: Route("on-extapi-post.success", payload=resp.json())
))
]
}
},
"""
Manage exception
""",
{
rulename: "on-do-extapi-post-errors",
subscribe_to: "{}-errors".format(os.environ["K_SERVICE"]),
ruledata: {
filters: [
CheckPayload(
lambda x: x.get("rule_name") == "on-do-extapi-post" and jp.
match1("$.processing[*].exception", x
) == "requests.exceptions.HTTPError" and jp.match1(
"$.processing[*].exc_extra_info.response_code",
x) == 503)
],
processing: [
Schedule(message="do-extapi-post",
payload=_(lambda _self: _self.payload["payload"]),
when=_(lambda _: (datetime.now() + timedelta(
seconds=30)).isoformat())),
]
}
}
]
print("EXAMPLE: myvm.json")
exit(1)
filename = sys.argv[1]
# validate file existence
if not os.path.isfile(filename):
print(
"ERROR could not find json file with govc output {}".format(filename))
exit(2)
# read file from disk
json_file = open(filename)
json_data = json.load(json_file)
# name of VM
print("name: {}".format(jp.match1("elements[*].Object.Config.Name",
json_data)))
print("State: {}".format(
jp.match1("elements[*].Object.Runtime.PowerState", json_data)))
print("OS: {}".format(
jp.match1("elements[*].Object.Summary.Config.GuestFullName", json_data)))
# get path to vm, break apart
fullPath = jp.match1("elements[*].Path", json_data)
fullPath = fullPath[0:fullPath.rfind("/")]
pathsplit = fullPath.split("/")
print("Full path: {}".format(fullPath))
print("Parent Folder: {}".format(pathsplit[len(pathsplit) - 1]))
# show IP address and cidr/netmask
print("Default IpAddress: {}".format(
jp.match1("elements[*].Object.Guest.IpAddress", json_data)))
def jpath_value(self, payload, path_expression):
r = jp.match1(path_expression, payload)
return r
def test_info_metric_list(self):
resp = self.runner('info metric list')
res = jp.match1('$.[*].Metric', resp)
self.assertIsNotNone(res)
# so this goes unused now
def showJSONValues(json_data, expr):
jsonpath_expr = parse(expr)
for match in jsonpath_expr.find(json_data):
print(match.value)
return
####### MAIN ##########################################################3
# read file from disk
json_file = open("squad.json")
json_data = json.load(json_file)
# show simple attribute, then values from array
print("Squad: {}".format(jp.match1("squadName", json_data)))
print("\nMembers:")
for name in jp.match("$.members[*].name", json_data):
print(" {}".format(name))
# get all members, count length of returned list
print("\nCount members in list: {}".format(
len(jp.match("$.members[*]", json_data))))
# use extensions to provide direct count of number of members in array
print("Count members using len extension: {}".format(
jp.match1("$.members.`len`", json_data)))
# lookup array element given simple embedded element
lookFor = "Madame Uppercut"
print("\nPowers of {}".format(lookFor))
def get_config_value(value):
return jp.match1(value, CONFIG)
# eg: Route("on-extapi-post.success", payload=resp.json())
))
]
}
},
"""
Manage exception
""",
{
rulename: "on-do-extapi-post-errors",
subscribe_to: "{}-errors".format(os.environ["K_SERVICE"]),
ruledata: {
filters: [
IsTrue(lambda payload: payload.get(
"rule_name") == "on-do-extapi-post" and jp.match1(
"$.processing[*].exception", payload
) == "requests.exceptions.HTTPError" and jp.match1(
"$.processing[*].exc_extra_info.response_code", payload
) == 503)
],
processing: [
Schedule(message="do-extapi-post",
payload=lambda payload: payload["payload"],
when=lambda _:
(datetime.now() + timedelta(seconds=10)).isoformat(),
replace=True),
]
}
}
]
import os
import paho.mqtt.client as mqtt
from jsonpath_rw import jsonpath
from jsonpath_rw_ext import parse
# for calling extended methods
import jsonpath_rw_ext as jp
CONFIG = json.loads(os.getenv("CONFIG"))
TOPICS = json.loads(os.getenv("INPUT"))
print(CONFIG)
print(TOPICS)
test = jp.match1("$.[0].mappings[0].source", TOPICS)
val0 = 0
def on_connect(client, userdata, flags, rc):
print("Connected with result code " + str(rc))
client.subscribe(TOPICS[0]["name"])
def on_message(client, userdata, msg):
global val0
message = msg.payload.decode('utf8').replace('"{', '{').replace('"}', '}').replace('\\', '')
js = json.loads(message)
val = get_value(js)
diff = val - val0
def get_value(js):
return jp.match1(get_value_path(), js)
def process(instance, arg):
return jp.match1(arg._expr, instance.payload)
def check_jsonpath_value(response, json_path_value):
'''Function will match json value in response using jsonpath '''
print_message(response)
for jsonpath, expected_value in json_path_value.items():
#assert expected_value == jp.match1(jsonpath, response.json())
print(expected_value, jp.match1(jsonpath, response.json()))
filters: [IsTrue(lambda payload: payload["got_errors"])],
processing: [
Route(
lambda subject: "{}-errors".format(subject.event_info()[
"source"]), lambda payload: payload["subject"],
lambda payload: payload)
],
},
},
"""
Notify on slack
""",
{
rulename: 'on-errors-notify',
subscribe_to: TopicsDefault.RESULTS,
ruledata: {
filters: [IsTrue(lambda payload: payload["got_errors"])],
processing: [
SlackPublishMessage(
channel="errors",
text=lambda self: ":ambulance: *{}[{}]* \n```\n{}\n```".
format(
self.subject.event_info()["source"], self.
payload["rule_name"], "\n".join(
jp.match1("$.processing[*].exc_info", self.payload)
))),
]
}
},
]
def match(self, instance):
return jp.match1(self._expr, instance.payload)
def test_info_metric_list(self):
resp = self.runner('info metric list')
res = jp.match1('$.[*].Metric', resp)
self.assertIsNotNone(res)
