"chrono",
"diesel",
"lazy_static",
+ "lemmy_utils",
"log",
"regex",
"serde 1.0.116",
bind: "0.0.0.0"
# port where lemmy should listen for incoming requests
port: 8536
+ # whether tls is required for activitypub. only disable this for debugging, never for producion.
+ tls_enabled: true
# json web token for authorization between server and client
jwt_secret: "changeme"
# address where pictrs is available
federation: {
# whether to enable activitypub federation. this feature is in alpha, do not enable in production.
enabled: false
- # whether tls is required for activitypub. only disable this for debugging, never for producion.
- tls_enabled: true
# comma separated list of instances with which federation is allowed
allowed_instances: ""
# comma separated list of instances which are blocked from federating
- LEMMY_DATABASE_URL=postgres://lemmy:password@postgres_alpha:5432/lemmy
- LEMMY_JWT_SECRET=changeme
- LEMMY_FEDERATION__ENABLED=true
- - LEMMY_FEDERATION__TLS_ENABLED=false
+ - LEMMY_TLS_ENABLED=false
- LEMMY_FEDERATION__ALLOWED_INSTANCES=lemmy-beta,lemmy-gamma,lemmy-delta,lemmy-epsilon
- LEMMY_PORT=8541
- LEMMY_SETUP__ADMIN_USERNAME=lemmy_alpha
- LEMMY_DATABASE_URL=postgres://lemmy:password@postgres_beta:5432/lemmy
- LEMMY_JWT_SECRET=changeme
- LEMMY_FEDERATION__ENABLED=true
- - LEMMY_FEDERATION__TLS_ENABLED=false
+ - LEMMY_TLS_ENABLED=false
- LEMMY_FEDERATION__ALLOWED_INSTANCES=lemmy-alpha,lemmy-gamma,lemmy-delta,lemmy-epsilon
- LEMMY_PORT=8551
- LEMMY_SETUP__ADMIN_USERNAME=lemmy_beta
- LEMMY_DATABASE_URL=postgres://lemmy:password@postgres_gamma:5432/lemmy
- LEMMY_JWT_SECRET=changeme
- LEMMY_FEDERATION__ENABLED=true
- - LEMMY_FEDERATION__TLS_ENABLED=false
+ - LEMMY_TLS_ENABLED=false
- LEMMY_FEDERATION__ALLOWED_INSTANCES=lemmy-alpha,lemmy-beta,lemmy-delta,lemmy-epsilon
- LEMMY_PORT=8561
- LEMMY_SETUP__ADMIN_USERNAME=lemmy_gamma
- LEMMY_DATABASE_URL=postgres://lemmy:password@postgres_delta:5432/lemmy
- LEMMY_JWT_SECRET=changeme
- LEMMY_FEDERATION__ENABLED=true
- - LEMMY_FEDERATION__TLS_ENABLED=false
+ - LEMMY_TLS_ENABLED=false
- LEMMY_FEDERATION__ALLOWED_INSTANCES=lemmy-beta
- LEMMY_PORT=8571
- LEMMY_SETUP__ADMIN_USERNAME=lemmy_delta
- LEMMY_DATABASE_URL=postgres://lemmy:password@postgres_epsilon:5432/lemmy
- LEMMY_JWT_SECRET=changeme
- LEMMY_FEDERATION__ENABLED=true
- - LEMMY_FEDERATION__TLS_ENABLED=false
+ - LEMMY_TLS_ENABLED=false
- LEMMY_FEDERATION__BLOCKED_INSTANCES=lemmy-alpha
- LEMMY_PORT=8581
- LEMMY_SETUP__ADMIN_USERNAME=lemmy_epsilon
// TODO no i18n support here.
let user_email = &user.email.expect("email");
let subject = &format!("Password reset for {}", user.name);
- let hostname = &format!("https://{}", Settings::get().hostname); //TODO add https for now.
+ let hostname = &Settings::get().get_protocol_and_hostname();
let html = &format!("<h1>Password Reset Request for {}</h1><br><a href={}/password_change/{}>Click here to reset your password</a>", user.name, hostname, &token);
match send_email(subject, user_email, &user.name, html) {
Ok(_o) => _o,
let data: &CreatePrivateMessage = &self;
let user = get_user_from_jwt(&data.auth, context.pool()).await?;
- let hostname = &format!("https://{}", Settings::get().hostname);
-
let content_slurs_removed = remove_slurs(&data.content.to_owned());
let private_message_form = PrivateMessageForm {
);
let html = &format!(
"<h1>Private Message</h1><br><div>{} - {}</div><br><a href={}/inbox>inbox</a>",
- user.name, &content_slurs_removed, hostname
+ user.name,
+ &content_slurs_removed,
+ Settings::get().get_protocol_and_hostname()
);
match send_email(subject, &email, &recipient_user.name, html) {
Ok(_o) => _o,
object::AsObject,
};
use lemmy_db::{community::Community, user::User_};
-use lemmy_utils::{apub::get_apub_protocol_string, settings::Settings, LemmyError};
+use lemmy_utils::{settings::Settings, LemmyError};
use lemmy_websocket::LemmyContext;
use serde::{export::fmt::Debug, Serialize};
use url::{ParseError, Url};
T: ToString,
{
let id = format!(
- "{}://{}/activities/{}/{}",
- get_apub_protocol_string(),
- Settings::get().hostname,
+ "{}/activities/{}/{}",
+ Settings::get().get_protocol_and_hostname(),
kind.to_string().to_lowercase(),
Uuid::new_v4()
);
};
use lemmy_structs::blocking;
use lemmy_utils::{
- apub::get_apub_protocol_string,
location_info,
+ settings::Settings,
utils::{check_slurs, check_slurs_opt, convert_datetime},
LemmyError,
};
};
Ok(Url::parse(&format!(
"{}://{}{}/inbox",
- get_apub_protocol_string(),
+ Settings::get().get_protocol_string(),
domain,
port,
))?)
};
use lemmy_structs::{blocking, site::SearchResponse};
use lemmy_utils::{
- apub::get_apub_protocol_string,
location_info,
request::{retry, RecvError},
+ settings::Settings,
LemmyError,
};
use lemmy_websocket::LemmyContext;
return Err(anyhow!("Invalid search query: {}", query).into());
};
- let url = format!("{}://{}{}", get_apub_protocol_string(), instance, name);
+ let url = format!(
+ "{}://{}{}",
+ Settings::get().get_protocol_string(),
+ instance,
+ name
+ );
Url::parse(&url)?
} else {
Url::parse(&query)?
use lemmy_db::{activity::do_insert_activity, user::User_, DbPool};
use lemmy_structs::{blocking, WebFingerResponse};
use lemmy_utils::{
- apub::get_apub_protocol_string,
location_info,
request::{retry, RecvError},
settings::Settings,
};
}
- if apub_id.scheme() != get_apub_protocol_string() {
+ if apub_id.scheme() != Settings::get().get_protocol_string() {
return Err(anyhow!("invalid apub id scheme: {:?}", apub_id.scheme()).into());
}
) -> Result<Url, LemmyError> {
let fetch_url = format!(
"{}://{}/.well-known/webfinger?resource=acct:{}@{}",
- get_apub_protocol_string(),
+ Settings::get().get_protocol_string(),
mention.domain,
mention.name,
mention.domain
path = "src/lib.rs"
[dependencies]
+lemmy_utils = { path = "../lemmy_utils" }
diesel = { version = "1.4", features = ["postgres","chrono","r2d2","64-column-tables","serde_json"] }
chrono = { version = "0.4", features = ["serde"] }
serde = { version = "1.0", features = ["derive"] }
};
use bcrypt::{hash, DEFAULT_COST};
use diesel::{dsl::*, result::Error, *};
+use lemmy_utils::settings::Settings;
use serde::Serialize;
#[derive(Clone, Queryable, Identifiable, PartialEq, Debug, Serialize)]
}
pub fn get_profile_url(&self, hostname: &str) -> String {
- format!("https://{}/u/{}", hostname, self.name)
+ format!(
+ "{}://{}/u/{}",
+ Settings::get().get_protocol_string(),
+ hostname,
+ self.name
+ )
}
pub fn upsert(conn: &PgConnection, user_form: &UserForm) -> Result<User_, Error> {
do_send_email: bool,
) -> Vec<i32> {
let mut recipient_ids = Vec::new();
- let hostname = &format!("https://{}", Settings::get().hostname);
+ let hostname = &Settings::get().get_protocol_and_hostname();
// Send the local mentions
for mention in mentions
PrivateMessage,
}
-pub fn get_apub_protocol_string() -> &'static str {
- if Settings::get().federation.tls_enabled {
- "https"
- } else {
- "http"
- }
-}
-
/// Generates the ActivityPub ID for a given object type and ID.
pub fn make_apub_endpoint(endpoint_type: EndpointType, name: &str) -> Url {
let point = match endpoint_type {
};
Url::parse(&format!(
- "{}://{}/{}/{}",
- get_apub_protocol_string(),
- Settings::get().hostname,
+ "{}/{}/{}",
+ Settings::get().get_protocol_and_hostname(),
point,
name
))
-use crate::{apub::get_apub_protocol_string, settings::Settings, LemmyError};
+use crate::{settings::Settings, LemmyError};
use anyhow::anyhow;
use log::error;
use percent_encoding::{utf8_percent_encode, NON_ALPHANUMERIC};
// The full urls are necessary for federation
let pictrs_thumbnail = if let Some(pictrs_hash) = pictrs_hash {
Some(format!(
- "{}://{}/pictrs/image/{}",
- get_apub_protocol_string(),
- Settings::get().hostname,
+ "{}/pictrs/image/{}",
+ Settings::get().get_protocol_and_hostname(),
pictrs_hash
))
} else {
pub hostname: String,
pub bind: IpAddr,
pub port: u16,
+ pub tls_enabled: bool,
pub jwt_secret: String,
pub pictrs_url: String,
pub rate_limit: RateLimitConfig,
#[derive(Debug, Deserialize, Clone)]
pub struct FederationConfig {
pub enabled: bool,
- pub tls_enabled: bool,
pub allowed_instances: String,
pub blocked_instances: String,
}
blocked_instances
}
+ /// Returns either "http" or "https", depending on tls_enabled setting
+ pub fn get_protocol_string(&self) -> &'static str {
+ if self.tls_enabled {
+ "https"
+ } else {
+ "http"
+ }
+ }
+
+ /// Returns something like `http://localhost` or `https://dev.lemmy.ml`,
+ /// with the correct protocol and hostname.
+ pub fn get_protocol_and_hostname(&self) -> String {
+ format!("{}://{}", self.get_protocol_string(), self.hostname)
+ }
+
pub fn save_config_file(data: &str) -> Result<String, Error> {
fs::write(CONFIG_FILE, data)?;
Crud,
};
use lemmy_utils::{
- apub::{generate_actor_keypair, get_apub_protocol_string, make_apub_endpoint, EndpointType},
+ apub::{generate_actor_keypair, make_apub_endpoint, EndpointType},
settings::Settings,
LemmyError,
};
info!("Running post_thumbnail_url_updates_2020_07_27");
let domain_prefix = format!(
- "{}://{}/pictrs/image/",
- get_apub_protocol_string(),
- Settings::get().hostname
+ "{}/pictrs/image/",
+ Settings::get().get_protocol_and_hostname(),
);
let incorrect_thumbnails = post.filter(thumbnail_url.not_like("http%"));
let mut channel_builder = ChannelBuilder::default();
channel_builder
.title(&format!("{} - All", site_view.name))
- .link(format!("https://{}", Settings::get().hostname))
+ .link(Settings::get().get_protocol_and_hostname())
.items(items);
if let Some(site_desc) = site_view.description {
let mut channel_builder = ChannelBuilder::default();
channel_builder
.title(&format!("{} - Subscribed", site_view.name))
- .link(format!("https://{}", Settings::get().hostname))
+ .link(Settings::get().get_protocol_and_hostname())
.items(items);
if let Some(site_desc) = site_view.description {
let mut channel_builder = ChannelBuilder::default();
channel_builder
.title(&format!("{} - Inbox", site_view.name))
- .link(format!("https://{}/inbox", Settings::get().hostname))
+ .link(format!(
+ "{}/inbox",
+ Settings::get().get_protocol_and_hostname()
+ ))
.items(items);
if let Some(site_desc) = site_view.description {
.iter()
.map(|r| {
let reply_url = format!(
- "https://{}/post/{}/comment/{}",
- Settings::get().hostname,
+ "{}/post/{}/comment/{}",
+ Settings::get().get_protocol_and_hostname(),
r.post_id,
r.id
);
.iter()
.map(|m| {
let mention_url = format!(
- "https://{}/post/{}/comment/{}",
- Settings::get().hostname,
+ "{}/post/{}/comment/{}",
+ Settings::get().get_protocol_and_hostname(),
m.post_id,
m.id
);
) -> Result<Item, LemmyError> {
let mut i = ItemBuilder::default();
i.title(format!("Reply from {}", creator_name));
- let author_url = format!("https://{}/u/{}", Settings::get().hostname, creator_name);
+ let author_url = format!(
+ "{}/u/{}",
+ Settings::get().get_protocol_and_hostname(),
+ creator_name
+ );
i.author(format!(
"/u/{} <a href=\"{}\">(link)</a>",
creator_name, author_url
i.title(p.name);
- let author_url = format!("https://{}/u/{}", Settings::get().hostname, p.creator_name);
+ let author_url = format!(
+ "{}/u/{}",
+ Settings::get().get_protocol_and_hostname(),
+ p.creator_name
+ );
i.author(format!(
"/u/{} <a href=\"{}\">(link)</a>",
p.creator_name, author_url
let dt = DateTime::<Utc>::from_utc(p.published, Utc);
i.pub_date(dt.to_rfc2822());
- let post_url = format!("https://{}/post/{}", Settings::get().hostname, p.id);
+ let post_url = format!(
+ "{}/post/{}",
+ Settings::get().get_protocol_and_hostname(),
+ p.id
+ );
i.comments(post_url.to_owned());
let guid = GuidBuilder::default()
.permalink(true)
i.guid(guid);
let community_url = format!(
- "https://{}/c/{}",
- Settings::get().hostname,
+ "{}/c/{}",
+ Settings::get().get_protocol_and_hostname(),
p.community_name
);
use lemmy_api::version;
use lemmy_db::site_view::SiteView;
use lemmy_structs::blocking;
-use lemmy_utils::{apub::get_apub_protocol_string, settings::Settings, LemmyError};
+use lemmy_utils::{settings::Settings, LemmyError};
use lemmy_websocket::LemmyContext;
use serde::{Deserialize, Serialize};
use url::Url;
links: NodeInfoWellKnownLinks {
rel: Url::parse("http://nodeinfo.diaspora.software/ns/schema/2.0")?,
href: Url::parse(&format!(
- "{}://{}/nodeinfo/2.0.json",
- get_apub_protocol_string(),
- Settings::get().hostname
+ "{}/nodeinfo/2.0.json",
+ Settings::get().get_protocol_and_hostname()
))?,
},
};