La copia de seguridad de ESR es un sistema de reserva fácil de usar simple para UNIX y Linux. Esto proporciona un simple, fácil a configurar la solución para la integridad de sistema de archivo.

La copia de seguridad de ESR proyecta trabajos en un ciclo de 2 semanas automático para asegurar que usted tiene un fácil para recuperar el sistema.

Aquí están algunos aspectos claves "de la copia de seguridad de ESR":

· Simple y fácil a configurar
· Dirección de Rotación de Archivo de 2 semanas Automática
· Almacenaje Remoto vía protocolo de transferencia de archivos
· Almacenaje de Archivo Local
· Cifrado con Teclas de 448 bits
· COMPLETAMENTE LIBRE de usar

La copia de seguridad de ESR toma la complicación de apoyos diarios, esto hace todo el trabajo para usted así usted puede concentrarse en cosas más interesantes. La copia de seguridad de ESR automáticamente realiza copias de seguridad debidamente Llenas e Incrementales en la lista siguiente

El lunes - copia de seguridad Llena
El martes - copia de seguridad Incremental
El miércoles - copia de seguridad Incremental
El jueves - copia de seguridad Incremental
El viernes - copia de seguridad Incremental
El sábado - copia de seguridad Incremental
El domingo - copia de seguridad Llena

Esto mantiene 3 directorios, semana corriente, última semana, y semanario-archivos. Después de que la copia de seguridad llena es realizada el domingo, automáticamente hace girar la última copia de seguridad llena del directorio de última semana al semanario-archivo para el cuidado seguro. Esto entonces borra los otros archivos porque ellos ya no son necesarios.

Esto automáticamente alterna todos los archivos del directorio de semana corriente al directorio de última semana. El directorio de semana corriente está listo entonces para sostener siguientes copias de seguridad de semanas. Usted siempre mantiene 2 juegos completos de copias de seguridad. Y todos sus viejos archivos están listos para ser almacenados en cinta o CD o se manejaron cualquier modo que usted elige.

La copia de seguridad de ESR le provee del almacenaje de archivo remoto vía el protocolo de transferencia de archivos entonces usted puede mantener conjuntos de copias de seguridad corrientes del sitio web fácilmente. Si usted dont tienen el acceso a un servidor de protocolo de transferencia de archivos remoto, o no desean usar el que. La copia de seguridad de ESR puede almacenar archivos en el sistema de archivo local en un directorio que usted elige. Usted también puede cifrar sus archivos con una tecla de cifrado de 448 bits.

el bit es un C ++ biblioteca para manipular memorias intermedias que contienen espacios de datos que no son el octeto (byte) alineado.

Los formatos de datos binarios que contienen espacios que no son el octeto alineado todavía son comunes. Una mirada de necesidad no adelante que la cabecera de IP que está presente en cada paquete de datos transmitidos en el Internet.

Además muchos dispositivos empotrados y los sensores todavía se comunican vía formatos binarios, y era para éste (sensores robóticos) que esta biblioteca fue al principio desarrollada.

La biblioteca de bit permite que formatos de datos sean especificados en el tiempo de ejecución por métodos de clase o cargados de archivos XML en el tiempo de ejecución (incluso cualquier combinación de eso).

Una biblioteca de compañero, bitgtk, proporciona un juego de artefactos Gtkmm para la visualización de representaciones de memoria intermedia de bit.

El proyecto de reserva añade el control de versión inmediato a cualquier archivo en un sistema de UNIX.

¿odia Usted *.bak y *.20050101 y *.cjn (¿sus iniciales aquí) y archivos *.do.not.touch tanto como hago? Ellos ensucian su sistema de ficheros cualquier tiempo alguien (y eran todos culpables de ello) necesita a la copia de seguridad un archivo theyre seguir trabajando.

¿Pero quién alguna vez vuelve y limpia el lío? ¿En que punto es un viejo el archivo hecho una copia de seguridad ya no necesario? ¿Y cuando usted necesita aquella copia de seguridad sólo para descubrir que su ausencia, o usted didnt capturan el que porque usted didnt quiere añadir el desorden? La copia de seguridad es mi respuesta a todo esto. Esto añade el control de versión al instante disponible, confiable a cada archivo en el sistema de ficheros.

La copia de seguridad es una interface ligera a la Subversión svn_fs biblioteca. Esto usa el software de control de versión potente como una parte trasera a un simple y minimalistic (aunque eficaz) interface de usuario. Es diseñado para el uso en el Linux/UNIX (incluso OS X) sistemas como un método de archivar archivos de configuración que cambian semicon frecuencia, pero hacen no necesariamente warrent su propio mecanismo de control de versión o depósito. Cosas como "/etc/hosts" o "httpd.conf".

Esto puede crear una copia de seguridad de cualquier archivo sin necesidad tener de importarlo primero, sin preocuparse de alistar nuevos depósitos, (y porque esto habla directamente a la capa FS) sin ensuciar ".svn" escondido (o aún peor, visable "CVS") directorios por todas partes. Esto hace esto usando "un archivo" global solo, que contiene un sistema de ficheros que refleja su raíz cuando usted añade a ello. Usted puede ver el archivo y restaurar archivos, hacer diffs, y trasladar cosas si es necesario. Para la administración más compleja, el archivo es un sistema de archivo de Subversión estándar que puede ser administrado con cualquier cliente compatable (incluso las herramientas de línea de orden de svn).

