znyang/ambig-iac huggingface dataset:
Task: Configure a custom Time to Live (TTL) attribute for data expiration.

Specification:
Has one "aws_dynamodb_table" resource
with one "ttl"
with one "attribute_name" = "custom_ttl_attribute"
with one "enabled" = true

Terraform configuration (main.tf):
provider "aws" {
region = "us-east-1" # Change to your desired AWS region
}

resource "aws_dynamodb_table" "example" {
name = "your-dynamodb-table-name"
billing_mode = "PAY_PER_REQUEST" # Or "PROVISIONED" if you prefer provisioned capacity
hash_key = "id"
attribute {
name = "id"
type = "S"
}

# Define other table settings as needed

ttl {
attribute_name = "custom_ttl_attribute" # Replace with your custom TTL attribute name
enabled = true # Set to true to enable TTL on the table
}
}

Validation policy (checks.rego):
package main

import future.keywords.in

default allow = false

# Check for DynamoDB table creation or update
dynamodb_table_modified(resources) {
some resource in resources
resource.type == "aws_dynamodb_table"
resource.change.actions[_] == "create"
}

# Check if TTL is enabled with the correct attribute name
ttl_configured(resource) {
resource.type == "aws_dynamodb_table"
resource.change.after.ttl[_].enabled == true
resource.change.after.ttl[_].attribute_name == "custom_ttl_attribute"
}

# Allow if DynamoDB table is modified and TTL is configured correctly
allow {
dynamodb_table_modified(input.resource_changes)
some resource in input.resource_changes
ttl_configured(resource)
}
Task: Configure a DynamoDB table with server-side encryption enabled.

Specification:
Has one "aws_dynamodb_table" resource
with one "server_side_encryption"
with one "enabled" = true

Terraform configuration (main.tf):
terraform {
  required_providers {
    aws = {
      source  = "hashicorp/aws"
      version = ">= 5.0"
    }
  }
}

provider "aws" {
  region = "us-east-1"
}

resource "aws_dynamodb_table" "example" {
name = "your-dynamodb-table-name"
billing_mode = "PAY_PER_REQUEST" # Or "PROVISIONED" if you prefer provisioned capacity
hash_key = "id"
attribute {
name = "id"
type = "S"
}

# Define other table settings as needed

server_side_encryption {
enabled = true
}
}

Validation policy (checks.rego):
package main

import future.keywords.in

default allow = false

dynamodb_table_modified(resources) {
some resource in resources
resource.type == "aws_dynamodb_table"
resource.change.actions[_] == "create"
}

encryption_at_rest_enabled(resource) {
resource.type == "aws_dynamodb_table"
resource.change.after.server_side_encryption[_].enabled == true
}

allow {
dynamodb_table_modified(input.resource_changes)
some resource in input.resource_changes
encryption_at_rest_enabled(resource)
}
Task: Create a DynamoDB table with data encryption at rest enabled for the table.

Specification:
Has one "aws_dynamodb_table" resource
with one "stream_enabled" = true
with one "stream_view_type" = "NEW_AND_OLD_IMAGES"

Terraform configuration (main.tf):
provider "aws" {
region = "us-east-1" # Change this to your desired AWS region
}

resource "aws_dynamodb_table" "example" {
name = "your-dynamodb-table-name"
billing_mode = "PAY_PER_REQUEST" # Or "PROVISIONED" if you prefer provisioned capacity
hash_key = "id"
attribute {
name = "id"
type = "S"
}

# Define other table settings as needed

stream_enabled = true # Enable streams
stream_view_type = "NEW_AND_OLD_IMAGES" # Choose the appropriate stream view type
}

Validation policy (checks.rego):
package main

import future.keywords.in

default allow = false

# Check for DynamoDB table creation or update
dynamodb_table_modified(resources) {
some resource in resources
resource.type == "aws_dynamodb_table"
resource.change.actions[_] == "create"
}

# Check if stream is enabled with new and old images
stream_configured(resource) {
resource.type == "aws_dynamodb_table"
resource.change.after.stream_enabled == true
resource.change.after.stream_view_type == "NEW_AND_OLD_IMAGES" 
}

# Allow if DynamoDB table is modified and stream is configured correctly
allow {
dynamodb_table_modified(input.resource_changes)
some resource in input.resource_changes
stream_configured(resource)
}
Task: Create an AWS VPC resource with an example CIDR block and IPv6 enabled

