Initialement publié sur StackOverflow

Vérifier que la ligne DCCUnitAlias ne manque pas dans le fichier .dproj du projet :

<PropertyGroup Condition="'$(Base)'!=''">
    <DCC_DependencyCheckOutputName>aida.exe</DCC_DependencyCheckOutputName>
    <DCC_UnitAlias>WinTypes=Windows;WinProcs=Windows;$(DCC_UnitAlias)</DCC_UnitAlias>
</PropertyGroup>

Si vous ne la voyez pas, faites une sauvegarde du fichier .dproj et ajoutez la ligne manquante au bon endroit : <PropertyGroup Condition="'$(Base)'!=''">

Poser un dxSkinController sur le DataModule, virer le NativeStyle, choisir une skin.

Dériver la fiche principale de TdxRibbonForm (use dxRibbonForm)
Poser un dxRibbon
SupportNonClientDrawing = true

Sur le OnSkinChanged du dxRibbonSkinChooser :

procedure TFMain.dxSkinChooserGalleryItem1SkinChanged(Sender: TObject;
  const ASkinName: string);
begin
  DM.dxSkinController1.NativeStyle := False;
  DM.dxSkinController1.SkinName := ASkinName;
  dxSkinChooserGalleryItem1.LargeGlyph := dxSkinChooserGalleryItem1.SelectedGroupItem.Glyph;
  //must set ColorSchemeName separately
  //see http://www.devexpress.com/Support/Center/p/S20045.aspx
  dxRibbon1.ColorSchemeName := ASkinName;
  with TRegistry.Create do
  Try
    if OpenKey('\Software\Cat\ProgName',True) then Begin
      WriteString('SkinName',ASkinName);
      CloseKey;
    end;
  finally
    Free;
  end;
end;

Et dans le Main.OnFormShow :

with TRegistry.Create do
Try
  if OpenKey('\Software\Cat\Progname',False) then Begin
    DM.dxSkinController1.SkinName:=ReadString('SkinName');
    dxRibbon1.ColorSchemeName := DM.dxSkinController1.SkinName;
    CloseKey;
  end;
finally
  Free;
end;

• Déposer une TNxQuery (qXXX), un TNxCachedDataset (cXXX), un TDataSource (dsXXX) et un TNxSqlUpdateObject (uXXX).
• Rattacher le dsXXX à cXXX
• Rattacher qXXX à cXXX (champ cXXX.SourceDataSet)
• Rattacher uXXX à cXXX (champ cXXX.UpdateObject)
• Définir la requête qXXX.Text pour récupérer le contenu de la table
• Ajouter les champs persistants à qXXX et cXXX
• Si qXXX a une Datasource, définir un événement cXXX.AfterInsert et y placer :

===

procedure TFFicheContrat.cLienContratCategorieAfterInsert(DataSet: TDataSet);
begin
  cLienContratCategorieidcontrat.AsInteger:=fContratsId.Value;
end;

• Définir des requêtes pour uXXX

INSERT

INSERT INTO lienscontratscategories (idcontrat,idcategorie,abattement)
VALUES (:idcontrat,:idcategorie,:abattement)

MODIFY

UPDATE lienscontratscategories 
SET idcategorie=:idcategorie, abattement=:abattement
WHERE id=:id

DELETE

DELETE FROM lienscontratscategories WHERE id=:id

Les paramètres :zzz se rapportent à cXXX

• Ajouter une demande de confirmation de suppression dans cXXX.BeforeDelete :

#

procedure TFFicheContrat.cLienContratCategorieBeforeDelete(DataSet: TDataSet);
begin
  if (MessageDlg('Retirer cet abattement pour cette catégorie de ce support  ?', mtWarning, [mbYes, mbNo], 0) = mrNo) then
    Abort;
end;

Je viens de faire une découverte très intéressante :

procedure TForm1.Button1Click(Sender: TObject);
begin
  Try
    exit;
  Finally
    ShowMessage('Finally called !');
  End;
end;

Le message est affiché.

J’ai enfin un truc qui marche… Récapitulons.

Créer un utilisateur vmail qui opérera seul sur les fichiers de mail.

adduser vmail

Configurer vmail comme on veut. Noter ses UID/GID (ici 1009)

Configurer courier-mta normalement.

installer courier-authlib-postgresql :

apt-get install courier-authlib-postgresql

Modifier /etc/courier/authdaemonrc. Il faut avoir :

authmodulelist="authpam authpgsql"

et pour commencer :

DEBUG_LOGIN=1

Modifier aussi /etc/courier/authpgsqlrc. Les lignes importantes sont :

PGSQL_HOST              127.0.0.1
PGSQL_PORT              5432
PGSQL_USERNAME          postgres
PGSQL_PASSWORD

Créer une base de données (dans postgres) nommée mail par exemple avec la table passwd ayant la structure suivante :

CREATE TABLE passwd (
        id                    varchar(128) DEFAULT '' NOT NULL,
        crypt                 varchar(128) DEFAULT '' NOT NULL,
        clear                 varchar(128) DEFAULT '' NOT NULL,
        name                  varchar(128) DEFAULT '' NOT NULL,
        uid                   int DEFAULT 65534 NOT NULL,
        gid                   int DEFAULT 65534 NOT NULL,
        home                  varchar(255) DEFAULT '' NOT NULL,
        maildir               varchar(255) DEFAULT '' NOT NULL,
        defaultdelivery       varchar(255) DEFAULT '' NOT NULL,
        quota                 varchar(255) DEFAULT '' NOT NULL,
        CONSTRAINT id PRIMARY KEY (id)
);

Insérer un enregistrement de test dans la base :

INSERT INTO passwd (id,crypt,name,uid,gid,home) VALUES ('taste','$1$CY7vG$bjUINelvcc2niojOcDibQ.','taste account',1009,1009,'/home/mail/taste');

