Ftp en perl et fichier corrompu

Le
Cedric.Revel
Bonjour a vous


Je sollicite votre aide pour un problème que je rencontre avec un
script perl pour faire du ftp.
Pour tout dire je connais pas du tout perl, c'est un collegue qui
s'est occupé de ca.

Le script s'occupe de faire des transfert ftp entre 2 serveurs ftp
windows.

Lorsque c'est des fichiers .txt, il n'y a pas de problème.
Par contre lorsque nous transférons des fichiers .pdf ou .zip, le
fichier destination est corrompu.
Je me suis rendu compte que les fichiers pdf par exemple était plus
grand.

En regardant dans le script, j'ai ajouté la ligne de code suivante

$ftp->binary();

Ca n'a rien changé, je m'en doutais un peu, les serveurs etant sur
windows tout les deux .

Merci d'avance pour votre aide
Vidéos High-Tech et Jeu Vidéo
Téléchargements
Vos réponses
Gagnez chaque mois un abonnement Premium avec GNT : Inscrivez-vous !
Trier par : date / pertinence
Paul Gaborit
Le #152314
À (at) Fri, 28 Sep 2007 02:02:14 -0700,
écrivait (wrote):
Le script s'occupe de faire des transfert ftp entre 2 serveurs ftp
windows.


Deux serveurs FTP ne peuvent pas se parler. En FTP, il y a toujours
une programme client (celui qui se connecte) et un programme serveur
(celui qui attend les connexion). À moins que vous n'utilisiez votre
script comme intermédiaire entre deux serveurs FTP (il est alors
client des deux serveurs).

Lorsque c'est des fichiers .txt, il n'y a pas de problème.
Par contre lorsque nous transférons des fichiers .pdf ou .zip, le
fichier destination est corrompu.
Je me suis rendu compte que les fichiers pdf par exemple était plus
grand.

En regardant dans le script, j'ai ajouté la ligne de code suivante

$ftp->binary();


Si l'objet $ftp est bien du type 'Net::FTP', c'est la bonne manière
d'indiquer qu'on souhaite faire des transferts en mode binaire (et
donc sans transformation).

Ca n'a rien changé, je m'en doutais un peu, les serveurs etant sur
windows tout les deux .


Effectivement, si les deux machines utilisent le même format de
fichier texte, les transformations des fins de ligne ne devraient rien
changer au contenu du fichier. Mais, les fichiers textes sous Windows
ont d'autres particularités (par exemple les caractères de fin de
fichiers) qui pourraient expliquer la corruption des fichiers binaires
transférés en mode texte. Dans tous les cas, le passage en mode
binaire ne peut qu'accélerer le transfert.

Bon, maintenant, si même en mode binaire, les fichiers sont encore
corrompus, c'est qu'il y a un problème ailleurs. Peut-être lors de la
lecture des fichiers... Les fichiers binaires ne se lisent pas comme
des fichiers textes (surtout sous Windows). Mais ma boule de cristal
est de très mauvaise qualité et ne me permet pas de voir votre code
pour y rechercher le bug... ;-)

--
Paul Gaborit - Perl en français -
espie
Le #152313
In article Paul Gaborit

À (at) Fri, 28 Sep 2007 02:02:14 -0700,
écrivait (wrote):
Le script s'occupe de faire des transfert ftp entre 2 serveurs ftp
windows.


Deux serveurs FTP ne peuvent pas se parler. En FTP, il y a toujours
une programme client (celui qui se connecte) et un programme serveur
(celui qui attend les connexion). À moins que vous n'utilisiez votre
script comme intermédiaire entre deux serveurs FTP (il est alors
client des deux serveurs).

Lorsque c'est des fichiers .txt, il n'y a pas de problème.
Par contre lorsque nous transférons des fichiers .pdf ou .zip, le
fichier destination est corrompu.
Je me suis rendu compte que les fichiers pdf par exemple était plus
grand.