Specification:
Has one resource "aws_vpc"        
with one "cidr_block" with any valid IPv4 address
with one "assign_generated_ipv6_cidr_block" with value "true"

Terraform configuration (main.tf):
terraform {
  required_providers {
    aws = {
      source  = "hashicorp/aws"
      version = ">= 5.0"
    }
  }
}

provider "aws" {
  region = "us-east-1"
}

resource "aws_vpc" "main" {
  cidr_block = "10.0.0.0/16"
  assign_generated_ipv6_cidr_block = true
}


Validation policy (checks.rego):
package vpc_ipv6
import future.keywords.in

default valid := false

valid {
	some changed_resource in input.resource_changes
	changed_resource.type == "aws_vpc"
	"create" in changed_resource.change.actions
	args := changed_resource.change.after
	net.cidr_is_valid(args.cidr_block)
	args.assign_generated_ipv6_cidr_block == true
}
Task: Create an AWS VPC resource with an Internet Gateway attached to it

Specification:
Has one resource "aws_vpc"

Has one resource "aws_internet_gateway"
with one "vpc_id" with value "aws_vpc.{VPC NAME}.id"

Terraform configuration (main.tf):
terraform {
  required_providers {
    aws = {
      source  = "hashicorp/aws"
      version = ">= 5.0"
    }
  }
}

provider "aws" {
  region = "us-east-1"
}

resource "aws_vpc" "main" {
  cidr_block = "10.0.0.0/16"
}

resource "aws_internet_gateway" "example_igw" {
  vpc_id = aws_vpc.main.id
}

Validation policy (checks.rego):
package vpc_netgate_basic
import future.keywords.in

default valid := false

valid {
	some ig_resource in input.configuration.root_module.resources
	ig_resource.type == "aws_internet_gateway"

	some vpc_resource in input.configuration.root_module.resources
	vpc_resource.type == "aws_vpc"
	vpc_resource.address in ig_resource.expressions.vpc_id.references
}
Task: Create an AWS VPC with an Egress-Only Internet Gateway attached to it

Specification:
Has one resource "aws_vpc"

Has one resource "aws_egress_only_internet_gateway"
with one "vpc_id" with value "aws_vpc.{VPC NAME}.id"

Terraform configuration (main.tf):
terraform {
  required_providers {
    aws = {
      source  = "hashicorp/aws"
      version = ">= 5.0"
    }
  }
}

provider "aws" {
  region = "us-east-1"
}

resource "aws_vpc" "main" {
  cidr_block                       = "10.0.0.0/16"
}

resource "aws_egress_only_internet_gateway" "example_egress_igw" {
  vpc_id = aws_vpc.main.id
}

Validation policy (checks.rego):
package vpc_egress_netgate
import future.keywords.in

default valid := false

valid {
	some eg_ig_resource in input.configuration.root_module.resources
	eg_ig_resource.type == "aws_egress_only_internet_gateway"

	some vpc_resource in input.configuration.root_module.resources
	vpc_resource.type == "aws_vpc"
	vpc_resource.address in eg_ig_resource.expressions.vpc_id.references
}
Task: Create an AWS VPC resource with one public subnet and one private subnet

Specification:
Has one resource "aws_vpc"

Has one resource "aws_subnet"
with one "vpc_id" with value "aws_vpc.{VPC NAME}.id"

Has another resource "aws_subnet"
with one "vpc_id" with value "aws_vpc.{VPC NAME}.id"

Terraform configuration (main.tf):
terraform {
  required_providers {
    aws = {
      source  = "hashicorp/aws"
      version = ">= 5.0"
    }
  }
}

provider "aws" {
  region = "us-east-1"
}

resource "aws_vpc" "main" {
  cidr_block = "10.0.0.0/16"
}

resource "aws_subnet" "my_public_subnet" {
  vpc_id     = aws_vpc.main.id
  cidr_block = "10.0.1.0/24"

  tags = {
    Name = "my_public_subnet"
  }
}

resource "aws_subnet" "my_private_subnet" {
  vpc_id     = aws_vpc.main.id
  cidr_block = "10.0.2.0/24"

  tags = {
    Name = "my_private_subnet"
  }
}

Validation policy (checks.rego):
package vpc_two_subnet
import future.keywords.in

