Le serveur de fichiers d'AVG offre la protection contre les virus pour des serveurs de fichiers de linux et de FreeBSD. Protection de garantie contre des virus, des vis sans fin et des Trojan pour des serveurs de fichiers de linux et de FreeBSD, indépendamment des charges de travail.

Installation et lancement

AVG 7.5 pour des modules d'installation de Linux/FreeBSD sont fournis comme dossiers de T/MN ou de DEB, ou comme ensemble de mesures de tar.gz.

Pour l'installation à partir du dossier de T/MN (Linux seulement), employer la commande suivante dans votre interpréteur de commandes interactif (accessible par exemple using l'application de xterm dans votre système d'hublot de X).

# T/MN - I avg75lms- {desserrage} - {version de vdb} .i386.rpm

Pour l'installation à partir du dossier de .deb (Linux seulement), employer la commande suivante dans votre interpréteur de commandes interactif (accessible par exemple using l'application de xterm dans votre système d'hublot de X).

# dpkg - I avg75lms- {desserrage} - {version de vdb} .i386.deb

Pour l'installation de l'ensemble de mesures de .tar.gz, employer les commandes suivantes (dans le répertoire où l'ensemble de mesures est localisé) d'éclater son contenu, changer le répertoire et puis exécuter finalement la séquence type de montage (comme fond). Pour linux procéder à ces opérations :

# xzvf avg75lms- {desserrage} de goudron - {version de vdb} .i386.tar.gz
# avg7-linux cd
# ./install.sh

Vous serez alors offert la chance d'enregistrer votre logiciel. Vous pouvez le faire maintenant ou plus tard (voir l'enregistrement de produit du chapitre 3.3). Pour le FreeBSD procéder à ces opérations :

# xzvf avg75fms- {desserrage} de goudron - {version de vdb} .i386.tar.gz
# avg7-freebsd cd
# ./install.sh

Vous serez alors offert la chance d'enregistrer votre logiciel. Vous pouvez le faire maintenant ou plus tard (voir l'enregistrement de produit du chapitre 3.3). Note : Les dossiers de régime de l'AVG 7.5 pour les versions 11 de Linux/FreeBSD et plus vieux sont montés sur le répertoire de /usr/local/lib/avg7. Même si vous exécutez la pleine mise à jour d'une version plus ancienne de votre AVG, la structure de répertoire demeure la même (assurant ascendant la compatibilité). Cependant, tous les éléments essentiels d'AVG
7.5 pour Linux/FreeBSD sont toujours mis à jour correctement pour t'offrir la sécurité maximale et la fiabilité.

Les versions 12 et plus neuf sont globalement montées sur le répertoire de /opt/grisoft. Des tiges symboliques sont produites dans divers répertoires système, menant au sous-arbre de répertoire de /opt/grisoft. Si vous voulez améliorer la vieille structure de répertoire, vous devez complet réinstaller votre AVG 7.5 pour Linux/FreeBSD. Noter cela dans cette documentation est toujours décrit l'emplacement plus neuf preferred d'AVG 7.5 pour
Installation de Linux/FreeBSD !

Le dossier est l'application de source ouverte de la commande de dossier utilisée sur presque chaque système d'exploitation libre (OpenBSD, Linux, FreeBSD, NetBSD) et également sur les systèmes qui emploient le logiciel gratuit (OS/2 y compris, DOS, MS Windows, etc.).

La commande de dossier, si au courant de youre pas de elle, est un outil de ligne de commande qui vous indique dans les mots ce qu'un peu la caractéristique un dossier contient. À la différence du MS-WINDOWS, l'UNIX et d'autres systèmes ne se fondent pas sur des extentions de nom de fichier pour vous indiquer que le type d'un dossier, mais regardent le contenu réel de dossiers. C'est, naturellement, plus fiable, mais exige un morceau d'E/S.

La commande originelle de dossier expédiée avec les Laboratoires Bell UNIX mais était indisponible sous la forme source aux masses avant reimplementation d'Ians.

Cette commande de dossier (et dossier magique) ont été initialement sauvés par Ian Darwin (qui contribue toujours de temps en temps) et sont maintenant mis à jour par un groupe de développeurs aboutissent par Christos Zoulas.

Whos using lui ?

Chaque distribution connue de schéma (FreeBSD, NetBSD, OpenBSD, Darwin/Mac OS X, etc.)
Chaque distribution linux connue
Le module mod_mime_magic de serveur de httpd d'Apache utilise les intestins de commandes de dossier pour effectuer le type de fichier estimant un httpd de dessous plus fiable d'Apache.

le navigateur de fichiers de jsp est un facile à utiliser et facile de monter la page de serveur de Java d'explorateur de fichiers. Ce régime de JSP permet l'accès et la manipulation basés sur le WEB lointains de dossier.

Voici quelques fonctionnalités clé de « navigateur de fichiers de jsp » :

