internal void UpdateEntry(CDatabaseEntry entry)
{
SQLiteDataReader reader = ExecuteParameterizedReader("SELECT * FROM ea_objects WHERE uid=@0", entry.Id);
CDiscoveredConfig existingprops = new CDiscoveredConfig();
while (reader.Read()) // read existing attributes
{
if (entry.Reference.ToStringNz() == "")
{
entry.Reference = reader["ref"].ToStringNz();
}
if (entry.Created.ToStringNz() == "")
{
entry.Created = reader["created"].ToStringNz();
}
if (entry.Accessed.ToStringNz() == "")
{
entry.Accessed = reader["accessed"].ToStringNz();
}
if (entry.Type.ToStringNz() == "")
{
entry.Type = reader["type"].ToStringNz();
}
existingprops = CDiscoveredConfig.Deserialize(reader["attributes"].ToStringNz());
}
if (existingprops.Attributes != null && existingprops.Attributes.Count() > 0)
{
CDiscoveredConfig newprops = CDiscoveredConfig.Deserialize(entry.Attributes);
existingprops.Merge(newprops);
entry.Attributes = existingprops.Serialize(CDiscoveredAttributes.SerializeAsShortJson);
ExecuteParameterizedNonQuery("UPDATE ea_objects SET name=@1, ref=@2, type=@3, parent=@4, created=@5, accessed=@6, attributes=@7 WHERE uid=@0", entry.Id, entry.Name, entry.Reference, entry.Type, entry.Parent, entry.Created, entry.Accessed, entry.Attributes);
}
}
private void AddGroupingInfo(CService server, CDiscoveredConfig oc)
{
if (server.Type == CServiceType.VCenterServer)
{
_AddGroupingInfo(server, server.Name, CDiscoveredTypes.VCenterServer, server.Id, server.Id);
string dc = oc.Attributes.Get(CAttributeType.Datacenter).ToStringNz();
string cl = oc.Attributes.Get(CAttributeType.Cluster).ToStringNz();
string dcid = _AddGroupingInfo(server, dc, CDiscoveredTypes.VIDatacenter, server.Id);
string clid = _AddGroupingInfo(server, cl, CDiscoveredTypes.VICluster, dcid);
}
if (server.Type == CServiceType.HYVServer)
{
string cl = oc.Attributes.Get(CAttributeType.Cluster).ToStringNz();
if (cl.Length > 0)
{
string clid = _AddGroupingInfo(server, cl, CDiscoveredTypes.HVCluster, "", "");
}
else
{
string hostid = _AddGroupingInfo(server, server.Name, CDiscoveredTypes.HVHost, server.Id, server.Id);
}
}
if (server.Type == CServiceType.ESXServer)
{
string hostid = _AddGroupingInfo(server, server.Name, CDiscoveredTypes.VIHost, server.Id, server.Id);
}
_AddGroupingInfo(server, oc.Site.ToStringNz(), CDiscoveredTypes.Site, server.Id);
}
public CDiscoveredConfig _UpdateGroupingInfo(CDiscoveredConfig group, CDiscoveredConfig oc)
{
if ((oc.Type == CDiscoveredTypes.VIHost) || (oc.Type == CDiscoveredTypes.HVHost))
{
group.Metrics.Increment(CMetricType.HostCpu, CMetricSubtype.Sockets, oc);
group.Metrics.Increment(CMetricType.HostCpu, CMetricSubtype.Cores, oc);
group.Metrics.Increment(CMetricType.HostMem, CMetricSubtype.Allocated, oc);
group.Metrics.Increment(CMetricType.HostCount, 1);
}
else if ((oc.Type == CDiscoveredTypes.VIVM) || (oc.Type == CDiscoveredTypes.HVVM))
{
group.Metrics.Increment(CMetricType.VmCpu, CMetricSubtype.Sockets, oc);
group.Metrics.Increment(CMetricType.VmCpu, CMetricSubtype.Cores, oc);
group.Metrics.Increment(CMetricType.VmDisk, CMetricSubtype.Allocated, oc);
group.Metrics.Increment(CMetricType.VmDisk, CMetricSubtype.Used, oc);
group.Metrics.Increment(CMetricType.VmDisk, CMetricSubtype.Unshared, oc);
group.Metrics.Increment(CMetricType.VmMem, CMetricSubtype.Allocated, oc);
group.Metrics.Increment(CMetricType.VmCount, 1);
}
else if ((oc.Type == CDiscoveredTypes.VIDatastore) || (oc.Type == CDiscoveredTypes.HVDatastore))
{
group.Metrics.Increment(CMetricType.DsDisk, CMetricSubtype.Allocated, oc);
group.Metrics.Increment(CMetricType.DsDisk, CMetricSubtype.Used, oc);
group.Metrics.Increment(CMetricType.DsCount, 1);
}
oc = _UpdateObjectGroupingInfo(oc);
return(oc);
}
private void OnDataCollectWorker_RemoveDuplicateServers()
{
List <CService> servers = new List <CService> {
};
servers.AddRange(DiscoveredServers.OfType <CService>());
servers = servers.OrderBy(o => o.Name).ToList();
string lastServerName = "";
int lastServerType = -1;
for (int i = 0; i < servers.Count(); i++)
{
//Log.Write(servers[i].Name);
if ((lastServerName.ToLower() == servers[i].Name.ToLower()) && (lastServerType == servers[i].Type))
{
servers.RemoveAt(i); // same server name with same server type
}
else
{
CQuery q = servers[i].Session.Queries[0];
for (int j = 0; j < q.Result.Count; j++)
{
CDiscoveredConfig sc = q.Result[j];
for (int k = 0; k < servers.Count(); k++)
{
// server already exists as another server's child
if (servers[k].Name.ToLower() == sc.Name.ToLower() && (servers[k].Id != servers[i].Id))
{
servers.RemoveAt(k);
}
}
}
}
if (i < servers.Count)
{
lastServerName = servers[i].Name;
lastServerType = servers[i].Type;
}
}
DiscoveredServers.Clear();
DiscoveredServers.AddRange(servers);
}
private CDiscoveredConfig UpdateGroupingInfo(CService server, CDiscoveredConfig oc)
{
foreach (CDiscoveredConfig group in DiscoveredGroups.Values)
{
bool match = false;
match = match || (group.Type == CDiscoveredTypes.VCenterServer && group.Name == server.Name);
match = match || (group.Type == CDiscoveredTypes.SCVMMServer && group.Name == server.Name);
match = match || (group.Type == CDiscoveredTypes.Site && group.Name == oc.Site.ToStringNz());
match = match || (group.Type == CDiscoveredTypes.VIDatacenter && group.Name == oc.Attributes.Get(CAttributeType.Datacenter).ToStringNz());
match = match || (group.Type == CDiscoveredTypes.VICluster && group.Name == oc.Attributes.Get(CAttributeType.Cluster).ToStringNz());
match = match || (group.Type == CDiscoveredTypes.HVCluster && group.Name == oc.Attributes.Get(CAttributeType.Cluster).ToStringNz());
match = match || (group.Type == CDiscoveredTypes.VIHost && oc.Owner.Contains(group.Id));
match = match || (group.Type == CDiscoveredTypes.HVHost && oc.Owner.Contains(group.Id));
if (match)
{
oc = _UpdateGroupingInfo(group, oc);
}
}
return(oc);
}
public void ExportDiscoveredConfig(CDiscoveredConfig oc, CService server = null, bool rolluptotals = false)
{
if (oc.Attributes != null && oc.Name.Length > 0)
{
if (server != null && rolluptotals)
{
// create grouping objects
AddGroupingInfo(server, oc);
// rollup totals by group and repair object parent properties
oc = UpdateGroupingInfo(server, oc);
}
CDatabaseEntry entry = new CDatabaseEntry();
entry.Id = oc.Id.ToString();
entry.Reference = oc.Attributes.Get(CAttributeType.Reference);
entry.Created = oc.Attributes.Get(CAttributeType.Created);
entry.Accessed = oc.Attributes.Get(CAttributeType.Accessed);
entry.Name = CFunctions.EscapeJson(oc.Name);
entry.Type = oc.Type.ToString();
entry.Parent = CFunctions.StringJoin(";", oc.Owner);
entry.Attributes = oc.Serialize(CDiscoveredConfig.SerializeAsShortJson);
if (!ExportedEntries.Contains(entry.Id))
{
_DBConn.AddEntry(entry);
ExportedEntries.Add(entry.Id);
}
else
{
_DBConn.UpdateEntry(entry);
}
}
if (oc.ChildObjects != null)
{
foreach (CDiscoveredConfig obj in oc.ChildObjects)
{
ExportDiscoveredConfig(obj, server, rolluptotals);
}
}
}
public CDiscoveredConfig _UpdateObjectGroupingInfo(CDiscoveredConfig oc)
{
if ((oc.Type == CDiscoveredTypes.VIHost) || (oc.Type == CDiscoveredTypes.HVHost))
{
CDiscoveredConfig cluster = null;
CDiscoveredConfig datacenter = null;
string clusterstr = oc.Attributes.Get(CAttributeType.Cluster);
string datacenterstr = oc.Attributes.Get(CAttributeType.Datacenter);
if ((clusterstr != null) && (DiscoveredGroups.TryGetValue(clusterstr, out cluster)))
{
oc.Owner = new List <string> {
cluster.Id
};
}
else if ((datacenterstr != null) && (DiscoveredGroups.TryGetValue(datacenterstr, out datacenter)))
{
oc.Owner = new List <string> {
datacenter.Id
};
}
}
return(oc);
}
internal List <CDiscoveredConfig> GetHosts(int queryid)
{
List <CDiscoveredConfig> HostsFound = new List <CDiscoveredConfig> {
};
IList <EntityViewBase> hosts = null;
// dont continue if not logged in
if (HVClient == null)
{
return(HostsFound);
}
try { Log.Write("[HvApi] Querying hosts associated with: " + Server.Name.ToUpper()); hosts = HVClient.FindEntityViews(typeof(HostSystem)); }
catch (Exception ex) { Log.Write("Error: Cannot query host information. Details: " + ex.TargetSite + ex.Message); }
_SiteInfo = Server.Session.Queries[queryid].Sites;
if (hosts != null)
{
Log.Write(CFunctions.StringReplace("Found hosts ({0}) associated with {1}", hosts.Count.ToString(), Server.Name.ToUpper()));
foreach (HostSystem host in hosts)
{
string cluster = "";
if (HVClient.HostType == HvHostType.Cluster)
{
cluster = HVClient._ClusterName;
}
CDiscoveredMetrics hostmetrics = new CDiscoveredMetrics();
hostmetrics.Set(CMetricType.HostCpu, CMetricSubtype.Sockets, host.Hardware.CpuInfo.NumCpuPackages);
hostmetrics.Set(CMetricType.HostCpu, CMetricSubtype.Cores, host.Hardware.CpuInfo.NumCpuCores);
hostmetrics.Set(CMetricType.HostMem, CMetricSubtype.Allocated, CFunctions.ConvertDataUnit(host.Hardware.MemorySize, CDataUnitType.Byte, CDataUnitType.MiB));
hostmetrics.Set(CMetricType.VmCount, CMetricSubtype.None, host.Vm.Count());
hostmetrics.Set(CMetricType.DsCount, CMetricSubtype.None, host.Datastore.Count());
CDiscoveredAttributes hostattribs = new CDiscoveredAttributes();
hostattribs.Set(CAttributeType.Reference, "HostSystem-" + host.Id.ToLower());
hostattribs.Set(CAttributeType.IP, host.IP.ToString());
hostattribs.Set(CAttributeType.OS, host.OS);
hostattribs.Set(CAttributeType.Cluster, cluster);
hostattribs.Set(CAttributeType.HardwareVersion, (host.Hardware.SystemInfo.Vendor + " " + host.Hardware.SystemInfo.Model).Replace(",", String.Empty));
hostattribs.Set(CAttributeType.PowerState, "poweredOn"); // silly but we will not get any data from powered off hosts
//hostattribs.Merge(GetObjectState(host))
CDiscoveredConfig hostinfo = new CDiscoveredConfig()
{
Type = new CDiscoveredTypes(CDiscoveredTypes.HVHost),
Site = CSite.Resolve(host.IP, _SiteInfo),
Name = host.Name.ToString(),
Metrics = hostmetrics,
Attributes = hostattribs,
Owner = new List <string> {
Server.Id
}
};
if ((hosts.Count == 1) && (HVClient.HostType == HvHostType.Standalone))
{
hostinfo.Id = Server.Id;
}
StoreObjectUid(hostinfo.Name, hostinfo.Id);
Log.Write(hostinfo.ToString(), Log.Verbosity.Debug);
HostsFound.Add(hostinfo);
}
HostsFound = HostsFound.OrderBy(o => o.Name).ToList();
}
return(HostsFound);
}
internal List <CDiscoveredConfig> GetVms(int queryid)
{
List <CDiscoveredConfig> VMsFound = new List <CDiscoveredConfig> {
};
IList <EntityViewBase> vms = null;
// dont continue if not logged in
if (HVClient == null)
{
return(VMsFound);
}
try { Log.Write("[HvApi] Querying virtual machines associated with: " + Server.Name.ToUpper()); vms = HVClient.FindEntityViews(typeof(VirtualMachine)); }
catch (Exception ex) { Log.Write("Error: Cannot query virtual machine information. Details: " + ex.TargetSite + ex.Message); }
_SiteInfo = Server.Session.Queries[queryid].Sites;
if (vms != null)
{
// iterate through vms and get general information
Log.Write(CFunctions.StringReplace("Found virtual machines ({0}) associated with {1}", vms.Count.ToString(), Server.Name.ToUpper()));
foreach (EntityViewBase tmp in vms)
{
VirtualMachine vm = (VirtualMachine)tmp;
if (vm.Name != null)
{
long storagealloc = CFunctions.ConvertDataUnit(vm.Storage.Allocated, CDataUnitType.Byte, CDataUnitType.MiB);
long storageused = CFunctions.ConvertDataUnit(vm.Storage.Used, CDataUnitType.Byte, CDataUnitType.MiB);
//double storageunshared = CFunctions.ConvertDataUnit(vm.Storage.Unshared, CDataUnitType.Byte, CDataUnitType.MiB);
string owner = RetrieveObjectUid(vm.Host);
CDiscoveredMetrics guestusage = new CDiscoveredMetrics();
guestusage.Set(CMetricType.VmDisk, CMetricSubtype.Allocated, vm.Storage.Allocated);
guestusage.Set(CMetricType.VmDisk, CMetricSubtype.Used, vm.Storage.Used);
guestusage.Set(CMetricType.VmCpu, CMetricSubtype.Sockets, vm.Hardware.NumCPU);
guestusage.Set(CMetricType.VmCpu, CMetricSubtype.Cores, ((int)vm.Hardware.NumCPU * vm.Hardware.NumCoresPerSocket.GetValueOrDefault(1)));
guestusage.Set(CMetricType.VmMem, CMetricSubtype.Allocated, vm.Hardware.MemoryMB);
guestusage.Set(CMetricType.VmDisk, CMetricSubtype.Allocated, storagealloc);
guestusage.Set(CMetricType.VmDisk, CMetricSubtype.Used, storageused);
CDiscoveredAttributes guestattribs = new CDiscoveredAttributes();
guestattribs.Set(CAttributeType.Reference, "VirtualMachine-" + vm.Id.ToLower());
guestattribs.Set(CAttributeType.IP, vm.Guest.IP.ToString());
guestattribs.Set(CAttributeType.OS, vm.Guest.OS);
guestattribs.Set(CAttributeType.HardwareVersion, vm.Version);
guestattribs.Set(CAttributeType.ToolsVersion, vm.Guest.ToolsVersion.ToString());
guestattribs.Set(CAttributeType.Cluster, vm.Cluster);
//guestattribs.Merge(GetObjectState(vm))
string vmPowerState = "poweredOff";
if ((VmEnabledState)vm.State == VmEnabledState.Enabled)
{
vmPowerState = "poweredOn";
}
else if (((VmEnabledState)vm.State == VmEnabledState.Paused) || ((VmEnabledState)vm.State == VmEnabledState.Pausing) || ((VmEnabledState)vm.State == VmEnabledState.Suspended))
{
vmPowerState = "suspended";
}
guestattribs.Set(CAttributeType.PowerState, vmPowerState);
CDiscoveredConfig guestinfo = new CDiscoveredConfig
{
Type = new CDiscoveredTypes(CDiscoveredTypes.HVVM),
Site = CSite.Resolve(vm.Guest.IP, _SiteInfo),
Name = vm.Name.ToString(),
Metrics = guestusage,
Attributes = guestattribs,
Owner = new List <string> {
owner
}
};
StoreObjectUid(guestinfo.Attributes.Get(CAttributeType.Reference), guestinfo.Id);
guestinfo.ChildObjects = GetVmDisks(queryid, vm);
Log.Write(guestinfo.ToString(), Log.Verbosity.Debug);
VMsFound.Add(guestinfo);
}
}
VMsFound = VMsFound.OrderBy(o => o.Name).ToList(); // sort alphabally
// get additional details for thin vmdk files
//VMsFound = UpdateVIVMDiskDatastoreInfo(queryid, VMsFound);
}
return(VMsFound);
}
internal List <CDiscoveredConfig> GetDatastores(int queryid)
{
List <CDiscoveredConfig> DatastoresFound = new List <CDiscoveredConfig> {
};
IList <EntityViewBase> datastores = null;
// dont continue if not logged in
if (HVClient == null)
{
return(DatastoresFound);
}
try { Log.Write("[HvApi] Querying datastores associated with: " + Server.Name.ToUpper()); datastores = HVClient.FindEntityViews(typeof(Datastore)); }
catch (Exception ex) { Log.Write("Error: Cannot query datastore information. Details: " + ex.TargetSite + ex.Message); }
_SiteInfo = Server.Session.Queries[queryid].Sites;
if (datastores != null)
{
// iterate through vms and get general information
Log.Write(CFunctions.StringReplace("Found datastores ({0}) associated with {1}", datastores.Count.ToString(), Server.Name.ToUpper()));
foreach (EntityViewBase tmp in datastores)
{
Datastore ds = (Datastore)tmp;
if (ds.Name != null)
{
long storagealloc = CFunctions.ConvertDataUnit(ds.Capacity, CDataUnitType.Byte, CDataUnitType.MiB);
long storageused = CFunctions.ConvertDataUnit(ds.Capacity - ds.FreeSpace, CDataUnitType.Byte, CDataUnitType.MiB);
List <string> owner = new List <string> {
};
foreach (string parent in ds.Host.Split(';'))
{
owner.Add(RetrieveObjectUid(parent));
}
CDiscoveredMetrics dsmetric = new CDiscoveredMetrics();
dsmetric.Set(CMetricType.DsDisk, CMetricSubtype.Allocated, storagealloc);
dsmetric.Set(CMetricType.DsDisk, CMetricSubtype.Used, storageused);
CDiscoveredAttributes dsattrib = new CDiscoveredAttributes();
string id = ds.ID.Split('{')[1].Split('}')[0];
dsattrib.Set(CAttributeType.Reference, "Datastore-" + id);
dsattrib.Set(CAttributeType.Format, ds.FileSystem);
dsattrib.Set(CAttributeType.Vendor, ds.Vendor);
dsattrib.Set(CAttributeType.Model, ds.Model);
dsattrib.Set(CAttributeType.Mode, ds.AccessMode);
dsattrib.Set(CAttributeType.Cluster, ds.Cluster);
bool islocal = true;
if ((ds.AccessMode.ToLower().Contains("iscsi")) || (ds.AccessMode.ToLower().Contains("fibre")))
{
islocal = false;
}
dsattrib.Set(CAttributeType.Local, islocal.ToString());
CDiscoveredConfig dsinfo = new CDiscoveredConfig();
dsinfo.Type = new CDiscoveredTypes(CDiscoveredTypes.HVDatastore);
dsinfo.Name = ds.Name;
dsinfo.Metrics = dsmetric;
dsinfo.Attributes = dsattrib;
dsinfo.Owner = owner;
StoreObjectUid(dsinfo.Attributes.Get(CAttributeType.Reference), dsinfo.Id);
Log.Write(dsinfo.ToString(), Log.Verbosity.Debug);
DatastoresFound.Add(dsinfo);
}
}
DatastoresFound = DatastoresFound.OrderBy(o => o.Name).ToList();
}
return(DatastoresFound);
}
