use generic func to convert slices of a type to slices of interface

Signed-off-by: Ivan Milchev <[email protected]>

resources/packs/azure/azure_cloud_defender.go

@@ -225,7 +225,7 @@ func (a *mqlAzureSubscriptionCloudDefenderService) GetSecurityContacts() (interf
 		mqlSecurityContact, err := a.MotorRuntime.CreateResource("azure.subscription.cloudDefenderService.securityContact",
 			"id", core.ToString(contact.ID),
 			"name", core.ToString(contact.Name),
-			"emails", core.StrSliceToInterface(strings.Split(mails, ";")),
+			"emails", core.SliceToInterfaceSlice(strings.Split(mails, ";")),
 			"notificationsByRole", notificationsByRole,
 			"alertNotifications", alertNotifications,
 		)

resources/packs/azure/azure_rm_sql.go

@@ -260,7 +260,7 @@ func (a *mqlAzureSubscriptionSqlServiceServer) GetVulnerabilityAssessmentSetting
 		"storageAccountAccessKey", core.ToString(vaSettings.Properties.StorageAccountAccessKey),
 		"storageContainerSasKey", core.ToString(vaSettings.Properties.StorageContainerSasKey),
 		"recurringScanEnabled", core.ToBool(vaSettings.Properties.RecurringScans.IsEnabled),
-		"recurringScanEmails", core.PtrStrSliceToInterface(vaSettings.Properties.RecurringScans.Emails),
+		"recurringScanEmails", core.SliceToInterfaceSlice(vaSettings.Properties.RecurringScans.Emails),
 		"mailSubscriptionAdmins", core.ToBool(vaSettings.Properties.RecurringScans.EmailSubscriptionAdmins),
 	)
 }

resources/packs/core/asset.go

@@ -117,5 +117,5 @@ func (a *mqlAsset) GetIds() ([]interface{}, error) {
 	if asset == nil {
 		return nil, errors.New("unimplemented")
 	}
-	return StrSliceToInterface(asset.PlatformIds), nil
+	return SliceToInterfaceSlice(asset.PlatformIds), nil
 }

resources/packs/core/certificates.go

@@ -104,13 +104,13 @@ func pkixnameToMql(runtime *resources.Runtime, name pkix.Name, id string) (PkixN
 		"dn", name.String(),
 		"serialNumber", name.SerialNumber,
 		"commonName", name.CommonName,
-		"country", StrSliceToInterface(name.Country),
-		"organization", StrSliceToInterface(name.Organization),
-		"organizationalUnit", StrSliceToInterface(name.OrganizationalUnit),
-		"locality", StrSliceToInterface(name.Locality),
-		"province", StrSliceToInterface(name.Province),
-		"streetAddress", StrSliceToInterface(name.StreetAddress),
-		"postalCode", StrSliceToInterface(name.PostalCode),
+		"country", SliceToInterfaceSlice(name.Country),
+		"organization", SliceToInterfaceSlice(name.Organization),
+		"organizationalUnit", SliceToInterfaceSlice(name.OrganizationalUnit),
+		"locality", SliceToInterfaceSlice(name.Locality),
+		"province", SliceToInterfaceSlice(name.Province),
+		"streetAddress", SliceToInterfaceSlice(name.StreetAddress),
+		"postalCode", SliceToInterfaceSlice(name.PostalCode),
 		"names", names,
 		"extraNames", extraNames,
 	)
