El servidor de archivos de AVG ofrece la protección de virus para Linux y servidores de archivos FreeBSD. Protección de seguridad contra virus, gusanos y trojans para Linux y servidores de archivos FreeBSD, sin tener en cuenta cargas de trabajo.

Instalación y Lanzamiento

AVG 7.5 para paquetes de instalación Linux/FreeBSD son proporcionados como REVOLUCIONES POR MINUTO o archivos deb, o como un paquete tar.gz.

Para la instalación del archivo de REVOLUCIONES POR MINUTO (Linux sólo), use el orden siguiente en su cáscara (accesible por ejemplo utilización de la aplicación xterm dentro de su X sistema de ventana).

# revoluciones por minuto-i avg75lms-{liberación} - {vdb versión}.i386.rpm

Para la instalación del archivo.deb (Linux sólo), use el orden siguiente en su cáscara (accesible por ejemplo utilización de la aplicación xterm dentro de su X sistema de ventana).

# dpkg-i avg75lms-{liberación} - {vdb versión}.i386.deb

Para la instalación del paquete.tar.gz, use los órdenes siguientes (en el directorio donde el paquete está localizado) para desempaquetar sus contenido, directorio de cambio y luego finalmente ejecutar el guión instalar (como la raíz). Ya que Linux siguen con estos pasos:

# alquitrán xzvf avg75lms-{liberación} - {vdb versión}.i386.tar.gz
# cd avg7-linux
# ./install.sh

Le ofrecerán entonces la posibilidad de registrar su software. Usted puede hacerlo ahora o más tarde (ver el Registro de Producto del capítulo 3.3). Ya que FreeBSD siguen con estos pasos:

# alquitrán xzvf avg75fms-{liberación} - {vdb versión}.i386.tar.gz
# cd avg7-freebsd
# ./install.sh

Le ofrecerán entonces la posibilidad de registrar su software. Usted puede hacerlo ahora o más tarde (ver el Registro de Producto del capítulo 3.3). Note: los archivos de programa del AVG 7.5 para versiones Linux/FreeBSD 11 y más viejo son instalados en el directorio/usr/local/lib/avg7. Incluso si usted realiza la actualización llena de la versión más vieja de su AVG, la estructura de directorio permanece el mismo (contrato de un seguro el hacia atrás compatibilidad). Sin embargo, todos los componentes esenciales de AVG
7.5 ya que Linux/FreeBSD siempre son actualizados correctamente para ofrecerle la seguridad máxima y fiabilidad.

Las versiones 12 y más nuevo son exhaustivamente instaladas en el directorio/opt/grisoft. Los enlaces simbólicos son creados en varios directorios de sistema, llevando al subárbol de directorio/opt/grisoft. Si usted quiere modernizar la vieja estructura de directorio, usted debe instalar de nuevo completamente su AVG 7.5 para Linux/FreeBSD. Note que en esta documentación siempre es descrito la posición más nueva preferida de AVG 7.5 para
¡Instalación de Linux/FreeBSD!

El XULTech Firelinks Administrador de archivos de servidor Remoto es un administrador de archivos remoto / panel de control que le deja manejar su servidor web usando una interface de GUI fácil de usar.

Firelinks usa Firefoxs XUL (Lengua de interface del Usuario de XML), y Javascript para entregar una aplicación basada en la web que tiene la mirada y la sensación de una aplicación de escritorio. Pruebe nuestra demostración viva y experiméntela usted mismo.

Firelinks opera como un administrador de archivos de escritorio regular. Por ejemplo, usted puede cambiar el tamaño y reajustar columnas individuales en la tabla de listado de archivo por rastra y gota. Cualquier personalización youve hecho ser recordado por la aplicación.

Aquí están algunos aspectos claves "de XULTech Firelinks Administrador de archivos de servidor Remoto":