· Produire, copier, déplacer, renommer et effacer les dossiers et les répertoires
· Voir les dossiers (illustrations, films, pdf, HTML,…)
· Éditer les fichiers texte
· Télécharger les dossiers au serveur (le mode par l'intermédiaire du moniteur de téléchargement)
· fichiers téléchargés du serveur
· Télécharger les ensembles de fichiers et les dépliants comme fichier zip unique qui est produit en marche
· Accomplir les commandes spécifiques sur le serveur (par exemple LS, le goudron, le chmod,…)
· Voir les entrées et éclater les dossiers de fermeture éclair, de choc, de guerre et de gz sur le serveur
· Juste un dossier, très facile à monter (en fait, le copier juste au serveur)
· Disposition personnalisable par l'intermédiaire de dossier de CSS
· Limiter l'accès de dossier par l'intermédiaire du noir ou du whitelist

Il devrait fonctionner avec n'importe quel serveur JSP1.1 compatible (par exemple Tomcat>=3.0), je l'a vérifié sur Tomcat 4.0, la résine 2.1.7 et la jetée.

Ce qu'il y a de neuf dans ce desserrage :

· Une version en lecture seule a été ajoutée.
· Elle est maintenant également utilisable comme téléchargement-centre.
· Des perfectionnements d'un certain UI ont été effectués, comme des shortkeys et une meilleure disposition.
· Il devrait également charger un peu plus rapidement.

le projet de file*HANDLER est principalement un script Perl qui combine quelques ensembles de mesures libres de conversion de médias (cités plus tard) avec un serveur accédant de parties terminales de PostgreSQL pour répertorier et servir la binaire et les fichiers texte dirigent de la base de données. Un dossier simple de cgi avec AJAX encastré fait des appels à ce serveur qui recherche également continuellement l'autre serveur sur Internet vivant de f*H.

Depuis le serveur cache des médias dans la base de données SQL sur demande, car le réseau se développe, le réseau s'améliore.

Son partage à carroyage de répertoire/furetage/recherchant avec le streaming audio/vidéo aussi bien que le texte plat/Doc./pdf/étalage d'image chacun. Son sauvé avec quelques crochets pour les étiquettes qui seraient comprises en votre frontpage réel de sorte que l'UI soit jeter-capable -- n'importe qui peut rapidement récrire [le GT] un UI neuf entier sans devoir s'inquiéter de la syntaxe de la version la plus neuve de dojo.licio.r ou quoi que.

Si vous vouliez ignorer les crochets de JS/HTML/CSS puis vous pouvez facilement employer le système pour effectuer les demandes directes que juste les listes de renvoi ont formatées comme tableau-fuselages de HTML. En d'autres termes, le marge bénéficiaire bénéficiaire EST le marge bénéficiaire bénéficiaire.

En soi, Ive a fouetté vers le haut d'un gadget du Dojo 0.2 qui combine la partie postérieure de portion avec un UI ainsi n'importe qui peut inclure la fonctionnalité de f*H n'importe où, ou personnaliser facilement une page de défaut fournie.

Un serveur de file*HANDLER est réellement quelques composantes Ive attaché pour vous (le sommet avalent) :

· Un page Web local fournissant l'UI (servi par un serveur HTTP de votre choix) qui est produit par une séquence type de cgi avec AJAX encastré.
· Une partie secondaire du même script CGI, agissant en tant que logiciel personnalisé, qui communique, par l'intermédiaire d'AJAX, avec le frontpage local pour réconcilier des demandes asynchrones de Javascript avec la partie postérieure de sous-réseau de file*HANDLER.
· Un serveur du réseau illimité sauvé dans Perl qui sert au front et l'extrémité communique transversal avec chacun le serveur de Perl de partie postérieure de file*HANDLER d'elses supplémentaire, il manage l'indexation des répertoires contents que vous choisissez de servir.
· Une base de données de PostgreSQL qui est consultée seulement par l'intermédiaire des sous-programmes internes de Perl a appelé de votre frontpage.

Tellement par exemple, un utilisateur distant vient à votre site. D'abord, non seulement peuvent ils parcourir et rechercher vos dossiers, mais ils peuvent également parcourir et rechercher les dossiers de n'importe qui accueillant autrement un serveur de file*HANDLER que votre serveur local connaît. (le file*HANDLER recense d'autres serveurs sur le réseau automatiquement). L'usager peut maintenant s'afficher/vue/écoute/montre par le flot n'importe quel contenu qu'ils trouvent du serveur de whomevers. Therese aucun téléchargement, ainsi partage tellement réel de therese, juste couler direct au programme de lecture d'usagers.

VFU est gestionnaire de console (mode texte) pour UNIX/Linux.

Pendant les années j'ai essayé d'effectuer la liste de fonctionnalités attrayante courte que VFU a. Attrayant comme annonçant ci-avant :) et il ne semble pas le fonctionner… au moins n'a pas fait pour moi et je ne l'ai jamais aimé.

J'ai rendu tous possibles d'effectuer à cache de VFU toutes les nécessités de management de dossier et d'offrir le grand ensemble d'options de comportement. Si je réussissais ou pas, vous pouvez décider pour vous-même mais sans essayant moi crois que personne ne peuvent dire à coup sûr.

Installation :

1. comment compiler le vfu

le `de passage effectuent à partir du répertoire de base de vfu

ceci devrait compiler tout

pour compiler chaque partie de vfu faire manuellement ceci :

-- aller au répertoire de vslib de `
-- le `de passage effectuent
-- aller au répertoire de vfu de `
-- le `de passage effectuent

si quelque chose va mal, vérifier ces derniers :

-- si votre emplacement du fichier du `curses.h n'est pas le `/usr/include/ncurses
vous devez changer ceci dans le fichier makefile.

-- si la bibliothèque de vslib n'est pas dans le `. répertoire de /vslib vous également
doivent changer ceci dans le fichier makefile.

2. comment monter le vfu

le `de passage montent la séquence type à partir du répertoire de base de vfu

monter les vérifications de séquence type si tous les dossiers required sont procurables/établis et puis fait ceci :

cp vfu/vfu rx/rx_* /usr/local/bin
cp vfu.1 /usr/local/man/man1
cp vfu.conf /usr/local/etc

3. comment monter le vfu manuellement

-- vous devez copier le vfu de `dans le `/usr/local/bin ou
répertoire du `/usr/bin et mode de jeu au rwxr-xr-x de 755 `
le propriétaire n'est pas significatif (le fond est également possible).

-- il y a la page de manuel préliminaire (vfu.1) qui pourrait être
copié à /usr/man/man1.

-- copier tous les outils du `rx/rx_* à /usr/local/bin
-- monter le réseau : : Module de Perl de ftp si eu besoin.
(ceci est employé pour le support de ftp)

ALERTE : veiller à retirer tous les vieux dossiers personnels de cache !

Le putter mince de dossier est un télépartageur MIS de dossier de méthode. Le putter mince de dossier se sert de la méthode MISE PAR HTTP pour transférer des dossiers au web server. Traditionnellement des dossiers sont téléchargés using le GOUJON de HTTP. La méthode de GOUJON cependant n'est pas specifcally conçue pour le téléchargement de dossier mais la méthode MISE est.

le putter de dossier de putterThin est un télépartageur de dossier multiple avec des capacités glissers-déposers. Il manifestera un moniteur de progrès tandis que le transfert est en cours et reprend des téléchargements interrompus.

Avec la méthode MISE, des dossiers multiples sont téléchargés pendant qu'ils sont sans les combiner d'abord dans un message de MIME. Comme résultat aucun se traduire de côté serveur n'est exigé.

La séquence type de téléchargement affiche simplement le train d'entrées et sauve les caractéristiques au disque dur.
Le putter mince de dossier est une solution en travers de plate-forme, il peut être employé pour télécharger les dossiers très grands à n'importe quel web server qui supporte la méthode MISE.

Ce qu'il y a de neuf dans le desserrage 1.0.2 stable :

· Corrige un bogue qui a eu comme conséquence l'applet représentant mal le dossier téléchargé comme en tant que zéro à certaines occasions.

Ce qu'il y a de neuf dans le bêta desserrage du développement 2.00 :

· Un moniteur neuf de progrès a été ajouté, et des caractéristiques de configuration peuvent être directement incluses dans le page Web qui contient l'applet (au lieu de cela using un fichier de configuration).
· Des dérouleurs de côté serveur de Perl ont été améliorés.

Dossier : : FilterFuncs est un module de Perl qui spécifient des fonctionnements de filtre pour des dossiers.

SYNTHÈSE

dossier d'utilisation : : Qw de FilterFuncs (filtres) ;

filtres (source.txt,
sous-marin {_ de $ = uc $_ ; 1},
dest.txt
) ;

INTRODUCTION

Dossier : : FilterFuncs le rend facile d'exécuter des transformations sur des dossiers. Quand vous utilisez ce module, vous spécifiez un groupe de fonctionnements de filtre qui exécutent des transformations sur les lignes dans un fichier source. Ces lignes transformées sont sauvées au dossier de destination que vous spécifiez. Par exemple, ce code convertit un fichier complet en haut de casse, ligne par ligne :
dossier d'utilisation : : Qw de FilterFuncs (filtres) ;

filtres (source.txt,
sous-marin {_ de $ = uc $_ ; 1},
dest.txt
) ;

Le « 1 » à la fin de la sous-routine de filtre indique des filtres maintenir toutes les lignes. La sous-routine de filtre devrait renvoyer 1 pour toutes les lignes qui devraient être maintenues, et elles devraient renvoyer 0 pour n'importe quelles lignes qui devraient être ignorées. Ce régime copie seulement les lignes qui contiennent quelque chose sans compter que juste le whitespace :

dossier d'utilisation : : Qw de FilterFuncs (filtres) ;

filtres (source.txt,
sous-marin {/S/},
dest.txt
) ;

Le fichier source entier n'est pas affiché dans la mémoire. Au lieu de cela on l'affiche une ligne à la fois, et le dossier de destination est sauvé une ligne à la fois.

Juste comme le concept de Perls d'une ligne peut être changé en réglant le $, ainsi l'idée de fonctionnements de filtres d'une ligne peut également être changé en spécifiant une valeur pour le $ dans l'appel en filtres :

mon $pad = « « x 2 ;
filtres (source.dat,
$ de => 1022,
sous-marin {_ de $. = $pad ; 1},
dest.dat
) ;

Des fonctionnements de filtre sont invoqués dans la commande dans laquelle ils sont vus. Les supérieur-boîtiers de ce code alors met les parenthses intérieurs chaque ligne dans source.txt et copie la sortie à dest.txt :

filtres (source.txt,
sous-marin {_ de $ = uc $_ ; 1},
sous-marin {chomp $_ ; $ de _ = « ($_) n » ; 1},
dest.txt
) ;

Évidemment, la ligne en cours qui est fonctionnée en circuit est dans $_.

La sous-routine de filtres s'attend à ce que son premier argument soit le nom du fichier source, et le dernier argument devrait être le nom du dossier de destination. Les filtres de fonctionnement mourront si ou un des noms de dossier est manquant ou s'ils sont inaccessibles.

OPTIONS

Quelques options déterminent comment la sous-routine de filtres fonctionne.

binmode

Binmode vous laisse spécifier une couche à employer pour les caractéristiques d'entrée. Par exemple, ceci affichera un dossier utf-8 et sauver les caractéristiques using la sortie de défaut posent :

filtres (
source.txt,
=> de binmode : utf8,
dest.txt,
) ;

boutmode

Boutmode laisse le programmeur spécifier une couche à employer pour sauver les caractéristiques de sortie. Par exemple, ce code sur une plateforme linux devrait afficher des caractéristiques des textes using la fin de ligne format de linux et les sauver using la fin de ligne format de DOS (CRLF) :

filtres (
source.txt,
=> de boutmode : crlf,
dest.txt,
) ;
$

Régler le $ vous laisse déterminer comment une fin de ligne est identifiée. Régler cette option à la même valeur que vous régleriez le $ variable dedans à un régime. Par exemple, supposer qu'un dossier contienne ceci :

ABCDEFGHIJKL

Le régime suivant devrait sauver trois lettres à la fois au dossier de sortie :
filtres (

source.txt,
$ de => 3,
sous-marin {_ de $ = « $_n » ; 1},
dest.txt,
) ;

NOTES

Nom de fonctionnement alterne

Si vous considérez le nom de fonctionnement filtre pour être trop générique, vous peut importer les filter_funcs nommés au lieu.

Valeurs de renvoi de commodité

Pour la commodité de programmeurs et pour faciliter le code autoexplicatif, les valeurs $KEEP_LINE et $IGNORE_LINE peuvent être exportés. Comme exemple, c'est un autre régime à filtrer à l'extérieur raye contenir seulement le whitespace :

dossier d'utilisation : : Qw de FilterFuncs (filtres $IGNORE_LINE) ;

filtres (source.txt,
sous-marin {$IGNORE_LINE de renvoi à moins que /S/},
dest.txt
) ;

Dossier : : PM2File - périmé. Dossier d'usager : : Là où

SYNTHÈSE

file_in_include () # périmé. Remplacer par le dossier : : Là où : : là où ()
pm2file () # périmé. Remplacer par le dossier : : Là où : : where_pm ()
pm2require () # périmé. Remplacer par le dossier : : Là où : : pm2require ()

$File : : PM2File : : warn_obsolete = 1 ; # allume l'alerte périmée

CONDITIONS

Le dossier : : Les subrouitnes de PM2File non utilisé.
Le dossier : : Des sous-routines de PM2File seront remplacées par le dossier approprié : : Là où sous-routine chaque fois qu'un dossier : : La sous-routine de PM2File a besoin de mise à jour comme suit :

Dossier : : PM2File : : dossier de find_in_include () : : Là où : : là où ()
Dossier : : PM2File : : dossier de pm2file : : Là où : : where_pm ()
Dossier : : PM2File : : dossier de pm2require : : Là où : : pm2require

NOTE : Le dossier de sous-routine : : Là où : : là où est presque un direct relâcher dedans pour le dossier : : PM2File : : find_in_include (). La différence est dans un dossier de contexte de choix : : Là où : : là où () renvoie un troisième organe où dossier : : PM2File : : renvois deux de find_in_include () seulement. Les deux premiers organes, bien que, sont identiques.

Dossier : : MMagic est un module de Perl pour estimer le type de fichier.

SYNTHÈSE

dossier d'utilisation : : MMagic ;
employer FileHandle ;

$mm = dossier neuf : : MMagic ; # dossier magique interne d'utilisation
# $mm = dossier : : MMagic->new (/etc/magic) ; # dossier magique externe d'utilisation
# $mm = dossier : : MMagic->new (/usr/share/etc/magic) ; # si vous employez Debian
$res = $mm->checktype_filename (« /somewhere/unknown/file ») ;

$fh = FileHandle neuf « < /somewhere/unknown/file2 » ;
$res = $mm->checktype_filehandle ($fh) ;

$fh->read ($data, 0x8564) ;
$res = $mm->checktype_contents ($data) ;

Dossier : : AnySpec est un module de Perl pour exécuter des fonctionnements sur des noms (lointains) étrangers de dossier.

SYNTHÈSE

# surface adjacente de sous-routine
#
dossier d'utilisation : : Qw d'AnySpec (14h de fspec de fspec_glob de fspec2fspec pm2fspec os2fspec fspec2os) ;

$file = fspec2fspec ($from_fspec, $to_fspec $fspec_file, [$nofile])
$os_file = fspec2os ($fspec, $file, [$no_file])
$fspec_file = os2fspec ($fspec, $file, [$no_file])

14h de $pm = de fspec ($fspec, $require_file)
($abs_file, $inc_path, $require_file) = pm2fspec ($fspec, $pm)

@globed_files = fspec_glob ($fspec, @files)


# surface adjacente de cours
#
dossier d'utilisation : : AnySpec
employer le qw de vars (le @ISA)
@ISA = qw (dossier : : AnySpec)

$file = __PACKAGE__->fspec2fspec ($from_fspec, $to_fspec $fspec_file, [$nofile])
$os_file = __PACKAGE__->fspec2os ($fspec, $file, [$no_file])
$fspec_file = __PACKAGE__->os2fspec ($fspec, $file, [$no_file])

14h de $pm = de __PACKAGE__->fspec ($fspec, $require_file)
($abs_file, $inc_path, $require_file) = __PACKAGE__->pm2fspec ($fspec, $pm)

@globed_files = __PACKAGE__->fspec_glob ($fspec, @files)

Les méthodes en cet ensemble de mesures, exécutent des fonctionnements sur des caractéristiques de dossier pour des systèmes d'exploitation autre puis le site actuel du système d'exploitation. La variable d'entrée $fspec indique aux méthodes en cet ensemble de mesures le cahier des charges de dossier pour des noms de dossier utilisés comme entrée aux méthodes. Ainsi, en employant des méthodes en cet ensemble de mesures, la méthode peut charger jusqu'à deux liment : : Les méthodes de sous-modules de Spéc. et ni l'un ni l'autre de elles n'est un sous-module pour le site actuel du système d'exploitation.

Dossier : : L'utilisation est un dossier facile, polyvalent, portatif traitant le module.

Dossier : : L'utilisation fournit un coffre à outils global d'utilitaires pour automatiser toutes sortes de fonctionnalités usuelles sur le dossier/répertoires. Son but est de faire ainsi de la façon la plus portative possible de sorte que les usagers de ce module ne doivent pas s'inquiéter de si leurs régimes fonctionnent sur d'autres OSes et machines.

SYNTHÈSE

dossier d'utilisation : : Utilisation ;
mon ($f) = dossier : : Util->new () ;

mon ($content) = $f->load_file (foo.txt) ;

=~ s/this/that/g de $content ;

$f->write_file (
=> bar.txt de dossier,
=> content $content,
=> 0644 de bitmask
) ;

$f->write_file (
=> file.bin, => content $binary_content de dossier, --binmode
) ;

mon (@lines) = $f->load_file (randomquote.txt, --comme-lignes) ;
mon ($line) = international (RAND (@lines scalaires));

impression $lines [$line] ;

mon (@files) = $f->list_dir (/var/tmp, qw/ --dossiers-seulement --recurse/) ;
mon (@textfiles) = $f->list_dir (/var/tmp, --pattern=.txt$) ;

si ($f->can_write (wibble.log)) {

mon ($HANDLE) = $f->open_handle (
=> wibble.log de dossier,
le => de mode ajoutent
) ;

monde de l'impression $HANDLE « bonjour ! Son », localtime scalaire ;

$HANDLE proche
}

mon ($log_line_count) = $f->line_count (/var/log/httpd/access_log) ;

estamper « mon dossier a un bitmask de ». $f->bitmask (my.file) ;

estamper « mon dossier est ». joindre (, $f->file_type (my.file)). « dossier. »

avertir que ce dossier est binaire ! si $f->isbin (my.file) ;

estamper « mon dossier était Last modified sur ».
localtime scalaire ($f->last_modified (my.file));

#… et _lots_ davantage

Dossier : : BasicFlock est un module de Perl pour le verrouillement de fichier avec la bande.

SYNTHÈSE

dossier d'utilisation : : BasicFlock ;

blocage ($filename) ;

blocage ($filename, partagé) ;

blocage ($filename, undef, non groupants) ;

blocage ($filename, partagé, non groupant) ;

débloquer ($filename) ;

Verrouiller les dossiers using l'appel de bande (). Le dossier à verrouiller doit déjà exister. C'est très une surface adjacente de chose.

Dossier : : La carte de remplacement est un module de Perl pour le traitement amélioré de goutte.

SYNTHÈSE

dossier d'utilisation : : Carte de remplacement ;
mon $foo = dossier : : Wildcard->new (=> « /home/me///core » de circuit) ;
tandis que (mon $file = $foo->next) {
séparer/$file ;
}

En regardant la façon dont les divers systèmes d'exploitation font l'expansion de carte de remplacement de nom de fichier (globbing), le VMS a une syntaxe gentille qui permet l'expansion et la recherche des arborescences des répertoires entières. Il serait gentil si d'autres systèmes d'exploitation avaient n'importe quoi de pareil incorporés. Meilleur Unix peut manager est par la trouvaille de programme utilitaire.

Ce module fournit cette installation au Perl. Considérant que la syntaxe indigène de VMS emploie les points de suspension « … », ceci n'équipera pas dedans des noms de fichier de POSIX, comme… est (cependant) un nom de fichier quelque peu étrange admissible. Au lieu de cela, « d'élément/ » est employé car ceci ne peut pas syntactiquement faire partie d'un nom de fichier, car vous n'obtenez pas trois séparateurs en simultané de nom de fichier avec rien entre (trois barres de fraction sont employées pour éviter la confusion avec la syntaxe de //node/path/name).

Vous ne devez pas employer cette syntaxe, comme vous pouvez faire se diviser et réussir dans un arrayref en tant que votre circuit.

Le module forme également une expression régulière pour la totalité de la chaîne de caractères de carte de remplacement, et grippe une série de références arrières ($1, $2 etc.) qui sont procurables pour construire des noms de fichier neufs.

neuf

Dossier : : Carte de remplacement-neuf ($wildcard, [, valeur de => d'option,…]) ; >
mon $foo = dossier : : Wildcard->new (=> « /home/me///core » de circuit) ;
mon $srcfnd = dossier : : Wildcard->new (=> « src///*.cpp » de circuit,
qr de => d'allumette (^src/(. * ?).cpp$),
dériver le => [src/$1.o, src/$1.hpp]) ;

C'est le constructeur pour le dossier : : Objectifs de carte de remplacement. À un niveau simple, réussir une chaîne de caractères unique de carte de remplacement comme circuit.

Pour des fonctionnements plus compliqués, vous pouvez accepter votre propre regexp d'allumette, ou employer l'option de dérivation pour spécifier des saisies d'expression régulière pour former la base d'autres noms de fichier qui sont construits pour vous.

L'exemple de $srcfnd te donne des fichiers d'exécution et des dossiers d'en-tête correspondant aux fichiers source de C++.

Voici les options qui sont procurables :

circuit

C'est le paramètre d'entrée qui spécifie la gamme des dossiers qui seront regardés. C'est Spéc. de goutte qui peut également contenir les points de suspension /// (elle pourrait contenir plus d'un points de suspension, mais l'avantage de ceci est douteux, et l'ellipsi multiple ferait heurter un rendement).

Noter que le circuit peut être relatif ou absolu. neuf fera la bonne chose, établissant qu'un circuit commençant/est absolu. Le recurse du répertoire courant vers le bas, spécifient .///foo.

Comme alternative, vous pouvez fournir un arrayref les constituants de circuit déjà divisés. Si vous faites ceci, vous devez dire neuf si le circuit est absolu. Comprendre une chaîne vide pour des points de suspension. Par exemple :

foo///bar/*.c est équivalent à [foo, barre, *.c]

Vous pouvez également construire un dossier : : Carte de remplacement sans circuit. Un appel à prochain renverra l'undef, mais les circuits peuvent être ajoutés using l'ajouter et ajouter des méthodes au début.
absolu

Ceci est ignoré à moins que vous utilisiez un circuit pré divisé. Si vous réussissez une chaîne de caractères comme circuit, neuf établira si le circuit est absolu ou relatif. Réussir des valeurs vrai pour les circuits absolus.

Si votre filespec originel commençait/avant que vous le divisiez, spécifier l'absolu absolu du => 1. n'est pas exigé pour Windows si le circuit contient un cahier des charges d'entraînement, par exemple C : /foo/bar.

case_insensitive

Par défaut, le module emploiera Filesys : : Taper pour déterminer si le système de fichiers de votre carte de remplacement est défini. C'est un module optionnel (voir le module : : Optionnel), et dossier : : La carte de remplacement estimera à la sensibilité à la casse basée sur votre du système d'exploitation. Ce ne sera pas toujours correct, comme le système de fichiers pourrait être VFAT monté sur linux ou ODS-5 sur le VMS.

La spécification de l'option case_insensitive force expressément ce comportement sur la carte de remplacement.

Noter ce dossier : : La carte de remplacement emploiera le système de fichiers du répertoire de travail actuel si le circuit n'est pas absolu. Si le circuit est absolu, vous devriez spécifier l'option de case_sensitivity expressément.

exclure

Vous pouvez fournir un regexp pour appliquer à tous les circuits produits, qui causeront n'importe quels circuits assortis de ne pas être traités. Si le fond des arborescences des répertoires s'assortit, aucun traitement n'est fait sur l'arbre entier.

Cette option peut être utile pour exclure des dépôts de contrôle de version, par exemple.

exclure le => qr/.svn/
allumette

Optionnel. Si vous ne spécifiez pas un regexp, vous obtenez tous les dossiers qui apparient la goutte ; de plus, la volonté neuve a installé un regexp pour vous, pour fournir une saisie pour chaque carte de remplacement utilisée dans le circuit.

Si vous fournissez un paramètre d'allumette, ceci sera employé au lieu, et filtrera les résultats.

dériver

Fournir un arrayref une liste de noms de fichier dérivés, qui seront construits pour chaque dossier assorti. Ce causes à côté du renvoi un arrayref au lieu d'une grandeur scalaire.
suivre

Si donné des valeurs vrai indiquent que des tiges symboliques doivent être suivies. Autrement, l'objectif de tige symbolique lui-même est présenté, mais les points de suspension ne traverseront pas la tige.

Ce module trouve un symlink bouclant qui indique un répertoire plus haut vers le haut, et présentera seulement l'arbre une fois.

ellipsis_order

Ceci peut prendre une des valeurs suivantes : normal, en largeur, à l'envers. Les options par défaut sont normales. Ceci contrôles comment dossier : : La carte de remplacement traite les points de suspension. Le défaut est une profondeur normale recherchent d'abord, présentant le nom de chaque répertoire contenant avant le contenu.

La commande inside-out présente les contenus du répertoire d'abord avant le répertoire, qui est utile quand vous voulez retirer des dossiers et des répertoires (tous les O/S exigent des répertoires d'être vides avant que le rmdir fonctionne). Voir le t/03_absolute.t pendant que ceci emploie la commande inside-out pour ranger après le test.

En largeur est nécessaire rarement (mais j'ai une demande de elle). Ici, les contenus du répertoire entiers est présentés avant de traverser tous les sous-répertoires.
Considérer l'arbre suivant : un a/bar/a/bar/drink a/foo/a/foo/lish
en largeur donnera l'ordre suivant : qw (un a/bar/a/foo/a/bar/drink a/foo/lish). la normale donne la commande dans laquelle les dossiers sont cotés. donne à l'envers ce qui suit : qw (a/bar/drink a/bar/a/foo/lish a/foo/a).

tri

Par défaut, globbing renvoie la liste des fichiers dans la commande dans laquelle ils sont retournés par le dirhandle (intérieurement). Si vous spécifiez le => 1 de tri, les dossiers sont triés dans la séquence d'ASCII (cas insensiblement si nous faisons fonctionner de cette façon). Si vous spécifiez un CODEREF, ceci sera employé comme sous-programme de comparaison. Noter que ceci prend ses opérandes dans le @_, pas dans $a et $b.

mettre au point et debug_output

Vous pouvez permettre une trace des conditions internes du dossier : : La carte de remplacement en réglant mettent au point à des valeurs vrai. Régler le debug_output à un filehandle ouvert pour obtenir la trace dans un dossier. Si vous soumettez des rapports de bug pour le dossier : : La carte de remplacement, fixant mettent au point des fichiers de suivi serait très utile.

défauts de debug_output à STDERR.
allumette
mon $foo_re = $foo->match ;
$foo->match (barre/faisceau) ;

C'est une méthode d'obtention et de jeu qui donne à accès au regexp d'allumette ce le dossier : : L'objectif de carte de remplacement emploie. Il est possible de changer l'expression régulière en marche au milieu d'une recherche (bien que je ne sais pas pourquoi n'importe qui voudrait faire ceci).

ajouter

$foo->append (=> /home/me/// *.tmp de circuit) ;

ajoute un circuit à une liste de todo d'objectifs. Ceci globbed après que l'objectif ait fini de traiter les cartes de remplacement existantes.

ajouter au début
$srcfnd->prepend (=> $include_file de circuit) ;

C'est assimilé pour ajouter, mais pour ajouter le circuit à la liste de todo. En d'autres termes, le fonctionnement actuel de carte de remplacement est interrompu pour servir le circuit neuf, alors le fonctionnement précédent de carte de remplacement est repris quand ceci est épuisé.

ensuite
tandis que (mon $core = $foo->next) {
séparer/$core ;
}
mon ($src, $obj, $hdr) = @ {$srcfnd->next} ;

La prochaine méthode est un iterator, qui renvoie les dossiers successifs. Renvoie les dossiers assortis s'il y avait aucun dérivent l'option réussie à neuf. S'il y avait une option de dérivation, renvoie un arrayref contenant le filespec assorti et tous filespecs dérivés. Les filespecs dérivés ne doivent pas exister.

Noter qui met à jour ensuite un curseur interne, qui maintient l'information de contexte et de condition. Prendre garde si les contenus du répertoire changent tandis que vous réitérez avec ensuite ; vous pouvez obtenir des résultats imprévisibles. Si vous avez l'intention de changer les teneurs des répertoires que vous êtes lecture (avec séparer/ou renommer), vous êtes plus aisé différant ce fonctionnement jusqu'à ce que vous ayez traité l'arbre entier. Pour l'effacement en attente ou renommer les fonctionnements, vous pourrait toujours employer un autre dossier : : Objectif de carte de remplacement - voir l'exemple de pointe ci-dessous :

tous
mes @cores = $foo->all ;

tous les renvois un choix de dossiers assortis, dans le cas simple. Renvoie un choix de choix si vous construisez des noms de fichier neufs, comme l'exemple de $srcfnd.

Prendre garde des implications de rendement et de mémoire d'employer tout. La méthode ne retournera pas jusqu'à ce qu'elle ait affiché les arborescences des répertoires entières. L'utilisation de la toute la méthode n'est pas recommandée pour traverser de grandes arborescences des répertoires et systèmes de fichiers entiers. Envisager de coder le traversal using l'iterator ensuite au lieu.

remettre à l'état initial

la remise cause le contexte de carte de remplacement d'être réglé pour relire le premier nom de fichier de nouveau. Noter que ceci causera des contenus du répertoire d'être relus.

Noter également que ceci fera retourner le circuit au circuit originel spécifique à neuf. Tous les circuits supplémentaires ajoutés ou ajoutés au début seront oubliés.

fin

Relâcher tous les traitements de répertoire liés au dossier : : Objectif de carte de remplacement. Un objectif qui a été fermé sera des ordures rassemblées une fois lui sort de l'étendue. Des cartes de remplacement qui ont été épuisées sont automatiquement fermées, (c.-à-d. tout a été employé, ou c< ensuite > undef retourné).

Les appels suivants à prochain renverront l'undef. Il est possible d'appeler la remise après fin sur le même dossier : : Objectif de carte de remplacement, qui le causera d'être rouvert.

Dossier : : NFSLock est un module de Perl pour faire le verrouillage de NFS (ou pas).

SYNTHÈSE

dossier d'utilisation : : Qw de NFSLock (uncache) ;
employer le qw de Fcntl (LOCK_EX LOCK_NB) ;

mon $file = « somefile » ;

le ### a installé un blocage - bouts jusqu'à ce que l'objectif desserre l'étendue
si (mon $lock = dossier neuf : : NFSLock {
=> $file de dossier,
=> LOCK_EX de lock_type|LOCK_NB,
=> 10 de blocking_timeout, # sec 10
=> de stale_lock_timeout 30 * 60, # mn 30
}) {

### OU
### mon $lock = dossier : : NFSLock->new ($file, LOCK_EX|LOCK_NB, 10.30*60) ;

le ### font la substance protégée en écriture sur $file
le ### en ce point $file est uncached du NFS (le plus récent)
s'ouvrir (DOSSIER, « +<$file ») || mourir $ ! ;

le ### ou l'ouvrent n'importe quelle voie que vous aimez
### mon $fh = E/S : : File->open ($file, w) || mourir $ !

mise à jour de ### (uncache en travers de NFS) d'autres dossiers
uncache (« someotherfile1 ») ;
uncache (« someotherfile2 ») ;
# s'ouvrir (FILE2, « someotherfile1 ») ;

le ### le débloquent
$lock->unlock () ;
### OU
undef $lock de ### ;
Le ### OU a laissé $lock sortent de l'étendue
} autrement {
me mourir « ne pourrait pas verrouiller le dossier [$File : : NFSLock : : errstr] » ;
}

Régime basé du concept de joindre dur des dossiers étant atomiques en travers du NFS. Ce concept a été mentionné dans le courrier : : Cadre : : Casier (qui a été initialement présenté dans le courrier : : Dépliant : : Maildir). Un certain flux courant est pris de là -- en particulier l'idée de produire un fichier local fait au hasard, travaux forcés liant un dossier courant au fichier local, et puis vérifiant le mode de nlink. Quelques idéologies n'étaient pas complètes (mécanisme d'uncache, verrouillage partagé) et du codage était même incorrect (index incorrect de stat). Dossier : : NFSLock a été sauvé pour être la lumière, générique, et rapide.

Ce qu'il y a de neuf dans ce desserrage :

· Perl

Dossier : : FindByRegex est un emballage de Perl pour le dossier : : Trouver qui trouve des arborescences des répertoires et exécute une certaine action pour chaque dossier dont les matchs nommés une expression régulière.

SYNOPSYS

dossier d'utilisation : : FindByRegex ;

$find = dossier : : FindByRegex->new ({

- => de srcdir [C : tmpteradata-SQL],
- => C de tardir : tmpteradata-sqldoc,
- => de trouvaille {=> 1 de no_chdir},

- => de rappels de service
{
qr/.p (l|m|OD|t)$/oi, &treat_pod de =>,
qr/sql.+ ? .sql$/oi, treat_pod de =>,
qr/.html ? $/oi, &treat_html de =>,
&treat_txt de => de qr/.txt$/oi,
qr/. (jpg|GIF|png|véhicule blindé amphibie soviétique d'infanterie|sous-marin de => de tiff) $ {&treat_graphic (@_)}
},

- ignorer le =>
[
qr/par exemple +.sql$/oi, # *.sql dans le répertoire par exemple
qr/java/oi, # tous les dossiers dans le répertoire de Java.
],

- excepte le =>
[
qr/java.* ? .html ? $/oi # n'ignorent pas *.html dans Java
]
}) ;

sous-dossier : : FindByRegex : : treat_pod
{
mon $this = commande des vitesses ;
…
}

sous-dossier : : FindByRegex : : treat_html
{
mon $this = commande des vitesses ;
…
}

sous-dossier : : FindByRegex : : treat_txt
{
mon $this = commande des vitesses ;
…
}

sous-dossier : : FindByRegex : : treat_graphic
{
mon $this = commande des vitesses ;
…
}

$find->travel_tree ;

Dossier : : Repl est un module de Perl qui fournit des utilitaires de réplique de dossier.

SYNTHÈSE

dossier d'utilisation : : Repl ;

%con = {
=> C de dira : /perl,
=> M de dirb : /perl,
=> bavard 1,
=> 10 d'âge,
} ;

$ref=File : : Repl->New (%con) ;
$r1 = $ref->Update (.p (l|m), a<>b, 1) ;
$r2 = $ref->Update (.t.*, a<>b, 1, .tmp$) ;

Le dossier : Repl fournit des utilitaires simples de réplique et de management de dossier. Ses fonctionnements principaux sont

Réplique de dossier

Permettre à deux structures de répertoire d'être mises à jour, assurant les dossiers qui répondent à des critères de logique de sélection sont reflétées et autrement synchronisées.

Renommer en bloc

Laisser lime dans une structure de répertoire à renommer selon la logique de sélection.

Comprimer

Laisser lime dans une structure de répertoire à comprimer selon une logique donnée.

Procédé

Exécuter un procédé courant de Perl contre des dossiers dans une structure de répertoire selon la logique de sélection.

Blanc

Laisser lime dans une structure de répertoire à effacer selon la logique de sélection.

Dossier : : LockDir est un utilitaire fondamental de blocage de nom de fichier-niveau de Perl.

SYNTHÈSE

dossier d'utilisation : : LockDir ;

SURFACE ADJACENTE

neuf

Initialise le cours. Renvoie l'objectif de singleton.

nflock ($file, $nap_till, $locker, $lockhost)

Verrouille le nom de fichier fourni. Seulement $file est exigé.

$file est le dossier à verrouiller ; $nap_till est le nombre de heures total à l'attente avant d'abandonner ; $locker est un nom recensant le casier ; $lockhost est le serveur demandant le blocage.

nunflock ($file)

Débloque le dossier fourni.

nlock_state ($file)

Examine la condition du blocage pour assurer le dossier fourni. Renvoie une liste : le premier organe est vrai si le dossier est débloqué, et trompeur sinon ; le deuxième organe est undef si le dossier est débloqué, et l'identité (nom et serveur) est lui est verrouillée.

DIAGNOSE

%s s'est déjà verrouillé

Vu quand vous avez déjà verrouillé le nom d'accès prié. À titre d'information seulement.

Aucun nom d'accès à verrouiller

Vous n'avez pas fourni un nom d'accès à verrouiller au nflock. Fatal.

les clichés sauvent au répertoire de %s

Le répertoire où le dossier demeure des clichés soit sauvé, ainsi les clichés lockfile soit produit.

les clichés obtiennent %s : %s

Les clichés nommés de blocage soient obtenus : la raison est acceptée. Le défaut se produit après que dix essais pour obtenir le blocage.

%s %s [%s] : verrouiller sur %s maintenu par %s

Le blocage sur le fichier spécifié est aide par le casier remarquable. Message informatif, estampé seulement quand l'élimination des imperfections est allumée.

la fin a échoué pour %s : %s

Le dossier contenant l'information de blocage n'a pas pu être fermé pour la raison montrée.

relâchement du blocage sur %s

Mettre au point le message ; note que le blocage sur le fichier spécifié a été avec succès relâché.