@@ -383,17 +383,17 @@ func (s *mqlCertificate) GetSignature() (string, error) {
 
 func (s *mqlCertificate) GetCrlDistributionPoints() ([]interface{}, error) {
 	cert := s.getGoCert()
-	return StrSliceToInterface(cert.CRLDistributionPoints), nil
+	return SliceToInterfaceSlice(cert.CRLDistributionPoints), nil
 }
 
 func (s *mqlCertificate) GetOcspServer() ([]interface{}, error) {
 	cert := s.getGoCert()
-	return StrSliceToInterface(cert.OCSPServer), nil
+	return SliceToInterfaceSlice(cert.OCSPServer), nil
 }
 
 func (s *mqlCertificate) GetIssuingCertificateUrl() ([]interface{}, error) {
 	cert := s.getGoCert()
-	return StrSliceToInterface(cert.IssuingCertificateURL), nil
+	return SliceToInterfaceSlice(cert.IssuingCertificateURL), nil
 }
 
 func (s *mqlCertificate) GetIsRevoked() (bool, error) {

resources/packs/core/core.utils.go

@@ -35,22 +35,12 @@ func ToBool(b *bool) bool {
 	return *b
 }
 
-func StrSliceToInterface(value []string) []interface{} {
-	res := make([]interface{}, len(value))
-	for i := range value {
-		res[i] = value[i]
+func SliceToInterfaceSlice[T any](ss []T) []interface{} {
+	ssI := make([]interface{}, 0, len(ss))
+	for _, s := range ss {
+		ssI = append(ssI, s)
 	}
-	return res
-}
-
-func PtrStrSliceToInterface(value []*string) []interface{} {
-	res := make([]interface{}, len(value))
-	for i := range value {
-		if value[i] != nil {
-			res[i] = value[i]
-		}
-	}
-	return res
+	return ssI
 }
 
 func PtrStrSliceToStr(value []*string) []string {

resources/packs/core/dns.go

@@ -37,7 +37,7 @@ func (d *mqlDomainName) init(args *resources.Args) (*resources.Args, DomainName,
 	(*args)["effectiveTLDPlusOne"] = dn.EffectiveTLDPlusOne
 	(*args)["tld"] = dn.TLD
 	(*args)["tldIcannManaged"] = dn.IcannManagedTLD
-	(*args)["labels"] = StrSliceToInterface(dn.Labels)
+	(*args)["labels"] = SliceToInterfaceSlice(dn.Labels)
 
 	return args, nil, nil
 }
@@ -236,12 +236,12 @@ func (d *mqlDns) GetDkim(params interface{}) ([]interface{}, error) {
 			"domain", name,
 			"dnsTxt", entry,
 			"version", dkimRepr.Version,
-			"hashAlgorithms", StrSliceToInterface(dkimRepr.HashAlgorithms),
+			"hashAlgorithms", SliceToInterfaceSlice(dkimRepr.HashAlgorithms),
 			"keyType", dkimRepr.KeyType,
 			"notes", dkimRepr.Notes,
 			"publicKeyData", dkimRepr.PublicKeyData,
-			"serviceTypes", StrSliceToInterface(dkimRepr.ServiceType),
-			"flags", StrSliceToInterface(dkimRepr.Flags),
+			"serviceTypes", SliceToInterfaceSlice(dkimRepr.ServiceType),
+			"flags", SliceToInterfaceSlice(dkimRepr.Flags),
 		)
 		if err != nil {
 			return nil, err

resources/packs/core/mondoo.go

@@ -69,5 +69,5 @@ func (m *mqlMondooAsset) GetPlatformIDs() ([]interface{}, error) {
 	if asset == nil {
 		return nil, errors.New("unimplemented")
 	}
-	return StrSliceToInterface(asset.PlatformIds), nil
+	return SliceToInterfaceSlice(asset.PlatformIds), nil
 }

resources/packs/gcp/access_approval.go

@@ -71,7 +71,7 @@ func accessApprovalSettings(motorProvider providers.Instance, runtime *resources
 
 	return runtime.CreateResource("gcp.accessApprovalSettings",
 		"resourcePath", settings.Name,
-		"notificationEmails", core.StrSliceToInterface(settings.NotificationEmails),
+		"notificationEmails", core.SliceToInterfaceSlice(settings.NotificationEmails),
 		"enrolledServices", mqlEnrolledServices,
 		"enrolledAncestor", settings.EnrolledAncestor,
 		"activeKeyVersion", settings.ActiveKeyVersion,

resources/packs/gcp/bigquery.go

@@ -275,7 +275,7 @@ func (g *mqlGcpProjectBigqueryServiceDataset) GetTables() ([]interface{}, error)
 
 		var clusteringFields []interface{}
 		if metadata.Clustering != nil {
-			clusteringFields = core.StrSliceToInterface(metadata.Clustering.Fields)
+			clusteringFields = core.SliceToInterfaceSlice(metadata.Clustering.Fields)
 		}
 
 		externalDataConfig, err := core.JsonToDict(metadata.ExternalDataConfig)

resources/packs/gcp/cloudrun.go

@@ -646,8 +646,8 @@ func mqlContainers(runtime *resources.Runtime, containers []*runpb.Container, te
 			"id", containerId,
 			"name", c.Name,
 			"image", c.Image,
-			"command", core.StrSliceToInterface(c.Command),
-			"args", core.StrSliceToInterface(c.Args),
+			"command", core.SliceToInterfaceSlice(c.Command),
+			"args", core.SliceToInterfaceSlice(c.Args),
 			"env", mqlEnvs,
 			"resources", mqlResources,
 			"ports", mqlPorts,

resources/packs/gcp/compute.go

@@ -346,7 +346,7 @@ func (g *mqlGcpProjectComputeServiceInstance) GetMachineType() (interface{}, err
 func newMqlServiceAccount(runtime *resources.Runtime, sa *compute.ServiceAccount) (interface{}, error) {
 	return runtime.CreateResource("gcp.project.computeService.serviceaccount",
 		"email", sa.Email,
-		"scopes", core.StrSliceToInterface(sa.Scopes),
+		"scopes", core.SliceToInterfaceSlice(sa.Scopes),
 	)
 }
 
@@ -366,10 +366,10 @@ func newMqlAttachedDisk(id string, projectId string, runtime *resources.Runtime,
 		"deviceName", attachedDisk.DeviceName,
 		"diskSizeGb", attachedDisk.DiskSizeGb,
 		"forceAttach", attachedDisk.ForceAttach,
-		"guestOsFeatures", core.StrSliceToInterface(guestOsFeatures),
+		"guestOsFeatures", core.SliceToInterfaceSlice(guestOsFeatures),
 		"index", attachedDisk.Index,
 		"interface", attachedDisk.Interface,
-		"licenses", core.StrSliceToInterface(attachedDisk.Licenses),
+		"licenses", core.SliceToInterfaceSlice(attachedDisk.Licenses),
 		"mode", attachedDisk.Mode,
 		"type", attachedDisk.Type,
 	)
@@ -519,7 +519,7 @@ func newMqlInstance(projectId string, zone GcpProjectComputeServiceZone, runtime
 		"networkInterfaces", networkInterfaces,
 		"privateIpv6GoogleAccess", instance.PrivateIpv6GoogleAccess,
 		"reservationAffinity", reservationAffinity,
-		"resourcePolicies", core.StrSliceToInterface(instance.ResourcePolicies),
+		"resourcePolicies", core.SliceToInterfaceSlice(instance.ResourcePolicies),
 		"physicalHostResourceStatus", physicalHost,
 		"scheduling", scheduling,
 		"enableIntegrityMonitoring", enableIntegrityMonitoring,
@@ -529,7 +529,7 @@ func newMqlInstance(projectId string, zone GcpProjectComputeServiceZone, runtime
 		"status", instance.Status,
 		"statusMessage", instance.StatusMessage,
 		"sourceMachineImage", instance.SourceMachineImage,
-		"tags", core.StrSliceToInterface(instance.Tags.Items),
+		"tags", core.SliceToInterfaceSlice(instance.Tags.Items),
 		"totalEgressBandwidthTier", totalEgressBandwidthTier,
 		"serviceAccounts", mqlServiceAccounts,
 		"disks", attachedDisks,
@@ -697,18 +697,18 @@ func (g *mqlGcpProjectComputeService) GetDisks() ([]interface{}, error) {
 						"name", disk.Name,
 						"architecture", disk.Architecture,
 						"description", disk.Description,
-						"guestOsFeatures", core.StrSliceToInterface(guestOsFeatures),
+						"guestOsFeatures", core.SliceToInterfaceSlice(guestOsFeatures),
 						"labels", core.StrMapToInterface(disk.Labels),
 						"lastAttachTimestamp", parseTime(disk.LastAttachTimestamp),
 						"lastDetachTimestamp", parseTime(disk.LastDetachTimestamp),
 						"locationHint", disk.LocationHint,
-						"licenses", core.StrSliceToInterface(disk.Licenses),
+						"licenses", core.SliceToInterfaceSlice(disk.Licenses),
 						"physicalBlockSizeBytes", disk.PhysicalBlockSizeBytes,
 						"provisionedIops", disk.ProvisionedIops,
 						// TODO: link to resources
 						//"region", disk.Region,
-						//"replicaZones", core.StrSliceToInterface(disk.ReplicaZones),
-						//"resourcePolicies", core.StrSliceToInterface(disk.ResourcePolicies),
+						//"replicaZones", core.SliceToInterfaceSlice(disk.ReplicaZones),
+						//"resourcePolicies", core.SliceToInterfaceSlice(disk.ResourcePolicies),
 						"sizeGb", disk.SizeGb,
 						// TODO: link to resources
 						//"sourceDiskId", disk.SourceDiskId,
@@ -852,11 +852,11 @@ func (g *mqlGcpProjectComputeService) GetFirewalls() ([]interface{}, error) {
 				"priority", firewall.Priority,
 				"disabled", firewall.Disabled,
 				"direction", firewall.Direction,
-				"sourceRanges", core.StrSliceToInterface(firewall.SourceRanges),
-				"sourceServiceAccounts", core.StrSliceToInterface(firewall.SourceServiceAccounts),
-				"sourceTags", core.StrSliceToInterface(firewall.SourceTags),
-				"destinationRanges", core.StrSliceToInterface(firewall.DestinationRanges),
-				"targetServiceAccounts", core.StrSliceToInterface(firewall.TargetServiceAccounts),
+				"sourceRanges", core.SliceToInterfaceSlice(firewall.SourceRanges),
+				"sourceServiceAccounts", core.SliceToInterfaceSlice(firewall.SourceServiceAccounts),
+				"sourceTags", core.SliceToInterfaceSlice(firewall.SourceTags),
+				"destinationRanges", core.SliceToInterfaceSlice(firewall.DestinationRanges),
+				"targetServiceAccounts", core.SliceToInterfaceSlice(firewall.TargetServiceAccounts),
 				"created", parseTime(firewall.CreationTimestamp),
 				"allowed", allowedDict,
 				"denied", deniedDict,
@@ -929,7 +929,7 @@ func (g *mqlGcpProjectComputeService) GetSnapshots() ([]interface{}, error) {
 				"storageBytes", snapshot.StorageBytes,
 				"storageBytesStatus", snapshot.StorageBytesStatus,
 				"snapshotType", snapshot.SnapshotType,
-				"licenses", core.StrSliceToInterface(snapshot.Licenses),
+				"licenses", core.SliceToInterfaceSlice(snapshot.Licenses),
 				"labels", core.StrMapToInterface(snapshot.Labels),
 				"status", snapshot.Status,
 				"created", parseTime(snapshot.CreationTimestamp),
@@ -1039,7 +1039,7 @@ func (g *mqlGcpProjectComputeService) GetImages() ([]interface{}, error) {
 				"archiveSizeBytes", image.ArchiveSizeBytes,
 				"diskSizeGb", image.DiskSizeGb,
 				"family", image.Family,
-				"licenses", core.StrSliceToInterface(image.Licenses),
+				"licenses", core.SliceToInterfaceSlice(image.Licenses),
 				"labels", core.StrMapToInterface(image.Labels),
 				"status", image.Status,
 				"created", parseTime(image.CreationTimestamp),
@@ -1189,7 +1189,7 @@ func (g *mqlGcpProjectComputeService) GetNetworks() ([]interface{}, error) {
 				"peerings", peerings,
 				"routingMode", routingMode,
 				"mode", networkMode(network),
-				"subnetworkUrls", core.StrSliceToInterface(network.Subnetworks),
+				"subnetworkUrls", core.SliceToInterfaceSlice(network.Subnetworks),
 			)
 			if err != nil {
 				return err
@@ -1346,7 +1346,7 @@ func newMqlSubnetwork(projectId string, runtime *resources.Runtime, subnetwork *
 			"filterExpression", subnetwork.LogConfig.GetFilterExpr(),
 			"flowSampling", float64(subnetwork.LogConfig.GetFlowSampling()),
 			"metadata", subnetwork.LogConfig.GetMetadata(),
-			"metadataFields", core.StrSliceToInterface(subnetwork.LogConfig.MetadataFields),
+			"metadataFields", core.SliceToInterfaceSlice(subnetwork.LogConfig.MetadataFields),
 		)
 		if err != nil {
 			return nil, err
@@ -1605,12 +1605,12 @@ func (g *mqlGcpProjectComputeService) GetBackendServices() ([]interface{}, error
 				if b.CdnPolicy.CacheKeyPolicy != nil {
 					mqlCacheKeyPolicy = map[string]interface{}{
 						"includeHost":          b.CdnPolicy.CacheKeyPolicy.IncludeHost,
-						"includeHttpHeaders":   core.StrSliceToInterface(b.CdnPolicy.CacheKeyPolicy.IncludeHttpHeaders),
-						"includeNamedCookies":  core.StrSliceToInterface(b.CdnPolicy.CacheKeyPolicy.IncludeNamedCookies),
+						"includeHttpHeaders":   core.SliceToInterfaceSlice(b.CdnPolicy.CacheKeyPolicy.IncludeHttpHeaders),
+						"includeNamedCookies":  core.SliceToInterfaceSlice(b.CdnPolicy.CacheKeyPolicy.IncludeNamedCookies),
 						"includeProtocol":      b.CdnPolicy.CacheKeyPolicy.IncludeProtocol,
 						"includeQueryString":   b.CdnPolicy.CacheKeyPolicy.IncludeQueryString,
-						"queryStringBlacklist": core.StrSliceToInterface(b.CdnPolicy.CacheKeyPolicy.QueryStringBlacklist),
-						"queryStringWhitelist": core.StrSliceToInterface(b.CdnPolicy.CacheKeyPolicy.QueryStringWhitelist),
+						"queryStringBlacklist": core.SliceToInterfaceSlice(b.CdnPolicy.CacheKeyPolicy.QueryStringBlacklist),
+						"queryStringWhitelist": core.SliceToInterfaceSlice(b.CdnPolicy.CacheKeyPolicy.QueryStringWhitelist),
 					}
 				}
 
@@ -1636,7 +1636,7 @@ func (g *mqlGcpProjectComputeService) GetBackendServices() ([]interface{}, error
 					"requestCoalescing", b.CdnPolicy.RequestCoalescing,
 					"serveWhileStale", b.CdnPolicy.ServeWhileStale,
 					"signedUrlCacheMaxAgeSec", b.CdnPolicy.SignedUrlCacheMaxAgeSec,
-					"signedUrlKeyNames", core.StrSliceToInterface(b.CdnPolicy.SignedUrlKeyNames),
+					"signedUrlKeyNames", core.SliceToInterfaceSlice(b.CdnPolicy.SignedUrlKeyNames),
 				)
 				if err != nil {
 					return nil, err
@@ -1737,7 +1737,7 @@ func (g *mqlGcpProjectComputeService) GetBackendServices() ([]interface{}, error
 			if b.SecuritySettings != nil {
 				mqlSecuritySettings = map[string]interface{}{
 					"clientTlsPolicy": b.SecuritySettings.ClientTlsPolicy,
-					"subjectAltNames": core.StrSliceToInterface(b.SecuritySettings.SubjectAltNames),
+					"subjectAltNames": core.SliceToInterfaceSlice(b.SecuritySettings.SubjectAltNames),
 				}
 			}
 
@@ -1757,13 +1757,13 @@ func (g *mqlGcpProjectComputeService) GetBackendServices() ([]interface{}, error
 				"connectionTrackingPolicy", mqlConnectionTrackingPolicy,
 				"consistentHash", mqlConsistentHash,
 				"created", parseTime(b.CreationTimestamp),
-				"customRequestHeaders", core.StrSliceToInterface(b.CustomRequestHeaders),
-				"customResponseHeaders", core.StrSliceToInterface(b.CustomResponseHeaders),
+				"customRequestHeaders", core.SliceToInterfaceSlice(b.CustomRequestHeaders),
+				"customResponseHeaders", core.SliceToInterfaceSlice(b.CustomResponseHeaders),
 				"description", b.Description,
 				"edgeSecurityPolicy", b.EdgeSecurityPolicy,
 				"enableCDN", b.EnableCDN,
 				"failoverPolicy", mqlFailoverPolicy,
-				"healthChecks", core.StrSliceToInterface(b.HealthChecks),
+				"healthChecks", core.SliceToInterfaceSlice(b.HealthChecks),
 				"iap", mqlIap,
 				"loadBalancingScheme", b.LoadBalancingScheme,
 				"localityLbPolicies", mqlLocalityLbPolicy,
@@ -1777,7 +1777,7 @@ func (g *mqlGcpProjectComputeService) GetBackendServices() ([]interface{}, error
 				"regionUrl", b.Region,
 				"securityPolicyUrl", b.SecurityPolicy,
 				"securitySettings", mqlSecuritySettings,
-				"serviceBindingUrls", core.StrSliceToInterface(b.ServiceBindings),
+				"serviceBindingUrls", core.SliceToInterfaceSlice(b.ServiceBindings),
 				"sessionAffinity", b.SessionAffinity,
 				"timeoutSec", b.TimeoutSec,
 			)
@@ -1861,7 +1861,7 @@ func (g *mqlGcpProjectComputeService) GetAddresses() ([]interface{}, error) {
 				"regionUrl", a.Region,
 				"status", a.Status,
 				"subnetworkUrl", a.Subnetwork,
-				"resourceUrls", core.StrSliceToInterface(a.Users),
+				"resourceUrls", core.SliceToInterfaceSlice(a.Users),
 			)
 			if err != nil {
 				return nil, err
@@ -1967,7 +1967,7 @@ func (g *mqlGcpProjectComputeService) GetForwardingRules() ([]interface{}, error
 				"networkTier", fwr.GetNetworkTier(),
 				"noAutomateDnsZone", fwr.GetNoAutomateDnsZone(),
 				"portRange", fwr.GetPortRange(),
-				"ports", core.StrSliceToInterface(fwr.GetPorts()),
+				"ports", core.SliceToInterfaceSlice(fwr.GetPorts()),
 				"regionUrl", fwr.GetRegion(),
 				"serviceDirectoryRegistrations", serviceDirRegs,
 				"serviceLabel", fwr.GetServiceLabel(),

resources/packs/gcp/dataproc.go

@@ -264,7 +264,7 @@ func (g *mqlGcpProjectDataprocService) GetClusters() ([]interface{}, error) {
 									"id", fmt.Sprintf("%s/dataproc/%s/config/gceCluster/reservationAffinity", projectId, c.ClusterName),
 									"consumeReservationType", c.Config.GceClusterConfig.ReservationAffinity.ConsumeReservationType,
 									"key", c.Config.GceClusterConfig.ReservationAffinity.Key,
-									"values", core.StrSliceToInterface(c.Config.GceClusterConfig.ReservationAffinity.Values),
+									"values", core.SliceToInterfaceSlice(c.Config.GceClusterConfig.ReservationAffinity.Values),
 								)
 								if err != nil {
 									log.Error().Err(err).Send()
@@ -294,10 +294,10 @@ func (g *mqlGcpProjectDataprocService) GetClusters() ([]interface{}, error) {
 								"privateIpv6GoogleAccess", c.Config.GceClusterConfig.PrivateIpv6GoogleAccess,
 								"reservationAffinity", mqlReservationAffinity,
 								"serviceAccount", c.Config.GceClusterConfig.ServiceAccount,
-								"serviceAccountScopes", core.StrSliceToInterface(c.Config.GceClusterConfig.ServiceAccountScopes),
+								"serviceAccountScopes", core.SliceToInterfaceSlice(c.Config.GceClusterConfig.ServiceAccountScopes),
 								"shieldedInstanceConfig", mqlShieldedCfg,
 								"subnetworkUri", c.Config.GceClusterConfig.SubnetworkUri,
-								"tags", core.StrSliceToInterface(c.Config.GceClusterConfig.Tags),
+								"tags", core.SliceToInterfaceSlice(c.Config.GceClusterConfig.Tags),
 								"zoneUri", c.Config.GceClusterConfig.ZoneUri,
 							)
 							if err != nil {
@@ -785,7 +785,7 @@ func instaceGroupConfigToMql(runtime *resources.Runtime, igc *dataproc.InstanceG
 		"accelerators", mqlAccs,
 		"diskConfig", mqlDiskCfg,
 		"imageUri", igc.ImageUri,
-		"instanceNames", core.StrSliceToInterface(igc.InstanceNames),
+		"instanceNames", core.SliceToInterfaceSlice(igc.InstanceNames),
 		"instanceReferences", mqlInstanceRefs,
 		"isPreemptible", igc.IsPreemptible,
 		"machineTypeUri", igc.MachineTypeUri,