general {
    stderr = no
    syslog_loglevel = 2
    syslog_facility = LOCAL0

    node_id = 1

    shutdown_mode {
        code = 508
        reason = "Yeti node in shutdown mode"
        allow_uac = true
    }


    media_processor_threads = 4
    rtp_receiver_threads = 4
    session_processor_threads = 20
    sip_udp_server_threads = 2
    sip_tcp_server_threads = 2

    dead_rtp_time=30

    default_bl_ttl=0

    symmetric_rtp_mode = packets
    symmetric_rtp_packets = 20
}

signaling-interfaces {
    interface internal {
        default-media-interface = internal
        ip4 {
            sip-udp {
                address = ~anon~
                port = 5060
                use-raw-sockets = off
            }
            sip-tcp {
                address = ~anon~
                port = 5060
                connect-timeout = 2000
                static-client-port = on
                idle-timeout=900000
                use-raw-sockets = off
            }
        }
    }
}

media-interfaces {
    interface internal {
        ip4 {
            rtp {
                address = ~anon~
                low-port = 16384
                high-port = 32767
                dscp = 46
                use-raw-sockets = off
            }
        }
}

modules {
    module "prometheus_exporter" {
        address = ~anon~
        port = 8080
        label(host, yeti-softswitch-test)
        label(pop, tdc)
    }

    module "di_log" {}
    module "mp3" {}
    module "opus" {}
    module "wav" {}
    module "gsm" {}
    module "ilbc" {}
    module "adpcm" {}
    module "l16" {}
    module "g722" {}

    module "registrar_client" {}
    module "postgresql" {}
    module "session_timer" {}
    module "jsonrpc" {
        listen{
            address = 127.0.0.1
            port = 7080
        }
        server_threads=1
    }

    module "http_client" {}

    module-global "uac_auth" {}
    module "options_prober" {}

    module "radius_client" {}
    module "redis" {
        max_batch_size = 10
        batch_timeout = 100
        max_queue_size = 1000
    }

    module "registrar" {
        redis {
            use_functions = no
            write {
                hosts = { 127.0.0.1:6379 }
            }
            read {
                hosts = { 127.0.0.1:6379 }
            }
       }
    }

    module "yeti" {
        pop_id = 1
        lega_cdr_headers {
            header(p-charge-info, string)
            header(diversion, array)
        }

        auth {
            realm = 127.0.0.1
        }

        msg_logger_dir = /var/spool/sems/dump
        audio_recorder_dir = /var/spool/sems/records
        audio_recorder_compress = true

        db_refresh_interval = 5
        ip_auth_reject_if_no_matched = true

        routing {
            schema = switch21
            #schema = switch20
            #function = route_release
            function = route_debug
            pass_input_interface_name = true
            init = init
            master_pool {
                host = 127.0.0.1
                port = 5432
                name = yeti
                user = yeti
                pass = ~anon~
                size = 4
                check_interval = 10
                max_exceptions = 0
                statement_timeout=3000
            }
            failover_to_slave = false
            slave_pool {
                host = 127.0.0.1
                port = 5432
                name = yeti
                user = yeti
                pass = ~anon~
                size = 4
                check_interval = 10
                max_exceptions = 0
                statement_timeout=3000
            }
            }
        }
        cdr {
            dir = /var/spool/sems/cdrs
            completed_dir = /var/spool/sems/cdrs/completed
            pool_size = 2
            schema = switch
            function = writecdr
            master {
                host = 127.0.0.1
                port = 5432
                name = cdr
                user = cdr
                pass = ~anon~
            }
            failover_to_slave = false
            slave {
                host = 127.0.0.1
                port = 5432
                name = cdr
                user = cdr
                pass = ~anon~
            }
            failover_requeue = true
            failover_to_file = false
            serialize_dynamic_fields = true
            batch_size = 1
            batch_timeout = 5000
        }
        resources {
            reject_on_error = false
            reduce_operations = true
            write {
                hosts = { 127.0.0.1:6379 }
                timeout = 500
            }
            read {
                hosts = { 127.0.0.1:6379 }
                timeout = 1000
            }
        }
        registrations {
            check_interval = 5000
        }
        rpc {
            calls_show_limit = 10000
        }
        core_options_handling = yes
    }
}

routing {
    application = yeti
}