Ninguna instalación de cliente requirió: la aplicación sólo tiene que ser instalada una vez como una aplicación de interfaz común de pasarela en su servidor web. Todo que usted necesita en el lado de cliente es una copia de los mundos el navegador de la fuente abierto más popular: Firefox.
Interface de Usuario intuitiva y Familiar: Firelinks trabaja justo como cualquier otro administrador de archivos basado de escritorio, como Microsoft Explorer o KDE Konqueror. La interface de usuario ha sido realzada con aspectos suplementarios, como un panel de previsión de web para hacerlo más útil para sitios web gerentes.
Seguro: A diferencia del protocolo de transferencia de archivos claro donde la contraseña es hecha pasar el claro, sólo el picadillo de contraseña es enviado por Firelinks en el tiempo de conexión. Usted también puede configurar Firelinks de modo que él sólo acepte la conexión de una dirección IP fija. Para la seguridad añadida usted también puede ejecutarlo vía el SSL si usted servidor web ha sido configurado para permitir conexiones de SSL.
Shell Remota incorporada: las aplicaciones de línea de orden Ejecutadas y el guión por la cáscara de orden incorporada Firelinkss, aun si su proveedor de servicios internet no ofrece su SSH.

El archivo es la realización de la fuente abierta del orden de archivo usado en casi cada sistema operativo libre (OpenBSD, Linux, FreeBSD, NetBSD) y también en sistemas que usan el izquierdo de copia (incluso OS/2, DOS, MS Windows, etc.).

El orden de archivo, si youre no familiar con ello, es unas herramientas de línea del orden que le dicen en palabras que tipo de datos un archivo contiene. A diferencia de Windows del MS, el UNIX y otros sistemas dont confían en el nombre del archivo extentions para decirle el tipo de un archivo, pero mirar los archivos contenido actuales. Esto es, por supuesto, más confiable, pero requiere un poco de la entrada-salida.

El orden de archivo original transportado con el UNIX de Laboratorios de Campana pero era no disponible en la forma de la fuente a las masas antes de la nueva realización de Ians.

Este orden de archivo (y archivo mágico) fue al principio escrito por Ian Darwin (quién todavía contribuye de vez en cuando) y es mantenido ahora por un grupo del plomo de reveladores por Christos Zoulas.

¿Whos utilización de esto?

Cada distribución BSD conocida (FreeBSD, NetBSD, OpenBSD, Darwin/Mac OS X, etc.)
Cada distribución de Linux conocida
El Apache httpd servidor mod_mime_magic módulo usa los órdenes de archivo innards para hacer el tipo de archivo que adivina más confiable bajo el Apache HTTPD.

el Navegador de Archivo de jsp es un fácil de usar y fácil a instalar el navegador de archivo página de servidor de java. Este programa de página de servidor Java permite el acceso de archivo basado en la web remoto y la manipulación.

Aquí están algunos aspectos claves "de jsp Navegador de Archivo":

Los · Crean, copian, mueven, renombran y borran archivos y directorios
· archivos de Vista (imágenes fotografías, películas, pdf, html...)
· Corrigen textfiles
Los · Suben archivos al servidor (Estado vía Suben el monitor)
· archivos de Telecarga del servidor
· los grupos de Telecarga de los archivos y carpetas como un archivo de zip solo que es creado al vuelo
Los · Ejecutan órdenes natales en el servidor (p.ej ls, alquitrán, chmod...)
· entradas de Vista y desempaquetan zip, tarro, guerra y archivos gz en el servidor
· Sólo un archivo, muy fácil a instalar (de hecho, sólo cópielo al servidor)
· Customizable disposición vía archivo css
Los · Restringen el acceso de archivo vía negro o whitelist

Esto debería trabajar con cualquier servidor compatible JSP1.1 (p.ej. Gato macho> =3.0), lo probé en el Gato macho 4.0, Resina 2.1.7 y Embarcadero.

Whats Nuevo en Esta Liberación:

· una versión sólo para leer fue añadido.
· Esto es utilizable también ahora como un subir-centro.
· Algunos realces UI fueron hechos, como shortkeys y una mejor disposición.
· Esto también debería cargar un poco más rápido.

el proyecto de file*HANDLER es principalmente un guión Perl que coordina algunos paquetes de conversión de medios libres (citó más tarde) con un servidor de teniendo acceso de servicios de fondo PostgreSQL para poner índice y servir binario y archivos de texto directos de la base de datos. Un archivo de interfaz común de pasarela simple con AYAX empotrado hace llamadas a este servidor que también busca constantemente a otros servidores f*H vivos en el Internet.

Desde los medios de caches de servidor en la base de datos SQL a la vista, cuando la red crece, la red mejora.

Su directorio gridded que comparte/hojea/busca con derramar el audio/vídeo así como el piso text/doc/pdf/image muestra para cada uno. Su escrito con unos ganchos para etiquetas que serían incluidas en su primera página actual de modo que el UI sea desechable - alguien puede volver a escribir rápidamente un todo nuevo [Tiempo Global] UI sin necesidad tener de preocuparse de la sintaxis de la versión más nueva de dojo.licio.r o tal.

