mirror of
https://github.com/shimataro/ssh-key-action.git
synced 2025-06-19 22:52:10 +10:00
* first action! (#1)
This commit is contained in:
shimataro
GitHub
parent
8deacc95b1
commit
ace1e6a69a
3750 changed files with 1155519 additions and 0 deletions
628
node_modules/cacache/README.es.md
generated
vendored
Normal file
628
node_modules/cacache/README.es.md
generated
vendored
Normal file
|
|
@ -0,0 +1,628 @@
|
|||
# cacache [](https://npm.im/cacache) [](https://npm.im/cacache) [](https://travis-ci.org/zkat/cacache) [](https://ci.appveyor.com/project/zkat/cacache) [](https://coveralls.io/github/zkat/cacache?branch=latest)
|
||||
|
||||
[`cacache`](https://github.com/zkat/cacache) es una librería de Node.js para
|
||||
manejar caches locales en disco, con acceso tanto con claves únicas como
|
||||
direcciones de contenido (hashes/hacheos). Es súper rápida, excelente con el
|
||||
acceso concurrente, y jamás te dará datos incorrectos, aún si se corrompen o
|
||||
manipulan directamente los ficheros del cache.
|
||||
|
||||
El propósito original era reemplazar el caché local de
|
||||
[npm](https://npm.im/npm), pero se puede usar por su propia cuenta.
|
||||
|
||||
_Traducciones: [English](README.md)_
|
||||
|
||||
## Instalación
|
||||
|
||||
`$ npm install --save cacache`
|
||||
|
||||
## Índice
|
||||
|
||||
* [Ejemplo](#ejemplo)
|
||||
* [Características](#características)
|
||||
* [Cómo Contribuir](#cómo-contribuir)
|
||||
* [API](#api)
|
||||
* [Usando el API en español](#localized-api)
|
||||
* Leer
|
||||
* [`ls`](#ls)
|
||||
* [`ls.flujo`](#ls-stream)
|
||||
* [`saca`](#get-data)
|
||||
* [`saca.flujo`](#get-stream)
|
||||
* [`saca.info`](#get-info)
|
||||
* [`saca.tieneDatos`](#get-hasContent)
|
||||
* Escribir
|
||||
* [`mete`](#put-data)
|
||||
* [`mete.flujo`](#put-stream)
|
||||
* [opciones para `mete*`](#put-options)
|
||||
* [`rm.todo`](#rm-all)
|
||||
* [`rm.entrada`](#rm-entry)
|
||||
* [`rm.datos`](#rm-content)
|
||||
* Utilidades
|
||||
* [`ponLenguaje`](#set-locale)
|
||||
* [`limpiaMemoizado`](#clear-memoized)
|
||||
* [`tmp.hazdir`](#tmp-mkdir)
|
||||
* [`tmp.conTmp`](#with-tmp)
|
||||
* Integridad
|
||||
* [Subresource Integrity](#integrity)
|
||||
* [`verifica`](#verify)
|
||||
* [`verifica.ultimaVez`](#verify-last-run)
|
||||
|
||||
### Ejemplo
|
||||
|
||||
```javascript
|
||||
const cacache = require('cacache/es')
|
||||
const fs = require('fs')
|
||||
|
||||
const tarbol = '/ruta/a/mi-tar.tgz'
|
||||
const rutaCache = '/tmp/my-toy-cache'
|
||||
const clave = 'mi-clave-única-1234'
|
||||
|
||||
// ¡Añádelo al caché! Usa `rutaCache` como raíz del caché.
|
||||
cacache.mete(rutaCache, clave, '10293801983029384').then(integrity => {
|
||||
console.log(`Saved content to ${rutaCache}.`)
|
||||
})
|
||||
|
||||
const destino = '/tmp/mytar.tgz'
|
||||
|
||||
// Copia el contenido del caché a otro fichero, pero esta vez con flujos.
|
||||
cacache.saca.flujo(
|
||||
rutaCache, clave
|
||||
).pipe(
|
||||
fs.createWriteStream(destino)
|
||||
).on('finish', () => {
|
||||
console.log('extracción completada')
|
||||
})
|
||||
|
||||
// La misma cosa, pero accesando el contenido directamente, sin tocar el índice.
|
||||
cacache.saca.porHacheo(rutaCache, integridad).then(datos => {
|
||||
fs.writeFile(destino, datos, err => {
|
||||
console.log('datos del tarbol sacados basado en su sha512, y escrito a otro fichero')
|
||||
})
|
||||
})
|
||||
```
|
||||
|
||||
### Características
|
||||
|
||||
* Extracción por clave o por dirección de contenido (shasum, etc)
|
||||
* Usa el estándard de web, [Subresource Integrity](#integrity)
|
||||
* Compatible con multiples algoritmos - usa sha1, sha512, etc, en el mismo caché sin problema
|
||||
* Entradas con contenido idéntico comparten ficheros
|
||||
* Tolerancia de fallas (inmune a corrupción, ficheros parciales, carreras de proceso, etc)
|
||||
* Verificación completa de datos cuando (escribiendo y leyendo)
|
||||
* Concurrencia rápida, segura y "lockless"
|
||||
* Compatible con `stream`s (flujos)
|
||||
* Compatible con `Promise`s (promesas)
|
||||
* Bastante rápida -- acceso, incluyendo verificación, en microsegundos
|
||||
* Almacenaje de metadatos arbitrarios
|
||||
* Colección de basura y verificación adicional fuera de banda
|
||||
* Cobertura rigurosa de pruebas
|
||||
* Probablente hay un "Bloom filter" por ahí en algún lado. Eso le mola a la gente, ¿Verdad? 🤔
|
||||
|
||||
### Cómo Contribuir
|
||||
|
||||
El equipo de cacache felizmente acepta contribuciones de código y otras maneras de participación. ¡Hay muchas formas diferentes de contribuir! La [Guía de Colaboradores](CONTRIBUTING.md) (en inglés) tiene toda la información que necesitas para cualquier tipo de contribución: todo desde cómo reportar errores hasta cómo someter parches con nuevas características. Con todo y eso, no se preocupe por si lo que haces está exáctamente correcto: no hay ningún problema en hacer preguntas si algo no está claro, o no lo encuentras.
|
||||
|
||||
El equipo de cacache tiene miembros hispanohablantes: es completamente aceptable crear `issues` y `pull requests` en español/castellano.
|
||||
|
||||
Todos los participantes en este proyecto deben obedecer el [Código de Conducta](CODE_OF_CONDUCT.md) (en inglés), y en general actuar de forma amable y respetuosa mientras participan en esta comunidad.
|
||||
|
||||
Por favor refiérase al [Historial de Cambios](CHANGELOG.md) (en inglés) para detalles sobre cambios importantes incluídos en cada versión.
|
||||
|
||||
Finalmente, cacache tiene un sistema de localización de lenguaje. Si te interesa añadir lenguajes o mejorar los que existen, mira en el directorio `./locales` para comenzar.
|
||||
|
||||
Happy hacking!
|
||||
|
||||
### API
|
||||
|
||||
#### <a name="localized-api"></a> Usando el API en español
|
||||
|
||||
cacache incluye una traducción completa de su API al castellano, con las mismas
|
||||
características. Para usar el API como está documentado en este documento, usa
|
||||
`require('cacache/es')`
|
||||
|
||||
cacache también tiene otros lenguajes: encuéntralos bajo `./locales`, y podrás
|
||||
usar el API en ese lenguaje con `require('cacache/<lenguaje>')`
|
||||
|
||||
#### <a name="ls"></a> `> cacache.ls(cache) -> Promise<Object>`
|
||||
|
||||
Enumera todas las entradas en el caché, dentro de un solo objeto. Cada entrada
|
||||
en el objeto tendrá como clave la clave única usada para el índice, el valor
|
||||
siendo un objeto de [`saca.info`](#get-info).
|
||||
|
||||
##### Ejemplo
|
||||
|
||||
```javascript
|
||||
cacache.ls(rutaCache).then(console.log)
|
||||
// Salida
|
||||
{
|
||||
'my-thing': {
|
||||
key: 'my-thing',
|
||||
integrity: 'sha512-BaSe64/EnCoDED+HAsh=='
|
||||
path: '.testcache/content/deadbeef', // unido con `rutaCache`
|
||||
time: 12345698490,
|
||||
size: 4023948,
|
||||
metadata: {
|
||||
name: 'blah',
|
||||
version: '1.2.3',
|
||||
description: 'this was once a package but now it is my-thing'
|
||||
}
|
||||
},
|
||||
'other-thing': {
|
||||
key: 'other-thing',
|
||||
integrity: 'sha1-ANothER+hasH=',
|
||||
path: '.testcache/content/bada55',
|
||||
time: 11992309289,
|
||||
size: 111112
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
#### <a name="ls-stream"></a> `> cacache.ls.flujo(cache) -> Readable`
|
||||
|
||||
Enumera todas las entradas en el caché, emitiendo un objeto de
|
||||
[`saca.info`](#get-info) por cada evento de `data` en el flujo.
|
||||
|
||||
##### Ejemplo
|
||||
|
||||
```javascript
|
||||
cacache.ls.flujo(rutaCache).on('data', console.log)
|
||||
// Salida
|
||||
{
|
||||
key: 'my-thing',
|
||||
integrity: 'sha512-BaSe64HaSh',
|
||||
path: '.testcache/content/deadbeef', // unido con `rutaCache`
|
||||
time: 12345698490,
|
||||
size: 13423,
|
||||
metadata: {
|
||||
name: 'blah',
|
||||
version: '1.2.3',
|
||||
description: 'this was once a package but now it is my-thing'
|
||||
}
|
||||
}
|
||||
|
||||
{
|
||||
key: 'other-thing',
|
||||
integrity: 'whirlpool-WoWSoMuchSupport',
|
||||
path: '.testcache/content/bada55',
|
||||
time: 11992309289,
|
||||
size: 498023984029
|
||||
}
|
||||
|
||||
{
|
||||
...
|
||||
}
|
||||
```
|
||||
|
||||
#### <a name="get-data"></a> `> cacache.saca(cache, clave, [ops]) -> Promise({data, metadata, integrity})`
|
||||
|
||||
Devuelve un objeto con los datos, hacheo de integridad y metadatos identificados
|
||||
por la `clave`. La propiedad `data` de este objeto será una instancia de
|
||||
`Buffer` con los datos almacenados en el caché. to do with it! cacache just
|
||||
won't care.
|
||||
|
||||
`integrity` es un `string` de [Subresource Integrity](#integrity). Dígase, un
|
||||
`string` que puede ser usado para verificar a la `data`, que tiene como formato
|
||||
`<algoritmo>-<hacheo-integridad-base64>`.
|
||||
|
||||
So no existe ninguna entrada identificada por `clave`, o se los datos
|
||||
almacenados localmente fallan verificación, el `Promise` fallará.
|
||||
|
||||
Una sub-función, `saca.porHacheo`, tiene casi el mismo comportamiento, excepto
|
||||
que busca entradas usando el hacheo de integridad, sin tocar el índice general.
|
||||
Esta versión *sólo* devuelve `data`, sin ningún objeto conteniéndola.
|
||||
|
||||
##### Nota
|
||||
|
||||
Esta función lee la entrada completa a la memoria antes de devolverla. Si estás
|
||||
almacenando datos Muy Grandes, es posible que [`saca.flujo`](#get-stream) sea
|
||||
una mejor solución.
|
||||
|
||||
##### Ejemplo
|
||||
|
||||
```javascript
|
||||
// Busca por clave
|
||||
cache.saca(rutaCache, 'my-thing').then(console.log)
|
||||
// Salida:
|
||||
{
|
||||
metadata: {
|
||||
thingName: 'my'
|
||||
},
|
||||
integrity: 'sha512-BaSe64HaSh',
|
||||
data: Buffer#<deadbeef>,
|
||||
size: 9320
|
||||
}
|
||||
|
||||
// Busca por hacheo
|
||||
cache.saca.porHacheo(rutaCache, 'sha512-BaSe64HaSh').then(console.log)
|
||||
// Salida:
|
||||
Buffer#<deadbeef>
|
||||
```
|
||||
|
||||
#### <a name="get-stream"></a> `> cacache.saca.flujo(cache, clave, [ops]) -> Readable`
|
||||
|
||||
Devuelve un [Readable
|
||||
Stream](https://nodejs.org/api/stream.html#stream_readable_streams) de los datos
|
||||
almacenados bajo `clave`.
|
||||
|
||||
So no existe ninguna entrada identificada por `clave`, o se los datos
|
||||
almacenados localmente fallan verificación, el `Promise` fallará.
|
||||
|
||||
`metadata` y `integrity` serán emitidos como eventos antes de que el flujo
|
||||
cierre.
|
||||
|
||||
Una sub-función, `saca.flujo.porHacheo`, tiene casi el mismo comportamiento,
|
||||
excepto que busca entradas usando el hacheo de integridad, sin tocar el índice
|
||||
general. Esta versión no emite eventos de `metadata` o `integrity`.
|
||||
|
||||
##### Ejemplo
|
||||
|
||||
```javascript
|
||||
// Busca por clave
|
||||
cache.saca.flujo(
|
||||
rutaCache, 'my-thing'
|
||||
).on('metadata', metadata => {
|
||||
console.log('metadata:', metadata)
|
||||
}).on('integrity', integrity => {
|
||||
console.log('integrity:', integrity)
|
||||
}).pipe(
|
||||
fs.createWriteStream('./x.tgz')
|
||||
)
|
||||
// Salidas:
|
||||
metadata: { ... }
|
||||
integrity: 'sha512-SoMeDIGest+64=='
|
||||
|
||||
// Busca por hacheo
|
||||
cache.saca.flujo.porHacheo(
|
||||
rutaCache, 'sha512-SoMeDIGest+64=='
|
||||
).pipe(
|
||||
fs.createWriteStream('./x.tgz')
|
||||
)
|
||||
```
|
||||
|
||||
#### <a name="get-info"></a> `> cacache.saca.info(cache, clave) -> Promise`
|
||||
|
||||
Busca la `clave` en el índice del caché, devolviendo información sobre la
|
||||
entrada si existe.
|
||||
|
||||
##### Campos
|
||||
|
||||
* `key` - Clave de la entrada. Igual al argumento `clave`.
|
||||
* `integrity` - [hacheo de Subresource Integrity](#integrity) del contenido al que se refiere esta entrada.
|
||||
* `path` - Dirección del fichero de datos almacenados, unida al argumento `cache`.
|
||||
* `time` - Hora de creación de la entrada
|
||||
* `metadata` - Metadatos asignados a esta entrada por el usuario
|
||||
|
||||
##### Ejemplo
|
||||
|
||||
```javascript
|
||||
cacache.saca.info(rutaCache, 'my-thing').then(console.log)
|
||||
|
||||
// Salida
|
||||
{
|
||||
key: 'my-thing',
|
||||
integrity: 'sha256-MUSTVERIFY+ALL/THINGS=='
|
||||
path: '.testcache/content/deadbeef',
|
||||
time: 12345698490,
|
||||
size: 849234,
|
||||
metadata: {
|
||||
name: 'blah',
|
||||
version: '1.2.3',
|
||||
description: 'this was once a package but now it is my-thing'
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
#### <a name="get-hasContent"></a> `> cacache.saca.tieneDatos(cache, integrity) -> Promise`
|
||||
|
||||
Busca un [hacheo Subresource Integrity](#integrity) en el caché. Si existe el
|
||||
contenido asociado con `integrity`, devuelve un objeto con dos campos: el hacheo
|
||||
_específico_ que se usó para la búsqueda, `sri`, y el tamaño total del
|
||||
contenido, `size`. Si no existe ningún contenido asociado con `integrity`,
|
||||
devuelve `false`.
|
||||
|
||||
##### Ejemplo
|
||||
|
||||
```javascript
|
||||
cacache.saca.tieneDatos(rutaCache, 'sha256-MUSTVERIFY+ALL/THINGS==').then(console.log)
|
||||
|
||||
// Salida
|
||||
{
|
||||
sri: {
|
||||
source: 'sha256-MUSTVERIFY+ALL/THINGS==',
|
||||
algorithm: 'sha256',
|
||||
digest: 'MUSTVERIFY+ALL/THINGS==',
|
||||
options: []
|
||||
},
|
||||
size: 9001
|
||||
}
|
||||
|
||||
cacache.saca.tieneDatos(rutaCache, 'sha521-NOT+IN/CACHE==').then(console.log)
|
||||
|
||||
// Salida
|
||||
false
|
||||
```
|
||||
|
||||
#### <a name="put-data"></a> `> cacache.mete(cache, clave, datos, [ops]) -> Promise`
|
||||
|
||||
Inserta `datos` en el caché. El `Promise` devuelto se resuelve con un hacheo
|
||||
(generado conforme a [`ops.algorithms`](#optsalgorithms)) después que la entrada
|
||||
haya sido escrita en completo.
|
||||
|
||||
##### Ejemplo
|
||||
|
||||
```javascript
|
||||
fetch(
|
||||
'https://registry.npmjs.org/cacache/-/cacache-1.0.0.tgz'
|
||||
).then(datos => {
|
||||
return cacache.mete(rutaCache, 'registry.npmjs.org|cacache@1.0.0', datos)
|
||||
}).then(integridad => {
|
||||
console.log('el hacheo de integridad es', integridad)
|
||||
})
|
||||
```
|
||||
|
||||
#### <a name="put-stream"></a> `> cacache.mete.flujo(cache, clave, [ops]) -> Writable`
|
||||
|
||||
Devuelve un [Writable
|
||||
Stream](https://nodejs.org/api/stream.html#stream_writable_streams) que inserta
|
||||
al caché los datos escritos a él. Emite un evento `integrity` con el hacheo del
|
||||
contenido escrito, cuando completa.
|
||||
|
||||
##### Ejemplo
|
||||
|
||||
```javascript
|
||||
request.get(
|
||||
'https://registry.npmjs.org/cacache/-/cacache-1.0.0.tgz'
|
||||
).pipe(
|
||||
cacache.mete.flujo(
|
||||
rutaCache, 'registry.npmjs.org|cacache@1.0.0'
|
||||
).on('integrity', d => console.log(`integrity digest is ${d}`))
|
||||
)
|
||||
```
|
||||
|
||||
#### <a name="put-options"></a> `> opciones para cacache.mete`
|
||||
|
||||
La funciones `cacache.mete` tienen un número de opciones en común.
|
||||
|
||||
##### `ops.metadata`
|
||||
|
||||
Metadatos del usuario que se almacenarán con la entrada.
|
||||
|
||||
##### `ops.size`
|
||||
|
||||
El tamaño declarado de los datos que se van a insertar. Si es proveído, cacache
|
||||
verificará que los datos escritos sean de ese tamaño, o si no, fallará con un
|
||||
error con código `EBADSIZE`.
|
||||
|
||||
##### `ops.integrity`
|
||||
|
||||
El hacheo de integridad de los datos siendo escritos.
|
||||
|
||||
Si es proveído, y los datos escritos no le corresponden, la operación fallará
|
||||
con un error con código `EINTEGRITY`.
|
||||
|
||||
`ops.algorithms` no tiene ningún efecto si esta opción está presente.
|
||||
|
||||
##### `ops.algorithms`
|
||||
|
||||
Por Defecto: `['sha512']`
|
||||
|
||||
Algoritmos que se deben usar cuando se calcule el hacheo de [subresource
|
||||
integrity](#integrity) para los datos insertados. Puede usar cualquier algoritmo
|
||||
enumerado en `crypto.getHashes()`.
|
||||
|
||||
Por el momento, sólo se acepta un algoritmo (dígase, un array con exáctamente un
|
||||
valor). No tiene ningún efecto si `ops.integrity` también ha sido proveido.
|
||||
|
||||
##### `ops.uid`/`ops.gid`
|
||||
|
||||
Si están presentes, cacache hará todo lo posible para asegurarse que todos los
|
||||
ficheros creados en el proceso de sus operaciones en el caché usen esta
|
||||
combinación en particular.
|
||||
|
||||
##### `ops.memoize`
|
||||
|
||||
Por Defecto: `null`
|
||||
|
||||
Si es verdad, cacache tratará de memoizar los datos de la entrada en memoria. La
|
||||
próxima vez que el proceso corriente trate de accesar los datos o entrada,
|
||||
cacache buscará en memoria antes de buscar en disco.
|
||||
|
||||
Si `ops.memoize` es un objeto regular o un objeto como `Map` (es decir, un
|
||||
objeto con métodos `get()` y `set()`), este objeto en sí sera usado en vez del
|
||||
caché de memoria global. Esto permite tener lógica específica a tu aplicación
|
||||
encuanto al almacenaje en memoria de tus datos.
|
||||
|
||||
Si quieres asegurarte que los datos se lean del disco en vez de memoria, usa
|
||||
`memoize: false` cuando uses funciones de `cacache.saca`.
|
||||
|
||||
#### <a name="rm-all"></a> `> cacache.rm.todo(cache) -> Promise`
|
||||
|
||||
Borra el caché completo, incluyendo ficheros temporeros, ficheros de datos, y el
|
||||
índice del caché.
|
||||
|
||||
##### Ejemplo
|
||||
|
||||
```javascript
|
||||
cacache.rm.todo(rutaCache).then(() => {
|
||||
console.log('THE APOCALYPSE IS UPON US 😱')
|
||||
})
|
||||
```
|
||||
|
||||
#### <a name="rm-entry"></a> `> cacache.rm.entrada(cache, clave) -> Promise`
|
||||
|
||||
Alias: `cacache.rm`
|
||||
|
||||
Borra la entrada `clave` del índuce. El contenido asociado con esta entrada
|
||||
seguirá siendo accesible por hacheo usando
|
||||
[`saca.flujo.porHacheo`](#get-stream).
|
||||
|
||||
Para borrar el contenido en sí, usa [`rm.datos`](#rm-content). Si quieres hacer
|
||||
esto de manera más segura (pues ficheros de contenido pueden ser usados por
|
||||
multiples entradas), usa [`verifica`](#verify) para borrar huérfanos.
|
||||
|
||||
##### Ejemplo
|
||||
|
||||
```javascript
|
||||
cacache.rm.entrada(rutaCache, 'my-thing').then(() => {
|
||||
console.log('I did not like it anyway')
|
||||
})
|
||||
```
|
||||
|
||||
#### <a name="rm-content"></a> `> cacache.rm.datos(cache, integrity) -> Promise`
|
||||
|
||||
Borra el contenido identificado por `integrity`. Cualquier entrada que se
|
||||
refiera a este contenido quedarán huérfanas y se invalidarán si se tratan de
|
||||
accesar, al menos que contenido idéntico sea añadido bajo `integrity`.
|
||||
|
||||
##### Ejemplo
|
||||
|
||||
```javascript
|
||||
cacache.rm.datos(rutaCache, 'sha512-SoMeDIGest/IN+BaSE64==').then(() => {
|
||||
console.log('los datos para `mi-cosa` se borraron')
|
||||
})
|
||||
```
|
||||
|
||||
#### <a name="set-locale"></a> `> cacache.ponLenguaje(locale)`
|
||||
|
||||
Configura el lenguaje usado para mensajes y errores de cacache. La lista de
|
||||
lenguajes disponibles está en el directorio `./locales` del proyecto.
|
||||
|
||||
_Te interesa añadir más lenguajes? [Somete un PR](CONTRIBUTING.md)!_
|
||||
|
||||
#### <a name="clear-memoized"></a> `> cacache.limpiaMemoizado()`
|
||||
|
||||
Completamente reinicializa el caché de memoria interno. Si estás usando tu
|
||||
propio objecto con `ops.memoize`, debes hacer esto de manera específica a él.
|
||||
|
||||
#### <a name="tmp-mkdir"></a> `> tmp.hazdir(cache, ops) -> Promise<Path>`
|
||||
|
||||
Alias: `tmp.mkdir`
|
||||
|
||||
Devuelve un directorio único dentro del directorio `tmp` del caché.
|
||||
|
||||
Una vez tengas el directorio, es responsabilidad tuya asegurarte que todos los
|
||||
ficheros escrito a él sean creados usando los permisos y `uid`/`gid` concordante
|
||||
con el caché. Si no, puedes pedirle a cacache que lo haga llamando a
|
||||
[`cacache.tmp.fix()`](#tmp-fix). Esta función arreglará todos los permisos en el
|
||||
directorio tmp.
|
||||
|
||||
Si quieres que cacache limpie el directorio automáticamente cuando termines, usa
|
||||
[`cacache.tmp.conTmp()`](#with-tpm).
|
||||
|
||||
##### Ejemplo
|
||||
|
||||
```javascript
|
||||
cacache.tmp.mkdir(cache).then(dir => {
|
||||
fs.writeFile(path.join(dir, 'blablabla'), Buffer#<1234>, ...)
|
||||
})
|
||||
```
|
||||
|
||||
#### <a name="with-tmp"></a> `> tmp.conTmp(cache, ops, cb) -> Promise`
|
||||
|
||||
Crea un directorio temporero con [`tmp.mkdir()`](#tmp-mkdir) y ejecuta `cb` con
|
||||
él como primer argumento. El directorio creado será removido automáticamente
|
||||
cuando el valor devolvido por `cb()` se resuelva.
|
||||
|
||||
Las mismas advertencias aplican en cuanto a manejando permisos para los ficheros
|
||||
dentro del directorio.
|
||||
|
||||
##### Ejemplo
|
||||
|
||||
```javascript
|
||||
cacache.tmp.conTmp(cache, dir => {
|
||||
return fs.writeFileAsync(path.join(dir, 'blablabla'), Buffer#<1234>, ...)
|
||||
}).then(() => {
|
||||
// `dir` no longer exists
|
||||
})
|
||||
```
|
||||
|
||||
#### <a name="integrity"></a> Hacheos de Subresource Integrity
|
||||
|
||||
cacache usa strings que siguen la especificación de [Subresource Integrity
|
||||
spec](https://developer.mozilla.org/en-US/docs/Web/Security/Subresource_Integrity).
|
||||
|
||||
Es decir, donde quiera cacache espera un argumento o opción `integrity`, ese
|
||||
string debería usar el formato `<algoritmo>-<hacheo-base64>`.
|
||||
|
||||
Una variación importante sobre los hacheos que cacache acepta es que acepta el
|
||||
nombre de cualquier algoritmo aceptado por el proceso de Node.js donde se usa.
|
||||
Puedes usar `crypto.getHashes()` para ver cuales están disponibles.
|
||||
|
||||
##### Generando tus propios hacheos
|
||||
|
||||
Si tienes un `shasum`, en general va a estar en formato de string hexadecimal
|
||||
(es decir, un `sha1` se vería como algo así:
|
||||
`5f5513f8822fdbe5145af33b64d8d970dcf95c6e`).
|
||||
|
||||
Para ser compatible con cacache, necesitas convertir esto a su equivalente en
|
||||
subresource integrity. Por ejemplo, el hacheo correspondiente al ejemplo
|
||||
anterior sería: `sha1-X1UT+IIv2+UUWvM7ZNjZcNz5XG4=`.
|
||||
|
||||
Puedes usar código así para generarlo por tu cuenta:
|
||||
|
||||
```javascript
|
||||
const crypto = require('crypto')
|
||||
const algoritmo = 'sha512'
|
||||
const datos = 'foobarbaz'
|
||||
|
||||
const integrity = (
|
||||
algorithm +
|
||||
'-' +
|
||||
crypto.createHash(algoritmo).update(datos).digest('base64')
|
||||
)
|
||||
```
|
||||
|
||||
También puedes usar [`ssri`](https://npm.im/ssri) para deferir el trabajo a otra
|
||||
librería que garantiza que todo esté correcto, pues maneja probablemente todas
|
||||
las operaciones que tendrías que hacer con SRIs, incluyendo convirtiendo entre
|
||||
hexadecimal y el formato SRI.
|
||||
|
||||
#### <a name="verify"></a> `> cacache.verifica(cache, ops) -> Promise`
|
||||
|
||||
Examina y arregla tu caché:
|
||||
|
||||
* Limpia entradas inválidas, huérfanas y corrompidas
|
||||
* Te deja filtrar cuales entradas retener, con tu propio filtro
|
||||
* Reclama cualquier ficheros de contenido sin referencias en el índice
|
||||
* Verifica integridad de todos los ficheros de contenido y remueve los malos
|
||||
* Arregla permisos del caché
|
||||
* Remieve el directorio `tmp` en el caché, y todo su contenido.
|
||||
|
||||
Cuando termine, devuelve un objeto con varias estadísticas sobre el proceso de
|
||||
verificación, por ejemplo la cantidad de espacio de disco reclamado, el número
|
||||
de entradas válidas, número de entradas removidas, etc.
|
||||
|
||||
##### Opciones
|
||||
|
||||
* `ops.uid` - uid para asignarle al caché y su contenido
|
||||
* `ops.gid` - gid para asignarle al caché y su contenido
|
||||
* `ops.filter` - recibe una entrada como argumento. Devuelve falso para removerla. Nota: es posible que esta función sea invocada con la misma entrada más de una vez.
|
||||
|
||||
##### Example
|
||||
|
||||
```sh
|
||||
echo somegarbage >> $RUTACACHE/content/deadbeef
|
||||
```
|
||||
|
||||
```javascript
|
||||
cacache.verifica(rutaCache).then(stats => {
|
||||
// deadbeef collected, because of invalid checksum.
|
||||
console.log('cache is much nicer now! stats:', stats)
|
||||
})
|
||||
```
|
||||
|
||||
#### <a name="verify-last-run"></a> `> cacache.verifica.ultimaVez(cache) -> Promise`
|
||||
|
||||
Alias: `últimaVez`
|
||||
|
||||
Devuelve un `Date` que representa la última vez que `cacache.verifica` fue
|
||||
ejecutada en `cache`.
|
||||
|
||||
##### Example
|
||||
|
||||
```javascript
|
||||
cacache.verifica(rutaCache).then(() => {
|
||||
cacache.verifica.ultimaVez(rutaCache).then(última => {
|
||||
console.log('La última vez que se usó cacache.verifica() fue ' + última)
|
||||
})
|
||||
})
|
||||
```
|
||||
Loading…
Add table
Add a link
Reference in a new issue