krisyotam/zed

Cargo.lock+1−0

@@ -9025,6 +9025,7 @@ dependencies = [ · 9024 unmodified lines
9025	"isahc",	9025	"isahc",
9026	"lazy_static",	9026	"lazy_static",
9027	"log",	9027	"log",
		9028	"parking_lot 0.11.2",
9028	"rand 0.8.5",	9029	"rand 0.8.5",
9029	"rust-embed",	9030	"rust-embed",
9030	"serde",	9031	"serde",

assets/settings/default.json+23−0

@@ -503,5 +503,28 @@ · 502 unmodified lines
503	// }	503	// }
504	// }	504	// }
505	// }	505	// }
		506	},
		507	// The server to connect to. If the environment variable
		508	// ZED_SERVER_URL is set, it will override this setting.
		509	"server_url": "https://zed.dev",
		510	// Settings overrides to use when using Zed Preview.
		511	// Mostly useful for developers who are managing multiple instances of Zed.
		512	"preview": {
		513	// "theme": "Andromeda"
		514	},
		515	// Settings overrides to use when using Zed Nightly.
		516	// Mostly useful for developers who are managing multiple instances of Zed.
		517	"nightly": {
		518	// "theme": "Andromeda"
		519	},
		520	// Settings overrides to use when using Zed Stable.
		521	// Mostly useful for developers who are managing multiple instances of Zed.
		522	"stable": {
		523	// "theme": "Andromeda"
		524	},
		525	// Settings overrides to use when using Zed Stable.
		526	// Mostly useful for developers who are managing multiple instances of Zed.
		527	"dev": {
		528	// "theme": "Andromeda"
506	}	529	}
507	}	530	}

crates/auto_update/src/auto_update.rs+16−22

     time::Duration,
 };
 use update_notification::UpdateNotification;
-use util::channel::{AppCommitSha, ReleaseChannel};
 use util::http::HttpClient;
+use util::{
+    channel::{AppCommitSha, ReleaseChannel},
+    http::ZedHttpClient,
+};
 use workspace::Workspace;
 const SHOULD_SHOW_UPDATE_NOTIFICATION_KEY: &str = "auto-updater-should-show-updated-notification";
 pub struct AutoUpdater {
     status: AutoUpdateStatus,
     current_version: SemanticVersion,
-    http_client: Arc<dyn HttpClient>,
+    http_client: Arc<ZedHttpClient>,
     pending_poll: Option<Task<Option<()>>>,
-    server_url: String,
 }
 #[derive(Deserialize)]
     }
 }