Si usted quisiera no hacer caso de los ganchos de JS/HTML/CSS entonces usted puede usar fácilmente el sistema para hacer peticiones directas que sólo las listas de devolución formatearan como cuerpos de la tabla de HTML. En otras palabras, la maquetación ES la maquetación.

Como tal, Ive estimuló un Dojo 0.2 Artefacto que coordina la parte trasera que sirve con un UI entonces alguien puede empotrar la funcionalidad f*H en todas partes, o fácilmente personalizar una página por defecto proporcionada.

Un servidor file*HANDLER está realmente unas partes constituyentes Ive amarrado para usted (cumbre abajo):

· una página web local que proporciona el UI (servido por un servidor de HTTP de su opción) que es generado por un guión cgi con AYAX empotrado.
· una parte secundaria del mismo guión de interfaz común de pasarela, actuando que el middleware, que se comunica, vía AYAX, con la primera página local para conciliar peticiones de JavaScript asincrónicas con la parte trasera de subred de file*HANDLER.
· siempre - en el servidor de red escrito en el PERL que sirve al frente y final comunica lateralmente con cada uno elses file*HANDLER servidor de PERL de parte trasera además, esto maneja poner índice de directorios contentos que usted decide servir.
· una base de datos PostgreSQL a que sólo tienen acceso vía rutinas de PERL internas llamadas de su primera página.

Tan por ejemplo, un usuario remoto viene a su sitio web. En primer lugar, no sólo ellos pueden buscar y buscar sus archivos, pero ellos también pueden buscar y buscar los archivos de alguien más recibiendo a un servidor file*HANDLER sobre el cual su servidor local conoce. (file*HANDLER identifica a otros servidores en la red automáticamente). El usuario puede leer/ver/escuchar/mirar ahora por la corriente cualquier contenido que ellos encuentran del servidor whomevers. Theres ninguna telecarga, entonces theres entonces actual compartiendo, correr sólo directo al navegador de usuarios.

File::PM2File - obsoleto. Usuario File::Where

SINOPSIS

file_in_include () # obsoleto. Reemplace con File::Where::where ()
pm2file () # obsoleto. Reemplace con File::Where::where_pm ()
pm2require () # obsoleto. Reemplace con File::Where::pm2require ()

$File:: PM2File:: warn_obsolete = 1; # enciende la advertencia obsoleta

EXIGENCIAS

File::PM2File el subrouitnes no debe ir usado.
File::PM2File las subrutinas deben ser reemplazadas por el apropiado File::Where subrutina siempre que File::PM2File la subrutina necesite la revisión como sigue:

File::PM2File::find_in_include () File::Where::where ()
File::PM2File::pm2file File::Where::where_pm ()
File::PM2File::pm2require File::Where::pm2require

NOTE: la subrutina File::Where::where es casi una gota directa en para File::PM2File::find_in_include (). La diferencia está en un contexto de matriz File::Where::where () devuelve un tercer artículo donde File::PM2File::find_in_include () sólo vuelve dos. Los dos primeros artículos, sin embargo, son el mismo.

File::MMagic es un módulo Perl para adivinar el tipo de archivo.

SINOPSIS

use File::MMagic;
use FileHandle;

$mm = nuevo File::MMagic; # usan el archivo mágico interno
# $mm = Archivo:: MMagic-> nuevo (/etc/magic); # usan el archivo mágico externo
# $mm = Archivo:: MMagic-> nuevo (/usr/share/etc/magic); # si usted usa Debian
$res = $mm-> checktype_filename ("/somewhere/unknown/file");

$fh = nuevo FileHandle "</somewhere/unknown/file2";
$res = $mm-> checktype_filehandle ($fh);

$fh-> leído ($data, 0x8564);
$res = $mm-> checktype_contents ($data);

File::AnySpec es un módulo Perl para realizar operaciones en nombres de fichero (remotos) extranjeros.

SINOPSIS

# Interface de Subrutina
#
use File::AnySpec qw (fspec2fspec pm2fspec os2fspec fspec2os fspec_glob fspec2pm);

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

$pm = fspec2pm ($fspec, $require_file)
($abs_file, $inc_path, $require_file) = pm2fspec ($fspec, $pm)

@globed_files = fspec_glob ($fspec, @files)


