def get_data(self, request, pool=None, obj_profile=None, **kwargs):
data = []
if pool:
pool = Pool.get_by_id(pool)
else:
pool = Pool.get_by_name("default")
# Get all managed objects
mos = ManagedObject.objects.filter(is_managed=True, pool=pool)
if not request.user.is_superuser:
mos = ManagedObject.objects.filter(
is_managed=True,
pool=pool,
administrative_domain__in=UserAccess.get_domains(request.user),
)
if obj_profile:
mos = mos.filter(object_profile=obj_profile)
columns = (_("Managed Object"), _("Address"), _("Object"),
_("Capabilities"))
for mo in mos:
mo.get_caps()
data += [(mo.name, mo.address, _("Main"), ";".join(mo.get_caps()))]
for i in Interface.objects.filter(managed_object=mo):
if i.type == "SVI":
continue
data += [(mo.name, mo.address, i.name,
";".join(i.enabled_protocols))]
return self.from_dataset(title=self.title, columns=columns, data=data)
def get_report_object(self,
user=None,
is_managed=None,
adm=None,
selector=None,
pool=None,
segment=None,
ids=None):
mos = ManagedObject.objects.filter()
if user.is_superuser and not adm and not selector and not segment:
mos = ManagedObject.objects.filter()
if ids:
mos = ManagedObject.objects.filter(id__in=[ids])
if is_managed is not None:
mos = ManagedObject.objects.filter(is_managed=is_managed)
if pool:
p = Pool.get_by_name(pool or "default")
mos = mos.filter(pool=p)
if not user.is_superuser:
mos = mos.filter(
administrative_domain__in=UserAccess.get_domains(user))
if adm:
ads = AdministrativeDomain.get_nested_ids(int(adm))
mos = mos.filter(administrative_domain__in=ads)
if selector:
selector = ManagedObjectSelector.get_by_id(int(selector))
mos = mos.filter(selector.Q)
if segment:
segment = NetworkSegment.objects.filter(id=segment).first()
if segment:
mos = mos.filter(segment__in=segment.get_nested_ids())
return mos
def handle_estimate(self,
device_count=None,
box_interval=65400,
periodic_interval=300,
*args,
**options):
"""
Calculate Resource needed job
:param device_count: Count active device
:param box_interval: Box discovery interval
:param periodic_interval: Periodic discovery interval
:param
:return:
"""
if device_count:
task_count = {
Pool.get_by_name("default"): {
"box_task_per_seconds":
float(device_count) / float(box_interval),
"periodic_task_per_seconds":
float(device_count) / float(periodic_interval),
}
}
job_avg = {
Pool.get_by_name("default"): {
"box":
120.0, # Time execute box discovery (average in seconds)
"periodic":
10, # Time execute periodic discovery (average in seconds)
}
}
else:
task_count = self.get_task_count()
job_avg = self.get_job_avg()
for pool in task_count:
if pool == "all" or not task_count[pool]:
continue
job_count = task_count[pool]["box_task_per_seconds"] * job_avg[
pool].get("box", 0) + task_count[pool][
"periodic_task_per_seconds"] * job_avg[pool].get(
"periodic", 0)
self.print("%20s %s" % ("Pool", "Threads est."))
self.print("%40s %d" % (pool.name, math.ceil(job_count)))
def get_data(self,
request,
pool=None,
int_profile=None,
mop=None,
avail_status=None,
**kwargs):
data = []
mos = ManagedObject.objects.filter(is_managed=True)
# % fixme remove.
if not pool and request.user.is_superuser:
pool = Pool.get_by_name("STAGEMO")
if pool:
mos = mos.filter(pool=pool)
if not request.user.is_superuser:
mos = mos.filter(
administrative_domain__in=UserAccess.get_domains(request.user))
if mop:
mos = mos.filter(object_profile=mop)
mos_ids = mos.values_list("id", flat=True)
iface = Interface.objects.filter(managed_object__in=mos,
profile=int_profile,
type="physical").values_list(
"managed_object", "name")
res = []
n = 0
# Interface._get_collection()
while mos_ids[(0 + n):(10000 + n)]:
mos_ids_f = mos_ids[(0 + n):(10000 + n)]
s_iface = {"%d.%s" % (mo.id, name) for mo, name in iface}
of = ObjectFact.objects.filter(
object__in=mos_ids_f,
cls="subinterface",
attrs__traffic_control_broadcast=False)
a_f = {".".join((str(o.object.id), o.attrs["name"])) for o in of}
res.extend(a_f.intersection(s_iface))
n += 10000
for s in res:
mo, iface = s.split(".")
mo = ManagedObject.get_by_id(mo)
data += [(mo.name, mo.address, mo.profile.name, iface)]
return self.from_dataset(
title=self.title,
columns=[
_("Managed Object"),
_("Address"),
_("SA Profile"),
_("Interface")
],
data=data,
)
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.clean_map["pool"] = Pool.get_by_name
self.clean_map["fm_pool"] = lambda x: Pool.get_by_name(x
) if x else None
self.clean_map["profile"] = Profile.get_by_name
self.clean_map["static_service_groups"] = lambda x: [
str(x.id) for x in ResourceGroup.objects.filter(remote_id__in=x)
]
self.clean_map["static_client_groups"] = lambda x: [
str(x.id) for x in ResourceGroup.objects.filter(remote_id__in=x)
]
def api_report(
self,
request,
o_format,
is_managed=None,
administrative_domain=None,
selector=None,
pool=None,
segment=None,
avail_status=False,
columns=None,
ids=None,
enable_autowidth=False,
):
def row(row):
def qe(v):
if v is None:
return ""
if isinstance(v, str):
return smart_text(v)
elif isinstance(v, datetime.datetime):
return v.strftime("%Y-%m-%d %H:%M:%S")
elif not isinstance(v, str):
return str(v)
else:
return v
return [qe(x) for x in row]
def translate_row(row, cmap):
return [row[i] for i in cmap]
type_columns = ["Up/10G", "Up/1G", "Up/100M", "Down/-", "-"]
cols = [
"object1_admin_domain",
# "id",
"object1_name",
"object1_address",
"object1_platform",
"object1_segment",
"object1_tags",
"object1_iface",
"object1_descr",
"object1_speed",
"object2_admin_domain",
"object2_name",
"object2_address",
"object2_platform",
"object2_segment",
"object2_tags",
"object2_iface",
"object2_descr",
"object2_speed",
"link_proto",
"last_seen",
]
header_row = [
"OBJECT1_ADMIN_DOMAIN",
"OBJECT1_NAME",
"OBJECT1_ADDRESS",
"OBJECT1_PLATFORM",
"OBJECT1_SEGMENT",
"OBJECT1_TAGS",
"OBJECT1_IFACE",
"OBJECT1_DESCR",
"OBJECT1_SPEED",
"OBJECT2_ADMIN_DOMAIN",
"OBJECT2_NAME",
"OBJECT2_ADDRESS",
"OBJECT2_PLATFORM",
"OBJECT2_SEGMENT",
"OBJECT2_TAGS",
"OBJECT2_IFACE",
"OBJECT2_DESCR",
"OBJECT2_SPEED",
"LINK_PROTO",
"LAST_SEEN",
]
if columns:
cmap = []
for c in columns.split(","):
try:
cmap += [cols.index(c)]
except ValueError:
continue
else:
cmap = list(range(len(cols)))
r = [translate_row(header_row, cmap)]
if "interface_type_count" in columns.split(","):
r[-1].extend(type_columns)
# self.logger.info(r)
# self.logger.info("---------------------------------")
# print("-----------%s------------%s" % (administrative_domain, columns))
p = Pool.get_by_name(pool or "default")
mos = ManagedObject.objects.filter()
if request.user.is_superuser and not administrative_domain and not selector and not segment:
mos = ManagedObject.objects.filter(pool=p)
if ids:
mos = ManagedObject.objects.filter(id__in=[ids])
if is_managed is not None:
mos = ManagedObject.objects.filter(is_managed=is_managed)
if pool:
mos = mos.filter(pool=p)
if not request.user.is_superuser:
mos = mos.filter(
administrative_domain__in=UserAccess.get_domains(request.user))
if administrative_domain:
ads = AdministrativeDomain.get_nested_ids(
int(administrative_domain))
mos = mos.filter(administrative_domain__in=ads)
if selector:
selector = ManagedObjectSelector.get_by_id(int(selector))
mos = mos.filter(selector.Q)
if segment:
segment = NetworkSegment.objects.filter(id=segment).first()
if segment:
mos = mos.filter(segment__in=segment.get_nested_ids())
mos_id = list(mos.values_list("id", flat=True))
rld = ReportLinksDetail(mos_id)
mo_resolv = {
mo[0]: mo[1:]
for mo in ManagedObject.objects.filter().values_list(
"id",
"administrative_domain__name",
"name",
"address",
"segment",
"platform",
"labels",
)
}
for link in rld.out:
if len(rld.out[link]) != 2:
# Multilink or bad link
continue
s1, s2 = rld.out[link]
seg1, seg2 = None, None
if "object1_segment" in columns.split(
",") or "object2_segment" in columns.split(","):
seg1, seg2 = mo_resolv[s1["mo"][0]][3], mo_resolv[s2["mo"]
[0]][3]
plat1, plat2 = None, None
if "object1_platform" in columns.split(
",") or "object2_platform" in columns.split(","):
plat1, plat2 = mo_resolv[s1["mo"][0]][4], mo_resolv[s2["mo"]
[0]][4]
r += [
translate_row(
row([
mo_resolv[s1["mo"][0]][0],
mo_resolv[s1["mo"][0]][1],
mo_resolv[s1["mo"][0]][2],
"" if not plat1 else Platform.get_by_id(plat1),
"" if not seg1 else NetworkSegment.get_by_id(seg1),
";".join(mo_resolv[s1["mo"][0]][5] or []),
s1["iface_n"][0],
s1.get("iface_descr")[0]
if s1.get("iface_descr") else "",
s1.get("iface_speed")[0]
if s1.get("iface_speed") else 0,
mo_resolv[s2["mo"][0]][0],
mo_resolv[s2["mo"][0]][1],
mo_resolv[s2["mo"][0]][2],
"" if not plat2 else Platform.get_by_id(plat2),
"" if not seg2 else NetworkSegment.get_by_id(seg2),
";".join(mo_resolv[s2["mo"][0]][5] or []),
s2["iface_n"][0],
s2.get("iface_descr")[0]
if s2.get("iface_descr") else "",
s2.get("iface_speed")[0]
if s2.get("iface_speed") else 0,
s2.get("dis_method", ""),
s2.get("last_seen", ""),
]),
cmap,
)
]
filename = "links_detail_report_%s" % datetime.datetime.now().strftime(
"%Y%m%d")
if o_format == "csv":
response = HttpResponse(content_type="text/csv")
response[
"Content-Disposition"] = 'attachment; filename="%s.csv"' % filename
writer = csv.writer(response,
dialect="excel",
delimiter=",",
quoting=csv.QUOTE_MINIMAL)
writer.writerows(r)
return response
elif o_format == "csv_zip":
response = BytesIO()
f = TextIOWrapper(TemporaryFile(mode="w+b"), encoding="utf-8")
writer = csv.writer(f,
dialect="excel",
delimiter=";",
quotechar='"')
writer.writerows(r)
f.seek(0)
with ZipFile(response, "w", compression=ZIP_DEFLATED) as zf:
zf.writestr("%s.csv" % filename, f.read())
zf.filename = "%s.csv.zip" % filename
# response = HttpResponse(content_type="text/csv")
response.seek(0)
response = HttpResponse(response.getvalue(),
content_type="application/zip")
response[
"Content-Disposition"] = 'attachment; filename="%s.csv.zip"' % filename
return response
elif o_format == "xlsx":
response = BytesIO()
wb = xlsxwriter.Workbook(response)
cf1 = wb.add_format({"bottom": 1, "left": 1, "right": 1, "top": 1})
ws = wb.add_worksheet("Objects")
max_column_data_length = {}
for rn, x in enumerate(r):
for cn, c in enumerate(x):
if rn and (r[0][cn] not in max_column_data_length or
len(str(c)) > max_column_data_length[r[0][cn]]):
max_column_data_length[r[0][cn]] = len(str(c))
ws.write(rn, cn, c, cf1)
ws.autofilter(0, 0, rn, cn)
ws.freeze_panes(1, 0)
for cn, c in enumerate(r[0]):
# Set column width
width = get_column_width(c)
if enable_autowidth and width < max_column_data_length[c]:
width = max_column_data_length[c]
ws.set_column(cn, cn, width=width)
wb.close()
response.seek(0)
response = HttpResponse(response.getvalue(),
content_type="application/vnd.ms-excel")
# response = HttpResponse(
# content_type="application/x-ms-excel")
response[
"Content-Disposition"] = 'attachment; filename="%s.xlsx"' % filename
response.close()
return response
def api_report(self, request, o_format, is_managed=None,
administrative_domain=None, selector=None, pool=None,
segment=None, avail_status=False, columns=None, ids=None):
def row(row):
def qe(v):
if v is None:
return ""
if isinstance(v, unicode):
return v.encode("utf-8")
elif isinstance(v, datetime.datetime):
return v.strftime("%Y-%m-%d %H:%M:%S")
elif not isinstance(v, str):
return str(v)
else:
return v
return [qe(x) for x in row]
def translate_row(row, cmap):
return [row[i] for i in cmap]
type_columns = ["Up/10G", "Up/1G", "Up/100M", "Down/-", "-"]
cols = [
"admin_domain",
# "id",
"object1_name",
"object1_address",
"object1_iface",
"object2_name",
"object2_address",
"object2_iface",
"link_proto",
"last_seen"
]
header_row = [
"ADMIN_DOMAIN",
"OBJECT1_NAME",
"OBJECT1_ADDRESS",
"OBJECT1_IFACE",
"OBJECT2_NAME",
"OBJECT2_ADDRESS",
"OBJECT2_IFACE",
"LINK_PROTO",
"LAST_SEEN"
]
if columns:
cmap = []
for c in columns.split(","):
try:
cmap += [cols.index(c)]
except ValueError:
continue
else:
cmap = list(range(len(cols)))
r = [translate_row(header_row, cmap)]
if "interface_type_count" in columns.split(","):
r[-1].extend(type_columns)
# self.logger.info(r)
# self.logger.info("---------------------------------")
# print("-----------%s------------%s" % (administrative_domain, columns))
p = Pool.get_by_name(pool or "default")
mos = ManagedObject.objects.filter()
if request.user.is_superuser and not administrative_domain and not selector and not segment:
mos = ManagedObject.objects.filter(pool=p)
if ids:
mos = ManagedObject.objects.filter(id__in=[ids])
if is_managed is not None:
mos = ManagedObject.objects.filter(is_managed=is_managed)
if pool:
mos = mos.filter(pool=p)
if not request.user.is_superuser:
mos = mos.filter(administrative_domain__in=UserAccess.get_domains(request.user))
if administrative_domain:
ads = AdministrativeDomain.get_nested_ids(int(administrative_domain))
mos = mos.filter(administrative_domain__in=ads)
if selector:
selector = ManagedObjectSelector.get_by_id(int(selector))
mos = mos.filter(selector.Q)
if segment:
segment = NetworkSegment.objects.filter(id=segment).first()
if segment:
mos = mos.filter(segment__in=segment.get_nested_ids())
mos_id = list(mos.values_list("id", flat=True))
rld = ReportLinksDetail(mos_id)
mo_resolv = dict((mo[0], mo[1:]) for mo in ManagedObject.objects.filter().values_list(
"id", "administrative_domain__name", "name", "address"))
for link in rld.out:
if len(rld.out[link]) != 2:
# Multilink or bad link
continue
s1, s2 = rld.out[link]
r += [translate_row(row([
mo_resolv[s1["mo"][0]][0],
mo_resolv[s1["mo"][0]][1],
mo_resolv[s1["mo"][0]][2],
s1["iface_n"][0],
mo_resolv[s2["mo"][0]][1],
mo_resolv[s2["mo"][0]][2],
s2["iface_n"][0],
s1.get("dis_method", ""),
s1.get("last_seen", "")
]), cmap)]
filename = "links_detail_report_%s" % datetime.datetime.now().strftime("%Y%m%d")
if o_format == "csv":
response = HttpResponse(content_type="text/csv")
response[
"Content-Disposition"] = "attachment; filename=\"%s.csv\"" % filename
writer = csv.writer(response, dialect='excel', delimiter=';')
writer.writerows(r)
return response
elif o_format == "xlsx":
with tempfile.NamedTemporaryFile(mode="wb") as f:
wb = xlsxwriter.Workbook(f.name)
ws = wb.add_worksheet("Objects")
for rn, x in enumerate(r):
for cn, c in enumerate(x):
ws.write(rn, cn, c)
ws.autofilter(0, 0, rn, cn)
wb.close()
response = HttpResponse(
content_type="application/x-ms-excel")
response[
"Content-Disposition"] = "attachment; filename=\"%s.xlsx\"" % filename
with open(f.name) as ff:
response.write(ff.read())
return response