Le champ crypt est obtenu en utilisant la commande :

authpasswd

Ici, le mot de passe crypté est 123.

Vérifier que la connexion en socket TCP marche bien -sinon jeter un œil du côté de /etc/postgresql/ et notamment pg_hba.conf :

psql -h 127.0.0.1 -U postgres mail

À ce stade, on doit pouvoir s’authentifier et voir taste dans la liste des comptes :

# authenumerate |grep taste
taste   1009    1009    /home/vmail/taste

# authtest taste
Authentication succeeded.

     Authenticated: taste  (uid 1009, gid 1009)
    Home Directory: /home/vmail/taste
           Maildir: (none)
             Quota: (none)
Encrypted Password: $1$CY7vG$bjUINelvcc2niojOcDibQ.
Cleartext Password: (none)
           Options: (none)

Créer /home/vmail/taste :

mkdir -p /home/vmail/taste

Créer le .courier-default de ce compte. Par exemple :

echo './Maildir' >/home/vmail/taste/.courier-default

Créer ensuite un alias qui pointe vers notre taste :

echo '@gitenville.com: taste' >/etc/aliases/gitenville
makealiases

J’avais besoin de monitorer un serveur samba à distance (via ssh). Voilà une solution quick and dirty.

La machine à monitorer est milkpan.

Sur milkpan

Créer un script check_smb dans /usr/local/sbin sur milkpan :

#!/bin/sh
#set -x
# Nagios states
STATE_OK=0
STATE_WARNING=1
STATE_CRITICAL=2
STATE_UNKNOWN=3

# Variables for end
RESULT=""
EXIT_STATUS=${STATE_UNKNOWN}

PROGNAME=`/usr/bin/basename $0`
SMBCLIENT="/usr/bin/smbclient"
GREP="/bin/grep"

USER=''
PASS=''
DOMAIN=WORKGROUP

# -- function: end script with output
endscript () {   
        echo ${RESULT}
        exit ${EXIT_STATUS}
}

# -- function: usage of script
usage () {
        echo "\
Nagios plugin to check if user can authenticate to domain

Usage:
        ${PROGNAME} -H <host> -U <username> -P <password>
        ${PROGNAME} --help
"
}

while [ -n "$1" ] # true if first argument is non-null
do
        case $1 in
                --help | -h )
                        usage
                        exit ${STATE_OK};;
                -H )
                        shift
                        HOST=$1;;
                -U )
                        shift
                        USER=$1;;
                -P )
                        shift
                        PASS=$1;;
                * )
                        usage
                        exit ${STATE_UNKNOWN};;
        esac
        shift # if there is no shift, script will continue with host as null
done

if [ "$HOST" = "" -o "$USER" = "" -o "$PASS" = "" ]; then
        usage
        RESULT="Undefined parameter(s)";
        EXIT_STATUS=${STATE_UNKNOWN}
        endscript
fi

OUTPUT=`${SMBCLIENT} //${HOST}/homes -c "pwd" -U ${USER}%${PASS} -W ${DOMAIN}  2>&1 |${GREP} Domain=`
if [ "$?" -eq "0" ]
        then
                RESULT="OK Authentication successful on ${OUTPUT}"
                EXIT_STATUS=${STATE_OK}
        else
                RESULT="Authentication failed on ${DOMAIN}: ${OUTPUT}"
                EXIT_STATUS=${STATE_CRITICAL}
fi

endscript

Ce script est basé sur http://www.googlux.com/nagios_smbcheck.html

Définir le mot de passe pour nobody :

sudo smbpasswd nobody

Définir les droits pour ce script :

sudo chmod 755 /usr/local/sbin/check_smb

Sur la machine qui héberge le Nagios

Ajouter une commande :

define command {
        command_name    check_ssh_smb
        command_line    $USER1$/check_by_ssh -H $HOSTADDRESS$ -l $USER10$ -i ~/.ssh/id_rsa -C "/usr/local/sbin/check_smb -H $ARG1$ -U $ARG2$ -P $ARG3$"
}

Et un service qui utilise cette commande :

define service {
        service_description     samba
        use                     generic-service
        host_name               milkpan
        check_command           check_ssh_smb!10.8.0.1!nobody!MyPassW0rd
}

Les paramètres passés sont :

• 10.8.0.1 : le sous-réseau sur lequel écoute le samba sur cette machine
• nobody : l’utilisateur qui se connecte
• MyPassW0rd : son mot de passe

Tunnel SSH

ssh -N -R port_on_beta:desthost:destport user@beta

Crée un tunnel entre localhost et beta. Ce tunnel créera sur beta un process qui écoutera sur le port port_on_beta et forwardera l’ensemble, via localhost à desthost sur son port destport.

-N ne lance pas de commande (shell)

Exemple :

ssh -N -R 2222:monserveurderriereunfirewall:5432 cat@miaou

Sur miaou :

psql -h localhost -p 2222 -U user madb

Exemple en ssh pur :

ssh -N -R 8888:localhost:22 fred@miaou.thefreecat.org

Sur miaou :

ssh -p 8888 fred@127.0.0.1

Prendre le contrôle d’un pc à distance :

ssh -f -L 5900:localhost:5900 cat@miaou2.internal.thefreecat.org \
        x11vnc -ncache 10 -safer -localhost -nopw -once -display :0 \
        && sleep 2 \
        && vncviewer -encodings tight localhost:0

Référence : http://doc.ubuntu-fr.org/ssh

Continuer la lecture →

Un petit aide-mémoire pour ceux qui, comme moi, galèrent régulièrement avec les totaux/sous-totaux des cxGrid : tellement puissantes qu’on ne sait plus où trouver les choses. Continuer la lecture →