# Interface de Clase
#
use File::AnySpec
use vars qw (@ISA)
@ISA = qw (File::AnySpec)

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

$pm = __ PAQUETE __-> fspec2pm ($fspec, $require_file)
($abs_file, $inc_path, $require_file) = __ PAQUETE __-> pm2fspec ($fspec, $pm)

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

Métodos en este paquete, realice operaciones en especificaciones de archivo para sistemas operativos otro entonces el sistema operativo de sitio web corriente. El $fspec de variable de insumo dice los métodos en este paquete la especificación de archivo para nombres de fichero acostumbrados como el insumo para los métodos. Así, usando métodos en este paquete, el método puede cargar hasta dos File::Spec los métodos de submódulos y ninguno de ellos son un submódulo para el sistema operativo de sitio web corriente.

File::Util es un módulo de manejando de archivo fácil, versátil, portátil.

File::Util proporciona una caja de herramientas completa de herramientas para automatizar todas las clases de tareas comunes en el archivo / directorios. Su objetivo es hacer así en la manera más portátil posible de modo que los usuarios de esta costumbre de módulo tengan que preocuparse de si sus programas trabajarán en otro OSes y máquinas.

SINOPSIS

use File::Util;
mi ($f) = Archivo:: Util-> nuevo ();

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

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

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

$f-> write_file (
archivo => file.bin, contenido => $binary_content, - binmode
);

mi (@lines) = $f-> load_file (randomquote.txt, - cuando-líneas);
mi ($line) = int (rand (escalar @lines));

$lines de letra [$line];

mi (@files) = $f-> list_dir (/var/tmp, los qw/-únicamente de archivos - blasfeman de nuevo/);
mi (@textfiles) = $f-> list_dir (/var/tmp, - modelo =. txt$);

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

mi ($HANDLE) = $f-> open_handle (
archivo => wibble.log,
el modo => añade
);

¡$HANDLE de letra "Hola Mundo! Su", escalar localtime;

$HANDLE cercano

}

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

letra "Mi archivo tiene un bitmask de". $f-> bitmask (my.file);

letra "Mi archivo es un". juntura ($f-> file_type (my.file)). "archivo".

¡advierta que Este archivo es binario! si $f-> isbin (my.file);

letra "Mi archivo era última modificado en".
escalar localtime ($f-> last_modified (my.file));

# ... y _lots_ más

File::BasicFlock es un módulo Perl para el archivo que se cierra con la multitud.

SINOPSIS

use File::BasicFlock;

cerradura ($filename);

cerradura ($filename, compartido);

cerradura ($filename, undef, no obstruyéndose);

cerradura ($filename, compartido, no obstruyéndose);

abra ($filename);

archivos de cerradura usando la multitud () llamada. El archivo para ser cerrado con llave debe existir ya. Esto es un muy cosa interface.

File::NFSLock es un módulo Perl para hacer el Sistema de fichas de Red (o no) cierre.

SINOPSIS

use File::NFSLock qw (no cache);
use Fcntl qw (LOCK_EX LOCK_NB);

mi $file = "somefile";

### aliste una cerradura - dura hasta que el objeto suelte el alcance
si (mi $lock = nuevo File::NFSLock {
archivo => $file,
lock_type => LOCK_EX|LOCK_NB,
blocking_timeout => 10, # de 10 segundos
stale_lock_timeout => 30 * 60, # 30 minutos
}) {

### O

### mi $lock = Archivo:: NFSLock-> nuevo ($file, LOCK_EX|LOCK_NB, 10,30*60);

### realmente escriba la materia protegida en el $file
### en este punto el $file es no escondido del Sistema de fichas de Red (el más reciente)
¡abierto (¡ARCHIVO, "+ <$file") los || mueren el $!;

### o ábralo cualquier modo que le gusta
### ¡mi $fh = IO:: Archivo-> abierto (¡$file, w) || mueren $!

### actualización (no cache a través de Sistema de fichas de Red) otros archivos
no cache ("someotherfile1");
no cache ("someotherfile2");
# abierto (FILE2, "someotherfile1");

### ábralo
El $lock-> abre ();
### O

### $lock de undef;
### O deje al $lock salir del alcance
} más {
muera "yo couldnt cierran con llave el archivo [$File:: NFSLock:: errstr]";
}

