How to Send Emails and Connect to IMAP Servers in Rust

Most web applications these days need to interact with email in some way or another, so good language support is crucial. Rust certainly has basic support for working with emails, but I wouldn’t say it can cover all use cases just yet. The ecosystem is quite small and doesn’t currently have good support for async/await.

That said, it’s a useful exercise to mess around with the solutions that are available and see how they work. In this tutorial, we’ll show you how to send emails and connect to IMAP servers in Rust.

Creating emails with lettre

The most popular crate for sending emails is lettre. As of now, the latest stable release of letter (0.9) doesn’t include an async API, but there’s also an alpha release for version 0.10, which supports async via tokioandasync-std.

Let’s first take a look at the current version without async then port the code to an async implementation using the alpha release.

Add the following to Cargo.toml to get started.

[dependencies]
lettre = "0.9"
lettre_email = "0.9"

With version 0.9, we need to use lettre_email to build emails then lettre to send them, so we need specify both.

Start by creating a basic email.

use lettre_email::EmailBuilder;

fn main() {
    let email = EmailBuilder::new()
        .to("hello@example.com")
        .from("me@hello.com")
        .subject("Example subject")
        .text("Hello, world!")
        .build()
        .unwrap();
}

This uses the builder pattern to create the data structure that represents an email. If we want to specify a name and an address, we can use a tuple, like this:

let email = EmailBuilder::new()
    .to(("hello@example.com", "Alice Smith"))
    .from(("me@hello.com", "Bob Smith"))
    .subject("Example subject")
    .text("Hello, world!")
    .build()
    .unwrap();

Adding a HTML body is as simple as calling the corresponding method on the builder.

let email = EmailBuilder::new()
    .to("hello@example.com")
    .from("me@hello.com")
    .subject("Example subject")
    .html("<h1>Hello, world!</h1>")
    .build()
    .unwrap();

Let’s say we want to send attachments with our emails. Here’s how you would attach a local file to an email:

use lettre_email::mime;
use lettre_email::EmailBuilder;
use std::path::Path;

fn main() {
    let email = EmailBuilder::new()
        .to("hello@example.com")
        .from("me@hello.com")
        .subject("Example subject")
        .html("<h1>Hello, world!</h1>")
        .attachment_from_file(
            &Path::new("path/to/file.pdf"), // Path to file on disk
            Some("Cookie-recipe.pdf"),      // Filename to use in the email
            &mime::APPLICATION_PDF,
        )
        .unwrap()
        .build()
        .unwrap();
}

Alternatively, we can use the attachment(...) builder method to send a vector of bytes directly from memory instead of a file on disk.

There are a few more builder methods for things I haven’t mentioned, so if you want to do something else with the email, take a look at the docs for lettre_email::EmailBuilder.

#rust #programming #developer

What is GEEK

Buddha Community

Best Practices for Running Your Own Email Server

Plesk Premium Email, powered by Kolab lets you become your own mail service provider in a few easy steps. It’s like creating a personal Gmail service, one that you control from top to bottom. Running the mail server allows you to store your own email, access the mail server’s logs, and access the raw email files in a user’s mailbox.

However, one key concern when running your own mail server is email deliverability. Without being able to effectively reach your customer base, you cannot do business. So, how do you ensure your emails do not end up as spam?

It’s important to follow common rules and best practices when operating a mail server to guarantee your emails always reach their destination. In this quick guide, we’ll walk you through a few things to consider, to make sure that your emails always end up where you intend.

Reputation Management

Much of email delivery depends on your reputation, which is attached to your IPs and domains.

Please note that there might be different types of setups where you can either influence these things or not:

• If you’re **running your own server **(or VPS – virtual private server) or a bunch of servers with Plesk for shared hosting with WHMCS, you have full influence and control about the following settings.
• If you’re an **end customer or reseller **of a service provider or hoster using Plesk, unfortunately only your hosting provider can do these modifications for you. In case you want to regain control of your environments, it’s time to move your shared hosting account to your own VPS!
• If you run Plesk on one of the hyperscale cloud providers such as DigitalOcean, Linode, AWS/Lightsail, Azure, or Google, your default email / SMTP (Port 25 or not) might be blocked on the infrastructure level. If that’s the case, you might need to contact their support to unblock it. In addition, also check that you’re receiving a reverse DNS entry for your IP that is required for operating an email server properly.

The two key-factors that we can influence are:

**1. Ensure other servers can distinguish **between genuine email coming from your server and spam coming from other servers, pretending to come from your server. If you don’t, a spammer can burn your hard-earned reputation while delivering their spam.

You can ensure this by enabling DKIM/DMARC and SPF protection in Plesk under “Server-Wide Mail Settings”.

#plesk news and announcements #email #email server #kolab #plesk email security #plesk premium email #self-hosted email #spam

Send Email In Laravel

Hello Guys,