La versión corriente es golpeada juntos en Perl. Su alfa, pero es bastante funcional... al menos para una prueba de concepto. Finalmente planeo volverlo a escribir en C... pero sabemos sobre "los mejores proyectos puestos." En el medio mientras, la versión Perl realmente trabaja... sobre todo. La única verdadera broma es que usted tiene que compilar e instalar la Subversión bindings para ello Perl. Hay algunos otros módulos que usted puede necesitar también, pero theyre todos bastante estándares.

Uso:

Usted probablemente shouldnt si usted youre hacer trabajo crítico de la misión. Su todavía código alfa después de todo. Pero si usted realmente decide darlo una vuelta, los dont me culpan de cualquier rotura (la única cosa que debería dañar archivos existentes es la combinación de-r y-o, que sobreescribirá durante restaurar).

El Mozilla:: copia de seguridad es un módulo Perl como una herramienta de reserva para perfiles de Mozilla.

SINOPSIS

$moz = Mozilla:: copia de seguridad-> nuevo ();
$file = $moz-> backup_profile ("firefox", "falta");

Este paquete proporciona una interface simple para hacer una copia de seguridad y restaurar los perfiles de aplicaciones Mozilla-relacionadas, como el Firefox o Thunderbird.

Las llamadas de método pueden usar llamado o parámetros posicionales (llamado llamadas son recomendados). Los métodos son perfilados abajo:

nuevo

$moz = Mozilla:: copia de seguridad-> nuevo (%options);

Crea nuevo Mozilla:: objeto de Reserva. Las opciones son como sigue:

registro

Un Registro:: objeto de Mensaje para recibir mensajes de registro.
Este valor es pasado a enchufes de unión si ellos lo aceptan.

enchufe de unión

Un enchufe de unión para usar para archivar. Los enchufes de unión incluidos son:
Mozilla:: copia de seguridad:: Enchufe de unión:: Zip

Guarda el perfil en un archivo de zip. Esto es el enchufe de unión por defecto.

Mozilla:: copia de seguridad:: Enchufe de unión:: FileCopy

copia los archivos en el perfil en otro directorio.

Mozilla:: copia de seguridad:: Enchufe de unión:: Alquitrán

Guarda el perfil en el archivo de tar.gz o un alquitrán.

Usted puede pasar opciones al enchufe de unión en la manera siguiente:

$moz = Mozilla:: copia de seguridad-> nuevo (
enchufe de unión => [Mozilla:: copia de seguridad:: Enchufe de unión:: Alquitrán, comprima => 1],
);
excluir

Una referencia de matriz de expresiones regulares para archivos para excluir de la copia de seguridad. Por ejemplo,

$moz = Mozilla:: copia de seguridad-> nuevo (
excluya => [^history, ^Cache],
);

Las expresiones regulares pueden ser cuerdas o Regexps compilado.

En ausencia el Cache, <Cache. La basura> carpetas, cache de XUL, cache de carpetas de correo y archivos de cerradura es excluida.

El Autoextracto de:: de archivo es un módulo Perl para atar en un fardo archivos comprimidos al código de Perl.

SINOPSIS

use el Archivo:: Autoextracto;

# escribe el guión de producción a STDOUT
Archive el Autoextracto de:::: createExtractor ("perlcode.pl", "somefiles.zip");

# con varias opciones:
Archive el Autoextracto de:::: createExtractor ("perlcode.pl", "somefiles.zip",
perlbin => "/opt/perl58/bin/perl",
output_fh => $someFileHandle,
);
También ver las herramientas de línea de orden, mkselfextract.

Archive el Autoextracto de:: permite que usted cree programas de Perl de archivos de zip comprimidos. Considerando una pieza de código y un archivo, esto crea un archivo solo que, cuando ejecutado, desempaqueta el archivo y luego ejecuta el código.

Este módulo proporciona una función a crear un guión de autoextractor, una función para desempaquetar el archivo, y funciones de herramienta para programas envueltos

Archive:: Tyd es una extensión Perl para el archivo simple archivar.

SINOPSIS

use el Archivo:: Tyd;

mi $tyd = nuevo Archivo:: Tyd (contraseña => contraseña secreta);

# Cargue un archivo.
$tyd-> openArchive ("./archive.tyd");

# Añada un archivo.
$tyd-> addFile ("./secreto image.jpg");

# Escriba el archivo.
$tyd-> writeArchive ("./archive.tyd");

# Lea las reglas secretas.
mi $rules = $tyd-> readFile ("rules.txt");

Tyd es algorith simple que archiva para fusionar archivos múltiples juntos y cifrar los resultados, de ahí un archivo protegido de la contraseña.

Tyd Hace: Lectura y escritura de archivos de Tyd cifrados y operaciones de archivo dentro de.

Tyd Hace: Cargue todos los archivos en la memoria. Tyd no está bien como un dispositivo de almacenaje para quanitity grande de archivos grandes. ¿Tyd Es el mejor para guardar pequeños archivos de texto y gráficos juntos (¿tal vez para guardar un spriteset y definiciones para un juego?)

Tyd no Hace: directorios de apoyo dentro del archivo, compresión de archivos, y muchas otras cosas que WinZip y apoyo de GZip.

Archive:: Rar es una interface con el orden de rar.

SINOPSIS

