Not working recorder

I don’t undestand, why rocording unavailible. image

I’ve been sitting for a long time and I can’t understand.

jibri.conf
jibri {
   // A unique identifier for this Jibri
   id = ""
   // TODO: eventually this will be required with no default
   // Whether or not Jibri should return to idle state after handling
   // (successfully or unsuccessfully) a request.  A value of 'true'
   // here means that a Jibri will NOT return back to the IDLE state
   // and will need to be restarted in order to be used again.
   single-use-mode = false
   api {
     http {
       external-api-port = 2222
       internal-api-port = 3333
   }
     xmpp {
       // See example_xmpp_envs.conf for an example of what is expected here
       environments = [
 	      {
                 name = "prod environment"
                 xmpp-server-hosts = ["meeting.voons.ru"]
                 xmpp-domain = "meeting.voons.ru"

                 control-muc {
                     domain = "internal.auth.meeting.voons.ru"
                     room-name = "JibriBrewery"
                     nickname = "jibri-nickname"
                 }

                 control-login {
                   domain = "auth.meeting.voons.ru"
                   username = "jibri"
                   password = "jibriauthpass"
                 }
                 call_login {
                   domain = "recorder.meeting.voons.ru"
                   username = "recorder"
                   password = "jibrirecorderpass"
                 }

                 strip-from-room-domain = "conference."
                 usage-timeout = 0
                 trust-all-xmpp-certs = true
             }]
     }
   }
   recording {
     recordings-directory = "/srv/recordings"
     # TODO: make this an optional param and remove the default
     finalize-script = "/path/to/finalize_recording.sh"
   }
   streaming {
     // A list of regex patterns for allowed RTMP URLs.  The RTMP URL used
     // when starting a stream must match at least one of the patterns in
     // this list.
     rtmp-allow-list = [
       // By default, all services are allowed
       ".*"
     ]
   }
   chrome {
     // The flags which will be passed to chromium when launching
     flags = [
       "--use-fake-ui-for-media-stream",
       "--start-maximized",
       "--kiosk",
       "--enabled",
       "--disable-infobars",
     "--autoplay-policy=no-user-gesture-required"
     ]
   }
   stats {
     enable-stats-d = true
   }
   webhook {
     // A list of subscribers interested in receiving webhook events
     subscribers = []
   }
   jwt-info {
     // The path to a .pem file which will be used to sign JWT tokens used in webhook
     // requests.  If not set, no JWT will be added to webhook requests.
     # signing-key-path = "/path/to/key.pem"

     // The kid to use as part of the JWT
     # kid = "key-id"

     // The issuer of the JWT
     # issuer = "issuer"

     // The audience of the JWT
     # audience = "audience"

     // The TTL of each generated JWT.  Can't be less than 10 minutes.
     # ttl = 1 hour
   }
   call-status-checks {
     // If all clients have their audio and video muted and if Jibri does not
     // detect any data stream (audio or video) comming in, it will stop
     // recording after NO_MEDIA_TIMEOUT expires.
     no-media-timeout = 30 seconds

     // If all clients have their audio and video muted, Jibri consideres this
     // as an empty call and stops the recording after ALL_MUTED_TIMEOUT expires.
     all-muted-timeout = 10 minutes

     // When detecting if a call is empty, Jibri takes into consideration for how
     // long the call has been empty already. If it has been empty for more than
     // DEFAULT_CALL_EMPTY_TIMEOUT, it will consider it empty and stop the recording.
     default-call-empty-timeout = 30 seconds
   }
 }
prosody
root@Dalton:/# grep password /var/lib/prosody/auth*/accounts/jibri.dat
    ["password"] = "jibriauthpass";
root@Dalton:/# grep password /var/lib/prosody/recorder*/accounts/recorder.dat
    ["password"] = "jibrirecorderpass";