Today I will give you demo how to send email in laravel, in this post we will show how to send email using SMTP in laravel, email is very basic and most important feature in web development field and it is necessary for all client.

So, in this tutorial I will give you information about send mail in laravel. So, follow below steps.

Send Email In Laravel

https://websolutionstuff.com/post/send-email-in-laravel

#laravel #php #send email in laravel #email #how to send email in laravel #laravel send mail

Node js Send Email with Attachment using Nodemailer

In this node js send email with attachment using nodemailer. In this tutorial, you will learn how you can send the email using the Gmail SMTP in node js. Here you will learn step by step, how you can send email using Gmail SMTP in node js

Sending email via Node js is easy. Today we are going to discuss send an email via node js. We will use nodemailermodule and Gmail SMTP to send the email. We will also learn how to send an email with an attachment. So let’s get started with the node js send email with attachment tutorial.

How to Send Attachment in Email using Nodemailer in Node Js

Just follow the following steps and send email through gmail with attachment using nodemailer in node js:

1. Step 1 - First Install Nodemailer 1. Step 2 - Configure Gmail SMTP with Nodemailer 1. Step 3 - Sending Email with Gmail SMTP 1. Step 4 - Send Multiple Recipient At The Same Time 1. Step 5 - Send Simple HTML

https://www.tutsmake.com/node-js-send-email-through-gmail-with-attachment-example/

#node js send email through gmail with attachment #how to send attachment in mail using nodemailer #nodejs send email with attachment #nodejs send email with attachment example

Send emails through Python

You will be surprised how easy is to configure your account and send emails with attachments in Python

You cannot imagine how easy and simple it is to configure your email account to be able to send emails to one or several contacts directly from your Python environment without any effort or complicated code.

In this article, I will walk you through the process. All you need is a Gmail account and your Python running and ready to go. Let me show you how it’s done.

#email #python #programming #automation #send-email #send emails through python

PostgreSQL Connection Pooling: Part 4 – PgBouncer vs. Pgpool-II

In our previous posts in this series, we spoke at length about using PgBouncer  and Pgpool-II , the connection pool architecture and pros and cons of leveraging one for your PostgreSQL deployment. In our final post, we will put them head-to-head in a detailed feature comparison and compare the results of PgBouncer vs. Pgpool-II performance for your PostgreSQL hosting !

The bottom line – Pgpool-II is a great tool if you need load-balancing and high availability. Connection pooling is almost a bonus you get alongside. PgBouncer does only one thing, but does it really well. If the objective is to limit the number of connections and reduce resource consumption, PgBouncer wins hands down.

It is also perfectly fine to use both PgBouncer and Pgpool-II in a chain – you can have a PgBouncer to provide connection pooling, which talks to a Pgpool-II instance that provides high availability and load balancing. This gives you the best of both worlds!

PostgreSQL Connection Pooling: Part 4 – PgBouncer vs. Pgpool-II

CLICK TO TWEET

Performance Testing

While PgBouncer may seem to be the better option in theory, theory can often be misleading. So, we pitted the two connection poolers head-to-head, using the standard pgbench tool, to see which one provides better transactions per second throughput through a benchmark test. For good measure, we ran the same tests without a connection pooler too.

Testing Conditions

All of the PostgreSQL benchmark tests were run under the following conditions:

1. Initialized pgbench using a scale factor of 100.
2. Disabled auto-vacuuming on the PostgreSQL instance to prevent interference.
3. No other workload was working at the time.
4. Used the default pgbench script to run the tests.
5. Used default settings for both PgBouncer and Pgpool-II, except max_children*. All PostgreSQL limits were also set to their defaults.
6. All tests ran as a single thread, on a single-CPU, 2-core machine, for a duration of 5 minutes.
7. Forced pgbench to create a new connection for each transaction using the -C option. This emulates modern web application workloads and is the whole reason to use a pooler!

We ran each iteration for 5 minutes to ensure any noise averaged out. Here is how the middleware was installed:

• For PgBouncer, we installed it on the same box as the PostgreSQL server(s). This is the configuration we use in our managed PostgreSQL clusters. Since PgBouncer is a very light-weight process, installing it on the box has no impact on overall performance.
• For Pgpool-II, we tested both when the Pgpool-II instance was installed on the same machine as PostgreSQL (on box column), and when it was installed on a different machine (off box column). As expected, the performance is much better when Pgpool-II is off the box as it doesn’t have to compete with the PostgreSQL server for resources.

Throughput Benchmark

Here are the transactions per second (TPS) results for each scenario across a range of number of clients:

#database #developer #performance #postgresql #connection control #connection pooler #connection pooler performance #connection queue #high availability #load balancing #number of connections #performance testing #pgbench #pgbouncer #pgbouncer and pgpool-ii #pgbouncer vs pgpool #pgpool-ii #pooling modes #postgresql connection pooling #postgresql limits #resource consumption #throughput benchmark #transactions per second #without pooling