Programa basado de concepto de conexión difícil de archivos siendo atómicos a través de Sistema de fichas de Red. Este concepto fue mencionado en el Correo:: Caja:: Armario (que fue al principio presentado en el Correo:: Carpeta:: Maildir). Algún flujo rutinario es tomado desde allí - en particular la idea de crear un archivo local arbitrario, con fuerza conectando un archivo común con el archivo local, y luego comprobando el estado nlink. Algunas ideologías no eran completas (mecanismo de no cache, cierre compartido) y un poco de codificación era hasta incorrecta (índice de stat incorrecto). File::NFSLock fue escrito para ser ligero, genérico, y rápido.

Whats Nuevo en Esta Liberación:

· Perl

File::FindByRegex es una envoltura Perl para File::Find que encuentra un árbol de directorio y ejecuta un poco de acción para cada archivo cuyo nombre matchs un regex.

SYNOPSYS

use File::FindByRegex;

$find = Archivo:: FindByRegex-> nuevo ({

-srcdir => [C:tmpteradata-sql],
-tardir => C:tmpteradata-sqldoc,
- encuentran => {no_chdir => 1},

- rellamadas =>
{
qr/.p (l|m|od|t) $/oi, => &treat_pod,
qr/sql. ¿+?. sql$/oi, => treat_pod,
¿qr/.html? $/oi, => &treat_html,
qr/.txt$/oi => &treat_txt,
qr/. (jpg|gif|png|bmp|tiff) $ / => suscripción {&treat_graphic (_)}
},

- no hacen caso =>
[
qr/eg. +. sql$/oi, # *.sql en directorio eg
qr/java/oi, # Todos los archivos en directorio de java.
],

-excepts =>
[
¿qr/java. *?. ¿html? El $/oi # dont no hace caso de *.html en java /
]
});

suscripción File::FindByRegex::treat_pod
{
mi $this = cambio;
...
}

suscripción File::FindByRegex::treat_html
{
mi $this = cambio;
...
}

suscripción File::FindByRegex::treat_txt
{
mi $this = cambio;
...
}

suscripción File::FindByRegex::treat_graphic
{
mi $this = cambio;
...
}

$find-> travel_tree;

File::Repl es un módulo Perl que proporciona herramientas de réplica de archivo.

SINOPSIS

use File::Repl;

%con = {
dira => C:/perl,
dirb => M:/perl,
verboso => 1,
edad => 10,
};

$ref=File:: Repl-> Nuevo (%con);
$r1 = $ref-> Actualización (.p (l|m), un <> b, 1);
$r2 = $ref-> Actualización (.t. *, un <> b, 1.tmp$);

File:Repl proporciona réplica de archivo simple y herramientas de dirección. Sus funciones principales son

Réplica de Archivo

El permiso de dos estructuras de directorio para ser mantenidas, asegurando archivos que encuentran criterios de lógica de selección es reflejado y por otra parte sincronizado.

Bulto Renombrar

El permiso de archivos en una estructura de directorio para ser renombrada según la lógica de selección.

Comprimir

El permiso de archivos en una estructura de directorio para ser comprimida según una lógica dada.

Proceso

Ejecute un proceso de perl común contra archivos en una estructura de directorio según la lógica de selección.

Eliminación

El permiso de archivos en una estructura de directorio para ser borrada según la lógica de selección.

File::LockDir es una herramienta de cerradura de nivel del nombre del archivo básica Perl.

SINOPSIS

use File::LockDir;

INTERFACE

nuevo

Inicia la clase. Devuelve el objeto de cosa única.

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

Cierra con llave el nombre del archivo suministrado. Sólo el $file se requiere.

El $file es el archivo para ser cerrado con llave; el $nap_till es el importe de tiempo para esperar antes de rendirse; el $locker es un nombre que identifica el armario; el $lockhost es el servidor que solicita la cerradura.

nunflock ($file)

Abre el archivo suministrado.

nlock_state ($file)

Comprueba el estado de la cerradura para el archivo suministrado. Devuelve una lista: el primer artículo es verdad si el archivo es abierto, y falso si no; el segundo artículo es undef si el archivo es abierto, y la identidad (nombre y servidor) es esto es cerrado con llave.

DIAGNÓSTICO

%s ya se cerró

Visto cuando youve ya cerró con llave el nombre de camino solicitado. Informativo sólo.

Ningún nombre de camino para ser cerrado con llave

Usted didnt suministra un nombre de camino para ser cerrado con llave a nflock. Fatal.