-pub fn init(http_client: Arc<dyn HttpClient>, server_url: String, cx: &mut AppContext) {
+pub fn init(http_client: Arc<ZedHttpClient>, cx: &mut AppContext) {
     AutoUpdateSetting::register(cx);
     cx.observe_new_views(|workspace: &mut Workspace, _cx| {
     if let Some(version) = ZED_APP_VERSION.or_else(|| cx.app_metadata().app_version) {
         let auto_updater = cx.new_model(|cx| {
-            let updater = AutoUpdater::new(version, http_client, server_url);
+            let updater = AutoUpdater::new(version, http_client);
             let mut update_subscription = AutoUpdateSetting::get_global(cx)
                 .0
         ReleaseChannel::Stable | ReleaseChannel::Preview
     ) {
         let auto_updater = auto_updater.read(cx);
-        let server_url = &auto_updater.server_url;
         let release_channel = release_channel.dev_name();
         let current_version = auto_updater.current_version;
-        let url = format!("{server_url}/releases/{release_channel}/{current_version}");
+        let url = &auto_updater
+            .http_client
+            .zed_url(&format!("/releases/{release_channel}/{current_version}"));
         cx.open_url(&url);
     }
         cx.default_global::<Option<Model<Self>>>().clone()
     }
-    fn new(
+    fn new(current_version: SemanticVersion, http_client: Arc<ZedHttpClient>) -> Self {
-        current_version: SemanticVersion,
-        http_client: Arc<dyn HttpClient>,
-        server_url: String,
-    ) -> Self {
         Self {
             status: AutoUpdateStatus::Idle,
             current_version,
             http_client,
-            server_url,
             pending_poll: None,
         }
     }
     }
     async fn update(this: Model<Self>, mut cx: AsyncAppContext) -> Result<()> {
-        let (client, server_url, current_version) = this.read_with(&cx, |this, _| {
+        let (client, current_version) = this.read_with(&cx, |this, _| {
-            (
+            (this.http_client.clone(), this.current_version)
-                this.http_client.clone(),
-                this.server_url.clone(),
-                this.current_version,
-            )
         })?;
-        let mut url_string = format!(
+        let mut url_string = client.zed_url(&format!(
-            "{server_url}/api/releases/latest?asset=Zed.dmg&os={}&arch={}",
+            "/api/releases/latest?asset=Zed.dmg&os={}&arch={}",
             OS, ARCH
-        );
+        ));
         cx.update(|cx| {
             if let Some(param) = cx
                 .try_global::<ReleaseChannel>()

crates/channel/src/channel_store_tests.rs+1−0

@@ -329,6 +329,7 @@ async fn test_channel_messages(cx: &mut TestAppContext) { · 328 unmodified lines
329	fn init_test(cx: &mut AppContext) -> Model<ChannelStore> {	329	fn init_test(cx: &mut AppContext) -> Model<ChannelStore> {
330	let settings_store = SettingsStore::test(cx);	330	let settings_store = SettingsStore::test(cx);
331	cx.set_global(settings_store);	331	cx.set_global(settings_store);
		332	client::init_settings(cx);
332		333
333	let http = FakeHttpClient::with_404_response();	334	let http = FakeHttpClient::with_404_response();
334	let client = Client::new(http.clone(), cx);	335	let client = Client::new(http.clone(), cx);

crates/client/src/client.rs+57−23

 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 use serde_json;
-use settings::Settings;
+use settings::{Settings, SettingsStore};
 use std::{
     any::TypeId,
     collections::HashMap,
 use telemetry::Telemetry;
 use thiserror::Error;
 use url::Url;
-use util::channel::ReleaseChannel;
 use util::http::HttpClient;
+use util::{channel::ReleaseChannel, http::ZedHttpClient};
 use util::{ResultExt, TryFutureExt};
 pub use rpc::*;
 pub use user::*;
 lazy_static! {
-    pub static ref ZED_SERVER_URL: String =
+    static ref ZED_SERVER_URL: Option<String> = std::env::var("ZED_SERVER_URL").ok();
-        std::env::var("ZED_SERVER_URL").unwrap_or_else(|_| "https://zed.dev".to_string());
+    static ref ZED_RPC_URL: Option<String> = std::env::var("ZED_RPC_URL").ok();
-    pub static ref ZED_RPC_URL: Option<String> = std::env::var("ZED_RPC_URL").ok();
     pub static ref IMPERSONATE_LOGIN: Option<String> = std::env::var("ZED_IMPERSONATE")
         .ok()
         .and_then(|s| if s.is_empty() { None } else { Some(s) });
 actions!(client, [SignIn, SignOut, Reconnect]);
+#[derive(Clone, Default, Serialize, Deserialize, JsonSchema)]
+pub struct ClientSettingsContent {
+    server_url: Option<String>,
+}
+#[derive(Deserialize)]
+pub struct ClientSettings {
+    pub server_url: String,
+}
+impl Settings for ClientSettings {
+    const KEY: Option<&'static str> = None;
+    type FileContent = ClientSettingsContent;
+    fn load(
+        default_value: &Self::FileContent,
+        user_values: &[&Self::FileContent],
+        _: &mut AppContext,
+    ) -> Result<Self>
+    where
+        Self: Sized,
+    {
+        let mut result = Self::load_via_json_merge(default_value, user_values)?;
+        if let Some(server_url) = &*ZED_SERVER_URL {
+            result.server_url = server_url.clone()
+        }
+        Ok(result)
+    }
+}
 pub fn init_settings(cx: &mut AppContext) {
     TelemetrySettings::register(cx);
+    cx.update_global(|store: &mut SettingsStore, cx| {
+        store.register_setting::<ClientSettings>(cx);
+    });
 }
 pub fn init(client: &Arc<Client>, cx: &mut AppContext) {
-    init_settings(cx);
     let client = Arc::downgrade(client);
     cx.on_action({
         let client = client.clone();
 pub struct Client {
     id: AtomicU64,
     peer: Arc<Peer>,
-    http: Arc<dyn HttpClient>,
+    http: Arc<ZedHttpClient>,
     telemetry: Arc<Telemetry>,
     state: RwLock<ClientState>,
 }
 impl Client {
-    pub fn new(http: Arc<dyn HttpClient>, cx: &mut AppContext) -> Arc<Self> {
+    pub fn new(http: Arc<ZedHttpClient>, cx: &mut AppContext) -> Arc<Self> {
-        Arc::new(Self {
+        let client = Arc::new(Self {
             id: AtomicU64::new(0),
             peer: Peer::new(0),
             telemetry: Telemetry::new(http.clone(), cx),
             authenticate: Default::default(),
             #[cfg(any(test, feature = "test-support"))]
             establish_connection: Default::default(),
-        })
+        });
+        client
     }
     pub fn id(&self) -> u64 {
         self.id.load(std::sync::atomic::Ordering::SeqCst)
     }
-    pub fn http_client(&self) -> Arc<dyn HttpClient> {
+    pub fn http_client(&self) -> Arc<ZedHttpClient> {
         self.http.clone()
     }
     }
     async fn get_rpc_url(
-        http: Arc<dyn HttpClient>,
+        http: Arc<ZedHttpClient>,
         release_channel: Option<ReleaseChannel>,
     ) -> Result<Url> {
         if let Some(url) = &*ZED_RPC_URL {
             return Url::parse(url).context("invalid rpc url");
         }
-        let mut url = format!("{}/rpc", *ZED_SERVER_URL);
+        let mut url = http.zed_url("/rpc");
         if let Some(preview_param) =
             release_channel.and_then(|channel| channel.release_query_param())
         {
                     // Open the Zed sign-in page in the user's browser, with query parameters that indicate
                     // that the user is signing in from a Zed app running on the same device.
-                    let mut url = format!(
+                    let mut url = http.zed_url(&format!(
-                        "{}/native_app_signin?native_app_port={}&native_app_public_key={}",
+                        "/native_app_signin?native_app_port={}&native_app_public_key={}",
-                        *ZED_SERVER_URL, port, public_key_string
+                        port, public_key_string
-                    );
+                    ));
                     if let Some(impersonate_login) = IMPERSONATE_LOGIN.as_ref() {
                         log::info!("impersonating user @{}", impersonate_login);
                                     }
                                     let post_auth_url =
-                                        format!("{}/native_app_signin_succeeded", *ZED_SERVER_URL);
+                                        http.zed_url("/native_app_signin_succeeded");
                                     req.respond(
                                         tiny_http::Response::empty(302).with_header(
                                             tiny_http::Header::from_bytes(
     }
     async fn authenticate_as_admin(
-        http: Arc<dyn HttpClient>,
+        http: Arc<ZedHttpClient>,
         login: String,
         mut api_token: String,
     ) -> Result<Credentials> {
     }
     let (user_id, access_token) = cx
-        .update(|cx| cx.read_credentials(&ZED_SERVER_URL))
+        .update(|cx| cx.read_credentials(&ClientSettings::get_global(cx).server_url))
         .log_err()?
         .await
         .log_err()??;
 ) -> Result<()> {
     cx.update(move |cx| {
         cx.write_credentials(
-            &ZED_SERVER_URL,
+            &ClientSettings::get_global(cx).server_url,
             &credentials.user_id.to_string(),
             credentials.access_token.as_bytes(),
         )
 }
 async fn delete_credentials_from_keychain(cx: &AsyncAppContext) -> Result<()> {
-    cx.update(move |cx| cx.delete_credentials(&ZED_SERVER_URL))?
+    cx.update(move |cx| cx.delete_credentials(&ClientSettings::get_global(cx).server_url))?
         .await
 }
         cx.update(|cx| {
             let settings_store = SettingsStore::test(cx);
             cx.set_global(settings_store);
+            init_settings(cx);
         });
     }
 }

crates/client/src/telemetry.rs+5−12

 mod event_coalescer;
-use crate::{TelemetrySettings, ZED_SERVER_URL};
+use crate::TelemetrySettings;
 use chrono::{DateTime, Utc};
 use futures::Future;
 use gpui::{AppContext, AppMetadata, BackgroundExecutor, Task};
-use lazy_static::lazy_static;
 use parking_lot::Mutex;
 use serde::Serialize;
 use settings::{Settings, SettingsStore};
     CpuRefreshKind, Pid, PidExt, ProcessExt, ProcessRefreshKind, RefreshKind, System, SystemExt,
 };
 use tempfile::NamedTempFile;
-use util::http::HttpClient;
+use util::http::{HttpClient, ZedHttpClient};
 #[cfg(not(debug_assertions))]
 use util::ResultExt;
 use util::{channel::ReleaseChannel, TryFutureExt};
 use self::event_coalescer::EventCoalescer;
 pub struct Telemetry {
-    http_client: Arc<dyn HttpClient>,
+    http_client: Arc<ZedHttpClient>,
     executor: BackgroundExecutor,
     state: Arc<Mutex<TelemetryState>>,
 }
     max_queue_size: usize,
 }
-const EVENTS_URL_PATH: &'static str = "/api/events";
-lazy_static! {
-    static ref EVENTS_URL: String = format!("{}{}", *ZED_SERVER_URL, EVENTS_URL_PATH);
-}
 #[derive(Serialize, Debug)]
 struct EventRequestBody {
     installation_id: Option<Arc<str>>,
 const FLUSH_INTERVAL: Duration = Duration::from_secs(60 * 5);
 impl Telemetry {
-    pub fn new(client: Arc<dyn HttpClient>, cx: &mut AppContext) -> Arc<Self> {
+    pub fn new(client: Arc<ZedHttpClient>, cx: &mut AppContext) -> Arc<Self> {
         let release_channel = cx
             .try_global::<ReleaseChannel>()
             .map(|release_channel| release_channel.display_name());
                     }
                     this.http_client
-                        .post_json(EVENTS_URL.as_str(), json_bytes.into())
+                        .post_json(&this.http_client.zed_url("/api/events"), json_bytes.into())
                         .await?;
                     anyhow::Ok(())
                 }

crates/collab/src/tests/test_server.rs+1−0

@@ -153,6 +153,7 @@ impl TestServer { · 152 unmodified lines
153	}	153	}
154	let settings = SettingsStore::test(cx);	154	let settings = SettingsStore::test(cx);
155	cx.set_global(settings);	155	cx.set_global(settings);
		156	client::init_settings(cx);
156	});	157	});
157		158
158	let http = FakeHttpClient::with_404_response();	159	let http = FakeHttpClient::with_404_response();

crates/feedback/src/feedback_modal.rs+3−3

 use anyhow::{anyhow, bail};
 use bitflags::bitflags;
-use client::{Client, ZED_SERVER_URL};
+use client::Client;
 use db::kvp::KEY_VALUE_STORE;
 use editor::{Editor, EditorEvent};
 use futures::AsyncReadExt;
 use regex::Regex;
 use serde_derive::Serialize;
 use ui::{prelude::*, Button, ButtonStyle, IconPosition, Tooltip};
-use util::ResultExt;
+use util::{http::HttpClient, ResultExt};
 use workspace::{ModalView, Toast, Workspace};
 use crate::{system_specs::SystemSpecs, GiveFeedback, OpenZedRepo};
             }
         }
-        let feedback_endpoint = format!("{}/api/feedback", *ZED_SERVER_URL);
         let telemetry = zed_client.telemetry();
         let metrics_id = telemetry.metrics_id();
         let installation_id = telemetry.installation_id();
         let is_staff = telemetry.is_staff();
         let http_client = zed_client.http_client();
+        let feedback_endpoint = http_client.zed_url("/api/feedback");
         let request = FeedbackRequestBody {
             feedback_text: &feedback_text,
             email,

crates/settings/src/settings_store.rs+40−2

@@ -1,6 +1,6 @@
1	use anyhow::{anyhow, Context, Result};	1	use anyhow::{anyhow, Context, Result};
2	use collections::{btree_map, hash_map, BTreeMap, HashMap};	2	use collections::{btree_map, hash_map, BTreeMap, HashMap};
3	use gpui::AppContext;	3	use gpui::{AppContext, AsyncAppContext};
4	use lazy_static::lazy_static;	4	use lazy_static::lazy_static;
5	use schemars::{gen::SchemaGenerator, schema::RootSchema, JsonSchema};	5	use schemars::{gen::SchemaGenerator, schema::RootSchema, JsonSchema};
6	use serde::{de::DeserializeOwned, Deserialize as _, Serialize};	6	use serde::{de::DeserializeOwned, Deserialize as _, Serialize};
@@ -13,7 +13,9 @@ use std::{ · 6 unmodified lines
13	str,	13	str,
14	sync::Arc,	14	sync::Arc,
15	};	15	};
16	use util::{merge_non_null_json_value_into, RangeExt, ResultExt as _};	16	use util::{
		17	channel::RELEASE_CHANNEL_NAME, merge_non_null_json_value_into, RangeExt, ResultExt as _,
		18	};
17		19
18	/// A value that can be defined as a user setting.	20	/// A value that can be defined as a user setting.
19	///	21	///
@@ -102,6 +104,14 @@ pub trait Settings: 'static + Send + Sync { · 82 unmodified lines
102	cx.global::<SettingsStore>().get(None)	104	cx.global::<SettingsStore>().get(None)
103	}	105	}
104		106
		107	#[track_caller]
		108	fn try_read_global<'a, R>(cx: &'a AsyncAppContext, f: impl FnOnce(&Self) -> R) -> Option<R>
		109	where
		110	Self: Sized,
		111	{
		112	cx.try_read_global(\|s: &SettingsStore, _\| f(s.get(None)))
		113	}
		114
105	#[track_caller]	115	#[track_caller]
106	fn override_global<'a>(settings: Self, cx: &'a mut AppContext)	116	fn override_global<'a>(settings: Self, cx: &'a mut AppContext)
107	where	117	where
@@ -197,6 +207,15 @@ impl SettingsStore { · 89 unmodified lines
197	user_values_stack = vec![user_settings];	207	user_values_stack = vec![user_settings];
198	}	208	}
199		209
		210	if let Some(release_settings) = &self.raw_user_settings.get(&*RELEASE_CHANNEL_NAME) {
		211	if let Some(release_settings) = setting_value
		212	.deserialize_setting(&release_settings)
		213	.log_err()
		214	{
		215	user_values_stack.push(release_settings);
		216	}
		217	}
		218
200	if let Some(setting) = setting_value	219	if let Some(setting) = setting_value
201	.load_setting(&default_settings, &user_values_stack, cx)	220	.load_setting(&default_settings, &user_values_stack, cx)
202	.context("A default setting must be added to the `default.json` file")	221	.context("A default setting must be added to the `default.json` file")
@@ -484,6 +503,15 @@ impl SettingsStore { · 281 unmodified lines
484	}	503	}
485	}	504	}
486		505
		506	for release_stage in ["dev", "nightly", "stable", "preview"] {
		507	let schema = combined_schema.schema.clone();
		508	combined_schema
		509	.schema
		510	.object()
		511	.properties
		512	.insert(release_stage.to_string(), schema.into());
		513	}
		514
487	serde_json::to_value(&combined_schema).unwrap()	515	serde_json::to_value(&combined_schema).unwrap()
488	}	516	}
489		517
@@ -509,6 +537,16 @@ impl SettingsStore { · 19 unmodified lines
509	paths_stack.push(None);	537	paths_stack.push(None);
510	}	538	}
511		539
		540	if let Some(release_settings) = &self.raw_user_settings.get(&*RELEASE_CHANNEL_NAME) {
		541	if let Some(release_settings) = setting_value
		542	.deserialize_setting(&release_settings)
		543	.log_err()
		544	{
		545	user_settings_stack.push(release_settings);
		546	paths_stack.push(None);
		547	}
		548	}
		549
512	// If the global settings file changed, reload the global value for the field.	550	// If the global settings file changed, reload the global value for the field.
513	if changed_local_path.is_none() {	551	if changed_local_path.is_none() {
514	if let Some(value) = setting_value	552	if let Some(value) = setting_value

crates/util/Cargo.toml+1−0

@@ -30,6 +30,7 @@ serde_json.workspace = true · 29 unmodified lines
30	git2 = { workspace = true, optional = true }	30	git2 = { workspace = true, optional = true }
31	dirs = "3.0"	31	dirs = "3.0"
32	take-until = "0.2.0"	32	take-until = "0.2.0"
		33	parking_lot.workspace = true
33		34
34	[target.'cfg(windows)'.dependencies]	35	[target.'cfg(windows)'.dependencies]
35	tendril = "0.4.3"	36	tendril = "0.4.3"

crates/util/src/http.rs+45−5

@@ -6,12 +6,49 @@ pub use isahc::{ · 5 unmodified lines
6	Error,	6	Error,
7	};	7	};
8	pub use isahc::{AsyncBody, Request, Response};	8	pub use isahc::{AsyncBody, Request, Response};
		9	use parking_lot::Mutex;
9	use smol::future::FutureExt;	10	use smol::future::FutureExt;
10	#[cfg(feature = "test-support")]	11	#[cfg(feature = "test-support")]
11	use std::fmt;	12	use std::fmt;
12	use std::{sync::Arc, time::Duration};	13	use std::{sync::Arc, time::Duration};
13	pub use url::Url;	14	pub use url::Url;
14		15
		16	pub struct ZedHttpClient {
		17	pub zed_host: Mutex<String>,
		18	client: Box<dyn HttpClient>,
		19	}
		20
		21	impl ZedHttpClient {
		22	pub fn zed_url(&self, path: &str) -> String {
		23	format!("{}{}", self.zed_host.lock(), path)
		24	}
		25	}
		26
		27	impl HttpClient for Arc<ZedHttpClient> {
		28	fn send(&self, req: Request<AsyncBody>) -> BoxFuture<Result<Response<AsyncBody>, Error>> {
		29	self.client.send(req)
		30	}
		31	}
		32
		33	impl HttpClient for ZedHttpClient {
		34	fn send(&self, req: Request<AsyncBody>) -> BoxFuture<Result<Response<AsyncBody>, Error>> {
		35	self.client.send(req)
		36	}
		37	}
		38
		39	pub fn zed_client(zed_host: &str) -> Arc<ZedHttpClient> {
		40	Arc::new(ZedHttpClient {
		41	zed_host: Mutex::new(zed_host.to_string()),
		42	client: Box::new(
		43	isahc::HttpClient::builder()
		44	.connect_timeout(Duration::from_secs(5))
		45	.low_speed_timeout(100, Duration::from_secs(5))
		46	.build()
		47	.unwrap(),
		48	),
		49	})
		50	}
		51
15	pub trait HttpClient: Send + Sync {	52	pub trait HttpClient: Send + Sync {
16	fn send(&self, req: Request<AsyncBody>) -> BoxFuture<Result<Response<AsyncBody>, Error>>;	53	fn send(&self, req: Request<AsyncBody>) -> BoxFuture<Result<Response<AsyncBody>, Error>>;
17		54
@@ -81,17 +118,20 @@ pub struct FakeHttpClient { · 63 unmodified lines
81		118
82	#[cfg(feature = "test-support")]	119	#[cfg(feature = "test-support")]
83	impl FakeHttpClient {	120	impl FakeHttpClient {
84	pub fn create<Fut, F>(handler: F) -> Arc<dyn HttpClient>	121	pub fn create<Fut, F>(handler: F) -> Arc<ZedHttpClient>
85	where	122	where
86	Fut: 'static + Send + futures::Future<Output = Result<Response<AsyncBody>, Error>>,	123	Fut: 'static + Send + futures::Future<Output = Result<Response<AsyncBody>, Error>>,
87	F: 'static + Send + Sync + Fn(Request<AsyncBody>) -> Fut,	124	F: 'static + Send + Sync + Fn(Request<AsyncBody>) -> Fut,
88	{	125	{
89	Arc::new(Self {	126	Arc::new(ZedHttpClient {
90	handler: Box::new(move \|req\| Box::pin(handler(req))),	127	zed_host: Mutex::new("http://test.example".into()),
		128	client: Box::new(Self {
		129	handler: Box::new(move \|req\| Box::pin(handler(req))),
		130	}),
91	})	131	})
92	}	132	}
93		133
94	pub fn with_404_response() -> Arc<dyn HttpClient> {	134	pub fn with_404_response() -> Arc<ZedHttpClient> {
95	Self::create(\|_\| async move {	135	Self::create(\|_\| async move {
96	Ok(Response::builder()	136	Ok(Response::builder()
97	.status(404)	137	.status(404)
@@ -100,7 +140,7 @@ impl FakeHttpClient { · 2 unmodified lines
100	})	140	})
101	}	141	}
102		142
103	pub fn with_200_response() -> Arc<dyn HttpClient> {	143	pub fn with_200_response() -> Arc<ZedHttpClient> {
104	Self::create(\|_\| async move {	144	Self::create(\|_\| async move {
105	Ok(Response::builder()	145	Ok(Response::builder()
106	.status(200)	146	.status(200)

crates/zed/src/main.rs+24−9

 use util::{
     async_maybe,
     channel::{parse_zed_link, AppCommitSha, ReleaseChannel, RELEASE_CHANNEL},
-    http::{self, HttpClient},
+    http::{self, HttpClient, ZedHttpClient},
     paths::{self, CRASHES_DIR, CRASHES_RETIRED_DIR},
     ResultExt,
 };
     menu::init();
     zed_actions::init();
-    let http = http::client();
     init_paths();
     init_logger();
         cx.set_global(store);
         handle_settings_file_changes(user_settings_file_rx, cx);
         handle_keymap_file_changes(user_keymap_file_rx, cx);
+        client::init_settings(cx);
+        let http = http::zed_client(&client::ClientSettings::get_global(cx).server_url);
         let client = client::Client::new(http.clone(), cx);
         let mut languages = LanguageRegistry::new(login_shell_env_loaded);
         languages.set_theme(cx.theme().clone());
         cx.observe_global::<SettingsStore>({
             let languages = languages.clone();
-            move |cx| languages.set_theme(cx.theme().clone())
+            let http = http.clone();
+            let client = client.clone();
+            move |cx| {
+                languages.set_theme(cx.theme().clone());
+                let new_host = &client::ClientSettings::get_global(cx).server_url;
+                let mut host = http.zed_host.lock();
+                if &*host != new_host {
+                    *host = new_host.clone();
+                    if client.status().borrow().is_connected() {
+                        client.reconnect(&cx.to_async());
+                    }
+                }
+            }
         })
         .detach();
         cx.set_global(Arc::downgrade(&app_state));
         audio::init(Assets, cx);
-        auto_update::init(http.clone(), client::ZED_SERVER_URL.clone(), cx);
+        auto_update::init(http.clone(), cx);
         workspace::init(app_state.clone(), cx);
         recent_projects::init(cx);
     }));
 }
-fn upload_panics_and_crashes(http: Arc<dyn HttpClient>, cx: &mut AppContext) {
+fn upload_panics_and_crashes(http: Arc<ZedHttpClient>, cx: &mut AppContext) {
     let telemetry_settings = *client::TelemetrySettings::get_global(cx);
     cx.background_executor()
         .spawn(async move {
 /// upload panics to us (via zed.dev)
 async fn upload_previous_panics(
-    http: Arc<dyn HttpClient>,
+    http: Arc<ZedHttpClient>,
     telemetry_settings: client::TelemetrySettings,
 ) -> Result<()> {
-    let panic_report_url = format!("{}/api/panic", &*client::ZED_SERVER_URL);
+    let panic_report_url = http.zed_url("/api/panic");
     let mut children = smol::fs::read_dir(&*paths::LOGS_DIR).await?;
     while let Some(child) = children.next().await {
         let child = child?;
 /// upload crashes from apple's diagnostic reports to our server.
 /// (only if telemetry is enabled)
 async fn upload_previous_crashes(
-    http: Arc<dyn HttpClient>,
+    http: Arc<ZedHttpClient>,
     telemetry_settings: client::TelemetrySettings,
 ) -> Result<()> {
     if !telemetry_settings.diagnostics {
         .unwrap_or("zed-2024-01-17-221900.ips".to_string()); // don't upload old crash reports from before we had this.
     let mut uploaded = last_uploaded.clone();
-    let crash_report_url = format!("{}/api/crash", &*client::ZED_SERVER_URL);
+    let crash_report_url = http.zed_url("/api/crash");
     for dir in [&*CRASHES_DIR, &*CRASHES_RETIRED_DIR] {
         let mut children = smol::fs::read_dir(&dir).await?;