En regardant dans le script, j'ai ajouté la ligne de code suivante

$ftp->binary();


Si l'objet $ftp est bien du type 'Net::FTP', c'est la bonne manière
d'indiquer qu'on souhaite faire des transferts en mode binaire (et
donc sans transformation).

Ca n'a rien changé, je m'en doutais un peu, les serveurs etant sur
windows tout les deux .


Effectivement, si les deux machines utilisent le même format de
fichier texte, les transformations des fins de ligne ne devraient rien
changer au contenu du fichier. Mais, les fichiers textes sous Windows
ont d'autres particularités (par exemple les caractères de fin de
fichiers) qui pourraient expliquer la corruption des fichiers binaires
transférés en mode texte. Dans tous les cas, le passage en mode
binaire ne peut qu'accélerer le transfert.

Bon, maintenant, si même en mode binaire, les fichiers sont encore
corrompus, c'est qu'il y a un problème ailleurs. Peut-être lors de la
lecture des fichiers... Les fichiers binaires ne se lisent pas comme
des fichiers textes (surtout sous Windows). Mais ma boule de cristal
est de très mauvaise qualité et ne me permet pas de voir votre code
pour y rechercher le bug... ;-)


Il faut regarder du cote info de debug. Je n'ai pas regarde Net::FTP *,
mais il est certainement possible de le passer en mode verbeux, et d'avoir
un transcript de toutes les informations echangees au niveau du controle du
FTP. Typiquement, le ->binary() devrait se voir comme envoi d'une commande
au serveur, et retour d'un code d'erreur du serveur.

On peut ensuite essayer de faire le meme transfert a la main, et noter les
differences.

Il y a plusieurs possibilites:
- soit c'est l'installation ftp qui deconne. -> se verifie a la main avec
un client ftp pas en perl.
- soit le script perl est buggue -> ca devrait se voir tres vite en mode
verbeux.
- on a un bug autre, dans Net::FTP ou son installation, et la ca va etre plus
dur.

Bonne chance, en tout cas.