jicofo.conf
jicofo {
    // Configuration related to jitsi-videobridge
    bridge {
      // The maximum number of participants in a single conference to put on one bridge (use -1 for no maximum).
      max-bridge-participants = "-1"

      // The assumed maximum packet rate that a bridge can handle.
      max-bridge-packet-rate = "50000"

      // The assumed average packet rate per participant.
      average-participant-packet-rate-pps = "500"

      // The assumed average stress per participant.
      average-participant-stress = "0.01"

      // The assumed time that an endpoint takes to start contributing fully to the load on a bridge. To avoid allocating
      // a burst of endpoints to the same bridge, the bridge stress is adjusted by adding the number of new endpoints
      // in the last [participant-rampup-time] multiplied by [average-participant-stress].
      participant-rampup-interval = "20 seconds"

      // The stress level above which a bridge is considered overstressed.
      stress-threshold = "0.08"

      // The amount of to wait before retrying using a failed bridge.
      failure-reset-threshold = "1 minute"

      // The bridge selection strategy. The built-in strategies are:
      // SingleBridgeSelectionStrategy: Use the least loaded bridge, do not split a conference between bridges (Octo).
      // SplitBridgeSelectionStrategy: Use a separate bridge for each participant (for testing).
      // RegionBasedBridgeSelectionStrategy: Attempt to put each participant in a bridge in their local region (i.e. use
      //    Octo for geo-location).
      // IntraRegionBridgeSelectionStrategy: Use additional bridges when a bridge becomes overloaded (i.e. use Octo for
      //    load balancing).
      //
      // Additionally, you can use the fully qualified class name for custom BridgeSelectionStrategy implementations.
      selection-strategy = "SingleBridgeSelectionStrategy"


      health-checks {
        // Whether jicofo should perform periodic health checks to the connected bridges.
        enabled = true
        // The interval at which to perform health checks.
        interval = "10 seconds"
        // When a health checks times out, jicofo will retry and only consider it fail after the retry fails. This
        // configures the delay between the original health check timing out and the second health check being sent.
        // It is a duration and defaults to half the [interval].
        # retry-delay = 5 seconds
      }


      // The JID of the MUC to be used as a brewery for bridge instances.
      brewery-jid = "JvbBrewery@internal.auth.meeting.voons.ru"
    }
    // Configure the codecs and RTP extensions to be used in the offer sent to clients.
    codec {
      video {

        vp8 {
          enabled = true
          pt = 100
          // Payload type for the associated RTX stream. Set to -1 to disable RTX.
          rtx-pt = 96
        }





      }

      audio {
        # isac-16000 {
        #   enabled = true
        #   pt = 103
        # }
        # isac-32000 {
        #   enabled = true
        #   pt = 104
        # }
        opus {
          enabled = true
          pt = 111
          minptime = 10
          use-inband-fec = true
          red {
            enabled = false
            pt = 112
          }
        }
        # telephone-event {
        #    enabled = true
        #    pt = 126
        # }
      }

      // RTP header extensions: Real Time Transport Protocol(L7 proto work over L4(UDP))
      rtp-extensions {
        audio-level {
          enabled = true
          id = 1
        }
        tof {
          // TOF is currently disabled, because we don't support it in the bridge
          // (and currently clients seem to not use it when abs-send-time is
          // available).
          enabled = false
          id = 2
        }
        abs-send-time {
          enabled = true
          id = 3
        }
        rid {
          enabled = false
          id = 4
        }
        tcc {
          enabled = true
          id = 5
        }
        video-content-type {
          enabled = false
          id = 7
        }
        framemarking {
          enabled = false
          id = 9
        }
      }
    }

    conference {
      // Whether to automatically grant the 'owner' role to the first participant in the conference (and subsequently to
      // the next in line when the current owner leaves).
      enable-auto-owner = "true"

      // How long to wait for the initial participant in a conference.
      initial-timeout = "15 seconds"

      // Whether jicofo should inject a random SSRC for endpoints which don't advertise any SSRCs. This is a temporary
      // workaround for an issue with signaling endpoints for Octo.
      // ssrc: Synchronization source identifier uniquely identifies the source of a stream.
      inject-ssrc-for-recv-only-endpoints = false

      max-ssrcs-per-user = 20

      // How long a participant's media session will be kept alive once it remains the only participant in the room.
      single-participant-timeout = 20 seconds
    }

    // Configuration for the internal health checks performed by jicofo.

    health {
      // Whether to perform health checks.
      enabled = true

      // The interval between health checks. If set to 0, periodic health checks will not be performed.
      interval = "10 seconds"

      # The timeout for a health check
      timeout = "30 seconds"

      # If performing a health check takes longer than this, it is considered unsuccessful.
      max-check-duration = "20 seconds"

      # The prefix to use when creating MUC rooms for the purpose of health checks.
      room-name-prefix = "__jicofo-health-check"
    }



    jibri {
      // The JID of the MUC to be used as a brewery for jibri instances for streaming.
      brewery-jid = "JvbBrewery@internal.auth.meeting.voons.ru"

      // How many times to retry a given Jibri request before giving up. Set to -1 to allow infinite retries.
      num-retries = "5"

      // How long to wait for Jibri to start recording from the time it accepts a START request.
      pending-timeout = "90"
    }






    // The region in which the machine is running.
    #local-region="us-east-1"

    #


    rest {
      port = 8888
      #tls-port = 8843
    }




    task-pools {
      shared-pool-max-threads = 1500
    }

    xmpp {
      // The separate XMPP connection used for communication with clients (endpoints).
      client {
        //enabled = true
        hostname = ["meeting.voons.ru"]
        port = 5347
        domain = "auth.meeting.voons.ru"
        username = "jibri"
        password = "jibriauthpass"

        // How long to wait for a response to a stanza before giving up.
        reply-timeout = 15 seconds

        // The JID/domain of the MUC service used for conferencing.
        conference-muc-jid = "confi"

        // A flag to suppress the TLS certificate verification.
        disable-certificate-verification = true
      }
      // The separate XMPP connection used for internal services (currently only jitsi-videobridge).
    #   service {
    #     enabled = true
    #     hostname = "xmpp.meet.jitsi"
    #     port = 6222
    #     domain = "auth.meet.jitsi"
    #     username =
    #     password =

    #     // How long to wait for a response to a stanza before giving up.
    #     reply-timeout = 15 seconds

    #     // A flag to suppress the TLS certificate verification.
    #     disable-certificate-verification = false
    #   }

      // How often XMPP components re-discovery will be performed. If set to 0, re-discovery will not be performed.
       rediscovery-interval = 0 seconds
    }
  }
sip-communicator.properties
org.jitsi.jicofo.BRIDGE_MUC=JvbBrewery@internal.auth.meeting.voons.ru
org.jitsi.jicofo.jibri.PENDING_TIMEOUT=90
org.jitsi.jicofo.ALWAYS_TRUST_MODE_ENABLED=true

Pls, help me… :sob:

which tutorial did you use? I checked your domain and it didn’t work aswell

I have watched this tutorial. Did everything according to him. Video, everything works, but the recording does not (

Do I need to register subdomains at the DNS domain registrar?
auth.meeting.**.ru
internal.auth.meeting.**.ru
recorder.meeting.**.ru
etc.

dont use that it’s outdated. use this TUTORIAL - How to Install the NEW JIBRI

No

2 Likes