Configuration/files/Robust/Robust.HG.ini/fr

Revision as of 08:20, 7 November 2016

Fichier Robust.HG.ini traduit en français

Cette page est en cours de construction (traduction jusqu'à 1.20). La traduction n'est pas finalisée, les contributeurs sont les bienvenus.

Fichier tiré de la version 0.9.0-425-ge38f16d d'OpenSimulator.

; * Lancement
; * $ Robust.exe -inifile Robust.HG.ini
; *
; * Configurations pour activer HG1.5
; * 
; * HG1.5 les handlers sont :  OpenSim.Server.Handlers.dll:GatekeeperService
; *                            OpenSim.Server.Handlers.dll:UserAgentService
; * Supplémentaire             OpenSim.Server.Handlers.dll:AssetServiceConnector and 
; *                            OpenSim.Server.Handlers.dll:XInventoryInConnector 
; * sont démarrés sur le port 8002, à l'extérieur du firewall
; *
; **
; *
; * La section Const nous permet de définir quelques informations basiques que nous
; * utiliseront tout au long de notre configuration. Nous proposeront des exemples pour 
; * configurer l'url de base du serveur Robust et des ports public et privé 
; * qu'il utilise. La modification des valeurs des constantes fixera les paramètres
; * de fonctionnement pour toute la configuration. D'autres constantes qui se révèleraient
; * utiles peuvent être ajoutées dans cette section. Elles peuvent être appelées
; * n'importe où dans la configuration en ajoutant ${Const|Name}. Cette écriture 
; * fournit un chemin de base pour définir les emplacements que  Robust
; * utilise pour écrire des données.
; * 

[Const]

   ; URL du serveur Robust 
   BaseURL = "http://127.0.0.1"
   ; Port public du serveur Robust
   PublicPort = "8002"
   ;Port privé du serveur Robust
   PrivatePort = "8003"

; * La section startup liste tous les connecteurs qui doivent être démarrés pour
; * cette instance du serveur. On pourra démarrer de un à toute la suite de connecteurs.
; * Les connecteurs doivent êtres séparés par des virgules.
; *
; * Il s'agit des connecteurs IN utilisés par le serveur. Les connecteurs in lisent cette
; * configuration et chargent les services nécessaires et les connecteurs de base de données.
; *
; * La syntaxe complète d'une chaîne de connecteur est:
; * [[<ConfigName>@]<port>/]<dll name>[:<class name>]
; *

[Startup]

; Endroit où créer un fichier PID
; Si le chemin n'est pas spécifié, alors aucun fichier PID ne sera créé.
; PIDFile = "/tmp/Robust.exe.pid"
; 
; Emplacement du registre des Plugins
; Définir le chemin vers le répertoire d'enregistrement des plugins. Les informations
; au sujet des dépôts enregistrés et des plugins installés seront stockées ici.
; Le processus Robust.exe doit avoir un accès en lecture et écriture pour ce répertoire.
RegistryLocation = "."
;
; Configuration modulaire 
; Définir le chemin d'accès au répertoire des fichiers ini modulaires ...
; Le processus Robust.exe doit avoir un accès en lecture et écriture pour ce répertoire.
ConfigDirectory = "."
;
; Les commandes de console peuvent être enregistrées dans un fichier, ainsi, l'historique des commandes
; persistera après un redémarrage.(par défaut l'option est true)
ConsoleHistoryFileEnabled = true
;
; Le fichier de l'historique peut être défini par un simple nom de fichier (relatif au répertoire bin/ d'OpenSim)
; ou par un chemin complet vers un autre répertoire. (par défaut ce sera OpenSimConsoleHistory.txt dans bin/)
ConsoleHistoryFile = "RobustConsoleHistory.txt"
;
; Combien de lignes l'historique des commandes doit-il conserver ? (valeur par défaut : 100)
ConsoleHistoryFileLines = 100

[ServiceList]

   AssetServiceConnector = "${Const|PrivatePort}/OpenSim.Server.Handlers.dll:AssetServiceConnector"
   InventoryInConnector = "${Const|PrivatePort}/OpenSim.Server.Handlers.dll:XInventoryInConnector"
   ;
   ;; Décommenter cette ligne si vous avez configuré Freeswitch (voir plus bas[FreeswitchService])
   ;VoiceConnector = "8004/OpenSim.Server.Handlers.dll:FreeswitchServerConnector"
   ;
   GridServiceConnector = "${Const|PrivatePort}/OpenSim.Server.Handlers.dll:GridServiceConnector"
   GridInfoServerInConnector = "${Const|PublicPort}/OpenSim.Server.Handlers.dll:GridInfoServerInConnector"
   AuthenticationServiceConnector = "${Const|PrivatePort}/OpenSim.Server.Handlers.dll:AuthenticationServiceConnector"
   OpenIdServerConnector = "${Const|PublicPort}/OpenSim.Server.Handlers.dll:OpenIdServerConnector"
   AvatarServiceConnector = "${Const|PrivatePort}/OpenSim.Server.Handlers.dll:AvatarServiceConnector"
   LLLoginServiceInConnector = "${Const|PublicPort}/OpenSim.Server.Handlers.dll:LLLoginServiceInConnector"
   PresenceServiceConnector = "${Const|PrivatePort}/OpenSim.Server.Handlers.dll:PresenceServiceConnector"
   UserAccountServiceConnector = "${Const|PrivatePort}/OpenSim.Server.Handlers.dll:UserAccountServiceConnector"
   GridUserServiceConnector = "${Const|PrivatePort}/OpenSim.Server.Handlers.dll:GridUserServiceConnector"
   AgentPreferencesServiceConnector = "${Const|PrivatePort}/OpenSim.Server.Handlers.dll:AgentPreferencesServiceConnector"
   FriendsServiceConnector = "${Const|PrivatePort}/OpenSim.Server.Handlers.dll:FriendsServiceConnector"
   MapAddServiceConnector = "${Const|PrivatePort}/OpenSim.Server.Handlers.dll:MapAddServiceConnector"
   MapGetServiceConnector = "${Const|PublicPort}/OpenSim.Server.Handlers.dll:MapGetServiceConnector"
   ;
   ;; Décommenter cette ligne si vous voulez que  les IM hors ligne fonctionnent.
   ; OfflineIMServiceConnector = "${Const|PrivatePort}/OpenSim.Addons.OfflineIM.dll:OfflineIMServiceRobustConnector"
   ;; Décommenter cette ligne si vous voulez que les groupes V2 fonctionnent.
   ; GroupsServiceConnector = "${Const|PrivatePort}/OpenSim.Addons.Groups.dll:GroupsServiceRobustConnector"
   ;; Décommenter pour permettre la mise en cache des 'bakes' 
   ;(infos sur le baking : https://wiki.blender.org/index.php/Doc:FR/2.4/Manual/Render/Bake)
   ;BakedTextureService = "${Const|PrivatePort}/OpenSim.Server.Handlers.dll:XBakesConnector"
   ;
   ;; En plus pour l'Hypergrid
   GatekeeperServiceInConnector = "${Const|PublicPort}/OpenSim.Server.Handlers.dll:GatekeeperServiceInConnector"
   UserAgentServerConnector = "${Const|PublicPort}/OpenSim.Server.Handlers.dll:UserAgentServerConnector"
   HeloServiceInConnector = "${Const|PublicPort}/OpenSim.Server.Handlers.dll:HeloServiceInConnector"
   HGFriendsServerConnector = "${Const|PublicPort}/OpenSim.Server.Handlers.dll:HGFriendsServerConnector"
   InstantMessageServerConnector = "${Const|PublicPort}/OpenSim.Server.Handlers.dll:InstantMessageServerConnector"
   HGInventoryServiceConnector = "HGInventoryService@${Const|PublicPort}/OpenSim.Server.Handlers.dll:XInventoryInConnector"
   HGAssetServiceConnector = "HGAssetService@${Const|PublicPort}/OpenSim.Server.Handlers.dll:AssetServiceConnector"
   ;; Décommenter cette ligne si vous voulez que les groupes V2, HG fonctionnent
   ; HGGroupsServiceConnector = "${Const|PublicPort}/OpenSim.Addons.Groups.dll:HGGroupsServiceRobustConnector"
   ;
   ;; Décommenter cette ligne pour UserProfiles voir [UserProfilesService] pour la configuration...
   ; UserProfilesServiceConnector = "${Const|PublicPort}/OpenSim.Server.Handlers.dll:UserProfilesConnector"
   ;
   ;; Décommenter si vous voulez centraliser les données d'estate (domaine)
   ; EstateDataService = "${Const|PrivatePort}/OpenSim.Server.Handlers.dll:EstateDataRobustConnector"

; * Ceci est commun à tous les services, c'est la configuration du réseau pour toute 
; * l'instance du serveur si rien n'a été spécifié plus haut.
; *

[Network]

   port = ${Const|PrivatePort}
   ; HTTPS pour les applications de gestion "hors bande" telles que le module d'administration 
   ; à distance. Indiquer https_main = True pour que le serveur http principal 
   ; utilise https ou "False" pour qu'il utiliser HTTP
   ; https_main = False
   ;
   ; Créer https_listener = "True" va créer une écoute sur le port
   ; spécifié. Fournir le chemin d'accès au certificat de votre serveur avec son
   ; mot de passe.
   ; https_listener = False
   ;
   ; Définir le port d'écoute 
   ; https_port = 0
   ;
   ; Chemin vers le certificat  X509 
   ; cert_path = "path/to/cert.p12"
   ;
   ; Mot de passe de cert
   ; cert_pass = "password"
   ;
   ;; Les 3 variables suivantes sont destinées à l'authentification HTTP de base pour les services Robust.
   ;; Utilisez-les si vos services dirigés sur le ${Const|PrivatePort} doivent être accessibles via Internet
   ;; et que vous voulez les protéger d'un accès non autorisé. 
   ; AuthType = "BasicHttpAuthentication"
   ; HttpAuthUsername = "some_username"
   ; HttpAuthPassword = "some_password"
   ;;
   ;; AuthType  ci-dessus peut être remplacé dans l'une des sections de service ci-dessous par 
   ;  AuthType = "None"
   ;; Cela est utile dans les cas où vous voulez protéger la plupart des services,
   ;; et que vous ne voulez pas protéger certains autres services. Username et Password peuvent aussi
   ;; être remplacés si vous voulez utiliser différents pouvoirs pour différents services.
   ;; Les services Hypergrid ne sont pas concernés par cela; ils sont accessibles publiquement 
   ;; par nature.
   ;; Par défaut, les scripts ne sont pas autorisés à appeler les services privés via llHttpRequest()
   ;; Ces appels sont détectés par l'en-tête HTTP X-Second Life-Shared
   ;; Si vous autorisez de tels appels, vous devez vous assurer qu'ils sont restreints à des scripteurs très fiables.
   ;; (rappelez-vous que des scripts peuvent être portés par les avatars dans leurs attachements.)
   ;; Cela peut être modifié dans des sections de service privées individuelles si nécessaire
   AllowllHTTPRequestIn = false
   ;
   ; * Ce qui suit s'applique à la console distante
   ; * Ça n'a pas d'effet sur les types de console locale ou de base
   ; * Laissez les commentaires pour désactiver les connexions à la console.
   ;ConsoleUser = Test
   ;ConsolePass = secret
   ;ConsolePort = 0

[Hypergrid]

   ;# {HomeURI} {Hypergrid} {URL du home de ce monde} {}
   ;; C'est l'adresse du serveur Robust externe qui
   ;; exécute le service UserAgents, éventuellement ce serveur.
   ;; Par exemple http://myworld.com:8002
   ;; Il s'agit d'une valeur par défaut qui peut être écrasée dans certaines sections.
   ; HomeURI = "${Const|BaseURL}:${Const|PublicPort}"
   ;
   ;# {GatekeeperURI} {Hypergrid} {URL du gatekeeper(gardion) de ce monde} {}
   ;; C'est l'adresse du serveur Robust externe qui 
   ;; exécute le service Gatekeeper, éventuellement ce serveur.
   ;; Par exemple http://myworld.com:8002
   ;; Il s'agit d'une valeur par défaut qui peut être écrasée dans certaines sections.
   ; GatekeeperURI = "${Const|BaseURL}:${Const|PublicPort}"

[AccessControl]

   ;# {AllowedClients} {} {Liste de clients autorisés séparés par une barre(|)} {}
   ;; La barre (|) sépare dans une liste les viewers qui  peuvent avoir accès aux régions.
   ;; On peut utiliser une sous-chaîne du nom du viewer pour accepter uniquement 
   ;; certaines versions.
   ;; Exemple: le visiteur utilise le viewer "Imprudence 1.3.2.0"
   ;; - "Imprudence" il a accès
   ;; - "Imprudence 1.3" il a accès
   ;; - "Imprudence 1.3.1" il n'a pas accès
   ; AllowedClients = ""
   ;
   ;# {DeniedClients} {} {Liste des clients refusés séparés par une barre (|)} {}
   ;; La barre (|) sépare dans une liste les viewers qui ne peuvent pas avoir accès aux régions.
   ;; On peut utiliser une sous-chaîne du nom du viewer pour refuser uniquement 
   ;; certaines versions.
   ;; Exemple: Le visiteur utilise le viewer "Imprudence 1.3.2.0"
   ;; - "Imprudence" Il n'a pas accès.
   ;; - "Imprudence 1.3" Il n'a pas accès.
   ;; - "Imprudence 1.3.1" Il n'a pas accès.
   ; DeniedClients = ""

[DatabaseService]

;; PGSQL
;; Décommenter ces lignes si vous voulez utiliser  le stockage PGSQL 
;; Modifier la chaîne de connexion avec les détails de votre bdd 
; StorageProvider = "OpenSim.Data.PGSQL.dll"
; ConnectionString = "Server=localhost;Database=opensim;User Id=opensim; password=***;"
;
; MySQL
;; Décommenter ces lignes si vous voulez utiliser le stockage MySQL
;; Modifier la chaîne de connexion avec les détails de votre bdd 
   StorageProvider = "OpenSim.Data.MySQL.dll"
   ConnectionString = "Data Source=localhost;Database=opensim;User ID=opensim;Password=*****;Old Guids=true;"

; * À titre d'exemple, la configuration ci-dessous imite précisément le serveur
; * d'asset existant. Il est lu par le connecteur IN des asset (défini plus haut)
; * puis il charge le connecteur OUT (un module de base de données locale). Lequel,
; * va à son tour lire le chargeur d'assets et les informations de connexion à la base de donnée.
; *

[AssetService]

   ;; Choix d'un service d'asset (Une seule option peut être activée)
   LocalServiceModule = "OpenSim.Services.AssetService.dll:AssetService"
   ;LocalServiceModule = "OpenSim.Services.FSAssetService.dll:FSAssetConnector"
   ;
   ;; Répertoires de FSAsset. Base directory , où les fichiers d'asset finalisés sont stockés et Spool directory 
   ;; pour les fichiers temporaires.
   ;; Ces répertoires doivent être sur le même système physique de fichiers.
   ;BaseDirectory = "./fsassets/data"
   ;SpoolDirectory = "./fsassets/tmp"
   ;
   ;; Le service d'origine peut être consulté si  FSAssets ne trouve pas un asset
   ;FallbackService = "OpenSim.Services.AssetService.dll:AssetService";
   ;; Combien de jours depuis la dernière mise à jour du temps d'accès avant qu'il soit à nouveau 
   ;; mis à jour par FSAssets lors de l'accès à un actif. Réduire les appels de BDD si un asset est souvent demandé. 
   ;; La valeur par défaut = 0 pour toujours mettre à jour le temps d'accès. 
   ;DaysBetweenAccessTimeUpdates = 30
   ;
   ;; Configuration de la base de données personnalisée pour FSAssets 
   ;; (Laisser vide pour utiliser la configuration par défaut de la base de données de la grille)
   ;StorageProvider = ""
   ;ConnectionString = ""
   ;Realm = "fsassets"
   ;
   ;; Les éléments suivants sont communs au  service d'asset par défaut et au service FSAsset.
   ;; Options de service d'asset commun
   DefaultAssetLoader = "OpenSim.Framework.AssetLoader.Filesystem.dll"
   AssetLoaderArgs = "./assets/AssetSets.xml"

; * Cette configuration charge les modules du serveur d'inventaires. Elle duplique 
; * la fonction du serveur d'inventaire existant.
; *

[InventoryService]

   LocalServiceModule = "OpenSim.Services.InventoryService.dll:XInventoryService"
   ;; Est-ce que les appels pour vider des dossiers (vider la corbeille)et supprimer/mettre à jour immédiatement des éléments ou 
   ;;des   dossiers (sans passer par la corbeille) réussissent ?
   ;; Si ce paramètre est false alors, il faut mettre en place un autre système pour effectuer ces opérations si nécessaire.
   AllowDelete = true

; * C'est le nouveau style du service de grille.
; * "Realm" est la table qui est utilisée pour la recherche des utilisateurs.
; * Cette table est par défaut "regions", qui utilise les tables existantes.
; *

[GridService]

   LocalServiceModule = "OpenSim.Services.GridService.dll:GridService"
   ; Realm = "regions"
   ; AllowDuplicateNames = "True"
   ;
   ;; Effectuer une vérification de la distance pour la création d'une région liée.
   ; Check4096 = "True"
   ;
   ;; Nécessaire pour afficher des images de cartes non-défaut pour les régions liées.
   AssetService = "OpenSim.Services.AssetService.dll:AssetService"
   ;
   ;; Dossier pour les images de cartes des régions liées
   ; MapTileDirectory = "./maptiles"
   ;
   ;; Ensuite, nous pouvons définir les propriétés des régions, comme les régions par défaut ou de replis 
   ;; La syntaxe est : Region_<RegionName> = "<flags>"
   ;; ou  :            Region_<RegionID> = "<flags>"
   ;; Où <flags> peut être DefaultRegion, DefaultHGRegion, FallbackRegion, NoDirectLogin, Persistent, LockedOut, Reservation, NoMove, Authenticate
   ;;  
   ;; DefaultRegion    Si une connexion locale ne peut être effectuée sur la région requise (par exemple,la region domicile n'existe pas, 
   ;;                  ou si l'avatar n'a pas le droit d'entrer, etc.)
   ;;                  Alors cette région devient la destination. Seule la première région par défaut en ligne sera utilisée. Si aucune DefaultHGRegion 
   ;;                  n'est définie alors elle sera également utilisée comme région de connexion pour l'hypergrid en cas de besoin 
   ;;                  (généralement parce qu'aucune région n'a été spécifié explicitement).
   ;;  
   ;; DefaultHGRegion  Si un avatar se connecte via l'hypergrid sans spécifier une région, alors il sera envoyé sur cette région. 
   ;;                  Seule la première région en ligne sera utilisée.
   ;;  
   ;; FallbackRegion   Si DefaultRegion n'est pas disponible pour une connexion locale, alors toutes les FallbackRegions seront essayées à la place.  
   ;;                  Elles sont testées dans l'ordre spécifié. Pour le moment, cela s'applique uniquement aux connexions locales et non 
   ;;                  aux connexions hypergrid.
   ;;  
   ;; NoDirectLogin    Un utilisateur hypergrid ne peut pas directement se connecter à ces régions. Cela ne s'applique pas aux connexions locales.
   ;;  
   ;; Persistent       Quand le simulateur est déconnecté, la région est signalée comme étant hors ligne mais reste enrgistrée sur la grille.
   ;;
   ; Region_Welcome_Area = "DefaultRegion, FallbackRegion"
   ;; (Remplacer les espaces par des underscore)
   ;
   ;; Autoriser la création d'Hyperlinks dans la console
   HypergridLinker = true
   ;
   ;; Autoriser les viewer à exporter du contenu
   ;; Définir à false pour empêcher l'exportation 
      ExportSupported = true
   ;
   ;; Si vous avez défini ce paramètre dans [Hypergrid], il n'est pas nécessaire de le redéfinir ici, laissez la ligne commentée.
   ; GatekeeperURI = "${Const|BaseURL}:${Const|PublicPort}"

; * Ce qui suit est la configuration du serveur freeswitch en mode grille.

[FreeswitchService]

   LocalServiceModule = "OpenSim.Services.FreeswitchService.dll:FreeswitchService"
   ;;Adresse IP de votre serveur FreeSWITCH.
   ;; Cette adresse doit être accessible aux viewers.
   ; ServerAddress = 127.0.0.1
   ;; Les paramètres de configuration suivants sont facultatifs 
   ;; Par défaut, c'est la même adresse que pour ServerAddress
   ; Realm = 127.0.0.1
   ;; Par défaut c'est la mếme adresse que pour ServerAddress sur le port 5060
   ; SIPProxy = 127.0.0.1:5060
   ;; La valeur par défaut est 5000ms
   ; DefaultTimeout = 5000
   ;; Le contexte du plan de numérotation.  Valeur par défaut "default"
   ; Context = default
   ;; Actuellement non utilisé
   ; UserName = freeswitch
   ;; Actuellement non utilisé
   ; Password = password
   ;; Les paramètres suivants concernent  STUN = Simple Traversal of UDP through NATs(traversée simple de UDP à travers les NAT)
   ;; Voir http://wiki.freeswitch.org/wiki/NAT_Traversal 
   ;; stun.freeswitch.org n'est pas garantie, dans le cadre d'une production vous l'utiliserez
   ;; à vos risques et périls   
   ; EchoServer = 127.0.0.1
   ; EchoPort = 50505
   ; AttemptSTUN = false

; * Ce qui suit est le nouveau style du service d'authentification. Actuellement, seul MySQL
; * est implémenté. 
; *

[AuthenticationService]

   ; Pour le connecteur du serveur
   LocalServiceModule = "OpenSim.Services.AuthenticationService.dll:PasswordAuthenticationService"
   ; Realm = "useraccounts"
   ;; Permettre au service de traiter le appels HTTP getauthinfo. (obtenir les informations)
   ;; Valeur par défaut : false
   ; AllowGetAuthInfo = false
   ;;Permettre au service de traiter les appels HTTP setauthinfo. (définir les informations)
   ;; Valeur par défaut : false
   ; AllowSetAuthInfo = false
   ;; Permettre au service de traiter le appels HTTP setpassword. (définir le mot de passe)
   ;; Valeur par défaut : false
   ; AllowSetPassword = false

[OpenIdService]

   ; Pour le connecteur du serveur
   AuthenticationServiceModule = "OpenSim.Services.AuthenticationService.dll:PasswordAuthenticationService"
   UserAccountServiceModule = "OpenSim.Services.UserAccountService.dll:UserAccountService"

; * Ce qui suit est le nouveau style du service utilisateur.
; * "Realm" est la table qui est utilisée pour la recherche utilisateur. 
; * C'est par défaut la table "useraccounts", qui utilise le nouveau style.
; * Realm = "users"   utilisera les anciennes tables comme source d'authentification.
; *

[UserAccountService]

   ; Pour le connecteur du serveur
   LocalServiceModule = "OpenSim.Services.UserAccountService.dll:UserAccountService"
   ; Realm = "useraccounts"
   ;
   ; Pour créer de nouveaux comptes via les services
   AuthenticationService = "OpenSim.Services.AuthenticationService.dll:PasswordAuthenticationService"
   PresenceService = "OpenSim.Services.PresenceService.dll:PresenceService"
   GridService = "OpenSim.Services.GridService.dll:GridService"
   InventoryService = "OpenSim.Services.InventoryService.dll:XInventoryService"
   AvatarService = "OpenSim.Services.AvatarService.dll:AvatarService"
   GridUserService = "OpenSim.Services.UserAccountService.dll:GridUserService"
   ;
   ;; Cette alternative crée un ensemble minimum de parties de corps et d'entrées pour un avatar dans  un viewer 2.
   ;; Quand un nouvel utilisateur est créé, l'avatar par défaut "Ruth" s'affiche à la place d'un nuage.
   ;; La valeur par défaut est false
   CreateDefaultAvatarEntries = true
   ;
   ;; Permet au service de traiter les appels HTTP createuser. (créer un utilisateur)
   ;; Valeur par défaut : false
   ; AllowCreateUser = false
   ;
   ;; Permet au service de traiter les appels HTTP setaccount. (configurer un compte)
   ;; Valeur par défaut : false
   ; AllowSetAccount = false

[GridUserService]

   ; Pour le connecteur du serveur
   LocalServiceModule = "OpenSim.Services.UserAccountService.dll:GridUserService"

[AgentPreferencesService]

   ; Pour le connecteur du serveur
   LocalServiceModule = "OpenSim.Services.UserAccountService.dll:AgentPreferencesService"

[PresenceService]

   ; Pour le connecteur du serveur
   LocalServiceModule = "OpenSim.Services.PresenceService.dll:PresenceService"

[AvatarService]

   ; Pour le connecteur du serveur
   LocalServiceModule = "OpenSim.Services.AvatarService.dll:AvatarService"

[FriendsService]

   ; Pour le connecteur du serveur
   LocalServiceModule = "OpenSim.Services.FriendsService.dll:FriendsService"

[EstateService]

   LocalServiceModule = "OpenSim.Services.EstateService.dll:EstateDataService"

[LibraryService]

   LibraryName = "OpenSim Library"
   DefaultLibrary = "./inventory/Libraries.xml"

[LoginService]

   ; Pour le connecteur du serveur
   LocalServiceModule = "OpenSim.Services.LLLoginService.dll:LLLoginService"
   ;
   ; Pour le service
   UserAccountService = "OpenSim.Services.UserAccountService.dll:UserAccountService"
   GridUserService = "OpenSim.Services.UserAccountService.dll:GridUserService"
   AuthenticationService = "OpenSim.Services.AuthenticationService.dll:PasswordAuthenticationService"
   InventoryService = "OpenSim.Services.InventoryService.dll:XInventoryService"
   AvatarService = "OpenSim.Services.AvatarService.dll:AvatarService"
   PresenceService = "OpenSim.Services.PresenceService.dll:PresenceService"
   GridService = "OpenSim.Services.GridService.dll:GridService"
   SimulationService ="OpenSim.Services.Connectors.dll:SimulationServiceConnector"
   LibraryService = "OpenSim.Services.InventoryService.dll:LibraryService"
   UserAgentService = "OpenSim.Services.HypergridService.dll:UserAgentService"
   FriendsService = "OpenSim.Services.FriendsService.dll:FriendsService"
   ;
   ; Ce service d'inventaire sera utilisé pour initialiser l'inventaire de l'utilisateur.
   HGInventoryServicePlugin = "OpenSim.Services.HypergridService.dll:HGSuitcaseInventoryService"
   HGInventoryServiceConstructorArg = "HGInventoryService"
   ;
   ;; Demander aux viewers co-operatifs d'utiliser un nom de monnaie différent
   ;Currency = ""
   ;
   ;; Fixer des frais minimums pour publier les annonces classées
   ; ClassifiedFee = 0
   ;
   WelcomeMessage = "Bienvenue, Avatar!"
   AllowRemoteSetLoginLevel = "false"
   ;
   ; Pour les cartes V2
   MapTileURL = "${Const|BaseURL}:${Const|PublicPort}/";
   ;
   ; Url pour rechercher un service
   ; SearchURL = "${Const|BaseURL}:${Const|PublicPort}/";
   ;
   ; Guide de destination V3
   ; DestinationGuide = "${Const|BaseURL}/guide"
   ;
   ; For V3 avatar picker (( travail en cours ))
   ; AvatarPicker = "${Const|BaseURL}/avatars"
   ;
   ; Si vous lancez ce serveur de connexion derrière un proxy, définissez ce paramètre à true
   ; HasProxy = false
   ;
   ;;Valeurs par défaut pour les utilisateurs, si rien d'autre n'est indiqué dans l'entrée (ServiceURLs) de la table useraccounts. 
   ;;Si vous avez défini GatekeeperURI dans [Hypergrid], il n'est pas nécessaire de le redéfinir ici, laissez cette ligne commentée
   ; GatekeeperURI = "${Const|BaseURL}:${Const|PublicPort}"
   SRV_HomeURI = "${Const|BaseURL}:${Const|PublicPort}"
   SRV_InventoryServerURI = "${Const|BaseURL}:${Const|PublicPort}"
   SRV_AssetServerURI = "${Const|BaseURL}:${Const|PublicPort}"
   SRV_ProfileServerURI = "${Const|BaseURL}:${Const|PublicPort}"
   SRV_FriendsServerURI = "${Const|BaseURL}:${Const|PublicPort}"
   SRV_IMServerURI = "${Const|BaseURL}:${Const|PublicPort}"
   SRV_GroupsServerURI = "${Const|BaseURL}:${Const|PublicPort}"
   ;
   ;# {DSTZone} {} {Remplacer la règle de l'heure d'été} {* none local} "America/Los_Angeles;Pacific Standard Time"
   ;; Les viewers ne reçoivent pas d'information du fuseau horaire du serveur - presque tous (?) la valeur par défaut est l'heure standard du Pacifique.
   ;; Toutefois, ils comptent sur le serveur pour leur dire si c'est l'heure d'été ou non.
   ;; Par conséquent, le calcul de l'heure d'été basée sur un fuseau horaire différent peut entraîner un affichage étrange  dans le viewer et des incohérences entre les grilles. 
   ;; Par défaut, ce paramètre utilise plusieurs noms de fuseau horaire pour calculer l'heure d'été en fonction du standard PST des viewers. 
   ;; Les options sont 
   ;;   "none"     pas d'heure d'été 
   ;;   "local"    utiliser seulement le fuseau horaire du serveur pour calculer l'heure d'été. Ancien comportement d'OpenSImulator.
   ;;   "America/Los_Angeles;Pacific Standard Time" utilisez ce nom de fuseau horaire pour rechercher des heures d'été.
   ;;   'America/Los_Angeles' est utilisé sur les systèmes Linux/Mac  alors que 'Pacific Standard Time' est utilisé sur Windows
   DSTZone = "America/Los_Angeles;Pacific Standard Time"

[MapImageService]

   LocalServiceModule = "OpenSim.Services.MapImageService.dll:MapImageService"
   ; Configurez cette ligne si vous désirez modifier la valeur par défaut
   ; TilesStoragePath = "maptiles"
   ;
   ; Si pour une raison quelconque vous avez placé le service AddMapTile en dehors du pare-feu (par exemple. ${Const|PublicPort}),
   ; vous aurez besoin peut-être d'utiliser cette configuration. Sinon, ne l'utilisez pas, car le service est déjà protégé.
   ; GridService = "OpenSim.Services.GridService.dll:GridService"
   ;
   ; En outre, si vous exécutez ce serveur derrière un proxy, définissez ce paramètre à true
   ; HasProxy = false

[GridInfoService]

   ;; Ces paramètres sont utiles pour retourner l'information d'un appel get_grid_info.
   ;; Les scripts de lancement de client et les clients tiers utilisent ces paramètres 
   ;; pour configurer le client et fournir une expérience d'utilisateur agréable.
   ;; Si vous voulez faciliter cela, vous devez configurer ces paramètres  en fonction 
   ;; de votre grille ou de votre standalone.
   ;
   ;; voir http://opensimulator.org/wiki/GridInfo
   ;; login uri: pour une grille c'est l'URI du serveur de connexion
   login = ${Const|BaseURL}:${Const|PublicPort}/
   ;; long grid name: le nom long de votre grille
   gridname = "Le continent perdu de hippo"
   ;; short grid name: un nom court pour votre grille
   gridnick = "hippogrid"
   ;; Page de connexion: facultatif: si elle existe, elle sera utilisée par le client
   ;; comme page d'accueil.                       
   ;welcome = ${Const|BaseURL}/welcome
   ;; helper uri: facultatif: si l'adresse existe, elle sera utilisée par le client
   ;                       pour tout ce qui concerne l'économie.
   ;economy = ${Const|BaseURL}/economy
   ;;Page web de la grille : facultatif: Page contenant des informations complémentaires sur votre grille
   ;about = ${Const|BaseURL}/about
   ;; Création de compte: facultatif: page  contenant des informations complémentaires au sujet de
   ;;                            la création d'un compte pour la grille
   ;register = ${Const|BaseURL}/register
   ;; Aide: facultatif: Page fournissant une assistance supplémentaire aux utilisateurs de votre grille
   ;help = ${Const|BaseURL}/help
   ;; Aide pour mot de passe: facultatif: Page fournissant une assistance pour les mots de passe aux utilisateurs de votre grille
   ;password = ${Const|BaseURL}/password
   ;; Adresse HG du  gatekeeper (gardien), si vous en avez une
   ;; C'est le point d'entrée pour toutes les régions du monde 
   ; gatekeeper = ${Const|BaseURL}:${Const|PublicPort}/
   ;; Domaine utilisateur HG, si vous en avez-un
   ;; C'est le point d'entrée pour tous les services HG liés à l'utilisateur
   ; uas = ${Const|BaseURL}:${Const|PublicPort}/

[GatekeeperService]

   LocalServiceModule = "OpenSim.Services.HypergridService.dll:GatekeeperService"
   ;; for the service
   UserAccountService = "OpenSim.Services.UserAccountService.dll:UserAccountService"
   UserAgentService = "OpenSim.Services.HypergridService.dll:UserAgentService"
   PresenceService = "OpenSim.Services.PresenceService.dll:PresenceService"
   GridUserService = "OpenSim.Services.UserAccountService.dll:GridUserService"
   GridService = "OpenSim.Services.GridService.dll:GridService"
   AuthenticationService = "OpenSim.Services.Connectors.dll:AuthenticationServicesConnector"
   SimulationService ="OpenSim.Services.Connectors.dll:SimulationServiceConnector"
   ; how does the outside world reach me? This acts as public key too.
   ;; If you have GatekeeperURI set under [Hypergrid], no need to set it here, leave it commented
   ; ExternalName = "${Const|BaseURL}:${Const|PublicPort}"
   ; Does this grid allow incoming links to any region in it? 
   ; If false, HG TPs happen only to the Default regions specified in [GridService] section
   AllowTeleportsToAnyRegion = true
   ; If you run this gatekeeper server behind a proxy, set this to true
   ; HasProxy = false
   ;; Are foreign visitors allowed?
   ;ForeignAgentsAllowed = true
   ;;
   ;; If ForeignAgentsAllowed is true, make exceptions using AllowExcept.
   ;; Leave blank or commented for no exceptions.
   ; AllowExcept = "http://griefer.com:8002, http://enemy.com:8002"
   ;;
   ;; If ForeignAgentsAllowed is false, make exceptions using DisallowExcept
   ;; Leave blank or commented for no exceptions.
   ; DisallowExcept = "http://myfriendgrid.com:8002, http://myboss.com:8002"

[UserAgentService]

   LocalServiceModule = "OpenSim.Services.HypergridService.dll:UserAgentService"
   ;; for the service
   GridUserService     = "OpenSim.Services.UserAccountService.dll:GridUserService"
   GridService         = "OpenSim.Services.GridService.dll:GridService"
   GatekeeperService   = "OpenSim.Services.HypergridService.dll:GatekeeperService"
   PresenceService     = "OpenSim.Services.PresenceService.dll:PresenceService"
   FriendsService      = "OpenSim.Services.FriendsService.dll:FriendsService"
   UserAccountService  = "OpenSim.Services.UserAccountService.dll:UserAccountService"
   ; If you run this user agent server behind a proxy, set this to true
   ; HasProxy = false
   ;; If you separate the UserAgentService from the LoginService, set this to
   ;; the IP address of the machine where your LoginService is
   ;LoginServerIP = "127.0.0.1"
   ; User level required to be contacted from other grids
   ;LevelOutsideContacts = 0
   ;; Restrictions on destinations of local users.
   ;; Are local users allowed to visit other grids?
   ;; What user level? Use variables of this forrm:
   ;; ForeignTripsAllowed_Level_<UserLevel> = true | false
   ;; (the default is true)
   ;; For example:
   ; ForeignTripsAllowed_Level_0 = false
   ; ForeignTripsAllowed_Level_200 = true ; true is default, no need to say it
   ;;
   ;; If ForeignTripsAllowed is false, make exceptions using DisallowExcept
   ;; Leave blank or commented for no exceptions.
   ; DisallowExcept_Level_0 = "http://myothergrid.com:8002, http://boss.com:8002"
   ;;
   ;; If ForeignTripsAllowed is true, make exceptions using AllowExcept.
   ;; Leave blank or commented for no exceptions.
   ; AllowExcept_Level_200 = "http://griefer.com:8002, http://enemy.com:8002"
   ;; This variable controls what is exposed to profiles of local users
   ;; as seen from outside of this grid. Leave it uncommented for exposing
   ;; UserTitle, UserFlags and the creation date. Uncomment and change to False
   ;; to block this info from being exposed.
   ; ShowUserDetailsInHGProfile = True

; * The interface that local users get when they are in other grids.
; * This restricts the inventory operations while in other grids.
; * Still not completely safe, especially if users perform inventory operations 
; * while in those grids. The more the user accesses his/her inventory, the more
; * those simulators will know about the user's inventory.
; * 

[HGInventoryService]

   ; For the InventoryServiceInConnector
   LocalServiceModule    = "OpenSim.Services.HypergridService.dll:HGSuitcaseInventoryService"
   ;; alternatives:
   ;;  HG1.5, more permissive, not recommended, but still supported
   ;LocalServiceModule    = "OpenSim.Services.HypergridService.dll:HGInventoryService"
   ;;  HG1.0, totally permissive, not recommended, but OK for grids with 100% trust
   ;LocalServiceModule    = "OpenSim.Services.InventoryService.dll:XInventoryService"
   UserAccountsService = "OpenSim.Services.UserAccountService.dll:UserAccountService"
   AvatarService = "OpenSim.Services.AvatarService.dll:AvatarService"
   ; HGInventoryService is a public-facing inventory service that allows users to 
   ; interact with their suitcase folder when on a foreign grid.  This reuses the general inventory service connector.
   ; Hence, if the user has set up authentication in [Network] to protect their private services
   ; make sure it is not set here.
   AuthType = None
   ;; Can overwrite the default in [Hypergrid], but probably shouldn't
   ; HomeURI = "${Const|BaseURL}:${Const|PublicPort}"

; * The interface that local users get when they are in other grids.
; * This restricts the access that the rest of the world has to
; * the assets of this world.
; * 

[HGAssetService]

   ;; Use the second option if you have FSAsset service enabled
   LocalServiceModule = "OpenSim.Services.HypergridService.dll:HGAssetService"
   ;LocalServiceModule = "OpenSim.Services.HypergridService.dll:HGFSAssetService"
   UserAccountsService = "OpenSim.Services.UserAccountService.dll:UserAccountService"
   ; HGAssetService is a public-facing service that allows users to  
   ; read and create assets when on another grid.  This reuses the general asset service connector.
   ; Hence, if the user has set up authentication in [Network] to protect their private services
   ; make sure it is overriden for this public service.
   AuthType = None
   ;; Can overwrite the default in [Hypergrid], but probably shouldn't
   ; HomeURI = "${Const|BaseURL}:${Const|PublicPort}"
   ;; The asset types that this grid can export to / import from other grids.
   ;; Comma separated.
   ;; Valid values are all the asset types in OpenMetaverse.AssetType, namely:
   ;; Unknown, Texture, Sound, CallingCard, Landmark, Clothing, Object, Notecard, LSLText, 
   ;; LSLBytecode, TextureTGA, Bodypart, SoundWAV, ImageTGA, ImageJPEG, Animation, Gesture, Mesh 
   ;;
   ;; Leave blank or commented if you don't want to apply any restrictions.
   ;; A more strict, but still reasonable, policy may be to disallow the exchange 
   ;; of scripts, like so:
   ; DisallowExport ="LSLText"
   ; DisallowImport ="LSLBytecode"

[HGFriendsService]

   LocalServiceModule = "OpenSim.Services.HypergridService.dll:HGFriendsService"
   UserAgentService = "OpenSim.Services.HypergridService.dll:UserAgentService"
   FriendsService = "OpenSim.Services.FriendsService.dll:FriendsService"
   UserAccountService = "OpenSim.Services.UserAccountService.dll:UserAccountService"
   GridService = "OpenSim.Services.GridService.dll:GridService"
   PresenceService = "OpenSim.Services.PresenceService.dll:PresenceService"

[HGInstantMessageService]

   LocalServiceModule  = "OpenSim.Services.HypergridService.dll:HGInstantMessageService"
   GridService         = "OpenSim.Services.GridService.dll:GridService"
   PresenceService     = "OpenSim.Services.PresenceService.dll:PresenceService"
   UserAgentService    = "OpenSim.Services.HypergridService.dll:UserAgentService"
   ; This should always be true in the Robust config
   InGatekeeper = True

[Messaging]

   ; OfflineIM
   OfflineIMService = "OpenSim.Addons.OfflineIM.dll:OfflineIMService"

[Groups]

   ;; for the HG Groups service
   OfflineIMService = "OpenSim.Addons.OfflineIM.dll:OfflineIMService"
   UserAccountService = "OpenSim.Services.UserAccountService.dll:UserAccountService"
   ;; What is the HomeURI of users associated with this grid?
   ;; Can overwrite the default in [Hypergrid], but probably shouldn't
   ; HomeURI = "${Const|BaseURL}:${Const|PublicPort}"
   ;; Sets the maximum number of groups an agent may join
   ; MaxAgentGroups = 42

[UserProfilesService]

   LocalServiceModule = "OpenSim.Services.UserProfilesService.dll:UserProfilesService"
   Enabled = false
   ;; Configure this for separate profiles database
   ;; ConnectionString = "Data Source=localhost;Database=opensim;User ID=opensim;Password=*****;Old Guids=true;"
   ;; Realm = UserProfiles
   UserAccountService = OpenSim.Services.UserAccountService.dll:UserAccountService
   AuthenticationServiceModule = "OpenSim.Services.AuthenticationService.dll:PasswordAuthenticationService"

[BakedTextureService]

   LocalServiceModule = "OpenSim.Server.Handlers.dll:XBakes"
   ;; This directory must be writable by the user ROBUST runs as. It will be created automatically.
   BaseDirectory = "./bakes"