Skip to content

Commit 00819c6

Browse files
macovedjmacovedj
committed
address comments
1 parent 78a5571 commit 00819c6

File tree

2 files changed

+54
-122
lines changed

2 files changed

+54
-122
lines changed

‎crates/client/src/lib.rs

+25-27
Original file line numberDiff line numberDiff line change
@@ -102,7 +102,7 @@ impl<R: RegistryStorage, C: ContentStorage, N: NamespaceMapStorage> Client<R, C,
102102
&self.namespace_map
103103
}
104104

105-
/// Get
105+
/// Get warg registry domain
106106
pub async fn get_warg_registry(&self, namespace: &str) -> Result<Option<RegistryDomain>> {
107107
self.update_checkpoint(None, &self.api.latest_checkpoint(None).await?, vec![])
108108
.await?;
@@ -111,16 +111,19 @@ impl<R: RegistryStorage, C: ContentStorage, N: NamespaceMapStorage> Client<R, C,
111111
.load_operator(Some(&RegistryDomain::from_str(namespace)?))
112112
.await?;
113113
if let Some(op) = operator {
114-
let namespace_state = op.state.namespace_state(namespace);
115-
if let Ok(Some(warg_protocol::operator::NamespaceState::Imported { registry })) =
116-
namespace_state
117-
{
118-
return Ok(Some(RegistryDomain::from_str(registry)?));
119-
} else if let Ok(Some(warg_protocol::operator::NamespaceState::Defined)) =
120-
namespace_state
121-
{
122-
return Ok(None);
123-
};
114+
match op.state.namespace_state(namespace) {
115+
Ok(Some(warg_protocol::operator::NamespaceState::Imported { registry })) => {
116+
return Ok(Some(RegistryDomain::from_str(registry)?));
117+
}
118+
Ok(Some(warg_protocol::operator::NamespaceState::Defined)) => {
119+
return Ok(None);
120+
}
121+
Ok(None) => return Ok(None),
122+
Err(e) => {
123+
eprintln!("Namespace `{namespace}` not found in operator log but found namespace `{e}`, which has alternative casing.");
124+
return Ok(None);
125+
}
126+
}
124127
};
125128
let nm_map = self.namespace_map.load_namespace_map().await?;
126129
Ok(if let Some(nm_map) = &nm_map {
@@ -494,28 +497,23 @@ impl<R: RegistryStorage, C: ContentStorage, N: NamespaceMapStorage> Client<R, C,
494497
let packages = packages.into_iter();
495498
let mut namespaced: IndexMap<&str, Vec<&PackageName>> = IndexMap::new();
496499
for package in packages {
497-
let namespace = package.namespace();
498-
let namespace_packages = namespaced.get_mut(namespace);
499-
if let Some(nm_pkgs) = namespace_packages {
500-
nm_pkgs.push(package);
501-
} else {
502-
namespaced.insert(namespace, vec![package]);
503-
}
500+
namespaced
501+
.entry(package.namespace())
502+
.or_default()
503+
.push(package);
504504
}
505505
let namespace_map = self.namespace_map.load_namespace_map().await?;
506506
if let Some(nm_map) = namespace_map {
507507
for (nm, pkg_names) in namespaced {
508508
let mut updating = Vec::with_capacity(pkg_names.len());
509509
let reg_domain = nm_map.get(nm);
510-
if reg_domain.is_some() {
511-
for package in pkg_names {
512-
updating.push(
513-
self.registry
514-
.load_package(self.get_warg_registry(nm).await?.as_ref(), package)
515-
.await?
516-
.unwrap_or_else(|| PackageInfo::new(package.clone())),
517-
);
518-
}
510+
for package in pkg_names {
511+
updating.push(
512+
self.registry
513+
.load_package(self.get_warg_registry(nm).await?.as_ref(), package)
514+
.await?
515+
.unwrap_or_else(|| PackageInfo::new(package.clone())),
516+
);
519517
}
520518

521519
self.update_checkpoint(

‎src/bin/warg.rs

+29-95
Original file line numberDiff line numberDiff line change
@@ -46,99 +46,33 @@ async fn main() -> Result<()> {
4646
.with_env_filter(EnvFilter::from_default_env())
4747
.init();
4848

49-
match &WargCli::parse() {
50-
WargCli::Config(cmd) => cmd.clone().exec().await?,
51-
WargCli::Info(cmd) => cmd.clone().exec().await?,
52-
WargCli::Key(cmd) => cmd.clone().exec().await?,
53-
WargCli::Lock(cmd) => {
54-
with_interactive_retry(|retry: Option<Retry>| async {
55-
if let Err(e) = cmd.clone().exec(retry).await {
56-
if let Some(e) = e.downcast_ref::<ClientError>() {
57-
describe_client_error_or_retry(e).await?;
58-
} else {
59-
eprintln!("error: {e:?}");
60-
}
61-
exit(1);
62-
}
63-
Ok(())
64-
})
65-
.await?
66-
}
67-
WargCli::Bundle(cmd) => {
68-
with_interactive_retry(|retry: Option<Retry>| async {
69-
if let Err(e) = cmd.clone().exec(retry).await {
70-
if let Some(e) = e.downcast_ref::<ClientError>() {
71-
describe_client_error_or_retry(e).await?;
72-
} else {
73-
eprintln!("error: {e:?}");
74-
}
75-
exit(1);
76-
}
77-
Ok(())
78-
})
79-
.await?
80-
}
81-
WargCli::Dependencies(cmd) => {
82-
with_interactive_retry(|retry: Option<Retry>| async {
83-
if let Err(e) = cmd.clone().exec(retry).await {
84-
if let Some(e) = e.downcast_ref::<ClientError>() {
85-
describe_client_error_or_retry(e).await?;
86-
} else {
87-
eprintln!("error: {e:?}");
88-
}
89-
exit(1);
90-
}
91-
Ok(())
92-
})
93-
.await?
94-
}
95-
WargCli::Download(cmd) => {
96-
with_interactive_retry(|retry: Option<Retry>| async {
97-
if let Err(e) = cmd.clone().exec(retry).await {
98-
if let Some(e) = e.downcast_ref::<ClientError>() {
99-
describe_client_error_or_retry(e).await?;
100-
} else {
101-
eprintln!("error: {e:?}");
102-
}
103-
exit(1);
104-
}
105-
Ok(())
106-
})
107-
.await?
108-
}
109-
WargCli::Update(cmd) => {
110-
with_interactive_retry(|retry: Option<Retry>| async {
111-
if let Err(e) = cmd.clone().exec(retry).await {
112-
if let Some(e) = e.downcast_ref::<ClientError>() {
113-
describe_client_error_or_retry(e).await?;
114-
} else {
115-
eprintln!("error: {e:?}");
116-
}
117-
exit(1);
118-
}
119-
Ok(())
120-
})
121-
.await?
122-
}
123-
WargCli::Publish(cmd) => {
124-
with_interactive_retry(|retry: Option<Retry>| async {
125-
if let Err(e) = cmd.clone().exec(retry).await {
126-
if let Some(e) = e.downcast_ref::<ClientError>() {
127-
describe_client_error_or_retry(e).await?;
128-
} else {
129-
eprintln!("error: {e:?}");
130-
}
131-
exit(1);
132-
}
133-
Ok(())
134-
})
135-
.await?
49+
with_interactive_retry(|retry: Option<Retry>| async {
50+
if let Err(e) = match WargCli::parse() {
51+
WargCli::Config(cmd) => cmd.exec().await,
52+
WargCli::Info(cmd) => cmd.exec().await,
53+
WargCli::Key(cmd) => cmd.exec().await,
54+
WargCli::Lock(cmd) => cmd.exec(retry).await,
55+
WargCli::Bundle(cmd) => cmd.exec(retry).await,
56+
WargCli::Dependencies(cmd) => cmd.exec(retry).await,
57+
WargCli::Download(cmd) => cmd.exec(retry).await,
58+
WargCli::Update(cmd) => cmd.exec(retry).await,
59+
WargCli::Publish(cmd) => cmd.exec(retry).await,
60+
WargCli::Reset(cmd) => cmd.exec().await,
61+
WargCli::Clear(cmd) => cmd.exec().await,
62+
WargCli::Login(cmd) => cmd.exec().await,
63+
WargCli::Logout(cmd) => cmd.exec().await,
64+
} {
65+
if let Some(e) = e.downcast_ref::<ClientError>() {
66+
describe_client_error_or_retry(e).await?;
67+
} else {
68+
eprintln!("error: {e:?}");
69+
}
70+
exit(1);
13671
}
137-
WargCli::Reset(cmd) => cmd.clone().exec().await?,
138-
WargCli::Clear(cmd) => cmd.clone().exec().await?,
139-
WargCli::Login(cmd) => cmd.clone().exec().await?,
140-
WargCli::Logout(cmd) => cmd.clone().exec().await?,
141-
}
72+
73+
Ok(())
74+
})
75+
.await?;
14276

14377
Ok(())
14478
}
@@ -162,9 +96,9 @@ async fn describe_client_error_or_retry(e: &ClientError) -> Result<()> {
16296
let registry = terms.next();
16397
if let (Some(namespace), Some(registry)) = (namespace, registry) {
16498
let prompt = format!(
165-
"The package `{}`, does not exist in the registry you're using.\nHowever, the package namespace `{namespace}` does exist in the registry at {registry}.\nWould you like to configure your warg cli to use this registry for packages with this namespace in the future? y/N\n",
166-
name.name()
167-
);
99+
"The package `{}`, does not exist in the registry you're using.\nHowever, the package namespace `{namespace}` does exist in the registry at {registry}.\nWould you like to configure your warg cli to use this registry for packages with this namespace in the future? y/N\n",
100+
name.name()
101+
);
168102
if Confirm::with_theme(&ColorfulTheme::default())
169103
.with_prompt(prompt)
170104
.interact()

0 commit comments

Comments
 (0)