*: un bref coup d'oeil a Net::FTP montre qu'effectivement, on peut passer
un parametre `debug' lors de la creation de la connexion.


Paul Gaborit
Le #152312
À (at) Fri, 28 Sep 2007 10:20:09 +0000 (UTC),
(Marc Espie) écrivait (wrote):
Il faut regarder du cote info de debug. Je n'ai pas regarde Net::FTP *,
mais il est certainement possible de le passer en mode verbeux, et d'avoir
un transcript de toutes les informations echangees au niveau du controle du
FTP. Typiquement, le ->binary() devrait se voir comme envoi d'une commande
au serveur, et retour d'un code d'erreur du serveur.

On peut ensuite essayer de faire le meme transfert a la main, et noter les
differences.


Ce sont de bons conseils.

Il y a plusieurs possibilites:
- soit c'est l'installation ftp qui deconne. -> se verifie a la main avec
un client ftp pas en perl.


C'est facile à vérifier mais si le serveur FTP fonctionne, j'imagine
que ce n'est pas qu'avec ce script Perl. Donc, le bug se serait déjà
manifester sur d'autres utilisations.

- soit le script perl est buggue -> ca devrait se voir tres vite en mode
verbeux.


Je pense que c'est l'explication la plus plausible. Et le mode debug
peut donner de bonnes informations (mais peut-être trop détaillées).

- on a un bug autre, dans Net::FTP ou son installation, et la ca va etre plus
dur.


Net::FTP n'est pas buggué (je l'utilise régulièrement sur de
nombreuses plateformes). Quant à un défaut d'installation... Cela me
semble assez peu crédible, d'autant que, sous windows, l'installation
à de grandes chances de passer par PPM (d'activestate) ou par cygwin.

--
Paul Gaborit - Perl en français -
Cedric.Revel
Le #152311
On 28 sep, 13:19, Paul Gaborit
À (at) Fri, 28 Sep 2007 10:20:09 +0000 (UTC),
(Marc Espie) écrivait (wrote):

Il faut regarder du cote info de debug. Je n'ai pas regarde Net::FTP *,
mais il est certainement possible de le passer en mode verbeux, et d'av oir
un transcript de toutes les informations echangees au niveau du control e du
FTP. Typiquement, le ->binary() devrait se voir comme envoi d'une comma nde
au serveur, et retour d'un code d'erreur du serveur.

On peut ensuite essayer de faire le meme transfert a la main, et noter les
differences.


Ce sont de bons conseils.

Il y a plusieurs possibilites:
- soit c'est l'installation ftp qui deconne. -> se verifie a la main av ec
un client ftp pas en perl.


C'est facile à vérifier mais si le serveur FTP fonctionne, j'imagine
que ce n'est pas qu'avec ce script Perl. Donc, le bug se serait déjà
manifester sur d'autres utilisations.

- soit le script perl est buggue -> ca devrait se voir tres vite en mode
verbeux.


Je pense que c'est l'explication la plus plausible. Et le mode debug
peut donner de bonnes informations (mais peut-être trop détaillées).

- on a un bug autre, dans Net::FTP ou son installation, et la ca va etr e plus
dur.


Net::FTP n'est pas buggué (je l'utilise régulièrement sur de
nombreuses plateformes). Quant à un défaut d'installation... Cela me
semble assez peu crédible, d'autant que, sous windows, l'installation
à de grandes chances de passer par PPM (d'activestate) ou par cygwin.

--
Paul Gaborit - Perl en français -

Nous avons fait des tests avec le client ftp de windows (ftp.exe), les
fichiers sont ok a l'arrivé.
Je vais essayer le mode 'debug' si je comprends comment cela
fonctionne ;)
La base du script a été pris d'un script nommé ftpmon je crois.

Merci pour vos réponses


Cedric.Revel
Le #152224
On 28 sep, 13:43, wrote:
On 28 sep, 13:19, Paul Gaborit




À (at) Fri, 28 Sep 2007 10:20:09 +0000 (UTC),
(Marc Espie) écrivait (wrote):

Il faut regarder du cote info de debug. Je n'ai pas regarde Net::FTP *,
mais il est certainement possible de le passer en mode verbeux, et d' avoir
un transcript de toutes les informations echangees au niveau du contr ole du
FTP. Typiquement, le ->binary() devrait se voir comme envoi d'une com mande
au serveur, et retour d'un code d'erreur du serveur.

On peut ensuite essayer de faire le meme transfert a la main, et note r les
differences.


Ce sont de bons conseils.

Il y a plusieurs possibilites:
- soit c'est l'installation ftp qui deconne. -> se verifie a la main avec
un client ftp pas en perl.


C'est facile à vérifier mais si le serveur FTP fonctionne, j'imagine
que ce n'est pas qu'avec ce script Perl. Donc, le bug se serait déj à
manifester sur d'autres utilisations.

- soit le script perl est buggue -> ca devrait se voir tres vite en m ode
verbeux.


Je pense que c'est l'explication la plus plausible. Et le mode debug
peut donner de bonnes informations (mais peut-être trop détaillée s).

- on a un bug autre, dans Net::FTP ou son installation, et la ca va e tre plus
dur.


Net::FTP n'est pas buggué (je l'utilise régulièrement sur de
nombreuses plateformes). Quant à un défaut d'installation... Cela me
semble assez peu crédible, d'autant que, sous windows, l'installation
à de grandes chances de passer par PPM (d'activestate) ou par cygwin.

--
Paul Gaborit - Perl en français -

Nous avons fait des tests avec le client ftp de windows (ftp.exe), les
fichiers sont ok a l'arrivé.
Je vais essayer le mode 'debug' si je comprends comment cela
fonctionne ;)
La base du script a été pris d'un script nommé ftpmon je crois.

Merci pour vos réponses- Masquer le texte des messages précédents -

- Afficher le texte des messages précédents -


Je vous poste le script que nous utilisons.
il scan des répertoires, verifie que les fichiers sont pas en cours de
modification et les transferts


Merci pour votre aide
Je vais continuer a chercher de mon coté

-------------DEBUT SCRIPT


use strict;
use warnings;

use vars qw( %Config %Monitor );

# FTPMon.pl
#
# 02/04/2007: version 1.1
# - si imprimante bloquée, passe à la suivante

use Win32::Daemon;
use Time::Local;
use Getopt::Long;
use Time::Hires qw(sleep);
use File::Basename;
use Win32::ChangeNotify;
use Data::Dumper;
use Net::FTP;

%Config = (
machine => Win32::NodeName(),
logfile => (Win32::GetFullPathName($0) =~ /^(.*).[^.]*
$/)[0].".log",
service_name => "ftpmon",
service_alias => "FTP labo",
service_sleep_time => 100,
show_debug => 1,
);

%Monitor = (

'Emission_resultat' => {
'monitor' => 'Repertoire_source',
'archive' => 'Repertoire_sourcearchive',
'command' => 'FTP adresse login pass',
'path' => 'Repertoire destination',
},


# par défaut
'timeout' => 15,
'command' => 'type {}',
);

my $Notify;
my $watchSubTree = 0;
my $events = "ATTRIBUTES|FILE_NAME|SIZE";

# -------------------------------------------------------------------
### Interception des signaux __WARN__ et __DIE__

local $SIG{'__WARN__'} = sub {
foreach my $m (@_) { Log("$m") }
Log("interception du signal __WARN__");
#die;
};

local $SIG{'__DIE__'} = sub {
foreach my $m (@_) { Log("$m") }
Log("interception du signal __DIE__");
exit(1);
};

# -------------------------------------------------------------------
### Interception des signaux SIG-INT et SIG-TERM

local $SIG{'INT'} = sub { Log("interception du signal SIG-INT") };
local $SIG{'TERM'} = sub { Log("interception du signal SIG-TERM") };

Configure(%Config);

if ($Config{install}) { InstallService(); exit(0) }
elsif ($Config{remove}) { RemoveService(); exit(0) }
elsif ($Config{start}) { StartService(); exit(0) }
elsif ($Config{stop}) { StopService(); exit(0) }
elsif ($Config{status}) { StatusService(); exit(0) }
elsif ($Config{help}) { Syntax(); exit(0) }

if (open(LOG, ">>$Config{logfile}")) {

my $BackupHandle = select(LOG);
$| = 1;
select($BackupHandle);

Log("-" x 55);
Log("Démarrage du service $Config{service_name}");
Log("PID: $$ ; Ordinateur: ".Win32::NodeName());
}

unless (Win32::Daemon::StartService()) {
Log("Impossible de démarrer le service $Config{service_name}");
Log("Erreur: ".GetError());
exit(1);
}

Log("Le service $Config{service_name} est en cours de démarrage...");

my $PrevState = SERVICE_START_PENDING;
my $LastRunTime = 0;

while (SERVICE_STOPPED != (my $State = Win32::Daemon::State()) ) {

if (SERVICE_START_PENDING == $State) { # Initialization code

foreach(sort keys %Monitor) {
if (ref($Monitor{$_}) eq 'HASH') {

unless ( exists($Monitor{$_}{monitor})
&& exists($Monitor{$_}{archive}) ) {
Log("-> suppression de $_ (paramétrage
incomplet)");
delete($Monitor{$_});
next;
}

unless (-d $Monitor{$_}{monitor}) {
Log("-> suppression de $_ (le répertoire n'existe
pas)");
delete($Monitor{$_});
next;
}

unless ($Monitor{$_}{command}) { $Monitor{$_}{command}
= $Monitor{command} }
unless ($Monitor{$_}{timeout}) { $Monitor{$_}{timeout}
= $Monitor{timeout} }

Log("-> démarrage de $_");
Log(" | monitor: ".($Monitor{$_}{monitor} || ''));
Log(" | archive: ".($Monitor{$_}{archive} || ''));
Log(" | command: ".($Monitor{$_}{command} || ''));
Log(" | timeout: ".($Monitor{$_}{timeout} || ''));

$Monitor{$_}{files} = {};
$Monitor{$_}{notify} =
Win32::ChangeNotify->new($Monitor{$_}{monitor},
$watchSubTree, $events);

GetDirContent($Monitor{$_}{monitor}, $Monitor{$_}
{files}, $Monitor{$_}{timeout});
}
}

Win32::Daemon::State($PrevState = SERVICE_RUNNING);
Log("Le service $Config{service_name} est démarré");

#Win32::Daemon::State($PrevState = SERVICE_STOPPED);
#Log("$Config{service_name} service could not get a process
list object: Aborting.");
#Log("Error: ".Win32::OLE->LastError());
}
elsif (SERVICE_PAUSE_PENDING == $State) { # Pausing...
Win32::Daemon::State($PrevState = SERVICE_PAUSED);
Log("Le service $Config{service_name} est en pause");
next;
}
elsif(SERVICE_CONTINUE_PENDING == $State) { # Resuming...
Win32::Daemon::State($PrevState = SERVICE_RUNNING);
Log("Le service $Config{service_name} n'est plus en pause");
next;
}
elsif (SERVICE_STOP_PENDING == $State) { # Stopping...

foreach(sort keys %Monitor) {
if (ref($Monitor{$_}) eq 'HASH') {
if (exists($Monitor{$_}{notify})) {
Log("-> arrêt de $_");
$Monitor{$_}{notify}->close();
}
}
}

Win32::Daemon::State($PrevState = SERVICE_STOPPED);
Log("Le service $Config{service_name} est en cours d'arrêt");
next;
}
elsif (SERVICE_RUNNING == $State) {

LOOP_MONITOR:
foreach my $mon (sort keys %Monitor) {
if (ref($Monitor{$mon}) eq 'HASH') {
if (exists($Monitor{$mon}{notify})) {

if ($Monitor{$mon}{notify}->wait(10)) {
$Monitor{$mon}{notify}->reset();
GetDirContent($Monitor{$mon}{monitor},
$Monitor{$mon}{files},
$Monitor{$mon}{timeout});
Log("[$mon]: -> liste des fichiers <-
n".Dumper($Monitor{$mon}{files}))
if $Config{'show_debug'};
}

my $nocut = 1;
my %count;
foreach (keys %{$Monitor{$mon}{files}}) {
$count{substr(basename($_), 0, 8)}++;
}

LOOP_ETIQU:
foreach my $f (sort keys %{$Monitor{$mon}{files}})
{
if ($Monitor{$mon}{files}{$f}-- <= 0) {

my $file = basename($f);

if (-f "$f") {

Log("[$mon]: [$file] début de
traitement du fichier")
if $Config{'show_debug'};

my $cmd = $Monitor{$mon}{command};
$cmd =~ s/{}/"$f"/g;
$cmd =~ s#/#\#g;

if ($cmd =~ m/^FTPs+(.+)s+(.+)s+(.+)
$/) {
unless (PutFTP($1, $2, $3, $f,
$Monitor{$mon}{path})) {
Win32::Sleep(5000);
next LOOP_MONITOR;
}
Log("[$mon]: [$file] transféré
vers 'ftp://$2:$3@$1'");
Win32::Sleep(250);
}
else {
Log("[$mon]: [$file] exécution de
la commande |$cmd|");
#system("$cmd >NUL");
#Log("(debug) $cmd >NUL");
}

if ($Monitor{$mon}{archive}) {
Log("[$mon]: [$file] archivage du
fichier")
if $Config{'show_debug'};
my $cmd = "move "$f" "
.""$Monitor{$mon}{archive}
".basename($f).""";
$cmd =~s#/#\#g;
system("$cmd >NUL");
#Log("(debug) $cmd >NUL");
}
else {
Log("[$mon]: [$file] suppression
du fichier")
if $Config{'show_debug'};
unlink($f);
}

Log("[$mon]: [$file] fin de traitement
du fichier")
if $Config{'show_debug'};
}
else { Log("[$mon]: le fichier "$f" est
introuvable") }

delete $Monitor{$mon}{files}{$f};
next;
}
}

}
}
}

#Win32::Sleep(50);
}
else {
Win32::Daemon::State($PrevState);
}
Win32::Sleep($Config{service_sleep_time});
}

Log("Le service $Config{service_name} est arrêté");
Win32::Daemon::StopService();
Log("Arrêt du service $Config{service_name}");
CloseLog();

exit(0);

sub Log {
my $Message = shift;
print LOG "[".localtime()."] $Messagen" if fileno(LOG);
print "[".localtime()."] $Messagen" unless fileno(LOG);
}

sub CloseLog {
close(LOG) if fileno(LOG);
}

sub InstallService {
my $ServiceConfig = GetServiceConfig();
if (Win32::Daemon::CreateService($ServiceConfig)) {
print "Le service $ServiceConfig->{display} à été installé n";
}
else {
print "Impossible d'installer le service $ServiceConfig-
{display}n",
"Erreur: ".GetError()."n";

}
}

sub RemoveService {
my $ServiceConfig = GetServiceConfig();
if (Win32::Daemon::DeleteService($ServiceConfig->{name})) {
print "Le service $ServiceConfig->{display} à été supprimé n";
}
else {
print "Impossible de supprimer le service $ServiceConfig-
{display}n",
"Erreur: ".GetError()."n";

}
}

sub StartService {
print "Démarrage du service $Config{service_name} en cours";

}

sub StopService {
print "Arrêt du service $Config{service_name} en cours";

}

sub StatusService {
print "Etat du service $Config{service_name}: ...";

}

sub GetDirContent {
my ($dir, $files, $timeout) = @_;

return 0 unless -e $dir;
return 0 unless -d $dir;

return 0 unless opendir(DIR, $dir);
my @content = grep !/(?:^.$)|(?:^..$)/, readdir DIR;
closedir DIR;

foreach (@content) { $files->{"$dir\$_"} = $timeout if -f "$dir\
$_" };
return 1;
}

sub PutFTP {
my ($host, $user, $pass, $fsrc, $path) = @_;


my $ftp;

unless (-f "$fsrc") {
Log("PutFTP: Impossible d'ouvrir le fichier '$fsrc'");
return 1;
}

local $SIG{'__WARN__'} = sub { return 0 };
local $SIG{'__DIE__'} = sub { return 0 };

{
$ftp = Net::FTP->new($host, Debug => 1, Passive => 0, Timeout
=> 5 )
or Log("PutFTP: Impossible de se connecter à '$host':
$@"), return 0;

$ftp->login($user, $pass)
or Log("PutFTP: Impossible de se logguer '$user': ".$ftp-
message), return 0;


$ftp->binary();

$ftp->cwd($path) if defined($path);

$ftp->put($fsrc)
or Log("PutFTP: Impossible de transférer le fichier
'$fsrc': ".$ftp->message), return 0;

$ftp->quit();
}

return 1;
}

sub GetServiceConfig {
my $ScriptPath = join("", Win32::GetFullPathName($0));
my %Hash = (
name => $Config{service_name},
display => $Config{service_alias} || "FTP",
path => $^X,
user => $Config{user} || "./Login",
pwd => $Config{password} || "Password",
description => "Emission des fichiers par FTP demande labo.",
parameters => ""$ScriptPath""
);
$Hash{display} .= " ($Hash{name})";
return(%Hash);
}

sub GetError {
return(Win32::FormatMessage(Win32::Daemon::GetLastError()));
}

sub Configure
{
my $Config = shift;
my $Result;
Getopt::Long::Configure("prefix_pattern=(-|/)");
$Result = GetOptions($Config,
qw( install|i remove|r
machine|m=s user|u|a|account=s password=s
service_name|n=s service_alias|d=s
logfile|l=s help
start stop status )
);
$Config->{help} = 1 unless $Result;
$Config->{machine} =~ s/[\/]//g;
}

sub Syntax {
my ($Script) = ($0 =~ /([^\]*?)$/);
my $Whitespace = " " x length($Script);
print<< "EOT";

Syntax:
$Script [-install [-account Account] [-password Password] [-l
LogFile]
[-m Machine] [-n Name]]
$Whitespace [-remove [-n Name]]
$Whitespace [-help]

-install...........Installs the service.
-account...........Specifies what account the service runs under.
Default: Local System
-password..........Specifies the password the service uses.
-l LogFile.........Specifies the path where the log should be
created.
-m Machine.........The machine to be monitored. You must specify
an
account that has administrative permissions on
the remote machine.
-n Name............Specifies a name for the service.
-proctime Time.....Time in seconds indicating how often to check
the process list for any to terminate.
-remove............Removes the service. If the service was
installed
specifying a name (using -n) then use the -n
option
when removing the service.
-help..............Display the help screen.

EOT
}

END
{
#Log("Le service $Config{service_name} s'est arrêté de façon
inattendue");
CloseLog();
}

__END__



Paul Gaborit
Le #152223
À (at) Fri, 28 Sep 2007 05:54:46 -0700,
écrivait (wrote):
Je vous poste le script que nous utilisons.
il scan des répertoires, verifie que les fichiers sont pas en cours de
modification et les transferts


Après un coup d'oeil rapide, il semble correctement écrit. L'appel à
'binary' est au bon endroit. Les tests de bonne exécution des
commandes sont bien faits. Tel quel je ne vois pas pourquoi ça ne
fonctionnerait pas.

Quelle version de Perl utilisez-vous ? Une 5.8.8 ?
Quelle version de Net::FTP ? La dernière version est la 2.77.

--
Paul Gaborit - Perl en français -
Cedric.Revel
Le #152222
On 28 sep, 18:09, Paul Gaborit
À (at) Fri, 28 Sep 2007 05:54:46 -0700,
écrivait (wrote):

Je vous poste le script que nous utilisons.
il scan des répertoires, verifie que les fichiers sont pas en cours de
modification et les transferts


Après un coup d'oeil rapide, il semble correctement écrit. L'appel à
'binary' est au bon endroit. Les tests de bonne exécution des
commandes sont bien faits. Tel quel je ne vois pas pourquoi ça ne
fonctionnerait pas.

Quelle version de Perl utilisez-vous ? Une 5.8.8 ?
Quelle version de Net::FTP ? La dernière version est la 2.77.

--
Paul Gaborit - Perl en français -

Bonjour a vous

Je vous donne des nouvelles de mon problème.
J'ai trouvé l'erreur.
J'avais oublié un binary() sur un 2nd script et j'avais complètement
oublié que les fichiers passé dans ce script.
Merci pour votre aide quand meme


Paul Gaborit
Le #152221
À (at) Mon, 01 Oct 2007 07:00:52 -0700,
écrivait (wrote):
Je vous donne des nouvelles de mon problème.
J'ai trouvé l'erreur.
J'avais oublié un binary() sur un 2nd script et j'avais complètement
oublié que les fichiers passé dans ce script.
Merci pour votre aide quand meme


Et bien, vous pourrez dire que vous nous aurez fait chercher... en
vain !

La prochaine fois, repensez à cette histoire. ;-)

--
Paul Gaborit - Perl en français -
Publicité
Poster une réponse
Anonyme