use el Archivo:: Rar;
mi $rar =new Archivo:: Rar ();
El $rar-> Añade (
- ponen la talla => $size_of_parts,
- archivan => $archive_filename,
- archivos => @list_of_files,
);

Esto es un módulo para manejarse de archivos de rar.

Localiza el orden de rar (del PASO o de regedit para Win32) y encapsularlo para crear, extraer y poner archivos de rar en una lista.

En este momento estos métodos son puestos en práctica:

nuevo ()

Devuelve un nuevo objeto de Rar. Usted puede pasar opciones de faltas.

Añada (%options)

Añada el archivo a un archivo.

Extracto (%options)

Extraiga contener de un archivo.

Lista (%options)

Llene la variable de lista del objeto whith el índice de un archivo.

OPCIONES

- archivo

Nombre del archivo de archivo.

- archivos

Lista de archivos para añadir. Usted puede usar un valor escalar o una referencia de matriz.

- tranquilo

Ninguna producción para el rar manda de Ser verdadero.

-sfx

Cree el archivo de autoextracción.

- tamaño

Tamaño de las partes en bytes.

- verboso

Nivel de verbosidad.

El bit:: Vector es un vector de bit eficiente, puesto de números enteros "e int grande" biblioteca de matemáticas.

MÉTODOS de CLASE

Versión

$version = Bit:: Vector-> Versión ();

Word_Bits
$bits = Bit:: Vector-> Word_Bits (); # bits en una palabra de máquina

Long_Bits
$bits = Bit:: Vector-> Long_Bits (); # bits en un no firmado mucho tiempo

nuevo
$vector = Bit:: Vector-> nuevo ($bits); # constructor de vector de bit

@veclist = Bit:: Vector-> nuevo ($bits, $count);

new_Hex
$vector = Bit:: Vector-> new_Hex ($bits, $string);

new_Bin
$vector = Bit:: Vector-> new_Bin ($bits, $string);

new_Dec
$vector = Bit:: Vector-> new_Dec ($bits, $string);

new_Enum
$vector = Bit:: Vector-> new_Enum ($bits, $string);

Concat_List
$vector = Bit:: Vector-> Concat_List (@vectors);
MÉTODOS de OBJETO
nuevo
$vec2 = $vec1-> nuevo ($bits); # llamada alternativa de constructor

@veclist = $vec-> nuevo ($bits, $count);

Sombra
$vec2 = $vec1-> Sombra (); # nuevo vector, mismo tamaño pero vacío

Clon

$vec2 = $vec1-> Clon (); # nuevo vector, duplicado exacto

Concat
$vector = $vec1-> Concat ($vec2);

Concat_List
$vector = $vec1-> Concat_List ($vec2, $vec3...);

Tamaño
$bits = $vector-> Tamaño ();

Cambiar el tamaño
El $vector-> Cambia el tamaño ($bits);
El $vector-> Cambia el tamaño ($vector-> Tamaño () +5);
El $vector-> Cambia el tamaño ($vector-> Tamaño ()-5);

copia
$vec2-> copia ($vec1);

Vacío
$vector-> Vacío ();

Llenarse
El $vector-> Se llena ();

Capirotazo
$vector-> Capirotazo ();

Flor de la vida
$vector-> Flor de la vida (); # Tamiz de Erathostenes

Revés
$vec2-> Revés ($vec1);

Interval_Empty
$vector-> Interval_Empty ($min, $max);

Interval_Fill
$vector-> Interval_Fill ($min, $max);

Interval_Flip
$vector-> Interval_Flip ($min, $max);

Interval_Reverse
$vector-> Interval_Reverse ($min, $max);

Interval_Scan_inc
si (($min, $max) = $vector-> Interval_Scan_inc ($start))

Interval_Scan_dec
si (($min, $max) = $vector-> Interval_Scan_dec ($start))

Interval_Copy
$vec2-> Interval_Copy ($vec1, $offset2, $offset1, $length);

Interval_Substitute
$vec2-> Interval_Substitute ($vec1, $off2, $len2, $off1, $len1);

is_empty
si ($vector-> is_empty ())

is_full
si ($vector-> is_full ())

igual
si ($vec1-> igual ($vec2))

Lexicompare (no firmado)
si ($vec1-> Lexicompare ($vec2) == 0)
¡si ($vec1-> Lexicompare (¡$vec2)! = 0)
si ($vec1-> Lexicompare ($vec2) <0)
si ($vec1-> Lexicompare ($vec2) <= 0)
si ($vec1-> Lexicompare ($vec2)> 0)
si ($vec1-> Lexicompare ($vec2)> = 0)

Compárese (firmado)
si ($vec1-> Se comparan ($vec2) == 0)
¡si ($vec1-> Se comparan (¡$vec2)! = 0)
si ($vec1-> Se comparan ($vec2) <0)
si ($vec1-> Se comparan ($vec2) <= 0)
si ($vec1-> Se comparan ($vec2)> 0)
si ($vec1-> Se comparan ($vec2)> = 0)

to_Hex
$string = $vector-> to_Hex ();

from_Hex
$vector-> from_Hex ($string);

to_Bin
$string = $vector-> to_Bin ();

from_Bin
$vector-> from_Bin ($string);

to_Dec
$string = $vector-> to_Dec ();

from_Dec
$vector-> from_Dec ($string);

to_Enum
$string = $vector-> to_Enum (); # p.ej "2,3,5-7,11,13-19"

from_Enum
$vector-> from_Enum ($string);

