Subidas
Una de las operaciones principales de rac-delta es la subida de nuevas versiones de tus builds o directorios, y aplicar solo los chunks modificados o eliminar chunks obsoletos desde el almacenamiento remoto.
Puedes usar rac-delta para actualizar una build o para subir una build completamente nueva a tu almacenamiento.
Pipeline de subida
Para esto, el SDK de rac-delta proporciona una pipeline de subida que ya implementa todos los pasos para subir automáticamente nuevas builds a tu almacenamiento.
- Node.js
- Rust
Uso básico de la pipeline:
const remoteIndexToUse = undefined;
await racDeltaClient.pipelines.upload.execute('path/to/build', remoteIndexToUse, {
requireRemoteIndex: false,
force: false,
ignorePatterns: undefined,
onStateChange: (state) => {
console.log(state);
},
onProgress: (type, progress, speed) => {
console.log(type, progress.toFixed(1), speed?.toFixed(1));
},
});
Parámetros:
| Nombre | Tipo | Descripción | ||||||||||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ruta | string | La ruta a tu build local que será subida (ruta relativa o absoluta) | ||||||||||||||||||
| rd-index remoto | RDIndex | El rd-index.json como objeto RDIndex que será usado como índice remoto, si no se proporciona ninguno, la pipeline intentará descargarlo desdde el almacenamiento. | ||||||||||||||||||
| opciones de subida | UploadOptions |
|
Uso básico de la pipeline:
let remote_index_to_use: Option<RDIndex> = None;
match client.pipelines.upload {
UploadPipelineBundle::Hash(pipeline) => {
pipeline
.execute(
Path::new("my/dir"),
remote_index_to_use,
Some(UploadOptions {
require_remote_index: Some(false),
force: Some(false),
ignore_patterns: None,
on_state_change: Some(std::sync::Arc::new(|state| {
println!("Upload state: {:?}", state);
})),
on_progress: Some(std::sync::Arc::new(|phase, progress, speed| {
println!(
"Phase: {:?}, progress: {:.1}%, speed: {}",
phase,
progress * 100.0,
speed
.map_or("unknown".to_string(), |s| format!("{:.1} bytes/s", s))
);
})),
}),
)
.await?;
}
UploadPipelineBundle::Url(_p) => {
// nada para SSH
}
}
Parámetros:
| Nombre | Tipo | Descripción | ||||||||||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| ruta | Path | La ruta a tu build local que será subida (ruta relativa o absoluta) | ||||||||||||||||||
| rd-index remoto | Option<RDIndex> | El rd-index.json como objeto RDIndex que será usado como índice remoto, si no se proporciona ninguno, la pipeline intentará descargarlo desdde el almacenamiento. | ||||||||||||||||||
| opciones de subida | Option<UploadOptions> |
|
Esto generará automáticamente tu rd-index.json local, descargará el rd-index.json remoto si no se ha proporcionado ninguno, comparará ambos índices, generará el Delta Plan y subirá y limpiará los nuevos chunks a tu almacenamiento configurado en el cliente de rac-delta.
Métodos auxiliares de la pipeline
Para poder subir correctamente los directorios usando rac-delta, la pipeline de subida usa métodos internos que usan los servicios de rac-delta para subir, comparar índices, eliminar chunks obsoletos, etc...
Si no quieres usar el método execute por defecto, puedes crear tu propia pipeline usando estos métodos auxiliares y los servicios.
- Node.js
- Rust
Ejemplo de uso de los métodos auxiliares de pipeline de subida:
const racDeltaClient = await RacDeltaClient.create({
chunkSize: 1024 * 1024,
maxConcurrency: 6,
storage: {
type: 'ssh',
host: 'localhost',
pathPrefix: '/root/upload',
port: 2222,
credentials: {
username: 'root',
password: 'password',
},
},
});
const remoteIndex = fetch('my/api/or/my/storage/rd-index.json');
// Generamos el rd-index.json local (podrías usar racDeltaClient.delta.createIndexFromDirectory también)
const localIndex = await racDeltaClient.pipelines.upload.scanDirectory('my/build');
// Generamos el DeltaPlan comparando ambos índices
const deltaPlan = await racDeltaClient.delta.compareForUpload(localIndex, remoteIndex);
// Subimos los nuevos chunks (usa maxConcurrency del cliente)
await racDeltaClient.pipelines.upload.uploadMissingChunks(deltaPlan, 'my/build', false);
// ... Borrar chunks obsoletos, subir nuevo índice... etc
Ejemplo de uso de los métodos auxiliares de pipeline de subida:
let config = RacDeltaConfig {
chunk_size: 1024 * 1024,
max_concurrency: Some(6),
storage: StorageConfig::SSH(SSHStorageConfig {
base: BaseStorageConfig {
path_prefix: Some("/root/upload".to_string()),
},
host: "localhost".to_string(),
port: Some(2222),
credentials: SSHCredentials {
username: "root".to_string(),
password: Some("password".to_string()),
private_key: None,
},
}),
};
let client: RacDeltaClient = RacDeltaClient::new(config).await?;
let remote_index = fetch from remote...;
// Generamos el rd-index.json local (podrías usar client.delta.create_index_from_directory también)
let local_index: Option<RDIndex> = match client.pipelines.upload {
UploadPipelineBundle::Hash(ref pipeline) => {
Some(pipeline.scan_directory(Path::new("my/dir"), None).await?)
}
UploadPipelineBundle::Url(ref _p) => None,
};
// Generamos el DeltaPlan comparando ambos índices
let delta_plan: DeltaPlan = client
.delta
.compare_for_upload(&local_index.unwrap(), remote_index)
.await?;
// Subimos los nuevos chunks (usa maxConcurrency del cliente)
match client.pipelines.upload {
UploadPipelineBundle::Hash(ref pipeline) => {
pipeline
.upload_missing_chunks(&delta_plan, Path::new("my/dir"), false, None)
.await?
}
UploadPipelineBundle::Url(ref _p) => (),
};
// ... Borrar chunks obsoletos, subir nuevo índice... etc
En Rust, las pipelines siempre están divididas en Hash y Url, esto es así porque UrlPipeline execute difiere de HashPipeline, haciendo un Enum resuelve esto parcialmente, ¡pero el proyecto está abierto a mejoras!
Nota: Para casi todos los casos usarás la pipeline Hash, Url es solo para el tipo de almacenamiento URL.
Para una lista completa de los métodos auxiliares echa un ojo a: pipelines. Y también a DeltaPlan