default valid := false

valid {
        some vpc_resource in input.configuration.root_module.resources
        vpc_resource.type == "aws_vpc"

        some subnet1 in input.configuration.root_module.resources
        subnet1.type == "aws_subnet"
        vpc_resource.address in subnet1.expressions.vpc_id.references

        some subnet2 in input.configuration.root_module.resources
        subnet2.type == "aws_subnet"
        vpc_resource.address in subnet2.expressions.vpc_id.references

        not subnet1 == subnet2
}
Task: Create an AWS VPC resource with a subnet and associated network ACLs to control both ingress and egress traffic

Specification:
Has one resource "aws_vpc"

Has one resource "aws_subnet"
with one "vpc_id" with value "aws_vpc.{VPC NAME}.id"

Has one resource "aws_network_acl"
with one "vpc_id" with value "aws_vpc.{VPC NAME}.id"
with one "egress" with correct parameters
with one "ingress" with correct parameters

Terraform configuration (main.tf):
terraform {
  required_providers {
    aws = {
      source  = "hashicorp/aws"
      version = ">= 5.0"
    }
  }
}

provider "aws" {
  region = "us-east-1"
}

resource "aws_vpc" "main" {
  cidr_block = "10.0.0.0/16"
}

resource "aws_subnet" "snet" {
  vpc_id     = aws_vpc.main.id
  cidr_block = "10.0.1.0/24"
}

resource "aws_network_acl" "ntwk_acl" {
  vpc_id      = aws_vpc.main.id

  egress {
    protocol   = "tcp"
    rule_no    = 200
    action     = "allow"
    cidr_block = "10.3.0.0/18"
    from_port  = 443
    to_port    = 443
   }

   ingress {
    protocol   = "tcp"
    rule_no    = 100
    action     = "allow"
    cidr_block = "10.3.0.0/18"
    from_port  = 80
    to_port    = 80
  }
}

Validation policy (checks.rego):
package vpc_net_acl
import future.keywords.in

default valid := false

valid {
        some net_acl_resource in input.configuration.root_module.resources
        net_acl_resource.type == "aws_network_acl"
        net_acl_resource.expressions.egress
        net_acl_resource.expressions.ingress
   
        some vpc_resource in input.configuration.root_module.resources
        vpc_resource.type == "aws_vpc"
        vpc_resource.address in net_acl_resource.expressions.vpc_id.references

        some subnet in input.configuration.root_module.resources
        subnet.type == "aws_subnet"
        vpc_resource.address in subnet.expressions.vpc_id.references
}
Task: Create two AWS VPCs and establish a peering connection between them

Specification:
Has two resources "aws_vpc"

Has one resource "aws_vpc_peering_connection"
with one "vpc_id" with value of one aws_vpc
with one "peer_vpc_id" with value of the other aws_vpc

Terraform configuration (main.tf):
terraform {
  required_providers {
    aws = {
      source  = "hashicorp/aws"
      version = ">= 5.0"
    }
  }
}

provider "aws" {
  region = "us-east-1"
}

resource "aws_vpc" "example_vpc1" {
  cidr_block = "10.0.0.0/16"
}

resource "aws_vpc" "example_vpc2" {
  cidr_block = "10.1.0.0/16"
}

resource "aws_vpc_peering_connection" "example_peer" {
  vpc_id        = aws_vpc.example_vpc1.id
  peer_vpc_id   = aws_vpc.example_vpc2.id
  auto_accept   = true
}

Validation policy (checks.rego):
package vpc_peer_connect
import future.keywords.in

default valid := false        

valid {
        some vpc_resource1 in input.configuration.root_module.resources
        vpc_resource1.type == "aws_vpc"
    
    some vpc_resource2 in input.configuration.root_module.resources
        vpc_resource2.type == "aws_vpc"

    not vpc_resource1 == vpc_resource2
    
        some peer_connection_resource in input.configuration.root_module.resources
        peer_connection_resource.type == "aws_vpc_peering_connection"
    vpc_resource1.address in peer_connection_resource.expressions.vpc_id.references
    vpc_resource2.address in peer_connection_resource.expressions.peer_vpc_id.references
}
Task: Create an AWS VPC resource with an Internet Gateway attached and a route to a custom route table directing traffic for a specific CIDR block through the Internet Gateway