Bit_Off
$vector-> Bit_Off ($index);

Bit_On
$vector-> Bit_On ($index);

bit_flip
$bit = $vector-> bit_flip ($index);

bit_test
contiene
$bit = $vector-> bit_test ($index);
El $bit = $vector-> contiene ($index);
si ($vector-> bit_test ($index))
si (el $vector-> contiene ($index))

Bit_Copy
$vector-> Bit_Copy ($index, $bit);

LSB (el bit menos significativo)
$vector-> LSB ($bit);

MSB (el bit más significativo)
$vector-> MSB ($bit);

lsb (el bit menos significativo)
$bit = $vector-> lsb ();

msb (el bit más significativo)
$bit = $vector-> msb ();

rotate_left
$carry = $vector-> rotate_left ();

rotate_right
$carry = $vector-> rotate_right ();

shift_left
$carry = $vector-> shift_left ($carry);

shift_right
$carry = $vector-> shift_right ($carry);

Move_Left
$vector-> Move_Left ($bits); el cambio # dejó posiciones "de $bits"

Move_Right
$vector-> Move_Right ($bits); posiciones "de $bits" de derecho de cambio #

Encarte
$vector-> Encarte ($offset, $bits);

Borrar
El $vector-> Borra ($offset, $bits);

incremento
$carry = $vector-> incremento ();

decremento
$carry = $vector-> decremento ();

inc
$overflow = $vec2-> inc ($vec1);

diciembre
$overflow = $vec2-> diciembre ($vec1);

añadir
El $carry = $vec3-> añade ($vec1, $vec2, $carry);
($carry, $overflow) = $vec3-> añaden ($vec1, $vec2, $carry);

restar
El $carry = $vec3-> resta ($vec1, $vec2, $carry);
($carry, $overflow) = $vec3-> restan ($vec1, $vec2, $carry);

Neg
Negar
$vec2-> Neg ($vec1);
El $vec2-> Niega ($vec1);

Abs
Absoluto
$vec2-> Abs ($vec1);
$vec2-> Absoluto ($vec1);

Signo
si ($vector-> Signo () == 0)
¡si ($vector-> Signo (¡)! = 0)
si ($vector-> Signo () <0)
si ($vector-> Signo () <= 0)
si ($vector-> Signo ()> 0)
si ($vector-> Signo ()> = 0)

Multiplicarse
El $vec3-> Se multiplica ($vec1, $vec2);

Dividirse
El $quot-> Se divide ($vec1, $vec2, $rest);

GCD (el Mayor Común divisor)
$vecgcd-> GCD ($veca, $vecb);
$vecgcd-> GCD ($vecx, $vecy, $veca, $vecb);

Energía
$vec3-> Energía ($vec1, $vec2);

Block_Store
$vector-> Block_Store ($buffer);

Block_Read
$buffer = $vector-> Block_Read ();

Word_Size
$size = $vector-> Word_Size (); # número de palabras en "$vector"

Word_Store
$vector-> Word_Store ($offset, $word);

Word_Read
$word = $vector-> Word_Read ($offset);

Word_List_Store
$vector-> Word_List_Store (@words);

Word_List_Read
@words = $vector-> Word_List_Read ();

Word_Insert
$vector-> Word_Insert ($offset, $count);

Word_Delete
$vector-> Word_Delete ($offset, $count);

Chunk_Store
$vector-> Chunk_Store ($chunksize, $offset, $chunk);

Chunk_Read
$chunk = $vector-> Chunk_Read ($chunksize, $offset);

Chunk_List_Store
$vector-> Chunk_List_Store ($chunksize, @chunks);

Chunk_List_Read
@chunks = $vector-> Chunk_List_Read ($chunksize);

Index_List_Remove
$vector-> Index_List_Remove (@indices);

Index_List_Store
$vector-> Index_List_Store (@indices);

Index_List_Read
@indices = $vector-> Index_List_Read ();

O

Unión
$vec3-> (o $vec1, $vec2);
$set3-> Unión ($set1, $set2);

Y
Intersección
$vec3-> (y $vec1, $vec2);
$set3-> Intersección ($set1, $set2);

AndNot
Diferencia
$vec3-> AndNot ($vec1, $vec2);
$set3-> Diferencia ($set1, $set2);

Xor
ExclusiveOr
$vec3-> Xor ($vec1, $vec2);
$set3-> ExclusiveOr ($set1, $set2);

No

Complemento
$vec2-> No ($vec1);
$set2-> Complemento ($set1);

subconjunto
si ($set1-> subconjunto ($set2)) # verdadero si el $set1 es el subconjunto del $set2

Norma
$norm = $set-> Norma ();
$norm = $set-> Norm2 ();
$norm = $set-> Norm3 ();

Minuto
$min = $set-> Minuto ();

Max
$max = $set-> Max ();

Multiplicación
$matrix3-> Multiplicación ($rows3, $cols3,
$matrix1, $rows1, $cols1,
$matrix2, $rows2, $cols2);

Producto
$matrix3-> Producto ($rows3, $cols3,
$matrix1, $rows1, $cols1,
$matrix2, $rows2, $cols2);

Cierre
$matrix-> Cierre ($rows, $cols);

Transportar
El $matrix2-> Transporta ($rows2, $cols2, $matrix1, $rows1, $cols1);

Archive:: TarGzip es un módulo Perl para guardar y devolver archivos a y de la cinta comprimida archiva (alquitrán).

