Question Lotus Notes et Powershell

Bien le bonjour à tous!

Je suis actuellement en train de faire un script pour pouvoir lister les utilisateurs de chaque groupe de mon serveur Domino et enregistrer dans un fichier les différences avec la liste précedente...

Mais c'est la cata!

Comme je teste et découvre lotus je 'tâtonne' ... et comme résultat, c'est le service entier qui part en vrille!

Je n'ai pas terminé le script, mais je pense savoir d'ou vient le souci... J'ouvre la base, mais à aucun moment je ne la referme, et résultat => verrouillée en lecture / écriture et c'est l'ensemble des utilisateurs qui se retrouve sans messagerie.

Voila la manière dont j'ouvre ma base names.nsf depuis le serveur.
[code:1]
$notes = New-Object -ComObject Lotus.Notessession
$notes.initialize()
$names = $notes.addressbooks | Where-Object {$_.filename -eq \"names.nsf\"}
$names.open()
[/code:1]


Et voila donc comment je la verrouille

La question que je vous pose sera donc double :

1) Comment puis-je \"fermer\" proprement ma base ouverte?
2) Est-il possible d'accéder à la base names.nsf sans se l'approprier?

Laurent Dardenne écrit:

1) Comment puis-je \"fermer\" proprement ma base ouverte?

S'il existe une méthode Open, celle nommée Close doit exister.

Justement non! Ça aurait tellement simple

Darum écrit:

2) Est-il possible d'accéder à la base names.nsf sans se l'approprier?

Consulte la doc de ton Objet COM et vérifie si tu peux paramétrer le mode d'accès, Open donc, en lecture uniquement.

Voui, peut être voir de ce coté, mais j'ai pas l'impression que la doc fourmille en ce qui concerne Domino et Powershell!

Merci pour les conseils en tout cas

Reuh!

Après bien des efforts et bien des frayeurs, j'ai lâché l'approche de l'attaque de la base de donnée directement. J'ai préféré passer par le LDAP pour récupérer les informations nécessaires.
Je pose ce code ici, pour qui veut, en guise de référence. J'ai glâné quelques informations de ci de la, et après un paquet non mesurable d'effort et de patience, je suis enfin arrivé à faire que mon code tourne comme je l'entends.

C'est peut être brouillon, mal construit à certains endroits, certains commentaires sont peut être à corriger mais ... ça marche et je suis à l'écoute des commentaires et des remarques!

Bref, ce script a pour but de lister les modifications faites sur la liste des groupes domino entre sa dernière exécution et la suivante.