Specification:
Has one resource "aws_vpc"

Has one resource "aws_internet_gateway"
with one "vpc_id" with value "aws_vpc.{VPC NAME}.id"

Has one resource "aws_route_table"
with one "vpc_id" with value "aws_vpc.{VPC NAME}.id"
with one route

Terraform configuration (main.tf):
terraform {
  required_providers {
    aws = {
      source  = "hashicorp/aws"
      version = ">= 5.0"
    }
  }
}

provider "aws" {
  region = "us-east-1"
}

resource "aws_vpc" "main" {
  cidr_block = "10.0.0.0/16"
}

resource "aws_internet_gateway" "example_igw" {
  vpc_id = aws_vpc.main.id
}

resource "aws_route_table" "example_public_rt" {
  vpc_id = aws_vpc.main.id

  route {
    cidr_block = "10.0.1.0/24"
    gateway_id = aws_internet_gateway.example_igw.id
  }
}

Validation policy (checks.rego):
package vpc_gateway_route
import future.keywords.in

default valid := false

valid {
    some route_resource in input.configuration.root_module.resources
        route_resource.type == "aws_route_table"

        some ig_resource in input.configuration.root_module.resources
        ig_resource.type == "aws_internet_gateway"   
    ig_resource.address in route_resource.expressions.route.references

        some vpc_resource in input.configuration.root_module.resources
        vpc_resource.type == "aws_vpc"
        vpc_resource.address in ig_resource.expressions.vpc_id.references
        vpc_resource.address in route_resource.expressions.vpc_id.references
}
Task: Create an AWS VPC resource with one subnet and then launches an EC2 instance into that subnet. Use AMI lookup for an ubuntu 20.04 AMD64 server.

Specification:
Has one resource "aws_vpc"

Has one resource "aws_subnet"
with one "vpc_id" with value "aws_vpc.{VPC NAME}.id"

Has one data source "aws_ami"
with one "filter" with "values" = "ubuntu/images/hvm-ssd/ubuntu-focal-20.04-amd64-server-*"

Has one resource "aws_instance"
with one "ami" with value "data.aws_ami.{DATA NAME}.id"
with one "subnet_id" with value "aws_subnet.{SUBNET NAME}.id"

Terraform configuration (main.tf):
terraform {
  required_providers {
    aws = {
      source  = "hashicorp/aws"
      version = ">= 5.0"
    }
  }
}

provider "aws" {
  region = "us-east-1"
}

resource "aws_vpc" "main" {
  cidr_block = "10.0.0.0/16"
}

resource "aws_subnet" "example_subnet" {
  vpc_id                  = aws_vpc.main.id
  cidr_block              = "10.0.1.0/24"
  map_public_ip_on_launch = true
}

data "aws_ami" "ubuntu_ami" {
  most_recent = true

  filter {
    name   = "name"
    values = ["ubuntu/images/hvm-ssd/ubuntu-focal-20.04-amd64-server-*"]
  }

  filter {
    name   = "virtualization-type"
    values = ["hvm"]
  }

  owners = ["099720109477"]
}

resource "aws_instance" "example_instance" {
  ami             = data.aws_ami.ubuntu_ami.id
  instance_type   = "t2.micro"
  subnet_id       = aws_subnet.example_subnet.id
}

Validation policy (checks.rego):
package vpc_instance
import future.keywords.in

default valid := false

valid {
        some vpc_resource in input.configuration.root_module.resources
        vpc_resource.type == "aws_vpc"

        some subnet in input.configuration.root_module.resources
        subnet.type == "aws_subnet"
        vpc_resource.address in subnet.expressions.vpc_id.references

    some ami in input.configuration.root_module.resources
    ami.type == "aws_ami"
    some filter in ami.expressions.filter
    some ami_name in filter.values.constant_value
    ami_name == "ubuntu/images/hvm-ssd/ubuntu-focal-20.04-amd64-server-*"

    some instance in input.configuration.root_module.resources
    instance.type == "aws_instance"
    ami.address in instance.expressions.ami.references
    subnet.address in instance.expressions.subnet_id.references
}
Task: Create two example subnets and group them to be used for a AWS Neptune cluster

Specification:
Has "aws_vpc"

Has two "aws_subnet"

Has "aws_neptune_subnet_group"
with subnet_ids = array with both "aws_subnet"