SINOPSIS

######
# Interface de Subrutina
#
use el Archivo:: TarGzip qw (parse_header no alquitrán de alquitrán);

$tar_file = alquitrán (@file, @options);
$tar_file = alquitrán (@file);

$success = no alquitrán (@file);
$success = no alquitrán (@file, @options);

%tar_header = parse_header ($buffer);

######
# Subrutinas de archivo
#
use el Archivo:: TarGzip;

el lazo *TAR_FILEHANDLE, Lazo:: Capas
el lazo *TAR_FILEHANDLE, Lazo:: Capas, @options

$success = abierto (TAR_FILEHANDLE, $tar_file);
$success = abierto (TAR_FILEHANDLE, $mode, $tar_file);

El $success = imprime el $file_name TAR_FILEHANDLE;
El $success = imprime el $file_name TAR_FILEHANDLE, $file_contents;

%tar_header =;

$success = cerca (TAR_FILEHANDLE);

######
# Objeto
#
el lazo *TAR_FILEHANDLE, Lazo:: Capas;
el lazo *TAR_FILEHANDLE, Lazo:: Capas, @options;

El $tar = ató *TAR_FILEHANDLE;
$tar = nuevo Archivo:: TarGzip ();
$tar = nuevo Archivo:: TarGzip (@options);

$success = $tar-> ABIERTO ($tar_file, @options);
$success = $tar-> ABIERTO ($mode, $tar_file, @options);

$success = $tar-> LETRA ($file_name);
$success = $tar-> LETRA ($file_name, $file_contents);

%tar_header = $tar-> READLINE (@options);
%tar_header = $tar-> READLINE (@file, @options);

$status = $tar-> objetivo ($buffer, $size);
$success = $tar-> CERCA ();

El Archivo:: TarGzip módulo proporciona la subrutina de alquitrán para archivar una lista de archivos en un archivo de archivo en el formato de alquitrán. El archivo de archivo puede ser opcionalmente comprimido usando las rutinas de compresión gzip. El Archivo:: TarGzip módulo también proporciona una subrutina de no alquitrán que puede extraer los archivos del alquitrán o archivos de archivo de tar/gzip. El alquitrán y las subrutinas de nivel de cumbre de no alquitrán usan métodos del Archivo:: TarGzip clase.

El Archivo:: TarGzip clase tiene muchas semejanzas para el Archivo muy maduro:: clase de Alquitrán que es al menos tres años más viejos. El Archivo más nuevo:: TarGzip confió muy pesado en el trabajo del autor del Archivo:: Alquitrán y en muchos citan como ejemplo el Archivo:: el Alquitrán es una mejor solución.

Altough el formato de archivo de alquitrán subyacente es el mismo código y similar es usado para tener acceso a los datos en los archivos de alquitrán subyacentes, el interas bewteen los dos son completamente diferentes. El Archivo:: TarGzip es basado en una interface de tipo de Controlador de archivos de Lazo. El Archivo de nthe:: TarGzip proporciona medios de tener acceso a archivos individuales dentro del archivo de archivo sin traer el archivo de archivo entero en la memoria. Cuando la opción de compresión gzip es activa, la compresión es realizada al vuelo sin crear un intermedio no comprimió el archivo de alquitrán.

Archive:: Chm es un módulo Perl que realiza algunas operaciones sólo para leer en la ayuda de HTML (.chm) archivos. La variedad de operaciones incluye contenido de enumeración, extracción de contenido y adquisición de la información sobre una cierta parte del archivo.

El módulo reemplaza el Texto:: Chm escrito por Domenico Delle Side. El método get_filelist () y todas sus dependencias es tomado casi "cuando - es" del Texto:: Chm como escrito por Domenico.

SINOPSIS

mi $test = Archivo:: Chm-> nuevo ("TestPrj.chm");

#make el registro de módulo su actividad
$test-> set_verbose (1);
$test-> set_logfile ("chmfile.log");

#set la función autosobreescribir a lejos
$test-> set_overwrite (0);

#enumerate los contenido del archivo
$test-> enum_files ("listing.txt", 1);

#extract todos los artículos en un cierto directorio
$test-> extract_all ("."/);

