diff --git a/.github/actions/spelling/expect.txt b/.github/actions/spelling/expect.txt index 60d56422c1..f73659d56e 100644 --- a/.github/actions/spelling/expect.txt +++ b/.github/actions/spelling/expect.txt @@ -43,6 +43,7 @@ cmdline cmnd cname compressratio +computeagent cooldown copywrite cpe @@ -76,6 +77,8 @@ ekm ekus elbv endpointslice +EPP +ERPCLOUD exo failback fargate @@ -99,6 +102,7 @@ gpu groupname gvnic HADOOP +HCMCLOUD headerorder hec Hns @@ -169,6 +173,7 @@ nodepool nokeys notebookinstancedetails nproc +nsg nsrecord nullgroup nullstring @@ -270,7 +275,9 @@ vdev VGeneration virtualmachine vlans +Vnic vnet +vpus vrf vtpm vulnerabilityassessmentsettings diff --git a/providers/oci/connection/clients.go b/providers/oci/connection/clients.go index f6a34f6187..0926130921 100644 --- a/providers/oci/connection/clients.go +++ b/providers/oci/connection/clients.go @@ -8,10 +8,22 @@ import ( "errors" "github.com/oracle/oci-go-sdk/v65/audit" + "github.com/oracle/oci-go-sdk/v65/bastion" + "github.com/oracle/oci-go-sdk/v65/cloudguard" "github.com/oracle/oci-go-sdk/v65/common" + "github.com/oracle/oci-go-sdk/v65/containerengine" "github.com/oracle/oci-go-sdk/v65/core" + "github.com/oracle/oci-go-sdk/v65/events" + "github.com/oracle/oci-go-sdk/v65/filestorage" "github.com/oracle/oci-go-sdk/v65/identity" + "github.com/oracle/oci-go-sdk/v65/keymanagement" + "github.com/oracle/oci-go-sdk/v65/loadbalancer" + "github.com/oracle/oci-go-sdk/v65/logging" + "github.com/oracle/oci-go-sdk/v65/monitoring" + "github.com/oracle/oci-go-sdk/v65/networkfirewall" "github.com/oracle/oci-go-sdk/v65/objectstorage" + "github.com/oracle/oci-go-sdk/v65/ons" + "github.com/oracle/oci-go-sdk/v65/vault" ) func (c *OciConnection) IdentityClient() (identity.IdentityClient, error) { @@ -152,3 +164,137 @@ func (c *OciConnection) ObjectStorageClient(region string) (*objectstorage.Objec client.SetRegion(region) return &client, nil } + +func (c *OciConnection) BlockstorageClient(region string) (*core.BlockstorageClient, error) { + client, err := core.NewBlockstorageClientWithConfigurationProvider(c.config) + if err != nil { + return nil, err + } + client.SetRegion(region) + return &client, nil +} + +func (c *OciConnection) FileStorageClient(region string) (*filestorage.FileStorageClient, error) { + client, err := filestorage.NewFileStorageClientWithConfigurationProvider(c.config) + if err != nil { + return nil, err + } + client.SetRegion(region) + return &client, nil +} + +func (c *OciConnection) LoggingClient(region string) (*logging.LoggingManagementClient, error) { + client, err := logging.NewLoggingManagementClientWithConfigurationProvider(c.config) + if err != nil { + return nil, err + } + client.SetRegion(region) + return &client, nil +} + +func (c *OciConnection) KmsVaultClient(region string) (*keymanagement.KmsVaultClient, error) { + client, err := keymanagement.NewKmsVaultClientWithConfigurationProvider(c.config) + if err != nil { + return nil, err + } + client.SetRegion(region) + return &client, nil +} + +func (c *OciConnection) KmsManagementClient(endpoint string) (*keymanagement.KmsManagementClient, error) { + client, err := keymanagement.NewKmsManagementClientWithConfigurationProvider(c.config, endpoint) + if err != nil { + return nil, err + } + return &client, nil +} + +func (c *OciConnection) EventsClient(region string) (*events.EventsClient, error) { + client, err := events.NewEventsClientWithConfigurationProvider(c.config) + if err != nil { + return nil, err + } + client.SetRegion(region) + return &client, nil +} + +func (c *OciConnection) NotificationControlPlaneClient(region string) (*ons.NotificationControlPlaneClient, error) { + client, err := ons.NewNotificationControlPlaneClientWithConfigurationProvider(c.config) + if err != nil { + return nil, err + } + client.SetRegion(region) + return &client, nil +} + +func (c *OciConnection) CloudGuardClient(region string) (*cloudguard.CloudGuardClient, error) { + client, err := cloudguard.NewCloudGuardClientWithConfigurationProvider(c.config) + if err != nil { + return nil, err + } + client.SetRegion(region) + return &client, nil +} + +func (c *OciConnection) NotificationDataPlaneClient(region string) (*ons.NotificationDataPlaneClient, error) { + client, err := ons.NewNotificationDataPlaneClientWithConfigurationProvider(c.config) + if err != nil { + return nil, err + } + client.SetRegion(region) + return &client, nil +} + +func (c *OciConnection) BastionClient(region string) (*bastion.BastionClient, error) { + client, err := bastion.NewBastionClientWithConfigurationProvider(c.config) + if err != nil { + return nil, err + } + client.SetRegion(region) + return &client, nil +} + +func (c *OciConnection) MonitoringClient(region string) (*monitoring.MonitoringClient, error) { + client, err := monitoring.NewMonitoringClientWithConfigurationProvider(c.config) + if err != nil { + return nil, err + } + client.SetRegion(region) + return &client, nil +} + +func (c *OciConnection) VaultsClient(region string) (*vault.VaultsClient, error) { + client, err := vault.NewVaultsClientWithConfigurationProvider(c.config) + if err != nil { + return nil, err + } + client.SetRegion(region) + return &client, nil +} + +func (c *OciConnection) LoadBalancerClient(region string) (*loadbalancer.LoadBalancerClient, error) { + client, err := loadbalancer.NewLoadBalancerClientWithConfigurationProvider(c.config) + if err != nil { + return nil, err + } + client.SetRegion(region) + return &client, nil +} + +func (c *OciConnection) NetworkFirewallClient(region string) (*networkfirewall.NetworkFirewallClient, error) { + client, err := networkfirewall.NewNetworkFirewallClientWithConfigurationProvider(c.config) + if err != nil { + return nil, err + } + client.SetRegion(region) + return &client, nil +} + +func (c *OciConnection) ContainerEngineClient(region string) (*containerengine.ContainerEngineClient, error) { + client, err := containerengine.NewContainerEngineClientWithConfigurationProvider(c.config) + if err != nil { + return nil, err + } + client.SetRegion(region) + return &client, nil +} diff --git a/providers/oci/go.mod b/providers/oci/go.mod index fbca1da36e..ea4bbe1de7 100644 --- a/providers/oci/go.mod +++ b/providers/oci/go.mod @@ -7,6 +7,7 @@ replace go.mondoo.com/mql/v13 => ../.. require ( github.com/oracle/oci-go-sdk/v65 v65.109.3 github.com/rs/zerolog v1.34.0 + github.com/stretchr/testify v1.11.1 go.mondoo.com/mql/v13 v13.2.0 ) @@ -58,6 +59,7 @@ require ( github.com/cockroachdb/redact v1.1.8 // indirect github.com/cyphar/filepath-securejoin v0.6.1 // indirect github.com/danieljoos/wincred v1.2.3 // indirect + github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc // indirect github.com/dvsekhvalnov/jose2go v1.8.0 // indirect github.com/emirpasic/gods v1.18.1 // indirect github.com/envoyproxy/go-control-plane/envoy v1.36.0 // indirect @@ -116,6 +118,7 @@ require ( github.com/pjbgf/sha1cd v0.5.0 // indirect github.com/pkg/errors v0.9.1 // indirect github.com/planetscale/vtprotobuf v0.6.1-0.20240319094008-0393e58bdf10 // indirect + github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 // indirect github.com/rivo/uniseg v0.4.7 // indirect github.com/rogpeppe/go-internal v1.14.1 // indirect github.com/ryanuber/go-glob v1.0.0 // indirect @@ -159,6 +162,7 @@ require ( google.golang.org/grpc v1.79.3 // indirect google.golang.org/protobuf v1.36.11 // indirect gopkg.in/warnings.v0 v0.1.2 // indirect + gopkg.in/yaml.v3 v3.0.1 // indirect moul.io/http2curl v1.0.0 // indirect sigs.k8s.io/yaml v1.6.0 // indirect ) diff --git a/providers/oci/resources/audit.go b/providers/oci/resources/audit.go new file mode 100644 index 0000000000..3eeb3d1801 --- /dev/null +++ b/providers/oci/resources/audit.go @@ -0,0 +1,48 @@ +// Copyright (c) Mondoo, Inc. +// SPDX-License-Identifier: BUSL-1.1 + +package resources + +import ( + "context" + + "github.com/oracle/oci-go-sdk/v65/audit" + "github.com/oracle/oci-go-sdk/v65/common" + "go.mondoo.com/mql/v13/providers/oci/connection" +) + +func (o *mqlOciAudit) id() (string, error) { + return "oci.audit", nil +} + +func (o *mqlOciAudit) retentionPeriodDays() (int64, error) { + conn := o.MqlRuntime.Connection.(*connection.OciConnection) + + // Audit configuration is tenancy-level; use home region + tenancy, err := conn.Tenant(context.Background()) + if err != nil { + return 0, err + } + + region := "" + if tenancy.HomeRegionKey != nil { + region = *tenancy.HomeRegionKey + } + + client, err := conn.AuditClient(region) + if err != nil { + return 0, err + } + + resp, err := client.GetConfiguration(context.Background(), audit.GetConfigurationRequest{ + CompartmentId: common.String(conn.TenantID()), + }) + if err != nil { + return 0, err + } + + if resp.RetentionPeriodDays == nil { + return 0, nil + } + return int64(*resp.RetentionPeriodDays), nil +} diff --git a/providers/oci/resources/bastion.go b/providers/oci/resources/bastion.go new file mode 100644 index 0000000000..6975bed1b0 --- /dev/null +++ b/providers/oci/resources/bastion.go @@ -0,0 +1,160 @@ +// Copyright (c) Mondoo, Inc. +// SPDX-License-Identifier: BUSL-1.1 + +package resources + +import ( + "context" + "errors" + "time" + + "github.com/oracle/oci-go-sdk/v65/bastion" + "github.com/oracle/oci-go-sdk/v65/common" + "github.com/rs/zerolog/log" + "go.mondoo.com/mql/v13/llx" + "go.mondoo.com/mql/v13/providers-sdk/v1/plugin" + "go.mondoo.com/mql/v13/providers-sdk/v1/util/jobpool" + "go.mondoo.com/mql/v13/providers/oci/connection" +) + +func (o *mqlOciBastion) id() (string, error) { + return "oci.bastion", nil +} + +func (o *mqlOciBastion) bastions() ([]any, error) { + conn := o.MqlRuntime.Connection.(*connection.OciConnection) + + ociResource, err := CreateResource(o.MqlRuntime, "oci", nil) + if err != nil { + return nil, err + } + oci := ociResource.(*mqlOci) + list := oci.GetRegions() + if list.Error != nil { + return nil, list.Error + } + + res := []any{} + poolOfJobs := jobpool.CreatePool(o.getBastions(conn, list.Data), 5) + poolOfJobs.Run() + + if poolOfJobs.HasErrors() { + return nil, poolOfJobs.GetErrors() + } + for i := range poolOfJobs.Jobs { + res = append(res, poolOfJobs.Jobs[i].Result.([]any)...) + } + + return res, nil +} + +func (o *mqlOciBastion) getBastions(conn *connection.OciConnection, regions []any) []*jobpool.Job { + ctx := context.Background() + tasks := make([]*jobpool.Job, 0) + for _, region := range regions { + regionResource, ok := region.(*mqlOciRegion) + if !ok { + return jobErr(errors.New("invalid region type")) + } + f := func() (jobpool.JobResult, error) { + log.Debug().Msgf("calling oci bastion with region %s", regionResource.Id.Data) + + svc, err := conn.BastionClient(regionResource.Id.Data) + if err != nil { + return nil, err + } + + bastions := []bastion.BastionSummary{} + var page *string + for { + response, err := svc.ListBastions(ctx, bastion.ListBastionsRequest{ + CompartmentId: common.String(conn.TenantID()), + Page: page, + }) + if err != nil { + return nil, err + } + + bastions = append(bastions, response.Items...) + + if response.OpcNextPage == nil { + break + } + page = response.OpcNextPage + } + + var res []any + for i := range bastions { + b := bastions[i] + + var created *time.Time + if b.TimeCreated != nil { + created = &b.TimeCreated.Time + } + var timeUpdated *time.Time + if b.TimeUpdated != nil { + timeUpdated = &b.TimeUpdated.Time + } + + mqlInstance, err := CreateResource(o.MqlRuntime, "oci.bastion.instance", map[string]*llx.RawData{ + "id": llx.StringDataPtr(b.Id), + "name": llx.StringDataPtr(b.Name), + "compartmentID": llx.StringDataPtr(b.CompartmentId), + "bastionType": llx.StringDataPtr(b.BastionType), + "state": llx.StringData(string(b.LifecycleState)), + "dnsProxyStatus": llx.StringData(string(b.DnsProxyStatus)), + "created": llx.TimeDataPtr(created), + "timeUpdated": llx.TimeDataPtr(timeUpdated), + }) + if err != nil { + return nil, err + } + mqlB := mqlInstance.(*mqlOciBastionInstance) + mqlB.cacheTargetVcnId = stringValue(b.TargetVcnId) + mqlB.cacheTargetSubnetId = stringValue(b.TargetSubnetId) + res = append(res, mqlB) + } + + return jobpool.JobResult(res), nil + } + tasks = append(tasks, jobpool.NewJob(f)) + } + return tasks +} + +type mqlOciBastionInstanceInternal struct { + cacheTargetVcnId string + cacheTargetSubnetId string +} + +func (o *mqlOciBastionInstance) id() (string, error) { + return "oci.bastion.instance/" + o.Id.Data, nil +} + +func (o *mqlOciBastionInstance) targetSubnet() (*mqlOciNetworkSubnet, error) { + if o.cacheTargetSubnetId == "" { + o.TargetSubnet.State = plugin.StateIsSet | plugin.StateIsNull + return nil, nil + } + mqlSubnet, err := NewResource(o.MqlRuntime, "oci.network.subnet", map[string]*llx.RawData{ + "id": llx.StringData(o.cacheTargetSubnetId), + }) + if err != nil { + return nil, err + } + return mqlSubnet.(*mqlOciNetworkSubnet), nil +} + +func (o *mqlOciBastionInstance) targetVcn() (*mqlOciNetworkVcn, error) { + if o.cacheTargetVcnId == "" { + o.TargetVcn.State = plugin.StateIsSet | plugin.StateIsNull + return nil, nil + } + mqlVcn, err := NewResource(o.MqlRuntime, "oci.network.vcn", map[string]*llx.RawData{ + "id": llx.StringData(o.cacheTargetVcnId), + }) + if err != nil { + return nil, err + } + return mqlVcn.(*mqlOciNetworkVcn), nil +} diff --git a/providers/oci/resources/buckets.go b/providers/oci/resources/buckets.go index 41f1812b2c..38139ea872 100644 --- a/providers/oci/resources/buckets.go +++ b/providers/oci/resources/buckets.go @@ -143,10 +143,11 @@ func (o *mqlOciObjectStorage) getBuckets(conn *connection.OciConnection, namespa } mqlInstance, err := CreateResource(o.MqlRuntime, "oci.objectStorage.bucket", map[string]*llx.RawData{ - "namespace": llx.StringDataPtr(bucket.Namespace), - "name": llx.StringDataPtr(bucket.Name), - "region": llx.ResourceData(regionResource, "oci.region"), - "created": llx.TimeDataPtr(created), + "namespace": llx.StringDataPtr(bucket.Namespace), + "name": llx.StringDataPtr(bucket.Name), + "compartmentID": llx.StringDataPtr(bucket.CompartmentId), + "region": llx.ResourceData(regionResource, "oci.region"), + "created": llx.TimeDataPtr(created), }) if err != nil { return nil, err @@ -227,6 +228,11 @@ func (o *mqlOciObjectStorageBucket) getBucketDetails() (*objectstorage.Bucket, e response, err := client.GetBucket(context.Background(), objectstorage.GetBucketRequest{ NamespaceName: common.String(namespace.Data), BucketName: common.String(name.Data), + Fields: []objectstorage.GetBucketFieldsEnum{ + objectstorage.GetBucketFieldsApproximatecount, + objectstorage.GetBucketFieldsApproximatesize, + objectstorage.GetBucketFieldsAutotiering, + }, }) if err != nil { return nil, err @@ -273,6 +279,9 @@ func (o *mqlOciObjectStorageBucket) objectEventsEnabled() (bool, error) { if err != nil { return false, err } + if bucketInfo.ObjectEventsEnabled == nil { + return false, nil + } return *bucketInfo.ObjectEventsEnabled, nil } @@ -281,6 +290,9 @@ func (o *mqlOciObjectStorageBucket) replicationEnabled() (bool, error) { if err != nil { return false, err } + if bucketInfo.ReplicationEnabled == nil { + return false, nil + } return *bucketInfo.ReplicationEnabled, nil } @@ -339,6 +351,17 @@ func (o *mqlOciObjectStorageBucket) approximateSize() (int64, error) { return *bucketInfo.ApproximateSize, nil } +func (o *mqlOciObjectStorageBucket) objectLifecyclePolicyEtag() (string, error) { + bucketInfo, err := o.getBucketDetails() + if err != nil { + return "", err + } + if bucketInfo.ObjectLifecyclePolicyEtag == nil { + return "", nil + } + return *bucketInfo.ObjectLifecyclePolicyEtag, nil +} + func (o *mqlOciObjectStorageBucket) freeformTags() (map[string]interface{}, error) { bucketInfo, err := o.getBucketDetails() if err != nil { diff --git a/providers/oci/resources/cloudguard.go b/providers/oci/resources/cloudguard.go new file mode 100644 index 0000000000..50bf204b8f --- /dev/null +++ b/providers/oci/resources/cloudguard.go @@ -0,0 +1,228 @@ +// Copyright (c) Mondoo, Inc. +// SPDX-License-Identifier: BUSL-1.1 + +package resources + +import ( + "context" + "errors" + "time" + + "github.com/oracle/oci-go-sdk/v65/cloudguard" + "github.com/oracle/oci-go-sdk/v65/common" + "go.mondoo.com/mql/v13/llx" + "go.mondoo.com/mql/v13/providers/oci/connection" +) + +// CloudGuard is a tenancy-level service that only operates in the home region, +// unlike other OCI services that require per-region iteration. +type mqlOciCloudGuardInternal struct { + config *cloudguard.Configuration + homeRegion string +} + +func (o *mqlOciCloudGuard) id() (string, error) { + return "oci.cloudGuard", nil +} + +func (o *mqlOciCloudGuard) getHomeRegion() (string, error) { + if o.homeRegion != "" { + return o.homeRegion, nil + } + + conn := o.MqlRuntime.Connection.(*connection.OciConnection) + tenancy, err := conn.Tenant(context.Background()) + if err != nil { + return "", err + } + + if tenancy.HomeRegionKey == nil { + return "", errors.New("no home region set") + } + + // HomeRegionKey returns the short region key (e.g., "IAD"), not the region name (e.g., "us-ashburn-1"). + // The OCI SDK's SetRegion() accepts both formats. + o.homeRegion = *tenancy.HomeRegionKey + return o.homeRegion, nil +} + +func (o *mqlOciCloudGuard) getConfig() (*cloudguard.Configuration, error) { + if o.config != nil { + return o.config, nil + } + + conn := o.MqlRuntime.Connection.(*connection.OciConnection) + + homeRegion, err := o.getHomeRegion() + if err != nil { + return nil, err + } + + client, err := conn.CloudGuardClient(homeRegion) + if err != nil { + return nil, err + } + + response, err := client.GetConfiguration(context.Background(), cloudguard.GetConfigurationRequest{ + CompartmentId: common.String(conn.TenantID()), + }) + if err != nil { + return nil, err + } + + o.config = &response.Configuration + return o.config, nil +} + +func (o *mqlOciCloudGuard) status() (bool, error) { + cfg, err := o.getConfig() + if err != nil { + return false, err + } + return cfg.Status == cloudguard.CloudGuardStatusEnabled, nil +} + +func (o *mqlOciCloudGuard) reportingRegion() (string, error) { + cfg, err := o.getConfig() + if err != nil { + return "", err + } + return stringValue(cfg.ReportingRegion), nil +} + +func (o *mqlOciCloudGuard) selfManageResources() (bool, error) { + cfg, err := o.getConfig() + if err != nil { + return false, err + } + return boolValue(cfg.SelfManageResources), nil +} + +func (o *mqlOciCloudGuard) targets() ([]any, error) { + conn := o.MqlRuntime.Connection.(*connection.OciConnection) + + homeRegion, err := o.getHomeRegion() + if err != nil { + return nil, err + } + + client, err := conn.CloudGuardClient(homeRegion) + if err != nil { + return nil, err + } + + ctx := context.Background() + targets := []cloudguard.TargetSummary{} + var page *string + for { + response, err := client.ListTargets(ctx, cloudguard.ListTargetsRequest{ + CompartmentId: common.String(conn.TenantID()), + Page: page, + }) + if err != nil { + return nil, err + } + + targets = append(targets, response.Items...) + + if response.OpcNextPage == nil { + break + } + page = response.OpcNextPage + } + + res := make([]any, 0, len(targets)) + for i := range targets { + target := targets[i] + + var created *time.Time + if target.TimeCreated != nil { + created = &target.TimeCreated.Time + } + + mqlInstance, err := CreateResource(o.MqlRuntime, "oci.cloudGuard.target", map[string]*llx.RawData{ + "id": llx.StringDataPtr(target.Id), + "name": llx.StringDataPtr(target.DisplayName), + "compartmentID": llx.StringDataPtr(target.CompartmentId), + "targetResourceId": llx.StringDataPtr(target.TargetResourceId), + "targetResourceType": llx.StringData(string(target.TargetResourceType)), + "state": llx.StringData(string(target.LifecycleState)), + "recipeCount": llx.IntDataPtr(target.RecipeCount), + "created": llx.TimeDataPtr(created), + }) + if err != nil { + return nil, err + } + res = append(res, mqlInstance) + } + + return res, nil +} + +func (o *mqlOciCloudGuard) detectorRecipes() ([]any, error) { + conn := o.MqlRuntime.Connection.(*connection.OciConnection) + + homeRegion, err := o.getHomeRegion() + if err != nil { + return nil, err + } + + client, err := conn.CloudGuardClient(homeRegion) + if err != nil { + return nil, err + } + + ctx := context.Background() + recipes := []cloudguard.DetectorRecipeSummary{} + var page *string + for { + response, err := client.ListDetectorRecipes(ctx, cloudguard.ListDetectorRecipesRequest{ + CompartmentId: common.String(conn.TenantID()), + Page: page, + }) + if err != nil { + return nil, err + } + + recipes = append(recipes, response.Items...) + + if response.OpcNextPage == nil { + break + } + page = response.OpcNextPage + } + + res := make([]any, 0, len(recipes)) + for i := range recipes { + recipe := recipes[i] + + var created *time.Time + if recipe.TimeCreated != nil { + created = &recipe.TimeCreated.Time + } + + mqlInstance, err := CreateResource(o.MqlRuntime, "oci.cloudGuard.detectorRecipe", map[string]*llx.RawData{ + "id": llx.StringDataPtr(recipe.Id), + "name": llx.StringDataPtr(recipe.DisplayName), + "description": llx.StringDataPtr(recipe.Description), + "owner": llx.StringData(string(recipe.Owner)), + "detectorType": llx.StringData(string(recipe.Detector)), + "state": llx.StringData(string(recipe.LifecycleState)), + "created": llx.TimeDataPtr(created), + }) + if err != nil { + return nil, err + } + res = append(res, mqlInstance) + } + + return res, nil +} + +func (o *mqlOciCloudGuardTarget) id() (string, error) { + return "oci.cloudGuard.target/" + o.Id.Data, nil +} + +func (o *mqlOciCloudGuardDetectorRecipe) id() (string, error) { + return "oci.cloudGuard.detectorRecipe/" + o.Id.Data, nil +} diff --git a/providers/oci/resources/compute.go b/providers/oci/resources/compute.go index 04ded832d7..f66e05e771 100644 --- a/providers/oci/resources/compute.go +++ b/providers/oci/resources/compute.go @@ -12,6 +12,8 @@ import ( "github.com/oracle/oci-go-sdk/v65/core" "github.com/rs/zerolog/log" "go.mondoo.com/mql/v13/llx" + "go.mondoo.com/mql/v13/providers-sdk/v1/plugin" + "go.mondoo.com/mql/v13/providers-sdk/v1/util/convert" "go.mondoo.com/mql/v13/providers-sdk/v1/util/jobpool" "go.mondoo.com/mql/v13/providers/oci/connection" "go.mondoo.com/mql/v13/types" @@ -109,16 +111,51 @@ func (o *mqlOciCompute) getComputeInstances(conn *connection.OciConnection, regi created = &instance.TimeCreated.Time } - freeformTags := make(map[string]interface{}) + freeformTags := make(map[string]interface{}, len(instance.FreeformTags)) for k, v := range instance.FreeformTags { freeformTags[k] = v } - definedTags := make(map[string]interface{}) + definedTags := make(map[string]interface{}, len(instance.DefinedTags)) for k, v := range instance.DefinedTags { definedTags[k] = v } + metadata := make(map[string]interface{}, len(instance.Metadata)) + for k, v := range instance.Metadata { + metadata[k] = v + } + + platformConfig, err := convert.JsonToDict(instance.PlatformConfig) + if err != nil { + return nil, err + } + + launchOptions, err := convert.JsonToDict(instance.LaunchOptions) + if err != nil { + return nil, err + } + + instanceOptions, err := convert.JsonToDict(instance.InstanceOptions) + if err != nil { + return nil, err + } + + shapeConfig, err := convert.JsonToDict(instance.ShapeConfig) + if err != nil { + return nil, err + } + + sourceDetails, err := convert.JsonToDict(instance.SourceDetails) + if err != nil { + return nil, err + } + + var timeMaintenanceRebootDue *time.Time + if instance.TimeMaintenanceRebootDue != nil { + timeMaintenanceRebootDue = &instance.TimeMaintenanceRebootDue.Time + } + // Create compartment resource reference compartment, err := CreateResource(o.MqlRuntime, "oci.compartment", map[string]*llx.RawData{ "id": llx.StringDataPtr(instance.CompartmentId), @@ -128,19 +165,26 @@ func (o *mqlOciCompute) getComputeInstances(conn *connection.OciConnection, regi } mqlInstance, err := CreateResource(o.MqlRuntime, "oci.compute.instance", map[string]*llx.RawData{ - "id": llx.StringDataPtr(instance.Id), - "name": llx.StringDataPtr(instance.DisplayName), - "region": llx.ResourceData(regionResource, "oci.region"), - "created": llx.TimeDataPtr(created), - "state": llx.StringData(string(instance.LifecycleState)), - "shape": llx.StringDataPtr(instance.Shape), - "availabilityDomain": llx.StringDataPtr(instance.AvailabilityDomain), - "compartment": llx.ResourceData(compartment, "oci.compartment"), - "faultDomain": llx.StringDataPtr(instance.FaultDomain), - "imageId": llx.StringDataPtr(instance.ImageId), - "dedicatedVmHostId": llx.StringDataPtr(instance.DedicatedVmHostId), - "freeformTags": llx.MapData(freeformTags, types.String), - "definedTags": llx.MapData(definedTags, types.Any), + "id": llx.StringDataPtr(instance.Id), + "name": llx.StringDataPtr(instance.DisplayName), + "region": llx.ResourceData(regionResource, "oci.region"), + "created": llx.TimeDataPtr(created), + "state": llx.StringData(string(instance.LifecycleState)), + "shape": llx.StringDataPtr(instance.Shape), + "availabilityDomain": llx.StringDataPtr(instance.AvailabilityDomain), + "compartment": llx.ResourceData(compartment, "oci.compartment"), + "faultDomain": llx.StringDataPtr(instance.FaultDomain), + "imageId": llx.StringDataPtr(instance.ImageId), + "dedicatedVmHostId": llx.StringDataPtr(instance.DedicatedVmHostId), + "platformConfig": llx.DictData(platformConfig), + "launchOptions": llx.DictData(launchOptions), + "instanceOptions": llx.DictData(instanceOptions), + "shapeConfig": llx.DictData(shapeConfig), + "sourceDetails": llx.DictData(sourceDetails), + "metadata": llx.MapData(metadata, types.String), + "timeMaintenanceRebootDue": llx.TimeDataPtr(timeMaintenanceRebootDue), + "freeformTags": llx.MapData(freeformTags, types.String), + "definedTags": llx.MapData(definedTags, types.Any), }) if err != nil { return nil, err @@ -246,21 +290,16 @@ func (o *mqlOciCompute) getComputeImage(conn *connection.OciConnection, regions created = &image.TimeCreated.Time } - freeformTags := make(map[string]interface{}) + freeformTags := make(map[string]interface{}, len(image.FreeformTags)) for k, v := range image.FreeformTags { freeformTags[k] = v } - definedTags := make(map[string]interface{}) + definedTags := make(map[string]interface{}, len(image.DefinedTags)) for k, v := range image.DefinedTags { definedTags[k] = v } - var sizeInMBs int64 - if image.SizeInMBs != nil { - sizeInMBs = *image.SizeInMBs - } - // Create compartment resource reference compartment, err := CreateResource(o.MqlRuntime, "oci.compartment", map[string]*llx.RawData{ "id": llx.StringDataPtr(image.CompartmentId), @@ -278,7 +317,7 @@ func (o *mqlOciCompute) getComputeImage(conn *connection.OciConnection, regions "compartment": llx.ResourceData(compartment, "oci.compartment"), "operatingSystem": llx.StringDataPtr(image.OperatingSystem), "operatingSystemVersion": llx.StringDataPtr(image.OperatingSystemVersion), - "sizeInMBs": llx.IntData(sizeInMBs), + "sizeInMBs": llx.IntDataPtr(image.SizeInMBs), "freeformTags": llx.MapData(freeformTags, types.String), "definedTags": llx.MapData(definedTags, types.Any), }) @@ -298,3 +337,263 @@ func (o *mqlOciCompute) getComputeImage(conn *connection.OciConnection, regions func (o *mqlOciComputeImage) id() (string, error) { return "oci.compute.image/" + o.Id.Data, nil } + +func (o *mqlOciCompute) blockVolumes() ([]any, error) { + conn := o.MqlRuntime.Connection.(*connection.OciConnection) + + ociResource, err := CreateResource(o.MqlRuntime, "oci", nil) + if err != nil { + return nil, err + } + oci := ociResource.(*mqlOci) + list := oci.GetRegions() + if list.Error != nil { + return nil, list.Error + } + + res := []any{} + poolOfJobs := jobpool.CreatePool(o.getBlockVolumes(conn, list.Data), 5) + poolOfJobs.Run() + + if poolOfJobs.HasErrors() { + return nil, poolOfJobs.GetErrors() + } + for i := range poolOfJobs.Jobs { + res = append(res, poolOfJobs.Jobs[i].Result.([]any)...) + } + + return res, nil +} + +func (o *mqlOciCompute) getBlockVolumesForRegion(ctx context.Context, client *core.BlockstorageClient, compartmentID string) ([]core.Volume, error) { + volumes := []core.Volume{} + var page *string + for { + request := core.ListVolumesRequest{ + CompartmentId: common.String(compartmentID), + Page: page, + } + + response, err := client.ListVolumes(ctx, request) + if err != nil { + return nil, err + } + + volumes = append(volumes, response.Items...) + + if response.OpcNextPage == nil { + break + } + + page = response.OpcNextPage + } + + return volumes, nil +} + +func (o *mqlOciCompute) getBlockVolumes(conn *connection.OciConnection, regions []any) []*jobpool.Job { + ctx := context.Background() + tasks := make([]*jobpool.Job, 0) + for _, region := range regions { + regionResource, ok := region.(*mqlOciRegion) + if !ok { + return jobErr(errors.New("invalid region type")) + } + f := func() (jobpool.JobResult, error) { + log.Debug().Msgf("calling oci with region %s", regionResource.Id.Data) + + svc, err := conn.BlockstorageClient(regionResource.Id.Data) + if err != nil { + return nil, err + } + + var res []any + volumes, err := o.getBlockVolumesForRegion(ctx, svc, conn.TenantID()) + if err != nil { + return nil, err + } + + for i := range volumes { + vol := volumes[i] + + var created *time.Time + if vol.TimeCreated != nil { + created = &vol.TimeCreated.Time + } + + mqlInstance, err := CreateResource(o.MqlRuntime, "oci.compute.blockVolume", map[string]*llx.RawData{ + "id": llx.StringDataPtr(vol.Id), + "name": llx.StringDataPtr(vol.DisplayName), + "compartmentID": llx.StringDataPtr(vol.CompartmentId), + "availabilityDomain": llx.StringDataPtr(vol.AvailabilityDomain), + "sizeInGBs": llx.IntDataPtr(vol.SizeInGBs), + "vpusPerGB": llx.IntDataPtr(vol.VpusPerGB), + "state": llx.StringData(string(vol.LifecycleState)), + "isHydrated": llx.BoolDataPtr(vol.IsHydrated), + "isAutoTuneEnabled": llx.BoolDataPtr(vol.IsAutoTuneEnabled), + "created": llx.TimeDataPtr(created), + }) + if err != nil { + return nil, err + } + mqlInstance.(*mqlOciComputeBlockVolume).cacheKmsKeyId = stringValue(vol.KmsKeyId) + res = append(res, mqlInstance) + } + + return jobpool.JobResult(res), nil + } + tasks = append(tasks, jobpool.NewJob(f)) + } + return tasks +} + +type mqlOciComputeBlockVolumeInternal struct { + cacheKmsKeyId string +} + +func (o *mqlOciComputeBlockVolume) id() (string, error) { + return "oci.compute.blockVolume/" + o.Id.Data, nil +} + +func (o *mqlOciComputeBlockVolume) kmsKey() (*mqlOciKmsKey, error) { + if o.cacheKmsKeyId == "" { + o.KmsKey.State = plugin.StateIsSet | plugin.StateIsNull + return nil, nil + } + mqlKey, err := NewResource(o.MqlRuntime, "oci.kms.key", map[string]*llx.RawData{ + "id": llx.StringData(o.cacheKmsKeyId), + }) + if err != nil { + return nil, err + } + return mqlKey.(*mqlOciKmsKey), nil +} + +func (o *mqlOciCompute) bootVolumes() ([]any, error) { + conn := o.MqlRuntime.Connection.(*connection.OciConnection) + + ociResource, err := CreateResource(o.MqlRuntime, "oci", nil) + if err != nil { + return nil, err + } + oci := ociResource.(*mqlOci) + list := oci.GetRegions() + if list.Error != nil { + return nil, list.Error + } + + res := []any{} + poolOfJobs := jobpool.CreatePool(o.getBootVolumes(conn, list.Data), 5) + poolOfJobs.Run() + + if poolOfJobs.HasErrors() { + return nil, poolOfJobs.GetErrors() + } + for i := range poolOfJobs.Jobs { + res = append(res, poolOfJobs.Jobs[i].Result.([]any)...) + } + + return res, nil +} + +func (o *mqlOciCompute) getBootVolumesForRegion(ctx context.Context, client *core.BlockstorageClient, compartmentID string) ([]core.BootVolume, error) { + bootVolumes := []core.BootVolume{} + var page *string + for { + request := core.ListBootVolumesRequest{ + CompartmentId: common.String(compartmentID), + Page: page, + } + + response, err := client.ListBootVolumes(ctx, request) + if err != nil { + return nil, err + } + + bootVolumes = append(bootVolumes, response.Items...) + + if response.OpcNextPage == nil { + break + } + + page = response.OpcNextPage + } + + return bootVolumes, nil +} + +func (o *mqlOciCompute) getBootVolumes(conn *connection.OciConnection, regions []any) []*jobpool.Job { + ctx := context.Background() + tasks := make([]*jobpool.Job, 0) + for _, region := range regions { + regionResource, ok := region.(*mqlOciRegion) + if !ok { + return jobErr(errors.New("invalid region type")) + } + f := func() (jobpool.JobResult, error) { + log.Debug().Msgf("calling oci with region %s", regionResource.Id.Data) + + svc, err := conn.BlockstorageClient(regionResource.Id.Data) + if err != nil { + return nil, err + } + + var res []any + bootVols, err := o.getBootVolumesForRegion(ctx, svc, conn.TenantID()) + if err != nil { + return nil, err + } + + for i := range bootVols { + bv := bootVols[i] + + var created *time.Time + if bv.TimeCreated != nil { + created = &bv.TimeCreated.Time + } + + mqlInstance, err := CreateResource(o.MqlRuntime, "oci.compute.bootVolume", map[string]*llx.RawData{ + "id": llx.StringDataPtr(bv.Id), + "name": llx.StringDataPtr(bv.DisplayName), + "compartmentID": llx.StringDataPtr(bv.CompartmentId), + "availabilityDomain": llx.StringDataPtr(bv.AvailabilityDomain), + "sizeInGBs": llx.IntDataPtr(bv.SizeInGBs), + "imageId": llx.StringDataPtr(bv.ImageId), + "state": llx.StringData(string(bv.LifecycleState)), + "created": llx.TimeDataPtr(created), + }) + if err != nil { + return nil, err + } + mqlInstance.(*mqlOciComputeBootVolume).cacheKmsKeyId = stringValue(bv.KmsKeyId) + res = append(res, mqlInstance) + } + + return jobpool.JobResult(res), nil + } + tasks = append(tasks, jobpool.NewJob(f)) + } + return tasks +} + +type mqlOciComputeBootVolumeInternal struct { + cacheKmsKeyId string +} + +func (o *mqlOciComputeBootVolume) id() (string, error) { + return "oci.compute.bootVolume/" + o.Id.Data, nil +} + +func (o *mqlOciComputeBootVolume) kmsKey() (*mqlOciKmsKey, error) { + if o.cacheKmsKeyId == "" { + o.KmsKey.State = plugin.StateIsSet | plugin.StateIsNull + return nil, nil + } + mqlKey, err := NewResource(o.MqlRuntime, "oci.kms.key", map[string]*llx.RawData{ + "id": llx.StringData(o.cacheKmsKeyId), + }) + if err != nil { + return nil, err + } + return mqlKey.(*mqlOciKmsKey), nil +} diff --git a/providers/oci/resources/conversion.go b/providers/oci/resources/conversion.go index 5a67294631..5c34d2bbde 100644 --- a/providers/oci/resources/conversion.go +++ b/providers/oci/resources/conversion.go @@ -4,20 +4,9 @@ package resources import ( - "time" - "go.mondoo.com/mql/v13/providers-sdk/v1/util/jobpool" ) -// parseTime parses RFC 3389 timestamps "2019-06-12T21:14:13.190Z" -func parseTime(timestamp string) *time.Time { - parsedCreated, err := time.Parse(time.RFC3339, timestamp) - if err != nil { - return nil - } - return &parsedCreated -} - func stringValue(s *string) string { if s == nil { return "" @@ -32,6 +21,20 @@ func boolValue(s *bool) bool { return *s } +func int64Value(i *int64) int64 { + if i == nil { + return 0 + } + return *i +} + +func intValue(i *int) int64 { + if i == nil { + return 0 + } + return int64(*i) +} + func jobErr(err error) []*jobpool.Job { return []*jobpool.Job{{Err: err}} } diff --git a/providers/oci/resources/conversion_test.go b/providers/oci/resources/conversion_test.go new file mode 100644 index 0000000000..b52348b39b --- /dev/null +++ b/providers/oci/resources/conversion_test.go @@ -0,0 +1,69 @@ +// Copyright (c) Mondoo, Inc. +// SPDX-License-Identifier: BUSL-1.1 + +package resources + +import ( + "testing" + + "github.com/stretchr/testify/assert" +) + +func TestStringValue(t *testing.T) { + t.Run("nil returns empty string", func(t *testing.T) { + assert.Equal(t, "", stringValue(nil)) + }) + + t.Run("non-nil returns value", func(t *testing.T) { + s := "hello" + assert.Equal(t, "hello", stringValue(&s)) + }) + + t.Run("empty string pointer returns empty string", func(t *testing.T) { + s := "" + assert.Equal(t, "", stringValue(&s)) + }) +} + +func TestBoolValue(t *testing.T) { + t.Run("nil returns false", func(t *testing.T) { + assert.False(t, boolValue(nil)) + }) + + t.Run("true pointer returns true", func(t *testing.T) { + b := true + assert.True(t, boolValue(&b)) + }) + + t.Run("false pointer returns false", func(t *testing.T) { + b := false + assert.False(t, boolValue(&b)) + }) +} + +func TestInt64Value(t *testing.T) { + t.Run("nil returns 0", func(t *testing.T) { + assert.Equal(t, int64(0), int64Value(nil)) + }) + + t.Run("non-nil returns value", func(t *testing.T) { + i := int64(42) + assert.Equal(t, int64(42), int64Value(&i)) + }) + + t.Run("zero pointer returns 0", func(t *testing.T) { + i := int64(0) + assert.Equal(t, int64(0), int64Value(&i)) + }) +} + +func TestIntValue(t *testing.T) { + t.Run("nil returns 0", func(t *testing.T) { + assert.Equal(t, int64(0), intValue(nil)) + }) + + t.Run("non-nil returns value as int64", func(t *testing.T) { + i := 42 + assert.Equal(t, int64(42), intValue(&i)) + }) +} diff --git a/providers/oci/resources/events.go b/providers/oci/resources/events.go new file mode 100644 index 0000000000..3f354e7983 --- /dev/null +++ b/providers/oci/resources/events.go @@ -0,0 +1,202 @@ +// Copyright (c) Mondoo, Inc. +// SPDX-License-Identifier: BUSL-1.1 + +package resources + +import ( + "context" + "errors" + "time" + + "github.com/oracle/oci-go-sdk/v65/common" + "github.com/oracle/oci-go-sdk/v65/events" + "github.com/rs/zerolog/log" + "go.mondoo.com/mql/v13/llx" + "go.mondoo.com/mql/v13/providers-sdk/v1/util/jobpool" + "go.mondoo.com/mql/v13/providers/oci/connection" +) + +func (o *mqlOciEvents) id() (string, error) { + return "oci.events", nil +} + +func (o *mqlOciEvents) rules() ([]any, error) { + conn := o.MqlRuntime.Connection.(*connection.OciConnection) + + ociResource, err := CreateResource(o.MqlRuntime, "oci", nil) + if err != nil { + return nil, err + } + oci := ociResource.(*mqlOci) + list := oci.GetRegions() + if list.Error != nil { + return nil, list.Error + } + + res := []any{} + poolOfJobs := jobpool.CreatePool(o.getEventRules(conn, list.Data), 5) + poolOfJobs.Run() + + if poolOfJobs.HasErrors() { + return nil, poolOfJobs.GetErrors() + } + for i := range poolOfJobs.Jobs { + res = append(res, poolOfJobs.Jobs[i].Result.([]any)...) + } + + return res, nil +} + +func (o *mqlOciEvents) getEventRulesForRegion(ctx context.Context, client *events.EventsClient, compartmentID string) ([]events.RuleSummary, error) { + rules := []events.RuleSummary{} + var page *string + for { + request := events.ListRulesRequest{ + CompartmentId: common.String(compartmentID), + Page: page, + } + + response, err := client.ListRules(ctx, request) + if err != nil { + return nil, err + } + + rules = append(rules, response.Items...) + + if response.OpcNextPage == nil { + break + } + + page = response.OpcNextPage + } + + return rules, nil +} + +func (o *mqlOciEvents) getEventRules(conn *connection.OciConnection, regions []any) []*jobpool.Job { + ctx := context.Background() + tasks := make([]*jobpool.Job, 0) + for _, region := range regions { + regionResource, ok := region.(*mqlOciRegion) + if !ok { + return jobErr(errors.New("invalid region type")) + } + f := func() (jobpool.JobResult, error) { + log.Debug().Msgf("calling oci with region %s", regionResource.Id.Data) + + svc, err := conn.EventsClient(regionResource.Id.Data) + if err != nil { + return nil, err + } + + var res []any + rules, err := o.getEventRulesForRegion(ctx, svc, conn.TenantID()) + if err != nil { + return nil, err + } + + for i := range rules { + rule := rules[i] + + var created *time.Time + if rule.TimeCreated != nil { + created = &rule.TimeCreated.Time + } + + mqlInstance, err := CreateResource(o.MqlRuntime, "oci.events.rule", map[string]*llx.RawData{ + "id": llx.StringDataPtr(rule.Id), + "name": llx.StringDataPtr(rule.DisplayName), + "description": llx.StringDataPtr(rule.Description), + "compartmentID": llx.StringDataPtr(rule.CompartmentId), + "condition": llx.StringDataPtr(rule.Condition), + "isEnabled": llx.BoolDataPtr(rule.IsEnabled), + "state": llx.StringData(string(rule.LifecycleState)), + "created": llx.TimeDataPtr(created), + }) + if err != nil { + return nil, err + } + + mqlRule := mqlInstance.(*mqlOciEventsRule) + mqlRule.region = regionResource.Id.Data + + res = append(res, mqlInstance) + } + + return jobpool.JobResult(res), nil + } + tasks = append(tasks, jobpool.NewJob(f)) + } + return tasks +} + +type mqlOciEventsRuleInternal struct { + rule *events.Rule + region string +} + +func (o *mqlOciEventsRule) id() (string, error) { + return "oci.events.rule/" + o.Id.Data, nil +} + +func (o *mqlOciEventsRule) getRuleDetails() (*events.Rule, error) { + if o.rule != nil { + return o.rule, nil + } + + conn := o.MqlRuntime.Connection.(*connection.OciConnection) + + client, err := conn.EventsClient(o.region) + if err != nil { + return nil, err + } + + response, err := client.GetRule(context.Background(), events.GetRuleRequest{ + RuleId: common.String(o.Id.Data), + }) + if err != nil { + return nil, err + } + + o.rule = &response.Rule + return o.rule, nil +} + +func (o *mqlOciEventsRule) actions() ([]any, error) { + rule, err := o.getRuleDetails() + if err != nil { + return nil, err + } + + if rule.Actions == nil { + return []any{}, nil + } + + res := make([]any, 0, len(rule.Actions.Actions)) + for _, action := range rule.Actions.Actions { + m := map[string]any{ + "id": stringValue(action.GetId()), + "isEnabled": boolValue(action.GetIsEnabled()), + "state": string(action.GetLifecycleState()), + } + + switch a := action.(type) { + case events.NotificationServiceAction: + m["actionType"] = "ONS" + m["topicId"] = stringValue(a.TopicId) + m["description"] = stringValue(a.Description) + case events.StreamingServiceAction: + m["actionType"] = "OSS" + m["streamId"] = stringValue(a.StreamId) + m["description"] = stringValue(a.Description) + case events.FaaSAction: + m["actionType"] = "FAAS" + m["functionId"] = stringValue(a.FunctionId) + m["description"] = stringValue(a.Description) + } + + res = append(res, m) + } + + return res, nil +} diff --git a/providers/oci/resources/filestorage.go b/providers/oci/resources/filestorage.go new file mode 100644 index 0000000000..ed7b763979 --- /dev/null +++ b/providers/oci/resources/filestorage.go @@ -0,0 +1,171 @@ +// Copyright (c) Mondoo, Inc. +// SPDX-License-Identifier: BUSL-1.1 + +package resources + +import ( + "context" + "errors" + "time" + + "github.com/oracle/oci-go-sdk/v65/common" + "github.com/oracle/oci-go-sdk/v65/filestorage" + "github.com/oracle/oci-go-sdk/v65/identity" + "github.com/rs/zerolog/log" + "go.mondoo.com/mql/v13/llx" + "go.mondoo.com/mql/v13/providers-sdk/v1/plugin" + "go.mondoo.com/mql/v13/providers-sdk/v1/util/jobpool" + "go.mondoo.com/mql/v13/providers/oci/connection" +) + +func (o *mqlOciFileStorage) id() (string, error) { + return "oci.fileStorage", nil +} + +func (o *mqlOciFileStorage) fileSystems() ([]any, error) { + conn := o.MqlRuntime.Connection.(*connection.OciConnection) + + ociResource, err := CreateResource(o.MqlRuntime, "oci", nil) + if err != nil { + return nil, err + } + oci := ociResource.(*mqlOci) + list := oci.GetRegions() + if list.Error != nil { + return nil, list.Error + } + + res := []any{} + poolOfJobs := jobpool.CreatePool(o.getFileSystems(conn, list.Data), 5) + poolOfJobs.Run() + + if poolOfJobs.HasErrors() { + return nil, poolOfJobs.GetErrors() + } + for i := range poolOfJobs.Jobs { + res = append(res, poolOfJobs.Jobs[i].Result.([]any)...) + } + + return res, nil +} + +func (o *mqlOciFileStorage) getFileSystemsForAD(ctx context.Context, fsClient *filestorage.FileStorageClient, compartmentID string, availabilityDomain string) ([]filestorage.FileSystemSummary, error) { + fileSystems := []filestorage.FileSystemSummary{} + var page *string + for { + request := filestorage.ListFileSystemsRequest{ + CompartmentId: common.String(compartmentID), + AvailabilityDomain: common.String(availabilityDomain), + Page: page, + } + + response, err := fsClient.ListFileSystems(ctx, request) + if err != nil { + return nil, err + } + + fileSystems = append(fileSystems, response.Items...) + + if response.OpcNextPage == nil { + break + } + + page = response.OpcNextPage + } + + return fileSystems, nil +} + +func (o *mqlOciFileStorage) getFileSystems(conn *connection.OciConnection, regions []any) []*jobpool.Job { + ctx := context.Background() + tasks := make([]*jobpool.Job, 0) + for _, region := range regions { + regionResource, ok := region.(*mqlOciRegion) + if !ok { + return jobErr(errors.New("invalid region type")) + } + f := func() (jobpool.JobResult, error) { + log.Debug().Msgf("calling oci with region %s", regionResource.Id.Data) + + // Get availability domains for this region + identityClient, err := conn.IdentityClientWithRegion(regionResource.Id.Data) + if err != nil { + return nil, err + } + + adResponse, err := identityClient.ListAvailabilityDomains(ctx, identity.ListAvailabilityDomainsRequest{ + CompartmentId: common.String(conn.TenantID()), + }) + if err != nil { + return nil, err + } + + fsClient, err := conn.FileStorageClient(regionResource.Id.Data) + if err != nil { + return nil, err + } + + var res []any + for _, ad := range adResponse.Items { + if ad.Name == nil { + continue + } + + fileSystems, err := o.getFileSystemsForAD(ctx, fsClient, conn.TenantID(), *ad.Name) + if err != nil { + return nil, err + } + + for i := range fileSystems { + fs := fileSystems[i] + + var created *time.Time + if fs.TimeCreated != nil { + created = &fs.TimeCreated.Time + } + + mqlInstance, err := CreateResource(o.MqlRuntime, "oci.fileStorage.fileSystem", map[string]*llx.RawData{ + "id": llx.StringDataPtr(fs.Id), + "name": llx.StringDataPtr(fs.DisplayName), + "compartmentID": llx.StringDataPtr(fs.CompartmentId), + "availabilityDomain": llx.StringDataPtr(fs.AvailabilityDomain), + "state": llx.StringData(string(fs.LifecycleState)), + "meteredBytes": llx.IntDataPtr(fs.MeteredBytes), + "created": llx.TimeDataPtr(created), + }) + if err != nil { + return nil, err + } + mqlInstance.(*mqlOciFileStorageFileSystem).cacheKmsKeyId = stringValue(fs.KmsKeyId) + res = append(res, mqlInstance) + } + } + + return jobpool.JobResult(res), nil + } + tasks = append(tasks, jobpool.NewJob(f)) + } + return tasks +} + +type mqlOciFileStorageFileSystemInternal struct { + cacheKmsKeyId string +} + +func (o *mqlOciFileStorageFileSystem) id() (string, error) { + return "oci.fileStorage.fileSystem/" + o.Id.Data, nil +} + +func (o *mqlOciFileStorageFileSystem) kmsKey() (*mqlOciKmsKey, error) { + if o.cacheKmsKeyId == "" { + o.KmsKey.State = plugin.StateIsSet | plugin.StateIsNull + return nil, nil + } + mqlKey, err := NewResource(o.MqlRuntime, "oci.kms.key", map[string]*llx.RawData{ + "id": llx.StringData(o.cacheKmsKeyId), + }) + if err != nil { + return nil, err + } + return mqlKey.(*mqlOciKmsKey), nil +} diff --git a/providers/oci/resources/kms.go b/providers/oci/resources/kms.go new file mode 100644 index 0000000000..763bac9d73 --- /dev/null +++ b/providers/oci/resources/kms.go @@ -0,0 +1,213 @@ +// Copyright (c) Mondoo, Inc. +// SPDX-License-Identifier: BUSL-1.1 + +package resources + +import ( + "context" + "errors" + "time" + + "github.com/oracle/oci-go-sdk/v65/common" + "github.com/oracle/oci-go-sdk/v65/keymanagement" + "github.com/rs/zerolog/log" + "go.mondoo.com/mql/v13/llx" + "go.mondoo.com/mql/v13/providers-sdk/v1/util/jobpool" + "go.mondoo.com/mql/v13/providers/oci/connection" +) + +func (o *mqlOciKms) id() (string, error) { + return "oci.kms", nil +} + +func (o *mqlOciKms) vaults() ([]any, error) { + conn := o.MqlRuntime.Connection.(*connection.OciConnection) + + ociResource, err := CreateResource(o.MqlRuntime, "oci", nil) + if err != nil { + return nil, err + } + oci := ociResource.(*mqlOci) + list := oci.GetRegions() + if list.Error != nil { + return nil, list.Error + } + + res := []any{} + poolOfJobs := jobpool.CreatePool(o.getVaults(conn, list.Data), 5) + poolOfJobs.Run() + + if poolOfJobs.HasErrors() { + return nil, poolOfJobs.GetErrors() + } + for i := range poolOfJobs.Jobs { + res = append(res, poolOfJobs.Jobs[i].Result.([]any)...) + } + + return res, nil +} + +func (o *mqlOciKms) getVaultsForRegion(ctx context.Context, client *keymanagement.KmsVaultClient, compartmentID string) ([]keymanagement.VaultSummary, error) { + entries := []keymanagement.VaultSummary{} + var page *string + for { + request := keymanagement.ListVaultsRequest{ + CompartmentId: common.String(compartmentID), + Page: page, + } + + response, err := client.ListVaults(ctx, request) + if err != nil { + return nil, err + } + + entries = append(entries, response.Items...) + + if response.OpcNextPage == nil { + break + } + page = response.OpcNextPage + } + + return entries, nil +} + +func (o *mqlOciKms) getVaults(conn *connection.OciConnection, regions []any) []*jobpool.Job { + ctx := context.Background() + tasks := make([]*jobpool.Job, 0) + for _, region := range regions { + regionResource, ok := region.(*mqlOciRegion) + if !ok { + return jobErr(errors.New("invalid region type")) + } + f := func() (jobpool.JobResult, error) { + log.Debug().Msgf("calling oci kms with region %s", regionResource.Id.Data) + + svc, err := conn.KmsVaultClient(regionResource.Id.Data) + if err != nil { + return nil, err + } + + var res []any + vaults, err := o.getVaultsForRegion(ctx, svc, conn.TenantID()) + if err != nil { + return nil, err + } + + for i := range vaults { + vault := vaults[i] + + var created *time.Time + if vault.TimeCreated != nil { + created = &vault.TimeCreated.Time + } + + mqlInstance, err := CreateResource(o.MqlRuntime, "oci.kms.vault", map[string]*llx.RawData{ + "id": llx.StringDataPtr(vault.Id), + "name": llx.StringDataPtr(vault.DisplayName), + "compartmentID": llx.StringDataPtr(vault.CompartmentId), + "vaultType": llx.StringData(string(vault.VaultType)), + "state": llx.StringData(string(vault.LifecycleState)), + "managementEndpoint": llx.StringDataPtr(vault.ManagementEndpoint), + "created": llx.TimeDataPtr(created), + }) + if err != nil { + return nil, err + } + mqlInstance.(*mqlOciKmsVault).region = regionResource.Id.Data + res = append(res, mqlInstance) + } + + return jobpool.JobResult(res), nil + } + tasks = append(tasks, jobpool.NewJob(f)) + } + return tasks +} + +type mqlOciKmsVaultInternal struct { + region string +} + +func (o *mqlOciKmsVault) id() (string, error) { + return "oci.kms.vault/" + o.Id.Data, nil +} + +func (o *mqlOciKmsVault) keys() ([]any, error) { + conn := o.MqlRuntime.Connection.(*connection.OciConnection) + ctx := context.Background() + + managementEndpoint := o.ManagementEndpoint.Data + if managementEndpoint == "" { + return []any{}, nil + } + + svc, err := conn.KmsManagementClient(managementEndpoint) + if err != nil { + return nil, err + } + + keys, err := o.getKeysForVault(ctx, svc, o.CompartmentID.Data) + if err != nil { + return nil, err + } + + res := []any{} + for i := range keys { + key := keys[i] + + var created *time.Time + if key.TimeCreated != nil { + created = &key.TimeCreated.Time + } + + algorithm := string(key.Algorithm) + + mqlInstance, err := CreateResource(o.MqlRuntime, "oci.kms.key", map[string]*llx.RawData{ + "id": llx.StringDataPtr(key.Id), + "name": llx.StringDataPtr(key.DisplayName), + "compartmentID": llx.StringDataPtr(key.CompartmentId), + "vaultId": llx.StringDataPtr(key.VaultId), + "algorithm": llx.StringData(algorithm), + "protectionMode": llx.StringData(string(key.ProtectionMode)), + "state": llx.StringData(string(key.LifecycleState)), + "isAutoRotationEnabled": llx.BoolDataPtr(key.IsAutoRotationEnabled), + "created": llx.TimeDataPtr(created), + }) + if err != nil { + return nil, err + } + res = append(res, mqlInstance) + } + + return res, nil +} + +func (o *mqlOciKmsVault) getKeysForVault(ctx context.Context, client *keymanagement.KmsManagementClient, compartmentID string) ([]keymanagement.KeySummary, error) { + entries := []keymanagement.KeySummary{} + var page *string + for { + request := keymanagement.ListKeysRequest{ + CompartmentId: common.String(compartmentID), + Page: page, + } + + response, err := client.ListKeys(ctx, request) + if err != nil { + return nil, err + } + + entries = append(entries, response.Items...) + + if response.OpcNextPage == nil { + break + } + page = response.OpcNextPage + } + + return entries, nil +} + +func (o *mqlOciKmsKey) id() (string, error) { + return "oci.kms.key/" + o.Id.Data, nil +} diff --git a/providers/oci/resources/loadbalancer.go b/providers/oci/resources/loadbalancer.go new file mode 100644 index 0000000000..519b1245e1 --- /dev/null +++ b/providers/oci/resources/loadbalancer.go @@ -0,0 +1,196 @@ +// Copyright (c) Mondoo, Inc. +// SPDX-License-Identifier: BUSL-1.1 + +package resources + +import ( + "context" + "errors" + "time" + + "github.com/oracle/oci-go-sdk/v65/common" + "github.com/oracle/oci-go-sdk/v65/loadbalancer" + "github.com/rs/zerolog/log" + "go.mondoo.com/mql/v13/llx" + "go.mondoo.com/mql/v13/providers-sdk/v1/util/convert" + "go.mondoo.com/mql/v13/providers-sdk/v1/util/jobpool" + "go.mondoo.com/mql/v13/providers/oci/connection" + "go.mondoo.com/mql/v13/types" +) + +func (o *mqlOciLoadBalancer) id() (string, error) { + return "oci.loadBalancer", nil +} + +func (o *mqlOciLoadBalancer) loadBalancers() ([]any, error) { + conn := o.MqlRuntime.Connection.(*connection.OciConnection) + + ociResource, err := CreateResource(o.MqlRuntime, "oci", nil) + if err != nil { + return nil, err + } + oci := ociResource.(*mqlOci) + list := oci.GetRegions() + if list.Error != nil { + return nil, list.Error + } + + res := []any{} + poolOfJobs := jobpool.CreatePool(o.getLoadBalancers(conn, list.Data), 5) + poolOfJobs.Run() + + if poolOfJobs.HasErrors() { + return nil, poolOfJobs.GetErrors() + } + for i := range poolOfJobs.Jobs { + res = append(res, poolOfJobs.Jobs[i].Result.([]any)...) + } + + return res, nil +} + +func (o *mqlOciLoadBalancer) getLoadBalancers(conn *connection.OciConnection, regions []any) []*jobpool.Job { + ctx := context.Background() + tasks := make([]*jobpool.Job, 0) + for _, region := range regions { + regionResource, ok := region.(*mqlOciRegion) + if !ok { + return jobErr(errors.New("invalid region type")) + } + f := func() (jobpool.JobResult, error) { + log.Debug().Msgf("calling oci load balancer with region %s", regionResource.Id.Data) + + svc, err := conn.LoadBalancerClient(regionResource.Id.Data) + if err != nil { + return nil, err + } + + lbs := []loadbalancer.LoadBalancer{} + var page *string + for { + response, err := svc.ListLoadBalancers(ctx, loadbalancer.ListLoadBalancersRequest{ + CompartmentId: common.String(conn.TenantID()), + Page: page, + }) + if err != nil { + return nil, err + } + + lbs = append(lbs, response.Items...) + + if response.OpcNextPage == nil { + break + } + page = response.OpcNextPage + } + + var res []any + for i := range lbs { + lb := lbs[i] + + var created *time.Time + if lb.TimeCreated != nil { + created = &lb.TimeCreated.Time + } + + mqlInstance, err := CreateResource(o.MqlRuntime, "oci.loadBalancer.loadBalancer", map[string]*llx.RawData{ + "id": llx.StringDataPtr(lb.Id), + "name": llx.StringDataPtr(lb.DisplayName), + "compartmentID": llx.StringDataPtr(lb.CompartmentId), + "shape": llx.StringDataPtr(lb.ShapeName), + "isPrivate": llx.BoolDataPtr(lb.IsPrivate), + "isDeleteProtectionEnabled": llx.BoolDataPtr(lb.IsDeleteProtectionEnabled), + "state": llx.StringData(string(lb.LifecycleState)), + "created": llx.TimeDataPtr(created), + }) + if err != nil { + return nil, err + } + mqlLb := mqlInstance.(*mqlOciLoadBalancerLoadBalancer) + mqlLb.cacheListeners = lb.Listeners + mqlLb.cacheBackendSets = lb.BackendSets + res = append(res, mqlLb) + } + + return jobpool.JobResult(res), nil + } + tasks = append(tasks, jobpool.NewJob(f)) + } + return tasks +} + +type mqlOciLoadBalancerLoadBalancerInternal struct { + cacheListeners map[string]loadbalancer.Listener + cacheBackendSets map[string]loadbalancer.BackendSet +} + +func (o *mqlOciLoadBalancerLoadBalancer) id() (string, error) { + return "oci.loadBalancer.loadBalancer/" + o.Id.Data, nil +} + +func (o *mqlOciLoadBalancerLoadBalancer) listeners() ([]any, error) { + res := []any{} + for name, listener := range o.cacheListeners { + var sslProtocols []any + var sslCipherSuiteName string + var sslVerifyPeerCert bool + if listener.SslConfiguration != nil { + for _, p := range listener.SslConfiguration.Protocols { + sslProtocols = append(sslProtocols, p) + } + sslCipherSuiteName = stringValue(listener.SslConfiguration.CipherSuiteName) + sslVerifyPeerCert = boolValue(listener.SslConfiguration.VerifyPeerCertificate) + } + + lbId := o.Id.Data + listenerId := lbId + "/listener/" + name + mqlInstance, err := CreateResource(o.MqlRuntime, "oci.loadBalancer.listener", map[string]*llx.RawData{ + "id": llx.StringData(listenerId), + "name": llx.StringData(name), + "port": llx.IntDataPtr(listener.Port), + "protocol": llx.StringDataPtr(listener.Protocol), + "defaultBackendSetName": llx.StringDataPtr(listener.DefaultBackendSetName), + "sslProtocols": llx.ArrayData(sslProtocols, types.String), + "sslCipherSuiteName": llx.StringData(sslCipherSuiteName), + "sslVerifyPeerCertificate": llx.BoolData(sslVerifyPeerCert), + }) + if err != nil { + return nil, err + } + res = append(res, mqlInstance) + } + return res, nil +} + +func (o *mqlOciLoadBalancerLoadBalancer) backendSets() ([]any, error) { + res := []any{} + for name, bs := range o.cacheBackendSets { + healthChecker, err := convert.JsonToDict(bs.HealthChecker) + if err != nil { + return nil, err + } + + lbId := o.Id.Data + bsId := lbId + "/backendSet/" + name + mqlInstance, err := CreateResource(o.MqlRuntime, "oci.loadBalancer.backendSet", map[string]*llx.RawData{ + "id": llx.StringData(bsId), + "name": llx.StringData(name), + "policy": llx.StringDataPtr(bs.Policy), + "healthChecker": llx.DictData(healthChecker), + "backendCount": llx.IntData(int64(len(bs.Backends))), + }) + if err != nil { + return nil, err + } + res = append(res, mqlInstance) + } + return res, nil +} + +func (o *mqlOciLoadBalancerListener) id() (string, error) { + return o.Id.Data, nil +} + +func (o *mqlOciLoadBalancerBackendSet) id() (string, error) { + return o.Id.Data, nil +} diff --git a/providers/oci/resources/logging.go b/providers/oci/resources/logging.go new file mode 100644 index 0000000000..317c9120aa --- /dev/null +++ b/providers/oci/resources/logging.go @@ -0,0 +1,260 @@ +// Copyright (c) Mondoo, Inc. +// SPDX-License-Identifier: BUSL-1.1 + +package resources + +import ( + "context" + "errors" + "time" + + "github.com/oracle/oci-go-sdk/v65/common" + "github.com/oracle/oci-go-sdk/v65/logging" + "github.com/rs/zerolog/log" + "go.mondoo.com/mql/v13/llx" + "go.mondoo.com/mql/v13/providers-sdk/v1/plugin" + "go.mondoo.com/mql/v13/providers-sdk/v1/util/convert" + "go.mondoo.com/mql/v13/providers-sdk/v1/util/jobpool" + "go.mondoo.com/mql/v13/providers/oci/connection" +) + +func (o *mqlOciLogging) id() (string, error) { + return "oci.logging", nil +} + +func (o *mqlOciLogging) logGroups() ([]any, error) { + conn := o.MqlRuntime.Connection.(*connection.OciConnection) + + ociResource, err := CreateResource(o.MqlRuntime, "oci", nil) + if err != nil { + return nil, err + } + oci := ociResource.(*mqlOci) + list := oci.GetRegions() + if list.Error != nil { + return nil, list.Error + } + + res := []any{} + poolOfJobs := jobpool.CreatePool(o.getLogGroups(conn, list.Data), 5) + poolOfJobs.Run() + + if poolOfJobs.HasErrors() { + return nil, poolOfJobs.GetErrors() + } + for i := range poolOfJobs.Jobs { + res = append(res, poolOfJobs.Jobs[i].Result.([]any)...) + } + + return res, nil +} + +func (o *mqlOciLogging) getLogGroupsForRegion(ctx context.Context, client *logging.LoggingManagementClient, compartmentID string) ([]logging.LogGroupSummary, error) { + entries := []logging.LogGroupSummary{} + var page *string + for { + request := logging.ListLogGroupsRequest{ + CompartmentId: common.String(compartmentID), + IsCompartmentIdInSubtree: common.Bool(true), + Page: page, + } + + response, err := client.ListLogGroups(ctx, request) + if err != nil { + return nil, err + } + + entries = append(entries, response.Items...) + + if response.OpcNextPage == nil { + break + } + page = response.OpcNextPage + } + + return entries, nil +} + +func (o *mqlOciLogging) getLogGroups(conn *connection.OciConnection, regions []any) []*jobpool.Job { + ctx := context.Background() + tasks := make([]*jobpool.Job, 0) + for _, region := range regions { + regionResource, ok := region.(*mqlOciRegion) + if !ok { + return jobErr(errors.New("invalid region type")) + } + f := func() (jobpool.JobResult, error) { + log.Debug().Msgf("calling oci logging with region %s", regionResource.Id.Data) + + svc, err := conn.LoggingClient(regionResource.Id.Data) + if err != nil { + return nil, err + } + + var res []any + logGroups, err := o.getLogGroupsForRegion(ctx, svc, conn.TenantID()) + if err != nil { + return nil, err + } + + for i := range logGroups { + lg := logGroups[i] + + var created *time.Time + if lg.TimeCreated != nil { + created = &lg.TimeCreated.Time + } + + mqlInstance, err := CreateResource(o.MqlRuntime, "oci.logging.logGroup", map[string]*llx.RawData{ + "id": llx.StringDataPtr(lg.Id), + "name": llx.StringDataPtr(lg.DisplayName), + "description": llx.StringDataPtr(lg.Description), + "compartmentID": llx.StringDataPtr(lg.CompartmentId), + "state": llx.StringData(string(lg.LifecycleState)), + "created": llx.TimeDataPtr(created), + }) + if err != nil { + return nil, err + } + // Store the region internally so logs() knows which region to query + mqlInstance.(*mqlOciLoggingLogGroup).region = regionResource.Id.Data + res = append(res, mqlInstance) + } + + return jobpool.JobResult(res), nil + } + tasks = append(tasks, jobpool.NewJob(f)) + } + return tasks +} + +type mqlOciLoggingLogGroupInternal struct { + region string +} + +func (o *mqlOciLoggingLogGroup) id() (string, error) { + return "oci.logging.logGroup/" + o.Id.Data, nil +} + +func (o *mqlOciLoggingLogGroup) logs() ([]any, error) { + conn := o.MqlRuntime.Connection.(*connection.OciConnection) + ctx := context.Background() + + logGroupId := o.Id.Data + + svc, err := conn.LoggingClient(o.region) + if err != nil { + return nil, err + } + + logs, err := o.getLogsForGroup(ctx, svc, logGroupId) + if err != nil { + return nil, err + } + + res := []any{} + for i := range logs { + l := logs[i] + + config, err := convertLogConfiguration(l.Configuration) + if err != nil { + return nil, err + } + + var logCreated, logLastModified *time.Time + if l.TimeCreated != nil { + logCreated = &l.TimeCreated.Time + } + if l.TimeLastModified != nil { + logLastModified = &l.TimeLastModified.Time + } + + mqlInstance, err := CreateResource(o.MqlRuntime, "oci.logging.log", map[string]*llx.RawData{ + "id": llx.StringDataPtr(l.Id), + "name": llx.StringDataPtr(l.DisplayName), + "logType": llx.StringData(string(l.LogType)), + "isEnabled": llx.BoolDataPtr(l.IsEnabled), + "state": llx.StringData(string(l.LifecycleState)), + "retentionDuration": llx.IntDataPtr(l.RetentionDuration), + "configuration": llx.DictData(config), + "created": llx.TimeDataPtr(logCreated), + "timeLastModified": llx.TimeDataPtr(logLastModified), + }) + if err != nil { + return nil, err + } + mqlInstance.(*mqlOciLoggingLog).cacheLogGroupId = stringValue(l.LogGroupId) + res = append(res, mqlInstance) + } + + return res, nil +} + +func (o *mqlOciLoggingLogGroup) getLogsForGroup(ctx context.Context, client *logging.LoggingManagementClient, logGroupId string) ([]logging.LogSummary, error) { + entries := []logging.LogSummary{} + var page *string + for { + request := logging.ListLogsRequest{ + LogGroupId: common.String(logGroupId), + Page: page, + } + + response, err := client.ListLogs(ctx, request) + if err != nil { + return nil, err + } + + entries = append(entries, response.Items...) + + if response.OpcNextPage == nil { + break + } + page = response.OpcNextPage + } + + return entries, nil +} + +type mqlOciLoggingLogInternal struct { + cacheLogGroupId string +} + +func (o *mqlOciLoggingLog) id() (string, error) { + return "oci.logging.log/" + o.Id.Data, nil +} + +func (o *mqlOciLoggingLog) logGroup() (*mqlOciLoggingLogGroup, error) { + if o.cacheLogGroupId == "" { + o.LogGroup.State = plugin.StateIsSet | plugin.StateIsNull + return nil, nil + } + mqlLg, err := NewResource(o.MqlRuntime, "oci.logging.logGroup", map[string]*llx.RawData{ + "id": llx.StringData(o.cacheLogGroupId), + }) + if err != nil { + return nil, err + } + return mqlLg.(*mqlOciLoggingLogGroup), nil +} + +func convertLogConfiguration(cfg *logging.Configuration) (map[string]interface{}, error) { + if cfg == nil { + return nil, nil + } + + result := map[string]interface{}{} + + if cfg.CompartmentId != nil { + result["compartmentId"] = *cfg.CompartmentId + } + + if cfg.Source != nil { + source, err := convert.JsonToDict(cfg.Source) + if err != nil { + return nil, err + } + result["source"] = source + } + + return result, nil +} diff --git a/providers/oci/resources/logging_test.go b/providers/oci/resources/logging_test.go new file mode 100644 index 0000000000..d8428bb585 --- /dev/null +++ b/providers/oci/resources/logging_test.go @@ -0,0 +1,70 @@ +// Copyright (c) Mondoo, Inc. +// SPDX-License-Identifier: BUSL-1.1 + +package resources + +import ( + "testing" + + "github.com/oracle/oci-go-sdk/v65/common" + "github.com/oracle/oci-go-sdk/v65/logging" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" +) + +func TestConvertLogConfiguration(t *testing.T) { + t.Run("nil config returns nil", func(t *testing.T) { + result, err := convertLogConfiguration(nil) + require.NoError(t, err) + assert.Nil(t, result) + }) + + t.Run("empty config returns empty map", func(t *testing.T) { + cfg := &logging.Configuration{} + result, err := convertLogConfiguration(cfg) + require.NoError(t, err) + assert.NotNil(t, result) + assert.Empty(t, result) + }) + + t.Run("config with compartment ID", func(t *testing.T) { + cfg := &logging.Configuration{ + CompartmentId: common.String("ocid1.compartment.oc1..example"), + } + result, err := convertLogConfiguration(cfg) + require.NoError(t, err) + assert.Equal(t, "ocid1.compartment.oc1..example", result["compartmentId"]) + }) + + t.Run("config with source", func(t *testing.T) { + cfg := &logging.Configuration{ + Source: &logging.OciService{ + Service: common.String("flowlogs"), + Resource: common.String("ocid1.subnet.oc1..example"), + Category: common.String("all"), + }, + } + result, err := convertLogConfiguration(cfg) + require.NoError(t, err) + source, ok := result["source"].(map[string]interface{}) + require.True(t, ok, "source should be a map") + assert.Equal(t, "flowlogs", source["service"]) + assert.Equal(t, "ocid1.subnet.oc1..example", source["resource"]) + assert.Equal(t, "all", source["category"]) + }) + + t.Run("config with all fields", func(t *testing.T) { + cfg := &logging.Configuration{ + CompartmentId: common.String("ocid1.compartment.oc1..example"), + Source: &logging.OciService{ + Service: common.String("objectstorage"), + Resource: common.String("ocid1.bucket.oc1..example"), + Category: common.String("write"), + }, + } + result, err := convertLogConfiguration(cfg) + require.NoError(t, err) + assert.Equal(t, "ocid1.compartment.oc1..example", result["compartmentId"]) + assert.NotNil(t, result["source"]) + }) +} diff --git a/providers/oci/resources/monitoring.go b/providers/oci/resources/monitoring.go new file mode 100644 index 0000000000..9217945ede --- /dev/null +++ b/providers/oci/resources/monitoring.go @@ -0,0 +1,121 @@ +// Copyright (c) Mondoo, Inc. +// SPDX-License-Identifier: BUSL-1.1 + +package resources + +import ( + "context" + "errors" + + "github.com/oracle/oci-go-sdk/v65/common" + "github.com/oracle/oci-go-sdk/v65/monitoring" + "github.com/rs/zerolog/log" + "go.mondoo.com/mql/v13/llx" + "go.mondoo.com/mql/v13/providers-sdk/v1/util/jobpool" + "go.mondoo.com/mql/v13/providers/oci/connection" + "go.mondoo.com/mql/v13/types" +) + +func (o *mqlOciMonitoring) id() (string, error) { + return "oci.monitoring", nil +} + +func (o *mqlOciMonitoring) alarms() ([]any, error) { + conn := o.MqlRuntime.Connection.(*connection.OciConnection) + + ociResource, err := CreateResource(o.MqlRuntime, "oci", nil) + if err != nil { + return nil, err + } + oci := ociResource.(*mqlOci) + list := oci.GetRegions() + if list.Error != nil { + return nil, list.Error + } + + res := []any{} + poolOfJobs := jobpool.CreatePool(o.getAlarms(conn, list.Data), 5) + poolOfJobs.Run() + + if poolOfJobs.HasErrors() { + return nil, poolOfJobs.GetErrors() + } + for i := range poolOfJobs.Jobs { + res = append(res, poolOfJobs.Jobs[i].Result.([]any)...) + } + + return res, nil +} + +func (o *mqlOciMonitoring) getAlarms(conn *connection.OciConnection, regions []any) []*jobpool.Job { + ctx := context.Background() + tasks := make([]*jobpool.Job, 0) + for _, region := range regions { + regionResource, ok := region.(*mqlOciRegion) + if !ok { + return jobErr(errors.New("invalid region type")) + } + f := func() (jobpool.JobResult, error) { + log.Debug().Msgf("calling oci monitoring with region %s", regionResource.Id.Data) + + svc, err := conn.MonitoringClient(regionResource.Id.Data) + if err != nil { + return nil, err + } + + alarms := []monitoring.AlarmSummary{} + var page *string + for { + response, err := svc.ListAlarms(ctx, monitoring.ListAlarmsRequest{ + CompartmentId: common.String(conn.TenantID()), + Page: page, + }) + if err != nil { + return nil, err + } + + alarms = append(alarms, response.Items...) + + if response.OpcNextPage == nil { + break + } + page = response.OpcNextPage + } + + var res []any + for i := range alarms { + alarm := alarms[i] + + destinations := make([]any, 0, len(alarm.Destinations)) + for _, d := range alarm.Destinations { + destinations = append(destinations, d) + } + + mqlInstance, err := CreateResource(o.MqlRuntime, "oci.monitoring.alarm", map[string]*llx.RawData{ + "id": llx.StringDataPtr(alarm.Id), + "name": llx.StringDataPtr(alarm.DisplayName), + "compartmentID": llx.StringDataPtr(alarm.CompartmentId), + "metricCompartmentId": llx.StringDataPtr(alarm.MetricCompartmentId), + "namespace": llx.StringDataPtr(alarm.Namespace), + "query": llx.StringDataPtr(alarm.Query), + "severity": llx.StringData(string(alarm.Severity)), + "destinations": llx.ArrayData(destinations, types.String), + "isEnabled": llx.BoolDataPtr(alarm.IsEnabled), + "state": llx.StringData(string(alarm.LifecycleState)), + }) + if err != nil { + return nil, err + } + res = append(res, mqlInstance) + } + + return jobpool.JobResult(res), nil + } + tasks = append(tasks, jobpool.NewJob(f)) + } + return tasks +} + +func (o *mqlOciMonitoringAlarm) id() (string, error) { + return "oci.monitoring.alarm/" + o.Id.Data, nil +} diff --git a/providers/oci/resources/network.go b/providers/oci/resources/network.go index b906bbec37..30ee6a0729 100644 --- a/providers/oci/resources/network.go +++ b/providers/oci/resources/network.go @@ -5,12 +5,15 @@ package resources import ( "context" + "errors" + "sync" "time" "github.com/oracle/oci-go-sdk/v65/common" "github.com/oracle/oci-go-sdk/v65/core" "github.com/rs/zerolog/log" "go.mondoo.com/mql/v13/llx" + "go.mondoo.com/mql/v13/providers-sdk/v1/plugin" "go.mondoo.com/mql/v13/providers-sdk/v1/util/convert" "go.mondoo.com/mql/v13/providers-sdk/v1/util/jobpool" "go.mondoo.com/mql/v13/providers/oci/connection" @@ -75,7 +78,7 @@ func (o *mqlOciNetwork) getVcns(conn *connection.OciConnection) []*jobpool.Job { } for _, region := range regions { f := func() (jobpool.JobResult, error) { - log.Debug().Msgf("calling oci with region %s", region) + log.Debug().Msgf("calling oci with region %s", *region.RegionKey) svc, err := conn.NetworkClient(*region.RegionKey) if err != nil { @@ -233,7 +236,7 @@ func (o *mqlOciNetwork) getSecurityLists(conn *connection.OciConnection) []*jobp } for _, region := range regions { f := func() (jobpool.JobResult, error) { - log.Debug().Msgf("calling oci with region %s", region) + log.Debug().Msgf("calling oci with region %s", *region.RegionKey) svc, err := conn.NetworkClient(*region.RegionKey) if err != nil { @@ -317,6 +320,7 @@ func (o *mqlOciNetwork) getSecurityLists(conn *connection.OciConnection) []*jobp if err != nil { return nil, err } + mqlInstance.(*mqlOciNetworkSecurityList).cacheVcnId = stringValue(securityList.VcnId) res = append(res, mqlInstance) } @@ -327,6 +331,413 @@ func (o *mqlOciNetwork) getSecurityLists(conn *connection.OciConnection) []*jobp return tasks } +type mqlOciNetworkSecurityListInternal struct { + cacheVcnId string +} + func (o *mqlOciNetworkSecurityList) id() (string, error) { return "oci.network.securityList/" + o.Id.Data, nil } + +func (o *mqlOciNetworkSecurityList) vcn() (*mqlOciNetworkVcn, error) { + if o.cacheVcnId == "" { + o.Vcn.State = plugin.StateIsSet | plugin.StateIsNull + return nil, nil + } + mqlVcn, err := NewResource(o.MqlRuntime, "oci.network.vcn", map[string]*llx.RawData{ + "id": llx.StringData(o.cacheVcnId), + }) + if err != nil { + return nil, err + } + return mqlVcn.(*mqlOciNetworkVcn), nil +} + +func (o *mqlOciNetwork) subnets() ([]any, error) { + conn := o.MqlRuntime.Connection.(*connection.OciConnection) + + ociResource, err := CreateResource(o.MqlRuntime, "oci", nil) + if err != nil { + return nil, err + } + oci := ociResource.(*mqlOci) + list := oci.GetRegions() + if list.Error != nil { + return nil, list.Error + } + + res := []any{} + poolOfJobs := jobpool.CreatePool(o.getSubnets(conn, list.Data), 5) + poolOfJobs.Run() + + if poolOfJobs.HasErrors() { + return nil, poolOfJobs.GetErrors() + } + for i := range poolOfJobs.Jobs { + res = append(res, poolOfJobs.Jobs[i].Result.([]any)...) + } + + return res, nil +} + +func (o *mqlOciNetwork) getSubnets(conn *connection.OciConnection, regions []any) []*jobpool.Job { + ctx := context.Background() + tasks := make([]*jobpool.Job, 0) + for _, region := range regions { + regionResource, ok := region.(*mqlOciRegion) + if !ok { + return jobErr(errors.New("invalid region type")) + } + f := func() (jobpool.JobResult, error) { + log.Debug().Msgf("calling oci subnets with region %s", regionResource.Id.Data) + + svc, err := conn.NetworkClient(regionResource.Id.Data) + if err != nil { + return nil, err + } + + subnets := []core.Subnet{} + var page *string + for { + response, err := svc.ListSubnets(ctx, core.ListSubnetsRequest{ + CompartmentId: common.String(conn.TenantID()), + Page: page, + }) + if err != nil { + return nil, err + } + + subnets = append(subnets, response.Items...) + + if response.OpcNextPage == nil { + break + } + page = response.OpcNextPage + } + + var res []any + for i := range subnets { + subnet := subnets[i] + + var created *time.Time + if subnet.TimeCreated != nil { + created = &subnet.TimeCreated.Time + } + + freeformTags := make(map[string]interface{}, len(subnet.FreeformTags)) + for k, v := range subnet.FreeformTags { + freeformTags[k] = v + } + + definedTags := make(map[string]interface{}, len(subnet.DefinedTags)) + for k, v := range subnet.DefinedTags { + definedTags[k] = v + } + + mqlInstance, err := CreateResource(o.MqlRuntime, "oci.network.subnet", map[string]*llx.RawData{ + "id": llx.StringDataPtr(subnet.Id), + "name": llx.StringDataPtr(subnet.DisplayName), + "compartmentID": llx.StringDataPtr(subnet.CompartmentId), + "availabilityDomain": llx.StringDataPtr(subnet.AvailabilityDomain), + "cidrBlock": llx.StringDataPtr(subnet.CidrBlock), + "state": llx.StringData(string(subnet.LifecycleState)), + "dnsLabel": llx.StringDataPtr(subnet.DnsLabel), + "subnetDomainName": llx.StringDataPtr(subnet.SubnetDomainName), + "prohibitPublicIpOnVnic": llx.BoolDataPtr(subnet.ProhibitPublicIpOnVnic), + "prohibitInternetIngress": llx.BoolDataPtr(subnet.ProhibitInternetIngress), + "created": llx.TimeDataPtr(created), + "freeformTags": llx.MapData(freeformTags, types.String), + "definedTags": llx.MapData(definedTags, types.Any), + }) + if err != nil { + return nil, err + } + mqlSub := mqlInstance.(*mqlOciNetworkSubnet) + mqlSub.cacheVcnId = stringValue(subnet.VcnId) + res = append(res, mqlSub) + } + + return jobpool.JobResult(res), nil + } + tasks = append(tasks, jobpool.NewJob(f)) + } + return tasks +} + +type mqlOciNetworkSubnetInternal struct { + cacheVcnId string +} + +func (o *mqlOciNetworkSubnet) id() (string, error) { + return "oci.network.subnet/" + o.Id.Data, nil +} + +func (o *mqlOciNetworkSubnet) vcn() (*mqlOciNetworkVcn, error) { + if o.cacheVcnId == "" { + o.Vcn.State = plugin.StateIsSet | plugin.StateIsNull + return nil, nil + } + mqlVcn, err := NewResource(o.MqlRuntime, "oci.network.vcn", map[string]*llx.RawData{ + "id": llx.StringData(o.cacheVcnId), + }) + if err != nil { + return nil, err + } + return mqlVcn.(*mqlOciNetworkVcn), nil +} + +func (o *mqlOciNetwork) networkSecurityGroups() ([]any, error) { + conn := o.MqlRuntime.Connection.(*connection.OciConnection) + + res := []any{} + poolOfJobs := jobpool.CreatePool(o.getNetworkSecurityGroups(conn), 5) + poolOfJobs.Run() + + if poolOfJobs.HasErrors() { + return nil, poolOfJobs.GetErrors() + } + for i := range poolOfJobs.Jobs { + res = append(res, poolOfJobs.Jobs[i].Result.([]any)...) + } + + return res, nil +} + +func (o *mqlOciNetwork) getNSGsForRegion(ctx context.Context, networkClient *core.VirtualNetworkClient, compartmentID string) ([]core.NetworkSecurityGroup, error) { + nsgs := []core.NetworkSecurityGroup{} + var page *string + for { + request := core.ListNetworkSecurityGroupsRequest{ + CompartmentId: common.String(compartmentID), + Page: page, + } + + response, err := networkClient.ListNetworkSecurityGroups(ctx, request) + if err != nil { + return nil, err + } + + nsgs = append(nsgs, response.Items...) + + if response.OpcNextPage == nil { + break + } + + page = response.OpcNextPage + } + + return nsgs, nil +} + +func (o *mqlOciNetwork) getNetworkSecurityGroups(conn *connection.OciConnection) []*jobpool.Job { + ctx := context.Background() + tasks := make([]*jobpool.Job, 0) + regions, err := conn.GetRegions(ctx) + if err != nil { + return []*jobpool.Job{{Err: err}} + } + for _, region := range regions { + f := func() (jobpool.JobResult, error) { + log.Debug().Msgf("calling oci with region %s", *region.RegionKey) + + svc, err := conn.NetworkClient(*region.RegionKey) + if err != nil { + return nil, err + } + + var res []any + nsgs, err := o.getNSGsForRegion(ctx, svc, conn.TenantID()) + if err != nil { + return nil, err + } + + for i := range nsgs { + nsg := nsgs[i] + + var created *time.Time + if nsg.TimeCreated != nil { + created = &nsg.TimeCreated.Time + } + + freeformTags := make(map[string]interface{}) + for k, v := range nsg.FreeformTags { + freeformTags[k] = v + } + + definedTags := make(map[string]interface{}) + for k, v := range nsg.DefinedTags { + definedTags[k] = v + } + + mqlInstance, err := CreateResource(o.MqlRuntime, "oci.network.networkSecurityGroup", map[string]*llx.RawData{ + "id": llx.StringDataPtr(nsg.Id), + "name": llx.StringDataPtr(nsg.DisplayName), + "compartmentID": llx.StringDataPtr(nsg.CompartmentId), + "state": llx.StringData(string(nsg.LifecycleState)), + "created": llx.TimeDataPtr(created), + "freeformTags": llx.MapData(freeformTags, types.String), + "definedTags": llx.MapData(definedTags, types.Any), + }) + if err != nil { + return nil, err + } + mqlNsg := mqlInstance.(*mqlOciNetworkNetworkSecurityGroup) + mqlNsg.region = *region.RegionKey + mqlNsg.cacheVcnId = stringValue(nsg.VcnId) + res = append(res, mqlInstance) + } + + return jobpool.JobResult(res), nil + } + tasks = append(tasks, jobpool.NewJob(f)) + } + return tasks +} + +type mqlOciNetworkNetworkSecurityGroupInternal struct { + region string + cacheVcnId string + fetchLock sync.Mutex + fetched bool +} + +func (o *mqlOciNetworkNetworkSecurityGroup) id() (string, error) { + return "oci.network.networkSecurityGroup/" + o.Id.Data, nil +} + +func (o *mqlOciNetworkNetworkSecurityGroup) vcn() (*mqlOciNetworkVcn, error) { + if o.cacheVcnId == "" { + o.Vcn.State = plugin.StateIsSet | plugin.StateIsNull + return nil, nil + } + mqlVcn, err := NewResource(o.MqlRuntime, "oci.network.vcn", map[string]*llx.RawData{ + "id": llx.StringData(o.cacheVcnId), + }) + if err != nil { + return nil, err + } + return mqlVcn.(*mqlOciNetworkVcn), nil +} + +// NSG security rule for serialization to dict +type nsgSecurityRule struct { + Direction string `json:"direction"` + Protocol string `json:"protocol"` + Description string `json:"description,omitempty"` + Source string `json:"source,omitempty"` + SourceType string `json:"sourceType,omitempty"` + Destination string `json:"destination,omitempty"` + DestinationType string `json:"destinationType,omitempty"` + IsStateless bool `json:"isStateless"` + TcpOptions *core.TcpOptions `json:"tcpOptions,omitempty"` + UdpOptions *core.UdpOptions `json:"udpOptions,omitempty"` + IcmpOptions *core.IcmpOptions `json:"icmpOptions,omitempty"` +} + +func (o *mqlOciNetworkNetworkSecurityGroup) getRulesForNSG(ctx context.Context, networkClient *core.VirtualNetworkClient, nsgId string) ([]core.SecurityRule, error) { + rules := []core.SecurityRule{} + var page *string + for { + request := core.ListNetworkSecurityGroupSecurityRulesRequest{ + NetworkSecurityGroupId: common.String(nsgId), + Page: page, + } + + response, err := networkClient.ListNetworkSecurityGroupSecurityRules(ctx, request) + if err != nil { + return nil, err + } + + rules = append(rules, response.Items...) + + if response.OpcNextPage == nil { + break + } + + page = response.OpcNextPage + } + + return rules, nil +} + +func (o *mqlOciNetworkNetworkSecurityGroup) fetchSecurityRules() (ingress []any, egress []any, err error) { + if o.fetched { + return nil, nil, nil + } + o.fetchLock.Lock() + defer o.fetchLock.Unlock() + if o.fetched { + return nil, nil, nil + } + + conn := o.MqlRuntime.Connection.(*connection.OciConnection) + ctx := context.Background() + + svc, err := conn.NetworkClient(o.region) + if err != nil { + return nil, nil, err + } + + rules, err := o.getRulesForNSG(ctx, svc, o.Id.Data) + if err != nil { + return nil, nil, err + } + + ingressRules := []nsgSecurityRule{} + egressRules := []nsgSecurityRule{} + + for i := range rules { + rule := rules[i] + r := nsgSecurityRule{ + Direction: string(rule.Direction), + Protocol: stringValue(rule.Protocol), + Description: stringValue(rule.Description), + Source: stringValue(rule.Source), + SourceType: string(rule.SourceType), + Destination: stringValue(rule.Destination), + DestinationType: string(rule.DestinationType), + IsStateless: boolValue(rule.IsStateless), + TcpOptions: rule.TcpOptions, + UdpOptions: rule.UdpOptions, + IcmpOptions: rule.IcmpOptions, + } + + if rule.Direction == core.SecurityRuleDirectionIngress { + ingressRules = append(ingressRules, r) + } else { + egressRules = append(egressRules, r) + } + } + + ingress, err = convert.JsonToDictSlice(ingressRules) + if err != nil { + return nil, nil, err + } + + egress, err = convert.JsonToDictSlice(egressRules) + if err != nil { + return nil, nil, err + } + + o.IngressSecurityRules = plugin.TValue[[]any]{Data: ingress, State: plugin.StateIsSet} + o.EgressSecurityRules = plugin.TValue[[]any]{Data: egress, State: plugin.StateIsSet} + o.fetched = true + + return ingress, egress, nil +} + +func (o *mqlOciNetworkNetworkSecurityGroup) ingressSecurityRules() ([]any, error) { + _, _, err := o.fetchSecurityRules() + if err != nil { + return nil, err + } + return o.IngressSecurityRules.Data, nil +} + +func (o *mqlOciNetworkNetworkSecurityGroup) egressSecurityRules() ([]any, error) { + _, _, err := o.fetchSecurityRules() + if err != nil { + return nil, err + } + return o.EgressSecurityRules.Data, nil +} diff --git a/providers/oci/resources/networkfirewall.go b/providers/oci/resources/networkfirewall.go new file mode 100644 index 0000000000..b04125d508 --- /dev/null +++ b/providers/oci/resources/networkfirewall.go @@ -0,0 +1,309 @@ +// Copyright (c) Mondoo, Inc. +// SPDX-License-Identifier: BUSL-1.1 + +package resources + +import ( + "context" + "errors" + "sync" + "time" + + "github.com/oracle/oci-go-sdk/v65/common" + "github.com/oracle/oci-go-sdk/v65/networkfirewall" + "github.com/rs/zerolog/log" + "go.mondoo.com/mql/v13/llx" + "go.mondoo.com/mql/v13/providers-sdk/v1/plugin" + "go.mondoo.com/mql/v13/providers-sdk/v1/util/jobpool" + "go.mondoo.com/mql/v13/providers/oci/connection" +) + +func (o *mqlOciNetworkFirewall) id() (string, error) { + return "oci.networkFirewall", nil +} + +func (o *mqlOciNetworkFirewall) firewalls() ([]any, error) { + conn := o.MqlRuntime.Connection.(*connection.OciConnection) + + ociResource, err := CreateResource(o.MqlRuntime, "oci", nil) + if err != nil { + return nil, err + } + oci := ociResource.(*mqlOci) + list := oci.GetRegions() + if list.Error != nil { + return nil, list.Error + } + + res := []any{} + poolOfJobs := jobpool.CreatePool(o.getFirewalls(conn, list.Data), 5) + poolOfJobs.Run() + + if poolOfJobs.HasErrors() { + return nil, poolOfJobs.GetErrors() + } + for i := range poolOfJobs.Jobs { + res = append(res, poolOfJobs.Jobs[i].Result.([]any)...) + } + + return res, nil +} + +func (o *mqlOciNetworkFirewall) getFirewalls(conn *connection.OciConnection, regions []any) []*jobpool.Job { + ctx := context.Background() + tasks := make([]*jobpool.Job, 0) + for _, region := range regions { + regionResource, ok := region.(*mqlOciRegion) + if !ok { + return jobErr(errors.New("invalid region type")) + } + f := func() (jobpool.JobResult, error) { + log.Debug().Msgf("calling oci network firewall with region %s", regionResource.Id.Data) + + svc, err := conn.NetworkFirewallClient(regionResource.Id.Data) + if err != nil { + return nil, err + } + + firewalls := []networkfirewall.NetworkFirewallSummary{} + var page *string + for { + response, err := svc.ListNetworkFirewalls(ctx, networkfirewall.ListNetworkFirewallsRequest{ + CompartmentId: common.String(conn.TenantID()), + Page: page, + }) + if err != nil { + return nil, err + } + + firewalls = append(firewalls, response.Items...) + + if response.OpcNextPage == nil { + break + } + page = response.OpcNextPage + } + + var res []any + for i := range firewalls { + fw := firewalls[i] + + var created *time.Time + if fw.TimeCreated != nil { + created = &fw.TimeCreated.Time + } + var timeUpdated *time.Time + if fw.TimeUpdated != nil { + timeUpdated = &fw.TimeUpdated.Time + } + + mqlInstance, err := CreateResource(o.MqlRuntime, "oci.networkFirewall.firewall", map[string]*llx.RawData{ + "id": llx.StringDataPtr(fw.Id), + "name": llx.StringDataPtr(fw.DisplayName), + "compartmentID": llx.StringDataPtr(fw.CompartmentId), + "ipv4Address": llx.StringDataPtr(fw.Ipv4Address), + "ipv6Address": llx.StringDataPtr(fw.Ipv6Address), + "shape": llx.StringDataPtr(fw.Shape), + "state": llx.StringData(string(fw.LifecycleState)), + "created": llx.TimeDataPtr(created), + "timeUpdated": llx.TimeDataPtr(timeUpdated), + }) + if err != nil { + return nil, err + } + mqlFw := mqlInstance.(*mqlOciNetworkFirewallFirewall) + mqlFw.cacheSubnetId = stringValue(fw.SubnetId) + mqlFw.cachePolicyId = stringValue(fw.NetworkFirewallPolicyId) + res = append(res, mqlFw) + } + + return jobpool.JobResult(res), nil + } + tasks = append(tasks, jobpool.NewJob(f)) + } + return tasks +} + +type mqlOciNetworkFirewallFirewallInternal struct { + cacheSubnetId string + cachePolicyId string +} + +func (o *mqlOciNetworkFirewallFirewall) id() (string, error) { + return "oci.networkFirewall.firewall/" + o.Id.Data, nil +} + +func (o *mqlOciNetworkFirewallFirewall) subnet() (*mqlOciNetworkSubnet, error) { + if o.cacheSubnetId == "" { + o.Subnet.State = plugin.StateIsSet | plugin.StateIsNull + return nil, nil + } + mqlSubnet, err := NewResource(o.MqlRuntime, "oci.network.subnet", map[string]*llx.RawData{ + "id": llx.StringData(o.cacheSubnetId), + }) + if err != nil { + return nil, err + } + return mqlSubnet.(*mqlOciNetworkSubnet), nil +} + +func (o *mqlOciNetworkFirewallFirewall) policy() (*mqlOciNetworkFirewallPolicy, error) { + if o.cachePolicyId == "" { + o.Policy.State = plugin.StateIsSet | plugin.StateIsNull + return nil, nil + } + mqlPolicy, err := NewResource(o.MqlRuntime, "oci.networkFirewall.policy", map[string]*llx.RawData{ + "id": llx.StringData(o.cachePolicyId), + }) + if err != nil { + return nil, err + } + return mqlPolicy.(*mqlOciNetworkFirewallPolicy), nil +} + +func (o *mqlOciNetworkFirewall) policies() ([]any, error) { + conn := o.MqlRuntime.Connection.(*connection.OciConnection) + + ociResource, err := CreateResource(o.MqlRuntime, "oci", nil) + if err != nil { + return nil, err + } + oci := ociResource.(*mqlOci) + list := oci.GetRegions() + if list.Error != nil { + return nil, list.Error + } + + res := []any{} + poolOfJobs := jobpool.CreatePool(o.getPolicies(conn, list.Data), 5) + poolOfJobs.Run() + + if poolOfJobs.HasErrors() { + return nil, poolOfJobs.GetErrors() + } + for i := range poolOfJobs.Jobs { + res = append(res, poolOfJobs.Jobs[i].Result.([]any)...) + } + + return res, nil +} + +func (o *mqlOciNetworkFirewall) getPolicies(conn *connection.OciConnection, regions []any) []*jobpool.Job { + ctx := context.Background() + tasks := make([]*jobpool.Job, 0) + for _, region := range regions { + regionResource, ok := region.(*mqlOciRegion) + if !ok { + return jobErr(errors.New("invalid region type")) + } + f := func() (jobpool.JobResult, error) { + log.Debug().Msgf("calling oci network firewall policies with region %s", regionResource.Id.Data) + + svc, err := conn.NetworkFirewallClient(regionResource.Id.Data) + if err != nil { + return nil, err + } + + policies := []networkfirewall.NetworkFirewallPolicySummary{} + var page *string + for { + response, err := svc.ListNetworkFirewallPolicies(ctx, networkfirewall.ListNetworkFirewallPoliciesRequest{ + CompartmentId: common.String(conn.TenantID()), + Page: page, + }) + if err != nil { + return nil, err + } + + policies = append(policies, response.Items...) + + if response.OpcNextPage == nil { + break + } + page = response.OpcNextPage + } + + var res []any + for i := range policies { + p := policies[i] + + var created *time.Time + if p.TimeCreated != nil { + created = &p.TimeCreated.Time + } + + mqlInstance, err := CreateResource(o.MqlRuntime, "oci.networkFirewall.policy", map[string]*llx.RawData{ + "id": llx.StringDataPtr(p.Id), + "name": llx.StringDataPtr(p.DisplayName), + "compartmentID": llx.StringDataPtr(p.CompartmentId), + "state": llx.StringData(string(p.LifecycleState)), + "created": llx.TimeDataPtr(created), + }) + if err != nil { + return nil, err + } + mqlInstance.(*mqlOciNetworkFirewallPolicy).region = regionResource.Id.Data + res = append(res, mqlInstance) + } + + return jobpool.JobResult(res), nil + } + tasks = append(tasks, jobpool.NewJob(f)) + } + return tasks +} + +type mqlOciNetworkFirewallPolicyInternal struct { + region string + fetched bool + detail *networkfirewall.NetworkFirewallPolicy + fetchLock sync.Mutex +} + +func (o *mqlOciNetworkFirewallPolicy) fetchDetail() (*networkfirewall.NetworkFirewallPolicy, error) { + if o.fetched { + return o.detail, nil + } + o.fetchLock.Lock() + defer o.fetchLock.Unlock() + if o.fetched { + return o.detail, nil + } + conn := o.MqlRuntime.Connection.(*connection.OciConnection) + svc, err := conn.NetworkFirewallClient(o.region) + if err != nil { + return nil, err + } + resp, err := svc.GetNetworkFirewallPolicy(context.Background(), networkfirewall.GetNetworkFirewallPolicyRequest{ + NetworkFirewallPolicyId: common.String(o.Id.Data), + }) + if err != nil { + return nil, err + } + o.detail = &resp.NetworkFirewallPolicy + o.fetched = true + return o.detail, nil +} + +func (o *mqlOciNetworkFirewallPolicy) description() (string, error) { + detail, err := o.fetchDetail() + if err != nil { + return "", err + } + return stringValue(detail.Description), nil +} + +func (o *mqlOciNetworkFirewallPolicy) attachedFirewallCount() (int64, error) { + detail, err := o.fetchDetail() + if err != nil { + return 0, err + } + if detail.AttachedNetworkFirewallCount == nil { + return 0, nil + } + return int64(*detail.AttachedNetworkFirewallCount), nil +} + +func (o *mqlOciNetworkFirewallPolicy) id() (string, error) { + return "oci.networkFirewall.policy/" + o.Id.Data, nil +} diff --git a/providers/oci/resources/oci.lr b/providers/oci/resources/oci.lr index 450b1c0486..d6289a311e 100644 --- a/providers/oci/resources/oci.lr +++ b/providers/oci/resources/oci.lr @@ -190,6 +190,10 @@ oci.compute { instances() []oci.compute.instance // Compute images images() []oci.compute.image + // Block volumes + blockVolumes() []oci.compute.blockVolume + // Boot volumes + bootVolumes() []oci.compute.bootVolume } // Oracle Cloud Infrastructure (OCI) Compute instance @@ -202,7 +206,7 @@ private oci.compute.instance @defaults("name") { region oci.region // Instance creation time created time - // Instance lifecycle state (MOVING, PROVISIONING, RUNNING, STARTING, STOPPING, STOPPED, CREATING_IMAGE, TERMINATING, TERMINATED) + // Instance lifecycle state (e.g., MOVING, PROVISIONING, RUNNING, STARTING, STOPPING, STOPPED, CREATING_IMAGE, TERMINATING, TERMINATED) state string // Compute shape determining CPU and memory (e.g., VM.Standard2.1) shape string @@ -216,6 +220,20 @@ private oci.compute.instance @defaults("name") { imageId string // Dedicated VM host OCID if running on dedicated infrastructure dedicatedVmHostId string + // Platform security configuration (Secure Boot, TPM, Measured Boot, memory encryption) + platformConfig dict + // Launch configuration options (boot volume type, firmware, network type, encryption) + launchOptions dict + // Instance runtime options (legacy IMDS endpoint configuration) + instanceOptions dict + // Shape configuration details (OCPUs, memory, GPUs) + shapeConfig dict + // Boot volume or image source details + sourceDetails dict + // Instance metadata key-value pairs + metadata map[string]string + // Expected maintenance reboot time, if scheduled + timeMaintenanceRebootDue time // Free-form tags for resource management freeformTags map[string]string // Defined tags for governance and cost tracking @@ -232,7 +250,7 @@ private oci.compute.image @defaults("name") { region oci.region // Image creation time created time - // Image lifecycle state (PROVISIONING, IMPORTING, AVAILABLE, EXPORTING, DISABLED, DELETED) + // Image lifecycle state (e.g., PROVISIONING, IMPORTING, AVAILABLE, EXPORTING, DISABLED, DELETED) state string // Compartment containing the image compartment oci.compartment @@ -248,12 +266,64 @@ private oci.compute.image @defaults("name") { definedTags map[string]map[string]string } +// Oracle Cloud Infrastructure (OCI) block volume +private oci.compute.blockVolume @defaults("name") { + // Block volume OCID + id string + // Block volume display name + name string + // Compartment OCID containing the block volume + compartmentID string + // Availability domain where the block volume is located + availabilityDomain string + // Size of the block volume in GBs + sizeInGBs int + // Volume performance units per GB + vpusPerGB int + // Block volume lifecycle state (e.g., PROVISIONING, RESTORING, AVAILABLE, TERMINATING, TERMINATED, FAULTY) + state string + // Whether the cloned volume's data has finished copying from the source + isHydrated bool + // KMS key for volume encryption + kmsKey() oci.kms.key + // Whether auto-tune performance is enabled + isAutoTuneEnabled bool + // Block volume creation time + created time +} + +// Oracle Cloud Infrastructure (OCI) boot volume +private oci.compute.bootVolume @defaults("name") { + // Boot volume OCID + id string + // Boot volume display name + name string + // Compartment OCID containing the boot volume + compartmentID string + // Availability domain where the boot volume is located + availabilityDomain string + // Size of the boot volume in GBs + sizeInGBs int + // Image OCID used to create the boot volume + imageId string + // Boot volume lifecycle state (e.g., PROVISIONING, RESTORING, AVAILABLE, TERMINATING, TERMINATED, FAULTY) + state string + // KMS key for volume encryption + kmsKey() oci.kms.key + // Boot volume creation time + created time +} + // Oracle Cloud Infrastructure (OCI) Networking service oci.network { // Virtual Cloud Networks (VCNs) vcns() []oci.network.vcn + // Subnets + subnets() []oci.network.subnet // VCN security lists securityLists() []oci.network.securityList + // Network Security Groups (NSGs) + networkSecurityGroups() []oci.network.networkSecurityGroup } // Oracle Cloud Infrastructure (OCI) Virtual Cloud Network (VCN) @@ -266,7 +336,7 @@ private oci.network.vcn @defaults("name") { name string // VCN creation time created time - // VCN lifecycle state (PROVISIONING, AVAILABLE, UPDATING, TERMINATING, TERMINATED) + // VCN lifecycle state (e.g., PROVISIONING, AVAILABLE, TERMINATING, TERMINATED, UPDATING) state string // Deprecated: Use cidrBlocks instead cidrBlock string @@ -288,6 +358,38 @@ private oci.network.vcn @defaults("name") { definedTags map[string]map[string]string } +// Oracle Cloud Infrastructure (OCI) network subnet +private oci.network.subnet @defaults("name") { + // Subnet OCID + id string + // Subnet display name + name string + // Compartment OCID containing the subnet + compartmentID string + // VCN the subnet belongs to + vcn() oci.network.vcn + // Availability domain (regional subnets have no AD) + availabilityDomain string + // IPv4 CIDR block for the subnet + cidrBlock string + // Subnet lifecycle state (e.g., PROVISIONING, AVAILABLE, TERMINATING, TERMINATED, UPDATING) + state string + // DNS label for the subnet + dnsLabel string + // Subnet domain name for DNS resolution + subnetDomainName string + // Whether public IP assignment on VNICs is prohibited + prohibitPublicIpOnVnic bool + // Whether internet ingress is prohibited + prohibitInternetIngress bool + // Subnet creation time + created time + // Free-form tags for resource management + freeformTags map[string]string + // Defined tags for governance and cost tracking + definedTags map[string]map[string]string +} + // Oracle Cloud Infrastructure (OCI) VCN security list (virtual firewall rules) private oci.network.securityList @defaults("name") { // Security list OCID @@ -298,18 +400,140 @@ private oci.network.securityList @defaults("name") { name string // Security list creation time created time - // Security list lifecycle state (PROVISIONING, AVAILABLE, TERMINATING, TERMINATED) + // Security list lifecycle state (e.g., PROVISIONING, AVAILABLE, TERMINATING, TERMINATED) state string // Egress security rules for outbound traffic egressSecurityRules []dict // Ingress security rules for inbound traffic ingressSecurityRules []dict - // VCN OCID that this security list belongs to + // Deprecated: Use vcn() instead vcnId string + // VCN that this security list belongs to + vcn() oci.network.vcn + // Free-form tags for resource management + freeformTags map[string]string + // Defined tags for governance and cost tracking + definedTags map[string]map[string]string +} + +// Oracle Cloud Infrastructure (OCI) Network Security Group (virtual firewall rules for VNICs) +private oci.network.networkSecurityGroup @defaults("name") { + // NSG OCID + id string + // NSG display name + name string + // Compartment OCID containing the NSG + compartmentID string + // VCN the NSG belongs to + vcn() oci.network.vcn + // NSG lifecycle state (e.g., PROVISIONING, AVAILABLE, TERMINATING, TERMINATED) + state string + // NSG creation time + created time // Free-form tags for resource management freeformTags map[string]string // Defined tags for governance and cost tracking definedTags map[string]map[string]string + // Ingress security rules + ingressSecurityRules() []dict + // Egress security rules + egressSecurityRules() []dict +} + +// Oracle Cloud Infrastructure (OCI) Logging service +oci.logging { + // Log groups in the tenancy + logGroups() []oci.logging.logGroup +} + +// Oracle Cloud Infrastructure (OCI) log group +private oci.logging.logGroup @defaults("name") { + // Log group OCID + id string + // Display name + name string + // Log group description + description string + // Compartment OCID + compartmentID string + // Lifecycle state (e.g., CREATING, ACTIVE, UPDATING, INACTIVE, DELETING, FAILED) + state string + // Logs in the group + logs() []oci.logging.log + // Creation time + created time +} + +// Oracle Cloud Infrastructure (OCI) log +private oci.logging.log @defaults("name") { + // Log OCID + id string + // Display name + name string + // Log type (SERVICE, CUSTOM) + logType string + // Parent log group + logGroup() oci.logging.logGroup + // Whether the log is enabled + isEnabled bool + // Lifecycle state (e.g., CREATING, ACTIVE, UPDATING, INACTIVE, DELETING, FAILED) + state string + // Retention duration in days + retentionDuration int + // Log configuration (source type, category, resource) + configuration dict + // Creation time + created time + // Last modification time + timeLastModified time +} + +// Oracle Cloud Infrastructure (OCI) Key Management service +oci.kms { + // Key vaults in the tenancy + vaults() []oci.kms.vault +} + +// Oracle Cloud Infrastructure (OCI) KMS vault +private oci.kms.vault @defaults("name") { + // Vault OCID + id string + // Display name + name string + // Compartment OCID + compartmentID string + // Vault type (DEFAULT, VIRTUAL_PRIVATE, EXTERNAL) + vaultType string + // Lifecycle state (e.g., CREATING, ACTIVE, DELETING, DELETED, PENDING_DELETION, SCHEDULING_DELETION, CANCELLING_DELETION, UPDATING, BACKUP_IN_PROGRESS, RESTORING) + state string + // Vault management endpoint + managementEndpoint string + // Keys in the vault + keys() []oci.kms.key + // Creation time + created time +} + +// Oracle Cloud Infrastructure (OCI) KMS key +private oci.kms.key @defaults("name") { + // Key OCID + id string + // Display name + name string + // Compartment OCID + compartmentID string + // Parent vault OCID + vaultId string + // Key algorithm (AES, RSA, ECDSA) + algorithm string + // Protection mode (HSM, SOFTWARE, EXTERNAL) + protectionMode string + // Lifecycle state (e.g., CREATING, ENABLING, ENABLED, DISABLING, DISABLED, DELETING, DELETED, PENDING_DELETION, SCHEDULING_DELETION, CANCELLING_DELETION, UPDATING, BACKUP_IN_PROGRESS, RESTORING) + state string + // Whether auto key rotation is enabled + isAutoRotationEnabled bool + // Creation time + created time } // Oracle Cloud Infrastructure (OCI) Object Storage service @@ -356,8 +580,436 @@ private oci.objectStorage.bucket { approximateCount() int // Approximate total size of objects in bytes approximateSize() int + // Object lifecycle policy ETag + objectLifecyclePolicyEtag() string // Free-form tags for resource management freeformTags() map[string]string // Defined tags for governance and cost tracking definedTags() map[string]map[string]string } + +// Oracle Cloud Infrastructure (OCI) File Storage service +oci.fileStorage { + // File systems + fileSystems() []oci.fileStorage.fileSystem +} + +// Oracle Cloud Infrastructure (OCI) file system +private oci.fileStorage.fileSystem @defaults("name") { + // File system OCID + id string + // File system display name + name string + // Compartment OCID containing the file system + compartmentID string + // Availability domain where the file system is located + availabilityDomain string + // File system lifecycle state (e.g., CREATING, ACTIVE, UPDATING, DELETING, DELETED, FAILED) + state string + // KMS key for file system encryption + kmsKey() oci.kms.key + // Number of bytes consumed by the file system including snapshots + meteredBytes int + // File system creation time + created time +} + +// Oracle Cloud Infrastructure (OCI) Events service +oci.events { + // Event rules + rules() []oci.events.rule +} + +// Oracle Cloud Infrastructure (OCI) event rule +private oci.events.rule @defaults("name") { + // Rule OCID + id string + // Rule display name + name string + // Rule description + description string + // Compartment OCID containing the rule + compartmentID string + // Event matching condition (JSON) + condition string + // Whether the rule is enabled + isEnabled bool + // Rule lifecycle state (e.g., CREATING, ACTIVE, INACTIVE, UPDATING, DELETING, DELETED, FAILED) + state string + // Actions to perform when the rule matches an event + actions() []dict + // Rule creation time + created time +} + +// Oracle Cloud Infrastructure (OCI) Cloud Guard threat detection and security monitoring +oci.cloudGuard { + // Whether Cloud Guard is enabled + status() bool + // Region where Cloud Guard reports findings + reportingRegion() string + // Whether Cloud Guard resources are self-managed + selfManageResources() bool + // Cloud Guard targets (monitored compartments/resources) + targets() []oci.cloudGuard.target + // Cloud Guard detector recipes + detectorRecipes() []oci.cloudGuard.detectorRecipe +} + +// Oracle Cloud Infrastructure (OCI) Cloud Guard target +private oci.cloudGuard.target @defaults("name") { + // Target OCID + id string + // Target display name + name string + // Compartment OCID containing the target + compartmentID string + // OCID of the resource being monitored + targetResourceId string + // Type of resource being monitored (e.g., COMPARTMENT, ERPCLOUD, HCMCLOUD, SECURITY_ZONE) + targetResourceType string + // Target lifecycle state (e.g., CREATING, UPDATING, ACTIVE, INACTIVE, DELETING, DELETED, FAILED) + state string + // Number of detector recipes attached to the target + recipeCount int + // Target creation time + created time +} + +// Oracle Cloud Infrastructure (OCI) Cloud Guard detector recipe +private oci.cloudGuard.detectorRecipe @defaults("name") { + // Detector recipe OCID + id string + // Detector recipe display name + name string + // Detector recipe description + description string + // Owner of the detector recipe (CUSTOMER or ORACLE) + owner string + // Type of detector (e.g., IAAS_ACTIVITY_DETECTOR, IAAS_CONFIGURATION_DETECTOR, IAAS_THREAT_DETECTOR, IAAS_LOG_INSIGHT_DETECTOR, IAAS_INSTANCE_SECURITY_DETECTOR, IAAS_CONTAINER_SECURITY_DETECTOR) + detectorType string + // Detector recipe lifecycle state (e.g., CREATING, UPDATING, ACTIVE, INACTIVE, DELETING, DELETED, FAILED) + state string + // Detector recipe creation time + created time +} + +// Oracle Cloud Infrastructure (OCI) Notifications (ONS) service +oci.ons { + // Notification topics + topics() []oci.ons.topic +} + +// Oracle Cloud Infrastructure (OCI) notification topic +private oci.ons.topic @defaults("name") { + // Topic OCID + id string + // Topic name + name string + // Topic description + description string + // Compartment OCID containing the topic + compartmentID string + // Topic lifecycle state (e.g., ACTIVE, DELETING, CREATING) + state string + // Topic creation time + created time + // Topic subscriptions + subscriptions() []oci.ons.subscription +} + +// Oracle Cloud Infrastructure (OCI) notification subscription +private oci.ons.subscription @defaults("id") { + // Subscription OCID + id string + // Topic the subscription belongs to + topic() oci.ons.topic + // Delivery protocol (EMAIL, HTTPS, SLACK, etc.) + protocol string + // Delivery endpoint + endpoint string + // Subscription lifecycle state (e.g., PENDING, ACTIVE, DELETED) + state string + // Subscription creation time + created time +} + +// Oracle Cloud Infrastructure (OCI) Audit service +oci.audit { + // Audit log retention period in days + retentionPeriodDays() int +} + +// Oracle Cloud Infrastructure (OCI) Bastion service +oci.bastion { + // Bastion instances + bastions() []oci.bastion.instance +} + +// Oracle Cloud Infrastructure (OCI) bastion instance +private oci.bastion.instance @defaults("name") { + // Bastion OCID + id string + // Bastion display name + name string + // Compartment OCID + compartmentID string + // Bastion type (e.g., standard) + bastionType string + // Target VCN + targetVcn() oci.network.vcn + // Target subnet + targetSubnet() oci.network.subnet + // Lifecycle state (e.g., CREATING, ACTIVE, UPDATING, DELETING, DELETED, FAILED) + state string + // DNS proxy status (DISABLED, ENABLED) + dnsProxyStatus string + // Creation time + created time + // Last update time + timeUpdated time +} + +// Oracle Cloud Infrastructure (OCI) Monitoring service +oci.monitoring { + // Monitoring alarm definitions + alarms() []oci.monitoring.alarm +} + +// Oracle Cloud Infrastructure (OCI) monitoring alarm +private oci.monitoring.alarm @defaults("name") { + // Alarm OCID + id string + // Alarm display name + name string + // Compartment OCID + compartmentID string + // Metric compartment OCID being monitored + metricCompartmentId string + // Metric namespace (e.g., oci_computeagent, oci_vcn) + namespace string + // Monitoring Query Language (MQL) expression + query string + // Alarm severity (CRITICAL, ERROR, WARNING, INFO) + severity string + // List of notification destination OCIDs (ONS topics) + destinations []string + // Whether the alarm is enabled + isEnabled bool + // Lifecycle state (e.g., ACTIVE, DELETING, DELETED) + state string +} + +// Oracle Cloud Infrastructure (OCI) Vault secrets service +oci.vault { + // Secrets stored in vaults + secrets() []oci.vault.secret +} + +// Oracle Cloud Infrastructure (OCI) vault secret +private oci.vault.secret @defaults("name") { + // Secret OCID + id string + // Secret name + name string + // Compartment OCID + compartmentID string + // Vault containing this secret + kmsVault() oci.kms.vault + // KMS key used for encryption + kmsKey() oci.kms.key + // Secret description + description string + // Lifecycle state (e.g., CREATING, ACTIVE, UPDATING, DELETING, DELETED, SCHEDULING_DELETION, PENDING_DELETION, CANCELLING_DELETION, FAILED) + state string + // Rotation status (NOT_ENABLED, CANCELLING, ROTATING) + rotationStatus string + // Last rotation time + lastRotationTime time + // Next scheduled rotation time + nextRotationTime time + // Whether auto generation is enabled + isAutoGenerationEnabled bool + // Creation time + created time +} + +// Oracle Cloud Infrastructure (OCI) Load Balancer service +oci.loadBalancer { + // Load balancers + loadBalancers() []oci.loadBalancer.loadBalancer +} + +// Oracle Cloud Infrastructure (OCI) load balancer +private oci.loadBalancer.loadBalancer @defaults("name") { + // Load balancer OCID + id string + // Display name + name string + // Compartment OCID + compartmentID string + // Shape name (e.g., flexible, 100Mbps, 400Mbps) + shape string + // Whether the load balancer is private (no public IP) + isPrivate bool + // Whether delete protection is enabled + isDeleteProtectionEnabled bool + // Lifecycle state (e.g., CREATING, ACTIVE, FAILED, DELETING, DELETED) + state string + // Load balancer listeners + listeners() []oci.loadBalancer.listener + // Backend sets + backendSets() []oci.loadBalancer.backendSet + // Creation time + created time +} + +// Oracle Cloud Infrastructure (OCI) load balancer listener +private oci.loadBalancer.listener @defaults("name") { + // Listener name + id string + // Listener name + name string + // Listener port + port int + // Protocol (HTTP, HTTPS, HTTP2, TCP, GRPC) + protocol string + // Default backend set name + defaultBackendSetName string + // SSL/TLS protocols enabled (e.g., TLSv1.2, TLSv1.3) + sslProtocols []string + // SSL cipher suite name + sslCipherSuiteName string + // Whether peer certificate verification is enabled + sslVerifyPeerCertificate bool +} + +// Oracle Cloud Infrastructure (OCI) load balancer backend set +private oci.loadBalancer.backendSet @defaults("name") { + // Backend set name + id string + // Backend set name + name string + // Load balancing policy (ROUND_ROBIN, LEAST_CONNECTIONS, IP_HASH) + policy string + // Health checker configuration + healthChecker dict + // Number of backends + backendCount int +} + +// Oracle Cloud Infrastructure (OCI) Network Firewall service +oci.networkFirewall { + // Network firewalls + firewalls() []oci.networkFirewall.firewall + // Network firewall policies + policies() []oci.networkFirewall.policy +} + +// Oracle Cloud Infrastructure (OCI) network firewall +private oci.networkFirewall.firewall @defaults("name") { + // Firewall OCID + id string + // Display name + name string + // Compartment OCID + compartmentID string + // Subnet the firewall is deployed in + subnet() oci.network.subnet + // Firewall policy + policy() oci.networkFirewall.policy + // IPv4 address + ipv4Address string + // IPv6 address + ipv6Address string + // Firewall shape + shape string + // Lifecycle state (e.g., CREATING, UPDATING, ACTIVE, DELETING, DELETED, FAILED) + state string + // Creation time + created time + // Last update time + timeUpdated time +} + +// Oracle Cloud Infrastructure (OCI) network firewall policy +private oci.networkFirewall.policy @defaults("name") { + // Policy OCID + id string + // Display name + name string + // Compartment OCID + compartmentID string + // Policy description + description() string + // Number of firewalls attached to this policy + attachedFirewallCount() int + // Lifecycle state (e.g., CREATING, UPDATING, ACTIVE, DELETING, DELETED, FAILED) + state string + // Creation time + created time +} + +// Oracle Cloud Infrastructure (OCI) Container Engine for Kubernetes (OKE) +oci.oke { + // OKE clusters + clusters() []oci.oke.cluster +} + +// Oracle Cloud Infrastructure (OCI) OKE cluster +private oci.oke.cluster @defaults("name") { + // Cluster OCID + id string + // Cluster name + name string + // Compartment OCID + compartmentID string + // Kubernetes version + kubernetesVersion string + // Cluster type (BASIC_CLUSTER, ENHANCED_CLUSTER) + type string + // VCN the cluster is deployed in + vcn() oci.network.vcn + // KMS key for secret encryption + kmsKey() oci.kms.key + // Whether the Kubernetes API endpoint is publicly accessible + isPublicEndpointEnabled bool + // Public API endpoint URL + publicEndpoint string + // Private API endpoint URL + privateEndpoint string + // Whether image signature verification policy is enabled + isImagePolicyEnabled bool + // Available Kubernetes version upgrades + availableKubernetesUpgrades []string + // Whether Pod Security Policy admission controller is enabled + isPodSecurityPolicyEnabled bool + // Lifecycle state (e.g., CREATING, ACTIVE, FAILED, DELETING, DELETED, UPDATING) + state string + // Node pools in the cluster + nodePools() []oci.oke.nodePool + // Creation time + created time +} + +// Oracle Cloud Infrastructure (OCI) OKE node pool +private oci.oke.nodePool @defaults("name") { + // Node pool OCID + id string + // Node pool name + name string + // Compartment OCID + compartmentID string + // Kubernetes version on nodes + kubernetesVersion string + // Compute shape for nodes + nodeShape string + // Node shape configuration (OCPUs, memory) + nodeShapeConfig dict + // Node image name + nodeImageName string + // SSH public key on nodes (should be empty for security) + sshPublicKey string + // Lifecycle state (e.g., CREATING, ACTIVE, UPDATING, DELETING, DELETED, FAILED, NEEDS_ATTENTION) + state string +} diff --git a/providers/oci/resources/oci.lr.go b/providers/oci/resources/oci.lr.go index 3a13eeda6a..fa83a4b271 100644 --- a/providers/oci/resources/oci.lr.go +++ b/providers/oci/resources/oci.lr.go @@ -17,25 +17,62 @@ import ( // The MQL type names exposed as public consts for ease of reference. const ( - ResourceOci string = "oci" - ResourceOciTenancy string = "oci.tenancy" - ResourceOciRegion string = "oci.region" - ResourceOciCompartment string = "oci.compartment" - ResourceOciIdentity string = "oci.identity" - ResourceOciIdentityUser string = "oci.identity.user" - ResourceOciIdentityApiKey string = "oci.identity.apiKey" - ResourceOciIdentityCustomerSecretKey string = "oci.identity.customerSecretKey" - ResourceOciIdentityAuthToken string = "oci.identity.authToken" - ResourceOciIdentityGroup string = "oci.identity.group" - ResourceOciIdentityPolicy string = "oci.identity.policy" - ResourceOciCompute string = "oci.compute" - ResourceOciComputeInstance string = "oci.compute.instance" - ResourceOciComputeImage string = "oci.compute.image" - ResourceOciNetwork string = "oci.network" - ResourceOciNetworkVcn string = "oci.network.vcn" - ResourceOciNetworkSecurityList string = "oci.network.securityList" - ResourceOciObjectStorage string = "oci.objectStorage" - ResourceOciObjectStorageBucket string = "oci.objectStorage.bucket" + ResourceOci string = "oci" + ResourceOciTenancy string = "oci.tenancy" + ResourceOciRegion string = "oci.region" + ResourceOciCompartment string = "oci.compartment" + ResourceOciIdentity string = "oci.identity" + ResourceOciIdentityUser string = "oci.identity.user" + ResourceOciIdentityApiKey string = "oci.identity.apiKey" + ResourceOciIdentityCustomerSecretKey string = "oci.identity.customerSecretKey" + ResourceOciIdentityAuthToken string = "oci.identity.authToken" + ResourceOciIdentityGroup string = "oci.identity.group" + ResourceOciIdentityPolicy string = "oci.identity.policy" + ResourceOciCompute string = "oci.compute" + ResourceOciComputeInstance string = "oci.compute.instance" + ResourceOciComputeImage string = "oci.compute.image" + ResourceOciComputeBlockVolume string = "oci.compute.blockVolume" + ResourceOciComputeBootVolume string = "oci.compute.bootVolume" + ResourceOciNetwork string = "oci.network" + ResourceOciNetworkVcn string = "oci.network.vcn" + ResourceOciNetworkSubnet string = "oci.network.subnet" + ResourceOciNetworkSecurityList string = "oci.network.securityList" + ResourceOciNetworkNetworkSecurityGroup string = "oci.network.networkSecurityGroup" + ResourceOciLogging string = "oci.logging" + ResourceOciLoggingLogGroup string = "oci.logging.logGroup" + ResourceOciLoggingLog string = "oci.logging.log" + ResourceOciKms string = "oci.kms" + ResourceOciKmsVault string = "oci.kms.vault" + ResourceOciKmsKey string = "oci.kms.key" + ResourceOciObjectStorage string = "oci.objectStorage" + ResourceOciObjectStorageBucket string = "oci.objectStorage.bucket" + ResourceOciFileStorage string = "oci.fileStorage" + ResourceOciFileStorageFileSystem string = "oci.fileStorage.fileSystem" + ResourceOciEvents string = "oci.events" + ResourceOciEventsRule string = "oci.events.rule" + ResourceOciCloudGuard string = "oci.cloudGuard" + ResourceOciCloudGuardTarget string = "oci.cloudGuard.target" + ResourceOciCloudGuardDetectorRecipe string = "oci.cloudGuard.detectorRecipe" + ResourceOciOns string = "oci.ons" + ResourceOciOnsTopic string = "oci.ons.topic" + ResourceOciOnsSubscription string = "oci.ons.subscription" + ResourceOciAudit string = "oci.audit" + ResourceOciBastion string = "oci.bastion" + ResourceOciBastionInstance string = "oci.bastion.instance" + ResourceOciMonitoring string = "oci.monitoring" + ResourceOciMonitoringAlarm string = "oci.monitoring.alarm" + ResourceOciVault string = "oci.vault" + ResourceOciVaultSecret string = "oci.vault.secret" + ResourceOciLoadBalancer string = "oci.loadBalancer" + ResourceOciLoadBalancerLoadBalancer string = "oci.loadBalancer.loadBalancer" + ResourceOciLoadBalancerListener string = "oci.loadBalancer.listener" + ResourceOciLoadBalancerBackendSet string = "oci.loadBalancer.backendSet" + ResourceOciNetworkFirewall string = "oci.networkFirewall" + ResourceOciNetworkFirewallFirewall string = "oci.networkFirewall.firewall" + ResourceOciNetworkFirewallPolicy string = "oci.networkFirewall.policy" + ResourceOciOke string = "oci.oke" + ResourceOciOkeCluster string = "oci.oke.cluster" + ResourceOciOkeNodePool string = "oci.oke.nodePool" ) var resourceFactories map[string]plugin.ResourceFactory @@ -98,6 +135,14 @@ func init() { // to override args, implement: initOciComputeImage(runtime *plugin.Runtime, args map[string]*llx.RawData) (map[string]*llx.RawData, plugin.Resource, error) Create: createOciComputeImage, }, + "oci.compute.blockVolume": { + // to override args, implement: initOciComputeBlockVolume(runtime *plugin.Runtime, args map[string]*llx.RawData) (map[string]*llx.RawData, plugin.Resource, error) + Create: createOciComputeBlockVolume, + }, + "oci.compute.bootVolume": { + // to override args, implement: initOciComputeBootVolume(runtime *plugin.Runtime, args map[string]*llx.RawData) (map[string]*llx.RawData, plugin.Resource, error) + Create: createOciComputeBootVolume, + }, "oci.network": { // to override args, implement: initOciNetwork(runtime *plugin.Runtime, args map[string]*llx.RawData) (map[string]*llx.RawData, plugin.Resource, error) Create: createOciNetwork, @@ -106,10 +151,42 @@ func init() { // to override args, implement: initOciNetworkVcn(runtime *plugin.Runtime, args map[string]*llx.RawData) (map[string]*llx.RawData, plugin.Resource, error) Create: createOciNetworkVcn, }, + "oci.network.subnet": { + // to override args, implement: initOciNetworkSubnet(runtime *plugin.Runtime, args map[string]*llx.RawData) (map[string]*llx.RawData, plugin.Resource, error) + Create: createOciNetworkSubnet, + }, "oci.network.securityList": { // to override args, implement: initOciNetworkSecurityList(runtime *plugin.Runtime, args map[string]*llx.RawData) (map[string]*llx.RawData, plugin.Resource, error) Create: createOciNetworkSecurityList, }, + "oci.network.networkSecurityGroup": { + // to override args, implement: initOciNetworkNetworkSecurityGroup(runtime *plugin.Runtime, args map[string]*llx.RawData) (map[string]*llx.RawData, plugin.Resource, error) + Create: createOciNetworkNetworkSecurityGroup, + }, + "oci.logging": { + // to override args, implement: initOciLogging(runtime *plugin.Runtime, args map[string]*llx.RawData) (map[string]*llx.RawData, plugin.Resource, error) + Create: createOciLogging, + }, + "oci.logging.logGroup": { + // to override args, implement: initOciLoggingLogGroup(runtime *plugin.Runtime, args map[string]*llx.RawData) (map[string]*llx.RawData, plugin.Resource, error) + Create: createOciLoggingLogGroup, + }, + "oci.logging.log": { + // to override args, implement: initOciLoggingLog(runtime *plugin.Runtime, args map[string]*llx.RawData) (map[string]*llx.RawData, plugin.Resource, error) + Create: createOciLoggingLog, + }, + "oci.kms": { + // to override args, implement: initOciKms(runtime *plugin.Runtime, args map[string]*llx.RawData) (map[string]*llx.RawData, plugin.Resource, error) + Create: createOciKms, + }, + "oci.kms.vault": { + // to override args, implement: initOciKmsVault(runtime *plugin.Runtime, args map[string]*llx.RawData) (map[string]*llx.RawData, plugin.Resource, error) + Create: createOciKmsVault, + }, + "oci.kms.key": { + // to override args, implement: initOciKmsKey(runtime *plugin.Runtime, args map[string]*llx.RawData) (map[string]*llx.RawData, plugin.Resource, error) + Create: createOciKmsKey, + }, "oci.objectStorage": { // to override args, implement: initOciObjectStorage(runtime *plugin.Runtime, args map[string]*llx.RawData) (map[string]*llx.RawData, plugin.Resource, error) Create: createOciObjectStorage, @@ -118,6 +195,114 @@ func init() { Init: initOciObjectStorageBucket, Create: createOciObjectStorageBucket, }, + "oci.fileStorage": { + // to override args, implement: initOciFileStorage(runtime *plugin.Runtime, args map[string]*llx.RawData) (map[string]*llx.RawData, plugin.Resource, error) + Create: createOciFileStorage, + }, + "oci.fileStorage.fileSystem": { + // to override args, implement: initOciFileStorageFileSystem(runtime *plugin.Runtime, args map[string]*llx.RawData) (map[string]*llx.RawData, plugin.Resource, error) + Create: createOciFileStorageFileSystem, + }, + "oci.events": { + // to override args, implement: initOciEvents(runtime *plugin.Runtime, args map[string]*llx.RawData) (map[string]*llx.RawData, plugin.Resource, error) + Create: createOciEvents, + }, + "oci.events.rule": { + // to override args, implement: initOciEventsRule(runtime *plugin.Runtime, args map[string]*llx.RawData) (map[string]*llx.RawData, plugin.Resource, error) + Create: createOciEventsRule, + }, + "oci.cloudGuard": { + // to override args, implement: initOciCloudGuard(runtime *plugin.Runtime, args map[string]*llx.RawData) (map[string]*llx.RawData, plugin.Resource, error) + Create: createOciCloudGuard, + }, + "oci.cloudGuard.target": { + // to override args, implement: initOciCloudGuardTarget(runtime *plugin.Runtime, args map[string]*llx.RawData) (map[string]*llx.RawData, plugin.Resource, error) + Create: createOciCloudGuardTarget, + }, + "oci.cloudGuard.detectorRecipe": { + // to override args, implement: initOciCloudGuardDetectorRecipe(runtime *plugin.Runtime, args map[string]*llx.RawData) (map[string]*llx.RawData, plugin.Resource, error) + Create: createOciCloudGuardDetectorRecipe, + }, + "oci.ons": { + // to override args, implement: initOciOns(runtime *plugin.Runtime, args map[string]*llx.RawData) (map[string]*llx.RawData, plugin.Resource, error) + Create: createOciOns, + }, + "oci.ons.topic": { + // to override args, implement: initOciOnsTopic(runtime *plugin.Runtime, args map[string]*llx.RawData) (map[string]*llx.RawData, plugin.Resource, error) + Create: createOciOnsTopic, + }, + "oci.ons.subscription": { + // to override args, implement: initOciOnsSubscription(runtime *plugin.Runtime, args map[string]*llx.RawData) (map[string]*llx.RawData, plugin.Resource, error) + Create: createOciOnsSubscription, + }, + "oci.audit": { + // to override args, implement: initOciAudit(runtime *plugin.Runtime, args map[string]*llx.RawData) (map[string]*llx.RawData, plugin.Resource, error) + Create: createOciAudit, + }, + "oci.bastion": { + // to override args, implement: initOciBastion(runtime *plugin.Runtime, args map[string]*llx.RawData) (map[string]*llx.RawData, plugin.Resource, error) + Create: createOciBastion, + }, + "oci.bastion.instance": { + // to override args, implement: initOciBastionInstance(runtime *plugin.Runtime, args map[string]*llx.RawData) (map[string]*llx.RawData, plugin.Resource, error) + Create: createOciBastionInstance, + }, + "oci.monitoring": { + // to override args, implement: initOciMonitoring(runtime *plugin.Runtime, args map[string]*llx.RawData) (map[string]*llx.RawData, plugin.Resource, error) + Create: createOciMonitoring, + }, + "oci.monitoring.alarm": { + // to override args, implement: initOciMonitoringAlarm(runtime *plugin.Runtime, args map[string]*llx.RawData) (map[string]*llx.RawData, plugin.Resource, error) + Create: createOciMonitoringAlarm, + }, + "oci.vault": { + // to override args, implement: initOciVault(runtime *plugin.Runtime, args map[string]*llx.RawData) (map[string]*llx.RawData, plugin.Resource, error) + Create: createOciVault, + }, + "oci.vault.secret": { + // to override args, implement: initOciVaultSecret(runtime *plugin.Runtime, args map[string]*llx.RawData) (map[string]*llx.RawData, plugin.Resource, error) + Create: createOciVaultSecret, + }, + "oci.loadBalancer": { + // to override args, implement: initOciLoadBalancer(runtime *plugin.Runtime, args map[string]*llx.RawData) (map[string]*llx.RawData, plugin.Resource, error) + Create: createOciLoadBalancer, + }, + "oci.loadBalancer.loadBalancer": { + // to override args, implement: initOciLoadBalancerLoadBalancer(runtime *plugin.Runtime, args map[string]*llx.RawData) (map[string]*llx.RawData, plugin.Resource, error) + Create: createOciLoadBalancerLoadBalancer, + }, + "oci.loadBalancer.listener": { + // to override args, implement: initOciLoadBalancerListener(runtime *plugin.Runtime, args map[string]*llx.RawData) (map[string]*llx.RawData, plugin.Resource, error) + Create: createOciLoadBalancerListener, + }, + "oci.loadBalancer.backendSet": { + // to override args, implement: initOciLoadBalancerBackendSet(runtime *plugin.Runtime, args map[string]*llx.RawData) (map[string]*llx.RawData, plugin.Resource, error) + Create: createOciLoadBalancerBackendSet, + }, + "oci.networkFirewall": { + // to override args, implement: initOciNetworkFirewall(runtime *plugin.Runtime, args map[string]*llx.RawData) (map[string]*llx.RawData, plugin.Resource, error) + Create: createOciNetworkFirewall, + }, + "oci.networkFirewall.firewall": { + // to override args, implement: initOciNetworkFirewallFirewall(runtime *plugin.Runtime, args map[string]*llx.RawData) (map[string]*llx.RawData, plugin.Resource, error) + Create: createOciNetworkFirewallFirewall, + }, + "oci.networkFirewall.policy": { + // to override args, implement: initOciNetworkFirewallPolicy(runtime *plugin.Runtime, args map[string]*llx.RawData) (map[string]*llx.RawData, plugin.Resource, error) + Create: createOciNetworkFirewallPolicy, + }, + "oci.oke": { + // to override args, implement: initOciOke(runtime *plugin.Runtime, args map[string]*llx.RawData) (map[string]*llx.RawData, plugin.Resource, error) + Create: createOciOke, + }, + "oci.oke.cluster": { + // to override args, implement: initOciOkeCluster(runtime *plugin.Runtime, args map[string]*llx.RawData) (map[string]*llx.RawData, plugin.Resource, error) + Create: createOciOkeCluster, + }, + "oci.oke.nodePool": { + // to override args, implement: initOciOkeNodePool(runtime *plugin.Runtime, args map[string]*llx.RawData) (map[string]*llx.RawData, plugin.Resource, error) + Create: createOciOkeNodePool, + }, } } @@ -408,6 +593,12 @@ var getDataFields = map[string]func(r plugin.Resource) *plugin.DataRes{ "oci.compute.images": func(r plugin.Resource) *plugin.DataRes { return (r.(*mqlOciCompute).GetImages()).ToDataRes(types.Array(types.Resource("oci.compute.image"))) }, + "oci.compute.blockVolumes": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciCompute).GetBlockVolumes()).ToDataRes(types.Array(types.Resource("oci.compute.blockVolume"))) + }, + "oci.compute.bootVolumes": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciCompute).GetBootVolumes()).ToDataRes(types.Array(types.Resource("oci.compute.bootVolume"))) + }, "oci.compute.instance.id": func(r plugin.Resource) *plugin.DataRes { return (r.(*mqlOciComputeInstance).GetId()).ToDataRes(types.String) }, @@ -441,6 +632,27 @@ var getDataFields = map[string]func(r plugin.Resource) *plugin.DataRes{ "oci.compute.instance.dedicatedVmHostId": func(r plugin.Resource) *plugin.DataRes { return (r.(*mqlOciComputeInstance).GetDedicatedVmHostId()).ToDataRes(types.String) }, + "oci.compute.instance.platformConfig": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciComputeInstance).GetPlatformConfig()).ToDataRes(types.Dict) + }, + "oci.compute.instance.launchOptions": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciComputeInstance).GetLaunchOptions()).ToDataRes(types.Dict) + }, + "oci.compute.instance.instanceOptions": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciComputeInstance).GetInstanceOptions()).ToDataRes(types.Dict) + }, + "oci.compute.instance.shapeConfig": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciComputeInstance).GetShapeConfig()).ToDataRes(types.Dict) + }, + "oci.compute.instance.sourceDetails": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciComputeInstance).GetSourceDetails()).ToDataRes(types.Dict) + }, + "oci.compute.instance.metadata": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciComputeInstance).GetMetadata()).ToDataRes(types.Map(types.String, types.String)) + }, + "oci.compute.instance.timeMaintenanceRebootDue": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciComputeInstance).GetTimeMaintenanceRebootDue()).ToDataRes(types.Time) + }, "oci.compute.instance.freeformTags": func(r plugin.Resource) *plugin.DataRes { return (r.(*mqlOciComputeInstance).GetFreeformTags()).ToDataRes(types.Map(types.String, types.String)) }, @@ -480,12 +692,78 @@ var getDataFields = map[string]func(r plugin.Resource) *plugin.DataRes{ "oci.compute.image.definedTags": func(r plugin.Resource) *plugin.DataRes { return (r.(*mqlOciComputeImage).GetDefinedTags()).ToDataRes(types.Map(types.String, types.Map(types.String, types.String))) }, + "oci.compute.blockVolume.id": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciComputeBlockVolume).GetId()).ToDataRes(types.String) + }, + "oci.compute.blockVolume.name": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciComputeBlockVolume).GetName()).ToDataRes(types.String) + }, + "oci.compute.blockVolume.compartmentID": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciComputeBlockVolume).GetCompartmentID()).ToDataRes(types.String) + }, + "oci.compute.blockVolume.availabilityDomain": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciComputeBlockVolume).GetAvailabilityDomain()).ToDataRes(types.String) + }, + "oci.compute.blockVolume.sizeInGBs": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciComputeBlockVolume).GetSizeInGBs()).ToDataRes(types.Int) + }, + "oci.compute.blockVolume.vpusPerGB": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciComputeBlockVolume).GetVpusPerGB()).ToDataRes(types.Int) + }, + "oci.compute.blockVolume.state": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciComputeBlockVolume).GetState()).ToDataRes(types.String) + }, + "oci.compute.blockVolume.isHydrated": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciComputeBlockVolume).GetIsHydrated()).ToDataRes(types.Bool) + }, + "oci.compute.blockVolume.kmsKey": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciComputeBlockVolume).GetKmsKey()).ToDataRes(types.Resource("oci.kms.key")) + }, + "oci.compute.blockVolume.isAutoTuneEnabled": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciComputeBlockVolume).GetIsAutoTuneEnabled()).ToDataRes(types.Bool) + }, + "oci.compute.blockVolume.created": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciComputeBlockVolume).GetCreated()).ToDataRes(types.Time) + }, + "oci.compute.bootVolume.id": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciComputeBootVolume).GetId()).ToDataRes(types.String) + }, + "oci.compute.bootVolume.name": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciComputeBootVolume).GetName()).ToDataRes(types.String) + }, + "oci.compute.bootVolume.compartmentID": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciComputeBootVolume).GetCompartmentID()).ToDataRes(types.String) + }, + "oci.compute.bootVolume.availabilityDomain": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciComputeBootVolume).GetAvailabilityDomain()).ToDataRes(types.String) + }, + "oci.compute.bootVolume.sizeInGBs": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciComputeBootVolume).GetSizeInGBs()).ToDataRes(types.Int) + }, + "oci.compute.bootVolume.imageId": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciComputeBootVolume).GetImageId()).ToDataRes(types.String) + }, + "oci.compute.bootVolume.state": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciComputeBootVolume).GetState()).ToDataRes(types.String) + }, + "oci.compute.bootVolume.kmsKey": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciComputeBootVolume).GetKmsKey()).ToDataRes(types.Resource("oci.kms.key")) + }, + "oci.compute.bootVolume.created": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciComputeBootVolume).GetCreated()).ToDataRes(types.Time) + }, "oci.network.vcns": func(r plugin.Resource) *plugin.DataRes { return (r.(*mqlOciNetwork).GetVcns()).ToDataRes(types.Array(types.Resource("oci.network.vcn"))) }, + "oci.network.subnets": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciNetwork).GetSubnets()).ToDataRes(types.Array(types.Resource("oci.network.subnet"))) + }, "oci.network.securityLists": func(r plugin.Resource) *plugin.DataRes { return (r.(*mqlOciNetwork).GetSecurityLists()).ToDataRes(types.Array(types.Resource("oci.network.securityList"))) }, + "oci.network.networkSecurityGroups": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciNetwork).GetNetworkSecurityGroups()).ToDataRes(types.Array(types.Resource("oci.network.networkSecurityGroup"))) + }, "oci.network.vcn.id": func(r plugin.Resource) *plugin.DataRes { return (r.(*mqlOciNetworkVcn).GetId()).ToDataRes(types.String) }, @@ -528,6 +806,48 @@ var getDataFields = map[string]func(r plugin.Resource) *plugin.DataRes{ "oci.network.vcn.definedTags": func(r plugin.Resource) *plugin.DataRes { return (r.(*mqlOciNetworkVcn).GetDefinedTags()).ToDataRes(types.Map(types.String, types.Map(types.String, types.String))) }, + "oci.network.subnet.id": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciNetworkSubnet).GetId()).ToDataRes(types.String) + }, + "oci.network.subnet.name": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciNetworkSubnet).GetName()).ToDataRes(types.String) + }, + "oci.network.subnet.compartmentID": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciNetworkSubnet).GetCompartmentID()).ToDataRes(types.String) + }, + "oci.network.subnet.vcn": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciNetworkSubnet).GetVcn()).ToDataRes(types.Resource("oci.network.vcn")) + }, + "oci.network.subnet.availabilityDomain": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciNetworkSubnet).GetAvailabilityDomain()).ToDataRes(types.String) + }, + "oci.network.subnet.cidrBlock": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciNetworkSubnet).GetCidrBlock()).ToDataRes(types.String) + }, + "oci.network.subnet.state": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciNetworkSubnet).GetState()).ToDataRes(types.String) + }, + "oci.network.subnet.dnsLabel": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciNetworkSubnet).GetDnsLabel()).ToDataRes(types.String) + }, + "oci.network.subnet.subnetDomainName": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciNetworkSubnet).GetSubnetDomainName()).ToDataRes(types.String) + }, + "oci.network.subnet.prohibitPublicIpOnVnic": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciNetworkSubnet).GetProhibitPublicIpOnVnic()).ToDataRes(types.Bool) + }, + "oci.network.subnet.prohibitInternetIngress": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciNetworkSubnet).GetProhibitInternetIngress()).ToDataRes(types.Bool) + }, + "oci.network.subnet.created": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciNetworkSubnet).GetCreated()).ToDataRes(types.Time) + }, + "oci.network.subnet.freeformTags": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciNetworkSubnet).GetFreeformTags()).ToDataRes(types.Map(types.String, types.String)) + }, + "oci.network.subnet.definedTags": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciNetworkSubnet).GetDefinedTags()).ToDataRes(types.Map(types.String, types.Map(types.String, types.String))) + }, "oci.network.securityList.id": func(r plugin.Resource) *plugin.DataRes { return (r.(*mqlOciNetworkSecurityList).GetId()).ToDataRes(types.String) }, @@ -552,12 +872,153 @@ var getDataFields = map[string]func(r plugin.Resource) *plugin.DataRes{ "oci.network.securityList.vcnId": func(r plugin.Resource) *plugin.DataRes { return (r.(*mqlOciNetworkSecurityList).GetVcnId()).ToDataRes(types.String) }, + "oci.network.securityList.vcn": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciNetworkSecurityList).GetVcn()).ToDataRes(types.Resource("oci.network.vcn")) + }, "oci.network.securityList.freeformTags": func(r plugin.Resource) *plugin.DataRes { return (r.(*mqlOciNetworkSecurityList).GetFreeformTags()).ToDataRes(types.Map(types.String, types.String)) }, "oci.network.securityList.definedTags": func(r plugin.Resource) *plugin.DataRes { return (r.(*mqlOciNetworkSecurityList).GetDefinedTags()).ToDataRes(types.Map(types.String, types.Map(types.String, types.String))) }, + "oci.network.networkSecurityGroup.id": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciNetworkNetworkSecurityGroup).GetId()).ToDataRes(types.String) + }, + "oci.network.networkSecurityGroup.name": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciNetworkNetworkSecurityGroup).GetName()).ToDataRes(types.String) + }, + "oci.network.networkSecurityGroup.compartmentID": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciNetworkNetworkSecurityGroup).GetCompartmentID()).ToDataRes(types.String) + }, + "oci.network.networkSecurityGroup.vcn": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciNetworkNetworkSecurityGroup).GetVcn()).ToDataRes(types.Resource("oci.network.vcn")) + }, + "oci.network.networkSecurityGroup.state": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciNetworkNetworkSecurityGroup).GetState()).ToDataRes(types.String) + }, + "oci.network.networkSecurityGroup.created": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciNetworkNetworkSecurityGroup).GetCreated()).ToDataRes(types.Time) + }, + "oci.network.networkSecurityGroup.freeformTags": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciNetworkNetworkSecurityGroup).GetFreeformTags()).ToDataRes(types.Map(types.String, types.String)) + }, + "oci.network.networkSecurityGroup.definedTags": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciNetworkNetworkSecurityGroup).GetDefinedTags()).ToDataRes(types.Map(types.String, types.Map(types.String, types.String))) + }, + "oci.network.networkSecurityGroup.ingressSecurityRules": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciNetworkNetworkSecurityGroup).GetIngressSecurityRules()).ToDataRes(types.Array(types.Dict)) + }, + "oci.network.networkSecurityGroup.egressSecurityRules": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciNetworkNetworkSecurityGroup).GetEgressSecurityRules()).ToDataRes(types.Array(types.Dict)) + }, + "oci.logging.logGroups": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciLogging).GetLogGroups()).ToDataRes(types.Array(types.Resource("oci.logging.logGroup"))) + }, + "oci.logging.logGroup.id": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciLoggingLogGroup).GetId()).ToDataRes(types.String) + }, + "oci.logging.logGroup.name": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciLoggingLogGroup).GetName()).ToDataRes(types.String) + }, + "oci.logging.logGroup.description": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciLoggingLogGroup).GetDescription()).ToDataRes(types.String) + }, + "oci.logging.logGroup.compartmentID": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciLoggingLogGroup).GetCompartmentID()).ToDataRes(types.String) + }, + "oci.logging.logGroup.state": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciLoggingLogGroup).GetState()).ToDataRes(types.String) + }, + "oci.logging.logGroup.logs": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciLoggingLogGroup).GetLogs()).ToDataRes(types.Array(types.Resource("oci.logging.log"))) + }, + "oci.logging.logGroup.created": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciLoggingLogGroup).GetCreated()).ToDataRes(types.Time) + }, + "oci.logging.log.id": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciLoggingLog).GetId()).ToDataRes(types.String) + }, + "oci.logging.log.name": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciLoggingLog).GetName()).ToDataRes(types.String) + }, + "oci.logging.log.logType": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciLoggingLog).GetLogType()).ToDataRes(types.String) + }, + "oci.logging.log.logGroup": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciLoggingLog).GetLogGroup()).ToDataRes(types.Resource("oci.logging.logGroup")) + }, + "oci.logging.log.isEnabled": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciLoggingLog).GetIsEnabled()).ToDataRes(types.Bool) + }, + "oci.logging.log.state": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciLoggingLog).GetState()).ToDataRes(types.String) + }, + "oci.logging.log.retentionDuration": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciLoggingLog).GetRetentionDuration()).ToDataRes(types.Int) + }, + "oci.logging.log.configuration": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciLoggingLog).GetConfiguration()).ToDataRes(types.Dict) + }, + "oci.logging.log.created": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciLoggingLog).GetCreated()).ToDataRes(types.Time) + }, + "oci.logging.log.timeLastModified": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciLoggingLog).GetTimeLastModified()).ToDataRes(types.Time) + }, + "oci.kms.vaults": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciKms).GetVaults()).ToDataRes(types.Array(types.Resource("oci.kms.vault"))) + }, + "oci.kms.vault.id": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciKmsVault).GetId()).ToDataRes(types.String) + }, + "oci.kms.vault.name": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciKmsVault).GetName()).ToDataRes(types.String) + }, + "oci.kms.vault.compartmentID": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciKmsVault).GetCompartmentID()).ToDataRes(types.String) + }, + "oci.kms.vault.vaultType": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciKmsVault).GetVaultType()).ToDataRes(types.String) + }, + "oci.kms.vault.state": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciKmsVault).GetState()).ToDataRes(types.String) + }, + "oci.kms.vault.managementEndpoint": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciKmsVault).GetManagementEndpoint()).ToDataRes(types.String) + }, + "oci.kms.vault.keys": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciKmsVault).GetKeys()).ToDataRes(types.Array(types.Resource("oci.kms.key"))) + }, + "oci.kms.vault.created": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciKmsVault).GetCreated()).ToDataRes(types.Time) + }, + "oci.kms.key.id": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciKmsKey).GetId()).ToDataRes(types.String) + }, + "oci.kms.key.name": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciKmsKey).GetName()).ToDataRes(types.String) + }, + "oci.kms.key.compartmentID": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciKmsKey).GetCompartmentID()).ToDataRes(types.String) + }, + "oci.kms.key.vaultId": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciKmsKey).GetVaultId()).ToDataRes(types.String) + }, + "oci.kms.key.algorithm": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciKmsKey).GetAlgorithm()).ToDataRes(types.String) + }, + "oci.kms.key.protectionMode": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciKmsKey).GetProtectionMode()).ToDataRes(types.String) + }, + "oci.kms.key.state": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciKmsKey).GetState()).ToDataRes(types.String) + }, + "oci.kms.key.isAutoRotationEnabled": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciKmsKey).GetIsAutoRotationEnabled()).ToDataRes(types.Bool) + }, + "oci.kms.key.created": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciKmsKey).GetCreated()).ToDataRes(types.Time) + }, "oci.objectStorage.namespace": func(r plugin.Resource) *plugin.DataRes { return (r.(*mqlOciObjectStorage).GetNamespace()).ToDataRes(types.String) }, @@ -615,700 +1076,5466 @@ var getDataFields = map[string]func(r plugin.Resource) *plugin.DataRes{ "oci.objectStorage.bucket.approximateSize": func(r plugin.Resource) *plugin.DataRes { return (r.(*mqlOciObjectStorageBucket).GetApproximateSize()).ToDataRes(types.Int) }, + "oci.objectStorage.bucket.objectLifecyclePolicyEtag": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciObjectStorageBucket).GetObjectLifecyclePolicyEtag()).ToDataRes(types.String) + }, "oci.objectStorage.bucket.freeformTags": func(r plugin.Resource) *plugin.DataRes { return (r.(*mqlOciObjectStorageBucket).GetFreeformTags()).ToDataRes(types.Map(types.String, types.String)) }, "oci.objectStorage.bucket.definedTags": func(r plugin.Resource) *plugin.DataRes { return (r.(*mqlOciObjectStorageBucket).GetDefinedTags()).ToDataRes(types.Map(types.String, types.Map(types.String, types.String))) }, -} - -func GetData(resource plugin.Resource, field string, args map[string]*llx.RawData) *plugin.DataRes { - f, ok := getDataFields[resource.MqlName()+"."+field] - if !ok { - return &plugin.DataRes{Error: "cannot find '" + field + "' in resource '" + resource.MqlName() + "'"} - } - - return f(resource) -} - -var setDataFields = map[string]func(r plugin.Resource, v *llx.RawData) bool{ - "oci.__id": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOci).__id, ok = v.Value.(string) - return + "oci.fileStorage.fileSystems": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciFileStorage).GetFileSystems()).ToDataRes(types.Array(types.Resource("oci.fileStorage.fileSystem"))) }, - "oci.regions": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOci).Regions, ok = plugin.RawToTValue[[]any](v.Value, v.Error) - return + "oci.fileStorage.fileSystem.id": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciFileStorageFileSystem).GetId()).ToDataRes(types.String) }, - "oci.compartments": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOci).Compartments, ok = plugin.RawToTValue[[]any](v.Value, v.Error) - return + "oci.fileStorage.fileSystem.name": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciFileStorageFileSystem).GetName()).ToDataRes(types.String) }, - "oci.tenancy.__id": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciTenancy).__id, ok = v.Value.(string) - return + "oci.fileStorage.fileSystem.compartmentID": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciFileStorageFileSystem).GetCompartmentID()).ToDataRes(types.String) }, - "oci.tenancy.id": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciTenancy).Id, ok = plugin.RawToTValue[string](v.Value, v.Error) - return + "oci.fileStorage.fileSystem.availabilityDomain": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciFileStorageFileSystem).GetAvailabilityDomain()).ToDataRes(types.String) }, - "oci.tenancy.name": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciTenancy).Name, ok = plugin.RawToTValue[string](v.Value, v.Error) - return + "oci.fileStorage.fileSystem.state": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciFileStorageFileSystem).GetState()).ToDataRes(types.String) }, - "oci.tenancy.description": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciTenancy).Description, ok = plugin.RawToTValue[string](v.Value, v.Error) - return + "oci.fileStorage.fileSystem.kmsKey": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciFileStorageFileSystem).GetKmsKey()).ToDataRes(types.Resource("oci.kms.key")) }, - "oci.tenancy.retentionPeriod": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciTenancy).RetentionPeriod, ok = plugin.RawToTValue[*time.Time](v.Value, v.Error) - return + "oci.fileStorage.fileSystem.meteredBytes": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciFileStorageFileSystem).GetMeteredBytes()).ToDataRes(types.Int) }, - "oci.region.__id": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciRegion).__id, ok = v.Value.(string) - return + "oci.fileStorage.fileSystem.created": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciFileStorageFileSystem).GetCreated()).ToDataRes(types.Time) }, - "oci.region.id": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciRegion).Id, ok = plugin.RawToTValue[string](v.Value, v.Error) - return + "oci.events.rules": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciEvents).GetRules()).ToDataRes(types.Array(types.Resource("oci.events.rule"))) }, - "oci.region.name": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciRegion).Name, ok = plugin.RawToTValue[string](v.Value, v.Error) - return + "oci.events.rule.id": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciEventsRule).GetId()).ToDataRes(types.String) }, - "oci.region.isHomeRegion": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciRegion).IsHomeRegion, ok = plugin.RawToTValue[bool](v.Value, v.Error) - return + "oci.events.rule.name": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciEventsRule).GetName()).ToDataRes(types.String) }, - "oci.region.status": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciRegion).Status, ok = plugin.RawToTValue[string](v.Value, v.Error) - return + "oci.events.rule.description": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciEventsRule).GetDescription()).ToDataRes(types.String) }, - "oci.compartment.__id": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciCompartment).__id, ok = v.Value.(string) - return + "oci.events.rule.compartmentID": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciEventsRule).GetCompartmentID()).ToDataRes(types.String) }, - "oci.compartment.id": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciCompartment).Id, ok = plugin.RawToTValue[string](v.Value, v.Error) - return + "oci.events.rule.condition": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciEventsRule).GetCondition()).ToDataRes(types.String) }, - "oci.compartment.name": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciCompartment).Name, ok = plugin.RawToTValue[string](v.Value, v.Error) - return + "oci.events.rule.isEnabled": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciEventsRule).GetIsEnabled()).ToDataRes(types.Bool) }, - "oci.compartment.description": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciCompartment).Description, ok = plugin.RawToTValue[string](v.Value, v.Error) - return + "oci.events.rule.state": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciEventsRule).GetState()).ToDataRes(types.String) }, - "oci.compartment.created": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciCompartment).Created, ok = plugin.RawToTValue[*time.Time](v.Value, v.Error) - return + "oci.events.rule.actions": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciEventsRule).GetActions()).ToDataRes(types.Array(types.Dict)) }, - "oci.compartment.state": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciCompartment).State, ok = plugin.RawToTValue[string](v.Value, v.Error) - return + "oci.events.rule.created": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciEventsRule).GetCreated()).ToDataRes(types.Time) }, - "oci.identity.__id": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciIdentity).__id, ok = v.Value.(string) - return + "oci.cloudGuard.status": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciCloudGuard).GetStatus()).ToDataRes(types.Bool) }, - "oci.identity.users": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciIdentity).Users, ok = plugin.RawToTValue[[]any](v.Value, v.Error) - return + "oci.cloudGuard.reportingRegion": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciCloudGuard).GetReportingRegion()).ToDataRes(types.String) }, - "oci.identity.groups": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciIdentity).Groups, ok = plugin.RawToTValue[[]any](v.Value, v.Error) - return + "oci.cloudGuard.selfManageResources": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciCloudGuard).GetSelfManageResources()).ToDataRes(types.Bool) }, - "oci.identity.policies": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciIdentity).Policies, ok = plugin.RawToTValue[[]any](v.Value, v.Error) - return + "oci.cloudGuard.targets": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciCloudGuard).GetTargets()).ToDataRes(types.Array(types.Resource("oci.cloudGuard.target"))) }, - "oci.identity.user.__id": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciIdentityUser).__id, ok = v.Value.(string) - return + "oci.cloudGuard.detectorRecipes": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciCloudGuard).GetDetectorRecipes()).ToDataRes(types.Array(types.Resource("oci.cloudGuard.detectorRecipe"))) }, - "oci.identity.user.id": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciIdentityUser).Id, ok = plugin.RawToTValue[string](v.Value, v.Error) - return + "oci.cloudGuard.target.id": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciCloudGuardTarget).GetId()).ToDataRes(types.String) }, - "oci.identity.user.compartmentID": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciIdentityUser).CompartmentID, ok = plugin.RawToTValue[string](v.Value, v.Error) - return + "oci.cloudGuard.target.name": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciCloudGuardTarget).GetName()).ToDataRes(types.String) }, - "oci.identity.user.name": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciIdentityUser).Name, ok = plugin.RawToTValue[string](v.Value, v.Error) - return + "oci.cloudGuard.target.compartmentID": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciCloudGuardTarget).GetCompartmentID()).ToDataRes(types.String) }, - "oci.identity.user.description": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciIdentityUser).Description, ok = plugin.RawToTValue[string](v.Value, v.Error) - return + "oci.cloudGuard.target.targetResourceId": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciCloudGuardTarget).GetTargetResourceId()).ToDataRes(types.String) }, - "oci.identity.user.created": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciIdentityUser).Created, ok = plugin.RawToTValue[*time.Time](v.Value, v.Error) - return + "oci.cloudGuard.target.targetResourceType": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciCloudGuardTarget).GetTargetResourceType()).ToDataRes(types.String) }, - "oci.identity.user.state": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciIdentityUser).State, ok = plugin.RawToTValue[string](v.Value, v.Error) - return + "oci.cloudGuard.target.state": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciCloudGuardTarget).GetState()).ToDataRes(types.String) }, - "oci.identity.user.mfaActivated": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciIdentityUser).MfaActivated, ok = plugin.RawToTValue[bool](v.Value, v.Error) - return + "oci.cloudGuard.target.recipeCount": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciCloudGuardTarget).GetRecipeCount()).ToDataRes(types.Int) }, - "oci.identity.user.email": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciIdentityUser).Email, ok = plugin.RawToTValue[string](v.Value, v.Error) - return + "oci.cloudGuard.target.created": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciCloudGuardTarget).GetCreated()).ToDataRes(types.Time) }, - "oci.identity.user.emailVerified": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciIdentityUser).EmailVerified, ok = plugin.RawToTValue[bool](v.Value, v.Error) - return + "oci.cloudGuard.detectorRecipe.id": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciCloudGuardDetectorRecipe).GetId()).ToDataRes(types.String) }, - "oci.identity.user.capabilities": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciIdentityUser).Capabilities, ok = plugin.RawToTValue[map[string]any](v.Value, v.Error) - return + "oci.cloudGuard.detectorRecipe.name": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciCloudGuardDetectorRecipe).GetName()).ToDataRes(types.String) }, - "oci.identity.user.lastLogin": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciIdentityUser).LastLogin, ok = plugin.RawToTValue[*time.Time](v.Value, v.Error) - return + "oci.cloudGuard.detectorRecipe.description": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciCloudGuardDetectorRecipe).GetDescription()).ToDataRes(types.String) }, - "oci.identity.user.previousLogin": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciIdentityUser).PreviousLogin, ok = plugin.RawToTValue[*time.Time](v.Value, v.Error) - return + "oci.cloudGuard.detectorRecipe.owner": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciCloudGuardDetectorRecipe).GetOwner()).ToDataRes(types.String) }, - "oci.identity.user.freeformTags": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciIdentityUser).FreeformTags, ok = plugin.RawToTValue[map[string]any](v.Value, v.Error) - return + "oci.cloudGuard.detectorRecipe.detectorType": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciCloudGuardDetectorRecipe).GetDetectorType()).ToDataRes(types.String) }, - "oci.identity.user.definedTags": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciIdentityUser).DefinedTags, ok = plugin.RawToTValue[map[string]any](v.Value, v.Error) - return + "oci.cloudGuard.detectorRecipe.state": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciCloudGuardDetectorRecipe).GetState()).ToDataRes(types.String) }, - "oci.identity.user.apiKeys": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciIdentityUser).ApiKeys, ok = plugin.RawToTValue[[]any](v.Value, v.Error) - return + "oci.cloudGuard.detectorRecipe.created": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciCloudGuardDetectorRecipe).GetCreated()).ToDataRes(types.Time) }, - "oci.identity.user.customerSecretKeys": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciIdentityUser).CustomerSecretKeys, ok = plugin.RawToTValue[[]any](v.Value, v.Error) - return + "oci.ons.topics": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciOns).GetTopics()).ToDataRes(types.Array(types.Resource("oci.ons.topic"))) }, - "oci.identity.user.authTokens": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciIdentityUser).AuthTokens, ok = plugin.RawToTValue[[]any](v.Value, v.Error) - return + "oci.ons.topic.id": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciOnsTopic).GetId()).ToDataRes(types.String) }, - "oci.identity.user.groups": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciIdentityUser).Groups, ok = plugin.RawToTValue[[]any](v.Value, v.Error) - return + "oci.ons.topic.name": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciOnsTopic).GetName()).ToDataRes(types.String) }, - "oci.identity.apiKey.__id": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciIdentityApiKey).__id, ok = v.Value.(string) - return + "oci.ons.topic.description": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciOnsTopic).GetDescription()).ToDataRes(types.String) }, - "oci.identity.apiKey.id": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciIdentityApiKey).Id, ok = plugin.RawToTValue[string](v.Value, v.Error) - return + "oci.ons.topic.compartmentID": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciOnsTopic).GetCompartmentID()).ToDataRes(types.String) }, - "oci.identity.apiKey.value": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciIdentityApiKey).Value, ok = plugin.RawToTValue[string](v.Value, v.Error) - return + "oci.ons.topic.state": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciOnsTopic).GetState()).ToDataRes(types.String) }, - "oci.identity.apiKey.fingerprint": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciIdentityApiKey).Fingerprint, ok = plugin.RawToTValue[string](v.Value, v.Error) - return + "oci.ons.topic.created": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciOnsTopic).GetCreated()).ToDataRes(types.Time) }, - "oci.identity.apiKey.created": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciIdentityApiKey).Created, ok = plugin.RawToTValue[*time.Time](v.Value, v.Error) - return + "oci.ons.topic.subscriptions": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciOnsTopic).GetSubscriptions()).ToDataRes(types.Array(types.Resource("oci.ons.subscription"))) }, - "oci.identity.apiKey.state": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciIdentityApiKey).State, ok = plugin.RawToTValue[string](v.Value, v.Error) - return + "oci.ons.subscription.id": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciOnsSubscription).GetId()).ToDataRes(types.String) }, - "oci.identity.customerSecretKey.__id": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciIdentityCustomerSecretKey).__id, ok = v.Value.(string) - return + "oci.ons.subscription.topic": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciOnsSubscription).GetTopic()).ToDataRes(types.Resource("oci.ons.topic")) }, - "oci.identity.customerSecretKey.id": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciIdentityCustomerSecretKey).Id, ok = plugin.RawToTValue[string](v.Value, v.Error) - return + "oci.ons.subscription.protocol": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciOnsSubscription).GetProtocol()).ToDataRes(types.String) }, - "oci.identity.customerSecretKey.name": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciIdentityCustomerSecretKey).Name, ok = plugin.RawToTValue[string](v.Value, v.Error) - return + "oci.ons.subscription.endpoint": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciOnsSubscription).GetEndpoint()).ToDataRes(types.String) }, - "oci.identity.customerSecretKey.created": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciIdentityCustomerSecretKey).Created, ok = plugin.RawToTValue[*time.Time](v.Value, v.Error) - return + "oci.ons.subscription.state": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciOnsSubscription).GetState()).ToDataRes(types.String) }, - "oci.identity.customerSecretKey.state": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciIdentityCustomerSecretKey).State, ok = plugin.RawToTValue[string](v.Value, v.Error) - return + "oci.ons.subscription.created": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciOnsSubscription).GetCreated()).ToDataRes(types.Time) }, - "oci.identity.authToken.__id": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciIdentityAuthToken).__id, ok = v.Value.(string) - return + "oci.audit.retentionPeriodDays": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciAudit).GetRetentionPeriodDays()).ToDataRes(types.Int) }, - "oci.identity.authToken.id": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciIdentityAuthToken).Id, ok = plugin.RawToTValue[string](v.Value, v.Error) - return + "oci.bastion.bastions": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciBastion).GetBastions()).ToDataRes(types.Array(types.Resource("oci.bastion.instance"))) }, - "oci.identity.authToken.description": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciIdentityAuthToken).Description, ok = plugin.RawToTValue[string](v.Value, v.Error) - return + "oci.bastion.instance.id": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciBastionInstance).GetId()).ToDataRes(types.String) }, - "oci.identity.authToken.created": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciIdentityAuthToken).Created, ok = plugin.RawToTValue[*time.Time](v.Value, v.Error) - return + "oci.bastion.instance.name": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciBastionInstance).GetName()).ToDataRes(types.String) }, - "oci.identity.authToken.expires": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciIdentityAuthToken).Expires, ok = plugin.RawToTValue[*time.Time](v.Value, v.Error) - return + "oci.bastion.instance.compartmentID": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciBastionInstance).GetCompartmentID()).ToDataRes(types.String) }, - "oci.identity.authToken.state": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciIdentityAuthToken).State, ok = plugin.RawToTValue[string](v.Value, v.Error) - return + "oci.bastion.instance.bastionType": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciBastionInstance).GetBastionType()).ToDataRes(types.String) }, - "oci.identity.group.__id": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciIdentityGroup).__id, ok = v.Value.(string) - return + "oci.bastion.instance.targetVcn": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciBastionInstance).GetTargetVcn()).ToDataRes(types.Resource("oci.network.vcn")) }, - "oci.identity.group.id": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciIdentityGroup).Id, ok = plugin.RawToTValue[string](v.Value, v.Error) - return + "oci.bastion.instance.targetSubnet": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciBastionInstance).GetTargetSubnet()).ToDataRes(types.Resource("oci.network.subnet")) }, - "oci.identity.group.compartmentID": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciIdentityGroup).CompartmentID, ok = plugin.RawToTValue[string](v.Value, v.Error) - return + "oci.bastion.instance.state": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciBastionInstance).GetState()).ToDataRes(types.String) }, - "oci.identity.group.name": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciIdentityGroup).Name, ok = plugin.RawToTValue[string](v.Value, v.Error) - return + "oci.bastion.instance.dnsProxyStatus": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciBastionInstance).GetDnsProxyStatus()).ToDataRes(types.String) }, - "oci.identity.group.description": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciIdentityGroup).Description, ok = plugin.RawToTValue[string](v.Value, v.Error) - return + "oci.bastion.instance.created": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciBastionInstance).GetCreated()).ToDataRes(types.Time) }, - "oci.identity.group.created": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciIdentityGroup).Created, ok = plugin.RawToTValue[*time.Time](v.Value, v.Error) - return + "oci.bastion.instance.timeUpdated": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciBastionInstance).GetTimeUpdated()).ToDataRes(types.Time) }, - "oci.identity.group.state": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciIdentityGroup).State, ok = plugin.RawToTValue[string](v.Value, v.Error) - return + "oci.monitoring.alarms": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciMonitoring).GetAlarms()).ToDataRes(types.Array(types.Resource("oci.monitoring.alarm"))) }, - "oci.identity.group.freeformTags": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciIdentityGroup).FreeformTags, ok = plugin.RawToTValue[map[string]any](v.Value, v.Error) - return + "oci.monitoring.alarm.id": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciMonitoringAlarm).GetId()).ToDataRes(types.String) }, - "oci.identity.group.definedTags": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciIdentityGroup).DefinedTags, ok = plugin.RawToTValue[map[string]any](v.Value, v.Error) - return + "oci.monitoring.alarm.name": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciMonitoringAlarm).GetName()).ToDataRes(types.String) }, - "oci.identity.policy.__id": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciIdentityPolicy).__id, ok = v.Value.(string) - return + "oci.monitoring.alarm.compartmentID": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciMonitoringAlarm).GetCompartmentID()).ToDataRes(types.String) }, - "oci.identity.policy.id": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciIdentityPolicy).Id, ok = plugin.RawToTValue[string](v.Value, v.Error) - return + "oci.monitoring.alarm.metricCompartmentId": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciMonitoringAlarm).GetMetricCompartmentId()).ToDataRes(types.String) }, - "oci.identity.policy.compartmentID": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciIdentityPolicy).CompartmentID, ok = plugin.RawToTValue[string](v.Value, v.Error) - return + "oci.monitoring.alarm.namespace": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciMonitoringAlarm).GetNamespace()).ToDataRes(types.String) }, - "oci.identity.policy.name": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciIdentityPolicy).Name, ok = plugin.RawToTValue[string](v.Value, v.Error) - return + "oci.monitoring.alarm.query": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciMonitoringAlarm).GetQuery()).ToDataRes(types.String) }, - "oci.identity.policy.description": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciIdentityPolicy).Description, ok = plugin.RawToTValue[string](v.Value, v.Error) - return + "oci.monitoring.alarm.severity": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciMonitoringAlarm).GetSeverity()).ToDataRes(types.String) }, - "oci.identity.policy.created": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciIdentityPolicy).Created, ok = plugin.RawToTValue[*time.Time](v.Value, v.Error) - return + "oci.monitoring.alarm.destinations": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciMonitoringAlarm).GetDestinations()).ToDataRes(types.Array(types.String)) }, - "oci.identity.policy.state": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciIdentityPolicy).State, ok = plugin.RawToTValue[string](v.Value, v.Error) - return + "oci.monitoring.alarm.isEnabled": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciMonitoringAlarm).GetIsEnabled()).ToDataRes(types.Bool) }, - "oci.identity.policy.statements": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciIdentityPolicy).Statements, ok = plugin.RawToTValue[[]any](v.Value, v.Error) - return + "oci.monitoring.alarm.state": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciMonitoringAlarm).GetState()).ToDataRes(types.String) }, - "oci.identity.policy.versionDate": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciIdentityPolicy).VersionDate, ok = plugin.RawToTValue[*time.Time](v.Value, v.Error) - return + "oci.vault.secrets": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciVault).GetSecrets()).ToDataRes(types.Array(types.Resource("oci.vault.secret"))) }, - "oci.identity.policy.freeformTags": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciIdentityPolicy).FreeformTags, ok = plugin.RawToTValue[map[string]any](v.Value, v.Error) - return + "oci.vault.secret.id": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciVaultSecret).GetId()).ToDataRes(types.String) }, - "oci.identity.policy.definedTags": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciIdentityPolicy).DefinedTags, ok = plugin.RawToTValue[map[string]any](v.Value, v.Error) - return + "oci.vault.secret.name": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciVaultSecret).GetName()).ToDataRes(types.String) }, - "oci.compute.__id": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciCompute).__id, ok = v.Value.(string) - return + "oci.vault.secret.compartmentID": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciVaultSecret).GetCompartmentID()).ToDataRes(types.String) }, - "oci.compute.instances": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciCompute).Instances, ok = plugin.RawToTValue[[]any](v.Value, v.Error) - return + "oci.vault.secret.kmsVault": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciVaultSecret).GetKmsVault()).ToDataRes(types.Resource("oci.kms.vault")) }, - "oci.compute.images": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciCompute).Images, ok = plugin.RawToTValue[[]any](v.Value, v.Error) - return + "oci.vault.secret.kmsKey": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciVaultSecret).GetKmsKey()).ToDataRes(types.Resource("oci.kms.key")) }, - "oci.compute.instance.__id": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciComputeInstance).__id, ok = v.Value.(string) - return + "oci.vault.secret.description": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciVaultSecret).GetDescription()).ToDataRes(types.String) }, - "oci.compute.instance.id": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciComputeInstance).Id, ok = plugin.RawToTValue[string](v.Value, v.Error) - return + "oci.vault.secret.state": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciVaultSecret).GetState()).ToDataRes(types.String) }, - "oci.compute.instance.name": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciComputeInstance).Name, ok = plugin.RawToTValue[string](v.Value, v.Error) - return + "oci.vault.secret.rotationStatus": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciVaultSecret).GetRotationStatus()).ToDataRes(types.String) }, - "oci.compute.instance.region": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciComputeInstance).Region, ok = plugin.RawToTValue[*mqlOciRegion](v.Value, v.Error) - return + "oci.vault.secret.lastRotationTime": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciVaultSecret).GetLastRotationTime()).ToDataRes(types.Time) }, - "oci.compute.instance.created": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciComputeInstance).Created, ok = plugin.RawToTValue[*time.Time](v.Value, v.Error) - return + "oci.vault.secret.nextRotationTime": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciVaultSecret).GetNextRotationTime()).ToDataRes(types.Time) }, - "oci.compute.instance.state": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciComputeInstance).State, ok = plugin.RawToTValue[string](v.Value, v.Error) - return + "oci.vault.secret.isAutoGenerationEnabled": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciVaultSecret).GetIsAutoGenerationEnabled()).ToDataRes(types.Bool) }, - "oci.compute.instance.shape": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciComputeInstance).Shape, ok = plugin.RawToTValue[string](v.Value, v.Error) - return + "oci.vault.secret.created": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciVaultSecret).GetCreated()).ToDataRes(types.Time) }, - "oci.compute.instance.availabilityDomain": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciComputeInstance).AvailabilityDomain, ok = plugin.RawToTValue[string](v.Value, v.Error) - return + "oci.loadBalancer.loadBalancers": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciLoadBalancer).GetLoadBalancers()).ToDataRes(types.Array(types.Resource("oci.loadBalancer.loadBalancer"))) }, - "oci.compute.instance.compartment": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciComputeInstance).Compartment, ok = plugin.RawToTValue[*mqlOciCompartment](v.Value, v.Error) - return + "oci.loadBalancer.loadBalancer.id": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciLoadBalancerLoadBalancer).GetId()).ToDataRes(types.String) }, - "oci.compute.instance.faultDomain": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciComputeInstance).FaultDomain, ok = plugin.RawToTValue[string](v.Value, v.Error) - return + "oci.loadBalancer.loadBalancer.name": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciLoadBalancerLoadBalancer).GetName()).ToDataRes(types.String) }, - "oci.compute.instance.imageId": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciComputeInstance).ImageId, ok = plugin.RawToTValue[string](v.Value, v.Error) - return + "oci.loadBalancer.loadBalancer.compartmentID": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciLoadBalancerLoadBalancer).GetCompartmentID()).ToDataRes(types.String) }, - "oci.compute.instance.dedicatedVmHostId": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciComputeInstance).DedicatedVmHostId, ok = plugin.RawToTValue[string](v.Value, v.Error) - return + "oci.loadBalancer.loadBalancer.shape": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciLoadBalancerLoadBalancer).GetShape()).ToDataRes(types.String) }, - "oci.compute.instance.freeformTags": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciComputeInstance).FreeformTags, ok = plugin.RawToTValue[map[string]any](v.Value, v.Error) - return + "oci.loadBalancer.loadBalancer.isPrivate": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciLoadBalancerLoadBalancer).GetIsPrivate()).ToDataRes(types.Bool) }, - "oci.compute.instance.definedTags": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciComputeInstance).DefinedTags, ok = plugin.RawToTValue[map[string]any](v.Value, v.Error) - return + "oci.loadBalancer.loadBalancer.isDeleteProtectionEnabled": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciLoadBalancerLoadBalancer).GetIsDeleteProtectionEnabled()).ToDataRes(types.Bool) }, - "oci.compute.image.__id": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciComputeImage).__id, ok = v.Value.(string) - return + "oci.loadBalancer.loadBalancer.state": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciLoadBalancerLoadBalancer).GetState()).ToDataRes(types.String) }, - "oci.compute.image.id": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciComputeImage).Id, ok = plugin.RawToTValue[string](v.Value, v.Error) - return + "oci.loadBalancer.loadBalancer.listeners": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciLoadBalancerLoadBalancer).GetListeners()).ToDataRes(types.Array(types.Resource("oci.loadBalancer.listener"))) }, - "oci.compute.image.name": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciComputeImage).Name, ok = plugin.RawToTValue[string](v.Value, v.Error) - return + "oci.loadBalancer.loadBalancer.backendSets": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciLoadBalancerLoadBalancer).GetBackendSets()).ToDataRes(types.Array(types.Resource("oci.loadBalancer.backendSet"))) }, - "oci.compute.image.region": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciComputeImage).Region, ok = plugin.RawToTValue[*mqlOciRegion](v.Value, v.Error) - return + "oci.loadBalancer.loadBalancer.created": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciLoadBalancerLoadBalancer).GetCreated()).ToDataRes(types.Time) }, - "oci.compute.image.created": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciComputeImage).Created, ok = plugin.RawToTValue[*time.Time](v.Value, v.Error) - return + "oci.loadBalancer.listener.id": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciLoadBalancerListener).GetId()).ToDataRes(types.String) }, - "oci.compute.image.state": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciComputeImage).State, ok = plugin.RawToTValue[string](v.Value, v.Error) - return + "oci.loadBalancer.listener.name": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciLoadBalancerListener).GetName()).ToDataRes(types.String) }, - "oci.compute.image.compartment": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciComputeImage).Compartment, ok = plugin.RawToTValue[*mqlOciCompartment](v.Value, v.Error) - return + "oci.loadBalancer.listener.port": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciLoadBalancerListener).GetPort()).ToDataRes(types.Int) }, - "oci.compute.image.operatingSystem": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciComputeImage).OperatingSystem, ok = plugin.RawToTValue[string](v.Value, v.Error) - return + "oci.loadBalancer.listener.protocol": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciLoadBalancerListener).GetProtocol()).ToDataRes(types.String) }, - "oci.compute.image.operatingSystemVersion": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciComputeImage).OperatingSystemVersion, ok = plugin.RawToTValue[string](v.Value, v.Error) - return + "oci.loadBalancer.listener.defaultBackendSetName": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciLoadBalancerListener).GetDefaultBackendSetName()).ToDataRes(types.String) }, - "oci.compute.image.sizeInMBs": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciComputeImage).SizeInMBs, ok = plugin.RawToTValue[int64](v.Value, v.Error) - return + "oci.loadBalancer.listener.sslProtocols": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciLoadBalancerListener).GetSslProtocols()).ToDataRes(types.Array(types.String)) }, - "oci.compute.image.freeformTags": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciComputeImage).FreeformTags, ok = plugin.RawToTValue[map[string]any](v.Value, v.Error) - return + "oci.loadBalancer.listener.sslCipherSuiteName": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciLoadBalancerListener).GetSslCipherSuiteName()).ToDataRes(types.String) }, - "oci.compute.image.definedTags": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciComputeImage).DefinedTags, ok = plugin.RawToTValue[map[string]any](v.Value, v.Error) - return + "oci.loadBalancer.listener.sslVerifyPeerCertificate": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciLoadBalancerListener).GetSslVerifyPeerCertificate()).ToDataRes(types.Bool) }, - "oci.network.__id": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciNetwork).__id, ok = v.Value.(string) - return + "oci.loadBalancer.backendSet.id": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciLoadBalancerBackendSet).GetId()).ToDataRes(types.String) }, - "oci.network.vcns": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciNetwork).Vcns, ok = plugin.RawToTValue[[]any](v.Value, v.Error) - return + "oci.loadBalancer.backendSet.name": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciLoadBalancerBackendSet).GetName()).ToDataRes(types.String) }, - "oci.network.securityLists": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciNetwork).SecurityLists, ok = plugin.RawToTValue[[]any](v.Value, v.Error) - return + "oci.loadBalancer.backendSet.policy": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciLoadBalancerBackendSet).GetPolicy()).ToDataRes(types.String) }, - "oci.network.vcn.__id": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciNetworkVcn).__id, ok = v.Value.(string) - return + "oci.loadBalancer.backendSet.healthChecker": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciLoadBalancerBackendSet).GetHealthChecker()).ToDataRes(types.Dict) }, - "oci.network.vcn.id": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciNetworkVcn).Id, ok = plugin.RawToTValue[string](v.Value, v.Error) - return + "oci.loadBalancer.backendSet.backendCount": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciLoadBalancerBackendSet).GetBackendCount()).ToDataRes(types.Int) }, - "oci.network.vcn.compartmentID": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciNetworkVcn).CompartmentID, ok = plugin.RawToTValue[string](v.Value, v.Error) - return + "oci.networkFirewall.firewalls": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciNetworkFirewall).GetFirewalls()).ToDataRes(types.Array(types.Resource("oci.networkFirewall.firewall"))) }, - "oci.network.vcn.name": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciNetworkVcn).Name, ok = plugin.RawToTValue[string](v.Value, v.Error) - return + "oci.networkFirewall.policies": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciNetworkFirewall).GetPolicies()).ToDataRes(types.Array(types.Resource("oci.networkFirewall.policy"))) }, - "oci.network.vcn.created": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciNetworkVcn).Created, ok = plugin.RawToTValue[*time.Time](v.Value, v.Error) - return + "oci.networkFirewall.firewall.id": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciNetworkFirewallFirewall).GetId()).ToDataRes(types.String) }, - "oci.network.vcn.state": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciNetworkVcn).State, ok = plugin.RawToTValue[string](v.Value, v.Error) - return + "oci.networkFirewall.firewall.name": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciNetworkFirewallFirewall).GetName()).ToDataRes(types.String) }, - "oci.network.vcn.cidrBlock": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciNetworkVcn).CidrBlock, ok = plugin.RawToTValue[string](v.Value, v.Error) - return + "oci.networkFirewall.firewall.compartmentID": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciNetworkFirewallFirewall).GetCompartmentID()).ToDataRes(types.String) }, - "oci.network.vcn.cidrBlocks": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciNetworkVcn).CidrBlocks, ok = plugin.RawToTValue[[]any](v.Value, v.Error) - return + "oci.networkFirewall.firewall.subnet": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciNetworkFirewallFirewall).GetSubnet()).ToDataRes(types.Resource("oci.network.subnet")) }, - "oci.network.vcn.vcnDomainName": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciNetworkVcn).VcnDomainName, ok = plugin.RawToTValue[string](v.Value, v.Error) - return + "oci.networkFirewall.firewall.policy": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciNetworkFirewallFirewall).GetPolicy()).ToDataRes(types.Resource("oci.networkFirewall.policy")) }, - "oci.network.vcn.defaultDhcpOptionsId": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciNetworkVcn).DefaultDhcpOptionsId, ok = plugin.RawToTValue[string](v.Value, v.Error) - return + "oci.networkFirewall.firewall.ipv4Address": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciNetworkFirewallFirewall).GetIpv4Address()).ToDataRes(types.String) }, - "oci.network.vcn.defaultRouteTableId": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciNetworkVcn).DefaultRouteTableId, ok = plugin.RawToTValue[string](v.Value, v.Error) - return + "oci.networkFirewall.firewall.ipv6Address": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciNetworkFirewallFirewall).GetIpv6Address()).ToDataRes(types.String) }, - "oci.network.vcn.defaultSecurityListId": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciNetworkVcn).DefaultSecurityListId, ok = plugin.RawToTValue[string](v.Value, v.Error) - return + "oci.networkFirewall.firewall.shape": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciNetworkFirewallFirewall).GetShape()).ToDataRes(types.String) }, - "oci.network.vcn.dnsLabel": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciNetworkVcn).DnsLabel, ok = plugin.RawToTValue[string](v.Value, v.Error) + "oci.networkFirewall.firewall.state": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciNetworkFirewallFirewall).GetState()).ToDataRes(types.String) + }, + "oci.networkFirewall.firewall.created": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciNetworkFirewallFirewall).GetCreated()).ToDataRes(types.Time) + }, + "oci.networkFirewall.firewall.timeUpdated": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciNetworkFirewallFirewall).GetTimeUpdated()).ToDataRes(types.Time) + }, + "oci.networkFirewall.policy.id": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciNetworkFirewallPolicy).GetId()).ToDataRes(types.String) + }, + "oci.networkFirewall.policy.name": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciNetworkFirewallPolicy).GetName()).ToDataRes(types.String) + }, + "oci.networkFirewall.policy.compartmentID": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciNetworkFirewallPolicy).GetCompartmentID()).ToDataRes(types.String) + }, + "oci.networkFirewall.policy.description": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciNetworkFirewallPolicy).GetDescription()).ToDataRes(types.String) + }, + "oci.networkFirewall.policy.attachedFirewallCount": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciNetworkFirewallPolicy).GetAttachedFirewallCount()).ToDataRes(types.Int) + }, + "oci.networkFirewall.policy.state": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciNetworkFirewallPolicy).GetState()).ToDataRes(types.String) + }, + "oci.networkFirewall.policy.created": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciNetworkFirewallPolicy).GetCreated()).ToDataRes(types.Time) + }, + "oci.oke.clusters": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciOke).GetClusters()).ToDataRes(types.Array(types.Resource("oci.oke.cluster"))) + }, + "oci.oke.cluster.id": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciOkeCluster).GetId()).ToDataRes(types.String) + }, + "oci.oke.cluster.name": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciOkeCluster).GetName()).ToDataRes(types.String) + }, + "oci.oke.cluster.compartmentID": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciOkeCluster).GetCompartmentID()).ToDataRes(types.String) + }, + "oci.oke.cluster.kubernetesVersion": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciOkeCluster).GetKubernetesVersion()).ToDataRes(types.String) + }, + "oci.oke.cluster.type": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciOkeCluster).GetType()).ToDataRes(types.String) + }, + "oci.oke.cluster.vcn": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciOkeCluster).GetVcn()).ToDataRes(types.Resource("oci.network.vcn")) + }, + "oci.oke.cluster.kmsKey": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciOkeCluster).GetKmsKey()).ToDataRes(types.Resource("oci.kms.key")) + }, + "oci.oke.cluster.isPublicEndpointEnabled": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciOkeCluster).GetIsPublicEndpointEnabled()).ToDataRes(types.Bool) + }, + "oci.oke.cluster.publicEndpoint": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciOkeCluster).GetPublicEndpoint()).ToDataRes(types.String) + }, + "oci.oke.cluster.privateEndpoint": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciOkeCluster).GetPrivateEndpoint()).ToDataRes(types.String) + }, + "oci.oke.cluster.isImagePolicyEnabled": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciOkeCluster).GetIsImagePolicyEnabled()).ToDataRes(types.Bool) + }, + "oci.oke.cluster.availableKubernetesUpgrades": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciOkeCluster).GetAvailableKubernetesUpgrades()).ToDataRes(types.Array(types.String)) + }, + "oci.oke.cluster.isPodSecurityPolicyEnabled": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciOkeCluster).GetIsPodSecurityPolicyEnabled()).ToDataRes(types.Bool) + }, + "oci.oke.cluster.state": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciOkeCluster).GetState()).ToDataRes(types.String) + }, + "oci.oke.cluster.nodePools": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciOkeCluster).GetNodePools()).ToDataRes(types.Array(types.Resource("oci.oke.nodePool"))) + }, + "oci.oke.cluster.created": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciOkeCluster).GetCreated()).ToDataRes(types.Time) + }, + "oci.oke.nodePool.id": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciOkeNodePool).GetId()).ToDataRes(types.String) + }, + "oci.oke.nodePool.name": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciOkeNodePool).GetName()).ToDataRes(types.String) + }, + "oci.oke.nodePool.compartmentID": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciOkeNodePool).GetCompartmentID()).ToDataRes(types.String) + }, + "oci.oke.nodePool.kubernetesVersion": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciOkeNodePool).GetKubernetesVersion()).ToDataRes(types.String) + }, + "oci.oke.nodePool.nodeShape": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciOkeNodePool).GetNodeShape()).ToDataRes(types.String) + }, + "oci.oke.nodePool.nodeShapeConfig": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciOkeNodePool).GetNodeShapeConfig()).ToDataRes(types.Dict) + }, + "oci.oke.nodePool.nodeImageName": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciOkeNodePool).GetNodeImageName()).ToDataRes(types.String) + }, + "oci.oke.nodePool.sshPublicKey": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciOkeNodePool).GetSshPublicKey()).ToDataRes(types.String) + }, + "oci.oke.nodePool.state": func(r plugin.Resource) *plugin.DataRes { + return (r.(*mqlOciOkeNodePool).GetState()).ToDataRes(types.String) + }, +} + +func GetData(resource plugin.Resource, field string, args map[string]*llx.RawData) *plugin.DataRes { + f, ok := getDataFields[resource.MqlName()+"."+field] + if !ok { + return &plugin.DataRes{Error: "cannot find '" + field + "' in resource '" + resource.MqlName() + "'"} + } + + return f(resource) +} + +var setDataFields = map[string]func(r plugin.Resource, v *llx.RawData) bool{ + "oci.__id": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOci).__id, ok = v.Value.(string) return }, - "oci.network.vcn.freeformTags": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciNetworkVcn).FreeformTags, ok = plugin.RawToTValue[map[string]any](v.Value, v.Error) + "oci.regions": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOci).Regions, ok = plugin.RawToTValue[[]any](v.Value, v.Error) return }, - "oci.network.vcn.definedTags": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciNetworkVcn).DefinedTags, ok = plugin.RawToTValue[map[string]any](v.Value, v.Error) + "oci.compartments": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOci).Compartments, ok = plugin.RawToTValue[[]any](v.Value, v.Error) return }, - "oci.network.securityList.__id": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciNetworkSecurityList).__id, ok = v.Value.(string) + "oci.tenancy.__id": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciTenancy).__id, ok = v.Value.(string) return }, - "oci.network.securityList.id": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciNetworkSecurityList).Id, ok = plugin.RawToTValue[string](v.Value, v.Error) + "oci.tenancy.id": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciTenancy).Id, ok = plugin.RawToTValue[string](v.Value, v.Error) return }, - "oci.network.securityList.compartmentID": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciNetworkSecurityList).CompartmentID, ok = plugin.RawToTValue[string](v.Value, v.Error) + "oci.tenancy.name": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciTenancy).Name, ok = plugin.RawToTValue[string](v.Value, v.Error) return }, - "oci.network.securityList.name": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciNetworkSecurityList).Name, ok = plugin.RawToTValue[string](v.Value, v.Error) + "oci.tenancy.description": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciTenancy).Description, ok = plugin.RawToTValue[string](v.Value, v.Error) return }, - "oci.network.securityList.created": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciNetworkSecurityList).Created, ok = plugin.RawToTValue[*time.Time](v.Value, v.Error) + "oci.tenancy.retentionPeriod": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciTenancy).RetentionPeriod, ok = plugin.RawToTValue[*time.Time](v.Value, v.Error) return }, - "oci.network.securityList.state": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciNetworkSecurityList).State, ok = plugin.RawToTValue[string](v.Value, v.Error) + "oci.region.__id": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciRegion).__id, ok = v.Value.(string) return }, - "oci.network.securityList.egressSecurityRules": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciNetworkSecurityList).EgressSecurityRules, ok = plugin.RawToTValue[[]any](v.Value, v.Error) + "oci.region.id": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciRegion).Id, ok = plugin.RawToTValue[string](v.Value, v.Error) return }, - "oci.network.securityList.ingressSecurityRules": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciNetworkSecurityList).IngressSecurityRules, ok = plugin.RawToTValue[[]any](v.Value, v.Error) + "oci.region.name": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciRegion).Name, ok = plugin.RawToTValue[string](v.Value, v.Error) return }, - "oci.network.securityList.vcnId": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciNetworkSecurityList).VcnId, ok = plugin.RawToTValue[string](v.Value, v.Error) + "oci.region.isHomeRegion": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciRegion).IsHomeRegion, ok = plugin.RawToTValue[bool](v.Value, v.Error) return }, - "oci.network.securityList.freeformTags": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciNetworkSecurityList).FreeformTags, ok = plugin.RawToTValue[map[string]any](v.Value, v.Error) + "oci.region.status": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciRegion).Status, ok = plugin.RawToTValue[string](v.Value, v.Error) return }, - "oci.network.securityList.definedTags": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciNetworkSecurityList).DefinedTags, ok = plugin.RawToTValue[map[string]any](v.Value, v.Error) + "oci.compartment.__id": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciCompartment).__id, ok = v.Value.(string) return }, - "oci.objectStorage.__id": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciObjectStorage).__id, ok = v.Value.(string) + "oci.compartment.id": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciCompartment).Id, ok = plugin.RawToTValue[string](v.Value, v.Error) return }, - "oci.objectStorage.namespace": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciObjectStorage).Namespace, ok = plugin.RawToTValue[string](v.Value, v.Error) + "oci.compartment.name": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciCompartment).Name, ok = plugin.RawToTValue[string](v.Value, v.Error) return }, - "oci.objectStorage.buckets": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciObjectStorage).Buckets, ok = plugin.RawToTValue[[]any](v.Value, v.Error) + "oci.compartment.description": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciCompartment).Description, ok = plugin.RawToTValue[string](v.Value, v.Error) return }, - "oci.objectStorage.bucket.__id": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciObjectStorageBucket).__id, ok = v.Value.(string) + "oci.compartment.created": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciCompartment).Created, ok = plugin.RawToTValue[*time.Time](v.Value, v.Error) return }, - "oci.objectStorage.bucket.namespace": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciObjectStorageBucket).Namespace, ok = plugin.RawToTValue[string](v.Value, v.Error) + "oci.compartment.state": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciCompartment).State, ok = plugin.RawToTValue[string](v.Value, v.Error) return }, - "oci.objectStorage.bucket.name": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciObjectStorageBucket).Name, ok = plugin.RawToTValue[string](v.Value, v.Error) + "oci.identity.__id": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciIdentity).__id, ok = v.Value.(string) return }, - "oci.objectStorage.bucket.compartmentID": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciObjectStorageBucket).CompartmentID, ok = plugin.RawToTValue[string](v.Value, v.Error) + "oci.identity.users": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciIdentity).Users, ok = plugin.RawToTValue[[]any](v.Value, v.Error) return }, - "oci.objectStorage.bucket.created": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciObjectStorageBucket).Created, ok = plugin.RawToTValue[*time.Time](v.Value, v.Error) + "oci.identity.groups": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciIdentity).Groups, ok = plugin.RawToTValue[[]any](v.Value, v.Error) return }, - "oci.objectStorage.bucket.region": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciObjectStorageBucket).Region, ok = plugin.RawToTValue[*mqlOciRegion](v.Value, v.Error) + "oci.identity.policies": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciIdentity).Policies, ok = plugin.RawToTValue[[]any](v.Value, v.Error) return }, - "oci.objectStorage.bucket.publicAccessType": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciObjectStorageBucket).PublicAccessType, ok = plugin.RawToTValue[string](v.Value, v.Error) + "oci.identity.user.__id": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciIdentityUser).__id, ok = v.Value.(string) return }, - "oci.objectStorage.bucket.storageTier": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciObjectStorageBucket).StorageTier, ok = plugin.RawToTValue[string](v.Value, v.Error) + "oci.identity.user.id": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciIdentityUser).Id, ok = plugin.RawToTValue[string](v.Value, v.Error) return }, - "oci.objectStorage.bucket.autoTiering": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciObjectStorageBucket).AutoTiering, ok = plugin.RawToTValue[string](v.Value, v.Error) + "oci.identity.user.compartmentID": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciIdentityUser).CompartmentID, ok = plugin.RawToTValue[string](v.Value, v.Error) return }, - "oci.objectStorage.bucket.versioning": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciObjectStorageBucket).Versioning, ok = plugin.RawToTValue[string](v.Value, v.Error) + "oci.identity.user.name": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciIdentityUser).Name, ok = plugin.RawToTValue[string](v.Value, v.Error) return }, - "oci.objectStorage.bucket.objectEventsEnabled": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciObjectStorageBucket).ObjectEventsEnabled, ok = plugin.RawToTValue[bool](v.Value, v.Error) + "oci.identity.user.description": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciIdentityUser).Description, ok = plugin.RawToTValue[string](v.Value, v.Error) return }, - "oci.objectStorage.bucket.replicationEnabled": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciObjectStorageBucket).ReplicationEnabled, ok = plugin.RawToTValue[bool](v.Value, v.Error) + "oci.identity.user.created": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciIdentityUser).Created, ok = plugin.RawToTValue[*time.Time](v.Value, v.Error) return }, - "oci.objectStorage.bucket.id": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciObjectStorageBucket).Id, ok = plugin.RawToTValue[string](v.Value, v.Error) + "oci.identity.user.state": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciIdentityUser).State, ok = plugin.RawToTValue[string](v.Value, v.Error) return }, - "oci.objectStorage.bucket.isReadOnly": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciObjectStorageBucket).IsReadOnly, ok = plugin.RawToTValue[bool](v.Value, v.Error) + "oci.identity.user.mfaActivated": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciIdentityUser).MfaActivated, ok = plugin.RawToTValue[bool](v.Value, v.Error) return }, - "oci.objectStorage.bucket.etag": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciObjectStorageBucket).Etag, ok = plugin.RawToTValue[string](v.Value, v.Error) + "oci.identity.user.email": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciIdentityUser).Email, ok = plugin.RawToTValue[string](v.Value, v.Error) return }, - "oci.objectStorage.bucket.kmsKeyId": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciObjectStorageBucket).KmsKeyId, ok = plugin.RawToTValue[string](v.Value, v.Error) + "oci.identity.user.emailVerified": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciIdentityUser).EmailVerified, ok = plugin.RawToTValue[bool](v.Value, v.Error) return }, - "oci.objectStorage.bucket.approximateCount": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciObjectStorageBucket).ApproximateCount, ok = plugin.RawToTValue[int64](v.Value, v.Error) + "oci.identity.user.capabilities": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciIdentityUser).Capabilities, ok = plugin.RawToTValue[map[string]any](v.Value, v.Error) return }, - "oci.objectStorage.bucket.approximateSize": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciObjectStorageBucket).ApproximateSize, ok = plugin.RawToTValue[int64](v.Value, v.Error) + "oci.identity.user.lastLogin": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciIdentityUser).LastLogin, ok = plugin.RawToTValue[*time.Time](v.Value, v.Error) return }, - "oci.objectStorage.bucket.freeformTags": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciObjectStorageBucket).FreeformTags, ok = plugin.RawToTValue[map[string]any](v.Value, v.Error) + "oci.identity.user.previousLogin": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciIdentityUser).PreviousLogin, ok = plugin.RawToTValue[*time.Time](v.Value, v.Error) return }, - "oci.objectStorage.bucket.definedTags": func(r plugin.Resource, v *llx.RawData) (ok bool) { - r.(*mqlOciObjectStorageBucket).DefinedTags, ok = plugin.RawToTValue[map[string]any](v.Value, v.Error) + "oci.identity.user.freeformTags": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciIdentityUser).FreeformTags, ok = plugin.RawToTValue[map[string]any](v.Value, v.Error) + return + }, + "oci.identity.user.definedTags": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciIdentityUser).DefinedTags, ok = plugin.RawToTValue[map[string]any](v.Value, v.Error) + return + }, + "oci.identity.user.apiKeys": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciIdentityUser).ApiKeys, ok = plugin.RawToTValue[[]any](v.Value, v.Error) + return + }, + "oci.identity.user.customerSecretKeys": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciIdentityUser).CustomerSecretKeys, ok = plugin.RawToTValue[[]any](v.Value, v.Error) + return + }, + "oci.identity.user.authTokens": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciIdentityUser).AuthTokens, ok = plugin.RawToTValue[[]any](v.Value, v.Error) + return + }, + "oci.identity.user.groups": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciIdentityUser).Groups, ok = plugin.RawToTValue[[]any](v.Value, v.Error) + return + }, + "oci.identity.apiKey.__id": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciIdentityApiKey).__id, ok = v.Value.(string) + return + }, + "oci.identity.apiKey.id": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciIdentityApiKey).Id, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.identity.apiKey.value": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciIdentityApiKey).Value, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.identity.apiKey.fingerprint": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciIdentityApiKey).Fingerprint, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.identity.apiKey.created": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciIdentityApiKey).Created, ok = plugin.RawToTValue[*time.Time](v.Value, v.Error) + return + }, + "oci.identity.apiKey.state": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciIdentityApiKey).State, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.identity.customerSecretKey.__id": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciIdentityCustomerSecretKey).__id, ok = v.Value.(string) + return + }, + "oci.identity.customerSecretKey.id": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciIdentityCustomerSecretKey).Id, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.identity.customerSecretKey.name": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciIdentityCustomerSecretKey).Name, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.identity.customerSecretKey.created": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciIdentityCustomerSecretKey).Created, ok = plugin.RawToTValue[*time.Time](v.Value, v.Error) return }, + "oci.identity.customerSecretKey.state": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciIdentityCustomerSecretKey).State, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.identity.authToken.__id": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciIdentityAuthToken).__id, ok = v.Value.(string) + return + }, + "oci.identity.authToken.id": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciIdentityAuthToken).Id, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.identity.authToken.description": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciIdentityAuthToken).Description, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.identity.authToken.created": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciIdentityAuthToken).Created, ok = plugin.RawToTValue[*time.Time](v.Value, v.Error) + return + }, + "oci.identity.authToken.expires": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciIdentityAuthToken).Expires, ok = plugin.RawToTValue[*time.Time](v.Value, v.Error) + return + }, + "oci.identity.authToken.state": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciIdentityAuthToken).State, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.identity.group.__id": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciIdentityGroup).__id, ok = v.Value.(string) + return + }, + "oci.identity.group.id": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciIdentityGroup).Id, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.identity.group.compartmentID": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciIdentityGroup).CompartmentID, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.identity.group.name": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciIdentityGroup).Name, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.identity.group.description": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciIdentityGroup).Description, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.identity.group.created": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciIdentityGroup).Created, ok = plugin.RawToTValue[*time.Time](v.Value, v.Error) + return + }, + "oci.identity.group.state": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciIdentityGroup).State, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.identity.group.freeformTags": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciIdentityGroup).FreeformTags, ok = plugin.RawToTValue[map[string]any](v.Value, v.Error) + return + }, + "oci.identity.group.definedTags": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciIdentityGroup).DefinedTags, ok = plugin.RawToTValue[map[string]any](v.Value, v.Error) + return + }, + "oci.identity.policy.__id": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciIdentityPolicy).__id, ok = v.Value.(string) + return + }, + "oci.identity.policy.id": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciIdentityPolicy).Id, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.identity.policy.compartmentID": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciIdentityPolicy).CompartmentID, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.identity.policy.name": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciIdentityPolicy).Name, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.identity.policy.description": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciIdentityPolicy).Description, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.identity.policy.created": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciIdentityPolicy).Created, ok = plugin.RawToTValue[*time.Time](v.Value, v.Error) + return + }, + "oci.identity.policy.state": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciIdentityPolicy).State, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.identity.policy.statements": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciIdentityPolicy).Statements, ok = plugin.RawToTValue[[]any](v.Value, v.Error) + return + }, + "oci.identity.policy.versionDate": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciIdentityPolicy).VersionDate, ok = plugin.RawToTValue[*time.Time](v.Value, v.Error) + return + }, + "oci.identity.policy.freeformTags": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciIdentityPolicy).FreeformTags, ok = plugin.RawToTValue[map[string]any](v.Value, v.Error) + return + }, + "oci.identity.policy.definedTags": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciIdentityPolicy).DefinedTags, ok = plugin.RawToTValue[map[string]any](v.Value, v.Error) + return + }, + "oci.compute.__id": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciCompute).__id, ok = v.Value.(string) + return + }, + "oci.compute.instances": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciCompute).Instances, ok = plugin.RawToTValue[[]any](v.Value, v.Error) + return + }, + "oci.compute.images": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciCompute).Images, ok = plugin.RawToTValue[[]any](v.Value, v.Error) + return + }, + "oci.compute.blockVolumes": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciCompute).BlockVolumes, ok = plugin.RawToTValue[[]any](v.Value, v.Error) + return + }, + "oci.compute.bootVolumes": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciCompute).BootVolumes, ok = plugin.RawToTValue[[]any](v.Value, v.Error) + return + }, + "oci.compute.instance.__id": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciComputeInstance).__id, ok = v.Value.(string) + return + }, + "oci.compute.instance.id": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciComputeInstance).Id, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.compute.instance.name": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciComputeInstance).Name, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.compute.instance.region": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciComputeInstance).Region, ok = plugin.RawToTValue[*mqlOciRegion](v.Value, v.Error) + return + }, + "oci.compute.instance.created": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciComputeInstance).Created, ok = plugin.RawToTValue[*time.Time](v.Value, v.Error) + return + }, + "oci.compute.instance.state": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciComputeInstance).State, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.compute.instance.shape": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciComputeInstance).Shape, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.compute.instance.availabilityDomain": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciComputeInstance).AvailabilityDomain, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.compute.instance.compartment": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciComputeInstance).Compartment, ok = plugin.RawToTValue[*mqlOciCompartment](v.Value, v.Error) + return + }, + "oci.compute.instance.faultDomain": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciComputeInstance).FaultDomain, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.compute.instance.imageId": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciComputeInstance).ImageId, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.compute.instance.dedicatedVmHostId": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciComputeInstance).DedicatedVmHostId, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.compute.instance.platformConfig": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciComputeInstance).PlatformConfig, ok = plugin.RawToTValue[any](v.Value, v.Error) + return + }, + "oci.compute.instance.launchOptions": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciComputeInstance).LaunchOptions, ok = plugin.RawToTValue[any](v.Value, v.Error) + return + }, + "oci.compute.instance.instanceOptions": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciComputeInstance).InstanceOptions, ok = plugin.RawToTValue[any](v.Value, v.Error) + return + }, + "oci.compute.instance.shapeConfig": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciComputeInstance).ShapeConfig, ok = plugin.RawToTValue[any](v.Value, v.Error) + return + }, + "oci.compute.instance.sourceDetails": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciComputeInstance).SourceDetails, ok = plugin.RawToTValue[any](v.Value, v.Error) + return + }, + "oci.compute.instance.metadata": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciComputeInstance).Metadata, ok = plugin.RawToTValue[map[string]any](v.Value, v.Error) + return + }, + "oci.compute.instance.timeMaintenanceRebootDue": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciComputeInstance).TimeMaintenanceRebootDue, ok = plugin.RawToTValue[*time.Time](v.Value, v.Error) + return + }, + "oci.compute.instance.freeformTags": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciComputeInstance).FreeformTags, ok = plugin.RawToTValue[map[string]any](v.Value, v.Error) + return + }, + "oci.compute.instance.definedTags": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciComputeInstance).DefinedTags, ok = plugin.RawToTValue[map[string]any](v.Value, v.Error) + return + }, + "oci.compute.image.__id": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciComputeImage).__id, ok = v.Value.(string) + return + }, + "oci.compute.image.id": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciComputeImage).Id, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.compute.image.name": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciComputeImage).Name, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.compute.image.region": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciComputeImage).Region, ok = plugin.RawToTValue[*mqlOciRegion](v.Value, v.Error) + return + }, + "oci.compute.image.created": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciComputeImage).Created, ok = plugin.RawToTValue[*time.Time](v.Value, v.Error) + return + }, + "oci.compute.image.state": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciComputeImage).State, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.compute.image.compartment": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciComputeImage).Compartment, ok = plugin.RawToTValue[*mqlOciCompartment](v.Value, v.Error) + return + }, + "oci.compute.image.operatingSystem": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciComputeImage).OperatingSystem, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.compute.image.operatingSystemVersion": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciComputeImage).OperatingSystemVersion, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.compute.image.sizeInMBs": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciComputeImage).SizeInMBs, ok = plugin.RawToTValue[int64](v.Value, v.Error) + return + }, + "oci.compute.image.freeformTags": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciComputeImage).FreeformTags, ok = plugin.RawToTValue[map[string]any](v.Value, v.Error) + return + }, + "oci.compute.image.definedTags": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciComputeImage).DefinedTags, ok = plugin.RawToTValue[map[string]any](v.Value, v.Error) + return + }, + "oci.compute.blockVolume.__id": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciComputeBlockVolume).__id, ok = v.Value.(string) + return + }, + "oci.compute.blockVolume.id": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciComputeBlockVolume).Id, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.compute.blockVolume.name": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciComputeBlockVolume).Name, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.compute.blockVolume.compartmentID": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciComputeBlockVolume).CompartmentID, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.compute.blockVolume.availabilityDomain": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciComputeBlockVolume).AvailabilityDomain, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.compute.blockVolume.sizeInGBs": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciComputeBlockVolume).SizeInGBs, ok = plugin.RawToTValue[int64](v.Value, v.Error) + return + }, + "oci.compute.blockVolume.vpusPerGB": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciComputeBlockVolume).VpusPerGB, ok = plugin.RawToTValue[int64](v.Value, v.Error) + return + }, + "oci.compute.blockVolume.state": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciComputeBlockVolume).State, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.compute.blockVolume.isHydrated": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciComputeBlockVolume).IsHydrated, ok = plugin.RawToTValue[bool](v.Value, v.Error) + return + }, + "oci.compute.blockVolume.kmsKey": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciComputeBlockVolume).KmsKey, ok = plugin.RawToTValue[*mqlOciKmsKey](v.Value, v.Error) + return + }, + "oci.compute.blockVolume.isAutoTuneEnabled": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciComputeBlockVolume).IsAutoTuneEnabled, ok = plugin.RawToTValue[bool](v.Value, v.Error) + return + }, + "oci.compute.blockVolume.created": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciComputeBlockVolume).Created, ok = plugin.RawToTValue[*time.Time](v.Value, v.Error) + return + }, + "oci.compute.bootVolume.__id": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciComputeBootVolume).__id, ok = v.Value.(string) + return + }, + "oci.compute.bootVolume.id": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciComputeBootVolume).Id, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.compute.bootVolume.name": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciComputeBootVolume).Name, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.compute.bootVolume.compartmentID": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciComputeBootVolume).CompartmentID, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.compute.bootVolume.availabilityDomain": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciComputeBootVolume).AvailabilityDomain, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.compute.bootVolume.sizeInGBs": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciComputeBootVolume).SizeInGBs, ok = plugin.RawToTValue[int64](v.Value, v.Error) + return + }, + "oci.compute.bootVolume.imageId": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciComputeBootVolume).ImageId, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.compute.bootVolume.state": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciComputeBootVolume).State, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.compute.bootVolume.kmsKey": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciComputeBootVolume).KmsKey, ok = plugin.RawToTValue[*mqlOciKmsKey](v.Value, v.Error) + return + }, + "oci.compute.bootVolume.created": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciComputeBootVolume).Created, ok = plugin.RawToTValue[*time.Time](v.Value, v.Error) + return + }, + "oci.network.__id": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciNetwork).__id, ok = v.Value.(string) + return + }, + "oci.network.vcns": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciNetwork).Vcns, ok = plugin.RawToTValue[[]any](v.Value, v.Error) + return + }, + "oci.network.subnets": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciNetwork).Subnets, ok = plugin.RawToTValue[[]any](v.Value, v.Error) + return + }, + "oci.network.securityLists": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciNetwork).SecurityLists, ok = plugin.RawToTValue[[]any](v.Value, v.Error) + return + }, + "oci.network.networkSecurityGroups": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciNetwork).NetworkSecurityGroups, ok = plugin.RawToTValue[[]any](v.Value, v.Error) + return + }, + "oci.network.vcn.__id": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciNetworkVcn).__id, ok = v.Value.(string) + return + }, + "oci.network.vcn.id": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciNetworkVcn).Id, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.network.vcn.compartmentID": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciNetworkVcn).CompartmentID, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.network.vcn.name": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciNetworkVcn).Name, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.network.vcn.created": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciNetworkVcn).Created, ok = plugin.RawToTValue[*time.Time](v.Value, v.Error) + return + }, + "oci.network.vcn.state": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciNetworkVcn).State, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.network.vcn.cidrBlock": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciNetworkVcn).CidrBlock, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.network.vcn.cidrBlocks": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciNetworkVcn).CidrBlocks, ok = plugin.RawToTValue[[]any](v.Value, v.Error) + return + }, + "oci.network.vcn.vcnDomainName": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciNetworkVcn).VcnDomainName, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.network.vcn.defaultDhcpOptionsId": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciNetworkVcn).DefaultDhcpOptionsId, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.network.vcn.defaultRouteTableId": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciNetworkVcn).DefaultRouteTableId, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.network.vcn.defaultSecurityListId": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciNetworkVcn).DefaultSecurityListId, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.network.vcn.dnsLabel": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciNetworkVcn).DnsLabel, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.network.vcn.freeformTags": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciNetworkVcn).FreeformTags, ok = plugin.RawToTValue[map[string]any](v.Value, v.Error) + return + }, + "oci.network.vcn.definedTags": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciNetworkVcn).DefinedTags, ok = plugin.RawToTValue[map[string]any](v.Value, v.Error) + return + }, + "oci.network.subnet.__id": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciNetworkSubnet).__id, ok = v.Value.(string) + return + }, + "oci.network.subnet.id": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciNetworkSubnet).Id, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.network.subnet.name": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciNetworkSubnet).Name, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.network.subnet.compartmentID": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciNetworkSubnet).CompartmentID, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.network.subnet.vcn": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciNetworkSubnet).Vcn, ok = plugin.RawToTValue[*mqlOciNetworkVcn](v.Value, v.Error) + return + }, + "oci.network.subnet.availabilityDomain": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciNetworkSubnet).AvailabilityDomain, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.network.subnet.cidrBlock": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciNetworkSubnet).CidrBlock, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.network.subnet.state": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciNetworkSubnet).State, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.network.subnet.dnsLabel": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciNetworkSubnet).DnsLabel, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.network.subnet.subnetDomainName": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciNetworkSubnet).SubnetDomainName, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.network.subnet.prohibitPublicIpOnVnic": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciNetworkSubnet).ProhibitPublicIpOnVnic, ok = plugin.RawToTValue[bool](v.Value, v.Error) + return + }, + "oci.network.subnet.prohibitInternetIngress": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciNetworkSubnet).ProhibitInternetIngress, ok = plugin.RawToTValue[bool](v.Value, v.Error) + return + }, + "oci.network.subnet.created": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciNetworkSubnet).Created, ok = plugin.RawToTValue[*time.Time](v.Value, v.Error) + return + }, + "oci.network.subnet.freeformTags": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciNetworkSubnet).FreeformTags, ok = plugin.RawToTValue[map[string]any](v.Value, v.Error) + return + }, + "oci.network.subnet.definedTags": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciNetworkSubnet).DefinedTags, ok = plugin.RawToTValue[map[string]any](v.Value, v.Error) + return + }, + "oci.network.securityList.__id": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciNetworkSecurityList).__id, ok = v.Value.(string) + return + }, + "oci.network.securityList.id": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciNetworkSecurityList).Id, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.network.securityList.compartmentID": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciNetworkSecurityList).CompartmentID, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.network.securityList.name": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciNetworkSecurityList).Name, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.network.securityList.created": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciNetworkSecurityList).Created, ok = plugin.RawToTValue[*time.Time](v.Value, v.Error) + return + }, + "oci.network.securityList.state": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciNetworkSecurityList).State, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.network.securityList.egressSecurityRules": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciNetworkSecurityList).EgressSecurityRules, ok = plugin.RawToTValue[[]any](v.Value, v.Error) + return + }, + "oci.network.securityList.ingressSecurityRules": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciNetworkSecurityList).IngressSecurityRules, ok = plugin.RawToTValue[[]any](v.Value, v.Error) + return + }, + "oci.network.securityList.vcnId": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciNetworkSecurityList).VcnId, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.network.securityList.vcn": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciNetworkSecurityList).Vcn, ok = plugin.RawToTValue[*mqlOciNetworkVcn](v.Value, v.Error) + return + }, + "oci.network.securityList.freeformTags": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciNetworkSecurityList).FreeformTags, ok = plugin.RawToTValue[map[string]any](v.Value, v.Error) + return + }, + "oci.network.securityList.definedTags": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciNetworkSecurityList).DefinedTags, ok = plugin.RawToTValue[map[string]any](v.Value, v.Error) + return + }, + "oci.network.networkSecurityGroup.__id": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciNetworkNetworkSecurityGroup).__id, ok = v.Value.(string) + return + }, + "oci.network.networkSecurityGroup.id": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciNetworkNetworkSecurityGroup).Id, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.network.networkSecurityGroup.name": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciNetworkNetworkSecurityGroup).Name, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.network.networkSecurityGroup.compartmentID": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciNetworkNetworkSecurityGroup).CompartmentID, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.network.networkSecurityGroup.vcn": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciNetworkNetworkSecurityGroup).Vcn, ok = plugin.RawToTValue[*mqlOciNetworkVcn](v.Value, v.Error) + return + }, + "oci.network.networkSecurityGroup.state": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciNetworkNetworkSecurityGroup).State, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.network.networkSecurityGroup.created": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciNetworkNetworkSecurityGroup).Created, ok = plugin.RawToTValue[*time.Time](v.Value, v.Error) + return + }, + "oci.network.networkSecurityGroup.freeformTags": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciNetworkNetworkSecurityGroup).FreeformTags, ok = plugin.RawToTValue[map[string]any](v.Value, v.Error) + return + }, + "oci.network.networkSecurityGroup.definedTags": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciNetworkNetworkSecurityGroup).DefinedTags, ok = plugin.RawToTValue[map[string]any](v.Value, v.Error) + return + }, + "oci.network.networkSecurityGroup.ingressSecurityRules": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciNetworkNetworkSecurityGroup).IngressSecurityRules, ok = plugin.RawToTValue[[]any](v.Value, v.Error) + return + }, + "oci.network.networkSecurityGroup.egressSecurityRules": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciNetworkNetworkSecurityGroup).EgressSecurityRules, ok = plugin.RawToTValue[[]any](v.Value, v.Error) + return + }, + "oci.logging.__id": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciLogging).__id, ok = v.Value.(string) + return + }, + "oci.logging.logGroups": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciLogging).LogGroups, ok = plugin.RawToTValue[[]any](v.Value, v.Error) + return + }, + "oci.logging.logGroup.__id": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciLoggingLogGroup).__id, ok = v.Value.(string) + return + }, + "oci.logging.logGroup.id": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciLoggingLogGroup).Id, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.logging.logGroup.name": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciLoggingLogGroup).Name, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.logging.logGroup.description": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciLoggingLogGroup).Description, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.logging.logGroup.compartmentID": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciLoggingLogGroup).CompartmentID, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.logging.logGroup.state": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciLoggingLogGroup).State, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.logging.logGroup.logs": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciLoggingLogGroup).Logs, ok = plugin.RawToTValue[[]any](v.Value, v.Error) + return + }, + "oci.logging.logGroup.created": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciLoggingLogGroup).Created, ok = plugin.RawToTValue[*time.Time](v.Value, v.Error) + return + }, + "oci.logging.log.__id": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciLoggingLog).__id, ok = v.Value.(string) + return + }, + "oci.logging.log.id": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciLoggingLog).Id, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.logging.log.name": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciLoggingLog).Name, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.logging.log.logType": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciLoggingLog).LogType, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.logging.log.logGroup": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciLoggingLog).LogGroup, ok = plugin.RawToTValue[*mqlOciLoggingLogGroup](v.Value, v.Error) + return + }, + "oci.logging.log.isEnabled": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciLoggingLog).IsEnabled, ok = plugin.RawToTValue[bool](v.Value, v.Error) + return + }, + "oci.logging.log.state": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciLoggingLog).State, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.logging.log.retentionDuration": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciLoggingLog).RetentionDuration, ok = plugin.RawToTValue[int64](v.Value, v.Error) + return + }, + "oci.logging.log.configuration": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciLoggingLog).Configuration, ok = plugin.RawToTValue[any](v.Value, v.Error) + return + }, + "oci.logging.log.created": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciLoggingLog).Created, ok = plugin.RawToTValue[*time.Time](v.Value, v.Error) + return + }, + "oci.logging.log.timeLastModified": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciLoggingLog).TimeLastModified, ok = plugin.RawToTValue[*time.Time](v.Value, v.Error) + return + }, + "oci.kms.__id": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciKms).__id, ok = v.Value.(string) + return + }, + "oci.kms.vaults": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciKms).Vaults, ok = plugin.RawToTValue[[]any](v.Value, v.Error) + return + }, + "oci.kms.vault.__id": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciKmsVault).__id, ok = v.Value.(string) + return + }, + "oci.kms.vault.id": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciKmsVault).Id, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.kms.vault.name": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciKmsVault).Name, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.kms.vault.compartmentID": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciKmsVault).CompartmentID, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.kms.vault.vaultType": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciKmsVault).VaultType, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.kms.vault.state": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciKmsVault).State, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.kms.vault.managementEndpoint": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciKmsVault).ManagementEndpoint, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.kms.vault.keys": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciKmsVault).Keys, ok = plugin.RawToTValue[[]any](v.Value, v.Error) + return + }, + "oci.kms.vault.created": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciKmsVault).Created, ok = plugin.RawToTValue[*time.Time](v.Value, v.Error) + return + }, + "oci.kms.key.__id": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciKmsKey).__id, ok = v.Value.(string) + return + }, + "oci.kms.key.id": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciKmsKey).Id, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.kms.key.name": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciKmsKey).Name, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.kms.key.compartmentID": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciKmsKey).CompartmentID, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.kms.key.vaultId": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciKmsKey).VaultId, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.kms.key.algorithm": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciKmsKey).Algorithm, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.kms.key.protectionMode": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciKmsKey).ProtectionMode, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.kms.key.state": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciKmsKey).State, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.kms.key.isAutoRotationEnabled": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciKmsKey).IsAutoRotationEnabled, ok = plugin.RawToTValue[bool](v.Value, v.Error) + return + }, + "oci.kms.key.created": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciKmsKey).Created, ok = plugin.RawToTValue[*time.Time](v.Value, v.Error) + return + }, + "oci.objectStorage.__id": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciObjectStorage).__id, ok = v.Value.(string) + return + }, + "oci.objectStorage.namespace": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciObjectStorage).Namespace, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.objectStorage.buckets": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciObjectStorage).Buckets, ok = plugin.RawToTValue[[]any](v.Value, v.Error) + return + }, + "oci.objectStorage.bucket.__id": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciObjectStorageBucket).__id, ok = v.Value.(string) + return + }, + "oci.objectStorage.bucket.namespace": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciObjectStorageBucket).Namespace, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.objectStorage.bucket.name": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciObjectStorageBucket).Name, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.objectStorage.bucket.compartmentID": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciObjectStorageBucket).CompartmentID, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.objectStorage.bucket.created": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciObjectStorageBucket).Created, ok = plugin.RawToTValue[*time.Time](v.Value, v.Error) + return + }, + "oci.objectStorage.bucket.region": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciObjectStorageBucket).Region, ok = plugin.RawToTValue[*mqlOciRegion](v.Value, v.Error) + return + }, + "oci.objectStorage.bucket.publicAccessType": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciObjectStorageBucket).PublicAccessType, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.objectStorage.bucket.storageTier": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciObjectStorageBucket).StorageTier, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.objectStorage.bucket.autoTiering": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciObjectStorageBucket).AutoTiering, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.objectStorage.bucket.versioning": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciObjectStorageBucket).Versioning, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.objectStorage.bucket.objectEventsEnabled": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciObjectStorageBucket).ObjectEventsEnabled, ok = plugin.RawToTValue[bool](v.Value, v.Error) + return + }, + "oci.objectStorage.bucket.replicationEnabled": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciObjectStorageBucket).ReplicationEnabled, ok = plugin.RawToTValue[bool](v.Value, v.Error) + return + }, + "oci.objectStorage.bucket.id": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciObjectStorageBucket).Id, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.objectStorage.bucket.isReadOnly": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciObjectStorageBucket).IsReadOnly, ok = plugin.RawToTValue[bool](v.Value, v.Error) + return + }, + "oci.objectStorage.bucket.etag": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciObjectStorageBucket).Etag, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.objectStorage.bucket.kmsKeyId": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciObjectStorageBucket).KmsKeyId, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.objectStorage.bucket.approximateCount": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciObjectStorageBucket).ApproximateCount, ok = plugin.RawToTValue[int64](v.Value, v.Error) + return + }, + "oci.objectStorage.bucket.approximateSize": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciObjectStorageBucket).ApproximateSize, ok = plugin.RawToTValue[int64](v.Value, v.Error) + return + }, + "oci.objectStorage.bucket.objectLifecyclePolicyEtag": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciObjectStorageBucket).ObjectLifecyclePolicyEtag, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.objectStorage.bucket.freeformTags": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciObjectStorageBucket).FreeformTags, ok = plugin.RawToTValue[map[string]any](v.Value, v.Error) + return + }, + "oci.objectStorage.bucket.definedTags": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciObjectStorageBucket).DefinedTags, ok = plugin.RawToTValue[map[string]any](v.Value, v.Error) + return + }, + "oci.fileStorage.__id": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciFileStorage).__id, ok = v.Value.(string) + return + }, + "oci.fileStorage.fileSystems": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciFileStorage).FileSystems, ok = plugin.RawToTValue[[]any](v.Value, v.Error) + return + }, + "oci.fileStorage.fileSystem.__id": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciFileStorageFileSystem).__id, ok = v.Value.(string) + return + }, + "oci.fileStorage.fileSystem.id": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciFileStorageFileSystem).Id, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.fileStorage.fileSystem.name": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciFileStorageFileSystem).Name, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.fileStorage.fileSystem.compartmentID": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciFileStorageFileSystem).CompartmentID, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.fileStorage.fileSystem.availabilityDomain": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciFileStorageFileSystem).AvailabilityDomain, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.fileStorage.fileSystem.state": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciFileStorageFileSystem).State, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.fileStorage.fileSystem.kmsKey": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciFileStorageFileSystem).KmsKey, ok = plugin.RawToTValue[*mqlOciKmsKey](v.Value, v.Error) + return + }, + "oci.fileStorage.fileSystem.meteredBytes": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciFileStorageFileSystem).MeteredBytes, ok = plugin.RawToTValue[int64](v.Value, v.Error) + return + }, + "oci.fileStorage.fileSystem.created": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciFileStorageFileSystem).Created, ok = plugin.RawToTValue[*time.Time](v.Value, v.Error) + return + }, + "oci.events.__id": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciEvents).__id, ok = v.Value.(string) + return + }, + "oci.events.rules": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciEvents).Rules, ok = plugin.RawToTValue[[]any](v.Value, v.Error) + return + }, + "oci.events.rule.__id": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciEventsRule).__id, ok = v.Value.(string) + return + }, + "oci.events.rule.id": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciEventsRule).Id, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.events.rule.name": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciEventsRule).Name, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.events.rule.description": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciEventsRule).Description, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.events.rule.compartmentID": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciEventsRule).CompartmentID, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.events.rule.condition": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciEventsRule).Condition, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.events.rule.isEnabled": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciEventsRule).IsEnabled, ok = plugin.RawToTValue[bool](v.Value, v.Error) + return + }, + "oci.events.rule.state": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciEventsRule).State, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.events.rule.actions": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciEventsRule).Actions, ok = plugin.RawToTValue[[]any](v.Value, v.Error) + return + }, + "oci.events.rule.created": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciEventsRule).Created, ok = plugin.RawToTValue[*time.Time](v.Value, v.Error) + return + }, + "oci.cloudGuard.__id": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciCloudGuard).__id, ok = v.Value.(string) + return + }, + "oci.cloudGuard.status": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciCloudGuard).Status, ok = plugin.RawToTValue[bool](v.Value, v.Error) + return + }, + "oci.cloudGuard.reportingRegion": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciCloudGuard).ReportingRegion, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.cloudGuard.selfManageResources": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciCloudGuard).SelfManageResources, ok = plugin.RawToTValue[bool](v.Value, v.Error) + return + }, + "oci.cloudGuard.targets": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciCloudGuard).Targets, ok = plugin.RawToTValue[[]any](v.Value, v.Error) + return + }, + "oci.cloudGuard.detectorRecipes": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciCloudGuard).DetectorRecipes, ok = plugin.RawToTValue[[]any](v.Value, v.Error) + return + }, + "oci.cloudGuard.target.__id": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciCloudGuardTarget).__id, ok = v.Value.(string) + return + }, + "oci.cloudGuard.target.id": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciCloudGuardTarget).Id, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.cloudGuard.target.name": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciCloudGuardTarget).Name, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.cloudGuard.target.compartmentID": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciCloudGuardTarget).CompartmentID, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.cloudGuard.target.targetResourceId": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciCloudGuardTarget).TargetResourceId, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.cloudGuard.target.targetResourceType": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciCloudGuardTarget).TargetResourceType, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.cloudGuard.target.state": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciCloudGuardTarget).State, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.cloudGuard.target.recipeCount": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciCloudGuardTarget).RecipeCount, ok = plugin.RawToTValue[int64](v.Value, v.Error) + return + }, + "oci.cloudGuard.target.created": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciCloudGuardTarget).Created, ok = plugin.RawToTValue[*time.Time](v.Value, v.Error) + return + }, + "oci.cloudGuard.detectorRecipe.__id": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciCloudGuardDetectorRecipe).__id, ok = v.Value.(string) + return + }, + "oci.cloudGuard.detectorRecipe.id": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciCloudGuardDetectorRecipe).Id, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.cloudGuard.detectorRecipe.name": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciCloudGuardDetectorRecipe).Name, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.cloudGuard.detectorRecipe.description": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciCloudGuardDetectorRecipe).Description, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.cloudGuard.detectorRecipe.owner": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciCloudGuardDetectorRecipe).Owner, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.cloudGuard.detectorRecipe.detectorType": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciCloudGuardDetectorRecipe).DetectorType, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.cloudGuard.detectorRecipe.state": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciCloudGuardDetectorRecipe).State, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.cloudGuard.detectorRecipe.created": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciCloudGuardDetectorRecipe).Created, ok = plugin.RawToTValue[*time.Time](v.Value, v.Error) + return + }, + "oci.ons.__id": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciOns).__id, ok = v.Value.(string) + return + }, + "oci.ons.topics": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciOns).Topics, ok = plugin.RawToTValue[[]any](v.Value, v.Error) + return + }, + "oci.ons.topic.__id": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciOnsTopic).__id, ok = v.Value.(string) + return + }, + "oci.ons.topic.id": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciOnsTopic).Id, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.ons.topic.name": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciOnsTopic).Name, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.ons.topic.description": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciOnsTopic).Description, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.ons.topic.compartmentID": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciOnsTopic).CompartmentID, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.ons.topic.state": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciOnsTopic).State, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.ons.topic.created": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciOnsTopic).Created, ok = plugin.RawToTValue[*time.Time](v.Value, v.Error) + return + }, + "oci.ons.topic.subscriptions": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciOnsTopic).Subscriptions, ok = plugin.RawToTValue[[]any](v.Value, v.Error) + return + }, + "oci.ons.subscription.__id": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciOnsSubscription).__id, ok = v.Value.(string) + return + }, + "oci.ons.subscription.id": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciOnsSubscription).Id, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.ons.subscription.topic": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciOnsSubscription).Topic, ok = plugin.RawToTValue[*mqlOciOnsTopic](v.Value, v.Error) + return + }, + "oci.ons.subscription.protocol": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciOnsSubscription).Protocol, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.ons.subscription.endpoint": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciOnsSubscription).Endpoint, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.ons.subscription.state": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciOnsSubscription).State, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.ons.subscription.created": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciOnsSubscription).Created, ok = plugin.RawToTValue[*time.Time](v.Value, v.Error) + return + }, + "oci.audit.__id": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciAudit).__id, ok = v.Value.(string) + return + }, + "oci.audit.retentionPeriodDays": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciAudit).RetentionPeriodDays, ok = plugin.RawToTValue[int64](v.Value, v.Error) + return + }, + "oci.bastion.__id": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciBastion).__id, ok = v.Value.(string) + return + }, + "oci.bastion.bastions": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciBastion).Bastions, ok = plugin.RawToTValue[[]any](v.Value, v.Error) + return + }, + "oci.bastion.instance.__id": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciBastionInstance).__id, ok = v.Value.(string) + return + }, + "oci.bastion.instance.id": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciBastionInstance).Id, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.bastion.instance.name": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciBastionInstance).Name, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.bastion.instance.compartmentID": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciBastionInstance).CompartmentID, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.bastion.instance.bastionType": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciBastionInstance).BastionType, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.bastion.instance.targetVcn": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciBastionInstance).TargetVcn, ok = plugin.RawToTValue[*mqlOciNetworkVcn](v.Value, v.Error) + return + }, + "oci.bastion.instance.targetSubnet": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciBastionInstance).TargetSubnet, ok = plugin.RawToTValue[*mqlOciNetworkSubnet](v.Value, v.Error) + return + }, + "oci.bastion.instance.state": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciBastionInstance).State, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.bastion.instance.dnsProxyStatus": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciBastionInstance).DnsProxyStatus, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.bastion.instance.created": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciBastionInstance).Created, ok = plugin.RawToTValue[*time.Time](v.Value, v.Error) + return + }, + "oci.bastion.instance.timeUpdated": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciBastionInstance).TimeUpdated, ok = plugin.RawToTValue[*time.Time](v.Value, v.Error) + return + }, + "oci.monitoring.__id": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciMonitoring).__id, ok = v.Value.(string) + return + }, + "oci.monitoring.alarms": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciMonitoring).Alarms, ok = plugin.RawToTValue[[]any](v.Value, v.Error) + return + }, + "oci.monitoring.alarm.__id": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciMonitoringAlarm).__id, ok = v.Value.(string) + return + }, + "oci.monitoring.alarm.id": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciMonitoringAlarm).Id, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.monitoring.alarm.name": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciMonitoringAlarm).Name, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.monitoring.alarm.compartmentID": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciMonitoringAlarm).CompartmentID, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.monitoring.alarm.metricCompartmentId": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciMonitoringAlarm).MetricCompartmentId, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.monitoring.alarm.namespace": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciMonitoringAlarm).Namespace, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.monitoring.alarm.query": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciMonitoringAlarm).Query, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.monitoring.alarm.severity": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciMonitoringAlarm).Severity, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.monitoring.alarm.destinations": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciMonitoringAlarm).Destinations, ok = plugin.RawToTValue[[]any](v.Value, v.Error) + return + }, + "oci.monitoring.alarm.isEnabled": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciMonitoringAlarm).IsEnabled, ok = plugin.RawToTValue[bool](v.Value, v.Error) + return + }, + "oci.monitoring.alarm.state": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciMonitoringAlarm).State, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.vault.__id": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciVault).__id, ok = v.Value.(string) + return + }, + "oci.vault.secrets": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciVault).Secrets, ok = plugin.RawToTValue[[]any](v.Value, v.Error) + return + }, + "oci.vault.secret.__id": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciVaultSecret).__id, ok = v.Value.(string) + return + }, + "oci.vault.secret.id": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciVaultSecret).Id, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.vault.secret.name": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciVaultSecret).Name, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.vault.secret.compartmentID": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciVaultSecret).CompartmentID, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.vault.secret.kmsVault": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciVaultSecret).KmsVault, ok = plugin.RawToTValue[*mqlOciKmsVault](v.Value, v.Error) + return + }, + "oci.vault.secret.kmsKey": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciVaultSecret).KmsKey, ok = plugin.RawToTValue[*mqlOciKmsKey](v.Value, v.Error) + return + }, + "oci.vault.secret.description": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciVaultSecret).Description, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.vault.secret.state": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciVaultSecret).State, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.vault.secret.rotationStatus": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciVaultSecret).RotationStatus, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.vault.secret.lastRotationTime": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciVaultSecret).LastRotationTime, ok = plugin.RawToTValue[*time.Time](v.Value, v.Error) + return + }, + "oci.vault.secret.nextRotationTime": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciVaultSecret).NextRotationTime, ok = plugin.RawToTValue[*time.Time](v.Value, v.Error) + return + }, + "oci.vault.secret.isAutoGenerationEnabled": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciVaultSecret).IsAutoGenerationEnabled, ok = plugin.RawToTValue[bool](v.Value, v.Error) + return + }, + "oci.vault.secret.created": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciVaultSecret).Created, ok = plugin.RawToTValue[*time.Time](v.Value, v.Error) + return + }, + "oci.loadBalancer.__id": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciLoadBalancer).__id, ok = v.Value.(string) + return + }, + "oci.loadBalancer.loadBalancers": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciLoadBalancer).LoadBalancers, ok = plugin.RawToTValue[[]any](v.Value, v.Error) + return + }, + "oci.loadBalancer.loadBalancer.__id": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciLoadBalancerLoadBalancer).__id, ok = v.Value.(string) + return + }, + "oci.loadBalancer.loadBalancer.id": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciLoadBalancerLoadBalancer).Id, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.loadBalancer.loadBalancer.name": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciLoadBalancerLoadBalancer).Name, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.loadBalancer.loadBalancer.compartmentID": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciLoadBalancerLoadBalancer).CompartmentID, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.loadBalancer.loadBalancer.shape": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciLoadBalancerLoadBalancer).Shape, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.loadBalancer.loadBalancer.isPrivate": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciLoadBalancerLoadBalancer).IsPrivate, ok = plugin.RawToTValue[bool](v.Value, v.Error) + return + }, + "oci.loadBalancer.loadBalancer.isDeleteProtectionEnabled": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciLoadBalancerLoadBalancer).IsDeleteProtectionEnabled, ok = plugin.RawToTValue[bool](v.Value, v.Error) + return + }, + "oci.loadBalancer.loadBalancer.state": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciLoadBalancerLoadBalancer).State, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.loadBalancer.loadBalancer.listeners": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciLoadBalancerLoadBalancer).Listeners, ok = plugin.RawToTValue[[]any](v.Value, v.Error) + return + }, + "oci.loadBalancer.loadBalancer.backendSets": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciLoadBalancerLoadBalancer).BackendSets, ok = plugin.RawToTValue[[]any](v.Value, v.Error) + return + }, + "oci.loadBalancer.loadBalancer.created": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciLoadBalancerLoadBalancer).Created, ok = plugin.RawToTValue[*time.Time](v.Value, v.Error) + return + }, + "oci.loadBalancer.listener.__id": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciLoadBalancerListener).__id, ok = v.Value.(string) + return + }, + "oci.loadBalancer.listener.id": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciLoadBalancerListener).Id, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.loadBalancer.listener.name": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciLoadBalancerListener).Name, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.loadBalancer.listener.port": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciLoadBalancerListener).Port, ok = plugin.RawToTValue[int64](v.Value, v.Error) + return + }, + "oci.loadBalancer.listener.protocol": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciLoadBalancerListener).Protocol, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.loadBalancer.listener.defaultBackendSetName": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciLoadBalancerListener).DefaultBackendSetName, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.loadBalancer.listener.sslProtocols": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciLoadBalancerListener).SslProtocols, ok = plugin.RawToTValue[[]any](v.Value, v.Error) + return + }, + "oci.loadBalancer.listener.sslCipherSuiteName": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciLoadBalancerListener).SslCipherSuiteName, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.loadBalancer.listener.sslVerifyPeerCertificate": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciLoadBalancerListener).SslVerifyPeerCertificate, ok = plugin.RawToTValue[bool](v.Value, v.Error) + return + }, + "oci.loadBalancer.backendSet.__id": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciLoadBalancerBackendSet).__id, ok = v.Value.(string) + return + }, + "oci.loadBalancer.backendSet.id": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciLoadBalancerBackendSet).Id, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.loadBalancer.backendSet.name": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciLoadBalancerBackendSet).Name, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.loadBalancer.backendSet.policy": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciLoadBalancerBackendSet).Policy, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.loadBalancer.backendSet.healthChecker": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciLoadBalancerBackendSet).HealthChecker, ok = plugin.RawToTValue[any](v.Value, v.Error) + return + }, + "oci.loadBalancer.backendSet.backendCount": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciLoadBalancerBackendSet).BackendCount, ok = plugin.RawToTValue[int64](v.Value, v.Error) + return + }, + "oci.networkFirewall.__id": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciNetworkFirewall).__id, ok = v.Value.(string) + return + }, + "oci.networkFirewall.firewalls": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciNetworkFirewall).Firewalls, ok = plugin.RawToTValue[[]any](v.Value, v.Error) + return + }, + "oci.networkFirewall.policies": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciNetworkFirewall).Policies, ok = plugin.RawToTValue[[]any](v.Value, v.Error) + return + }, + "oci.networkFirewall.firewall.__id": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciNetworkFirewallFirewall).__id, ok = v.Value.(string) + return + }, + "oci.networkFirewall.firewall.id": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciNetworkFirewallFirewall).Id, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.networkFirewall.firewall.name": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciNetworkFirewallFirewall).Name, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.networkFirewall.firewall.compartmentID": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciNetworkFirewallFirewall).CompartmentID, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.networkFirewall.firewall.subnet": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciNetworkFirewallFirewall).Subnet, ok = plugin.RawToTValue[*mqlOciNetworkSubnet](v.Value, v.Error) + return + }, + "oci.networkFirewall.firewall.policy": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciNetworkFirewallFirewall).Policy, ok = plugin.RawToTValue[*mqlOciNetworkFirewallPolicy](v.Value, v.Error) + return + }, + "oci.networkFirewall.firewall.ipv4Address": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciNetworkFirewallFirewall).Ipv4Address, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.networkFirewall.firewall.ipv6Address": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciNetworkFirewallFirewall).Ipv6Address, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.networkFirewall.firewall.shape": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciNetworkFirewallFirewall).Shape, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.networkFirewall.firewall.state": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciNetworkFirewallFirewall).State, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.networkFirewall.firewall.created": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciNetworkFirewallFirewall).Created, ok = plugin.RawToTValue[*time.Time](v.Value, v.Error) + return + }, + "oci.networkFirewall.firewall.timeUpdated": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciNetworkFirewallFirewall).TimeUpdated, ok = plugin.RawToTValue[*time.Time](v.Value, v.Error) + return + }, + "oci.networkFirewall.policy.__id": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciNetworkFirewallPolicy).__id, ok = v.Value.(string) + return + }, + "oci.networkFirewall.policy.id": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciNetworkFirewallPolicy).Id, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.networkFirewall.policy.name": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciNetworkFirewallPolicy).Name, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.networkFirewall.policy.compartmentID": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciNetworkFirewallPolicy).CompartmentID, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.networkFirewall.policy.description": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciNetworkFirewallPolicy).Description, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.networkFirewall.policy.attachedFirewallCount": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciNetworkFirewallPolicy).AttachedFirewallCount, ok = plugin.RawToTValue[int64](v.Value, v.Error) + return + }, + "oci.networkFirewall.policy.state": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciNetworkFirewallPolicy).State, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.networkFirewall.policy.created": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciNetworkFirewallPolicy).Created, ok = plugin.RawToTValue[*time.Time](v.Value, v.Error) + return + }, + "oci.oke.__id": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciOke).__id, ok = v.Value.(string) + return + }, + "oci.oke.clusters": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciOke).Clusters, ok = plugin.RawToTValue[[]any](v.Value, v.Error) + return + }, + "oci.oke.cluster.__id": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciOkeCluster).__id, ok = v.Value.(string) + return + }, + "oci.oke.cluster.id": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciOkeCluster).Id, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.oke.cluster.name": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciOkeCluster).Name, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.oke.cluster.compartmentID": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciOkeCluster).CompartmentID, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.oke.cluster.kubernetesVersion": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciOkeCluster).KubernetesVersion, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.oke.cluster.type": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciOkeCluster).Type, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.oke.cluster.vcn": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciOkeCluster).Vcn, ok = plugin.RawToTValue[*mqlOciNetworkVcn](v.Value, v.Error) + return + }, + "oci.oke.cluster.kmsKey": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciOkeCluster).KmsKey, ok = plugin.RawToTValue[*mqlOciKmsKey](v.Value, v.Error) + return + }, + "oci.oke.cluster.isPublicEndpointEnabled": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciOkeCluster).IsPublicEndpointEnabled, ok = plugin.RawToTValue[bool](v.Value, v.Error) + return + }, + "oci.oke.cluster.publicEndpoint": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciOkeCluster).PublicEndpoint, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.oke.cluster.privateEndpoint": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciOkeCluster).PrivateEndpoint, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.oke.cluster.isImagePolicyEnabled": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciOkeCluster).IsImagePolicyEnabled, ok = plugin.RawToTValue[bool](v.Value, v.Error) + return + }, + "oci.oke.cluster.availableKubernetesUpgrades": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciOkeCluster).AvailableKubernetesUpgrades, ok = plugin.RawToTValue[[]any](v.Value, v.Error) + return + }, + "oci.oke.cluster.isPodSecurityPolicyEnabled": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciOkeCluster).IsPodSecurityPolicyEnabled, ok = plugin.RawToTValue[bool](v.Value, v.Error) + return + }, + "oci.oke.cluster.state": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciOkeCluster).State, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.oke.cluster.nodePools": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciOkeCluster).NodePools, ok = plugin.RawToTValue[[]any](v.Value, v.Error) + return + }, + "oci.oke.cluster.created": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciOkeCluster).Created, ok = plugin.RawToTValue[*time.Time](v.Value, v.Error) + return + }, + "oci.oke.nodePool.__id": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciOkeNodePool).__id, ok = v.Value.(string) + return + }, + "oci.oke.nodePool.id": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciOkeNodePool).Id, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.oke.nodePool.name": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciOkeNodePool).Name, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.oke.nodePool.compartmentID": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciOkeNodePool).CompartmentID, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.oke.nodePool.kubernetesVersion": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciOkeNodePool).KubernetesVersion, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.oke.nodePool.nodeShape": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciOkeNodePool).NodeShape, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.oke.nodePool.nodeShapeConfig": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciOkeNodePool).NodeShapeConfig, ok = plugin.RawToTValue[any](v.Value, v.Error) + return + }, + "oci.oke.nodePool.nodeImageName": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciOkeNodePool).NodeImageName, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.oke.nodePool.sshPublicKey": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciOkeNodePool).SshPublicKey, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, + "oci.oke.nodePool.state": func(r plugin.Resource, v *llx.RawData) (ok bool) { + r.(*mqlOciOkeNodePool).State, ok = plugin.RawToTValue[string](v.Value, v.Error) + return + }, +} + +func SetData(resource plugin.Resource, field string, val *llx.RawData) error { + f, ok := setDataFields[resource.MqlName()+"."+field] + if !ok { + return errors.New("[oci] cannot set '" + field + "' in resource '" + resource.MqlName() + "', field not found") + } + + if ok := f(resource, val); !ok { + return errors.New("[oci] cannot set '" + field + "' in resource '" + resource.MqlName() + "', type does not match") + } + return nil +} + +func SetAllData(resource plugin.Resource, args map[string]*llx.RawData) error { + var err error + for k, v := range args { + if err = SetData(resource, k, v); err != nil { + return err + } + } + return nil +} + +// mqlOci for the oci resource +type mqlOci struct { + MqlRuntime *plugin.Runtime + __id string + // optional: if you define mqlOciInternal it will be used here + Regions plugin.TValue[[]any] + Compartments plugin.TValue[[]any] +} + +// createOci creates a new instance of this resource +func createOci(runtime *plugin.Runtime, args map[string]*llx.RawData) (plugin.Resource, error) { + res := &mqlOci{ + MqlRuntime: runtime, + } + + err := SetAllData(res, args) + if err != nil { + return res, err + } + + if res.__id == "" { + res.__id, err = res.id() + if err != nil { + return nil, err + } + } + + if runtime.HasRecording { + args, err = runtime.ResourceFromRecording("oci", res.__id) + if err != nil || args == nil { + return res, err + } + return res, SetAllData(res, args) + } + + return res, nil +} + +func (c *mqlOci) MqlName() string { + return "oci" +} + +func (c *mqlOci) MqlID() string { + return c.__id +} + +func (c *mqlOci) GetRegions() *plugin.TValue[[]any] { + return plugin.GetOrCompute[[]any](&c.Regions, func() ([]any, error) { + if c.MqlRuntime.HasRecording { + d, err := c.MqlRuntime.FieldResourceFromRecording("oci", c.__id, "regions") + if err != nil { + return nil, err + } + if d != nil { + return d.Value.([]any), nil + } + } + + return c.regions() + }) +} + +func (c *mqlOci) GetCompartments() *plugin.TValue[[]any] { + return plugin.GetOrCompute[[]any](&c.Compartments, func() ([]any, error) { + if c.MqlRuntime.HasRecording { + d, err := c.MqlRuntime.FieldResourceFromRecording("oci", c.__id, "compartments") + if err != nil { + return nil, err + } + if d != nil { + return d.Value.([]any), nil + } + } + + return c.compartments() + }) +} + +// mqlOciTenancy for the oci.tenancy resource +type mqlOciTenancy struct { + MqlRuntime *plugin.Runtime + __id string + // optional: if you define mqlOciTenancyInternal it will be used here + Id plugin.TValue[string] + Name plugin.TValue[string] + Description plugin.TValue[string] + RetentionPeriod plugin.TValue[*time.Time] +} + +// createOciTenancy creates a new instance of this resource +func createOciTenancy(runtime *plugin.Runtime, args map[string]*llx.RawData) (plugin.Resource, error) { + res := &mqlOciTenancy{ + MqlRuntime: runtime, + } + + err := SetAllData(res, args) + if err != nil { + return res, err + } + + if res.__id == "" { + res.__id, err = res.id() + if err != nil { + return nil, err + } + } + + if runtime.HasRecording { + args, err = runtime.ResourceFromRecording("oci.tenancy", res.__id) + if err != nil || args == nil { + return res, err + } + return res, SetAllData(res, args) + } + + return res, nil +} + +func (c *mqlOciTenancy) MqlName() string { + return "oci.tenancy" +} + +func (c *mqlOciTenancy) MqlID() string { + return c.__id +} + +func (c *mqlOciTenancy) GetId() *plugin.TValue[string] { + return &c.Id +} + +func (c *mqlOciTenancy) GetName() *plugin.TValue[string] { + return &c.Name +} + +func (c *mqlOciTenancy) GetDescription() *plugin.TValue[string] { + return &c.Description +} + +func (c *mqlOciTenancy) GetRetentionPeriod() *plugin.TValue[*time.Time] { + return plugin.GetOrCompute[*time.Time](&c.RetentionPeriod, func() (*time.Time, error) { + return c.retentionPeriod() + }) +} + +// mqlOciRegion for the oci.region resource +type mqlOciRegion struct { + MqlRuntime *plugin.Runtime + __id string + // optional: if you define mqlOciRegionInternal it will be used here + Id plugin.TValue[string] + Name plugin.TValue[string] + IsHomeRegion plugin.TValue[bool] + Status plugin.TValue[string] +} + +// createOciRegion creates a new instance of this resource +func createOciRegion(runtime *plugin.Runtime, args map[string]*llx.RawData) (plugin.Resource, error) { + res := &mqlOciRegion{ + MqlRuntime: runtime, + } + + err := SetAllData(res, args) + if err != nil { + return res, err + } + + if res.__id == "" { + res.__id, err = res.id() + if err != nil { + return nil, err + } + } + + if runtime.HasRecording { + args, err = runtime.ResourceFromRecording("oci.region", res.__id) + if err != nil || args == nil { + return res, err + } + return res, SetAllData(res, args) + } + + return res, nil +} + +func (c *mqlOciRegion) MqlName() string { + return "oci.region" +} + +func (c *mqlOciRegion) MqlID() string { + return c.__id +} + +func (c *mqlOciRegion) GetId() *plugin.TValue[string] { + return &c.Id +} + +func (c *mqlOciRegion) GetName() *plugin.TValue[string] { + return &c.Name +} + +func (c *mqlOciRegion) GetIsHomeRegion() *plugin.TValue[bool] { + return &c.IsHomeRegion +} + +func (c *mqlOciRegion) GetStatus() *plugin.TValue[string] { + return &c.Status +} + +// mqlOciCompartment for the oci.compartment resource +type mqlOciCompartment struct { + MqlRuntime *plugin.Runtime + __id string + // optional: if you define mqlOciCompartmentInternal it will be used here + Id plugin.TValue[string] + Name plugin.TValue[string] + Description plugin.TValue[string] + Created plugin.TValue[*time.Time] + State plugin.TValue[string] +} + +// createOciCompartment creates a new instance of this resource +func createOciCompartment(runtime *plugin.Runtime, args map[string]*llx.RawData) (plugin.Resource, error) { + res := &mqlOciCompartment{ + MqlRuntime: runtime, + } + + err := SetAllData(res, args) + if err != nil { + return res, err + } + + if res.__id == "" { + res.__id, err = res.id() + if err != nil { + return nil, err + } + } + + if runtime.HasRecording { + args, err = runtime.ResourceFromRecording("oci.compartment", res.__id) + if err != nil || args == nil { + return res, err + } + return res, SetAllData(res, args) + } + + return res, nil +} + +func (c *mqlOciCompartment) MqlName() string { + return "oci.compartment" +} + +func (c *mqlOciCompartment) MqlID() string { + return c.__id +} + +func (c *mqlOciCompartment) GetId() *plugin.TValue[string] { + return &c.Id +} + +func (c *mqlOciCompartment) GetName() *plugin.TValue[string] { + return &c.Name +} + +func (c *mqlOciCompartment) GetDescription() *plugin.TValue[string] { + return &c.Description +} + +func (c *mqlOciCompartment) GetCreated() *plugin.TValue[*time.Time] { + return &c.Created +} + +func (c *mqlOciCompartment) GetState() *plugin.TValue[string] { + return &c.State +} + +// mqlOciIdentity for the oci.identity resource +type mqlOciIdentity struct { + MqlRuntime *plugin.Runtime + __id string + // optional: if you define mqlOciIdentityInternal it will be used here + Users plugin.TValue[[]any] + Groups plugin.TValue[[]any] + Policies plugin.TValue[[]any] +} + +// createOciIdentity creates a new instance of this resource +func createOciIdentity(runtime *plugin.Runtime, args map[string]*llx.RawData) (plugin.Resource, error) { + res := &mqlOciIdentity{ + MqlRuntime: runtime, + } + + err := SetAllData(res, args) + if err != nil { + return res, err + } + + if res.__id == "" { + res.__id, err = res.id() + if err != nil { + return nil, err + } + } + + if runtime.HasRecording { + args, err = runtime.ResourceFromRecording("oci.identity", res.__id) + if err != nil || args == nil { + return res, err + } + return res, SetAllData(res, args) + } + + return res, nil +} + +func (c *mqlOciIdentity) MqlName() string { + return "oci.identity" +} + +func (c *mqlOciIdentity) MqlID() string { + return c.__id +} + +func (c *mqlOciIdentity) GetUsers() *plugin.TValue[[]any] { + return plugin.GetOrCompute[[]any](&c.Users, func() ([]any, error) { + if c.MqlRuntime.HasRecording { + d, err := c.MqlRuntime.FieldResourceFromRecording("oci.identity", c.__id, "users") + if err != nil { + return nil, err + } + if d != nil { + return d.Value.([]any), nil + } + } + + return c.users() + }) +} + +func (c *mqlOciIdentity) GetGroups() *plugin.TValue[[]any] { + return plugin.GetOrCompute[[]any](&c.Groups, func() ([]any, error) { + if c.MqlRuntime.HasRecording { + d, err := c.MqlRuntime.FieldResourceFromRecording("oci.identity", c.__id, "groups") + if err != nil { + return nil, err + } + if d != nil { + return d.Value.([]any), nil + } + } + + return c.groups() + }) +} + +func (c *mqlOciIdentity) GetPolicies() *plugin.TValue[[]any] { + return plugin.GetOrCompute[[]any](&c.Policies, func() ([]any, error) { + if c.MqlRuntime.HasRecording { + d, err := c.MqlRuntime.FieldResourceFromRecording("oci.identity", c.__id, "policies") + if err != nil { + return nil, err + } + if d != nil { + return d.Value.([]any), nil + } + } + + return c.policies() + }) +} + +// mqlOciIdentityUser for the oci.identity.user resource +type mqlOciIdentityUser struct { + MqlRuntime *plugin.Runtime + __id string + // optional: if you define mqlOciIdentityUserInternal it will be used here + Id plugin.TValue[string] + CompartmentID plugin.TValue[string] + Name plugin.TValue[string] + Description plugin.TValue[string] + Created plugin.TValue[*time.Time] + State plugin.TValue[string] + MfaActivated plugin.TValue[bool] + Email plugin.TValue[string] + EmailVerified plugin.TValue[bool] + Capabilities plugin.TValue[map[string]any] + LastLogin plugin.TValue[*time.Time] + PreviousLogin plugin.TValue[*time.Time] + FreeformTags plugin.TValue[map[string]any] + DefinedTags plugin.TValue[map[string]any] + ApiKeys plugin.TValue[[]any] + CustomerSecretKeys plugin.TValue[[]any] + AuthTokens plugin.TValue[[]any] + Groups plugin.TValue[[]any] +} + +// createOciIdentityUser creates a new instance of this resource +func createOciIdentityUser(runtime *plugin.Runtime, args map[string]*llx.RawData) (plugin.Resource, error) { + res := &mqlOciIdentityUser{ + MqlRuntime: runtime, + } + + err := SetAllData(res, args) + if err != nil { + return res, err + } + + if res.__id == "" { + res.__id, err = res.id() + if err != nil { + return nil, err + } + } + + if runtime.HasRecording { + args, err = runtime.ResourceFromRecording("oci.identity.user", res.__id) + if err != nil || args == nil { + return res, err + } + return res, SetAllData(res, args) + } + + return res, nil +} + +func (c *mqlOciIdentityUser) MqlName() string { + return "oci.identity.user" +} + +func (c *mqlOciIdentityUser) MqlID() string { + return c.__id +} + +func (c *mqlOciIdentityUser) GetId() *plugin.TValue[string] { + return &c.Id +} + +func (c *mqlOciIdentityUser) GetCompartmentID() *plugin.TValue[string] { + return &c.CompartmentID +} + +func (c *mqlOciIdentityUser) GetName() *plugin.TValue[string] { + return &c.Name +} + +func (c *mqlOciIdentityUser) GetDescription() *plugin.TValue[string] { + return &c.Description +} + +func (c *mqlOciIdentityUser) GetCreated() *plugin.TValue[*time.Time] { + return &c.Created +} + +func (c *mqlOciIdentityUser) GetState() *plugin.TValue[string] { + return &c.State +} + +func (c *mqlOciIdentityUser) GetMfaActivated() *plugin.TValue[bool] { + return &c.MfaActivated +} + +func (c *mqlOciIdentityUser) GetEmail() *plugin.TValue[string] { + return &c.Email +} + +func (c *mqlOciIdentityUser) GetEmailVerified() *plugin.TValue[bool] { + return &c.EmailVerified +} + +func (c *mqlOciIdentityUser) GetCapabilities() *plugin.TValue[map[string]any] { + return &c.Capabilities +} + +func (c *mqlOciIdentityUser) GetLastLogin() *plugin.TValue[*time.Time] { + return &c.LastLogin +} + +func (c *mqlOciIdentityUser) GetPreviousLogin() *plugin.TValue[*time.Time] { + return &c.PreviousLogin +} + +func (c *mqlOciIdentityUser) GetFreeformTags() *plugin.TValue[map[string]any] { + return &c.FreeformTags +} + +func (c *mqlOciIdentityUser) GetDefinedTags() *plugin.TValue[map[string]any] { + return &c.DefinedTags +} + +func (c *mqlOciIdentityUser) GetApiKeys() *plugin.TValue[[]any] { + return plugin.GetOrCompute[[]any](&c.ApiKeys, func() ([]any, error) { + if c.MqlRuntime.HasRecording { + d, err := c.MqlRuntime.FieldResourceFromRecording("oci.identity.user", c.__id, "apiKeys") + if err != nil { + return nil, err + } + if d != nil { + return d.Value.([]any), nil + } + } + + return c.apiKeys() + }) +} + +func (c *mqlOciIdentityUser) GetCustomerSecretKeys() *plugin.TValue[[]any] { + return plugin.GetOrCompute[[]any](&c.CustomerSecretKeys, func() ([]any, error) { + if c.MqlRuntime.HasRecording { + d, err := c.MqlRuntime.FieldResourceFromRecording("oci.identity.user", c.__id, "customerSecretKeys") + if err != nil { + return nil, err + } + if d != nil { + return d.Value.([]any), nil + } + } + + return c.customerSecretKeys() + }) +} + +func (c *mqlOciIdentityUser) GetAuthTokens() *plugin.TValue[[]any] { + return plugin.GetOrCompute[[]any](&c.AuthTokens, func() ([]any, error) { + if c.MqlRuntime.HasRecording { + d, err := c.MqlRuntime.FieldResourceFromRecording("oci.identity.user", c.__id, "authTokens") + if err != nil { + return nil, err + } + if d != nil { + return d.Value.([]any), nil + } + } + + return c.authTokens() + }) +} + +func (c *mqlOciIdentityUser) GetGroups() *plugin.TValue[[]any] { + return plugin.GetOrCompute[[]any](&c.Groups, func() ([]any, error) { + if c.MqlRuntime.HasRecording { + d, err := c.MqlRuntime.FieldResourceFromRecording("oci.identity.user", c.__id, "groups") + if err != nil { + return nil, err + } + if d != nil { + return d.Value.([]any), nil + } + } + + return c.groups() + }) +} + +// mqlOciIdentityApiKey for the oci.identity.apiKey resource +type mqlOciIdentityApiKey struct { + MqlRuntime *plugin.Runtime + __id string + // optional: if you define mqlOciIdentityApiKeyInternal it will be used here + Id plugin.TValue[string] + Value plugin.TValue[string] + Fingerprint plugin.TValue[string] + Created plugin.TValue[*time.Time] + State plugin.TValue[string] +} + +// createOciIdentityApiKey creates a new instance of this resource +func createOciIdentityApiKey(runtime *plugin.Runtime, args map[string]*llx.RawData) (plugin.Resource, error) { + res := &mqlOciIdentityApiKey{ + MqlRuntime: runtime, + } + + err := SetAllData(res, args) + if err != nil { + return res, err + } + + if res.__id == "" { + res.__id, err = res.id() + if err != nil { + return nil, err + } + } + + if runtime.HasRecording { + args, err = runtime.ResourceFromRecording("oci.identity.apiKey", res.__id) + if err != nil || args == nil { + return res, err + } + return res, SetAllData(res, args) + } + + return res, nil +} + +func (c *mqlOciIdentityApiKey) MqlName() string { + return "oci.identity.apiKey" +} + +func (c *mqlOciIdentityApiKey) MqlID() string { + return c.__id +} + +func (c *mqlOciIdentityApiKey) GetId() *plugin.TValue[string] { + return &c.Id +} + +func (c *mqlOciIdentityApiKey) GetValue() *plugin.TValue[string] { + return &c.Value +} + +func (c *mqlOciIdentityApiKey) GetFingerprint() *plugin.TValue[string] { + return &c.Fingerprint +} + +func (c *mqlOciIdentityApiKey) GetCreated() *plugin.TValue[*time.Time] { + return &c.Created +} + +func (c *mqlOciIdentityApiKey) GetState() *plugin.TValue[string] { + return &c.State +} + +// mqlOciIdentityCustomerSecretKey for the oci.identity.customerSecretKey resource +type mqlOciIdentityCustomerSecretKey struct { + MqlRuntime *plugin.Runtime + __id string + // optional: if you define mqlOciIdentityCustomerSecretKeyInternal it will be used here + Id plugin.TValue[string] + Name plugin.TValue[string] + Created plugin.TValue[*time.Time] + State plugin.TValue[string] +} + +// createOciIdentityCustomerSecretKey creates a new instance of this resource +func createOciIdentityCustomerSecretKey(runtime *plugin.Runtime, args map[string]*llx.RawData) (plugin.Resource, error) { + res := &mqlOciIdentityCustomerSecretKey{ + MqlRuntime: runtime, + } + + err := SetAllData(res, args) + if err != nil { + return res, err + } + + if res.__id == "" { + res.__id, err = res.id() + if err != nil { + return nil, err + } + } + + if runtime.HasRecording { + args, err = runtime.ResourceFromRecording("oci.identity.customerSecretKey", res.__id) + if err != nil || args == nil { + return res, err + } + return res, SetAllData(res, args) + } + + return res, nil +} + +func (c *mqlOciIdentityCustomerSecretKey) MqlName() string { + return "oci.identity.customerSecretKey" +} + +func (c *mqlOciIdentityCustomerSecretKey) MqlID() string { + return c.__id +} + +func (c *mqlOciIdentityCustomerSecretKey) GetId() *plugin.TValue[string] { + return &c.Id +} + +func (c *mqlOciIdentityCustomerSecretKey) GetName() *plugin.TValue[string] { + return &c.Name +} + +func (c *mqlOciIdentityCustomerSecretKey) GetCreated() *plugin.TValue[*time.Time] { + return &c.Created +} + +func (c *mqlOciIdentityCustomerSecretKey) GetState() *plugin.TValue[string] { + return &c.State +} + +// mqlOciIdentityAuthToken for the oci.identity.authToken resource +type mqlOciIdentityAuthToken struct { + MqlRuntime *plugin.Runtime + __id string + // optional: if you define mqlOciIdentityAuthTokenInternal it will be used here + Id plugin.TValue[string] + Description plugin.TValue[string] + Created plugin.TValue[*time.Time] + Expires plugin.TValue[*time.Time] + State plugin.TValue[string] +} + +// createOciIdentityAuthToken creates a new instance of this resource +func createOciIdentityAuthToken(runtime *plugin.Runtime, args map[string]*llx.RawData) (plugin.Resource, error) { + res := &mqlOciIdentityAuthToken{ + MqlRuntime: runtime, + } + + err := SetAllData(res, args) + if err != nil { + return res, err + } + + if res.__id == "" { + res.__id, err = res.id() + if err != nil { + return nil, err + } + } + + if runtime.HasRecording { + args, err = runtime.ResourceFromRecording("oci.identity.authToken", res.__id) + if err != nil || args == nil { + return res, err + } + return res, SetAllData(res, args) + } + + return res, nil +} + +func (c *mqlOciIdentityAuthToken) MqlName() string { + return "oci.identity.authToken" +} + +func (c *mqlOciIdentityAuthToken) MqlID() string { + return c.__id +} + +func (c *mqlOciIdentityAuthToken) GetId() *plugin.TValue[string] { + return &c.Id +} + +func (c *mqlOciIdentityAuthToken) GetDescription() *plugin.TValue[string] { + return &c.Description +} + +func (c *mqlOciIdentityAuthToken) GetCreated() *plugin.TValue[*time.Time] { + return &c.Created +} + +func (c *mqlOciIdentityAuthToken) GetExpires() *plugin.TValue[*time.Time] { + return &c.Expires +} + +func (c *mqlOciIdentityAuthToken) GetState() *plugin.TValue[string] { + return &c.State +} + +// mqlOciIdentityGroup for the oci.identity.group resource +type mqlOciIdentityGroup struct { + MqlRuntime *plugin.Runtime + __id string + // optional: if you define mqlOciIdentityGroupInternal it will be used here + Id plugin.TValue[string] + CompartmentID plugin.TValue[string] + Name plugin.TValue[string] + Description plugin.TValue[string] + Created plugin.TValue[*time.Time] + State plugin.TValue[string] + FreeformTags plugin.TValue[map[string]any] + DefinedTags plugin.TValue[map[string]any] +} + +// createOciIdentityGroup creates a new instance of this resource +func createOciIdentityGroup(runtime *plugin.Runtime, args map[string]*llx.RawData) (plugin.Resource, error) { + res := &mqlOciIdentityGroup{ + MqlRuntime: runtime, + } + + err := SetAllData(res, args) + if err != nil { + return res, err + } + + if res.__id == "" { + res.__id, err = res.id() + if err != nil { + return nil, err + } + } + + if runtime.HasRecording { + args, err = runtime.ResourceFromRecording("oci.identity.group", res.__id) + if err != nil || args == nil { + return res, err + } + return res, SetAllData(res, args) + } + + return res, nil +} + +func (c *mqlOciIdentityGroup) MqlName() string { + return "oci.identity.group" +} + +func (c *mqlOciIdentityGroup) MqlID() string { + return c.__id +} + +func (c *mqlOciIdentityGroup) GetId() *plugin.TValue[string] { + return &c.Id +} + +func (c *mqlOciIdentityGroup) GetCompartmentID() *plugin.TValue[string] { + return &c.CompartmentID +} + +func (c *mqlOciIdentityGroup) GetName() *plugin.TValue[string] { + return &c.Name +} + +func (c *mqlOciIdentityGroup) GetDescription() *plugin.TValue[string] { + return &c.Description +} + +func (c *mqlOciIdentityGroup) GetCreated() *plugin.TValue[*time.Time] { + return &c.Created +} + +func (c *mqlOciIdentityGroup) GetState() *plugin.TValue[string] { + return &c.State +} + +func (c *mqlOciIdentityGroup) GetFreeformTags() *plugin.TValue[map[string]any] { + return &c.FreeformTags +} + +func (c *mqlOciIdentityGroup) GetDefinedTags() *plugin.TValue[map[string]any] { + return &c.DefinedTags +} + +// mqlOciIdentityPolicy for the oci.identity.policy resource +type mqlOciIdentityPolicy struct { + MqlRuntime *plugin.Runtime + __id string + // optional: if you define mqlOciIdentityPolicyInternal it will be used here + Id plugin.TValue[string] + CompartmentID plugin.TValue[string] + Name plugin.TValue[string] + Description plugin.TValue[string] + Created plugin.TValue[*time.Time] + State plugin.TValue[string] + Statements plugin.TValue[[]any] + VersionDate plugin.TValue[*time.Time] + FreeformTags plugin.TValue[map[string]any] + DefinedTags plugin.TValue[map[string]any] +} + +// createOciIdentityPolicy creates a new instance of this resource +func createOciIdentityPolicy(runtime *plugin.Runtime, args map[string]*llx.RawData) (plugin.Resource, error) { + res := &mqlOciIdentityPolicy{ + MqlRuntime: runtime, + } + + err := SetAllData(res, args) + if err != nil { + return res, err + } + + if res.__id == "" { + res.__id, err = res.id() + if err != nil { + return nil, err + } + } + + if runtime.HasRecording { + args, err = runtime.ResourceFromRecording("oci.identity.policy", res.__id) + if err != nil || args == nil { + return res, err + } + return res, SetAllData(res, args) + } + + return res, nil +} + +func (c *mqlOciIdentityPolicy) MqlName() string { + return "oci.identity.policy" +} + +func (c *mqlOciIdentityPolicy) MqlID() string { + return c.__id +} + +func (c *mqlOciIdentityPolicy) GetId() *plugin.TValue[string] { + return &c.Id +} + +func (c *mqlOciIdentityPolicy) GetCompartmentID() *plugin.TValue[string] { + return &c.CompartmentID +} + +func (c *mqlOciIdentityPolicy) GetName() *plugin.TValue[string] { + return &c.Name +} + +func (c *mqlOciIdentityPolicy) GetDescription() *plugin.TValue[string] { + return &c.Description +} + +func (c *mqlOciIdentityPolicy) GetCreated() *plugin.TValue[*time.Time] { + return &c.Created +} + +func (c *mqlOciIdentityPolicy) GetState() *plugin.TValue[string] { + return &c.State +} + +func (c *mqlOciIdentityPolicy) GetStatements() *plugin.TValue[[]any] { + return &c.Statements +} + +func (c *mqlOciIdentityPolicy) GetVersionDate() *plugin.TValue[*time.Time] { + return &c.VersionDate +} + +func (c *mqlOciIdentityPolicy) GetFreeformTags() *plugin.TValue[map[string]any] { + return &c.FreeformTags +} + +func (c *mqlOciIdentityPolicy) GetDefinedTags() *plugin.TValue[map[string]any] { + return &c.DefinedTags +} + +// mqlOciCompute for the oci.compute resource +type mqlOciCompute struct { + MqlRuntime *plugin.Runtime + __id string + // optional: if you define mqlOciComputeInternal it will be used here + Instances plugin.TValue[[]any] + Images plugin.TValue[[]any] + BlockVolumes plugin.TValue[[]any] + BootVolumes plugin.TValue[[]any] +} + +// createOciCompute creates a new instance of this resource +func createOciCompute(runtime *plugin.Runtime, args map[string]*llx.RawData) (plugin.Resource, error) { + res := &mqlOciCompute{ + MqlRuntime: runtime, + } + + err := SetAllData(res, args) + if err != nil { + return res, err + } + + if res.__id == "" { + res.__id, err = res.id() + if err != nil { + return nil, err + } + } + + if runtime.HasRecording { + args, err = runtime.ResourceFromRecording("oci.compute", res.__id) + if err != nil || args == nil { + return res, err + } + return res, SetAllData(res, args) + } + + return res, nil +} + +func (c *mqlOciCompute) MqlName() string { + return "oci.compute" +} + +func (c *mqlOciCompute) MqlID() string { + return c.__id +} + +func (c *mqlOciCompute) GetInstances() *plugin.TValue[[]any] { + return plugin.GetOrCompute[[]any](&c.Instances, func() ([]any, error) { + if c.MqlRuntime.HasRecording { + d, err := c.MqlRuntime.FieldResourceFromRecording("oci.compute", c.__id, "instances") + if err != nil { + return nil, err + } + if d != nil { + return d.Value.([]any), nil + } + } + + return c.instances() + }) +} + +func (c *mqlOciCompute) GetImages() *plugin.TValue[[]any] { + return plugin.GetOrCompute[[]any](&c.Images, func() ([]any, error) { + if c.MqlRuntime.HasRecording { + d, err := c.MqlRuntime.FieldResourceFromRecording("oci.compute", c.__id, "images") + if err != nil { + return nil, err + } + if d != nil { + return d.Value.([]any), nil + } + } + + return c.images() + }) +} + +func (c *mqlOciCompute) GetBlockVolumes() *plugin.TValue[[]any] { + return plugin.GetOrCompute[[]any](&c.BlockVolumes, func() ([]any, error) { + if c.MqlRuntime.HasRecording { + d, err := c.MqlRuntime.FieldResourceFromRecording("oci.compute", c.__id, "blockVolumes") + if err != nil { + return nil, err + } + if d != nil { + return d.Value.([]any), nil + } + } + + return c.blockVolumes() + }) +} + +func (c *mqlOciCompute) GetBootVolumes() *plugin.TValue[[]any] { + return plugin.GetOrCompute[[]any](&c.BootVolumes, func() ([]any, error) { + if c.MqlRuntime.HasRecording { + d, err := c.MqlRuntime.FieldResourceFromRecording("oci.compute", c.__id, "bootVolumes") + if err != nil { + return nil, err + } + if d != nil { + return d.Value.([]any), nil + } + } + + return c.bootVolumes() + }) +} + +// mqlOciComputeInstance for the oci.compute.instance resource +type mqlOciComputeInstance struct { + MqlRuntime *plugin.Runtime + __id string + // optional: if you define mqlOciComputeInstanceInternal it will be used here + Id plugin.TValue[string] + Name plugin.TValue[string] + Region plugin.TValue[*mqlOciRegion] + Created plugin.TValue[*time.Time] + State plugin.TValue[string] + Shape plugin.TValue[string] + AvailabilityDomain plugin.TValue[string] + Compartment plugin.TValue[*mqlOciCompartment] + FaultDomain plugin.TValue[string] + ImageId plugin.TValue[string] + DedicatedVmHostId plugin.TValue[string] + PlatformConfig plugin.TValue[any] + LaunchOptions plugin.TValue[any] + InstanceOptions plugin.TValue[any] + ShapeConfig plugin.TValue[any] + SourceDetails plugin.TValue[any] + Metadata plugin.TValue[map[string]any] + TimeMaintenanceRebootDue plugin.TValue[*time.Time] + FreeformTags plugin.TValue[map[string]any] + DefinedTags plugin.TValue[map[string]any] +} + +// createOciComputeInstance creates a new instance of this resource +func createOciComputeInstance(runtime *plugin.Runtime, args map[string]*llx.RawData) (plugin.Resource, error) { + res := &mqlOciComputeInstance{ + MqlRuntime: runtime, + } + + err := SetAllData(res, args) + if err != nil { + return res, err + } + + if res.__id == "" { + res.__id, err = res.id() + if err != nil { + return nil, err + } + } + + if runtime.HasRecording { + args, err = runtime.ResourceFromRecording("oci.compute.instance", res.__id) + if err != nil || args == nil { + return res, err + } + return res, SetAllData(res, args) + } + + return res, nil +} + +func (c *mqlOciComputeInstance) MqlName() string { + return "oci.compute.instance" +} + +func (c *mqlOciComputeInstance) MqlID() string { + return c.__id +} + +func (c *mqlOciComputeInstance) GetId() *plugin.TValue[string] { + return &c.Id +} + +func (c *mqlOciComputeInstance) GetName() *plugin.TValue[string] { + return &c.Name +} + +func (c *mqlOciComputeInstance) GetRegion() *plugin.TValue[*mqlOciRegion] { + return &c.Region +} + +func (c *mqlOciComputeInstance) GetCreated() *plugin.TValue[*time.Time] { + return &c.Created +} + +func (c *mqlOciComputeInstance) GetState() *plugin.TValue[string] { + return &c.State +} + +func (c *mqlOciComputeInstance) GetShape() *plugin.TValue[string] { + return &c.Shape +} + +func (c *mqlOciComputeInstance) GetAvailabilityDomain() *plugin.TValue[string] { + return &c.AvailabilityDomain +} + +func (c *mqlOciComputeInstance) GetCompartment() *plugin.TValue[*mqlOciCompartment] { + return &c.Compartment +} + +func (c *mqlOciComputeInstance) GetFaultDomain() *plugin.TValue[string] { + return &c.FaultDomain +} + +func (c *mqlOciComputeInstance) GetImageId() *plugin.TValue[string] { + return &c.ImageId +} + +func (c *mqlOciComputeInstance) GetDedicatedVmHostId() *plugin.TValue[string] { + return &c.DedicatedVmHostId +} + +func (c *mqlOciComputeInstance) GetPlatformConfig() *plugin.TValue[any] { + return &c.PlatformConfig +} + +func (c *mqlOciComputeInstance) GetLaunchOptions() *plugin.TValue[any] { + return &c.LaunchOptions +} + +func (c *mqlOciComputeInstance) GetInstanceOptions() *plugin.TValue[any] { + return &c.InstanceOptions +} + +func (c *mqlOciComputeInstance) GetShapeConfig() *plugin.TValue[any] { + return &c.ShapeConfig +} + +func (c *mqlOciComputeInstance) GetSourceDetails() *plugin.TValue[any] { + return &c.SourceDetails +} + +func (c *mqlOciComputeInstance) GetMetadata() *plugin.TValue[map[string]any] { + return &c.Metadata +} + +func (c *mqlOciComputeInstance) GetTimeMaintenanceRebootDue() *plugin.TValue[*time.Time] { + return &c.TimeMaintenanceRebootDue +} + +func (c *mqlOciComputeInstance) GetFreeformTags() *plugin.TValue[map[string]any] { + return &c.FreeformTags +} + +func (c *mqlOciComputeInstance) GetDefinedTags() *plugin.TValue[map[string]any] { + return &c.DefinedTags +} + +// mqlOciComputeImage for the oci.compute.image resource +type mqlOciComputeImage struct { + MqlRuntime *plugin.Runtime + __id string + // optional: if you define mqlOciComputeImageInternal it will be used here + Id plugin.TValue[string] + Name plugin.TValue[string] + Region plugin.TValue[*mqlOciRegion] + Created plugin.TValue[*time.Time] + State plugin.TValue[string] + Compartment plugin.TValue[*mqlOciCompartment] + OperatingSystem plugin.TValue[string] + OperatingSystemVersion plugin.TValue[string] + SizeInMBs plugin.TValue[int64] + FreeformTags plugin.TValue[map[string]any] + DefinedTags plugin.TValue[map[string]any] +} + +// createOciComputeImage creates a new instance of this resource +func createOciComputeImage(runtime *plugin.Runtime, args map[string]*llx.RawData) (plugin.Resource, error) { + res := &mqlOciComputeImage{ + MqlRuntime: runtime, + } + + err := SetAllData(res, args) + if err != nil { + return res, err + } + + if res.__id == "" { + res.__id, err = res.id() + if err != nil { + return nil, err + } + } + + if runtime.HasRecording { + args, err = runtime.ResourceFromRecording("oci.compute.image", res.__id) + if err != nil || args == nil { + return res, err + } + return res, SetAllData(res, args) + } + + return res, nil +} + +func (c *mqlOciComputeImage) MqlName() string { + return "oci.compute.image" +} + +func (c *mqlOciComputeImage) MqlID() string { + return c.__id +} + +func (c *mqlOciComputeImage) GetId() *plugin.TValue[string] { + return &c.Id +} + +func (c *mqlOciComputeImage) GetName() *plugin.TValue[string] { + return &c.Name +} + +func (c *mqlOciComputeImage) GetRegion() *plugin.TValue[*mqlOciRegion] { + return &c.Region +} + +func (c *mqlOciComputeImage) GetCreated() *plugin.TValue[*time.Time] { + return &c.Created +} + +func (c *mqlOciComputeImage) GetState() *plugin.TValue[string] { + return &c.State +} + +func (c *mqlOciComputeImage) GetCompartment() *plugin.TValue[*mqlOciCompartment] { + return &c.Compartment +} + +func (c *mqlOciComputeImage) GetOperatingSystem() *plugin.TValue[string] { + return &c.OperatingSystem +} + +func (c *mqlOciComputeImage) GetOperatingSystemVersion() *plugin.TValue[string] { + return &c.OperatingSystemVersion +} + +func (c *mqlOciComputeImage) GetSizeInMBs() *plugin.TValue[int64] { + return &c.SizeInMBs +} + +func (c *mqlOciComputeImage) GetFreeformTags() *plugin.TValue[map[string]any] { + return &c.FreeformTags +} + +func (c *mqlOciComputeImage) GetDefinedTags() *plugin.TValue[map[string]any] { + return &c.DefinedTags +} + +// mqlOciComputeBlockVolume for the oci.compute.blockVolume resource +type mqlOciComputeBlockVolume struct { + MqlRuntime *plugin.Runtime + __id string + mqlOciComputeBlockVolumeInternal + Id plugin.TValue[string] + Name plugin.TValue[string] + CompartmentID plugin.TValue[string] + AvailabilityDomain plugin.TValue[string] + SizeInGBs plugin.TValue[int64] + VpusPerGB plugin.TValue[int64] + State plugin.TValue[string] + IsHydrated plugin.TValue[bool] + KmsKey plugin.TValue[*mqlOciKmsKey] + IsAutoTuneEnabled plugin.TValue[bool] + Created plugin.TValue[*time.Time] +} + +// createOciComputeBlockVolume creates a new instance of this resource +func createOciComputeBlockVolume(runtime *plugin.Runtime, args map[string]*llx.RawData) (plugin.Resource, error) { + res := &mqlOciComputeBlockVolume{ + MqlRuntime: runtime, + } + + err := SetAllData(res, args) + if err != nil { + return res, err + } + + if res.__id == "" { + res.__id, err = res.id() + if err != nil { + return nil, err + } + } + + if runtime.HasRecording { + args, err = runtime.ResourceFromRecording("oci.compute.blockVolume", res.__id) + if err != nil || args == nil { + return res, err + } + return res, SetAllData(res, args) + } + + return res, nil +} + +func (c *mqlOciComputeBlockVolume) MqlName() string { + return "oci.compute.blockVolume" +} + +func (c *mqlOciComputeBlockVolume) MqlID() string { + return c.__id +} + +func (c *mqlOciComputeBlockVolume) GetId() *plugin.TValue[string] { + return &c.Id +} + +func (c *mqlOciComputeBlockVolume) GetName() *plugin.TValue[string] { + return &c.Name +} + +func (c *mqlOciComputeBlockVolume) GetCompartmentID() *plugin.TValue[string] { + return &c.CompartmentID +} + +func (c *mqlOciComputeBlockVolume) GetAvailabilityDomain() *plugin.TValue[string] { + return &c.AvailabilityDomain +} + +func (c *mqlOciComputeBlockVolume) GetSizeInGBs() *plugin.TValue[int64] { + return &c.SizeInGBs +} + +func (c *mqlOciComputeBlockVolume) GetVpusPerGB() *plugin.TValue[int64] { + return &c.VpusPerGB +} + +func (c *mqlOciComputeBlockVolume) GetState() *plugin.TValue[string] { + return &c.State +} + +func (c *mqlOciComputeBlockVolume) GetIsHydrated() *plugin.TValue[bool] { + return &c.IsHydrated +} + +func (c *mqlOciComputeBlockVolume) GetKmsKey() *plugin.TValue[*mqlOciKmsKey] { + return plugin.GetOrCompute[*mqlOciKmsKey](&c.KmsKey, func() (*mqlOciKmsKey, error) { + if c.MqlRuntime.HasRecording { + d, err := c.MqlRuntime.FieldResourceFromRecording("oci.compute.blockVolume", c.__id, "kmsKey") + if err != nil { + return nil, err + } + if d != nil { + return d.Value.(*mqlOciKmsKey), nil + } + } + + return c.kmsKey() + }) +} + +func (c *mqlOciComputeBlockVolume) GetIsAutoTuneEnabled() *plugin.TValue[bool] { + return &c.IsAutoTuneEnabled +} + +func (c *mqlOciComputeBlockVolume) GetCreated() *plugin.TValue[*time.Time] { + return &c.Created +} + +// mqlOciComputeBootVolume for the oci.compute.bootVolume resource +type mqlOciComputeBootVolume struct { + MqlRuntime *plugin.Runtime + __id string + mqlOciComputeBootVolumeInternal + Id plugin.TValue[string] + Name plugin.TValue[string] + CompartmentID plugin.TValue[string] + AvailabilityDomain plugin.TValue[string] + SizeInGBs plugin.TValue[int64] + ImageId plugin.TValue[string] + State plugin.TValue[string] + KmsKey plugin.TValue[*mqlOciKmsKey] + Created plugin.TValue[*time.Time] +} + +// createOciComputeBootVolume creates a new instance of this resource +func createOciComputeBootVolume(runtime *plugin.Runtime, args map[string]*llx.RawData) (plugin.Resource, error) { + res := &mqlOciComputeBootVolume{ + MqlRuntime: runtime, + } + + err := SetAllData(res, args) + if err != nil { + return res, err + } + + if res.__id == "" { + res.__id, err = res.id() + if err != nil { + return nil, err + } + } + + if runtime.HasRecording { + args, err = runtime.ResourceFromRecording("oci.compute.bootVolume", res.__id) + if err != nil || args == nil { + return res, err + } + return res, SetAllData(res, args) + } + + return res, nil +} + +func (c *mqlOciComputeBootVolume) MqlName() string { + return "oci.compute.bootVolume" +} + +func (c *mqlOciComputeBootVolume) MqlID() string { + return c.__id +} + +func (c *mqlOciComputeBootVolume) GetId() *plugin.TValue[string] { + return &c.Id +} + +func (c *mqlOciComputeBootVolume) GetName() *plugin.TValue[string] { + return &c.Name +} + +func (c *mqlOciComputeBootVolume) GetCompartmentID() *plugin.TValue[string] { + return &c.CompartmentID +} + +func (c *mqlOciComputeBootVolume) GetAvailabilityDomain() *plugin.TValue[string] { + return &c.AvailabilityDomain +} + +func (c *mqlOciComputeBootVolume) GetSizeInGBs() *plugin.TValue[int64] { + return &c.SizeInGBs +} + +func (c *mqlOciComputeBootVolume) GetImageId() *plugin.TValue[string] { + return &c.ImageId +} + +func (c *mqlOciComputeBootVolume) GetState() *plugin.TValue[string] { + return &c.State +} + +func (c *mqlOciComputeBootVolume) GetKmsKey() *plugin.TValue[*mqlOciKmsKey] { + return plugin.GetOrCompute[*mqlOciKmsKey](&c.KmsKey, func() (*mqlOciKmsKey, error) { + if c.MqlRuntime.HasRecording { + d, err := c.MqlRuntime.FieldResourceFromRecording("oci.compute.bootVolume", c.__id, "kmsKey") + if err != nil { + return nil, err + } + if d != nil { + return d.Value.(*mqlOciKmsKey), nil + } + } + + return c.kmsKey() + }) +} + +func (c *mqlOciComputeBootVolume) GetCreated() *plugin.TValue[*time.Time] { + return &c.Created +} + +// mqlOciNetwork for the oci.network resource +type mqlOciNetwork struct { + MqlRuntime *plugin.Runtime + __id string + // optional: if you define mqlOciNetworkInternal it will be used here + Vcns plugin.TValue[[]any] + Subnets plugin.TValue[[]any] + SecurityLists plugin.TValue[[]any] + NetworkSecurityGroups plugin.TValue[[]any] +} + +// createOciNetwork creates a new instance of this resource +func createOciNetwork(runtime *plugin.Runtime, args map[string]*llx.RawData) (plugin.Resource, error) { + res := &mqlOciNetwork{ + MqlRuntime: runtime, + } + + err := SetAllData(res, args) + if err != nil { + return res, err + } + + if res.__id == "" { + res.__id, err = res.id() + if err != nil { + return nil, err + } + } + + if runtime.HasRecording { + args, err = runtime.ResourceFromRecording("oci.network", res.__id) + if err != nil || args == nil { + return res, err + } + return res, SetAllData(res, args) + } + + return res, nil +} + +func (c *mqlOciNetwork) MqlName() string { + return "oci.network" +} + +func (c *mqlOciNetwork) MqlID() string { + return c.__id +} + +func (c *mqlOciNetwork) GetVcns() *plugin.TValue[[]any] { + return plugin.GetOrCompute[[]any](&c.Vcns, func() ([]any, error) { + if c.MqlRuntime.HasRecording { + d, err := c.MqlRuntime.FieldResourceFromRecording("oci.network", c.__id, "vcns") + if err != nil { + return nil, err + } + if d != nil { + return d.Value.([]any), nil + } + } + + return c.vcns() + }) +} + +func (c *mqlOciNetwork) GetSubnets() *plugin.TValue[[]any] { + return plugin.GetOrCompute[[]any](&c.Subnets, func() ([]any, error) { + if c.MqlRuntime.HasRecording { + d, err := c.MqlRuntime.FieldResourceFromRecording("oci.network", c.__id, "subnets") + if err != nil { + return nil, err + } + if d != nil { + return d.Value.([]any), nil + } + } + + return c.subnets() + }) +} + +func (c *mqlOciNetwork) GetSecurityLists() *plugin.TValue[[]any] { + return plugin.GetOrCompute[[]any](&c.SecurityLists, func() ([]any, error) { + if c.MqlRuntime.HasRecording { + d, err := c.MqlRuntime.FieldResourceFromRecording("oci.network", c.__id, "securityLists") + if err != nil { + return nil, err + } + if d != nil { + return d.Value.([]any), nil + } + } + + return c.securityLists() + }) +} + +func (c *mqlOciNetwork) GetNetworkSecurityGroups() *plugin.TValue[[]any] { + return plugin.GetOrCompute[[]any](&c.NetworkSecurityGroups, func() ([]any, error) { + if c.MqlRuntime.HasRecording { + d, err := c.MqlRuntime.FieldResourceFromRecording("oci.network", c.__id, "networkSecurityGroups") + if err != nil { + return nil, err + } + if d != nil { + return d.Value.([]any), nil + } + } + + return c.networkSecurityGroups() + }) +} + +// mqlOciNetworkVcn for the oci.network.vcn resource +type mqlOciNetworkVcn struct { + MqlRuntime *plugin.Runtime + __id string + // optional: if you define mqlOciNetworkVcnInternal it will be used here + Id plugin.TValue[string] + CompartmentID plugin.TValue[string] + Name plugin.TValue[string] + Created plugin.TValue[*time.Time] + State plugin.TValue[string] + CidrBlock plugin.TValue[string] + CidrBlocks plugin.TValue[[]any] + VcnDomainName plugin.TValue[string] + DefaultDhcpOptionsId plugin.TValue[string] + DefaultRouteTableId plugin.TValue[string] + DefaultSecurityListId plugin.TValue[string] + DnsLabel plugin.TValue[string] + FreeformTags plugin.TValue[map[string]any] + DefinedTags plugin.TValue[map[string]any] +} + +// createOciNetworkVcn creates a new instance of this resource +func createOciNetworkVcn(runtime *plugin.Runtime, args map[string]*llx.RawData) (plugin.Resource, error) { + res := &mqlOciNetworkVcn{ + MqlRuntime: runtime, + } + + err := SetAllData(res, args) + if err != nil { + return res, err + } + + if res.__id == "" { + res.__id, err = res.id() + if err != nil { + return nil, err + } + } + + if runtime.HasRecording { + args, err = runtime.ResourceFromRecording("oci.network.vcn", res.__id) + if err != nil || args == nil { + return res, err + } + return res, SetAllData(res, args) + } + + return res, nil +} + +func (c *mqlOciNetworkVcn) MqlName() string { + return "oci.network.vcn" +} + +func (c *mqlOciNetworkVcn) MqlID() string { + return c.__id +} + +func (c *mqlOciNetworkVcn) GetId() *plugin.TValue[string] { + return &c.Id +} + +func (c *mqlOciNetworkVcn) GetCompartmentID() *plugin.TValue[string] { + return &c.CompartmentID +} + +func (c *mqlOciNetworkVcn) GetName() *plugin.TValue[string] { + return &c.Name +} + +func (c *mqlOciNetworkVcn) GetCreated() *plugin.TValue[*time.Time] { + return &c.Created +} + +func (c *mqlOciNetworkVcn) GetState() *plugin.TValue[string] { + return &c.State +} + +func (c *mqlOciNetworkVcn) GetCidrBlock() *plugin.TValue[string] { + return &c.CidrBlock +} + +func (c *mqlOciNetworkVcn) GetCidrBlocks() *plugin.TValue[[]any] { + return &c.CidrBlocks +} + +func (c *mqlOciNetworkVcn) GetVcnDomainName() *plugin.TValue[string] { + return &c.VcnDomainName +} + +func (c *mqlOciNetworkVcn) GetDefaultDhcpOptionsId() *plugin.TValue[string] { + return &c.DefaultDhcpOptionsId +} + +func (c *mqlOciNetworkVcn) GetDefaultRouteTableId() *plugin.TValue[string] { + return &c.DefaultRouteTableId +} + +func (c *mqlOciNetworkVcn) GetDefaultSecurityListId() *plugin.TValue[string] { + return &c.DefaultSecurityListId +} + +func (c *mqlOciNetworkVcn) GetDnsLabel() *plugin.TValue[string] { + return &c.DnsLabel +} + +func (c *mqlOciNetworkVcn) GetFreeformTags() *plugin.TValue[map[string]any] { + return &c.FreeformTags +} + +func (c *mqlOciNetworkVcn) GetDefinedTags() *plugin.TValue[map[string]any] { + return &c.DefinedTags +} + +// mqlOciNetworkSubnet for the oci.network.subnet resource +type mqlOciNetworkSubnet struct { + MqlRuntime *plugin.Runtime + __id string + mqlOciNetworkSubnetInternal + Id plugin.TValue[string] + Name plugin.TValue[string] + CompartmentID plugin.TValue[string] + Vcn plugin.TValue[*mqlOciNetworkVcn] + AvailabilityDomain plugin.TValue[string] + CidrBlock plugin.TValue[string] + State plugin.TValue[string] + DnsLabel plugin.TValue[string] + SubnetDomainName plugin.TValue[string] + ProhibitPublicIpOnVnic plugin.TValue[bool] + ProhibitInternetIngress plugin.TValue[bool] + Created plugin.TValue[*time.Time] + FreeformTags plugin.TValue[map[string]any] + DefinedTags plugin.TValue[map[string]any] +} + +// createOciNetworkSubnet creates a new instance of this resource +func createOciNetworkSubnet(runtime *plugin.Runtime, args map[string]*llx.RawData) (plugin.Resource, error) { + res := &mqlOciNetworkSubnet{ + MqlRuntime: runtime, + } + + err := SetAllData(res, args) + if err != nil { + return res, err + } + + if res.__id == "" { + res.__id, err = res.id() + if err != nil { + return nil, err + } + } + + if runtime.HasRecording { + args, err = runtime.ResourceFromRecording("oci.network.subnet", res.__id) + if err != nil || args == nil { + return res, err + } + return res, SetAllData(res, args) + } + + return res, nil +} + +func (c *mqlOciNetworkSubnet) MqlName() string { + return "oci.network.subnet" +} + +func (c *mqlOciNetworkSubnet) MqlID() string { + return c.__id +} + +func (c *mqlOciNetworkSubnet) GetId() *plugin.TValue[string] { + return &c.Id +} + +func (c *mqlOciNetworkSubnet) GetName() *plugin.TValue[string] { + return &c.Name +} + +func (c *mqlOciNetworkSubnet) GetCompartmentID() *plugin.TValue[string] { + return &c.CompartmentID +} + +func (c *mqlOciNetworkSubnet) GetVcn() *plugin.TValue[*mqlOciNetworkVcn] { + return plugin.GetOrCompute[*mqlOciNetworkVcn](&c.Vcn, func() (*mqlOciNetworkVcn, error) { + if c.MqlRuntime.HasRecording { + d, err := c.MqlRuntime.FieldResourceFromRecording("oci.network.subnet", c.__id, "vcn") + if err != nil { + return nil, err + } + if d != nil { + return d.Value.(*mqlOciNetworkVcn), nil + } + } + + return c.vcn() + }) +} + +func (c *mqlOciNetworkSubnet) GetAvailabilityDomain() *plugin.TValue[string] { + return &c.AvailabilityDomain +} + +func (c *mqlOciNetworkSubnet) GetCidrBlock() *plugin.TValue[string] { + return &c.CidrBlock +} + +func (c *mqlOciNetworkSubnet) GetState() *plugin.TValue[string] { + return &c.State +} + +func (c *mqlOciNetworkSubnet) GetDnsLabel() *plugin.TValue[string] { + return &c.DnsLabel +} + +func (c *mqlOciNetworkSubnet) GetSubnetDomainName() *plugin.TValue[string] { + return &c.SubnetDomainName +} + +func (c *mqlOciNetworkSubnet) GetProhibitPublicIpOnVnic() *plugin.TValue[bool] { + return &c.ProhibitPublicIpOnVnic +} + +func (c *mqlOciNetworkSubnet) GetProhibitInternetIngress() *plugin.TValue[bool] { + return &c.ProhibitInternetIngress +} + +func (c *mqlOciNetworkSubnet) GetCreated() *plugin.TValue[*time.Time] { + return &c.Created +} + +func (c *mqlOciNetworkSubnet) GetFreeformTags() *plugin.TValue[map[string]any] { + return &c.FreeformTags +} + +func (c *mqlOciNetworkSubnet) GetDefinedTags() *plugin.TValue[map[string]any] { + return &c.DefinedTags +} + +// mqlOciNetworkSecurityList for the oci.network.securityList resource +type mqlOciNetworkSecurityList struct { + MqlRuntime *plugin.Runtime + __id string + mqlOciNetworkSecurityListInternal + Id plugin.TValue[string] + CompartmentID plugin.TValue[string] + Name plugin.TValue[string] + Created plugin.TValue[*time.Time] + State plugin.TValue[string] + EgressSecurityRules plugin.TValue[[]any] + IngressSecurityRules plugin.TValue[[]any] + VcnId plugin.TValue[string] + Vcn plugin.TValue[*mqlOciNetworkVcn] + FreeformTags plugin.TValue[map[string]any] + DefinedTags plugin.TValue[map[string]any] +} + +// createOciNetworkSecurityList creates a new instance of this resource +func createOciNetworkSecurityList(runtime *plugin.Runtime, args map[string]*llx.RawData) (plugin.Resource, error) { + res := &mqlOciNetworkSecurityList{ + MqlRuntime: runtime, + } + + err := SetAllData(res, args) + if err != nil { + return res, err + } + + if res.__id == "" { + res.__id, err = res.id() + if err != nil { + return nil, err + } + } + + if runtime.HasRecording { + args, err = runtime.ResourceFromRecording("oci.network.securityList", res.__id) + if err != nil || args == nil { + return res, err + } + return res, SetAllData(res, args) + } + + return res, nil +} + +func (c *mqlOciNetworkSecurityList) MqlName() string { + return "oci.network.securityList" +} + +func (c *mqlOciNetworkSecurityList) MqlID() string { + return c.__id +} + +func (c *mqlOciNetworkSecurityList) GetId() *plugin.TValue[string] { + return &c.Id +} + +func (c *mqlOciNetworkSecurityList) GetCompartmentID() *plugin.TValue[string] { + return &c.CompartmentID +} + +func (c *mqlOciNetworkSecurityList) GetName() *plugin.TValue[string] { + return &c.Name +} + +func (c *mqlOciNetworkSecurityList) GetCreated() *plugin.TValue[*time.Time] { + return &c.Created +} + +func (c *mqlOciNetworkSecurityList) GetState() *plugin.TValue[string] { + return &c.State +} + +func (c *mqlOciNetworkSecurityList) GetEgressSecurityRules() *plugin.TValue[[]any] { + return &c.EgressSecurityRules +} + +func (c *mqlOciNetworkSecurityList) GetIngressSecurityRules() *plugin.TValue[[]any] { + return &c.IngressSecurityRules +} + +func (c *mqlOciNetworkSecurityList) GetVcnId() *plugin.TValue[string] { + return &c.VcnId +} + +func (c *mqlOciNetworkSecurityList) GetVcn() *plugin.TValue[*mqlOciNetworkVcn] { + return plugin.GetOrCompute[*mqlOciNetworkVcn](&c.Vcn, func() (*mqlOciNetworkVcn, error) { + if c.MqlRuntime.HasRecording { + d, err := c.MqlRuntime.FieldResourceFromRecording("oci.network.securityList", c.__id, "vcn") + if err != nil { + return nil, err + } + if d != nil { + return d.Value.(*mqlOciNetworkVcn), nil + } + } + + return c.vcn() + }) +} + +func (c *mqlOciNetworkSecurityList) GetFreeformTags() *plugin.TValue[map[string]any] { + return &c.FreeformTags +} + +func (c *mqlOciNetworkSecurityList) GetDefinedTags() *plugin.TValue[map[string]any] { + return &c.DefinedTags +} + +// mqlOciNetworkNetworkSecurityGroup for the oci.network.networkSecurityGroup resource +type mqlOciNetworkNetworkSecurityGroup struct { + MqlRuntime *plugin.Runtime + __id string + mqlOciNetworkNetworkSecurityGroupInternal + Id plugin.TValue[string] + Name plugin.TValue[string] + CompartmentID plugin.TValue[string] + Vcn plugin.TValue[*mqlOciNetworkVcn] + State plugin.TValue[string] + Created plugin.TValue[*time.Time] + FreeformTags plugin.TValue[map[string]any] + DefinedTags plugin.TValue[map[string]any] + IngressSecurityRules plugin.TValue[[]any] + EgressSecurityRules plugin.TValue[[]any] +} + +// createOciNetworkNetworkSecurityGroup creates a new instance of this resource +func createOciNetworkNetworkSecurityGroup(runtime *plugin.Runtime, args map[string]*llx.RawData) (plugin.Resource, error) { + res := &mqlOciNetworkNetworkSecurityGroup{ + MqlRuntime: runtime, + } + + err := SetAllData(res, args) + if err != nil { + return res, err + } + + if res.__id == "" { + res.__id, err = res.id() + if err != nil { + return nil, err + } + } + + if runtime.HasRecording { + args, err = runtime.ResourceFromRecording("oci.network.networkSecurityGroup", res.__id) + if err != nil || args == nil { + return res, err + } + return res, SetAllData(res, args) + } + + return res, nil +} + +func (c *mqlOciNetworkNetworkSecurityGroup) MqlName() string { + return "oci.network.networkSecurityGroup" +} + +func (c *mqlOciNetworkNetworkSecurityGroup) MqlID() string { + return c.__id +} + +func (c *mqlOciNetworkNetworkSecurityGroup) GetId() *plugin.TValue[string] { + return &c.Id +} + +func (c *mqlOciNetworkNetworkSecurityGroup) GetName() *plugin.TValue[string] { + return &c.Name +} + +func (c *mqlOciNetworkNetworkSecurityGroup) GetCompartmentID() *plugin.TValue[string] { + return &c.CompartmentID +} + +func (c *mqlOciNetworkNetworkSecurityGroup) GetVcn() *plugin.TValue[*mqlOciNetworkVcn] { + return plugin.GetOrCompute[*mqlOciNetworkVcn](&c.Vcn, func() (*mqlOciNetworkVcn, error) { + if c.MqlRuntime.HasRecording { + d, err := c.MqlRuntime.FieldResourceFromRecording("oci.network.networkSecurityGroup", c.__id, "vcn") + if err != nil { + return nil, err + } + if d != nil { + return d.Value.(*mqlOciNetworkVcn), nil + } + } + + return c.vcn() + }) +} + +func (c *mqlOciNetworkNetworkSecurityGroup) GetState() *plugin.TValue[string] { + return &c.State +} + +func (c *mqlOciNetworkNetworkSecurityGroup) GetCreated() *plugin.TValue[*time.Time] { + return &c.Created +} + +func (c *mqlOciNetworkNetworkSecurityGroup) GetFreeformTags() *plugin.TValue[map[string]any] { + return &c.FreeformTags +} + +func (c *mqlOciNetworkNetworkSecurityGroup) GetDefinedTags() *plugin.TValue[map[string]any] { + return &c.DefinedTags +} + +func (c *mqlOciNetworkNetworkSecurityGroup) GetIngressSecurityRules() *plugin.TValue[[]any] { + return plugin.GetOrCompute[[]any](&c.IngressSecurityRules, func() ([]any, error) { + return c.ingressSecurityRules() + }) +} + +func (c *mqlOciNetworkNetworkSecurityGroup) GetEgressSecurityRules() *plugin.TValue[[]any] { + return plugin.GetOrCompute[[]any](&c.EgressSecurityRules, func() ([]any, error) { + return c.egressSecurityRules() + }) +} + +// mqlOciLogging for the oci.logging resource +type mqlOciLogging struct { + MqlRuntime *plugin.Runtime + __id string + // optional: if you define mqlOciLoggingInternal it will be used here + LogGroups plugin.TValue[[]any] +} + +// createOciLogging creates a new instance of this resource +func createOciLogging(runtime *plugin.Runtime, args map[string]*llx.RawData) (plugin.Resource, error) { + res := &mqlOciLogging{ + MqlRuntime: runtime, + } + + err := SetAllData(res, args) + if err != nil { + return res, err + } + + if res.__id == "" { + res.__id, err = res.id() + if err != nil { + return nil, err + } + } + + if runtime.HasRecording { + args, err = runtime.ResourceFromRecording("oci.logging", res.__id) + if err != nil || args == nil { + return res, err + } + return res, SetAllData(res, args) + } + + return res, nil +} + +func (c *mqlOciLogging) MqlName() string { + return "oci.logging" +} + +func (c *mqlOciLogging) MqlID() string { + return c.__id +} + +func (c *mqlOciLogging) GetLogGroups() *plugin.TValue[[]any] { + return plugin.GetOrCompute[[]any](&c.LogGroups, func() ([]any, error) { + if c.MqlRuntime.HasRecording { + d, err := c.MqlRuntime.FieldResourceFromRecording("oci.logging", c.__id, "logGroups") + if err != nil { + return nil, err + } + if d != nil { + return d.Value.([]any), nil + } + } + + return c.logGroups() + }) +} + +// mqlOciLoggingLogGroup for the oci.logging.logGroup resource +type mqlOciLoggingLogGroup struct { + MqlRuntime *plugin.Runtime + __id string + mqlOciLoggingLogGroupInternal + Id plugin.TValue[string] + Name plugin.TValue[string] + Description plugin.TValue[string] + CompartmentID plugin.TValue[string] + State plugin.TValue[string] + Logs plugin.TValue[[]any] + Created plugin.TValue[*time.Time] +} + +// createOciLoggingLogGroup creates a new instance of this resource +func createOciLoggingLogGroup(runtime *plugin.Runtime, args map[string]*llx.RawData) (plugin.Resource, error) { + res := &mqlOciLoggingLogGroup{ + MqlRuntime: runtime, + } + + err := SetAllData(res, args) + if err != nil { + return res, err + } + + if res.__id == "" { + res.__id, err = res.id() + if err != nil { + return nil, err + } + } + + if runtime.HasRecording { + args, err = runtime.ResourceFromRecording("oci.logging.logGroup", res.__id) + if err != nil || args == nil { + return res, err + } + return res, SetAllData(res, args) + } + + return res, nil +} + +func (c *mqlOciLoggingLogGroup) MqlName() string { + return "oci.logging.logGroup" +} + +func (c *mqlOciLoggingLogGroup) MqlID() string { + return c.__id +} + +func (c *mqlOciLoggingLogGroup) GetId() *plugin.TValue[string] { + return &c.Id +} + +func (c *mqlOciLoggingLogGroup) GetName() *plugin.TValue[string] { + return &c.Name +} + +func (c *mqlOciLoggingLogGroup) GetDescription() *plugin.TValue[string] { + return &c.Description +} + +func (c *mqlOciLoggingLogGroup) GetCompartmentID() *plugin.TValue[string] { + return &c.CompartmentID +} + +func (c *mqlOciLoggingLogGroup) GetState() *plugin.TValue[string] { + return &c.State +} + +func (c *mqlOciLoggingLogGroup) GetLogs() *plugin.TValue[[]any] { + return plugin.GetOrCompute[[]any](&c.Logs, func() ([]any, error) { + if c.MqlRuntime.HasRecording { + d, err := c.MqlRuntime.FieldResourceFromRecording("oci.logging.logGroup", c.__id, "logs") + if err != nil { + return nil, err + } + if d != nil { + return d.Value.([]any), nil + } + } + + return c.logs() + }) +} + +func (c *mqlOciLoggingLogGroup) GetCreated() *plugin.TValue[*time.Time] { + return &c.Created +} + +// mqlOciLoggingLog for the oci.logging.log resource +type mqlOciLoggingLog struct { + MqlRuntime *plugin.Runtime + __id string + mqlOciLoggingLogInternal + Id plugin.TValue[string] + Name plugin.TValue[string] + LogType plugin.TValue[string] + LogGroup plugin.TValue[*mqlOciLoggingLogGroup] + IsEnabled plugin.TValue[bool] + State plugin.TValue[string] + RetentionDuration plugin.TValue[int64] + Configuration plugin.TValue[any] + Created plugin.TValue[*time.Time] + TimeLastModified plugin.TValue[*time.Time] +} + +// createOciLoggingLog creates a new instance of this resource +func createOciLoggingLog(runtime *plugin.Runtime, args map[string]*llx.RawData) (plugin.Resource, error) { + res := &mqlOciLoggingLog{ + MqlRuntime: runtime, + } + + err := SetAllData(res, args) + if err != nil { + return res, err + } + + if res.__id == "" { + res.__id, err = res.id() + if err != nil { + return nil, err + } + } + + if runtime.HasRecording { + args, err = runtime.ResourceFromRecording("oci.logging.log", res.__id) + if err != nil || args == nil { + return res, err + } + return res, SetAllData(res, args) + } + + return res, nil +} + +func (c *mqlOciLoggingLog) MqlName() string { + return "oci.logging.log" +} + +func (c *mqlOciLoggingLog) MqlID() string { + return c.__id +} + +func (c *mqlOciLoggingLog) GetId() *plugin.TValue[string] { + return &c.Id +} + +func (c *mqlOciLoggingLog) GetName() *plugin.TValue[string] { + return &c.Name +} + +func (c *mqlOciLoggingLog) GetLogType() *plugin.TValue[string] { + return &c.LogType +} + +func (c *mqlOciLoggingLog) GetLogGroup() *plugin.TValue[*mqlOciLoggingLogGroup] { + return plugin.GetOrCompute[*mqlOciLoggingLogGroup](&c.LogGroup, func() (*mqlOciLoggingLogGroup, error) { + if c.MqlRuntime.HasRecording { + d, err := c.MqlRuntime.FieldResourceFromRecording("oci.logging.log", c.__id, "logGroup") + if err != nil { + return nil, err + } + if d != nil { + return d.Value.(*mqlOciLoggingLogGroup), nil + } + } + + return c.logGroup() + }) +} + +func (c *mqlOciLoggingLog) GetIsEnabled() *plugin.TValue[bool] { + return &c.IsEnabled +} + +func (c *mqlOciLoggingLog) GetState() *plugin.TValue[string] { + return &c.State +} + +func (c *mqlOciLoggingLog) GetRetentionDuration() *plugin.TValue[int64] { + return &c.RetentionDuration +} + +func (c *mqlOciLoggingLog) GetConfiguration() *plugin.TValue[any] { + return &c.Configuration +} + +func (c *mqlOciLoggingLog) GetCreated() *plugin.TValue[*time.Time] { + return &c.Created +} + +func (c *mqlOciLoggingLog) GetTimeLastModified() *plugin.TValue[*time.Time] { + return &c.TimeLastModified +} + +// mqlOciKms for the oci.kms resource +type mqlOciKms struct { + MqlRuntime *plugin.Runtime + __id string + // optional: if you define mqlOciKmsInternal it will be used here + Vaults plugin.TValue[[]any] +} + +// createOciKms creates a new instance of this resource +func createOciKms(runtime *plugin.Runtime, args map[string]*llx.RawData) (plugin.Resource, error) { + res := &mqlOciKms{ + MqlRuntime: runtime, + } + + err := SetAllData(res, args) + if err != nil { + return res, err + } + + if res.__id == "" { + res.__id, err = res.id() + if err != nil { + return nil, err + } + } + + if runtime.HasRecording { + args, err = runtime.ResourceFromRecording("oci.kms", res.__id) + if err != nil || args == nil { + return res, err + } + return res, SetAllData(res, args) + } + + return res, nil +} + +func (c *mqlOciKms) MqlName() string { + return "oci.kms" +} + +func (c *mqlOciKms) MqlID() string { + return c.__id +} + +func (c *mqlOciKms) GetVaults() *plugin.TValue[[]any] { + return plugin.GetOrCompute[[]any](&c.Vaults, func() ([]any, error) { + if c.MqlRuntime.HasRecording { + d, err := c.MqlRuntime.FieldResourceFromRecording("oci.kms", c.__id, "vaults") + if err != nil { + return nil, err + } + if d != nil { + return d.Value.([]any), nil + } + } + + return c.vaults() + }) +} + +// mqlOciKmsVault for the oci.kms.vault resource +type mqlOciKmsVault struct { + MqlRuntime *plugin.Runtime + __id string + mqlOciKmsVaultInternal + Id plugin.TValue[string] + Name plugin.TValue[string] + CompartmentID plugin.TValue[string] + VaultType plugin.TValue[string] + State plugin.TValue[string] + ManagementEndpoint plugin.TValue[string] + Keys plugin.TValue[[]any] + Created plugin.TValue[*time.Time] +} + +// createOciKmsVault creates a new instance of this resource +func createOciKmsVault(runtime *plugin.Runtime, args map[string]*llx.RawData) (plugin.Resource, error) { + res := &mqlOciKmsVault{ + MqlRuntime: runtime, + } + + err := SetAllData(res, args) + if err != nil { + return res, err + } + + if res.__id == "" { + res.__id, err = res.id() + if err != nil { + return nil, err + } + } + + if runtime.HasRecording { + args, err = runtime.ResourceFromRecording("oci.kms.vault", res.__id) + if err != nil || args == nil { + return res, err + } + return res, SetAllData(res, args) + } + + return res, nil +} + +func (c *mqlOciKmsVault) MqlName() string { + return "oci.kms.vault" +} + +func (c *mqlOciKmsVault) MqlID() string { + return c.__id +} + +func (c *mqlOciKmsVault) GetId() *plugin.TValue[string] { + return &c.Id +} + +func (c *mqlOciKmsVault) GetName() *plugin.TValue[string] { + return &c.Name +} + +func (c *mqlOciKmsVault) GetCompartmentID() *plugin.TValue[string] { + return &c.CompartmentID +} + +func (c *mqlOciKmsVault) GetVaultType() *plugin.TValue[string] { + return &c.VaultType +} + +func (c *mqlOciKmsVault) GetState() *plugin.TValue[string] { + return &c.State +} + +func (c *mqlOciKmsVault) GetManagementEndpoint() *plugin.TValue[string] { + return &c.ManagementEndpoint +} + +func (c *mqlOciKmsVault) GetKeys() *plugin.TValue[[]any] { + return plugin.GetOrCompute[[]any](&c.Keys, func() ([]any, error) { + if c.MqlRuntime.HasRecording { + d, err := c.MqlRuntime.FieldResourceFromRecording("oci.kms.vault", c.__id, "keys") + if err != nil { + return nil, err + } + if d != nil { + return d.Value.([]any), nil + } + } + + return c.keys() + }) +} + +func (c *mqlOciKmsVault) GetCreated() *plugin.TValue[*time.Time] { + return &c.Created +} + +// mqlOciKmsKey for the oci.kms.key resource +type mqlOciKmsKey struct { + MqlRuntime *plugin.Runtime + __id string + // optional: if you define mqlOciKmsKeyInternal it will be used here + Id plugin.TValue[string] + Name plugin.TValue[string] + CompartmentID plugin.TValue[string] + VaultId plugin.TValue[string] + Algorithm plugin.TValue[string] + ProtectionMode plugin.TValue[string] + State plugin.TValue[string] + IsAutoRotationEnabled plugin.TValue[bool] + Created plugin.TValue[*time.Time] +} + +// createOciKmsKey creates a new instance of this resource +func createOciKmsKey(runtime *plugin.Runtime, args map[string]*llx.RawData) (plugin.Resource, error) { + res := &mqlOciKmsKey{ + MqlRuntime: runtime, + } + + err := SetAllData(res, args) + if err != nil { + return res, err + } + + if res.__id == "" { + res.__id, err = res.id() + if err != nil { + return nil, err + } + } + + if runtime.HasRecording { + args, err = runtime.ResourceFromRecording("oci.kms.key", res.__id) + if err != nil || args == nil { + return res, err + } + return res, SetAllData(res, args) + } + + return res, nil +} + +func (c *mqlOciKmsKey) MqlName() string { + return "oci.kms.key" +} + +func (c *mqlOciKmsKey) MqlID() string { + return c.__id +} + +func (c *mqlOciKmsKey) GetId() *plugin.TValue[string] { + return &c.Id +} + +func (c *mqlOciKmsKey) GetName() *plugin.TValue[string] { + return &c.Name +} + +func (c *mqlOciKmsKey) GetCompartmentID() *plugin.TValue[string] { + return &c.CompartmentID +} + +func (c *mqlOciKmsKey) GetVaultId() *plugin.TValue[string] { + return &c.VaultId +} + +func (c *mqlOciKmsKey) GetAlgorithm() *plugin.TValue[string] { + return &c.Algorithm +} + +func (c *mqlOciKmsKey) GetProtectionMode() *plugin.TValue[string] { + return &c.ProtectionMode +} + +func (c *mqlOciKmsKey) GetState() *plugin.TValue[string] { + return &c.State +} + +func (c *mqlOciKmsKey) GetIsAutoRotationEnabled() *plugin.TValue[bool] { + return &c.IsAutoRotationEnabled +} + +func (c *mqlOciKmsKey) GetCreated() *plugin.TValue[*time.Time] { + return &c.Created +} + +// mqlOciObjectStorage for the oci.objectStorage resource +type mqlOciObjectStorage struct { + MqlRuntime *plugin.Runtime + __id string + // optional: if you define mqlOciObjectStorageInternal it will be used here + Namespace plugin.TValue[string] + Buckets plugin.TValue[[]any] +} + +// createOciObjectStorage creates a new instance of this resource +func createOciObjectStorage(runtime *plugin.Runtime, args map[string]*llx.RawData) (plugin.Resource, error) { + res := &mqlOciObjectStorage{ + MqlRuntime: runtime, + } + + err := SetAllData(res, args) + if err != nil { + return res, err + } + + if res.__id == "" { + res.__id, err = res.id() + if err != nil { + return nil, err + } + } + + if runtime.HasRecording { + args, err = runtime.ResourceFromRecording("oci.objectStorage", res.__id) + if err != nil || args == nil { + return res, err + } + return res, SetAllData(res, args) + } + + return res, nil +} + +func (c *mqlOciObjectStorage) MqlName() string { + return "oci.objectStorage" +} + +func (c *mqlOciObjectStorage) MqlID() string { + return c.__id +} + +func (c *mqlOciObjectStorage) GetNamespace() *plugin.TValue[string] { + return plugin.GetOrCompute[string](&c.Namespace, func() (string, error) { + return c.namespace() + }) +} + +func (c *mqlOciObjectStorage) GetBuckets() *plugin.TValue[[]any] { + return plugin.GetOrCompute[[]any](&c.Buckets, func() ([]any, error) { + if c.MqlRuntime.HasRecording { + d, err := c.MqlRuntime.FieldResourceFromRecording("oci.objectStorage", c.__id, "buckets") + if err != nil { + return nil, err + } + if d != nil { + return d.Value.([]any), nil + } + } + + return c.buckets() + }) +} + +// mqlOciObjectStorageBucket for the oci.objectStorage.bucket resource +type mqlOciObjectStorageBucket struct { + MqlRuntime *plugin.Runtime + __id string + mqlOciObjectStorageBucketInternal + Namespace plugin.TValue[string] + Name plugin.TValue[string] + CompartmentID plugin.TValue[string] + Created plugin.TValue[*time.Time] + Region plugin.TValue[*mqlOciRegion] + PublicAccessType plugin.TValue[string] + StorageTier plugin.TValue[string] + AutoTiering plugin.TValue[string] + Versioning plugin.TValue[string] + ObjectEventsEnabled plugin.TValue[bool] + ReplicationEnabled plugin.TValue[bool] + Id plugin.TValue[string] + IsReadOnly plugin.TValue[bool] + Etag plugin.TValue[string] + KmsKeyId plugin.TValue[string] + ApproximateCount plugin.TValue[int64] + ApproximateSize plugin.TValue[int64] + ObjectLifecyclePolicyEtag plugin.TValue[string] + FreeformTags plugin.TValue[map[string]any] + DefinedTags plugin.TValue[map[string]any] +} + +// createOciObjectStorageBucket creates a new instance of this resource +func createOciObjectStorageBucket(runtime *plugin.Runtime, args map[string]*llx.RawData) (plugin.Resource, error) { + res := &mqlOciObjectStorageBucket{ + MqlRuntime: runtime, + } + + err := SetAllData(res, args) + if err != nil { + return res, err + } + + if res.__id == "" { + res.__id, err = res.id() + if err != nil { + return nil, err + } + } + + if runtime.HasRecording { + args, err = runtime.ResourceFromRecording("oci.objectStorage.bucket", res.__id) + if err != nil || args == nil { + return res, err + } + return res, SetAllData(res, args) + } + + return res, nil +} + +func (c *mqlOciObjectStorageBucket) MqlName() string { + return "oci.objectStorage.bucket" +} + +func (c *mqlOciObjectStorageBucket) MqlID() string { + return c.__id +} + +func (c *mqlOciObjectStorageBucket) GetNamespace() *plugin.TValue[string] { + return &c.Namespace +} + +func (c *mqlOciObjectStorageBucket) GetName() *plugin.TValue[string] { + return &c.Name +} + +func (c *mqlOciObjectStorageBucket) GetCompartmentID() *plugin.TValue[string] { + return &c.CompartmentID +} + +func (c *mqlOciObjectStorageBucket) GetCreated() *plugin.TValue[*time.Time] { + return &c.Created +} + +func (c *mqlOciObjectStorageBucket) GetRegion() *plugin.TValue[*mqlOciRegion] { + return &c.Region +} + +func (c *mqlOciObjectStorageBucket) GetPublicAccessType() *plugin.TValue[string] { + return plugin.GetOrCompute[string](&c.PublicAccessType, func() (string, error) { + return c.publicAccessType() + }) +} + +func (c *mqlOciObjectStorageBucket) GetStorageTier() *plugin.TValue[string] { + return plugin.GetOrCompute[string](&c.StorageTier, func() (string, error) { + return c.storageTier() + }) +} + +func (c *mqlOciObjectStorageBucket) GetAutoTiering() *plugin.TValue[string] { + return plugin.GetOrCompute[string](&c.AutoTiering, func() (string, error) { + return c.autoTiering() + }) +} + +func (c *mqlOciObjectStorageBucket) GetVersioning() *plugin.TValue[string] { + return plugin.GetOrCompute[string](&c.Versioning, func() (string, error) { + return c.versioning() + }) +} + +func (c *mqlOciObjectStorageBucket) GetObjectEventsEnabled() *plugin.TValue[bool] { + return plugin.GetOrCompute[bool](&c.ObjectEventsEnabled, func() (bool, error) { + return c.objectEventsEnabled() + }) +} + +func (c *mqlOciObjectStorageBucket) GetReplicationEnabled() *plugin.TValue[bool] { + return plugin.GetOrCompute[bool](&c.ReplicationEnabled, func() (bool, error) { + return c.replicationEnabled() + }) +} + +func (c *mqlOciObjectStorageBucket) GetId() *plugin.TValue[string] { + return &c.Id +} + +func (c *mqlOciObjectStorageBucket) GetIsReadOnly() *plugin.TValue[bool] { + return plugin.GetOrCompute[bool](&c.IsReadOnly, func() (bool, error) { + return c.isReadOnly() + }) +} + +func (c *mqlOciObjectStorageBucket) GetEtag() *plugin.TValue[string] { + return plugin.GetOrCompute[string](&c.Etag, func() (string, error) { + return c.etag() + }) +} + +func (c *mqlOciObjectStorageBucket) GetKmsKeyId() *plugin.TValue[string] { + return plugin.GetOrCompute[string](&c.KmsKeyId, func() (string, error) { + return c.kmsKeyId() + }) +} + +func (c *mqlOciObjectStorageBucket) GetApproximateCount() *plugin.TValue[int64] { + return plugin.GetOrCompute[int64](&c.ApproximateCount, func() (int64, error) { + return c.approximateCount() + }) +} + +func (c *mqlOciObjectStorageBucket) GetApproximateSize() *plugin.TValue[int64] { + return plugin.GetOrCompute[int64](&c.ApproximateSize, func() (int64, error) { + return c.approximateSize() + }) +} + +func (c *mqlOciObjectStorageBucket) GetObjectLifecyclePolicyEtag() *plugin.TValue[string] { + return plugin.GetOrCompute[string](&c.ObjectLifecyclePolicyEtag, func() (string, error) { + return c.objectLifecyclePolicyEtag() + }) +} + +func (c *mqlOciObjectStorageBucket) GetFreeformTags() *plugin.TValue[map[string]any] { + return plugin.GetOrCompute[map[string]any](&c.FreeformTags, func() (map[string]any, error) { + return c.freeformTags() + }) +} + +func (c *mqlOciObjectStorageBucket) GetDefinedTags() *plugin.TValue[map[string]any] { + return plugin.GetOrCompute[map[string]any](&c.DefinedTags, func() (map[string]any, error) { + return c.definedTags() + }) +} + +// mqlOciFileStorage for the oci.fileStorage resource +type mqlOciFileStorage struct { + MqlRuntime *plugin.Runtime + __id string + // optional: if you define mqlOciFileStorageInternal it will be used here + FileSystems plugin.TValue[[]any] +} + +// createOciFileStorage creates a new instance of this resource +func createOciFileStorage(runtime *plugin.Runtime, args map[string]*llx.RawData) (plugin.Resource, error) { + res := &mqlOciFileStorage{ + MqlRuntime: runtime, + } + + err := SetAllData(res, args) + if err != nil { + return res, err + } + + if res.__id == "" { + res.__id, err = res.id() + if err != nil { + return nil, err + } + } + + if runtime.HasRecording { + args, err = runtime.ResourceFromRecording("oci.fileStorage", res.__id) + if err != nil || args == nil { + return res, err + } + return res, SetAllData(res, args) + } + + return res, nil +} + +func (c *mqlOciFileStorage) MqlName() string { + return "oci.fileStorage" +} + +func (c *mqlOciFileStorage) MqlID() string { + return c.__id +} + +func (c *mqlOciFileStorage) GetFileSystems() *plugin.TValue[[]any] { + return plugin.GetOrCompute[[]any](&c.FileSystems, func() ([]any, error) { + if c.MqlRuntime.HasRecording { + d, err := c.MqlRuntime.FieldResourceFromRecording("oci.fileStorage", c.__id, "fileSystems") + if err != nil { + return nil, err + } + if d != nil { + return d.Value.([]any), nil + } + } + + return c.fileSystems() + }) +} + +// mqlOciFileStorageFileSystem for the oci.fileStorage.fileSystem resource +type mqlOciFileStorageFileSystem struct { + MqlRuntime *plugin.Runtime + __id string + mqlOciFileStorageFileSystemInternal + Id plugin.TValue[string] + Name plugin.TValue[string] + CompartmentID plugin.TValue[string] + AvailabilityDomain plugin.TValue[string] + State plugin.TValue[string] + KmsKey plugin.TValue[*mqlOciKmsKey] + MeteredBytes plugin.TValue[int64] + Created plugin.TValue[*time.Time] +} + +// createOciFileStorageFileSystem creates a new instance of this resource +func createOciFileStorageFileSystem(runtime *plugin.Runtime, args map[string]*llx.RawData) (plugin.Resource, error) { + res := &mqlOciFileStorageFileSystem{ + MqlRuntime: runtime, + } + + err := SetAllData(res, args) + if err != nil { + return res, err + } + + if res.__id == "" { + res.__id, err = res.id() + if err != nil { + return nil, err + } + } + + if runtime.HasRecording { + args, err = runtime.ResourceFromRecording("oci.fileStorage.fileSystem", res.__id) + if err != nil || args == nil { + return res, err + } + return res, SetAllData(res, args) + } + + return res, nil +} + +func (c *mqlOciFileStorageFileSystem) MqlName() string { + return "oci.fileStorage.fileSystem" +} + +func (c *mqlOciFileStorageFileSystem) MqlID() string { + return c.__id +} + +func (c *mqlOciFileStorageFileSystem) GetId() *plugin.TValue[string] { + return &c.Id +} + +func (c *mqlOciFileStorageFileSystem) GetName() *plugin.TValue[string] { + return &c.Name +} + +func (c *mqlOciFileStorageFileSystem) GetCompartmentID() *plugin.TValue[string] { + return &c.CompartmentID +} + +func (c *mqlOciFileStorageFileSystem) GetAvailabilityDomain() *plugin.TValue[string] { + return &c.AvailabilityDomain +} + +func (c *mqlOciFileStorageFileSystem) GetState() *plugin.TValue[string] { + return &c.State +} + +func (c *mqlOciFileStorageFileSystem) GetKmsKey() *plugin.TValue[*mqlOciKmsKey] { + return plugin.GetOrCompute[*mqlOciKmsKey](&c.KmsKey, func() (*mqlOciKmsKey, error) { + if c.MqlRuntime.HasRecording { + d, err := c.MqlRuntime.FieldResourceFromRecording("oci.fileStorage.fileSystem", c.__id, "kmsKey") + if err != nil { + return nil, err + } + if d != nil { + return d.Value.(*mqlOciKmsKey), nil + } + } + + return c.kmsKey() + }) } -func SetData(resource plugin.Resource, field string, val *llx.RawData) error { - f, ok := setDataFields[resource.MqlName()+"."+field] - if !ok { - return errors.New("[oci] cannot set '" + field + "' in resource '" + resource.MqlName() + "', field not found") +func (c *mqlOciFileStorageFileSystem) GetMeteredBytes() *plugin.TValue[int64] { + return &c.MeteredBytes +} + +func (c *mqlOciFileStorageFileSystem) GetCreated() *plugin.TValue[*time.Time] { + return &c.Created +} + +// mqlOciEvents for the oci.events resource +type mqlOciEvents struct { + MqlRuntime *plugin.Runtime + __id string + // optional: if you define mqlOciEventsInternal it will be used here + Rules plugin.TValue[[]any] +} + +// createOciEvents creates a new instance of this resource +func createOciEvents(runtime *plugin.Runtime, args map[string]*llx.RawData) (plugin.Resource, error) { + res := &mqlOciEvents{ + MqlRuntime: runtime, } - if ok := f(resource, val); !ok { - return errors.New("[oci] cannot set '" + field + "' in resource '" + resource.MqlName() + "', type does not match") + err := SetAllData(res, args) + if err != nil { + return res, err } - return nil + + if res.__id == "" { + res.__id, err = res.id() + if err != nil { + return nil, err + } + } + + if runtime.HasRecording { + args, err = runtime.ResourceFromRecording("oci.events", res.__id) + if err != nil || args == nil { + return res, err + } + return res, SetAllData(res, args) + } + + return res, nil } -func SetAllData(resource plugin.Resource, args map[string]*llx.RawData) error { - var err error - for k, v := range args { - if err = SetData(resource, k, v); err != nil { - return err +func (c *mqlOciEvents) MqlName() string { + return "oci.events" +} + +func (c *mqlOciEvents) MqlID() string { + return c.__id +} + +func (c *mqlOciEvents) GetRules() *plugin.TValue[[]any] { + return plugin.GetOrCompute[[]any](&c.Rules, func() ([]any, error) { + if c.MqlRuntime.HasRecording { + d, err := c.MqlRuntime.FieldResourceFromRecording("oci.events", c.__id, "rules") + if err != nil { + return nil, err + } + if d != nil { + return d.Value.([]any), nil + } + } + + return c.rules() + }) +} + +// mqlOciEventsRule for the oci.events.rule resource +type mqlOciEventsRule struct { + MqlRuntime *plugin.Runtime + __id string + mqlOciEventsRuleInternal + Id plugin.TValue[string] + Name plugin.TValue[string] + Description plugin.TValue[string] + CompartmentID plugin.TValue[string] + Condition plugin.TValue[string] + IsEnabled plugin.TValue[bool] + State plugin.TValue[string] + Actions plugin.TValue[[]any] + Created plugin.TValue[*time.Time] +} + +// createOciEventsRule creates a new instance of this resource +func createOciEventsRule(runtime *plugin.Runtime, args map[string]*llx.RawData) (plugin.Resource, error) { + res := &mqlOciEventsRule{ + MqlRuntime: runtime, + } + + err := SetAllData(res, args) + if err != nil { + return res, err + } + + if res.__id == "" { + res.__id, err = res.id() + if err != nil { + return nil, err } } - return nil + + if runtime.HasRecording { + args, err = runtime.ResourceFromRecording("oci.events.rule", res.__id) + if err != nil || args == nil { + return res, err + } + return res, SetAllData(res, args) + } + + return res, nil } -// mqlOci for the oci resource -type mqlOci struct { +func (c *mqlOciEventsRule) MqlName() string { + return "oci.events.rule" +} + +func (c *mqlOciEventsRule) MqlID() string { + return c.__id +} + +func (c *mqlOciEventsRule) GetId() *plugin.TValue[string] { + return &c.Id +} + +func (c *mqlOciEventsRule) GetName() *plugin.TValue[string] { + return &c.Name +} + +func (c *mqlOciEventsRule) GetDescription() *plugin.TValue[string] { + return &c.Description +} + +func (c *mqlOciEventsRule) GetCompartmentID() *plugin.TValue[string] { + return &c.CompartmentID +} + +func (c *mqlOciEventsRule) GetCondition() *plugin.TValue[string] { + return &c.Condition +} + +func (c *mqlOciEventsRule) GetIsEnabled() *plugin.TValue[bool] { + return &c.IsEnabled +} + +func (c *mqlOciEventsRule) GetState() *plugin.TValue[string] { + return &c.State +} + +func (c *mqlOciEventsRule) GetActions() *plugin.TValue[[]any] { + return plugin.GetOrCompute[[]any](&c.Actions, func() ([]any, error) { + return c.actions() + }) +} + +func (c *mqlOciEventsRule) GetCreated() *plugin.TValue[*time.Time] { + return &c.Created +} + +// mqlOciCloudGuard for the oci.cloudGuard resource +type mqlOciCloudGuard struct { MqlRuntime *plugin.Runtime __id string - // optional: if you define mqlOciInternal it will be used here - Regions plugin.TValue[[]any] - Compartments plugin.TValue[[]any] + mqlOciCloudGuardInternal + Status plugin.TValue[bool] + ReportingRegion plugin.TValue[string] + SelfManageResources plugin.TValue[bool] + Targets plugin.TValue[[]any] + DetectorRecipes plugin.TValue[[]any] } -// createOci creates a new instance of this resource -func createOci(runtime *plugin.Runtime, args map[string]*llx.RawData) (plugin.Resource, error) { - res := &mqlOci{ +// createOciCloudGuard creates a new instance of this resource +func createOciCloudGuard(runtime *plugin.Runtime, args map[string]*llx.RawData) (plugin.Resource, error) { + res := &mqlOciCloudGuard{ MqlRuntime: runtime, } @@ -1325,7 +6552,7 @@ func createOci(runtime *plugin.Runtime, args map[string]*llx.RawData) (plugin.Re } if runtime.HasRecording { - args, err = runtime.ResourceFromRecording("oci", res.__id) + args, err = runtime.ResourceFromRecording("oci.cloudGuard", res.__id) if err != nil || args == nil { return res, err } @@ -1335,18 +6562,36 @@ func createOci(runtime *plugin.Runtime, args map[string]*llx.RawData) (plugin.Re return res, nil } -func (c *mqlOci) MqlName() string { - return "oci" +func (c *mqlOciCloudGuard) MqlName() string { + return "oci.cloudGuard" } -func (c *mqlOci) MqlID() string { +func (c *mqlOciCloudGuard) MqlID() string { return c.__id } -func (c *mqlOci) GetRegions() *plugin.TValue[[]any] { - return plugin.GetOrCompute[[]any](&c.Regions, func() ([]any, error) { +func (c *mqlOciCloudGuard) GetStatus() *plugin.TValue[bool] { + return plugin.GetOrCompute[bool](&c.Status, func() (bool, error) { + return c.status() + }) +} + +func (c *mqlOciCloudGuard) GetReportingRegion() *plugin.TValue[string] { + return plugin.GetOrCompute[string](&c.ReportingRegion, func() (string, error) { + return c.reportingRegion() + }) +} + +func (c *mqlOciCloudGuard) GetSelfManageResources() *plugin.TValue[bool] { + return plugin.GetOrCompute[bool](&c.SelfManageResources, func() (bool, error) { + return c.selfManageResources() + }) +} + +func (c *mqlOciCloudGuard) GetTargets() *plugin.TValue[[]any] { + return plugin.GetOrCompute[[]any](&c.Targets, func() ([]any, error) { if c.MqlRuntime.HasRecording { - d, err := c.MqlRuntime.FieldResourceFromRecording("oci", c.__id, "regions") + d, err := c.MqlRuntime.FieldResourceFromRecording("oci.cloudGuard", c.__id, "targets") if err != nil { return nil, err } @@ -1355,14 +6600,14 @@ func (c *mqlOci) GetRegions() *plugin.TValue[[]any] { } } - return c.regions() + return c.targets() }) } -func (c *mqlOci) GetCompartments() *plugin.TValue[[]any] { - return plugin.GetOrCompute[[]any](&c.Compartments, func() ([]any, error) { +func (c *mqlOciCloudGuard) GetDetectorRecipes() *plugin.TValue[[]any] { + return plugin.GetOrCompute[[]any](&c.DetectorRecipes, func() ([]any, error) { if c.MqlRuntime.HasRecording { - d, err := c.MqlRuntime.FieldResourceFromRecording("oci", c.__id, "compartments") + d, err := c.MqlRuntime.FieldResourceFromRecording("oci.cloudGuard", c.__id, "detectorRecipes") if err != nil { return nil, err } @@ -1371,24 +6616,28 @@ func (c *mqlOci) GetCompartments() *plugin.TValue[[]any] { } } - return c.compartments() + return c.detectorRecipes() }) } -// mqlOciTenancy for the oci.tenancy resource -type mqlOciTenancy struct { +// mqlOciCloudGuardTarget for the oci.cloudGuard.target resource +type mqlOciCloudGuardTarget struct { MqlRuntime *plugin.Runtime __id string - // optional: if you define mqlOciTenancyInternal it will be used here - Id plugin.TValue[string] - Name plugin.TValue[string] - Description plugin.TValue[string] - RetentionPeriod plugin.TValue[*time.Time] + // optional: if you define mqlOciCloudGuardTargetInternal it will be used here + Id plugin.TValue[string] + Name plugin.TValue[string] + CompartmentID plugin.TValue[string] + TargetResourceId plugin.TValue[string] + TargetResourceType plugin.TValue[string] + State plugin.TValue[string] + RecipeCount plugin.TValue[int64] + Created plugin.TValue[*time.Time] } -// createOciTenancy creates a new instance of this resource -func createOciTenancy(runtime *plugin.Runtime, args map[string]*llx.RawData) (plugin.Resource, error) { - res := &mqlOciTenancy{ +// createOciCloudGuardTarget creates a new instance of this resource +func createOciCloudGuardTarget(runtime *plugin.Runtime, args map[string]*llx.RawData) (plugin.Resource, error) { + res := &mqlOciCloudGuardTarget{ MqlRuntime: runtime, } @@ -1405,7 +6654,7 @@ func createOciTenancy(runtime *plugin.Runtime, args map[string]*llx.RawData) (pl } if runtime.HasRecording { - args, err = runtime.ResourceFromRecording("oci.tenancy", res.__id) + args, err = runtime.ResourceFromRecording("oci.cloudGuard.target", res.__id) if err != nil || args == nil { return res, err } @@ -1415,46 +6664,63 @@ func createOciTenancy(runtime *plugin.Runtime, args map[string]*llx.RawData) (pl return res, nil } -func (c *mqlOciTenancy) MqlName() string { - return "oci.tenancy" +func (c *mqlOciCloudGuardTarget) MqlName() string { + return "oci.cloudGuard.target" } -func (c *mqlOciTenancy) MqlID() string { +func (c *mqlOciCloudGuardTarget) MqlID() string { return c.__id } -func (c *mqlOciTenancy) GetId() *plugin.TValue[string] { +func (c *mqlOciCloudGuardTarget) GetId() *plugin.TValue[string] { return &c.Id } -func (c *mqlOciTenancy) GetName() *plugin.TValue[string] { +func (c *mqlOciCloudGuardTarget) GetName() *plugin.TValue[string] { return &c.Name } -func (c *mqlOciTenancy) GetDescription() *plugin.TValue[string] { - return &c.Description +func (c *mqlOciCloudGuardTarget) GetCompartmentID() *plugin.TValue[string] { + return &c.CompartmentID } -func (c *mqlOciTenancy) GetRetentionPeriod() *plugin.TValue[*time.Time] { - return plugin.GetOrCompute[*time.Time](&c.RetentionPeriod, func() (*time.Time, error) { - return c.retentionPeriod() - }) +func (c *mqlOciCloudGuardTarget) GetTargetResourceId() *plugin.TValue[string] { + return &c.TargetResourceId } -// mqlOciRegion for the oci.region resource -type mqlOciRegion struct { +func (c *mqlOciCloudGuardTarget) GetTargetResourceType() *plugin.TValue[string] { + return &c.TargetResourceType +} + +func (c *mqlOciCloudGuardTarget) GetState() *plugin.TValue[string] { + return &c.State +} + +func (c *mqlOciCloudGuardTarget) GetRecipeCount() *plugin.TValue[int64] { + return &c.RecipeCount +} + +func (c *mqlOciCloudGuardTarget) GetCreated() *plugin.TValue[*time.Time] { + return &c.Created +} + +// mqlOciCloudGuardDetectorRecipe for the oci.cloudGuard.detectorRecipe resource +type mqlOciCloudGuardDetectorRecipe struct { MqlRuntime *plugin.Runtime __id string - // optional: if you define mqlOciRegionInternal it will be used here + // optional: if you define mqlOciCloudGuardDetectorRecipeInternal it will be used here Id plugin.TValue[string] Name plugin.TValue[string] - IsHomeRegion plugin.TValue[bool] - Status plugin.TValue[string] + Description plugin.TValue[string] + Owner plugin.TValue[string] + DetectorType plugin.TValue[string] + State plugin.TValue[string] + Created plugin.TValue[*time.Time] } -// createOciRegion creates a new instance of this resource -func createOciRegion(runtime *plugin.Runtime, args map[string]*llx.RawData) (plugin.Resource, error) { - res := &mqlOciRegion{ +// createOciCloudGuardDetectorRecipe creates a new instance of this resource +func createOciCloudGuardDetectorRecipe(runtime *plugin.Runtime, args map[string]*llx.RawData) (plugin.Resource, error) { + res := &mqlOciCloudGuardDetectorRecipe{ MqlRuntime: runtime, } @@ -1471,7 +6737,7 @@ func createOciRegion(runtime *plugin.Runtime, args map[string]*llx.RawData) (plu } if runtime.HasRecording { - args, err = runtime.ResourceFromRecording("oci.region", res.__id) + args, err = runtime.ResourceFromRecording("oci.cloudGuard.detectorRecipe", res.__id) if err != nil || args == nil { return res, err } @@ -1481,45 +6747,120 @@ func createOciRegion(runtime *plugin.Runtime, args map[string]*llx.RawData) (plu return res, nil } -func (c *mqlOciRegion) MqlName() string { - return "oci.region" +func (c *mqlOciCloudGuardDetectorRecipe) MqlName() string { + return "oci.cloudGuard.detectorRecipe" } -func (c *mqlOciRegion) MqlID() string { +func (c *mqlOciCloudGuardDetectorRecipe) MqlID() string { return c.__id } -func (c *mqlOciRegion) GetId() *plugin.TValue[string] { +func (c *mqlOciCloudGuardDetectorRecipe) GetId() *plugin.TValue[string] { return &c.Id } -func (c *mqlOciRegion) GetName() *plugin.TValue[string] { +func (c *mqlOciCloudGuardDetectorRecipe) GetName() *plugin.TValue[string] { return &c.Name } -func (c *mqlOciRegion) GetIsHomeRegion() *plugin.TValue[bool] { - return &c.IsHomeRegion +func (c *mqlOciCloudGuardDetectorRecipe) GetDescription() *plugin.TValue[string] { + return &c.Description +} + +func (c *mqlOciCloudGuardDetectorRecipe) GetOwner() *plugin.TValue[string] { + return &c.Owner +} + +func (c *mqlOciCloudGuardDetectorRecipe) GetDetectorType() *plugin.TValue[string] { + return &c.DetectorType +} + +func (c *mqlOciCloudGuardDetectorRecipe) GetState() *plugin.TValue[string] { + return &c.State +} + +func (c *mqlOciCloudGuardDetectorRecipe) GetCreated() *plugin.TValue[*time.Time] { + return &c.Created +} + +// mqlOciOns for the oci.ons resource +type mqlOciOns struct { + MqlRuntime *plugin.Runtime + __id string + // optional: if you define mqlOciOnsInternal it will be used here + Topics plugin.TValue[[]any] +} + +// createOciOns creates a new instance of this resource +func createOciOns(runtime *plugin.Runtime, args map[string]*llx.RawData) (plugin.Resource, error) { + res := &mqlOciOns{ + MqlRuntime: runtime, + } + + err := SetAllData(res, args) + if err != nil { + return res, err + } + + if res.__id == "" { + res.__id, err = res.id() + if err != nil { + return nil, err + } + } + + if runtime.HasRecording { + args, err = runtime.ResourceFromRecording("oci.ons", res.__id) + if err != nil || args == nil { + return res, err + } + return res, SetAllData(res, args) + } + + return res, nil +} + +func (c *mqlOciOns) MqlName() string { + return "oci.ons" +} + +func (c *mqlOciOns) MqlID() string { + return c.__id } -func (c *mqlOciRegion) GetStatus() *plugin.TValue[string] { - return &c.Status +func (c *mqlOciOns) GetTopics() *plugin.TValue[[]any] { + return plugin.GetOrCompute[[]any](&c.Topics, func() ([]any, error) { + if c.MqlRuntime.HasRecording { + d, err := c.MqlRuntime.FieldResourceFromRecording("oci.ons", c.__id, "topics") + if err != nil { + return nil, err + } + if d != nil { + return d.Value.([]any), nil + } + } + + return c.topics() + }) } -// mqlOciCompartment for the oci.compartment resource -type mqlOciCompartment struct { +// mqlOciOnsTopic for the oci.ons.topic resource +type mqlOciOnsTopic struct { MqlRuntime *plugin.Runtime __id string - // optional: if you define mqlOciCompartmentInternal it will be used here - Id plugin.TValue[string] - Name plugin.TValue[string] - Description plugin.TValue[string] - Created plugin.TValue[*time.Time] - State plugin.TValue[string] + mqlOciOnsTopicInternal + Id plugin.TValue[string] + Name plugin.TValue[string] + Description plugin.TValue[string] + CompartmentID plugin.TValue[string] + State plugin.TValue[string] + Created plugin.TValue[*time.Time] + Subscriptions plugin.TValue[[]any] } -// createOciCompartment creates a new instance of this resource -func createOciCompartment(runtime *plugin.Runtime, args map[string]*llx.RawData) (plugin.Resource, error) { - res := &mqlOciCompartment{ +// createOciOnsTopic creates a new instance of this resource +func createOciOnsTopic(runtime *plugin.Runtime, args map[string]*llx.RawData) (plugin.Resource, error) { + res := &mqlOciOnsTopic{ MqlRuntime: runtime, } @@ -1536,7 +6877,7 @@ func createOciCompartment(runtime *plugin.Runtime, args map[string]*llx.RawData) } if runtime.HasRecording { - args, err = runtime.ResourceFromRecording("oci.compartment", res.__id) + args, err = runtime.ResourceFromRecording("oci.ons.topic", res.__id) if err != nil || args == nil { return res, err } @@ -1546,47 +6887,70 @@ func createOciCompartment(runtime *plugin.Runtime, args map[string]*llx.RawData) return res, nil } -func (c *mqlOciCompartment) MqlName() string { - return "oci.compartment" +func (c *mqlOciOnsTopic) MqlName() string { + return "oci.ons.topic" } -func (c *mqlOciCompartment) MqlID() string { +func (c *mqlOciOnsTopic) MqlID() string { return c.__id } -func (c *mqlOciCompartment) GetId() *plugin.TValue[string] { +func (c *mqlOciOnsTopic) GetId() *plugin.TValue[string] { return &c.Id } -func (c *mqlOciCompartment) GetName() *plugin.TValue[string] { +func (c *mqlOciOnsTopic) GetName() *plugin.TValue[string] { return &c.Name } -func (c *mqlOciCompartment) GetDescription() *plugin.TValue[string] { +func (c *mqlOciOnsTopic) GetDescription() *plugin.TValue[string] { return &c.Description } -func (c *mqlOciCompartment) GetCreated() *plugin.TValue[*time.Time] { - return &c.Created +func (c *mqlOciOnsTopic) GetCompartmentID() *plugin.TValue[string] { + return &c.CompartmentID } -func (c *mqlOciCompartment) GetState() *plugin.TValue[string] { +func (c *mqlOciOnsTopic) GetState() *plugin.TValue[string] { return &c.State } -// mqlOciIdentity for the oci.identity resource -type mqlOciIdentity struct { - MqlRuntime *plugin.Runtime - __id string - // optional: if you define mqlOciIdentityInternal it will be used here - Users plugin.TValue[[]any] - Groups plugin.TValue[[]any] - Policies plugin.TValue[[]any] +func (c *mqlOciOnsTopic) GetCreated() *plugin.TValue[*time.Time] { + return &c.Created } -// createOciIdentity creates a new instance of this resource -func createOciIdentity(runtime *plugin.Runtime, args map[string]*llx.RawData) (plugin.Resource, error) { - res := &mqlOciIdentity{ +func (c *mqlOciOnsTopic) GetSubscriptions() *plugin.TValue[[]any] { + return plugin.GetOrCompute[[]any](&c.Subscriptions, func() ([]any, error) { + if c.MqlRuntime.HasRecording { + d, err := c.MqlRuntime.FieldResourceFromRecording("oci.ons.topic", c.__id, "subscriptions") + if err != nil { + return nil, err + } + if d != nil { + return d.Value.([]any), nil + } + } + + return c.subscriptions() + }) +} + +// mqlOciOnsSubscription for the oci.ons.subscription resource +type mqlOciOnsSubscription struct { + MqlRuntime *plugin.Runtime + __id string + mqlOciOnsSubscriptionInternal + Id plugin.TValue[string] + Topic plugin.TValue[*mqlOciOnsTopic] + Protocol plugin.TValue[string] + Endpoint plugin.TValue[string] + State plugin.TValue[string] + Created plugin.TValue[*time.Time] +} + +// createOciOnsSubscription creates a new instance of this resource +func createOciOnsSubscription(runtime *plugin.Runtime, args map[string]*llx.RawData) (plugin.Resource, error) { + res := &mqlOciOnsSubscription{ MqlRuntime: runtime, } @@ -1603,7 +6967,7 @@ func createOciIdentity(runtime *plugin.Runtime, args map[string]*llx.RawData) (p } if runtime.HasRecording { - args, err = runtime.ResourceFromRecording("oci.identity", res.__id) + args, err = runtime.ResourceFromRecording("oci.ons.subscription", res.__id) if err != nil || args == nil { return res, err } @@ -1613,90 +6977,61 @@ func createOciIdentity(runtime *plugin.Runtime, args map[string]*llx.RawData) (p return res, nil } -func (c *mqlOciIdentity) MqlName() string { - return "oci.identity" +func (c *mqlOciOnsSubscription) MqlName() string { + return "oci.ons.subscription" } -func (c *mqlOciIdentity) MqlID() string { +func (c *mqlOciOnsSubscription) MqlID() string { return c.__id } -func (c *mqlOciIdentity) GetUsers() *plugin.TValue[[]any] { - return plugin.GetOrCompute[[]any](&c.Users, func() ([]any, error) { +func (c *mqlOciOnsSubscription) GetId() *plugin.TValue[string] { + return &c.Id +} + +func (c *mqlOciOnsSubscription) GetTopic() *plugin.TValue[*mqlOciOnsTopic] { + return plugin.GetOrCompute[*mqlOciOnsTopic](&c.Topic, func() (*mqlOciOnsTopic, error) { if c.MqlRuntime.HasRecording { - d, err := c.MqlRuntime.FieldResourceFromRecording("oci.identity", c.__id, "users") + d, err := c.MqlRuntime.FieldResourceFromRecording("oci.ons.subscription", c.__id, "topic") if err != nil { return nil, err } if d != nil { - return d.Value.([]any), nil + return d.Value.(*mqlOciOnsTopic), nil } } - return c.users() + return c.topic() }) } -func (c *mqlOciIdentity) GetGroups() *plugin.TValue[[]any] { - return plugin.GetOrCompute[[]any](&c.Groups, func() ([]any, error) { - if c.MqlRuntime.HasRecording { - d, err := c.MqlRuntime.FieldResourceFromRecording("oci.identity", c.__id, "groups") - if err != nil { - return nil, err - } - if d != nil { - return d.Value.([]any), nil - } - } +func (c *mqlOciOnsSubscription) GetProtocol() *plugin.TValue[string] { + return &c.Protocol +} - return c.groups() - }) +func (c *mqlOciOnsSubscription) GetEndpoint() *plugin.TValue[string] { + return &c.Endpoint } -func (c *mqlOciIdentity) GetPolicies() *plugin.TValue[[]any] { - return plugin.GetOrCompute[[]any](&c.Policies, func() ([]any, error) { - if c.MqlRuntime.HasRecording { - d, err := c.MqlRuntime.FieldResourceFromRecording("oci.identity", c.__id, "policies") - if err != nil { - return nil, err - } - if d != nil { - return d.Value.([]any), nil - } - } +func (c *mqlOciOnsSubscription) GetState() *plugin.TValue[string] { + return &c.State +} - return c.policies() - }) +func (c *mqlOciOnsSubscription) GetCreated() *plugin.TValue[*time.Time] { + return &c.Created } -// mqlOciIdentityUser for the oci.identity.user resource -type mqlOciIdentityUser struct { +// mqlOciAudit for the oci.audit resource +type mqlOciAudit struct { MqlRuntime *plugin.Runtime __id string - // optional: if you define mqlOciIdentityUserInternal it will be used here - Id plugin.TValue[string] - CompartmentID plugin.TValue[string] - Name plugin.TValue[string] - Description plugin.TValue[string] - Created plugin.TValue[*time.Time] - State plugin.TValue[string] - MfaActivated plugin.TValue[bool] - Email plugin.TValue[string] - EmailVerified plugin.TValue[bool] - Capabilities plugin.TValue[map[string]any] - LastLogin plugin.TValue[*time.Time] - PreviousLogin plugin.TValue[*time.Time] - FreeformTags plugin.TValue[map[string]any] - DefinedTags plugin.TValue[map[string]any] - ApiKeys plugin.TValue[[]any] - CustomerSecretKeys plugin.TValue[[]any] - AuthTokens plugin.TValue[[]any] - Groups plugin.TValue[[]any] + // optional: if you define mqlOciAuditInternal it will be used here + RetentionPeriodDays plugin.TValue[int64] } -// createOciIdentityUser creates a new instance of this resource -func createOciIdentityUser(runtime *plugin.Runtime, args map[string]*llx.RawData) (plugin.Resource, error) { - res := &mqlOciIdentityUser{ +// createOciAudit creates a new instance of this resource +func createOciAudit(runtime *plugin.Runtime, args map[string]*llx.RawData) (plugin.Resource, error) { + res := &mqlOciAudit{ MqlRuntime: runtime, } @@ -1713,7 +7048,7 @@ func createOciIdentityUser(runtime *plugin.Runtime, args map[string]*llx.RawData } if runtime.HasRecording { - args, err = runtime.ResourceFromRecording("oci.identity.user", res.__id) + args, err = runtime.ResourceFromRecording("oci.audit", res.__id) if err != nil || args == nil { return res, err } @@ -1723,122 +7058,69 @@ func createOciIdentityUser(runtime *plugin.Runtime, args map[string]*llx.RawData return res, nil } -func (c *mqlOciIdentityUser) MqlName() string { - return "oci.identity.user" +func (c *mqlOciAudit) MqlName() string { + return "oci.audit" } -func (c *mqlOciIdentityUser) MqlID() string { +func (c *mqlOciAudit) MqlID() string { return c.__id } -func (c *mqlOciIdentityUser) GetId() *plugin.TValue[string] { - return &c.Id -} - -func (c *mqlOciIdentityUser) GetCompartmentID() *plugin.TValue[string] { - return &c.CompartmentID -} - -func (c *mqlOciIdentityUser) GetName() *plugin.TValue[string] { - return &c.Name -} - -func (c *mqlOciIdentityUser) GetDescription() *plugin.TValue[string] { - return &c.Description -} - -func (c *mqlOciIdentityUser) GetCreated() *plugin.TValue[*time.Time] { - return &c.Created -} - -func (c *mqlOciIdentityUser) GetState() *plugin.TValue[string] { - return &c.State -} - -func (c *mqlOciIdentityUser) GetMfaActivated() *plugin.TValue[bool] { - return &c.MfaActivated -} - -func (c *mqlOciIdentityUser) GetEmail() *plugin.TValue[string] { - return &c.Email -} - -func (c *mqlOciIdentityUser) GetEmailVerified() *plugin.TValue[bool] { - return &c.EmailVerified -} - -func (c *mqlOciIdentityUser) GetCapabilities() *plugin.TValue[map[string]any] { - return &c.Capabilities -} - -func (c *mqlOciIdentityUser) GetLastLogin() *plugin.TValue[*time.Time] { - return &c.LastLogin +func (c *mqlOciAudit) GetRetentionPeriodDays() *plugin.TValue[int64] { + return plugin.GetOrCompute[int64](&c.RetentionPeriodDays, func() (int64, error) { + return c.retentionPeriodDays() + }) } -func (c *mqlOciIdentityUser) GetPreviousLogin() *plugin.TValue[*time.Time] { - return &c.PreviousLogin +// mqlOciBastion for the oci.bastion resource +type mqlOciBastion struct { + MqlRuntime *plugin.Runtime + __id string + // optional: if you define mqlOciBastionInternal it will be used here + Bastions plugin.TValue[[]any] } -func (c *mqlOciIdentityUser) GetFreeformTags() *plugin.TValue[map[string]any] { - return &c.FreeformTags -} +// createOciBastion creates a new instance of this resource +func createOciBastion(runtime *plugin.Runtime, args map[string]*llx.RawData) (plugin.Resource, error) { + res := &mqlOciBastion{ + MqlRuntime: runtime, + } -func (c *mqlOciIdentityUser) GetDefinedTags() *plugin.TValue[map[string]any] { - return &c.DefinedTags -} + err := SetAllData(res, args) + if err != nil { + return res, err + } -func (c *mqlOciIdentityUser) GetApiKeys() *plugin.TValue[[]any] { - return plugin.GetOrCompute[[]any](&c.ApiKeys, func() ([]any, error) { - if c.MqlRuntime.HasRecording { - d, err := c.MqlRuntime.FieldResourceFromRecording("oci.identity.user", c.__id, "apiKeys") - if err != nil { - return nil, err - } - if d != nil { - return d.Value.([]any), nil - } + if res.__id == "" { + res.__id, err = res.id() + if err != nil { + return nil, err } + } - return c.apiKeys() - }) -} - -func (c *mqlOciIdentityUser) GetCustomerSecretKeys() *plugin.TValue[[]any] { - return plugin.GetOrCompute[[]any](&c.CustomerSecretKeys, func() ([]any, error) { - if c.MqlRuntime.HasRecording { - d, err := c.MqlRuntime.FieldResourceFromRecording("oci.identity.user", c.__id, "customerSecretKeys") - if err != nil { - return nil, err - } - if d != nil { - return d.Value.([]any), nil - } + if runtime.HasRecording { + args, err = runtime.ResourceFromRecording("oci.bastion", res.__id) + if err != nil || args == nil { + return res, err } + return res, SetAllData(res, args) + } - return c.customerSecretKeys() - }) + return res, nil } -func (c *mqlOciIdentityUser) GetAuthTokens() *plugin.TValue[[]any] { - return plugin.GetOrCompute[[]any](&c.AuthTokens, func() ([]any, error) { - if c.MqlRuntime.HasRecording { - d, err := c.MqlRuntime.FieldResourceFromRecording("oci.identity.user", c.__id, "authTokens") - if err != nil { - return nil, err - } - if d != nil { - return d.Value.([]any), nil - } - } +func (c *mqlOciBastion) MqlName() string { + return "oci.bastion" +} - return c.authTokens() - }) +func (c *mqlOciBastion) MqlID() string { + return c.__id } -func (c *mqlOciIdentityUser) GetGroups() *plugin.TValue[[]any] { - return plugin.GetOrCompute[[]any](&c.Groups, func() ([]any, error) { +func (c *mqlOciBastion) GetBastions() *plugin.TValue[[]any] { + return plugin.GetOrCompute[[]any](&c.Bastions, func() ([]any, error) { if c.MqlRuntime.HasRecording { - d, err := c.MqlRuntime.FieldResourceFromRecording("oci.identity.user", c.__id, "groups") + d, err := c.MqlRuntime.FieldResourceFromRecording("oci.bastion", c.__id, "bastions") if err != nil { return nil, err } @@ -1847,25 +7129,30 @@ func (c *mqlOciIdentityUser) GetGroups() *plugin.TValue[[]any] { } } - return c.groups() + return c.bastions() }) } -// mqlOciIdentityApiKey for the oci.identity.apiKey resource -type mqlOciIdentityApiKey struct { - MqlRuntime *plugin.Runtime - __id string - // optional: if you define mqlOciIdentityApiKeyInternal it will be used here - Id plugin.TValue[string] - Value plugin.TValue[string] - Fingerprint plugin.TValue[string] - Created plugin.TValue[*time.Time] - State plugin.TValue[string] -} - -// createOciIdentityApiKey creates a new instance of this resource -func createOciIdentityApiKey(runtime *plugin.Runtime, args map[string]*llx.RawData) (plugin.Resource, error) { - res := &mqlOciIdentityApiKey{ +// mqlOciBastionInstance for the oci.bastion.instance resource +type mqlOciBastionInstance struct { + MqlRuntime *plugin.Runtime + __id string + mqlOciBastionInstanceInternal + Id plugin.TValue[string] + Name plugin.TValue[string] + CompartmentID plugin.TValue[string] + BastionType plugin.TValue[string] + TargetVcn plugin.TValue[*mqlOciNetworkVcn] + TargetSubnet plugin.TValue[*mqlOciNetworkSubnet] + State plugin.TValue[string] + DnsProxyStatus plugin.TValue[string] + Created plugin.TValue[*time.Time] + TimeUpdated plugin.TValue[*time.Time] +} + +// createOciBastionInstance creates a new instance of this resource +func createOciBastionInstance(runtime *plugin.Runtime, args map[string]*llx.RawData) (plugin.Resource, error) { + res := &mqlOciBastionInstance{ MqlRuntime: runtime, } @@ -1882,7 +7169,7 @@ func createOciIdentityApiKey(runtime *plugin.Runtime, args map[string]*llx.RawDa } if runtime.HasRecording { - args, err = runtime.ResourceFromRecording("oci.identity.apiKey", res.__id) + args, err = runtime.ResourceFromRecording("oci.bastion.instance", res.__id) if err != nil || args == nil { return res, err } @@ -1892,48 +7179,89 @@ func createOciIdentityApiKey(runtime *plugin.Runtime, args map[string]*llx.RawDa return res, nil } -func (c *mqlOciIdentityApiKey) MqlName() string { - return "oci.identity.apiKey" +func (c *mqlOciBastionInstance) MqlName() string { + return "oci.bastion.instance" } -func (c *mqlOciIdentityApiKey) MqlID() string { +func (c *mqlOciBastionInstance) MqlID() string { return c.__id } -func (c *mqlOciIdentityApiKey) GetId() *plugin.TValue[string] { +func (c *mqlOciBastionInstance) GetId() *plugin.TValue[string] { return &c.Id } -func (c *mqlOciIdentityApiKey) GetValue() *plugin.TValue[string] { - return &c.Value +func (c *mqlOciBastionInstance) GetName() *plugin.TValue[string] { + return &c.Name } -func (c *mqlOciIdentityApiKey) GetFingerprint() *plugin.TValue[string] { - return &c.Fingerprint +func (c *mqlOciBastionInstance) GetCompartmentID() *plugin.TValue[string] { + return &c.CompartmentID } -func (c *mqlOciIdentityApiKey) GetCreated() *plugin.TValue[*time.Time] { - return &c.Created +func (c *mqlOciBastionInstance) GetBastionType() *plugin.TValue[string] { + return &c.BastionType } -func (c *mqlOciIdentityApiKey) GetState() *plugin.TValue[string] { +func (c *mqlOciBastionInstance) GetTargetVcn() *plugin.TValue[*mqlOciNetworkVcn] { + return plugin.GetOrCompute[*mqlOciNetworkVcn](&c.TargetVcn, func() (*mqlOciNetworkVcn, error) { + if c.MqlRuntime.HasRecording { + d, err := c.MqlRuntime.FieldResourceFromRecording("oci.bastion.instance", c.__id, "targetVcn") + if err != nil { + return nil, err + } + if d != nil { + return d.Value.(*mqlOciNetworkVcn), nil + } + } + + return c.targetVcn() + }) +} + +func (c *mqlOciBastionInstance) GetTargetSubnet() *plugin.TValue[*mqlOciNetworkSubnet] { + return plugin.GetOrCompute[*mqlOciNetworkSubnet](&c.TargetSubnet, func() (*mqlOciNetworkSubnet, error) { + if c.MqlRuntime.HasRecording { + d, err := c.MqlRuntime.FieldResourceFromRecording("oci.bastion.instance", c.__id, "targetSubnet") + if err != nil { + return nil, err + } + if d != nil { + return d.Value.(*mqlOciNetworkSubnet), nil + } + } + + return c.targetSubnet() + }) +} + +func (c *mqlOciBastionInstance) GetState() *plugin.TValue[string] { return &c.State } -// mqlOciIdentityCustomerSecretKey for the oci.identity.customerSecretKey resource -type mqlOciIdentityCustomerSecretKey struct { +func (c *mqlOciBastionInstance) GetDnsProxyStatus() *plugin.TValue[string] { + return &c.DnsProxyStatus +} + +func (c *mqlOciBastionInstance) GetCreated() *plugin.TValue[*time.Time] { + return &c.Created +} + +func (c *mqlOciBastionInstance) GetTimeUpdated() *plugin.TValue[*time.Time] { + return &c.TimeUpdated +} + +// mqlOciMonitoring for the oci.monitoring resource +type mqlOciMonitoring struct { MqlRuntime *plugin.Runtime __id string - // optional: if you define mqlOciIdentityCustomerSecretKeyInternal it will be used here - Id plugin.TValue[string] - Name plugin.TValue[string] - Created plugin.TValue[*time.Time] - State plugin.TValue[string] + // optional: if you define mqlOciMonitoringInternal it will be used here + Alarms plugin.TValue[[]any] } -// createOciIdentityCustomerSecretKey creates a new instance of this resource -func createOciIdentityCustomerSecretKey(runtime *plugin.Runtime, args map[string]*llx.RawData) (plugin.Resource, error) { - res := &mqlOciIdentityCustomerSecretKey{ +// createOciMonitoring creates a new instance of this resource +func createOciMonitoring(runtime *plugin.Runtime, args map[string]*llx.RawData) (plugin.Resource, error) { + res := &mqlOciMonitoring{ MqlRuntime: runtime, } @@ -1950,7 +7278,7 @@ func createOciIdentityCustomerSecretKey(runtime *plugin.Runtime, args map[string } if runtime.HasRecording { - args, err = runtime.ResourceFromRecording("oci.identity.customerSecretKey", res.__id) + args, err = runtime.ResourceFromRecording("oci.monitoring", res.__id) if err != nil || args == nil { return res, err } @@ -1960,45 +7288,50 @@ func createOciIdentityCustomerSecretKey(runtime *plugin.Runtime, args map[string return res, nil } -func (c *mqlOciIdentityCustomerSecretKey) MqlName() string { - return "oci.identity.customerSecretKey" +func (c *mqlOciMonitoring) MqlName() string { + return "oci.monitoring" } -func (c *mqlOciIdentityCustomerSecretKey) MqlID() string { +func (c *mqlOciMonitoring) MqlID() string { return c.__id } -func (c *mqlOciIdentityCustomerSecretKey) GetId() *plugin.TValue[string] { - return &c.Id -} - -func (c *mqlOciIdentityCustomerSecretKey) GetName() *plugin.TValue[string] { - return &c.Name -} - -func (c *mqlOciIdentityCustomerSecretKey) GetCreated() *plugin.TValue[*time.Time] { - return &c.Created -} +func (c *mqlOciMonitoring) GetAlarms() *plugin.TValue[[]any] { + return plugin.GetOrCompute[[]any](&c.Alarms, func() ([]any, error) { + if c.MqlRuntime.HasRecording { + d, err := c.MqlRuntime.FieldResourceFromRecording("oci.monitoring", c.__id, "alarms") + if err != nil { + return nil, err + } + if d != nil { + return d.Value.([]any), nil + } + } -func (c *mqlOciIdentityCustomerSecretKey) GetState() *plugin.TValue[string] { - return &c.State + return c.alarms() + }) } -// mqlOciIdentityAuthToken for the oci.identity.authToken resource -type mqlOciIdentityAuthToken struct { +// mqlOciMonitoringAlarm for the oci.monitoring.alarm resource +type mqlOciMonitoringAlarm struct { MqlRuntime *plugin.Runtime __id string - // optional: if you define mqlOciIdentityAuthTokenInternal it will be used here - Id plugin.TValue[string] - Description plugin.TValue[string] - Created plugin.TValue[*time.Time] - Expires plugin.TValue[*time.Time] - State plugin.TValue[string] + // optional: if you define mqlOciMonitoringAlarmInternal it will be used here + Id plugin.TValue[string] + Name plugin.TValue[string] + CompartmentID plugin.TValue[string] + MetricCompartmentId plugin.TValue[string] + Namespace plugin.TValue[string] + Query plugin.TValue[string] + Severity plugin.TValue[string] + Destinations plugin.TValue[[]any] + IsEnabled plugin.TValue[bool] + State plugin.TValue[string] } -// createOciIdentityAuthToken creates a new instance of this resource -func createOciIdentityAuthToken(runtime *plugin.Runtime, args map[string]*llx.RawData) (plugin.Resource, error) { - res := &mqlOciIdentityAuthToken{ +// createOciMonitoringAlarm creates a new instance of this resource +func createOciMonitoringAlarm(runtime *plugin.Runtime, args map[string]*llx.RawData) (plugin.Resource, error) { + res := &mqlOciMonitoringAlarm{ MqlRuntime: runtime, } @@ -2015,7 +7348,7 @@ func createOciIdentityAuthToken(runtime *plugin.Runtime, args map[string]*llx.Ra } if runtime.HasRecording { - args, err = runtime.ResourceFromRecording("oci.identity.authToken", res.__id) + args, err = runtime.ResourceFromRecording("oci.monitoring.alarm", res.__id) if err != nil || args == nil { return res, err } @@ -2025,52 +7358,65 @@ func createOciIdentityAuthToken(runtime *plugin.Runtime, args map[string]*llx.Ra return res, nil } -func (c *mqlOciIdentityAuthToken) MqlName() string { - return "oci.identity.authToken" +func (c *mqlOciMonitoringAlarm) MqlName() string { + return "oci.monitoring.alarm" } -func (c *mqlOciIdentityAuthToken) MqlID() string { +func (c *mqlOciMonitoringAlarm) MqlID() string { return c.__id } -func (c *mqlOciIdentityAuthToken) GetId() *plugin.TValue[string] { +func (c *mqlOciMonitoringAlarm) GetId() *plugin.TValue[string] { return &c.Id } -func (c *mqlOciIdentityAuthToken) GetDescription() *plugin.TValue[string] { - return &c.Description +func (c *mqlOciMonitoringAlarm) GetName() *plugin.TValue[string] { + return &c.Name } -func (c *mqlOciIdentityAuthToken) GetCreated() *plugin.TValue[*time.Time] { - return &c.Created +func (c *mqlOciMonitoringAlarm) GetCompartmentID() *plugin.TValue[string] { + return &c.CompartmentID } -func (c *mqlOciIdentityAuthToken) GetExpires() *plugin.TValue[*time.Time] { - return &c.Expires +func (c *mqlOciMonitoringAlarm) GetMetricCompartmentId() *plugin.TValue[string] { + return &c.MetricCompartmentId } -func (c *mqlOciIdentityAuthToken) GetState() *plugin.TValue[string] { +func (c *mqlOciMonitoringAlarm) GetNamespace() *plugin.TValue[string] { + return &c.Namespace +} + +func (c *mqlOciMonitoringAlarm) GetQuery() *plugin.TValue[string] { + return &c.Query +} + +func (c *mqlOciMonitoringAlarm) GetSeverity() *plugin.TValue[string] { + return &c.Severity +} + +func (c *mqlOciMonitoringAlarm) GetDestinations() *plugin.TValue[[]any] { + return &c.Destinations +} + +func (c *mqlOciMonitoringAlarm) GetIsEnabled() *plugin.TValue[bool] { + return &c.IsEnabled +} + +func (c *mqlOciMonitoringAlarm) GetState() *plugin.TValue[string] { return &c.State } -// mqlOciIdentityGroup for the oci.identity.group resource -type mqlOciIdentityGroup struct { +// mqlOciVault for the oci.vault resource +type mqlOciVault struct { MqlRuntime *plugin.Runtime __id string - // optional: if you define mqlOciIdentityGroupInternal it will be used here - Id plugin.TValue[string] - CompartmentID plugin.TValue[string] - Name plugin.TValue[string] - Description plugin.TValue[string] - Created plugin.TValue[*time.Time] - State plugin.TValue[string] - FreeformTags plugin.TValue[map[string]any] - DefinedTags plugin.TValue[map[string]any] + // optional: if you define mqlOciVaultInternal it will be used here + Secrets plugin.TValue[[]any] } -// createOciIdentityGroup creates a new instance of this resource -func createOciIdentityGroup(runtime *plugin.Runtime, args map[string]*llx.RawData) (plugin.Resource, error) { - res := &mqlOciIdentityGroup{ +// createOciVault creates a new instance of this resource +func createOciVault(runtime *plugin.Runtime, args map[string]*llx.RawData) (plugin.Resource, error) { + res := &mqlOciVault{ MqlRuntime: runtime, } @@ -2087,7 +7433,7 @@ func createOciIdentityGroup(runtime *plugin.Runtime, args map[string]*llx.RawDat } if runtime.HasRecording { - args, err = runtime.ResourceFromRecording("oci.identity.group", res.__id) + args, err = runtime.ResourceFromRecording("oci.vault", res.__id) if err != nil || args == nil { return res, err } @@ -2097,66 +7443,52 @@ func createOciIdentityGroup(runtime *plugin.Runtime, args map[string]*llx.RawDat return res, nil } -func (c *mqlOciIdentityGroup) MqlName() string { - return "oci.identity.group" +func (c *mqlOciVault) MqlName() string { + return "oci.vault" } -func (c *mqlOciIdentityGroup) MqlID() string { +func (c *mqlOciVault) MqlID() string { return c.__id } -func (c *mqlOciIdentityGroup) GetId() *plugin.TValue[string] { - return &c.Id -} - -func (c *mqlOciIdentityGroup) GetCompartmentID() *plugin.TValue[string] { - return &c.CompartmentID -} - -func (c *mqlOciIdentityGroup) GetName() *plugin.TValue[string] { - return &c.Name -} - -func (c *mqlOciIdentityGroup) GetDescription() *plugin.TValue[string] { - return &c.Description -} - -func (c *mqlOciIdentityGroup) GetCreated() *plugin.TValue[*time.Time] { - return &c.Created -} - -func (c *mqlOciIdentityGroup) GetState() *plugin.TValue[string] { - return &c.State -} - -func (c *mqlOciIdentityGroup) GetFreeformTags() *plugin.TValue[map[string]any] { - return &c.FreeformTags -} +func (c *mqlOciVault) GetSecrets() *plugin.TValue[[]any] { + return plugin.GetOrCompute[[]any](&c.Secrets, func() ([]any, error) { + if c.MqlRuntime.HasRecording { + d, err := c.MqlRuntime.FieldResourceFromRecording("oci.vault", c.__id, "secrets") + if err != nil { + return nil, err + } + if d != nil { + return d.Value.([]any), nil + } + } -func (c *mqlOciIdentityGroup) GetDefinedTags() *plugin.TValue[map[string]any] { - return &c.DefinedTags + return c.secrets() + }) } -// mqlOciIdentityPolicy for the oci.identity.policy resource -type mqlOciIdentityPolicy struct { +// mqlOciVaultSecret for the oci.vault.secret resource +type mqlOciVaultSecret struct { MqlRuntime *plugin.Runtime __id string - // optional: if you define mqlOciIdentityPolicyInternal it will be used here - Id plugin.TValue[string] - CompartmentID plugin.TValue[string] - Name plugin.TValue[string] - Description plugin.TValue[string] - Created plugin.TValue[*time.Time] - State plugin.TValue[string] - Statements plugin.TValue[[]any] - VersionDate plugin.TValue[*time.Time] - FreeformTags plugin.TValue[map[string]any] - DefinedTags plugin.TValue[map[string]any] -} - -// createOciIdentityPolicy creates a new instance of this resource -func createOciIdentityPolicy(runtime *plugin.Runtime, args map[string]*llx.RawData) (plugin.Resource, error) { - res := &mqlOciIdentityPolicy{ + mqlOciVaultSecretInternal + Id plugin.TValue[string] + Name plugin.TValue[string] + CompartmentID plugin.TValue[string] + KmsVault plugin.TValue[*mqlOciKmsVault] + KmsKey plugin.TValue[*mqlOciKmsKey] + Description plugin.TValue[string] + State plugin.TValue[string] + RotationStatus plugin.TValue[string] + LastRotationTime plugin.TValue[*time.Time] + NextRotationTime plugin.TValue[*time.Time] + IsAutoGenerationEnabled plugin.TValue[bool] + Created plugin.TValue[*time.Time] +} + +// createOciVaultSecret creates a new instance of this resource +func createOciVaultSecret(runtime *plugin.Runtime, args map[string]*llx.RawData) (plugin.Resource, error) { + res := &mqlOciVaultSecret{ MqlRuntime: runtime, } @@ -2173,7 +7505,7 @@ func createOciIdentityPolicy(runtime *plugin.Runtime, args map[string]*llx.RawDa } if runtime.HasRecording { - args, err = runtime.ResourceFromRecording("oci.identity.policy", res.__id) + args, err = runtime.ResourceFromRecording("oci.vault.secret", res.__id) if err != nil || args == nil { return res, err } @@ -2183,66 +7515,167 @@ func createOciIdentityPolicy(runtime *plugin.Runtime, args map[string]*llx.RawDa return res, nil } -func (c *mqlOciIdentityPolicy) MqlName() string { - return "oci.identity.policy" +func (c *mqlOciVaultSecret) MqlName() string { + return "oci.vault.secret" } -func (c *mqlOciIdentityPolicy) MqlID() string { +func (c *mqlOciVaultSecret) MqlID() string { return c.__id } -func (c *mqlOciIdentityPolicy) GetId() *plugin.TValue[string] { +func (c *mqlOciVaultSecret) GetId() *plugin.TValue[string] { return &c.Id } -func (c *mqlOciIdentityPolicy) GetCompartmentID() *plugin.TValue[string] { +func (c *mqlOciVaultSecret) GetName() *plugin.TValue[string] { + return &c.Name +} + +func (c *mqlOciVaultSecret) GetCompartmentID() *plugin.TValue[string] { return &c.CompartmentID } -func (c *mqlOciIdentityPolicy) GetName() *plugin.TValue[string] { - return &c.Name +func (c *mqlOciVaultSecret) GetKmsVault() *plugin.TValue[*mqlOciKmsVault] { + return plugin.GetOrCompute[*mqlOciKmsVault](&c.KmsVault, func() (*mqlOciKmsVault, error) { + if c.MqlRuntime.HasRecording { + d, err := c.MqlRuntime.FieldResourceFromRecording("oci.vault.secret", c.__id, "kmsVault") + if err != nil { + return nil, err + } + if d != nil { + return d.Value.(*mqlOciKmsVault), nil + } + } + + return c.kmsVault() + }) } -func (c *mqlOciIdentityPolicy) GetDescription() *plugin.TValue[string] { +func (c *mqlOciVaultSecret) GetKmsKey() *plugin.TValue[*mqlOciKmsKey] { + return plugin.GetOrCompute[*mqlOciKmsKey](&c.KmsKey, func() (*mqlOciKmsKey, error) { + if c.MqlRuntime.HasRecording { + d, err := c.MqlRuntime.FieldResourceFromRecording("oci.vault.secret", c.__id, "kmsKey") + if err != nil { + return nil, err + } + if d != nil { + return d.Value.(*mqlOciKmsKey), nil + } + } + + return c.kmsKey() + }) +} + +func (c *mqlOciVaultSecret) GetDescription() *plugin.TValue[string] { return &c.Description } -func (c *mqlOciIdentityPolicy) GetCreated() *plugin.TValue[*time.Time] { - return &c.Created -} +func (c *mqlOciVaultSecret) GetState() *plugin.TValue[string] { + return &c.State +} + +func (c *mqlOciVaultSecret) GetRotationStatus() *plugin.TValue[string] { + return &c.RotationStatus +} + +func (c *mqlOciVaultSecret) GetLastRotationTime() *plugin.TValue[*time.Time] { + return &c.LastRotationTime +} + +func (c *mqlOciVaultSecret) GetNextRotationTime() *plugin.TValue[*time.Time] { + return &c.NextRotationTime +} + +func (c *mqlOciVaultSecret) GetIsAutoGenerationEnabled() *plugin.TValue[bool] { + return &c.IsAutoGenerationEnabled +} + +func (c *mqlOciVaultSecret) GetCreated() *plugin.TValue[*time.Time] { + return &c.Created +} + +// mqlOciLoadBalancer for the oci.loadBalancer resource +type mqlOciLoadBalancer struct { + MqlRuntime *plugin.Runtime + __id string + // optional: if you define mqlOciLoadBalancerInternal it will be used here + LoadBalancers plugin.TValue[[]any] +} + +// createOciLoadBalancer creates a new instance of this resource +func createOciLoadBalancer(runtime *plugin.Runtime, args map[string]*llx.RawData) (plugin.Resource, error) { + res := &mqlOciLoadBalancer{ + MqlRuntime: runtime, + } + + err := SetAllData(res, args) + if err != nil { + return res, err + } + + if res.__id == "" { + res.__id, err = res.id() + if err != nil { + return nil, err + } + } -func (c *mqlOciIdentityPolicy) GetState() *plugin.TValue[string] { - return &c.State -} + if runtime.HasRecording { + args, err = runtime.ResourceFromRecording("oci.loadBalancer", res.__id) + if err != nil || args == nil { + return res, err + } + return res, SetAllData(res, args) + } -func (c *mqlOciIdentityPolicy) GetStatements() *plugin.TValue[[]any] { - return &c.Statements + return res, nil } -func (c *mqlOciIdentityPolicy) GetVersionDate() *plugin.TValue[*time.Time] { - return &c.VersionDate +func (c *mqlOciLoadBalancer) MqlName() string { + return "oci.loadBalancer" } -func (c *mqlOciIdentityPolicy) GetFreeformTags() *plugin.TValue[map[string]any] { - return &c.FreeformTags +func (c *mqlOciLoadBalancer) MqlID() string { + return c.__id } -func (c *mqlOciIdentityPolicy) GetDefinedTags() *plugin.TValue[map[string]any] { - return &c.DefinedTags +func (c *mqlOciLoadBalancer) GetLoadBalancers() *plugin.TValue[[]any] { + return plugin.GetOrCompute[[]any](&c.LoadBalancers, func() ([]any, error) { + if c.MqlRuntime.HasRecording { + d, err := c.MqlRuntime.FieldResourceFromRecording("oci.loadBalancer", c.__id, "loadBalancers") + if err != nil { + return nil, err + } + if d != nil { + return d.Value.([]any), nil + } + } + + return c.loadBalancers() + }) } -// mqlOciCompute for the oci.compute resource -type mqlOciCompute struct { +// mqlOciLoadBalancerLoadBalancer for the oci.loadBalancer.loadBalancer resource +type mqlOciLoadBalancerLoadBalancer struct { MqlRuntime *plugin.Runtime __id string - // optional: if you define mqlOciComputeInternal it will be used here - Instances plugin.TValue[[]any] - Images plugin.TValue[[]any] -} - -// createOciCompute creates a new instance of this resource -func createOciCompute(runtime *plugin.Runtime, args map[string]*llx.RawData) (plugin.Resource, error) { - res := &mqlOciCompute{ + mqlOciLoadBalancerLoadBalancerInternal + Id plugin.TValue[string] + Name plugin.TValue[string] + CompartmentID plugin.TValue[string] + Shape plugin.TValue[string] + IsPrivate plugin.TValue[bool] + IsDeleteProtectionEnabled plugin.TValue[bool] + State plugin.TValue[string] + Listeners plugin.TValue[[]any] + BackendSets plugin.TValue[[]any] + Created plugin.TValue[*time.Time] +} + +// createOciLoadBalancerLoadBalancer creates a new instance of this resource +func createOciLoadBalancerLoadBalancer(runtime *plugin.Runtime, args map[string]*llx.RawData) (plugin.Resource, error) { + res := &mqlOciLoadBalancerLoadBalancer{ MqlRuntime: runtime, } @@ -2259,7 +7692,7 @@ func createOciCompute(runtime *plugin.Runtime, args map[string]*llx.RawData) (pl } if runtime.HasRecording { - args, err = runtime.ResourceFromRecording("oci.compute", res.__id) + args, err = runtime.ResourceFromRecording("oci.loadBalancer.loadBalancer", res.__id) if err != nil || args == nil { return res, err } @@ -2269,18 +7702,46 @@ func createOciCompute(runtime *plugin.Runtime, args map[string]*llx.RawData) (pl return res, nil } -func (c *mqlOciCompute) MqlName() string { - return "oci.compute" +func (c *mqlOciLoadBalancerLoadBalancer) MqlName() string { + return "oci.loadBalancer.loadBalancer" } -func (c *mqlOciCompute) MqlID() string { +func (c *mqlOciLoadBalancerLoadBalancer) MqlID() string { return c.__id } -func (c *mqlOciCompute) GetInstances() *plugin.TValue[[]any] { - return plugin.GetOrCompute[[]any](&c.Instances, func() ([]any, error) { +func (c *mqlOciLoadBalancerLoadBalancer) GetId() *plugin.TValue[string] { + return &c.Id +} + +func (c *mqlOciLoadBalancerLoadBalancer) GetName() *plugin.TValue[string] { + return &c.Name +} + +func (c *mqlOciLoadBalancerLoadBalancer) GetCompartmentID() *plugin.TValue[string] { + return &c.CompartmentID +} + +func (c *mqlOciLoadBalancerLoadBalancer) GetShape() *plugin.TValue[string] { + return &c.Shape +} + +func (c *mqlOciLoadBalancerLoadBalancer) GetIsPrivate() *plugin.TValue[bool] { + return &c.IsPrivate +} + +func (c *mqlOciLoadBalancerLoadBalancer) GetIsDeleteProtectionEnabled() *plugin.TValue[bool] { + return &c.IsDeleteProtectionEnabled +} + +func (c *mqlOciLoadBalancerLoadBalancer) GetState() *plugin.TValue[string] { + return &c.State +} + +func (c *mqlOciLoadBalancerLoadBalancer) GetListeners() *plugin.TValue[[]any] { + return plugin.GetOrCompute[[]any](&c.Listeners, func() ([]any, error) { if c.MqlRuntime.HasRecording { - d, err := c.MqlRuntime.FieldResourceFromRecording("oci.compute", c.__id, "instances") + d, err := c.MqlRuntime.FieldResourceFromRecording("oci.loadBalancer.loadBalancer", c.__id, "listeners") if err != nil { return nil, err } @@ -2289,14 +7750,14 @@ func (c *mqlOciCompute) GetInstances() *plugin.TValue[[]any] { } } - return c.instances() + return c.listeners() }) } -func (c *mqlOciCompute) GetImages() *plugin.TValue[[]any] { - return plugin.GetOrCompute[[]any](&c.Images, func() ([]any, error) { +func (c *mqlOciLoadBalancerLoadBalancer) GetBackendSets() *plugin.TValue[[]any] { + return plugin.GetOrCompute[[]any](&c.BackendSets, func() ([]any, error) { if c.MqlRuntime.HasRecording { - d, err := c.MqlRuntime.FieldResourceFromRecording("oci.compute", c.__id, "images") + d, err := c.MqlRuntime.FieldResourceFromRecording("oci.loadBalancer.loadBalancer", c.__id, "backendSets") if err != nil { return nil, err } @@ -2305,33 +7766,32 @@ func (c *mqlOciCompute) GetImages() *plugin.TValue[[]any] { } } - return c.images() + return c.backendSets() }) } -// mqlOciComputeInstance for the oci.compute.instance resource -type mqlOciComputeInstance struct { - MqlRuntime *plugin.Runtime - __id string - // optional: if you define mqlOciComputeInstanceInternal it will be used here - Id plugin.TValue[string] - Name plugin.TValue[string] - Region plugin.TValue[*mqlOciRegion] - Created plugin.TValue[*time.Time] - State plugin.TValue[string] - Shape plugin.TValue[string] - AvailabilityDomain plugin.TValue[string] - Compartment plugin.TValue[*mqlOciCompartment] - FaultDomain plugin.TValue[string] - ImageId plugin.TValue[string] - DedicatedVmHostId plugin.TValue[string] - FreeformTags plugin.TValue[map[string]any] - DefinedTags plugin.TValue[map[string]any] +func (c *mqlOciLoadBalancerLoadBalancer) GetCreated() *plugin.TValue[*time.Time] { + return &c.Created } -// createOciComputeInstance creates a new instance of this resource -func createOciComputeInstance(runtime *plugin.Runtime, args map[string]*llx.RawData) (plugin.Resource, error) { - res := &mqlOciComputeInstance{ +// mqlOciLoadBalancerListener for the oci.loadBalancer.listener resource +type mqlOciLoadBalancerListener struct { + MqlRuntime *plugin.Runtime + __id string + // optional: if you define mqlOciLoadBalancerListenerInternal it will be used here + Id plugin.TValue[string] + Name plugin.TValue[string] + Port plugin.TValue[int64] + Protocol plugin.TValue[string] + DefaultBackendSetName plugin.TValue[string] + SslProtocols plugin.TValue[[]any] + SslCipherSuiteName plugin.TValue[string] + SslVerifyPeerCertificate plugin.TValue[bool] +} + +// createOciLoadBalancerListener creates a new instance of this resource +func createOciLoadBalancerListener(runtime *plugin.Runtime, args map[string]*llx.RawData) (plugin.Resource, error) { + res := &mqlOciLoadBalancerListener{ MqlRuntime: runtime, } @@ -2348,7 +7808,7 @@ func createOciComputeInstance(runtime *plugin.Runtime, args map[string]*llx.RawD } if runtime.HasRecording { - args, err = runtime.ResourceFromRecording("oci.compute.instance", res.__id) + args, err = runtime.ResourceFromRecording("oci.loadBalancer.listener", res.__id) if err != nil || args == nil { return res, err } @@ -2358,87 +7818,61 @@ func createOciComputeInstance(runtime *plugin.Runtime, args map[string]*llx.RawD return res, nil } -func (c *mqlOciComputeInstance) MqlName() string { - return "oci.compute.instance" +func (c *mqlOciLoadBalancerListener) MqlName() string { + return "oci.loadBalancer.listener" } -func (c *mqlOciComputeInstance) MqlID() string { +func (c *mqlOciLoadBalancerListener) MqlID() string { return c.__id } -func (c *mqlOciComputeInstance) GetId() *plugin.TValue[string] { +func (c *mqlOciLoadBalancerListener) GetId() *plugin.TValue[string] { return &c.Id } -func (c *mqlOciComputeInstance) GetName() *plugin.TValue[string] { +func (c *mqlOciLoadBalancerListener) GetName() *plugin.TValue[string] { return &c.Name } -func (c *mqlOciComputeInstance) GetRegion() *plugin.TValue[*mqlOciRegion] { - return &c.Region -} - -func (c *mqlOciComputeInstance) GetCreated() *plugin.TValue[*time.Time] { - return &c.Created -} - -func (c *mqlOciComputeInstance) GetState() *plugin.TValue[string] { - return &c.State -} - -func (c *mqlOciComputeInstance) GetShape() *plugin.TValue[string] { - return &c.Shape -} - -func (c *mqlOciComputeInstance) GetAvailabilityDomain() *plugin.TValue[string] { - return &c.AvailabilityDomain -} - -func (c *mqlOciComputeInstance) GetCompartment() *plugin.TValue[*mqlOciCompartment] { - return &c.Compartment +func (c *mqlOciLoadBalancerListener) GetPort() *plugin.TValue[int64] { + return &c.Port } -func (c *mqlOciComputeInstance) GetFaultDomain() *plugin.TValue[string] { - return &c.FaultDomain +func (c *mqlOciLoadBalancerListener) GetProtocol() *plugin.TValue[string] { + return &c.Protocol } -func (c *mqlOciComputeInstance) GetImageId() *plugin.TValue[string] { - return &c.ImageId +func (c *mqlOciLoadBalancerListener) GetDefaultBackendSetName() *plugin.TValue[string] { + return &c.DefaultBackendSetName } -func (c *mqlOciComputeInstance) GetDedicatedVmHostId() *plugin.TValue[string] { - return &c.DedicatedVmHostId +func (c *mqlOciLoadBalancerListener) GetSslProtocols() *plugin.TValue[[]any] { + return &c.SslProtocols } -func (c *mqlOciComputeInstance) GetFreeformTags() *plugin.TValue[map[string]any] { - return &c.FreeformTags +func (c *mqlOciLoadBalancerListener) GetSslCipherSuiteName() *plugin.TValue[string] { + return &c.SslCipherSuiteName } -func (c *mqlOciComputeInstance) GetDefinedTags() *plugin.TValue[map[string]any] { - return &c.DefinedTags +func (c *mqlOciLoadBalancerListener) GetSslVerifyPeerCertificate() *plugin.TValue[bool] { + return &c.SslVerifyPeerCertificate } -// mqlOciComputeImage for the oci.compute.image resource -type mqlOciComputeImage struct { +// mqlOciLoadBalancerBackendSet for the oci.loadBalancer.backendSet resource +type mqlOciLoadBalancerBackendSet struct { MqlRuntime *plugin.Runtime __id string - // optional: if you define mqlOciComputeImageInternal it will be used here - Id plugin.TValue[string] - Name plugin.TValue[string] - Region plugin.TValue[*mqlOciRegion] - Created plugin.TValue[*time.Time] - State plugin.TValue[string] - Compartment plugin.TValue[*mqlOciCompartment] - OperatingSystem plugin.TValue[string] - OperatingSystemVersion plugin.TValue[string] - SizeInMBs plugin.TValue[int64] - FreeformTags plugin.TValue[map[string]any] - DefinedTags plugin.TValue[map[string]any] + // optional: if you define mqlOciLoadBalancerBackendSetInternal it will be used here + Id plugin.TValue[string] + Name plugin.TValue[string] + Policy plugin.TValue[string] + HealthChecker plugin.TValue[any] + BackendCount plugin.TValue[int64] } -// createOciComputeImage creates a new instance of this resource -func createOciComputeImage(runtime *plugin.Runtime, args map[string]*llx.RawData) (plugin.Resource, error) { - res := &mqlOciComputeImage{ +// createOciLoadBalancerBackendSet creates a new instance of this resource +func createOciLoadBalancerBackendSet(runtime *plugin.Runtime, args map[string]*llx.RawData) (plugin.Resource, error) { + res := &mqlOciLoadBalancerBackendSet{ MqlRuntime: runtime, } @@ -2455,7 +7889,7 @@ func createOciComputeImage(runtime *plugin.Runtime, args map[string]*llx.RawData } if runtime.HasRecording { - args, err = runtime.ResourceFromRecording("oci.compute.image", res.__id) + args, err = runtime.ResourceFromRecording("oci.loadBalancer.backendSet", res.__id) if err != nil || args == nil { return res, err } @@ -2465,70 +7899,46 @@ func createOciComputeImage(runtime *plugin.Runtime, args map[string]*llx.RawData return res, nil } -func (c *mqlOciComputeImage) MqlName() string { - return "oci.compute.image" +func (c *mqlOciLoadBalancerBackendSet) MqlName() string { + return "oci.loadBalancer.backendSet" } -func (c *mqlOciComputeImage) MqlID() string { +func (c *mqlOciLoadBalancerBackendSet) MqlID() string { return c.__id } -func (c *mqlOciComputeImage) GetId() *plugin.TValue[string] { +func (c *mqlOciLoadBalancerBackendSet) GetId() *plugin.TValue[string] { return &c.Id } -func (c *mqlOciComputeImage) GetName() *plugin.TValue[string] { +func (c *mqlOciLoadBalancerBackendSet) GetName() *plugin.TValue[string] { return &c.Name } -func (c *mqlOciComputeImage) GetRegion() *plugin.TValue[*mqlOciRegion] { - return &c.Region -} - -func (c *mqlOciComputeImage) GetCreated() *plugin.TValue[*time.Time] { - return &c.Created -} - -func (c *mqlOciComputeImage) GetState() *plugin.TValue[string] { - return &c.State -} - -func (c *mqlOciComputeImage) GetCompartment() *plugin.TValue[*mqlOciCompartment] { - return &c.Compartment -} - -func (c *mqlOciComputeImage) GetOperatingSystem() *plugin.TValue[string] { - return &c.OperatingSystem -} - -func (c *mqlOciComputeImage) GetOperatingSystemVersion() *plugin.TValue[string] { - return &c.OperatingSystemVersion -} - -func (c *mqlOciComputeImage) GetSizeInMBs() *plugin.TValue[int64] { - return &c.SizeInMBs +func (c *mqlOciLoadBalancerBackendSet) GetPolicy() *plugin.TValue[string] { + return &c.Policy } -func (c *mqlOciComputeImage) GetFreeformTags() *plugin.TValue[map[string]any] { - return &c.FreeformTags +func (c *mqlOciLoadBalancerBackendSet) GetHealthChecker() *plugin.TValue[any] { + return &c.HealthChecker } -func (c *mqlOciComputeImage) GetDefinedTags() *plugin.TValue[map[string]any] { - return &c.DefinedTags +func (c *mqlOciLoadBalancerBackendSet) GetBackendCount() *plugin.TValue[int64] { + return &c.BackendCount } -// mqlOciNetwork for the oci.network resource -type mqlOciNetwork struct { +// mqlOciNetworkFirewall for the oci.networkFirewall resource +type mqlOciNetworkFirewall struct { MqlRuntime *plugin.Runtime __id string - // optional: if you define mqlOciNetworkInternal it will be used here - Vcns plugin.TValue[[]any] - SecurityLists plugin.TValue[[]any] + // optional: if you define mqlOciNetworkFirewallInternal it will be used here + Firewalls plugin.TValue[[]any] + Policies plugin.TValue[[]any] } -// createOciNetwork creates a new instance of this resource -func createOciNetwork(runtime *plugin.Runtime, args map[string]*llx.RawData) (plugin.Resource, error) { - res := &mqlOciNetwork{ +// createOciNetworkFirewall creates a new instance of this resource +func createOciNetworkFirewall(runtime *plugin.Runtime, args map[string]*llx.RawData) (plugin.Resource, error) { + res := &mqlOciNetworkFirewall{ MqlRuntime: runtime, } @@ -2545,7 +7955,7 @@ func createOciNetwork(runtime *plugin.Runtime, args map[string]*llx.RawData) (pl } if runtime.HasRecording { - args, err = runtime.ResourceFromRecording("oci.network", res.__id) + args, err = runtime.ResourceFromRecording("oci.networkFirewall", res.__id) if err != nil || args == nil { return res, err } @@ -2555,18 +7965,18 @@ func createOciNetwork(runtime *plugin.Runtime, args map[string]*llx.RawData) (pl return res, nil } -func (c *mqlOciNetwork) MqlName() string { - return "oci.network" +func (c *mqlOciNetworkFirewall) MqlName() string { + return "oci.networkFirewall" } -func (c *mqlOciNetwork) MqlID() string { +func (c *mqlOciNetworkFirewall) MqlID() string { return c.__id } -func (c *mqlOciNetwork) GetVcns() *plugin.TValue[[]any] { - return plugin.GetOrCompute[[]any](&c.Vcns, func() ([]any, error) { +func (c *mqlOciNetworkFirewall) GetFirewalls() *plugin.TValue[[]any] { + return plugin.GetOrCompute[[]any](&c.Firewalls, func() ([]any, error) { if c.MqlRuntime.HasRecording { - d, err := c.MqlRuntime.FieldResourceFromRecording("oci.network", c.__id, "vcns") + d, err := c.MqlRuntime.FieldResourceFromRecording("oci.networkFirewall", c.__id, "firewalls") if err != nil { return nil, err } @@ -2575,14 +7985,14 @@ func (c *mqlOciNetwork) GetVcns() *plugin.TValue[[]any] { } } - return c.vcns() + return c.firewalls() }) } -func (c *mqlOciNetwork) GetSecurityLists() *plugin.TValue[[]any] { - return plugin.GetOrCompute[[]any](&c.SecurityLists, func() ([]any, error) { +func (c *mqlOciNetworkFirewall) GetPolicies() *plugin.TValue[[]any] { + return plugin.GetOrCompute[[]any](&c.Policies, func() ([]any, error) { if c.MqlRuntime.HasRecording { - d, err := c.MqlRuntime.FieldResourceFromRecording("oci.network", c.__id, "securityLists") + d, err := c.MqlRuntime.FieldResourceFromRecording("oci.networkFirewall", c.__id, "policies") if err != nil { return nil, err } @@ -2591,34 +8001,31 @@ func (c *mqlOciNetwork) GetSecurityLists() *plugin.TValue[[]any] { } } - return c.securityLists() + return c.policies() }) } -// mqlOciNetworkVcn for the oci.network.vcn resource -type mqlOciNetworkVcn struct { +// mqlOciNetworkFirewallFirewall for the oci.networkFirewall.firewall resource +type mqlOciNetworkFirewallFirewall struct { MqlRuntime *plugin.Runtime __id string - // optional: if you define mqlOciNetworkVcnInternal it will be used here - Id plugin.TValue[string] - CompartmentID plugin.TValue[string] - Name plugin.TValue[string] - Created plugin.TValue[*time.Time] - State plugin.TValue[string] - CidrBlock plugin.TValue[string] - CidrBlocks plugin.TValue[[]any] - VcnDomainName plugin.TValue[string] - DefaultDhcpOptionsId plugin.TValue[string] - DefaultRouteTableId plugin.TValue[string] - DefaultSecurityListId plugin.TValue[string] - DnsLabel plugin.TValue[string] - FreeformTags plugin.TValue[map[string]any] - DefinedTags plugin.TValue[map[string]any] + mqlOciNetworkFirewallFirewallInternal + Id plugin.TValue[string] + Name plugin.TValue[string] + CompartmentID plugin.TValue[string] + Subnet plugin.TValue[*mqlOciNetworkSubnet] + Policy plugin.TValue[*mqlOciNetworkFirewallPolicy] + Ipv4Address plugin.TValue[string] + Ipv6Address plugin.TValue[string] + Shape plugin.TValue[string] + State plugin.TValue[string] + Created plugin.TValue[*time.Time] + TimeUpdated plugin.TValue[*time.Time] } -// createOciNetworkVcn creates a new instance of this resource -func createOciNetworkVcn(runtime *plugin.Runtime, args map[string]*llx.RawData) (plugin.Resource, error) { - res := &mqlOciNetworkVcn{ +// createOciNetworkFirewallFirewall creates a new instance of this resource +func createOciNetworkFirewallFirewall(runtime *plugin.Runtime, args map[string]*llx.RawData) (plugin.Resource, error) { + res := &mqlOciNetworkFirewallFirewall{ MqlRuntime: runtime, } @@ -2635,7 +8042,7 @@ func createOciNetworkVcn(runtime *plugin.Runtime, args map[string]*llx.RawData) } if runtime.HasRecording { - args, err = runtime.ResourceFromRecording("oci.network.vcn", res.__id) + args, err = runtime.ResourceFromRecording("oci.networkFirewall.firewall", res.__id) if err != nil || args == nil { return res, err } @@ -2645,90 +8052,99 @@ func createOciNetworkVcn(runtime *plugin.Runtime, args map[string]*llx.RawData) return res, nil } -func (c *mqlOciNetworkVcn) MqlName() string { - return "oci.network.vcn" +func (c *mqlOciNetworkFirewallFirewall) MqlName() string { + return "oci.networkFirewall.firewall" } -func (c *mqlOciNetworkVcn) MqlID() string { +func (c *mqlOciNetworkFirewallFirewall) MqlID() string { return c.__id } -func (c *mqlOciNetworkVcn) GetId() *plugin.TValue[string] { +func (c *mqlOciNetworkFirewallFirewall) GetId() *plugin.TValue[string] { return &c.Id } -func (c *mqlOciNetworkVcn) GetCompartmentID() *plugin.TValue[string] { - return &c.CompartmentID -} - -func (c *mqlOciNetworkVcn) GetName() *plugin.TValue[string] { +func (c *mqlOciNetworkFirewallFirewall) GetName() *plugin.TValue[string] { return &c.Name } -func (c *mqlOciNetworkVcn) GetCreated() *plugin.TValue[*time.Time] { - return &c.Created +func (c *mqlOciNetworkFirewallFirewall) GetCompartmentID() *plugin.TValue[string] { + return &c.CompartmentID } -func (c *mqlOciNetworkVcn) GetState() *plugin.TValue[string] { - return &c.State -} +func (c *mqlOciNetworkFirewallFirewall) GetSubnet() *plugin.TValue[*mqlOciNetworkSubnet] { + return plugin.GetOrCompute[*mqlOciNetworkSubnet](&c.Subnet, func() (*mqlOciNetworkSubnet, error) { + if c.MqlRuntime.HasRecording { + d, err := c.MqlRuntime.FieldResourceFromRecording("oci.networkFirewall.firewall", c.__id, "subnet") + if err != nil { + return nil, err + } + if d != nil { + return d.Value.(*mqlOciNetworkSubnet), nil + } + } -func (c *mqlOciNetworkVcn) GetCidrBlock() *plugin.TValue[string] { - return &c.CidrBlock + return c.subnet() + }) } -func (c *mqlOciNetworkVcn) GetCidrBlocks() *plugin.TValue[[]any] { - return &c.CidrBlocks -} +func (c *mqlOciNetworkFirewallFirewall) GetPolicy() *plugin.TValue[*mqlOciNetworkFirewallPolicy] { + return plugin.GetOrCompute[*mqlOciNetworkFirewallPolicy](&c.Policy, func() (*mqlOciNetworkFirewallPolicy, error) { + if c.MqlRuntime.HasRecording { + d, err := c.MqlRuntime.FieldResourceFromRecording("oci.networkFirewall.firewall", c.__id, "policy") + if err != nil { + return nil, err + } + if d != nil { + return d.Value.(*mqlOciNetworkFirewallPolicy), nil + } + } -func (c *mqlOciNetworkVcn) GetVcnDomainName() *plugin.TValue[string] { - return &c.VcnDomainName + return c.policy() + }) } -func (c *mqlOciNetworkVcn) GetDefaultDhcpOptionsId() *plugin.TValue[string] { - return &c.DefaultDhcpOptionsId +func (c *mqlOciNetworkFirewallFirewall) GetIpv4Address() *plugin.TValue[string] { + return &c.Ipv4Address } -func (c *mqlOciNetworkVcn) GetDefaultRouteTableId() *plugin.TValue[string] { - return &c.DefaultRouteTableId +func (c *mqlOciNetworkFirewallFirewall) GetIpv6Address() *plugin.TValue[string] { + return &c.Ipv6Address } -func (c *mqlOciNetworkVcn) GetDefaultSecurityListId() *plugin.TValue[string] { - return &c.DefaultSecurityListId +func (c *mqlOciNetworkFirewallFirewall) GetShape() *plugin.TValue[string] { + return &c.Shape } -func (c *mqlOciNetworkVcn) GetDnsLabel() *plugin.TValue[string] { - return &c.DnsLabel +func (c *mqlOciNetworkFirewallFirewall) GetState() *plugin.TValue[string] { + return &c.State } -func (c *mqlOciNetworkVcn) GetFreeformTags() *plugin.TValue[map[string]any] { - return &c.FreeformTags +func (c *mqlOciNetworkFirewallFirewall) GetCreated() *plugin.TValue[*time.Time] { + return &c.Created } -func (c *mqlOciNetworkVcn) GetDefinedTags() *plugin.TValue[map[string]any] { - return &c.DefinedTags +func (c *mqlOciNetworkFirewallFirewall) GetTimeUpdated() *plugin.TValue[*time.Time] { + return &c.TimeUpdated } -// mqlOciNetworkSecurityList for the oci.network.securityList resource -type mqlOciNetworkSecurityList struct { +// mqlOciNetworkFirewallPolicy for the oci.networkFirewall.policy resource +type mqlOciNetworkFirewallPolicy struct { MqlRuntime *plugin.Runtime __id string - // optional: if you define mqlOciNetworkSecurityListInternal it will be used here - Id plugin.TValue[string] - CompartmentID plugin.TValue[string] - Name plugin.TValue[string] - Created plugin.TValue[*time.Time] - State plugin.TValue[string] - EgressSecurityRules plugin.TValue[[]any] - IngressSecurityRules plugin.TValue[[]any] - VcnId plugin.TValue[string] - FreeformTags plugin.TValue[map[string]any] - DefinedTags plugin.TValue[map[string]any] + mqlOciNetworkFirewallPolicyInternal + Id plugin.TValue[string] + Name plugin.TValue[string] + CompartmentID plugin.TValue[string] + Description plugin.TValue[string] + AttachedFirewallCount plugin.TValue[int64] + State plugin.TValue[string] + Created plugin.TValue[*time.Time] } -// createOciNetworkSecurityList creates a new instance of this resource -func createOciNetworkSecurityList(runtime *plugin.Runtime, args map[string]*llx.RawData) (plugin.Resource, error) { - res := &mqlOciNetworkSecurityList{ +// createOciNetworkFirewallPolicy creates a new instance of this resource +func createOciNetworkFirewallPolicy(runtime *plugin.Runtime, args map[string]*llx.RawData) (plugin.Resource, error) { + res := &mqlOciNetworkFirewallPolicy{ MqlRuntime: runtime, } @@ -2745,7 +8161,7 @@ func createOciNetworkSecurityList(runtime *plugin.Runtime, args map[string]*llx. } if runtime.HasRecording { - args, err = runtime.ResourceFromRecording("oci.network.securityList", res.__id) + args, err = runtime.ResourceFromRecording("oci.networkFirewall.policy", res.__id) if err != nil || args == nil { return res, err } @@ -2755,66 +8171,57 @@ func createOciNetworkSecurityList(runtime *plugin.Runtime, args map[string]*llx. return res, nil } -func (c *mqlOciNetworkSecurityList) MqlName() string { - return "oci.network.securityList" +func (c *mqlOciNetworkFirewallPolicy) MqlName() string { + return "oci.networkFirewall.policy" } -func (c *mqlOciNetworkSecurityList) MqlID() string { +func (c *mqlOciNetworkFirewallPolicy) MqlID() string { return c.__id } -func (c *mqlOciNetworkSecurityList) GetId() *plugin.TValue[string] { +func (c *mqlOciNetworkFirewallPolicy) GetId() *plugin.TValue[string] { return &c.Id } -func (c *mqlOciNetworkSecurityList) GetCompartmentID() *plugin.TValue[string] { - return &c.CompartmentID -} - -func (c *mqlOciNetworkSecurityList) GetName() *plugin.TValue[string] { +func (c *mqlOciNetworkFirewallPolicy) GetName() *plugin.TValue[string] { return &c.Name } -func (c *mqlOciNetworkSecurityList) GetCreated() *plugin.TValue[*time.Time] { - return &c.Created -} - -func (c *mqlOciNetworkSecurityList) GetState() *plugin.TValue[string] { - return &c.State -} - -func (c *mqlOciNetworkSecurityList) GetEgressSecurityRules() *plugin.TValue[[]any] { - return &c.EgressSecurityRules +func (c *mqlOciNetworkFirewallPolicy) GetCompartmentID() *plugin.TValue[string] { + return &c.CompartmentID } -func (c *mqlOciNetworkSecurityList) GetIngressSecurityRules() *plugin.TValue[[]any] { - return &c.IngressSecurityRules +func (c *mqlOciNetworkFirewallPolicy) GetDescription() *plugin.TValue[string] { + return plugin.GetOrCompute[string](&c.Description, func() (string, error) { + return c.description() + }) } -func (c *mqlOciNetworkSecurityList) GetVcnId() *plugin.TValue[string] { - return &c.VcnId +func (c *mqlOciNetworkFirewallPolicy) GetAttachedFirewallCount() *plugin.TValue[int64] { + return plugin.GetOrCompute[int64](&c.AttachedFirewallCount, func() (int64, error) { + return c.attachedFirewallCount() + }) } -func (c *mqlOciNetworkSecurityList) GetFreeformTags() *plugin.TValue[map[string]any] { - return &c.FreeformTags +func (c *mqlOciNetworkFirewallPolicy) GetState() *plugin.TValue[string] { + return &c.State } -func (c *mqlOciNetworkSecurityList) GetDefinedTags() *plugin.TValue[map[string]any] { - return &c.DefinedTags +func (c *mqlOciNetworkFirewallPolicy) GetCreated() *plugin.TValue[*time.Time] { + return &c.Created } -// mqlOciObjectStorage for the oci.objectStorage resource -type mqlOciObjectStorage struct { +// mqlOciOke for the oci.oke resource +type mqlOciOke struct { MqlRuntime *plugin.Runtime __id string - // optional: if you define mqlOciObjectStorageInternal it will be used here - Namespace plugin.TValue[string] - Buckets plugin.TValue[[]any] + // optional: if you define mqlOciOkeInternal it will be used here + Clusters plugin.TValue[[]any] } -// createOciObjectStorage creates a new instance of this resource -func createOciObjectStorage(runtime *plugin.Runtime, args map[string]*llx.RawData) (plugin.Resource, error) { - res := &mqlOciObjectStorage{ +// createOciOke creates a new instance of this resource +func createOciOke(runtime *plugin.Runtime, args map[string]*llx.RawData) (plugin.Resource, error) { + res := &mqlOciOke{ MqlRuntime: runtime, } @@ -2831,7 +8238,7 @@ func createOciObjectStorage(runtime *plugin.Runtime, args map[string]*llx.RawDat } if runtime.HasRecording { - args, err = runtime.ResourceFromRecording("oci.objectStorage", res.__id) + args, err = runtime.ResourceFromRecording("oci.oke", res.__id) if err != nil || args == nil { return res, err } @@ -2841,24 +8248,18 @@ func createOciObjectStorage(runtime *plugin.Runtime, args map[string]*llx.RawDat return res, nil } -func (c *mqlOciObjectStorage) MqlName() string { - return "oci.objectStorage" +func (c *mqlOciOke) MqlName() string { + return "oci.oke" } -func (c *mqlOciObjectStorage) MqlID() string { +func (c *mqlOciOke) MqlID() string { return c.__id } -func (c *mqlOciObjectStorage) GetNamespace() *plugin.TValue[string] { - return plugin.GetOrCompute[string](&c.Namespace, func() (string, error) { - return c.namespace() - }) -} - -func (c *mqlOciObjectStorage) GetBuckets() *plugin.TValue[[]any] { - return plugin.GetOrCompute[[]any](&c.Buckets, func() ([]any, error) { +func (c *mqlOciOke) GetClusters() *plugin.TValue[[]any] { + return plugin.GetOrCompute[[]any](&c.Clusters, func() ([]any, error) { if c.MqlRuntime.HasRecording { - d, err := c.MqlRuntime.FieldResourceFromRecording("oci.objectStorage", c.__id, "buckets") + d, err := c.MqlRuntime.FieldResourceFromRecording("oci.oke", c.__id, "clusters") if err != nil { return nil, err } @@ -2867,39 +8268,36 @@ func (c *mqlOciObjectStorage) GetBuckets() *plugin.TValue[[]any] { } } - return c.buckets() + return c.clusters() }) } -// mqlOciObjectStorageBucket for the oci.objectStorage.bucket resource -type mqlOciObjectStorageBucket struct { +// mqlOciOkeCluster for the oci.oke.cluster resource +type mqlOciOkeCluster struct { MqlRuntime *plugin.Runtime __id string - mqlOciObjectStorageBucketInternal - Namespace plugin.TValue[string] - Name plugin.TValue[string] - CompartmentID plugin.TValue[string] - Created plugin.TValue[*time.Time] - Region plugin.TValue[*mqlOciRegion] - PublicAccessType plugin.TValue[string] - StorageTier plugin.TValue[string] - AutoTiering plugin.TValue[string] - Versioning plugin.TValue[string] - ObjectEventsEnabled plugin.TValue[bool] - ReplicationEnabled plugin.TValue[bool] - Id plugin.TValue[string] - IsReadOnly plugin.TValue[bool] - Etag plugin.TValue[string] - KmsKeyId plugin.TValue[string] - ApproximateCount plugin.TValue[int64] - ApproximateSize plugin.TValue[int64] - FreeformTags plugin.TValue[map[string]any] - DefinedTags plugin.TValue[map[string]any] -} - -// createOciObjectStorageBucket creates a new instance of this resource -func createOciObjectStorageBucket(runtime *plugin.Runtime, args map[string]*llx.RawData) (plugin.Resource, error) { - res := &mqlOciObjectStorageBucket{ + mqlOciOkeClusterInternal + Id plugin.TValue[string] + Name plugin.TValue[string] + CompartmentID plugin.TValue[string] + KubernetesVersion plugin.TValue[string] + Type plugin.TValue[string] + Vcn plugin.TValue[*mqlOciNetworkVcn] + KmsKey plugin.TValue[*mqlOciKmsKey] + IsPublicEndpointEnabled plugin.TValue[bool] + PublicEndpoint plugin.TValue[string] + PrivateEndpoint plugin.TValue[string] + IsImagePolicyEnabled plugin.TValue[bool] + AvailableKubernetesUpgrades plugin.TValue[[]any] + IsPodSecurityPolicyEnabled plugin.TValue[bool] + State plugin.TValue[string] + NodePools plugin.TValue[[]any] + Created plugin.TValue[*time.Time] +} + +// createOciOkeCluster creates a new instance of this resource +func createOciOkeCluster(runtime *plugin.Runtime, args map[string]*llx.RawData) (plugin.Resource, error) { + res := &mqlOciOkeCluster{ MqlRuntime: runtime, } @@ -2916,7 +8314,7 @@ func createOciObjectStorageBucket(runtime *plugin.Runtime, args map[string]*llx. } if runtime.HasRecording { - args, err = runtime.ResourceFromRecording("oci.objectStorage.bucket", res.__id) + args, err = runtime.ResourceFromRecording("oci.oke.cluster", res.__id) if err != nil || args == nil { return res, err } @@ -2926,112 +8324,199 @@ func createOciObjectStorageBucket(runtime *plugin.Runtime, args map[string]*llx. return res, nil } -func (c *mqlOciObjectStorageBucket) MqlName() string { - return "oci.objectStorage.bucket" +func (c *mqlOciOkeCluster) MqlName() string { + return "oci.oke.cluster" } -func (c *mqlOciObjectStorageBucket) MqlID() string { +func (c *mqlOciOkeCluster) MqlID() string { return c.__id } -func (c *mqlOciObjectStorageBucket) GetNamespace() *plugin.TValue[string] { - return &c.Namespace +func (c *mqlOciOkeCluster) GetId() *plugin.TValue[string] { + return &c.Id } -func (c *mqlOciObjectStorageBucket) GetName() *plugin.TValue[string] { +func (c *mqlOciOkeCluster) GetName() *plugin.TValue[string] { return &c.Name } -func (c *mqlOciObjectStorageBucket) GetCompartmentID() *plugin.TValue[string] { +func (c *mqlOciOkeCluster) GetCompartmentID() *plugin.TValue[string] { return &c.CompartmentID } -func (c *mqlOciObjectStorageBucket) GetCreated() *plugin.TValue[*time.Time] { - return &c.Created +func (c *mqlOciOkeCluster) GetKubernetesVersion() *plugin.TValue[string] { + return &c.KubernetesVersion } -func (c *mqlOciObjectStorageBucket) GetRegion() *plugin.TValue[*mqlOciRegion] { - return &c.Region +func (c *mqlOciOkeCluster) GetType() *plugin.TValue[string] { + return &c.Type } -func (c *mqlOciObjectStorageBucket) GetPublicAccessType() *plugin.TValue[string] { - return plugin.GetOrCompute[string](&c.PublicAccessType, func() (string, error) { - return c.publicAccessType() +func (c *mqlOciOkeCluster) GetVcn() *plugin.TValue[*mqlOciNetworkVcn] { + return plugin.GetOrCompute[*mqlOciNetworkVcn](&c.Vcn, func() (*mqlOciNetworkVcn, error) { + if c.MqlRuntime.HasRecording { + d, err := c.MqlRuntime.FieldResourceFromRecording("oci.oke.cluster", c.__id, "vcn") + if err != nil { + return nil, err + } + if d != nil { + return d.Value.(*mqlOciNetworkVcn), nil + } + } + + return c.vcn() }) } -func (c *mqlOciObjectStorageBucket) GetStorageTier() *plugin.TValue[string] { - return plugin.GetOrCompute[string](&c.StorageTier, func() (string, error) { - return c.storageTier() +func (c *mqlOciOkeCluster) GetKmsKey() *plugin.TValue[*mqlOciKmsKey] { + return plugin.GetOrCompute[*mqlOciKmsKey](&c.KmsKey, func() (*mqlOciKmsKey, error) { + if c.MqlRuntime.HasRecording { + d, err := c.MqlRuntime.FieldResourceFromRecording("oci.oke.cluster", c.__id, "kmsKey") + if err != nil { + return nil, err + } + if d != nil { + return d.Value.(*mqlOciKmsKey), nil + } + } + + return c.kmsKey() }) } -func (c *mqlOciObjectStorageBucket) GetAutoTiering() *plugin.TValue[string] { - return plugin.GetOrCompute[string](&c.AutoTiering, func() (string, error) { - return c.autoTiering() - }) +func (c *mqlOciOkeCluster) GetIsPublicEndpointEnabled() *plugin.TValue[bool] { + return &c.IsPublicEndpointEnabled } -func (c *mqlOciObjectStorageBucket) GetVersioning() *plugin.TValue[string] { - return plugin.GetOrCompute[string](&c.Versioning, func() (string, error) { - return c.versioning() - }) +func (c *mqlOciOkeCluster) GetPublicEndpoint() *plugin.TValue[string] { + return &c.PublicEndpoint } -func (c *mqlOciObjectStorageBucket) GetObjectEventsEnabled() *plugin.TValue[bool] { - return plugin.GetOrCompute[bool](&c.ObjectEventsEnabled, func() (bool, error) { - return c.objectEventsEnabled() - }) +func (c *mqlOciOkeCluster) GetPrivateEndpoint() *plugin.TValue[string] { + return &c.PrivateEndpoint } -func (c *mqlOciObjectStorageBucket) GetReplicationEnabled() *plugin.TValue[bool] { - return plugin.GetOrCompute[bool](&c.ReplicationEnabled, func() (bool, error) { - return c.replicationEnabled() +func (c *mqlOciOkeCluster) GetIsImagePolicyEnabled() *plugin.TValue[bool] { + return &c.IsImagePolicyEnabled +} + +func (c *mqlOciOkeCluster) GetAvailableKubernetesUpgrades() *plugin.TValue[[]any] { + return &c.AvailableKubernetesUpgrades +} + +func (c *mqlOciOkeCluster) GetIsPodSecurityPolicyEnabled() *plugin.TValue[bool] { + return &c.IsPodSecurityPolicyEnabled +} + +func (c *mqlOciOkeCluster) GetState() *plugin.TValue[string] { + return &c.State +} + +func (c *mqlOciOkeCluster) GetNodePools() *plugin.TValue[[]any] { + return plugin.GetOrCompute[[]any](&c.NodePools, func() ([]any, error) { + if c.MqlRuntime.HasRecording { + d, err := c.MqlRuntime.FieldResourceFromRecording("oci.oke.cluster", c.__id, "nodePools") + if err != nil { + return nil, err + } + if d != nil { + return d.Value.([]any), nil + } + } + + return c.nodePools() }) } -func (c *mqlOciObjectStorageBucket) GetId() *plugin.TValue[string] { +func (c *mqlOciOkeCluster) GetCreated() *plugin.TValue[*time.Time] { + return &c.Created +} + +// mqlOciOkeNodePool for the oci.oke.nodePool resource +type mqlOciOkeNodePool struct { + MqlRuntime *plugin.Runtime + __id string + // optional: if you define mqlOciOkeNodePoolInternal it will be used here + Id plugin.TValue[string] + Name plugin.TValue[string] + CompartmentID plugin.TValue[string] + KubernetesVersion plugin.TValue[string] + NodeShape plugin.TValue[string] + NodeShapeConfig plugin.TValue[any] + NodeImageName plugin.TValue[string] + SshPublicKey plugin.TValue[string] + State plugin.TValue[string] +} + +// createOciOkeNodePool creates a new instance of this resource +func createOciOkeNodePool(runtime *plugin.Runtime, args map[string]*llx.RawData) (plugin.Resource, error) { + res := &mqlOciOkeNodePool{ + MqlRuntime: runtime, + } + + err := SetAllData(res, args) + if err != nil { + return res, err + } + + if res.__id == "" { + res.__id, err = res.id() + if err != nil { + return nil, err + } + } + + if runtime.HasRecording { + args, err = runtime.ResourceFromRecording("oci.oke.nodePool", res.__id) + if err != nil || args == nil { + return res, err + } + return res, SetAllData(res, args) + } + + return res, nil +} + +func (c *mqlOciOkeNodePool) MqlName() string { + return "oci.oke.nodePool" +} + +func (c *mqlOciOkeNodePool) MqlID() string { + return c.__id +} + +func (c *mqlOciOkeNodePool) GetId() *plugin.TValue[string] { return &c.Id } -func (c *mqlOciObjectStorageBucket) GetIsReadOnly() *plugin.TValue[bool] { - return plugin.GetOrCompute[bool](&c.IsReadOnly, func() (bool, error) { - return c.isReadOnly() - }) +func (c *mqlOciOkeNodePool) GetName() *plugin.TValue[string] { + return &c.Name } -func (c *mqlOciObjectStorageBucket) GetEtag() *plugin.TValue[string] { - return plugin.GetOrCompute[string](&c.Etag, func() (string, error) { - return c.etag() - }) +func (c *mqlOciOkeNodePool) GetCompartmentID() *plugin.TValue[string] { + return &c.CompartmentID } -func (c *mqlOciObjectStorageBucket) GetKmsKeyId() *plugin.TValue[string] { - return plugin.GetOrCompute[string](&c.KmsKeyId, func() (string, error) { - return c.kmsKeyId() - }) +func (c *mqlOciOkeNodePool) GetKubernetesVersion() *plugin.TValue[string] { + return &c.KubernetesVersion } -func (c *mqlOciObjectStorageBucket) GetApproximateCount() *plugin.TValue[int64] { - return plugin.GetOrCompute[int64](&c.ApproximateCount, func() (int64, error) { - return c.approximateCount() - }) +func (c *mqlOciOkeNodePool) GetNodeShape() *plugin.TValue[string] { + return &c.NodeShape } -func (c *mqlOciObjectStorageBucket) GetApproximateSize() *plugin.TValue[int64] { - return plugin.GetOrCompute[int64](&c.ApproximateSize, func() (int64, error) { - return c.approximateSize() - }) +func (c *mqlOciOkeNodePool) GetNodeShapeConfig() *plugin.TValue[any] { + return &c.NodeShapeConfig } -func (c *mqlOciObjectStorageBucket) GetFreeformTags() *plugin.TValue[map[string]any] { - return plugin.GetOrCompute[map[string]any](&c.FreeformTags, func() (map[string]any, error) { - return c.freeformTags() - }) +func (c *mqlOciOkeNodePool) GetNodeImageName() *plugin.TValue[string] { + return &c.NodeImageName } -func (c *mqlOciObjectStorageBucket) GetDefinedTags() *plugin.TValue[map[string]any] { - return plugin.GetOrCompute[map[string]any](&c.DefinedTags, func() (map[string]any, error) { - return c.definedTags() - }) +func (c *mqlOciOkeNodePool) GetSshPublicKey() *plugin.TValue[string] { + return &c.SshPublicKey +} + +func (c *mqlOciOkeNodePool) GetState() *plugin.TValue[string] { + return &c.State } diff --git a/providers/oci/resources/oci.lr.versions b/providers/oci/resources/oci.lr.versions index 668c2cead7..3da542b30c 100644 --- a/providers/oci/resources/oci.lr.versions +++ b/providers/oci/resources/oci.lr.versions @@ -2,6 +2,44 @@ # SPDX-License-Identifier: BUSL-1.1 oci 9.0.0 +oci.audit 13.0.3 +oci.audit.retentionPeriodDays 13.0.3 +oci.bastion 13.0.3 +oci.bastion.bastions 13.0.3 +oci.bastion.instance 13.0.3 +oci.bastion.instance.bastionType 13.0.3 +oci.bastion.instance.compartmentID 13.0.3 +oci.bastion.instance.created 13.0.3 +oci.bastion.instance.dnsProxyStatus 13.0.3 +oci.bastion.instance.id 13.0.3 +oci.bastion.instance.name 13.0.3 +oci.bastion.instance.state 13.0.3 +oci.bastion.instance.targetSubnet 13.0.3 +oci.bastion.instance.targetVcn 13.0.3 +oci.bastion.instance.timeUpdated 13.0.3 +oci.cloudGuard 13.0.3 +oci.cloudGuard.detectorRecipe 13.0.3 +oci.cloudGuard.detectorRecipe.created 13.0.3 +oci.cloudGuard.detectorRecipe.description 13.0.3 +oci.cloudGuard.detectorRecipe.detectorType 13.0.3 +oci.cloudGuard.detectorRecipe.id 13.0.3 +oci.cloudGuard.detectorRecipe.name 13.0.3 +oci.cloudGuard.detectorRecipe.owner 13.0.3 +oci.cloudGuard.detectorRecipe.state 13.0.3 +oci.cloudGuard.detectorRecipes 13.0.3 +oci.cloudGuard.reportingRegion 13.0.3 +oci.cloudGuard.selfManageResources 13.0.3 +oci.cloudGuard.status 13.0.3 +oci.cloudGuard.target 13.0.3 +oci.cloudGuard.target.compartmentID 13.0.3 +oci.cloudGuard.target.created 13.0.3 +oci.cloudGuard.target.id 13.0.3 +oci.cloudGuard.target.name 13.0.3 +oci.cloudGuard.target.recipeCount 13.0.3 +oci.cloudGuard.target.state 13.0.3 +oci.cloudGuard.target.targetResourceId 13.0.3 +oci.cloudGuard.target.targetResourceType 13.0.3 +oci.cloudGuard.targets 13.0.3 oci.compartment 9.0.0 oci.compartment.created 9.0.0 oci.compartment.description 9.0.0 @@ -10,6 +48,30 @@ oci.compartment.name 9.0.0 oci.compartment.state 9.0.0 oci.compartments 9.0.0 oci.compute 9.0.0 +oci.compute.blockVolume 13.0.3 +oci.compute.blockVolume.availabilityDomain 13.0.3 +oci.compute.blockVolume.compartmentID 13.0.3 +oci.compute.blockVolume.created 13.0.3 +oci.compute.blockVolume.id 13.0.3 +oci.compute.blockVolume.isAutoTuneEnabled 13.0.3 +oci.compute.blockVolume.isHydrated 13.0.3 +oci.compute.blockVolume.kmsKey 13.0.3 +oci.compute.blockVolume.name 13.0.3 +oci.compute.blockVolume.sizeInGBs 13.0.3 +oci.compute.blockVolume.state 13.0.3 +oci.compute.blockVolume.vpusPerGB 13.0.3 +oci.compute.blockVolumes 13.0.3 +oci.compute.bootVolume 13.0.3 +oci.compute.bootVolume.availabilityDomain 13.0.3 +oci.compute.bootVolume.compartmentID 13.0.3 +oci.compute.bootVolume.created 13.0.3 +oci.compute.bootVolume.id 13.0.3 +oci.compute.bootVolume.imageId 13.0.3 +oci.compute.bootVolume.kmsKey 13.0.3 +oci.compute.bootVolume.name 13.0.3 +oci.compute.bootVolume.sizeInGBs 13.0.3 +oci.compute.bootVolume.state 13.0.3 +oci.compute.bootVolumes 13.0.3 oci.compute.image 9.0.0 oci.compute.image.compartment 11.1.0 oci.compute.image.created 9.0.0 @@ -33,11 +95,41 @@ oci.compute.instance.faultDomain 11.1.0 oci.compute.instance.freeformTags 11.1.0 oci.compute.instance.id 9.0.0 oci.compute.instance.imageId 11.1.0 +oci.compute.instance.instanceOptions 13.0.3 +oci.compute.instance.launchOptions 13.0.3 +oci.compute.instance.metadata 13.0.3 oci.compute.instance.name 9.0.0 +oci.compute.instance.platformConfig 13.0.3 oci.compute.instance.region 9.0.0 oci.compute.instance.shape 11.1.0 +oci.compute.instance.shapeConfig 13.0.3 +oci.compute.instance.sourceDetails 13.0.3 oci.compute.instance.state 9.0.0 +oci.compute.instance.timeMaintenanceRebootDue 13.0.3 oci.compute.instances 9.0.0 +oci.events 13.0.3 +oci.events.rule 13.0.3 +oci.events.rule.actions 13.0.3 +oci.events.rule.compartmentID 13.0.3 +oci.events.rule.condition 13.0.3 +oci.events.rule.created 13.0.3 +oci.events.rule.description 13.0.3 +oci.events.rule.id 13.0.3 +oci.events.rule.isEnabled 13.0.3 +oci.events.rule.name 13.0.3 +oci.events.rule.state 13.0.3 +oci.events.rules 13.0.3 +oci.fileStorage 13.0.3 +oci.fileStorage.fileSystem 13.0.3 +oci.fileStorage.fileSystem.availabilityDomain 13.0.3 +oci.fileStorage.fileSystem.compartmentID 13.0.3 +oci.fileStorage.fileSystem.created 13.0.3 +oci.fileStorage.fileSystem.id 13.0.3 +oci.fileStorage.fileSystem.kmsKey 13.0.3 +oci.fileStorage.fileSystem.meteredBytes 13.0.3 +oci.fileStorage.fileSystem.name 13.0.3 +oci.fileStorage.fileSystem.state 13.0.3 +oci.fileStorage.fileSystems 13.0.3 oci.identity 9.0.0 oci.identity.apiKey 9.0.0 oci.identity.apiKey.created 9.0.0 @@ -98,7 +190,102 @@ oci.identity.user.name 9.0.0 oci.identity.user.previousLogin 9.0.0 oci.identity.user.state 9.0.0 oci.identity.users 9.0.0 +oci.kms 13.0.3 +oci.kms.key 13.0.3 +oci.kms.key.algorithm 13.0.3 +oci.kms.key.compartmentID 13.0.3 +oci.kms.key.created 13.0.3 +oci.kms.key.id 13.0.3 +oci.kms.key.isAutoRotationEnabled 13.0.3 +oci.kms.key.name 13.0.3 +oci.kms.key.protectionMode 13.0.3 +oci.kms.key.state 13.0.3 +oci.kms.key.vaultId 13.0.3 +oci.kms.vault 13.0.3 +oci.kms.vault.compartmentID 13.0.3 +oci.kms.vault.created 13.0.3 +oci.kms.vault.id 13.0.3 +oci.kms.vault.keys 13.0.3 +oci.kms.vault.managementEndpoint 13.0.3 +oci.kms.vault.name 13.0.3 +oci.kms.vault.state 13.0.3 +oci.kms.vault.vaultType 13.0.3 +oci.kms.vaults 13.0.3 +oci.loadBalancer 13.0.3 +oci.loadBalancer.backendSet 13.0.3 +oci.loadBalancer.backendSet.backendCount 13.0.3 +oci.loadBalancer.backendSet.healthChecker 13.0.3 +oci.loadBalancer.backendSet.id 13.0.3 +oci.loadBalancer.backendSet.name 13.0.3 +oci.loadBalancer.backendSet.policy 13.0.3 +oci.loadBalancer.listener 13.0.3 +oci.loadBalancer.listener.defaultBackendSetName 13.0.3 +oci.loadBalancer.listener.id 13.0.3 +oci.loadBalancer.listener.name 13.0.3 +oci.loadBalancer.listener.port 13.0.3 +oci.loadBalancer.listener.protocol 13.0.3 +oci.loadBalancer.listener.sslCipherSuiteName 13.0.3 +oci.loadBalancer.listener.sslProtocols 13.0.3 +oci.loadBalancer.listener.sslVerifyPeerCertificate 13.0.3 +oci.loadBalancer.loadBalancer 13.0.3 +oci.loadBalancer.loadBalancer.backendSets 13.0.3 +oci.loadBalancer.loadBalancer.compartmentID 13.0.3 +oci.loadBalancer.loadBalancer.created 13.0.3 +oci.loadBalancer.loadBalancer.id 13.0.3 +oci.loadBalancer.loadBalancer.isDeleteProtectionEnabled 13.0.3 +oci.loadBalancer.loadBalancer.isPrivate 13.0.3 +oci.loadBalancer.loadBalancer.listeners 13.0.3 +oci.loadBalancer.loadBalancer.name 13.0.3 +oci.loadBalancer.loadBalancer.shape 13.0.3 +oci.loadBalancer.loadBalancer.state 13.0.3 +oci.loadBalancer.loadBalancers 13.0.3 +oci.logging 13.0.3 +oci.logging.log 13.0.3 +oci.logging.log.configuration 13.0.3 +oci.logging.log.created 13.0.3 +oci.logging.log.id 13.0.3 +oci.logging.log.isEnabled 13.0.3 +oci.logging.log.logGroup 13.0.3 +oci.logging.log.logType 13.0.3 +oci.logging.log.name 13.0.3 +oci.logging.log.retentionDuration 13.0.3 +oci.logging.log.state 13.0.3 +oci.logging.log.timeLastModified 13.0.3 +oci.logging.logGroup 13.0.3 +oci.logging.logGroup.compartmentID 13.0.3 +oci.logging.logGroup.created 13.0.3 +oci.logging.logGroup.description 13.0.3 +oci.logging.logGroup.id 13.0.3 +oci.logging.logGroup.logs 13.0.3 +oci.logging.logGroup.name 13.0.3 +oci.logging.logGroup.state 13.0.3 +oci.logging.logGroups 13.0.3 +oci.monitoring 13.0.3 +oci.monitoring.alarm 13.0.3 +oci.monitoring.alarm.compartmentID 13.0.3 +oci.monitoring.alarm.destinations 13.0.3 +oci.monitoring.alarm.id 13.0.3 +oci.monitoring.alarm.isEnabled 13.0.3 +oci.monitoring.alarm.metricCompartmentId 13.0.3 +oci.monitoring.alarm.name 13.0.3 +oci.monitoring.alarm.namespace 13.0.3 +oci.monitoring.alarm.query 13.0.3 +oci.monitoring.alarm.severity 13.0.3 +oci.monitoring.alarm.state 13.0.3 +oci.monitoring.alarms 13.0.3 oci.network 9.0.0 +oci.network.networkSecurityGroup 13.0.3 +oci.network.networkSecurityGroup.compartmentID 13.0.3 +oci.network.networkSecurityGroup.created 13.0.3 +oci.network.networkSecurityGroup.definedTags 13.0.3 +oci.network.networkSecurityGroup.egressSecurityRules 13.0.3 +oci.network.networkSecurityGroup.freeformTags 13.0.3 +oci.network.networkSecurityGroup.id 13.0.3 +oci.network.networkSecurityGroup.ingressSecurityRules 13.0.3 +oci.network.networkSecurityGroup.name 13.0.3 +oci.network.networkSecurityGroup.state 13.0.3 +oci.network.networkSecurityGroup.vcn 13.0.3 +oci.network.networkSecurityGroups 13.0.3 oci.network.securityList 9.0.0 oci.network.securityList.compartmentID 9.0.0 oci.network.securityList.created 9.0.0 @@ -109,8 +296,25 @@ oci.network.securityList.id 9.0.0 oci.network.securityList.ingressSecurityRules 9.0.0 oci.network.securityList.name 9.0.0 oci.network.securityList.state 9.0.0 -oci.network.securityList.vcnId 11.1.0 +oci.network.securityList.vcn 13.0.3 +oci.network.securityList.vcnId 13.0.3 oci.network.securityLists 9.0.0 +oci.network.subnet 13.0.3 +oci.network.subnet.availabilityDomain 13.0.3 +oci.network.subnet.cidrBlock 13.0.3 +oci.network.subnet.compartmentID 13.0.3 +oci.network.subnet.created 13.0.3 +oci.network.subnet.definedTags 13.0.3 +oci.network.subnet.dnsLabel 13.0.3 +oci.network.subnet.freeformTags 13.0.3 +oci.network.subnet.id 13.0.3 +oci.network.subnet.name 13.0.3 +oci.network.subnet.prohibitInternetIngress 13.0.3 +oci.network.subnet.prohibitPublicIpOnVnic 13.0.3 +oci.network.subnet.state 13.0.3 +oci.network.subnet.subnetDomainName 13.0.3 +oci.network.subnet.vcn 13.0.3 +oci.network.subnets 13.0.3 oci.network.vcn 9.0.0 oci.network.vcn.cidrBlock 9.0.0 oci.network.vcn.cidrBlocks 9.0.0 @@ -127,6 +331,29 @@ oci.network.vcn.name 9.0.0 oci.network.vcn.state 9.0.0 oci.network.vcn.vcnDomainName 11.1.0 oci.network.vcns 9.0.0 +oci.networkFirewall 13.0.3 +oci.networkFirewall.firewall 13.0.3 +oci.networkFirewall.firewall.compartmentID 13.0.3 +oci.networkFirewall.firewall.created 13.0.3 +oci.networkFirewall.firewall.id 13.0.3 +oci.networkFirewall.firewall.ipv4Address 13.0.3 +oci.networkFirewall.firewall.ipv6Address 13.0.3 +oci.networkFirewall.firewall.name 13.0.3 +oci.networkFirewall.firewall.policy 13.0.3 +oci.networkFirewall.firewall.shape 13.0.3 +oci.networkFirewall.firewall.state 13.0.3 +oci.networkFirewall.firewall.subnet 13.0.3 +oci.networkFirewall.firewall.timeUpdated 13.0.3 +oci.networkFirewall.firewalls 13.0.3 +oci.networkFirewall.policies 13.0.3 +oci.networkFirewall.policy 13.0.3 +oci.networkFirewall.policy.attachedFirewallCount 13.0.3 +oci.networkFirewall.policy.compartmentID 13.0.3 +oci.networkFirewall.policy.created 13.0.3 +oci.networkFirewall.policy.description 13.0.3 +oci.networkFirewall.policy.id 13.0.3 +oci.networkFirewall.policy.name 13.0.3 +oci.networkFirewall.policy.state 13.0.3 oci.objectStorage 9.0.0 oci.objectStorage.bucket 9.0.0 oci.objectStorage.bucket.approximateCount 11.1.0 @@ -143,6 +370,7 @@ oci.objectStorage.bucket.kmsKeyId 11.1.0 oci.objectStorage.bucket.name 9.0.0 oci.objectStorage.bucket.namespace 9.0.0 oci.objectStorage.bucket.objectEventsEnabled 9.0.0 +oci.objectStorage.bucket.objectLifecyclePolicyEtag 13.0.3 oci.objectStorage.bucket.publicAccessType 9.0.0 oci.objectStorage.bucket.region 9.0.0 oci.objectStorage.bucket.replicationEnabled 9.0.0 @@ -150,6 +378,52 @@ oci.objectStorage.bucket.storageTier 9.0.0 oci.objectStorage.bucket.versioning 9.0.0 oci.objectStorage.buckets 9.0.0 oci.objectStorage.namespace 9.0.0 +oci.oke 13.0.3 +oci.oke.cluster 13.0.3 +oci.oke.cluster.availableKubernetesUpgrades 13.0.3 +oci.oke.cluster.compartmentID 13.0.3 +oci.oke.cluster.created 13.0.3 +oci.oke.cluster.id 13.0.3 +oci.oke.cluster.isImagePolicyEnabled 13.0.3 +oci.oke.cluster.isPodSecurityPolicyEnabled 13.0.3 +oci.oke.cluster.isPublicEndpointEnabled 13.0.3 +oci.oke.cluster.kmsKey 13.0.3 +oci.oke.cluster.kubernetesVersion 13.0.3 +oci.oke.cluster.name 13.0.3 +oci.oke.cluster.nodePools 13.0.3 +oci.oke.cluster.privateEndpoint 13.0.3 +oci.oke.cluster.publicEndpoint 13.0.3 +oci.oke.cluster.state 13.0.3 +oci.oke.cluster.type 13.0.3 +oci.oke.cluster.vcn 13.0.3 +oci.oke.clusters 13.0.3 +oci.oke.nodePool 13.0.3 +oci.oke.nodePool.compartmentID 13.0.3 +oci.oke.nodePool.id 13.0.3 +oci.oke.nodePool.kubernetesVersion 13.0.3 +oci.oke.nodePool.name 13.0.3 +oci.oke.nodePool.nodeImageName 13.0.3 +oci.oke.nodePool.nodeShape 13.0.3 +oci.oke.nodePool.nodeShapeConfig 13.0.3 +oci.oke.nodePool.sshPublicKey 13.0.3 +oci.oke.nodePool.state 13.0.3 +oci.ons 13.0.3 +oci.ons.subscription 13.0.3 +oci.ons.subscription.created 13.0.3 +oci.ons.subscription.endpoint 13.0.3 +oci.ons.subscription.id 13.0.3 +oci.ons.subscription.protocol 13.0.3 +oci.ons.subscription.state 13.0.3 +oci.ons.subscription.topic 13.0.3 +oci.ons.topic 13.0.3 +oci.ons.topic.compartmentID 13.0.3 +oci.ons.topic.created 13.0.3 +oci.ons.topic.description 13.0.3 +oci.ons.topic.id 13.0.3 +oci.ons.topic.name 13.0.3 +oci.ons.topic.state 13.0.3 +oci.ons.topic.subscriptions 13.0.3 +oci.ons.topics 13.0.3 oci.region 9.0.0 oci.region.id 9.0.0 oci.region.isHomeRegion 9.0.0 @@ -161,3 +435,18 @@ oci.tenancy.description 9.0.0 oci.tenancy.id 9.0.0 oci.tenancy.name 9.0.0 oci.tenancy.retentionPeriod 9.0.0 +oci.vault 13.0.3 +oci.vault.secret 13.0.3 +oci.vault.secret.compartmentID 13.0.3 +oci.vault.secret.created 13.0.3 +oci.vault.secret.description 13.0.3 +oci.vault.secret.id 13.0.3 +oci.vault.secret.isAutoGenerationEnabled 13.0.3 +oci.vault.secret.kmsKey 13.0.3 +oci.vault.secret.kmsVault 13.0.3 +oci.vault.secret.lastRotationTime 13.0.3 +oci.vault.secret.name 13.0.3 +oci.vault.secret.nextRotationTime 13.0.3 +oci.vault.secret.rotationStatus 13.0.3 +oci.vault.secret.state 13.0.3 +oci.vault.secrets 13.0.3 diff --git a/providers/oci/resources/oke.go b/providers/oci/resources/oke.go new file mode 100644 index 0000000000..602a0f99e3 --- /dev/null +++ b/providers/oci/resources/oke.go @@ -0,0 +1,272 @@ +// Copyright (c) Mondoo, Inc. +// SPDX-License-Identifier: BUSL-1.1 + +package resources + +import ( + "context" + "errors" + "time" + + "github.com/oracle/oci-go-sdk/v65/common" + "github.com/oracle/oci-go-sdk/v65/containerengine" + "github.com/rs/zerolog/log" + "go.mondoo.com/mql/v13/llx" + "go.mondoo.com/mql/v13/providers-sdk/v1/plugin" + "go.mondoo.com/mql/v13/providers-sdk/v1/util/convert" + "go.mondoo.com/mql/v13/providers-sdk/v1/util/jobpool" + "go.mondoo.com/mql/v13/providers/oci/connection" + "go.mondoo.com/mql/v13/types" +) + +func (o *mqlOciOke) id() (string, error) { + return "oci.oke", nil +} + +func (o *mqlOciOke) clusters() ([]any, error) { + conn := o.MqlRuntime.Connection.(*connection.OciConnection) + + ociResource, err := CreateResource(o.MqlRuntime, "oci", nil) + if err != nil { + return nil, err + } + oci := ociResource.(*mqlOci) + list := oci.GetRegions() + if list.Error != nil { + return nil, list.Error + } + + res := []any{} + poolOfJobs := jobpool.CreatePool(o.getClusters(conn, list.Data), 5) + poolOfJobs.Run() + + if poolOfJobs.HasErrors() { + return nil, poolOfJobs.GetErrors() + } + for i := range poolOfJobs.Jobs { + res = append(res, poolOfJobs.Jobs[i].Result.([]any)...) + } + + return res, nil +} + +func (o *mqlOciOke) getClusters(conn *connection.OciConnection, regions []any) []*jobpool.Job { + ctx := context.Background() + tasks := make([]*jobpool.Job, 0) + for _, region := range regions { + regionResource, ok := region.(*mqlOciRegion) + if !ok { + return jobErr(errors.New("invalid region type")) + } + f := func() (jobpool.JobResult, error) { + log.Debug().Msgf("calling oci oke with region %s", regionResource.Id.Data) + + svc, err := conn.ContainerEngineClient(regionResource.Id.Data) + if err != nil { + return nil, err + } + + clusters := []containerengine.ClusterSummary{} + var page *string + for { + response, err := svc.ListClusters(ctx, containerengine.ListClustersRequest{ + CompartmentId: common.String(conn.TenantID()), + Page: page, + }) + if err != nil { + return nil, err + } + + clusters = append(clusters, response.Items...) + + if response.OpcNextPage == nil { + break + } + page = response.OpcNextPage + } + + var res []any + for i := range clusters { + cluster := clusters[i] + + var created *time.Time + if cluster.Metadata != nil && cluster.Metadata.TimeCreated != nil { + created = &cluster.Metadata.TimeCreated.Time + } + + // Extract endpoint config + var isPublicEndpointEnabled bool + if cluster.EndpointConfig != nil { + isPublicEndpointEnabled = boolValue(cluster.EndpointConfig.IsPublicIpEnabled) + } + + // Extract endpoints + var publicEndpoint, privateEndpoint string + if cluster.Endpoints != nil { + publicEndpoint = stringValue(cluster.Endpoints.PublicEndpoint) + privateEndpoint = stringValue(cluster.Endpoints.PrivateEndpoint) + } + + // Extract image policy + var isImagePolicyEnabled bool + if cluster.ImagePolicyConfig != nil { + isImagePolicyEnabled = boolValue(cluster.ImagePolicyConfig.IsPolicyEnabled) + } + + // Extract admission controller options + var isPodSecurityPolicyEnabled bool + if cluster.Options != nil && cluster.Options.AdmissionControllerOptions != nil { + isPodSecurityPolicyEnabled = boolValue(cluster.Options.AdmissionControllerOptions.IsPodSecurityPolicyEnabled) + } + + // Available upgrades + upgrades := make([]any, 0, len(cluster.AvailableKubernetesUpgrades)) + for _, u := range cluster.AvailableKubernetesUpgrades { + upgrades = append(upgrades, u) + } + + mqlInstance, err := CreateResource(o.MqlRuntime, "oci.oke.cluster", map[string]*llx.RawData{ + "id": llx.StringDataPtr(cluster.Id), + "name": llx.StringDataPtr(cluster.Name), + "compartmentID": llx.StringDataPtr(cluster.CompartmentId), + "kubernetesVersion": llx.StringDataPtr(cluster.KubernetesVersion), + "type": llx.StringData(string(cluster.Type)), + "isPublicEndpointEnabled": llx.BoolData(isPublicEndpointEnabled), + "publicEndpoint": llx.StringData(publicEndpoint), + "privateEndpoint": llx.StringData(privateEndpoint), + "isImagePolicyEnabled": llx.BoolData(isImagePolicyEnabled), + "availableKubernetesUpgrades": llx.ArrayData(upgrades, types.String), + "isPodSecurityPolicyEnabled": llx.BoolData(isPodSecurityPolicyEnabled), + "state": llx.StringData(string(cluster.LifecycleState)), + "created": llx.TimeDataPtr(created), + }) + if err != nil { + return nil, err + } + mqlCluster := mqlInstance.(*mqlOciOkeCluster) + mqlCluster.cacheVcnId = stringValue(cluster.VcnId) + mqlCluster.region = regionResource.Id.Data + res = append(res, mqlCluster) + } + + return jobpool.JobResult(res), nil + } + tasks = append(tasks, jobpool.NewJob(f)) + } + return tasks +} + +type mqlOciOkeClusterInternal struct { + cacheVcnId string + region string +} + +func (o *mqlOciOkeCluster) id() (string, error) { + return "oci.oke.cluster/" + o.Id.Data, nil +} + +func (o *mqlOciOkeCluster) vcn() (*mqlOciNetworkVcn, error) { + if o.cacheVcnId == "" { + o.Vcn.State = plugin.StateIsSet | plugin.StateIsNull + return nil, nil + } + mqlVcn, err := NewResource(o.MqlRuntime, "oci.network.vcn", map[string]*llx.RawData{ + "id": llx.StringData(o.cacheVcnId), + }) + if err != nil { + return nil, err + } + return mqlVcn.(*mqlOciNetworkVcn), nil +} + +func (o *mqlOciOkeCluster) kmsKey() (*mqlOciKmsKey, error) { + conn := o.MqlRuntime.Connection.(*connection.OciConnection) + + svc, err := conn.ContainerEngineClient(o.region) + if err != nil { + return nil, err + } + + resp, err := svc.GetCluster(context.Background(), containerengine.GetClusterRequest{ + ClusterId: common.String(o.Id.Data), + }) + if err != nil { + return nil, err + } + + kmsKeyId := stringValue(resp.Cluster.KmsKeyId) + if kmsKeyId == "" { + o.KmsKey.State = plugin.StateIsSet | plugin.StateIsNull + return nil, nil + } + mqlKey, err := NewResource(o.MqlRuntime, "oci.kms.key", map[string]*llx.RawData{ + "id": llx.StringData(kmsKeyId), + }) + if err != nil { + return nil, err + } + return mqlKey.(*mqlOciKmsKey), nil +} + +func (o *mqlOciOkeCluster) nodePools() ([]any, error) { + conn := o.MqlRuntime.Connection.(*connection.OciConnection) + ctx := context.Background() + + svc, err := conn.ContainerEngineClient(o.region) + if err != nil { + return nil, err + } + + clusterId := o.Id.Data + pools := []containerengine.NodePoolSummary{} + var page *string + for { + response, err := svc.ListNodePools(ctx, containerengine.ListNodePoolsRequest{ + CompartmentId: common.String(o.CompartmentID.Data), + ClusterId: common.String(clusterId), + Page: page, + }) + if err != nil { + return nil, err + } + + pools = append(pools, response.Items...) + + if response.OpcNextPage == nil { + break + } + page = response.OpcNextPage + } + + res := make([]any, 0, len(pools)) + for i := range pools { + np := pools[i] + + nodeShapeConfig, err := convert.JsonToDict(np.NodeShapeConfig) + if err != nil { + return nil, err + } + + mqlInstance, err := CreateResource(o.MqlRuntime, "oci.oke.nodePool", map[string]*llx.RawData{ + "id": llx.StringDataPtr(np.Id), + "name": llx.StringDataPtr(np.Name), + "compartmentID": llx.StringDataPtr(np.CompartmentId), + "kubernetesVersion": llx.StringDataPtr(np.KubernetesVersion), + "nodeShape": llx.StringDataPtr(np.NodeShape), + "nodeShapeConfig": llx.DictData(nodeShapeConfig), + "nodeImageName": llx.StringDataPtr(np.NodeImageName), + "sshPublicKey": llx.StringDataPtr(np.SshPublicKey), + "state": llx.StringData(string(np.LifecycleState)), + }) + if err != nil { + return nil, err + } + res = append(res, mqlInstance) + } + + return res, nil +} + +func (o *mqlOciOkeNodePool) id() (string, error) { + return "oci.oke.nodePool/" + o.Id.Data, nil +} diff --git a/providers/oci/resources/ons.go b/providers/oci/resources/ons.go new file mode 100644 index 0000000000..77b7109d55 --- /dev/null +++ b/providers/oci/resources/ons.go @@ -0,0 +1,221 @@ +// Copyright (c) Mondoo, Inc. +// SPDX-License-Identifier: BUSL-1.1 + +package resources + +import ( + "context" + "errors" + "time" + + "github.com/oracle/oci-go-sdk/v65/common" + "github.com/oracle/oci-go-sdk/v65/ons" + "github.com/rs/zerolog/log" + "go.mondoo.com/mql/v13/llx" + "go.mondoo.com/mql/v13/providers-sdk/v1/plugin" + "go.mondoo.com/mql/v13/providers-sdk/v1/util/jobpool" + "go.mondoo.com/mql/v13/providers/oci/connection" +) + +func (o *mqlOciOns) id() (string, error) { + return "oci.ons", nil +} + +func (o *mqlOciOns) topics() ([]any, error) { + conn := o.MqlRuntime.Connection.(*connection.OciConnection) + + ociResource, err := CreateResource(o.MqlRuntime, "oci", nil) + if err != nil { + return nil, err + } + oci := ociResource.(*mqlOci) + list := oci.GetRegions() + if list.Error != nil { + return nil, list.Error + } + + res := []any{} + poolOfJobs := jobpool.CreatePool(o.getTopics(conn, list.Data), 5) + poolOfJobs.Run() + + if poolOfJobs.HasErrors() { + return nil, poolOfJobs.GetErrors() + } + for i := range poolOfJobs.Jobs { + res = append(res, poolOfJobs.Jobs[i].Result.([]any)...) + } + + return res, nil +} + +func (o *mqlOciOns) getTopicsForRegion(ctx context.Context, client *ons.NotificationControlPlaneClient, compartmentID string) ([]ons.NotificationTopicSummary, error) { + topics := []ons.NotificationTopicSummary{} + var page *string + for { + request := ons.ListTopicsRequest{ + CompartmentId: common.String(compartmentID), + Page: page, + } + + response, err := client.ListTopics(ctx, request) + if err != nil { + return nil, err + } + + topics = append(topics, response.Items...) + + if response.OpcNextPage == nil { + break + } + + page = response.OpcNextPage + } + + return topics, nil +} + +func (o *mqlOciOns) getTopics(conn *connection.OciConnection, regions []any) []*jobpool.Job { + ctx := context.Background() + tasks := make([]*jobpool.Job, 0) + for _, region := range regions { + regionResource, ok := region.(*mqlOciRegion) + if !ok { + return jobErr(errors.New("invalid region type")) + } + f := func() (jobpool.JobResult, error) { + log.Debug().Msgf("calling oci with region %s", regionResource.Id.Data) + + svc, err := conn.NotificationControlPlaneClient(regionResource.Id.Data) + if err != nil { + return nil, err + } + + var res []any + topics, err := o.getTopicsForRegion(ctx, svc, conn.TenantID()) + if err != nil { + return nil, err + } + + for i := range topics { + topic := topics[i] + + var created *time.Time + if topic.TimeCreated != nil { + created = &topic.TimeCreated.Time + } + + mqlInstance, err := CreateResource(o.MqlRuntime, "oci.ons.topic", map[string]*llx.RawData{ + "id": llx.StringDataPtr(topic.TopicId), + "name": llx.StringDataPtr(topic.Name), + "description": llx.StringDataPtr(topic.Description), + "compartmentID": llx.StringDataPtr(topic.CompartmentId), + "state": llx.StringData(string(topic.LifecycleState)), + "created": llx.TimeDataPtr(created), + }) + if err != nil { + return nil, err + } + + mqlTopic := mqlInstance.(*mqlOciOnsTopic) + mqlTopic.region = regionResource.Id.Data + + res = append(res, mqlInstance) + } + + return jobpool.JobResult(res), nil + } + tasks = append(tasks, jobpool.NewJob(f)) + } + return tasks +} + +type mqlOciOnsTopicInternal struct { + region string +} + +func (o *mqlOciOnsTopic) id() (string, error) { + return "oci.ons.topic/" + o.Id.Data, nil +} + +func (o *mqlOciOnsTopic) subscriptions() ([]any, error) { + conn := o.MqlRuntime.Connection.(*connection.OciConnection) + + client, err := conn.NotificationDataPlaneClient(o.region) + if err != nil { + return nil, err + } + + topicId := o.Id.Data + ctx := context.Background() + + subs := []ons.SubscriptionSummary{} + var page *string + for { + request := ons.ListSubscriptionsRequest{ + CompartmentId: common.String(conn.TenantID()), + TopicId: common.String(topicId), + Page: page, + } + + response, err := client.ListSubscriptions(ctx, request) + if err != nil { + return nil, err + } + + subs = append(subs, response.Items...) + + if response.OpcNextPage == nil { + break + } + + page = response.OpcNextPage + } + + res := make([]any, 0, len(subs)) + for i := range subs { + sub := subs[i] + + var created *time.Time + if sub.CreatedTime != nil { + t := time.UnixMilli(*sub.CreatedTime) + created = &t + } + + mqlInstance, err := CreateResource(o.MqlRuntime, "oci.ons.subscription", map[string]*llx.RawData{ + "id": llx.StringDataPtr(sub.Id), + "protocol": llx.StringDataPtr(sub.Protocol), + "endpoint": llx.StringDataPtr(sub.Endpoint), + "state": llx.StringData(string(sub.LifecycleState)), + "created": llx.TimeDataPtr(created), + }) + if err != nil { + return nil, err + } + mqlInstance.(*mqlOciOnsSubscription).cacheTopicId = stringValue(sub.TopicId) + res = append(res, mqlInstance) + } + + return res, nil +} + +type mqlOciOnsSubscriptionInternal struct { + cacheTopicId string +} + +func (o *mqlOciOnsSubscription) id() (string, error) { + return "oci.ons.subscription/" + o.Id.Data, nil +} + +func (o *mqlOciOnsSubscription) topic() (*mqlOciOnsTopic, error) { + if o.cacheTopicId == "" { + o.Topic.State = plugin.StateIsSet | plugin.StateIsNull + return nil, nil + } + mqlTopic, err := NewResource(o.MqlRuntime, "oci.ons.topic", map[string]*llx.RawData{ + "id": llx.StringData(o.cacheTopicId), + }) + if err != nil { + return nil, err + } + return mqlTopic.(*mqlOciOnsTopic), nil +} diff --git a/providers/oci/resources/secrets.go b/providers/oci/resources/secrets.go new file mode 100644 index 0000000000..763cb1d976 --- /dev/null +++ b/providers/oci/resources/secrets.go @@ -0,0 +1,166 @@ +// Copyright (c) Mondoo, Inc. +// SPDX-License-Identifier: BUSL-1.1 + +package resources + +import ( + "context" + "errors" + "time" + + "github.com/oracle/oci-go-sdk/v65/common" + "github.com/oracle/oci-go-sdk/v65/vault" + "github.com/rs/zerolog/log" + "go.mondoo.com/mql/v13/llx" + "go.mondoo.com/mql/v13/providers-sdk/v1/plugin" + "go.mondoo.com/mql/v13/providers-sdk/v1/util/jobpool" + "go.mondoo.com/mql/v13/providers/oci/connection" +) + +func (o *mqlOciVault) id() (string, error) { + return "oci.vault", nil +} + +func (o *mqlOciVault) secrets() ([]any, error) { + conn := o.MqlRuntime.Connection.(*connection.OciConnection) + + ociResource, err := CreateResource(o.MqlRuntime, "oci", nil) + if err != nil { + return nil, err + } + oci := ociResource.(*mqlOci) + list := oci.GetRegions() + if list.Error != nil { + return nil, list.Error + } + + res := []any{} + poolOfJobs := jobpool.CreatePool(o.getSecrets(conn, list.Data), 5) + poolOfJobs.Run() + + if poolOfJobs.HasErrors() { + return nil, poolOfJobs.GetErrors() + } + for i := range poolOfJobs.Jobs { + res = append(res, poolOfJobs.Jobs[i].Result.([]any)...) + } + + return res, nil +} + +func (o *mqlOciVault) getSecrets(conn *connection.OciConnection, regions []any) []*jobpool.Job { + ctx := context.Background() + tasks := make([]*jobpool.Job, 0) + for _, region := range regions { + regionResource, ok := region.(*mqlOciRegion) + if !ok { + return jobErr(errors.New("invalid region type")) + } + f := func() (jobpool.JobResult, error) { + log.Debug().Msgf("calling oci vault secrets with region %s", regionResource.Id.Data) + + svc, err := conn.VaultsClient(regionResource.Id.Data) + if err != nil { + return nil, err + } + + secrets := []vault.SecretSummary{} + var page *string + for { + response, err := svc.ListSecrets(ctx, vault.ListSecretsRequest{ + CompartmentId: common.String(conn.TenantID()), + Page: page, + }) + if err != nil { + return nil, err + } + + secrets = append(secrets, response.Items...) + + if response.OpcNextPage == nil { + break + } + page = response.OpcNextPage + } + + var res []any + for i := range secrets { + s := secrets[i] + + var created *time.Time + if s.TimeCreated != nil { + created = &s.TimeCreated.Time + } + var lastRotation *time.Time + if s.LastRotationTime != nil { + lastRotation = &s.LastRotationTime.Time + } + var nextRotation *time.Time + if s.NextRotationTime != nil { + nextRotation = &s.NextRotationTime.Time + } + + mqlInstance, err := CreateResource(o.MqlRuntime, "oci.vault.secret", map[string]*llx.RawData{ + "id": llx.StringDataPtr(s.Id), + "name": llx.StringDataPtr(s.SecretName), + "compartmentID": llx.StringDataPtr(s.CompartmentId), + "description": llx.StringDataPtr(s.Description), + "state": llx.StringData(string(s.LifecycleState)), + "rotationStatus": llx.StringData(string(s.RotationStatus)), + "lastRotationTime": llx.TimeDataPtr(lastRotation), + "nextRotationTime": llx.TimeDataPtr(nextRotation), + "isAutoGenerationEnabled": llx.BoolDataPtr(s.IsAutoGenerationEnabled), + "created": llx.TimeDataPtr(created), + }) + if err != nil { + return nil, err + } + mqlS := mqlInstance.(*mqlOciVaultSecret) + mqlS.cacheKeyId = stringValue(s.KeyId) + mqlS.cacheVaultId = stringValue(s.VaultId) + res = append(res, mqlS) + } + + return jobpool.JobResult(res), nil + } + tasks = append(tasks, jobpool.NewJob(f)) + } + return tasks +} + +type mqlOciVaultSecretInternal struct { + cacheKeyId string + cacheVaultId string +} + +func (o *mqlOciVaultSecret) id() (string, error) { + return "oci.vault.secret/" + o.Id.Data, nil +} + +func (o *mqlOciVaultSecret) kmsVault() (*mqlOciKmsVault, error) { + if o.cacheVaultId == "" { + o.KmsVault.State = plugin.StateIsSet | plugin.StateIsNull + return nil, nil + } + mqlVault, err := NewResource(o.MqlRuntime, "oci.kms.vault", map[string]*llx.RawData{ + "id": llx.StringData(o.cacheVaultId), + }) + if err != nil { + return nil, err + } + return mqlVault.(*mqlOciKmsVault), nil +} + +func (o *mqlOciVaultSecret) kmsKey() (*mqlOciKmsKey, error) { + if o.cacheKeyId == "" { + o.KmsKey.State = plugin.StateIsSet | plugin.StateIsNull + return nil, nil + } + mqlKey, err := NewResource(o.MqlRuntime, "oci.kms.key", map[string]*llx.RawData{ + "id": llx.StringData(o.cacheKeyId), + }) + if err != nil { + return nil, err + } + return mqlKey.(*mqlOciKmsKey), nil +}