grimhilt/nextsync-rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

better architecture of PushChanges and applied to new

Browse Source
This commit is contained in:
grimhilt 2023-06-24 16:07:53 +02:00
parent 4842a20024
commit 23908c135c
7 changed files with 152 additions and 71 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
src/commands/add.rs
View File

@ -10,6 +10,8 @@ pub struct AddArgs<'a> {
pub force: bool,
}
// todo match deleted files
// todo match weird reg expression
pub fn add(args: AddArgs) {
let mut index_file = store::index::open();
let mut added_files: Vec<String> = vec![];
@ -27,7 +29,6 @@ pub fn add(args: AddArgs) {
match path.exists() {
true => {
if path.is_dir() {
added_files.push(String::from(path.to_str().unwrap()));
add_folder_content(path.to_path_buf(), &mut added_files);
} else {

10
src/commands/init.rs
View File

@ -16,27 +16,27 @@ pub fn init() {
// .nextsync folder
path.push(".nextsync");
match builder.create(path.clone()) {
Ok(()) => println!("Directory successfuly created"),
Ok(()) => (),
Err(_) => println!("Error: cannot create directory"),
};
path.push("objects");
match builder.create(path.clone()) {
Ok(()) => println!("Directory successfuly created"),
Ok(()) => (),
Err(_) => println!("Error: cannot create directory"),
};
path.pop();
path.push("HEAD");
match File::create(path.clone()) {
Ok(_) => println!("File successfuly created"),
Ok(_) => (),
Err(_) => println!("Error: cannot create .nextsyncignore"),
}
path.pop();
path.push("index");
match File::create(path.clone()) {
Ok(_) => println!("File successfuly created"),
Ok(_) => (),
Err(_) => println!("Error: cannot create .nextsyncignore"),
}
@ -45,7 +45,7 @@ pub fn init() {
path.push(".nextsyncignore");
match File::create(path) {
Ok(_) => println!("File successfuly created"),
Ok(_) => (),
Err(_) => println!("Error: cannot create .nextsyncignore"),
}
}

34
src/commands/push.rs
View File

@ -1,3 +1,4 @@
use std::path::Path;
use crate::services::api::ApiError;
use crate::services::upload_file::UploadFile;
use crate::services::delete_path::DeletePath;
@ -5,12 +6,13 @@ use crate::services::req_props::{ReqProps, ObjProps};
use crate::store::index;
use crate::store::object::{add_blob, rm_blob};
use crate::commands::{status, config};
use crate::commands::status::{State, Obj};
use crate::commands::status::{State, LocalObj};
use crate::commands::push::push_factory::{PushFactory, PushState};
pub mod push_factory;
pub mod new;
pub mod deleted;
//pub mod new_dir;
//pub mod deleted;
pub fn push() {
dbg!(status::get_all_staged());
@ -19,25 +21,45 @@ pub fn push() {
Some(r) => r,
None => {
eprintln!("fatal: no remote set in configuration");
std::process::exit(1);
//std::process::exit(1);
String::from("")
}
};
let staged_objs = status::get_all_staged();
// todo sort folder first
// path that certify that all its children can be push whithout hesistation
// (e.g if remote dir has no changes since last sync all children
// can be pushed without verification)
let whitelist: Option<&Path> = None;
for obj in staged_objs {
if obj.otype == String::from("tree") {
dbg!("should push folder");
//let push_factory = PushFactory.new_dir(obj.clone());
//let res = match push_factory.can_push(whitelist.clone()) {
// PushState::Valid => push_factory.push(),
// PushState::Done => (),
// PushState::Conflict => (),
// _ => todo!(),
//};
//match res {
//
//}
//dbg!("should push folder");
} else {
let push_factory = PushFactory.new(obj.clone());
match push_factory.can_push() {
match push_factory.can_push(whitelist.clone()) {
PushState::Valid => push_factory.push(),
PushState::Done => (),
PushState::Conflict => {
// download file
}
_ => todo!(),
}
}
}
// read index
// if dir upload dir
}

50
src/commands/push/new.rs
View File

@ -1,45 +1,33 @@
use std::path::Path;
use crate::services::api::ApiError;
use crate::services::req_props::ReqProps;
use crate::services::upload_file::UploadFile;
use crate::store::index;
use crate::store::object::add_blob;
use crate::commands::status::Obj;
use crate::commands::push::push_factory::{PushState, PushChange, PushFactory};
use crate::commands::status::LocalObj;
use crate::commands::push::push_factory::{PushState, PushChange, PushFactory, PushFlowState};
pub struct New {
pub obj: Obj,
pub obj: LocalObj,
}
impl PushChange for New {
fn can_push(&self) -> PushState {
// check if exist on server
let res = ReqProps::new()
.set_url(&self.obj.path.to_str().unwrap())
.getlastmodified()
.send_req_single();
fn can_push(&self, whitelist: Option<&Path>) -> PushState {
match self.flow(&self.obj, whitelist) {
PushFlowState::Whitelisted => PushState::Valid,
PushFlowState::NotOnRemote => PushState::Valid,
PushFlowState::RemoteIsNewer => PushState::Conflict,
PushFlowState::LocalIsNewer => PushState::Valid,
PushFlowState::Error => PushState::Error,
}
}
let file_infos = match res {
Ok(obj) => Ok(Some(obj)),
Err(ApiError::IncorrectRequest(err)) => {
if err.status() == 404 {
Ok(None)
} else {
Err(())
}
},
Err(_) => Err(()),
};
if let Ok(infos) = file_infos {
if let Some(info) = infos {
// file doesn't exist on remote
PushState::Valid
} else {
// todo check date
PushState::Conflict
}
} else {
PushState::Error
fn try_push(&self, whitelist: Option<&Path>) {
match self.can_push(whitelist) {
PushState::Valid => self.push(),
PushState::Conflict => todo!(), //download
PushState::Done => (),
PushState::Error => (),
}
}

79
src/commands/push/push_factory.rs
View File

@ -1,6 +1,10 @@
use crate::commands::status::{State, Obj};
use std::path::Path;
use crate::commands::status::{State, LocalObj};
use crate::services::api::ApiError;
use crate::services::req_props::{ObjProps, ReqProps};
use crate::commands::push::new::New;
use crate::commands::push::deleted::Deleted;
//use crate::commands::push::new_dir::NewDir;
//use crate::commands::push::deleted::Deleted;
#[derive(Debug)]
pub enum PushState {
@ -10,20 +14,83 @@ pub enum PushState {
Error,
}
pub enum PushFlowState {
Whitelisted,
NotOnRemote,
RemoteIsNewer,
LocalIsNewer,
Error,
}
pub trait PushChange {
fn can_push(&self) -> PushState;
fn can_push(&self, whitelist: Option<&Path>) -> PushState;
fn try_push(&self, whitelist: Option<&Path>);
fn push(&self);
fn is_whitelisted(&self, obj: &LocalObj, path: Option<&Path>) -> bool {
match path {
Some(p) => obj.path.starts_with(p),
None => false,
}
}
fn flow(&self, obj: &LocalObj, whitelist: Option<&Path>) -> PushFlowState {
if self.is_whitelisted(obj, whitelist) {
return PushFlowState::Whitelisted;
}
// check if exist on server
let res = ReqProps::new()
.set_url(obj.path.to_str().unwrap())
.getlastmodified()
.send_req_single();
let file_infos = match res {
Ok(obj) => Ok(Some(obj)),
Err(ApiError::IncorrectRequest(err)) => {
if err.status() == 404 {
Ok(None)
} else {
Err(())
}
},
Err(_) => Err(()),
};
let infos = match file_infos {
Ok(Some(info)) => info,
Ok(None) => return PushFlowState::NotOnRemote,
Err(_) => return PushFlowState::Error,
};
// check if remote is newest
// set timestamp from remote stuff
// get from file
todo!()
}
}
pub struct PushFactory;
impl PushFactory {
pub fn new(&self, obj: Obj) -> Box<dyn PushChange> {
pub fn new(&self, obj: LocalObj) -> Box<dyn PushChange> {
match obj.state {
State::New => Box::new(New { obj: obj.clone() }),
State::New => Box::new(New { obj }),
State::Renamed => todo!(),
State::Modified => todo!(),
State::Deleted => Box::new(Deleted { obj: obj.clone() }),
State::Deleted => todo!(),
//State::Deleted => Box::new(Deleted {}),
State::Default => todo!(),
}
}
pub fn new_dir(&self, obj: LocalObj) -> Box<dyn PushChange> {
match obj.state {
//State::New => Box::new(NewDir {}),
State::New => todo!(),
State::Renamed => todo!(),
State::Modified => todo!(),
State::Deleted => todo!(),
State::Default => todo!(),
}
}

41
src/commands/status.rs
View File

@ -38,14 +38,14 @@ pub fn status() {
}
#[derive(Debug, Clone)]
pub struct Obj {
pub struct LocalObj {
pub otype: String,
pub name: String,
pub path: PathBuf,
pub state: State,
}
pub fn get_all_staged() -> Vec<Obj> {
pub fn get_all_staged() -> Vec<LocalObj> {
// todo opti getting staged and then finding differences ?
// todo opti return folder
let (mut new_objs, mut del_objs) = get_diff();
@ -58,18 +58,17 @@ pub fn get_all_staged() -> Vec<Obj> {
staged_objs
}
fn get_renamed(_new_obj: &mut Vec<Obj>, _del_obj: &mut Vec<Obj>) -> Vec<Obj> {
fn get_renamed(_new_obj: &mut Vec<LocalObj>, _del_obj: &mut Vec<LocalObj>) -> Vec<LocalObj> {
// get hash of all new obj, compare to hash of all del
let renamed_objs = vec![];
renamed_objs
}
fn get_staged(objs: &mut Vec<Obj>) -> Vec<Obj> {
fn get_staged(objs: &mut Vec<LocalObj>) -> Vec<LocalObj> {
let mut indexes = HashSet::new();
let mut staged_objs: Vec<Obj> = vec![];
let mut staged_objs: Vec<LocalObj> = vec![];
let nextsync_path = utils::path::nextsync().unwrap();
if let Ok(entries) = store::index::read_line(nextsync_path.clone()) {
if let Ok(entries) = store::index::read_line() {
for entry in entries {
indexes.insert(entry.unwrap());
}
@ -87,7 +86,7 @@ fn get_staged(objs: &mut Vec<Obj>) -> Vec<Obj> {
staged_objs
}
fn get_diff() -> (Vec<Obj>, Vec<Obj>) {
fn get_diff() -> (Vec<LocalObj>, Vec<LocalObj>) {
let mut hashes = HashMap::new();
let mut objs: Vec<String> = vec![];
@ -138,8 +137,8 @@ fn get_diff() -> (Vec<Obj>, Vec<Obj>) {
}
let del_objs: Vec<Obj> = hashes.iter().map(|x| {
Obj {
let del_objs: Vec<LocalObj> = hashes.iter().map(|x| {
LocalObj {
otype: x.1.otype.clone(),
name: x.1.name.clone(),
path: x.1.path.clone(),
@ -147,10 +146,10 @@ fn get_diff() -> (Vec<Obj>, Vec<Obj>) {
}
}).collect();
let new_objs: Vec<Obj> = objs.iter().map(|x| {
let new_objs: Vec<LocalObj> = objs.iter().map(|x| {
let p = PathBuf::from(x.to_string());
// todo name
Obj {
LocalObj {
otype: get_type(p.clone()),
name: x.to_string(),
path: p,
@ -168,14 +167,14 @@ fn get_type(p: PathBuf) -> String {
}
}
fn add_to_hashmap(lines: Lines<BufReader<File>>, hashes: &mut HashMap<String, Obj>, path: PathBuf) {
fn add_to_hashmap(lines: Lines<BufReader<File>>, hashes: &mut HashMap<String, LocalObj>, path: PathBuf) {
for line in lines {
if let Ok(ip) = line {
if ip.clone().len() > 5 {
let (ftype, hash, name) = object::parse_line(ip);
let mut p = path.clone();
p.push(name.clone());
hashes.insert(String::from(hash), Obj{
hashes.insert(String::from(hash), LocalObj{
otype: String::from(ftype),
name: String::from(name),
path: p,
@ -196,7 +195,7 @@ fn add_to_vec(entries: Vec<PathBuf>, objects: &mut Vec<String>, root: PathBuf) {
}
fn print_status(staged_objs: Vec<Obj>, objs: Vec<Obj>) {
fn print_status(staged_objs: Vec<LocalObj>, objs: Vec<LocalObj>) {
dbg!(staged_objs.clone());
dbg!(objs.clone());
if staged_objs.len() == 0 && objs.len() == 0 {
@ -224,31 +223,31 @@ fn print_status(staged_objs: Vec<Obj>, objs: Vec<Obj>) {
}
}
fn print_object(obj: Obj) {
fn print_object(obj: LocalObj) {
if obj.state == State::Deleted {
println!(" {} {}", String::from("deleted:").red(), obj.name.red());
} else if obj.state == State::Renamed {
println!(" {} {}", String::from("renamed:").red(), obj.name.red());
} else if obj.state == State::New {
println!(" {} {}", String::from("new file:").red(), obj.name.red());
println!(" {} {}", String::from("new:").red(), obj.name.red());
} else if obj.state == State::Modified {
println!(" {} {}", String::from("modified:").red(), obj.name.red());
}
}
fn print_staged_object(obj: Obj) {
fn print_staged_object(obj: LocalObj) {
if obj.state == State::Deleted {
println!(" {} {}", String::from("deleted:").green(), obj.name.green());
} else if obj.state == State::Renamed {
println!(" {} {}", String::from("renamed:").green(), obj.name.green());
} else if obj.state == State::New {
println!(" {} {}", String::from("new file:").green(), obj.name.green());
println!(" {} {}", String::from("new:").green(), obj.name.green());
} else if obj.state == State::Modified {
println!(" {} {}", String::from("modified:").green(), obj.name.green());
}
}
fn remove_duplicate(hashes: &mut HashMap<String, Obj>, objects: &mut Vec<String>, remove_option: RemoveSide) -> Vec<String> {
fn remove_duplicate(hashes: &mut HashMap<String, LocalObj>, objects: &mut Vec<String>, remove_option: RemoveSide) -> Vec<String> {
let mut hasher = Sha1::new();
let mut duplicate = vec![];
@ -306,7 +305,7 @@ mod tests {
hasher.reset();
let mut hashes = HashMap::new();
let default_obj = Obj {
let default_obj = LocalObj {
otype: String::from("tree"),
name: String::from("test"),
path: PathBuf::from(""),

6
src/store/index.rs
View File

@ -26,7 +26,11 @@ pub fn open() -> File {
.open(path).expect("Cannot open index file")
}
pub fn read_line(mut path: PathBuf) -> io::Result<io::Lines<io::BufReader<File>>> {
pub fn read_line() -> io::Result<io::Lines<io::BufReader<File>>> {
let mut path = match path::nextsync() {
Some(p) => p,
None => todo!(),
};
path.push("index");
read::read_lines(path)
}