#extract un artículo solo del archivo
$item = $test-> ("/Secret de Isla de Mono Solution.html";

#or sólo consiguen la longitud del artículo
$test-> get_item_length ("/ Secreto de Isla de Mono Solution.html");

#get completan la información sobre el archivo de chm
@content = $test-> get_filelist ();
foreach (@content) {
$ de letra _-> {título}. "n" si $ definido _-> {título};
$ de letra _-> {paso}. "n";
$ de letra _-> {tamaño}. "n";
}

#p.s. Hay modos de comprobar errores, sólo buscar cada método y ver. :)

Archive:: Chm es un módulo que proporciona el acceso a archivos de Microsoft Compiled HTML Help (chm archivos). Mucho software todays transporta con la documentación en el formato de.chm. Sin embargo Microsoft sólo proporciona herramientas que ven a su propio OS y la compañía los doesnt revelan la especificación de formato.

Las especificaciones no oficiales pueden ser encontradas en el sitio web de Matthew T. Russottos: http://www.speakeasy.org/~russotto/chm/chmformat.html

El módulo es básicamente una envoltura de Alas Jed chmlib, una biblioteca C que proporciona el acceso a todos los archivos de ITSS, aunque.chm sea el único archivo de tipo de ITSS en el uso hoy. Para usar este módulo usted necesita chmlib instalado en su sistema. Usted puede conseguirlo en: http://66.93.236.84/~jedwin/projects/chmlib/

Actualmente el acceso a archivos.chm es sólo para leer y esto cambiará con el tiempo si el Ala Jed moderniza su biblioteca. Las operaciones apoyadas consiguen un listado de los contenido, extracción del que o todos los artículos en el archivo y recuperar una longitud de artículos.

La Búsqueda de Archivo es una extensión que muestra unas versiones archivadas de la página Web.

Muestra unas versiones archivadas de la página Web.

Primero haga clic: Archivo de Internet
Segundo clic: cache de Google
Tercer clic: Yahoo
Cuarto clic: MSN

Los WormBase:: Archivo:: Construyen puede crear archivos de liberaciones de Wormbase.

SINOPSIS

use:: bio GMOD:: Admin:: Archivo;
mi $archive =:: bio GMOD:: Admin:: Archivo-> nuevo ();

$archive-> create_archive ();

MÉTODOS

:: bio GMOD:: Admin:: Archivo-> nuevo (@options)
Cree nuevo WormBase:: objeto de Archivo para archivar liberaciones de WormBase.

Las opciones consisten en gran parte en sistema de archivo y pasos remotos. Si ninguno es proporcionado, ellos serán todos poblados del archivo por defecto localizado en el servidor WormBase primario.

Esto es la locución recomendada cuando aísla sus programas de cambios estructurales en WormBase. En este caso, los archivos serán construidos en/pub/wormbase/RELEASE donde la LIBERACIÓN es una liberación de WSXXX.

Hay, sin embargo, al menos dos opciones que usted deseará proporcionar:

- database_repository paso Lleno donde almacenar archivos en su sistema de ficheros
- mysql_path paso Lleno a los datos mysql dir

Ver WormBase.pm para detalles adicionales de todos los pasos dependientes del sistema que pueden ser anulados.

La clase de archivo es un guión de golpe que clasifica directorios en directorios de 4.4 gigabytes manejables para archivar en DVDs.

Es útil si usted tiene varias decenas o cientos de gigabytes de datos para archivar. También puede ser configurado para clasificar en directorios de 700 mb para archivar en CDs.

Uso:./archive-sort [-h] [-s PONEN LA TALLA] [-t] [-v] DEST de la fuente

Archivos de archivo de directorio DEST a nuevo directorio FUENTE en cachos de 4.4 gigabytes,
o cualquier TAMAÑO especificado por el usuario.

Este guión no ha sido probado extensivamente, entonces se recomienda que usted haga una copia del directorio que usted quiere archivar, luego ejecutar el guión en aquel directorio. Siempre use el-t (prueba) opción primero y con cuidado lea la producción antes de usar el guión.

Argumentos opcionales.

Letra de-h este mensaje de ayuda.
Tamaño de-s de los medios de archivo (4.4 gigabytes por defecto)
La Prueba de-t se ejecuta con mensajes verbosos.
-v Verboso

Ejemplos:

Primero cd a directorio que contiene directorios para ser archivados:

cd/home/user/archive
clase del archivo.../disc01

Esto es útil si usted tiene varios directorios grandes bajo/home/user/archive, pero ningunos archivos. El directorio de archivo no será incluido en disc01.

Si usted tiene un directorio lleno de muchos archivos, entonces cd al directorio principal del directorio que tiene que ser archivado:

cd/home/user
archivo de clase del archivo disc01

El Constructor:: del archivo es una generación de archivo y marco que archiva.

SINOPSIS

# Haga a un constructor con una sección, y algunos archivos
mi $Builder = Archivo:: Constructor-> nuevo;
mi $Section = $Builder-> new_section (html);
$Section-> add_file (one.html, cuerda, qq ~
¡Hola Mundo!
~ );
$Section-> add_file (two.html, archivo, ./source/file.html);
$Section-> add_file (three.html, Costumbre:: función, @args);

# Genere y guarde al disco
El $Builder-> guarda (./en algún sitio);

# Cree un archivo de zip de ello y guárdelo.
mi $Archive = $Builder-> archivo (zip).
El $Archive-> guarda (foo.zip);

# Cree un archivo tar.gz de sólo una sección
mi $Tar = $Section-> archivo (tar.gz);

Perl a menudo está usado para aplicaciones que generan grandes números de archivos, y el Archivo:: Constructor es diseñado para asistir en estas clases de tareas.

Esto proporciona un marco a definir un juego de archivos, y como ellos serán generados, y una serie de métodos para convertirlos en un Archivo de variar tipos, o guardar directamente al disco.

El archivo de extracto es un menú de servicio que permite que usted extraiga cualquier archivo de archivo que el refugio es capaz para leer + archivos ESTUPENDOS.

Usted puede decidió extraer aquí, o en un subdirectorio. En este caso, esto le pregunta el nombre del subdirectorio donde usted quiere extraer, y le sugiere el nombre de archivo en ausencia.

Para instalar, simplemente extraiga, y mueva los 2 archivos a ~/.kde/share/apps/konqueror/servicemenus

Su muy recomendado para descargar la última versión de no as en www.winace.com y ejecutar esta línea de orden en la posición de directorio no estupenda: los sudo cp no hacen un ace/usr/bin/unace

Usted debería la integración de refugio desactivate en kde entrando en el menú de configuración del refugio.

Si usted quiere que la traducción sea añadida, póngame una nota comentarios.

Whats Nuevo en Esta Liberación:

· gracias a shirka, el paso de archivo de extracto es ahora "la prueba" de un archivo "de prueba tar.bz2"
· Nombre que aparece en el menú es ahora "el archivo de Extracto" como aconsejado por dovidhalevi distinguir con el refugio

el xDash:: Archivo:: Pg es una clase baja para el Archivo.

SINOPSIS

Archivo de paquete;
use la base xDash:: Archivo:: Pg;
# Aliste sus propios parámetros de acceso de base de datos
suscripción SetParameters {cambio->:: súper SetDatabaseConnection (
llame => xdash, usuario =>, contraseña =>)}

USO

El módulo es desarrollado del modo orientado del objeto. Puede estar usado como la clase baja para archivar basado en PostgreSQL como la persistencia. La clase baja tiene que poner en práctica un juego fijo de métodos, llamados por el Archivo de clase sacado. El archivo es codificado por hardware en el xDash:: el Archivista (modelo de driver).

Para más detalles, como alistar todos los componentes necesarios, ver la introducción al despliegue: Planificación y despliegue xDash en un cajón de arena en http://xdash.jabberstudio.org/deployment/perl. Derivándose de la clase, como el modo de pasar argumentos, usted tiene que poner en práctica métodos explícitos puestos en una lista abajo. La sinopsis encima es un ejemplo del guión de cliente generado por el xdscr.

MÉTODOS

SetDatabaseConnection (llaman => $database_name, usuario => $database_user, contraseña => database_password)

Pasa el mí parámetros explicativos al módulo DBI, requerido por xDash:: Archivista.

El Bit de MCP2510 que Calcula el proyecto de Calculadora calcula un poco la calculadora para el MCP2510.

Esto calcula un poco la calculadora que es muy fácil de usar.

Todo que usted tiene que hacer debe elegir el baudrate y la oscilator-frecuencia.

Seguro usted puede corregir y cambiar todo el ajuste. Usted verá un bit gráfico calcular el diagrama que le muestran sus opciones corrientes.

Al final usted conseguirá un informe detallado de sus opciones choosen. Ver un ejemplo aquí: mcp2510btn

HowTo

En el primer paso usted tiene que elegir su baudrate deseado y la oscilator-frecuencia.

Segundo usted conseguirá una gran tabla con todo avaible baudrate para usted oscilator-frecuencia. Ser ya choosen algún baudrates si su baudrate iguala con unos en la tabla. Por otra parte usted tiene que seleccionarlos a mano, pero usted conseguirá desviaciones a usted choosen baudrate. Usted va la desviación en el por ciento en la tabla correcta.

Cuando usted está listo usted puede ir adelante para andar tres.
Aquí usted tiene que seleccionar primero su Tiempo de bit Nominal querido Screenshot 2 [Paso 3] y luego usted puede corregir/cambiar a valores para los segmentos solos del un poco cronometraje.

El Zip:: del archivo es un módulo Perl que proporciona una interface para COMPRIMIR de archivos de archivo.

SINOPSIS

# Cree un archivo de Zip
use el Archivo:: Zip qw (:ERROR_CODES:CONSTANTS);
mi $zip = Archivo:: Zip-> nuevo ();

# Añada un directorio
mi $dir_member = $zip-> addDirectory (dirname/);

# Añada un archivo de una cuerda con la compresión
mi $string_member = $zip-> addString (Esto es una prueba, stringMember.txt);
$string_member-> desiredCompressionMethod (COMPRESSION_DEFLATED);

# Añada un archivo del disco
mi $file_member = $zip-> addFile (xyz.pl, AnotherName.pl);

# Guarde el archivo de Zip
a menos que ($zip-> writeToFileNamed (someZip.zip) == AZ_OK) {
muera escriben el error;
}

# Lea un archivo de Zip
mi $somezip = Archivo:: Zip-> nuevo ();
a menos que ($somezip-> leído (someZip.zip) == AZ_OK) {
muera el error leído;
}

# Cambie el tipo de compresión para un archivo en el Zip
mi $member = $somezip-> memberNamed (stringMember.txt);
$member-> desiredCompressionMethod (COMPRESSION_STORED);
a menos que ($zip-> writeToFileNamed (someOtherZip.zip) == AZ_OK) {
muera escriben el error;
}

El Archivo:: módulo de Zip permite que un programa de Perl cree, manipule, lea, y escriba archivos de archivo de Zip.

Los archivos de zip pueden ser creados, o usted puede leer de archivos de zip existentes.
Una vez creado, ellos pueden ser escritos a archivos, corrientes, o cuerdas. Los miembros pueden ser añadidos, borrados, extraídos, reemplazados, reajustados, y enumerados. Ellos también pueden ser renombrados o tener sus fechas, comentarios, u otros atributos preguntados o modificados. Sus datos pueden ser comprimidos o no comprimidos como necesario.
Los miembros pueden ser creados de miembros en archivos de Zip existentes, o de directorios existentes, archivos, o cuerdas.

Este módulo usa la Compresa:: Zlib biblioteca para leer y escribir las corrientes comprimidas dentro de los archivos.

Las noticias:: Archivo son un paquete de archivando de noticias de Usenet para descargar y más tarde tener acceso a artículos de noticias al por mayor.

Esto puede cargar artículos presentados en el formato de POSADA, recuperarlos de un servidor de noticias que se ejecuta, o sólo tomar artículos uno tras otro. Las noticias:: módulo de Archivo son compatibles con Noticias:: Web y Red:: NNTP:: Servidor, entonces los artículos pueden ser compartidos vía la Web o vía NNTP.

SINOPSIS

use Noticias:: Archivo;
mi $archive = nuevas Noticias:: Archivo
(basedir =>/home/tskirvin/kiboze);

# Consiga un artículo de noticias
mi $article = Noticias:: Artículo-> nuevo (*STDIN);
mi $msgid = artículo-> cabecera (identificación del mensaje);

muera "el $msgidn Ya tratado"
si ($archive-> artículo ($messageid));

# Póngase la lista de grupos fueron supuestos guardar el artículo en
mi @groups = hendidura (s *, s *, $article-> cabecera (grupos de noticias));
trace un mapa {s/s +//g} @groups;

# Asegúrese fueron suscritos a estos grupos
los foreach (@groups) {$archive-> se suscriben ($ _)}

# Realmente guarde el artículo.
mi $ret = $archive-> save_article (
[{$article-> rawheaders}, {$article-> cuerpo}], @groups);
¿$ret? imprima "el artículo $messageidn Accepted"
: letra "Couldnt guarda el artículo $messageidn";

Las noticias:: Archivo guardan varios archivos para guardar la pista de sus archivos:

archivo activo

Guarda la pista de todos los grupos de noticias somos "suscritos" a y toda la información que cambia con regularidad - el número de artículos que hemos archivado, la corriente en general números de artículo, etc.

Vigilado con Noticias:: Activo.

base de datos de historia

Una pista de cuidado de base de datos simple de artículos por identificación del Mensaje. Hace el acceso por la identificación fácil, y asegura que dont guardamos el mismo artículo dos veces. La base de datos elegida para mantener a éstos es determinada por el usuario.

archivo de grupo de noticias

Guarda la pista de más información estática sobre los grupos de noticias somos suscritos a - descripciones, fechas de creación, etc.

Vigilado con Noticias:: GroupInfo.

directorio de archivo

La estructura de directorio de todos los artículos, con cada artículo guardó como textfile solo dentro de una estructura de directorio presentada en una sección del nombre de grupo por directorio, como el "rec/games/mecha". Las colocaciones cruzadas son hardlinked a otras estructuras de directorio.

Los artículos realmente están divididos en subdirectorios que contienen hasta 500 artículos, para evitar limitaciones de rendimiento de tamaño de directorio de UNIX. Los archivos individuales son así almacenados en un archivo, como el "rec/games/mecha/1.500/1".

Cada grupo de noticias también contiene la información de descripción, vigiló con
Noticias:: Descripción. Este archivo de descripción entra en la cumbre de la estructura,
tal como "rec/games/mecha/.overview".

Usted puede notar que estos archivos son muy similares a como la POSADA hace su trabajo. Esto es intencional - este paquete se supone para actuar desde muchos puntos de vista como una POSADA de peso más ligero.

Uso:

Variables Globales

Las variables siguientes son puestas dentro de Noticias:: Archivo, y son globales en todas partes de todas las invocaciones.

$News:: AJUSTE de:: activo
Valor por defecto para "ajuste ()" en nuevos objetos.

$News:: NOMBRE de SISTEMA ANFITRIÓN:: Activo
Valor por defecto para "nombre de sistema anfitrión ()" en nuevos objetos. Utilización obtenida
"Sys:: Nombre de sistema anfitrión:: nombre de sistema anfitrión ()".

$News:: PICADILLO de:: activo
El número de artículos para conservarse en cada directorio. La falta es 500;
cambie esto en su propio peligro, ya que las cosas pueden ser atornilladas más tarde
¡si usted lo cambia después de archivar algún artículo!

El Gerente de Reserva es unas herramientas de copia de seguridad de línea de orden para el ÑU/LINUX, diseñado para ayudarle a hacer archivos diarios de su sistema de archivo.

El Gerente de Reserva es escrito en el golpe y perl y esto puede hacer alquitrán, tar.gz, tar.bz, y archivos de zip y puede ser ejecutado en un modo paralelo con archivos de configuración diferentes.

Los archivos son guardados para un número dado de días y el sistema subir puede usar el ftp o scp para transferir los archivos generados a una lista de servidores remotos. El archivo de configuración es muy simple y básico y gettext está usado para la internacionalización.

Aquí están algunos aspectos claves "del Gerente de Reserva":

Los · Hacen alquitrán, tar.gz, tar.bz y archivos de zip.
· Automáticamente copian CDs los archivos en medios CDR/CDRW.
· Registrando a syslog es posible
Los · Realizan sumas de control MD5 copiando CDs datos en CDR para estar seguros que los archivos arent corrompieron.
· bases de datos de MySQL de reserva con mysqldump
El · Puede ser ejecutado en un modo paralelo con archivos de configuración diferentes.
Los · Guardan y purgan todos los archivos para un número dado de días.
Los · Suben los archivos generados a servidores remotos, con el ftp o con scp.
Los · Proporcionan dos modos diffrent de llamar el tarballs.
El · Es completly integrado al ambiente Debian.
· el paquete Debian usa debconf para proporcionar un instalador rápido y fácil.