180 lines
7.1 KiB
Python
180 lines
7.1 KiB
Python
#
|
|
# Copyright 2022 Google LLC
|
|
#
|
|
# Licensed under the Apache License, Version 2.0 (the "License");
|
|
# you may not use this file except in compliance with the License.
|
|
# You may obtain a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS,
|
|
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
# See the License for the specific language governing permissions and
|
|
# limitations under the License.
|
|
#
|
|
|
|
import time
|
|
|
|
from . import metrics, networks, limits
|
|
|
|
|
|
def get_vpc_peering_data(config, metrics_dict, limit_dict):
|
|
'''
|
|
Gets the data for VPC peerings (active or not) and writes it to the metric defined (vpc_peering_active_metric and vpc_peering_metric).
|
|
|
|
Parameters:
|
|
config (dict): The dict containing config like clients and limits
|
|
metrics_dict (dictionary of dictionary of string: string): metrics names and descriptions
|
|
limit_dict (dictionary of string:int): Dictionary with the network link as key and the limit as value
|
|
Returns:
|
|
None
|
|
'''
|
|
timestamp = time.time()
|
|
for project in config["monitored_projects"]:
|
|
active_vpc_peerings, vpc_peerings = gather_vpc_peerings_data(
|
|
config, project, limit_dict)
|
|
|
|
for peering in active_vpc_peerings:
|
|
metric_labels = {
|
|
'project': project,
|
|
'network_name': peering['network_name']
|
|
}
|
|
metrics.append_data_to_series_buffer(
|
|
config, metrics_dict["metrics_per_network"]
|
|
["vpc_peering_active_per_network"]["usage"]["name"],
|
|
peering['active_peerings'], metric_labels, timestamp=timestamp)
|
|
metrics.append_data_to_series_buffer(
|
|
config, metrics_dict["metrics_per_network"]
|
|
["vpc_peering_active_per_network"]["limit"]["name"],
|
|
peering['network_limit'], metric_labels, timestamp=timestamp)
|
|
metrics.append_data_to_series_buffer(
|
|
config, metrics_dict["metrics_per_network"]
|
|
["vpc_peering_active_per_network"]["utilization"]["name"],
|
|
peering['active_peerings'] / peering['network_limit'], metric_labels,
|
|
timestamp=timestamp)
|
|
print(
|
|
"Buffered number of active VPC peerings to custom metric for project:",
|
|
project)
|
|
|
|
for peering in vpc_peerings:
|
|
metric_labels = {
|
|
'project': project,
|
|
'network_name': peering['network_name']
|
|
}
|
|
metrics.append_data_to_series_buffer(
|
|
config, metrics_dict["metrics_per_network"]["vpc_peering_per_network"]
|
|
["usage"]["name"], peering['peerings'], metric_labels,
|
|
timestamp=timestamp)
|
|
metrics.append_data_to_series_buffer(
|
|
config, metrics_dict["metrics_per_network"]["vpc_peering_per_network"]
|
|
["limit"]["name"], peering['network_limit'], metric_labels,
|
|
timestamp=timestamp)
|
|
metrics.append_data_to_series_buffer(
|
|
config, metrics_dict["metrics_per_network"]["vpc_peering_per_network"]
|
|
["utilization"]["name"],
|
|
peering['peerings'] / peering['network_limit'], metric_labels,
|
|
timestamp=timestamp)
|
|
print("Buffered number of VPC peerings to custom metric for project:",
|
|
project)
|
|
|
|
|
|
def gather_peering_data(config, project_id):
|
|
'''
|
|
Returns a dictionary of all peerings for all networks in a project.
|
|
|
|
Parameters:
|
|
config (dict): The dict containing config like clients and limits
|
|
project_id (string): Project ID for the project containing the networks.
|
|
Returns:
|
|
network_list (dictionary of string: string): Contains the project_id, network_name(s) and network_id(s) of peered networks.
|
|
'''
|
|
request = config["clients"]["discovery_client"].networks().list(
|
|
project=project_id)
|
|
response = request.execute()
|
|
|
|
network_list = []
|
|
if 'items' in response:
|
|
for network in response['items']:
|
|
net = {
|
|
'project_id': project_id,
|
|
'network_name': network['name'],
|
|
'network_id': network['id'],
|
|
'peerings': []
|
|
}
|
|
if 'peerings' in network:
|
|
STATE = network['peerings'][0]['state']
|
|
if STATE == "ACTIVE":
|
|
for peered_network in network[
|
|
'peerings']: # "projects/{project_name}/global/networks/{network_name}"
|
|
start = peered_network['network'].find("projects/") + len(
|
|
'projects/')
|
|
end = peered_network['network'].find("/global")
|
|
peered_project = peered_network['network'][start:end]
|
|
peered_network_name = peered_network['network'].split(
|
|
"networks/")[1]
|
|
peered_net = {
|
|
'project_id':
|
|
peered_project,
|
|
'network_name':
|
|
peered_network_name,
|
|
'network_id':
|
|
networks.get_network_id(config, peered_project,
|
|
peered_network_name)
|
|
}
|
|
net["peerings"].append(peered_net)
|
|
network_list.append(net)
|
|
return network_list
|
|
|
|
|
|
def gather_vpc_peerings_data(config, project_id, limit_dict):
|
|
'''
|
|
Gets the data for all VPC peerings (active or not) in project_id and writes it to the metric defined in vpc_peering_active_metric and vpc_peering_metric.
|
|
|
|
Parameters:
|
|
config (dict): The dict containing config like clients and limits
|
|
project_id (string): We will take all VPCs in that project_id and look for all peerings to these VPCs.
|
|
limit_dict (dictionary of string:int): Dictionary with the network link as key and the limit as value
|
|
Returns:
|
|
active_peerings_dict (dictionary of string: string): Contains project_id, network_name, network_limit for each active VPC peering.
|
|
peerings_dict (dictionary of string: string): Contains project_id, network_name, network_limit for each VPC peering.
|
|
'''
|
|
active_peerings_dict = []
|
|
peerings_dict = []
|
|
request = config["clients"]["discovery_client"].networks().list(
|
|
project=project_id)
|
|
response = request.execute()
|
|
if 'items' in response:
|
|
for network in response['items']:
|
|
if 'peerings' in network:
|
|
STATE = network['peerings'][0]['state']
|
|
if STATE == "ACTIVE":
|
|
active_peerings_count = len(network['peerings'])
|
|
else:
|
|
active_peerings_count = 0
|
|
|
|
peerings_count = len(network['peerings'])
|
|
else:
|
|
peerings_count = 0
|
|
active_peerings_count = 0
|
|
|
|
network_link = f"https://www.googleapis.com/compute/v1/projects/{project_id}/global/networks/{network['name']}"
|
|
network_limit = limits.get_ppg(network_link, limit_dict)
|
|
|
|
active_d = {
|
|
'project_id': project_id,
|
|
'network_name': network['name'],
|
|
'active_peerings': active_peerings_count,
|
|
'network_limit': network_limit
|
|
}
|
|
active_peerings_dict.append(active_d)
|
|
d = {
|
|
'project_id': project_id,
|
|
'network_name': network['name'],
|
|
'peerings': peerings_count,
|
|
'network_limit': network_limit
|
|
}
|
|
peerings_dict.append(d)
|
|
|
|
return active_peerings_dict, peerings_dict
|