la superficie inclinada escribe al directorio de %s

El directorio donde el archivo reside la superficie inclinada ser escrito, entonces la superficie inclinada lockfile ser creado.

la superficie inclinada consigue %s: %s

La superficie inclinada de cerradura llamada ser conseguido: la razón es suministrada. El fracaso ocurre después de diez intentos de conseguir la cerradura.

%s %s [%s]: la cerradura en %s sostenida por %s

La cerradura en el archivo especificado es la ayuda por el armario célebre. El mensaje de Informatory, impreso sólo cuando la depuración es conectada.

cerca fallado para %s: %s

El archivo que contiene la información de cerradura couldnt estar cerrado por los motivos mostrados.

la liberación de cerradura en %s

Mensaje de ajuste; las notas que la cerradura en el archivo especificado fue con éxito soltada.

File::lockf es una interface de módulo Perl a la llamada de sistema lockf.

SINOPSIS

use File::lockf;

El archivo-Lockf es una interface a la llamada de sistema lockf. Perl apoya la llamada de sistema de multitud natalmente, pero esto no adquiere cerraduras de red. Perl también apoya la llamada de sistema fcntl, pero es algo feo para usar. Hay otros módulos de cierre disponibles para Perl, pero ninguno de ellos proporcionó lo que quise - una interface simple, limpia a la llamada de sistema lockf, sin cualquier campana o silbidos que entran en el camino.

El archivo-Lockf contiene cuatro funciones que trazan un mapa directamente a los cuatro modos de lockf, y una clase de envoltura OO que encapulates la funcionalidad de cierre básica junto con un método de herramienta adicional que iterativamente intenta adquirir una cerradura.

Funciones de cerradura

Las funciones siguientes vuelven 0 (cero) en el éxito, y el número de error de sistema de errno en el fracaso. Cada uno de ellos toma un controlador de archivos abierto como el primer argumento, y opcionalmente un parámetro de tamaño. Por favor ver su sistema lockf página de hombre para más detalles sobre la funcionalidad lockf en su sistema.

$status = File::lockf::lock (FH, ponga la talla = 0)
Esta función traza un mapa al modo F_LOCK de lockf.

$status = File::lockf::tlock (FH, ponga la talla = 0)
Esta función traza un mapa al modo F_TLOCK de lockf.

$status = File::lockf::ulock (FH, ponga la talla = 0)
Esta función traza un mapa al modo F_ULOCK de lockf.

$status = File::lockf::test (FH, ponga la talla = 0)
Esta función traza un mapa al modo F_TEST de lockf.

Envoltura de OO

El archivo-Lockf también proporciona una clase de envoltura OO simple alrededor de la funcionalidad que se cierra, que permite que usted para crear una cerradura se oponga para un controlador de archivos y luego realizar operaciones de cerradura con ello. Todos los métodos vuelven 0 (cero) en el éxito, y el número de error de sistema de errno en el fracaso.

$lock = nuevo File::lockf (*FH)

Esta función devuelve un nuevo objeto de cerradura atado al controlador de archivos dado. Note que usted tiene que pasar una referencia al controlador de archivos al constructor, no el controlador de archivos sí mismo.

El $status = $lock-> cerradura (ponen la talla = 0)
Este método llama File::lockf::lock en el controlador de archivos atado.

El $status = $lock-> tlock (ponen la talla = 0)
Este método llama File::lockf::tlock en el controlador de archivos atado.

El $status = $lock-> ulock (ponen la talla = 0)
Este método llama File::lockf::ulock en el controlador de archivos atado.

El $status = $lock-> prueba (ponen la talla = 0)
Este método llama File::lockf::test en el controlador de archivos atado.

El $status = $lock-> slock (cuentan = 5, retraso = 2, tamaño = 0)
Este método intentará cerrar con llave el controlador de archivos atado <cuenta> tiempos, durmiendo <el retraso> segundos después de cada intento. Esto volverá 0 si la cerradura tuviera éxito, o el número de error de sistema de errno si todas las tentativas fallan.

El Daizu:: Archivo es unos archivos de representación de clase Perl en copias trabajadoras.

Cada objeto de esta clase representa un archivo particular en un Daizu CMS trabajando la copia (un registro en la tabla de wc_file).

MÉTODOS

Note que todas las funciones que devuelven el valor de una propiedad de Subversión quitarán la conducción y el rastreo whitespace, y tratarán un valor que es vacío o completamente whitespace como si esto juego de wasnt en absoluto.