Terraform configuration (main.tf):
terraform {
  required_providers {
    aws = {
      source  = "hashicorp/aws"
      version = ">= 5.0"
    }
  }
}

provider "aws" {
  region = "us-east-1"
}

resource "aws_vpc" "example_vpc" {
  cidr_block = "10.0.0.0/16"
}

resource "aws_subnet" "subnet1" {
  vpc_id     = aws_vpc.example_vpc.id
  cidr_block = "10.0.1.0/24"
}

resource "aws_subnet" "subnet2" {
  vpc_id     = aws_vpc.example_vpc.id
  cidr_block = "10.0.2.0/24"
}
resource "aws_neptune_subnet_group" "default" {
  name       = "main"
  subnet_ids = [aws_subnet.subnet1.id, aws_subnet.subnet2.id]

  tags = {
    Name = "My neptune subnet group"
  }
}

Validation policy (checks.rego):
package aws_neptune_cluster
import future.keywords.in

default valid := false

valid {
    some vpc in input.configuration.root_module.resources
    vpc.type == "aws_vpc"

    some subnet1 in input.configuration.root_module.resources
    subnet1.type == "aws_subnet"
    vpc.address in subnet1.expressions.vpc_id.references
    
    some subnet2 in input.configuration.root_module.resources
    subnet2.type == "aws_subnet"
    vpc.address in subnet2.expressions.vpc_id.references
    
    not subnet1 == subnet2
    
    some subnet_group in input.configuration.root_module.resources
    subnet_group.type == "aws_neptune_subnet_group"
    subnet1.address in subnet_group.expressions.subnet_ids.references
    subnet2.address in subnet_group.expressions.subnet_ids.references
}
Task: Create two AWS Chime Voice Connectors, both with encryption, and group these together

Specification:
Has one resource "aws_chime_voice_connector"
with require_encryption="true"

Has another resource "aws_chime_voice_connector"
with require_encryption="true"

Has one resource "aws_chime_voice_connector_group"
with a connector for each voice connector with the correct id

Terraform configuration (main.tf):
terraform {
  required_providers {
    aws = {
      source  = "hashicorp/aws"
      version = ">= 5.0"
    }
  }
}

provider "aws" {
  region = "us-east-1"
}

resource "aws_chime_voice_connector" "vc1" {
  name               = "connector-test-1"
  require_encryption = true
  aws_region         = "us-east-1"
}

resource "aws_chime_voice_connector" "vc2" {
  name               = "connector-test-2"
  require_encryption = true
  aws_region         = "us-west-2"
}

resource "aws_chime_voice_connector_group" "group" {
  name = "test-group"

  connector {
    voice_connector_id = aws_chime_voice_connector.vc1.id
    priority           = 1
  }

  connector {
    voice_connector_id = aws_chime_voice_connector.vc2.id
    priority           = 3
  }
}

Validation policy (checks.rego):
package aws_chime_voice_connector
import future.keywords.in

default valid := false

valid {
    some vc1 in input.configuration.root_module.resources
    vc1.type == "aws_chime_voice_connector"
    vc1.expressions.require_encryption.constant_value == true

    some vc2 in input.configuration.root_module.resources
    vc2.type == "aws_chime_voice_connector"
    vc2.expressions.require_encryption.constant_value == true

    not vc1 == vc2
    
    some vcgroup in input.configuration.root_module.resources
    vcgroup.type == "aws_chime_voice_connector_group"

    some connector1 in vcgroup.expressions.connector
    vc1.address in connector1.voice_connector_id.references
    some connector2 in vcgroup.expressions.connector
    vc2.address in connector2.voice_connector_id.references
    
    not connector1 == connector2
}
Task: Create two AWS Chime Voice Connectors, both with encryption. Then create an aws_chime_voice_connector_group resource with each connector as a connector argument

Specification:
Has one resource "aws_chime_voice_connector"
with require_encryption="true"

Has another resource "aws_chime_voice_connector"
with require_encryption="true"

Has one resource "aws_chime_voice_connector_group"
with a connector for each voice connector with the correct id

Terraform configuration (main.tf):
terraform {
  required_providers {
    aws = {
      source  = "hashicorp/aws"
      version = ">= 5.0"
    }
  }
}

provider "aws" {
  region = "us-east-1"
}