[code:1]
$debugging = $false #a mettre sur true pour avoir des infos sur la zone de code qui crée l'enregistrement
$date = Get-Date -Format \"dd/MM/yyyy HH:mm:«»ss\"
set-location $([Environment]::GetFolderPath(\"Mydocuments\"«»)) #se place dans le repertoire \"mes documents\" de l'utilisateur actuel
try
{
$base = Import-Clixml referencegroupes.xml
}
catch
{
Write-Host \"Le fichier de réference n'existe pas, ou n'est pas disponible , il sera regénéré à la fin de ce script. Aucun fichier de modification ne se créera.\"
}

#ce bloc crée un message pour signifier qu'il n'a pas pu accéder au fichier de base. Si c'est le premier lancement, ou si le fichier n'est plus accessible, il le recréera avec ce que le script aura récupéré

$base = $base | Sort-Object -Property groupe -Unique

$Connection = New-Object -Com \"ADODB.Connection\" #création d'un objet de connexion à une source de données
$Connection.Provider = \"ADsDSOObject\" #Utilisé pour une connexion LDAP
$Connection.Properties.Item(\"User ID\"«»)=\"CN=Darum,O=Ma Société\" #authentifiant à préciser
$Connection.Properties.Item(\"Password\"«»)=\"P@ssw0rd!\" #Votre mot de passe
$Connection.Open(\"Active Directory Provider\"«»)
$Command = New-Object -Com \"ADODB.Command\" #on initialise la commande qui sera fournie à la connexion $Connection
$Command.ActiveConnection = $Connection #On lie la commande à la connexion
$Query = \"SELECT displayname, mail, member FROM 'LDAP://lotusserveur.mondomaine.com' WHERE objectclass='dominogroup'\" #nous enregistrons un texte qui sera pris comme commande, et qui précise que nous sélectionnons les propriétés displayname mail et member sur le serveur LDAP pour tout ce qui est un dominogroup
$Command.Commandtext = $Query
$Command.Commandtimeout = 60 #Ce timeout est le temps de validité de la commande avant qu'elle soit précisée comme perdue. Si votre base est imposante ou que votre connexion vers le serveur est lente, augmentez la valeur.
$execute = $Command.execute() #On exécute la commande et on l'enregistre dans $execute
$tab = @() #on crée un tableau qui recueillera les données
$execute.MoveFirst() #nous nous déplaçons au premier enregistrement

function ajoutligne ($groupe=$null,$ajout=$null,$retrait=$null,$creation=$null,$suppression=$null,$reference=\"???\"«») #Cette fonction permettra d'ajouter dans chaque colonne l'attribut et la valeur désirée
{

$obj = New-Object PSOBJECT
$obj | add-member -MemberType NoteProperty -Name \"Date\" -Value $date
$obj | add-member -MemberType NoteProperty -Name \"Groupe\" -Value $groupe
$obj | add-member -MemberType NoteProperty -Name \"Ajout de\" -Value $ajout
$obj | add-member -MemberType NoteProperty -Name \"Retrait de\" -Value $retrait
$obj | add-member -MemberType NoteProperty -Name \"Création\" -Value $creation
$obj | add-member -MemberType NoteProperty -Name \"Suppression\" -Value $suppression
if ($debugging -eq $true) {$obj | add-member -MemberType NoteProperty -Name \"Debbuging only\" -Value $reference}
return $obj
}
while ($execute.eof -eq $false) #cette boucle s'execute tant que nous ne sommes pas arrivés sur le EOF (End Of File) qui indique la fin des enregistrements. Une valeur BOF (Begin Of File) existe pour préciser le premier enregistrement.
{
$member = $execute.Fields | Where-Object {$_.name -eq \"member\"} #nous selectionnons dans l’élément de la boucle la valeur \"member\"
$displayname = $execute.Fields | Where-Object {$_.name -eq \"displayname\"} #idem pour displayname
$addresse = $execute.Fields | Where-Object {$_.name -eq \"mail\"} #idem pour mail

if ($member.Value -isnot [System.DBNull]) #Pour un enregistrement de base de donnée vide, $null n'est pas valide. Le type pour une entrée vide est [System.DBNull]
{
$objet = New-Object PSOBJECT
$objet |add-member -Name \"Groupe\" -MemberType NoteProperty -Value $($displayname.value)
$objet |Add-Member -Name \"Adresse\" -MemberType NoteProperty -Value $($addresse.value)
$objet |add-member -Name \"Membres\" -MemberType NoteProperty -Value $($member.value)
$tab += $objet
}

$execute.MoveNext()

}
if ($base -eq $null) #crée la première référence si elle n'existe pas
{
$tab | Export-Clixml referencegroupes.xml
#(get-date).toshortdatestring()+\";\"+(get-date).toshorttimestring()+\";Ecriture du fichier de reference\" >> debug.txt
}
else #execute le script s'il trouve la première reference
{ $tab = $tab |Sort-Object -Property Groupe -Unique
$tab | Export-Clixml newbase.xml
#(get-date).toshortdatestring()+\";\"+(get-date).toshorttimestring()+\";Ecriture du fichier de comparaison\" >> debug.txt

$newbase = Import-Clixml newbase.xml


$recap =@()

foreach ($entree in $base)
{

if ($newbase.groupe -notcontains $entree.groupe) #si la nouvelle base ne comporte pas le groupe, alors c'est qu'il est supprimé
{
$recap += ajoutligne -groupe $entree.groupe -suppression $true -reference '$newbase.groupe -contains $entree.groupe'
}
else #si le groupe existe, on en vérifie les utilisateurs en appelant l'autre base
{
$comparaison = $newbase | Where-Object {$_.groupe -eq $entree.groupe}
$changements = $null
$changements = Compare-Object $entree.membres $comparaison.membres

foreach ($changement in $changements)
{

if ($changement.sideindicator -eq \"=>\"«»)
{

$recap += ajoutligne -groupe $entree.groupe -ajout $changement.inputobject -reference '$changement.sideindicator -eq \"=>\"'
}
else
{

$recap += ajoutligne -groupe $entree.groupe -retrait $changement.inputobject -reference 'else ($changement.sideindicator -eq \"<=\"«»)'
}
} # fin foreach ($changement in $changements)
} #fin else
} #foreach ($groupe in $entree.groupe)

foreach ($entree in $newbase)
{

if ($base.groupe -notcontains $entree.groupe) #si l'ancienne base ne comporte pas le groupe, alors c'est qu'il est crée
{
$recap += ajoutligne -groupe $entree.groupe -creation $true -reference '$base.groupe -notcontains $entree.groupe'
}

} # foreach ($entree in $newbase)

$recap | Export-Csv \"Changements comptes.csv\" -Encoding UTF8 -notypeinformation -Append -Delimiter \";\" #export du fichier de suivi des modifications sur le compte
Move-Item -Path newbase.xml -destination referencegroupes.xml -Force #remplacement du fichier
} #fin else
[/code:1]