Daizu:: Archivo-> nuevo ($cms, $file_id)

Devuelva nuevo Daizu:: objeto de Archivo para el archivo con el número de identificación especificado.

$file-> datos

Devuelva una referencia a una cuerda que contiene los datos de archivo (contenido).

$file-> wc

Devuelva un Daizu:: Wc objeto que representa la copia trabajadora en la cual este archivo vive.

$file-> guid_uri

Devuelva el GUID URI para este archivo.

$file-> directory_path

Devuelve el paso de un directorio, el mismo como el archivo si su un directorio sí mismo, o el paso de su directorio principal, o si su al nivel superior.

$file-> permalink

Devuelve el primer URL generado por el archivo, que será el URL que usted quiere conectar con la mayor parte del tiempo. Para artículos esto siempre será la versión de HTML normal del artículo, aun si también hay otros URLs disponibles para ello, y siempre será la primera página de artículos de multipágina. Para archivos de no artículo no hay ninguna garantía sobre lo que esto devolverá, pero la mayoría sólo generará un URL solo de todos modos, y para aquellos que los generadores dont probablemente devolverán la mayor parte de URL linkable primero.

El URL devuelto es un URL absoluto proporcionado como un objeto de URI.

Las devoluciones nada si el archivo doesnt genera algún URL.

Hay algunos casos donde esto no podría ser lo que usted quiere. Por ejemplo, el directorio raíz de un sitio web usando Daizu:: General no generará o un URL en absoluto, o generará un para un Google sitemap XML archivo, ninguno de los cuales probablemente será útil para la conexión. Para conseguir el URL del sitio web usted tendría que probablemente encontrar que un archivo llamó algo como _index.html. Por otra parte, el Daizu:: generador de Blog:: general le dará un URL prudente para la página de inicio de blog si usted llama esto en su directorio raíz.

$file-> urls_in_db ($method, $argument)

Devuelva una lista de los URLs (cuerdas claras, cada uno URI absoluto) del archivo que tienen el método especificado y valores de argumento, que dibujan de la tabla de url en la base de datos.

$file-> article_urls

Devuelva la información sobre los URLs que el archivo debería tener, si es un artículo. Falla si esto isnt.

File::CounterFile es una clase contraria persistente.

SINOPSIS

use File::CounterFile;
$c = Archivo:: CounterFile-> nuevo ("CONTADOR", "aa00");

$id = $c-> inc;
abierto (F, "> F$id");

Este módulo pone en práctica una clase contraria persistente. Cada contador es representado por un archivo separado en el sistema de archivo. El cierre de archivo es aplicado, entonces procesos múltiples pueden intentar tener acceso a un contador simultáneamente sin el riesgo de la destrucción contraria.

Usted da el nombre de fichero como el primer parámetro al constructor de objeto (nuevo). El archivo es creado si no existe.

Si el nombre de fichero no comienza "con/" o ".", entonces es interpretado como un archivo con relación al $File:: Contraarchivo:: DEFAULT_DIR. El valor por defecto para esta variable es iniciado de la variable de ambiente TMPDIR, o/usr/tmp si ninguna variable de ambiente es definida. Usted puede querer adjudicar un valor diferente a esta variable antes de crear el contador.

Si usted pasa un segundo parámetro al constructor, esto pone el valor inicial para un nuevo contador. Este parámetro sólo entra en vigor cuando el archivo es creado (es decir esto no existe antes de la llamada).

Cuando usted llama el inc () método, usted incrementa el valor contrario por uno. Cuando usted llama diciembre (), el valor contrario es decremented. En ambos casos el nuevo valor es devuelto. El diciembre () método sólo trabaja para el contador numérico (dígitos sólo).
Usted puede echar una ojeada al valor del contador (sin incrementarlo) usando el valor () método.

El contador puede ser cerrado con llave y abierto con la cerradura () y abrir () métodos. Incrementar y recuperación de valor es más rápido cuando el contador es cerrado con llave, porque no tenemos que actualizar el archivo contrario todo el tiempo. Usted puede preguntar si el contador es cerrado con llave con el cerrado con llave () método.

También hay un operador que sobrecarga la interface al File::CounterFile objeto. Esto significa que usted puede usar al operador ++ para incrementar y el - operador para decrementing el contador, y usted puede interpolar el contador directamente en cuerdas.