resource "aws_chime_voice_connector" "vc1" {
  name               = "connector-test-1"
  require_encryption = true
  aws_region         = "us-east-1"
}

resource "aws_chime_voice_connector" "vc2" {
  name               = "connector-test-2"
  require_encryption = true
  aws_region         = "us-west-2"
}

resource "aws_chime_voice_connector_group" "group" {
  name = "test-group"

  connector {
    voice_connector_id = aws_chime_voice_connector.vc1.id
    priority           = 1
  }

  connector {
    voice_connector_id = aws_chime_voice_connector.vc2.id
    priority           = 3
  }
}

Validation policy (checks.rego):
package aws_chime_voice_connector
import future.keywords.in

default valid := false

valid {
    some vc1 in input.configuration.root_module.resources
    vc1.type == "aws_chime_voice_connector"
    vc1.expressions.require_encryption.constant_value == true

    some vc2 in input.configuration.root_module.resources
    vc2.type == "aws_chime_voice_connector"
    vc2.expressions.require_encryption.constant_value == true

    not vc1 == vc2
    
    some vcgroup in input.configuration.root_module.resources
    vcgroup.type == "aws_chime_voice_connector_group"

    some connector1 in vcgroup.expressions.connector
    vc1.address in connector1.voice_connector_id.references
    some connector2 in vcgroup.expressions.connector
    vc2.address in connector2.voice_connector_id.references
    
    not connector1 == connector2
}
Task: Create an AWS Chime Voice Connector. Then create an AWS Chime Voice Connector Logging resource with enable_sip_logs disabled and enable_media_metric_logs enabled

Specification:
Has one resource "aws_chime_voice_connector"

Has one resource "aws_chime_voice_connector_logging"
with voice_connector_id equal to the id of the voice connector
with enable_sip_logs false
with enable_media_metric_logs true

Terraform configuration (main.tf):
terraform {
  required_providers {
    aws = {
      source  = "hashicorp/aws"
      version = ">= 5.0"
    }
  }
}

provider "aws" {
  region = "us-east-1"
}

resource "aws_chime_voice_connector" "default" {
  name               = "vc-name-test"
  require_encryption = true
}

resource "aws_chime_voice_connector_logging" "default" {
  enable_sip_logs          = false
  enable_media_metric_logs = true
  voice_connector_id       = aws_chime_voice_connector.default.id
}

Validation policy (checks.rego):
package aws_chime_voice_connector
import future.keywords.in

default valid := false

valid {
    some vc in input.configuration.root_module.resources
    vc.type == "aws_chime_voice_connector"

    some vc_logging in input.configuration.root_module.resources
    vc_logging.type = "aws_chime_voice_connector_logging"
    vc_logging.expressions.enable_sip_logs.constant_value == false
    vc_logging.expressions.enable_media_metric_logs.constant_value == true
    vc.address in vc_logging.expressions.voice_connector_id.references
}
Task: Create an AWS Chime Voice Connector. Then create an AWS Chime Voice Connector Logging resource with logging of ONLY media metrics

Specification:
Has one resource "aws_chime_voice_connector"

Has one resource "aws_chime_voice_connector_logging"
with voice_connector_id equal to the id of the voice connector
with enable_sip_logs false
with enable_media_metric_logs true

Terraform configuration (main.tf):
terraform {
  required_providers {
    aws = {
      source  = "hashicorp/aws"
      version = ">= 5.0"
    }
  }
}

provider "aws" {
  region = "us-east-1"
}

resource "aws_chime_voice_connector" "default" {
  name               = "vc-name-test"
  require_encryption = true
}

resource "aws_chime_voice_connector_logging" "default" {
  enable_sip_logs          = false
  enable_media_metric_logs = true
  voice_connector_id       = aws_chime_voice_connector.default.id
}

Validation policy (checks.rego):
package aws_chime_voice_connector
import future.keywords.in

default valid := false

valid {
    some vc in input.configuration.root_module.resources
    vc.type == "aws_chime_voice_connector"

    some vc_logging in input.configuration.root_module.resources
    vc_logging.type = "aws_chime_voice_connector_logging"
    vc_logging.expressions.enable_sip_logs.constant_value == false
    vc_logging.expressions.enable_media_metric_logs.constant_value == true
    vc.address in vc_logging.expressions.voice_connector_id.references
}