sqlx_postgres/options/
parse.rs

1use crate::error::Error;
2use crate::{PgConnectOptions, PgSslMode};
3use sqlx_core::percent_encoding::{percent_decode_str, utf8_percent_encode, NON_ALPHANUMERIC};
4use sqlx_core::Url;
5use std::net::IpAddr;
6use std::str::FromStr;
7
8impl PgConnectOptions {
9    pub(crate) fn parse_from_url(url: &Url) -> Result<Self, Error> {
10        let mut options = Self::new_without_pgpass();
11
12        if let Some(host) = url.host_str() {
13            let host_decoded = percent_decode_str(host);
14            options = match host_decoded.clone().next() {
15                Some(b'/') => options.socket(&*host_decoded.decode_utf8().map_err(Error::config)?),
16                _ => options.host(host),
17            }
18        }
19
20        if let Some(port) = url.port() {
21            options = options.port(port);
22        }
23
24        let username = url.username();
25        if !username.is_empty() {
26            options = options.username(
27                &percent_decode_str(username)
28                    .decode_utf8()
29                    .map_err(Error::config)?,
30            );
31        }
32
33        if let Some(password) = url.password() {
34            options = options.password(
35                &percent_decode_str(password)
36                    .decode_utf8()
37                    .map_err(Error::config)?,
38            );
39        }
40
41        let path = url.path().trim_start_matches('/');
42        if !path.is_empty() {
43            options = options.database(
44                &percent_decode_str(path)
45                    .decode_utf8()
46                    .map_err(Error::config)?,
47            );
48        }
49
50        for (key, value) in url.query_pairs().into_iter() {
51            match &*key {
52                "sslmode" | "ssl-mode" => {
53                    options = options.ssl_mode(value.parse().map_err(Error::config)?);
54                }
55
56                "sslrootcert" | "ssl-root-cert" | "ssl-ca" => {
57                    options = options.ssl_root_cert(&*value);
58                }
59
60                "sslcert" | "ssl-cert" => options = options.ssl_client_cert(&*value),
61
62                "sslkey" | "ssl-key" => options = options.ssl_client_key(&*value),
63
64                "statement-cache-capacity" => {
65                    options =
66                        options.statement_cache_capacity(value.parse().map_err(Error::config)?);
67                }
68
69                "host" => {
70                    if value.starts_with('/') {
71                        options = options.socket(&*value);
72                    } else {
73                        options = options.host(&value);
74                    }
75                }
76
77                "hostaddr" => {
78                    value.parse::<IpAddr>().map_err(Error::config)?;
79                    options = options.host(&value)
80                }
81
82                "port" => options = options.port(value.parse().map_err(Error::config)?),
83
84                "dbname" => options = options.database(&value),
85
86                "user" => options = options.username(&value),
87
88                "password" => options = options.password(&value),
89
90                "application_name" => options = options.application_name(&value),
91
92                "options" => {
93                    if let Some(options) = options.options.as_mut() {
94                        options.push(' ');
95                        options.push_str(&value);
96                    } else {
97                        options.options = Some(value.to_string());
98                    }
99                }
100
101                k if k.starts_with("options[") => {
102                    if let Some(key) = k.strip_prefix("options[").unwrap().strip_suffix(']') {
103                        options = options.options([(key, &*value)]);
104                    }
105                }
106
107                _ => tracing::warn!(%key, %value, "ignoring unrecognized connect parameter"),
108            }
109        }
110
111        let options = options.apply_pgpass();
112
113        Ok(options)
114    }
115
116    pub(crate) fn build_url(&self) -> Url {
117        let host = match &self.socket {
118            Some(socket) => {
119                utf8_percent_encode(&socket.to_string_lossy(), NON_ALPHANUMERIC).to_string()
120            }
121            None => self.host.to_owned(),
122        };
123
124        let mut url = Url::parse(&format!(
125            "postgres://{}@{}:{}",
126            self.username, host, self.port
127        ))
128        .expect("BUG: generated un-parseable URL");
129
130        if let Some(password) = &self.password {
131            let password = utf8_percent_encode(password, NON_ALPHANUMERIC).to_string();
132            let _ = url.set_password(Some(&password));
133        }
134
135        if let Some(database) = &self.database {
136            url.set_path(database);
137        }
138
139        let ssl_mode = match self.ssl_mode {
140            PgSslMode::Allow => "allow",
141            PgSslMode::Disable => "disable",
142            PgSslMode::Prefer => "prefer",
143            PgSslMode::Require => "require",
144            PgSslMode::VerifyCa => "verify-ca",
145            PgSslMode::VerifyFull => "verify-full",
146        };
147        url.query_pairs_mut().append_pair("sslmode", ssl_mode);
148
149        if let Some(ssl_root_cert) = &self.ssl_root_cert {
150            url.query_pairs_mut()
151                .append_pair("sslrootcert", &ssl_root_cert.to_string());
152        }
153
154        if let Some(ssl_client_cert) = &self.ssl_client_cert {
155            url.query_pairs_mut()
156                .append_pair("sslcert", &ssl_client_cert.to_string());
157        }
158
159        if let Some(ssl_client_key) = &self.ssl_client_key {
160            url.query_pairs_mut()
161                .append_pair("sslkey", &ssl_client_key.to_string());
162        }
163
164        url.query_pairs_mut().append_pair(
165            "statement-cache-capacity",
166            &self.statement_cache_capacity.to_string(),
167        );
168
169        url
170    }
171}
172
173impl FromStr for PgConnectOptions {
174    type Err = Error;
175
176    fn from_str(s: &str) -> Result<Self, Error> {
177        let url: Url = s.parse().map_err(Error::config)?;
178
179        Self::parse_from_url(&url)
180    }
181}
182
183#[test]
184fn it_parses_socket_correctly_from_parameter() {
185    let url = "postgres:///?host=/var/run/postgres/";
186    let opts = PgConnectOptions::from_str(url).unwrap();
187
188    assert_eq!(Some("/var/run/postgres/".into()), opts.socket);
189}
190
191#[test]
192fn it_parses_host_correctly_from_parameter() {
193    let url = "postgres:///?host=google.database.com";
194    let opts = PgConnectOptions::from_str(url).unwrap();
195
196    assert_eq!(None, opts.socket);
197    assert_eq!("google.database.com", &opts.host);
198}
199
200#[test]
201fn it_parses_hostaddr_correctly_from_parameter() {
202    let url = "postgres:///?hostaddr=8.8.8.8";
203    let opts = PgConnectOptions::from_str(url).unwrap();
204
205    assert_eq!(None, opts.socket);
206    assert_eq!("8.8.8.8", &opts.host);
207}
208
209#[test]
210fn it_parses_port_correctly_from_parameter() {
211    let url = "postgres:///?port=1234";
212    let opts = PgConnectOptions::from_str(url).unwrap();
213
214    assert_eq!(None, opts.socket);
215    assert_eq!(1234, opts.port);
216}
217
218#[test]
219fn it_parses_dbname_correctly_from_parameter() {
220    let url = "postgres:///?dbname=some_db";
221    let opts = PgConnectOptions::from_str(url).unwrap();
222
223    assert_eq!(None, opts.socket);
224    assert_eq!(Some("some_db"), opts.database.as_deref());
225}
226
227#[test]
228fn it_parses_user_correctly_from_parameter() {
229    let url = "postgres:///?user=some_user";
230    let opts = PgConnectOptions::from_str(url).unwrap();
231
232    assert_eq!(None, opts.socket);
233    assert_eq!("some_user", opts.username);
234}
235
236#[test]
237fn it_parses_password_correctly_from_parameter() {
238    let url = "postgres:///?password=some_pass";
239    let opts = PgConnectOptions::from_str(url).unwrap();
240
241    assert_eq!(None, opts.socket);
242    assert_eq!(Some("some_pass"), opts.password.as_deref());
243}
244
245#[test]
246fn it_parses_application_name_correctly_from_parameter() {
247    let url = "postgres:///?application_name=some_name";
248    let opts = PgConnectOptions::from_str(url).unwrap();
249
250    assert_eq!(Some("some_name"), opts.application_name.as_deref());
251}
252
253#[test]
254fn it_parses_username_with_at_sign_correctly() {
255    let url = "postgres://user@hostname:password@hostname:5432/database";
256    let opts = PgConnectOptions::from_str(url).unwrap();
257
258    assert_eq!("user@hostname", &opts.username);
259}
260
261#[test]
262fn it_parses_password_with_non_ascii_chars_correctly() {
263    let url = "postgres://username:p@ssw0rd@hostname:5432/database";
264    let opts = PgConnectOptions::from_str(url).unwrap();
265
266    assert_eq!(Some("p@ssw0rd".into()), opts.password);
267}
268
269#[test]
270fn it_parses_socket_correctly_percent_encoded() {
271    let url = "postgres://%2Fvar%2Flib%2Fpostgres/database";
272    let opts = PgConnectOptions::from_str(url).unwrap();
273
274    assert_eq!(Some("/var/lib/postgres/".into()), opts.socket);
275}
276#[test]
277fn it_parses_socket_correctly_with_username_percent_encoded() {
278    let url = "postgres://some_user@%2Fvar%2Flib%2Fpostgres/database";
279    let opts = PgConnectOptions::from_str(url).unwrap();
280
281    assert_eq!("some_user", opts.username);
282    assert_eq!(Some("/var/lib/postgres/".into()), opts.socket);
283    assert_eq!(Some("database"), opts.database.as_deref());
284}
285#[test]
286fn it_parses_libpq_options_correctly() {
287    let url = "postgres:///?options=-c%20synchronous_commit%3Doff%20--search_path%3Dpostgres";
288    let opts = PgConnectOptions::from_str(url).unwrap();
289
290    assert_eq!(
291        Some("-c synchronous_commit=off --search_path=postgres".into()),
292        opts.options
293    );
294}
295#[test]
296fn it_parses_sqlx_options_correctly() {
297    let url = "postgres:///?options[synchronous_commit]=off&options[search_path]=postgres";
298    let opts = PgConnectOptions::from_str(url).unwrap();
299
300    assert_eq!(
301        Some("-c synchronous_commit=off -c search_path=postgres".into()),
302        opts.options
303    );
304}
305
306#[test]
307fn it_returns_the_parsed_url_when_socket() {
308    let url = "postgres://username@%2Fvar%2Flib%2Fpostgres/database";
309    let opts = PgConnectOptions::from_str(url).unwrap();
310
311    let mut expected_url = Url::parse(url).unwrap();
312    // PgConnectOptions defaults
313    let query_string = "sslmode=prefer&statement-cache-capacity=100";
314    let port = 5432;
315    expected_url.set_query(Some(query_string));
316    let _ = expected_url.set_port(Some(port));
317
318    assert_eq!(expected_url, opts.build_url());
319}
320
321#[test]
322fn it_returns_the_parsed_url_when_host() {
323    let url = "postgres://username:p@ssw0rd@hostname:5432/database";
324    let opts = PgConnectOptions::from_str(url).unwrap();
325
326    let mut expected_url = Url::parse(url).unwrap();
327    // PgConnectOptions defaults
328    let query_string = "sslmode=prefer&statement-cache-capacity=100";
329    expected_url.set_query(Some(query_string));
330
331    assert_eq!(expected_url, opts.build_url());
332}
333
334#[test]
335fn built_url_can_be_parsed() {
336    let url = "postgres://username:p@ssw0rd@hostname:5432/database";
337    let opts = PgConnectOptions::from_str(url).unwrap();
338
339    let parsed = PgConnectOptions::from_str(&opts.build_url().to_string());
340
341    assert!(parsed.is_ok());
342}
sqlx_postgres/options/parse.rs

sqlx_postgres/options/
parse.rs
