Partial switch to Gitea Actions

.gitea/workflows/build.yml

@@ -14,6 +14,8 @@ jobs:
         steps:
             - uses: actions/checkout@v4
             - uses: actions-rust-lang/setup-rust-toolchain@v1
+              with:
+                  shared-key: "automation_rs"
             - name: Rustfmt check
               uses: actions-rust-lang/rustfmt@v1
 
@@ -24,6 +26,8 @@ jobs:
         steps:
             - uses: actions/checkout@v4
             - uses: actions-rust-lang/setup-rust-toolchain@v1
+              with:
+                  shared-key: "automation_rs"
             - name: Clippy
               run: cargo clippy --all-targets --all -- -D warnings
 
@@ -34,6 +38,8 @@ jobs:
         steps:
             - uses: actions/checkout@v4
             - uses: actions-rust-lang/setup-rust-toolchain@v1
+              with:
+                  shared-key: "automation_rs"
             - name: Build
               run: cargo build --release
 

.rustfmt.toml

@@ -1,2 +0,0 @@
-imports_granularity = "Module"
-group_imports = "StdExternalCrate"

config/config.yml

@@ -110,7 +110,7 @@ devices:
         !ContactSensor
         topic: "zigbee2mqtt/hallway/frontdoor"
         presence:
-            topic: "automation/presence/contact/frontdoor"
+            topic: "automation_dev/presence/contact/frontdoor"
             timeout: 900
         trigger:
             devices: ["hallway_lights"]

google-home/src/device.rs

@@ -1,11 +1,13 @@
 use async_trait::async_trait;
 use serde::Serialize;
 
-use crate::errors::{DeviceError, ErrorCode};
+use crate::{
-use crate::request::execute::CommandType;
+    errors::{DeviceError, ErrorCode},
-use crate::response;
+    request::execute::CommandType,
-use crate::traits::{FanSpeed, OnOff, Scene, Trait};
+    response,
-use crate::types::Type;
+    traits::{FanSpeed, OnOff, Scene, Trait},
+    types::Type,
+};
 
 // TODO: Find a more elegant way to do this
 pub trait AsGoogleHomeDevice {

google-home/src/fullfillment.rs

@@ -1,14 +1,15 @@
-use std::collections::HashMap;
+use std::{collections::HashMap, sync::Arc};
-use std::sync::Arc;
 
 use futures::future::{join_all, OptionFuture};
 use thiserror::Error;
 use tokio::sync::{Mutex, RwLock};
 
-use crate::device::AsGoogleHomeDevice;
+use crate::{
-use crate::errors::{DeviceError, ErrorCode};
+    device::AsGoogleHomeDevice,
-use crate::request::{self, Intent, Request};
+    errors::{DeviceError, ErrorCode},
-use crate::response::{self, execute, query, sync, Response, ResponsePayload, State};
+    request::{self, Intent, Request},
+    response::{self, execute, query, sync, Response, ResponsePayload, State},
+};
 
 #[derive(Debug)]
 pub struct GoogleHome {

google-home/src/lib.rs

@@ -13,6 +13,7 @@ pub mod traits;
 pub mod types;
 
 pub use device::GoogleHomeDevice;
-pub use fullfillment::{FullfillmentError, GoogleHome};
+pub use fullfillment::FullfillmentError;
+pub use fullfillment::GoogleHome;
 pub use request::Request;
 pub use response::Response;

google-home/src/response/execute.rs

@@ -1,7 +1,6 @@
 use serde::Serialize;
 
-use crate::errors::ErrorCode;
+use crate::{errors::ErrorCode, response::State};
-use crate::response::State;
 
 #[derive(Debug, Serialize, Clone)]
 #[serde(rename_all = "camelCase")]
@@ -88,8 +87,10 @@ pub enum Status {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::errors::DeviceError;
+    use crate::{
-    use crate::response::{Response, ResponsePayload, State};
+        errors::DeviceError,
+        response::{Response, ResponsePayload, State},
+    };
 
     #[test]
     fn serialize() {

google-home/src/response/query.rs

@@ -2,8 +2,7 @@ use std::collections::HashMap;
 
 use serde::Serialize;
 
-use crate::errors::ErrorCode;
+use crate::{errors::ErrorCode, response::State};
-use crate::response::State;
 
 #[derive(Debug, Serialize)]
 #[serde(rename_all = "camelCase")]

google-home/src/response/sync.rs

@@ -69,9 +69,11 @@ impl Device {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::response::{Response, ResponsePayload};
+    use crate::{
-    use crate::traits::Trait;
+        response::{Response, ResponsePayload},
-    use crate::types::Type;
+        traits::Trait,
+        types::Type,
+    };
 
     #[test]
     fn serialize() {

impl_cast/src/lib.rs

@@ -1,7 +1,6 @@
 use proc_macro::TokenStream;
 use quote::{format_ident, quote, ToTokens};
-use syn::parse::Parse;
+use syn::{parse::Parse, parse_macro_input, Ident, ItemTrait, Path, Token, TypeParamBound};
-use syn::{parse_macro_input, Ident, ItemTrait, Path, Token, TypeParamBound};
 
 struct Attr {
     name: Ident,

src/auth.rs

@@ -1,7 +1,8 @@
-use axum::async_trait;
+use axum::{
-use axum::extract::{FromRef, FromRequestParts};
+    async_trait,
-use axum::http::request::Parts;
+    extract::{FromRef, FromRequestParts},
-use axum::http::StatusCode;
+    http::{request::Parts, StatusCode},
+};
 use serde::Deserialize;
 
 use crate::error::{ApiError, ApiErrorJson};

src/config.rs

@@ -1,6 +1,8 @@
-use std::fs;
+use std::{
-use std::net::{Ipv4Addr, SocketAddr};
+    fs,
-use std::time::Duration;
+    net::{Ipv4Addr, SocketAddr},
+    time::Duration,
+};
 
 use indexmap::IndexMap;
 use regex::{Captures, Regex};
@@ -8,11 +10,13 @@ use rumqttc::{MqttOptions, Transport};
 use serde::{Deserialize, Deserializer};
 use tracing::debug;
 
-use crate::auth::OpenIDConfig;
+use crate::{
-use crate::device_manager::DeviceConfigs;
+    auth::OpenIDConfig,
-use crate::devices::PresenceConfig;
+    device_manager::DeviceConfigs,
-use crate::error::{ConfigParseError, MissingEnv};
+    devices::PresenceConfig,
-use crate::schedule::Schedule;
+    error::{ConfigParseError, MissingEnv},
+    schedule::Schedule,
+};
 
 #[derive(Debug, Deserialize)]
 pub struct Config {

src/device_manager.rs

@@ -11,14 +11,19 @@ use tokio::sync::{RwLock, RwLockReadGuard};
 use tokio_cron_scheduler::{Job, JobScheduler};
 use tracing::{debug, error, instrument, trace};
 
-use crate::devices::{
+use crate::{
-    AirFilterConfig, As, AudioSetupConfig, ContactSensorConfig, DebugBridgeConfig, Device,
+    devices::{
-    HueBridgeConfig, HueGroupConfig, IkeaOutletConfig, KasaOutletConfig, LightSensorConfig,
+        AirFilterConfig, As, AudioSetupConfig, ContactSensorConfig, DebugBridgeConfig, Device,
-    WakeOnLANConfig, WasherConfig,
+        HueBridgeConfig, HueGroupConfig, IkeaOutletConfig, KasaOutletConfig, LightSensorConfig,
+        WakeOnLANConfig, WasherConfig,
+    },
+    error::DeviceConfigError,
+    event::OnDarkness,
+    event::OnNotification,
+    event::OnPresence,
+    event::{Event, EventChannel, OnMqtt},
+    schedule::{Action, Schedule},
 };
-use crate::error::DeviceConfigError;
-use crate::event::{Event, EventChannel, OnDarkness, OnMqtt, OnNotification, OnPresence};
-use crate::schedule::{Action, Schedule};
 
 pub struct ConfigExternal<'a> {
     pub client: &'a AsyncClient,

src/devices/audio_setup.rs

@@ -3,13 +3,17 @@ use google_home::traits::OnOff;
 use serde::Deserialize;
 use tracing::{debug, error, trace, warn};
 
+use crate::{
+    config::MqttDeviceConfig,
+    device_manager::{ConfigExternal, DeviceConfig, WrappedDevice},
+    devices::As,
+    error::DeviceConfigError,
+    event::OnMqtt,
+    event::OnPresence,
+    messages::{RemoteAction, RemoteMessage},
+};
+
 use super::Device;
-use crate::config::MqttDeviceConfig;
-use crate::device_manager::{ConfigExternal, DeviceConfig, WrappedDevice};
-use crate::devices::As;
-use crate::error::DeviceConfigError;
-use crate::event::{OnMqtt, OnPresence};
-use crate::messages::{RemoteAction, RemoteMessage};
 
 #[derive(Debug, Clone, Deserialize)]
 pub struct AudioSetupConfig {

src/devices/contact_sensor.rs

@@ -8,14 +8,18 @@ use serde_with::{serde_as, DurationSeconds};
 use tokio::task::JoinHandle;
 use tracing::{debug, error, trace, warn};
 
+use crate::{
+    config::MqttDeviceConfig,
+    device_manager::{ConfigExternal, DeviceConfig, WrappedDevice},
+    devices::{As, DEFAULT_PRESENCE},
+    error::DeviceConfigError,
+    event::OnMqtt,
+    event::OnPresence,
+    messages::{ContactMessage, PresenceMessage},
+    traits::Timeout,
+};
+
 use super::Device;
-use crate::config::MqttDeviceConfig;
-use crate::device_manager::{ConfigExternal, DeviceConfig, WrappedDevice};
-use crate::devices::{As, DEFAULT_PRESENCE};
-use crate::error::DeviceConfigError;
-use crate::event::{OnMqtt, OnPresence};
-use crate::messages::{ContactMessage, PresenceMessage};
-use crate::traits::Timeout;
 
 // NOTE: If we add more presence devices we might need to move this out of here
 #[serde_as]

src/devices/debug_bridge.rs

@@ -3,12 +3,16 @@ use rumqttc::AsyncClient;
 use serde::Deserialize;
 use tracing::warn;
 
-use crate::config::MqttDeviceConfig;
+use crate::device_manager::ConfigExternal;
-use crate::device_manager::{ConfigExternal, DeviceConfig};
+use crate::device_manager::DeviceConfig;
 use crate::devices::Device;
 use crate::error::DeviceConfigError;
-use crate::event::{OnDarkness, OnPresence};
+use crate::event::OnDarkness;
-use crate::messages::{DarknessMessage, PresenceMessage};
+use crate::event::OnPresence;
+use crate::{
+    config::MqttDeviceConfig,
+    messages::{DarknessMessage, PresenceMessage},
+};
 
 #[derive(Debug, Deserialize)]
 pub struct DebugBridgeConfig {

src/devices/hue_bridge.rs

@@ -4,10 +4,13 @@ use async_trait::async_trait;
 use serde::{Deserialize, Serialize};
 use tracing::{error, trace, warn};
 
-use crate::device_manager::{ConfigExternal, DeviceConfig};
+use crate::{
-use crate::devices::Device;
+    device_manager::{ConfigExternal, DeviceConfig},
-use crate::error::DeviceConfigError;
+    devices::Device,
-use crate::event::{OnDarkness, OnPresence};
+    error::DeviceConfigError,
+    event::OnDarkness,
+    event::OnPresence,
+};
 
 #[derive(Debug)]
 pub enum Flag {

src/devices/hue_light.rs

@@ -1,21 +1,25 @@
-use std::net::{Ipv4Addr, SocketAddr};
+use std::{
-use std::time::Duration;
+    net::{Ipv4Addr, SocketAddr},
+    time::Duration,
+};
 
 use anyhow::{anyhow, Context, Result};
 use async_trait::async_trait;
-use google_home::errors::ErrorCode;
+use google_home::{errors::ErrorCode, traits::OnOff};
-use google_home::traits::OnOff;
 use rumqttc::Publish;
 use serde::Deserialize;
 use tracing::{debug, error, warn};
 
+use crate::{
+    config::MqttDeviceConfig,
+    device_manager::{ConfigExternal, DeviceConfig},
+    error::DeviceConfigError,
+    event::OnMqtt,
+    messages::{RemoteAction, RemoteMessage},
+    traits::Timeout,
+};
+
 use super::Device;
-use crate::config::MqttDeviceConfig;
-use crate::device_manager::{ConfigExternal, DeviceConfig};
-use crate::error::DeviceConfigError;
-use crate::event::OnMqtt;
-use crate::messages::{RemoteAction, RemoteMessage};
-use crate::traits::Timeout;
 
 #[derive(Debug, Clone, Deserialize)]
 pub struct HueGroupConfig {
@@ -225,8 +229,7 @@ impl Timeout for HueGroup {
 mod message {
     use std::time::Duration;
 
-    use serde::ser::SerializeStruct;
+    use serde::{ser::SerializeStruct, Deserialize, Serialize};
-    use serde::{Deserialize, Serialize};
 
     #[derive(Debug, Serialize, Deserialize)]
     pub struct Action {

src/devices/ikea_outlet.rs

@@ -1,14 +1,17 @@
-use std::time::Duration;
-
 use anyhow::Result;
 use async_trait::async_trait;
 use google_home::errors::ErrorCode;
-use google_home::traits::{self, OnOff};
+use google_home::{
-use google_home::types::Type;
+    device,
-use google_home::{device, GoogleHomeDevice};
+    traits::{self, OnOff},
+    types::Type,
+    GoogleHomeDevice,
+};
 use rumqttc::{matches, AsyncClient, Publish};
 use serde::Deserialize;
-use serde_with::{serde_as, DurationSeconds};
+use serde_with::serde_as;
+use serde_with::DurationSeconds;
+use std::time::Duration;
 use tokio::task::JoinHandle;
 use tracing::{debug, error, trace, warn};
 
@@ -16,7 +19,8 @@ use crate::config::{InfoConfig, MqttDeviceConfig};
 use crate::device_manager::{ConfigExternal, DeviceConfig};
 use crate::devices::Device;
 use crate::error::DeviceConfigError;
-use crate::event::{OnMqtt, OnPresence};
+use crate::event::OnMqtt;
+use crate::event::OnPresence;
 use crate::messages::{OnOffMessage, RemoteAction, RemoteMessage};
 use crate::traits::Timeout;
 

src/devices/kasa_outlet.rs

@@ -1,19 +1,28 @@
-use std::net::{Ipv4Addr, SocketAddr};
+use std::{
-use std::str::Utf8Error;
+    net::{Ipv4Addr, SocketAddr},
+    str::Utf8Error,
+};
 
 use async_trait::async_trait;
 use bytes::{Buf, BufMut};
-use google_home::errors::{self, DeviceError};
+use google_home::{
-use google_home::traits;
+    errors::{self, DeviceError},
+    traits,
+};
 use serde::{Deserialize, Serialize};
 use thiserror::Error;
-use tokio::io::{AsyncReadExt, AsyncWriteExt};
+use tokio::{
-use tokio::net::TcpStream;
+    io::{AsyncReadExt, AsyncWriteExt},
+    net::TcpStream,
+};
 use tracing::trace;
 
+use crate::{
+    device_manager::{ConfigExternal, DeviceConfig},
+    error::DeviceConfigError,
+};
+
 use super::Device;
-use crate::device_manager::{ConfigExternal, DeviceConfig};
-use crate::error::DeviceConfigError;
 
 #[derive(Debug, Clone, Deserialize)]
 pub struct KasaOutletConfig {

src/devices/light_sensor.rs

@@ -3,12 +3,15 @@ use rumqttc::Publish;
 use serde::Deserialize;
 use tracing::{debug, trace, warn};
 
-use crate::config::MqttDeviceConfig;
+use crate::{
-use crate::device_manager::{ConfigExternal, DeviceConfig};
+    config::MqttDeviceConfig,
-use crate::devices::Device;
+    device_manager::{ConfigExternal, DeviceConfig},
-use crate::error::DeviceConfigError;
+    devices::Device,
-use crate::event::{self, Event, OnMqtt};
+    error::DeviceConfigError,
-use crate::messages::BrightnessMessage;
+    event::OnMqtt,
+    event::{self, Event},
+    messages::BrightnessMessage,
+};
 
 #[derive(Debug, Clone, Deserialize)]
 pub struct LightSensorConfig {

src/devices/mod.rs

@@ -12,9 +12,6 @@ mod presence;
 mod wake_on_lan;
 mod washer;
 
-use google_home::device::AsGoogleHomeDevice;
-use google_home::traits::OnOff;
-
 pub use self::air_filter::AirFilterConfig;
 pub use self::audio_setup::AudioSetupConfig;
 pub use self::contact_sensor::ContactSensorConfig;
@@ -28,8 +25,11 @@ pub use self::ntfy::{Notification, Ntfy};
 pub use self::presence::{Presence, PresenceConfig, DEFAULT_PRESENCE};
 pub use self::wake_on_lan::WakeOnLANConfig;
 pub use self::washer::WasherConfig;
-use crate::event::{OnDarkness, OnMqtt, OnNotification, OnPresence};
+
+use google_home::{device::AsGoogleHomeDevice, traits::OnOff};
+
 use crate::traits::Timeout;
+use crate::{event::OnDarkness, event::OnMqtt, event::OnNotification, event::OnPresence};
 
 #[impl_cast::device(As: OnMqtt + OnPresence + OnDarkness + OnNotification + OnOff + Timeout)]
 pub trait Device: AsGoogleHomeDevice + std::fmt::Debug + Sync + Send {

src/devices/ntfy.rs

@@ -5,9 +5,12 @@ use serde::Serialize;
 use serde_repr::*;
 use tracing::{debug, error, warn};
 
-use crate::config::NtfyConfig;
+use crate::{
-use crate::devices::Device;
+    config::NtfyConfig,
-use crate::event::{self, Event, EventChannel, OnNotification, OnPresence};
+    devices::Device,
+    event::{self, Event, EventChannel},
+    event::{OnNotification, OnPresence},
+};
 
 #[derive(Debug)]
 pub struct Ntfy {

src/devices/presence.rs

@@ -5,10 +5,13 @@ use rumqttc::Publish;
 use serde::Deserialize;
 use tracing::{debug, warn};
 
-use crate::config::MqttDeviceConfig;
+use crate::{
-use crate::devices::Device;
+    config::MqttDeviceConfig,
-use crate::event::{self, Event, EventChannel, OnMqtt};
+    devices::Device,
-use crate::messages::PresenceMessage;
+    event::OnMqtt,
+    event::{self, Event, EventChannel},
+    messages::PresenceMessage,
+};
 
 #[derive(Debug, Deserialize)]
 pub struct PresenceConfig {

src/devices/wake_on_lan.rs

@@ -2,20 +2,26 @@ use std::net::Ipv4Addr;
 
 use async_trait::async_trait;
 use eui48::MacAddress;
-use google_home::errors::ErrorCode;
+use google_home::{
-use google_home::traits::{self, Scene};
+    device,
-use google_home::types::Type;
+    errors::ErrorCode,
-use google_home::{device, GoogleHomeDevice};
+    traits::{self, Scene},
+    types::Type,
+    GoogleHomeDevice,
+};
 use rumqttc::Publish;
 use serde::Deserialize;
 use tracing::{debug, error, trace};
 
+use crate::{
+    config::{InfoConfig, MqttDeviceConfig},
+    device_manager::{ConfigExternal, DeviceConfig},
+    error::DeviceConfigError,
+    event::OnMqtt,
+    messages::ActivateMessage,
+};
+
 use super::Device;
-use crate::config::{InfoConfig, MqttDeviceConfig};
-use crate::device_manager::{ConfigExternal, DeviceConfig};
-use crate::error::DeviceConfigError;
-use crate::event::OnMqtt;
-use crate::messages::ActivateMessage;
 
 #[derive(Debug, Clone, Deserialize)]
 pub struct WakeOnLANConfig {

src/devices/washer.rs

@@ -3,13 +3,15 @@ use rumqttc::Publish;
 use serde::Deserialize;
 use tracing::{debug, error, warn};
 
-use super::ntfy::Priority;
+use crate::{
-use super::{Device, Notification};
+    config::MqttDeviceConfig,
-use crate::config::MqttDeviceConfig;
+    device_manager::{ConfigExternal, DeviceConfig},
-use crate::device_manager::{ConfigExternal, DeviceConfig};
+    error::DeviceConfigError,
-use crate::error::DeviceConfigError;
+    event::{Event, EventChannel, OnMqtt},
-use crate::event::{Event, EventChannel, OnMqtt};
+    messages::PowerMessage,
-use crate::messages::PowerMessage;
+};
+
+use super::{ntfy::Priority, Device, Notification};
 
 #[derive(Debug, Clone, Deserialize)]
 pub struct WasherConfig {

src/error.rs

@@ -1,7 +1,6 @@
 use std::{error, fmt, result};
 
-use axum::http::status::InvalidStatusCode;
+use axum::{http::status::InvalidStatusCode, response::IntoResponse};
-use axum::response::IntoResponse;
 use bytes::Bytes;
 use rumqttc::ClientError;
 use serde::{Deserialize, Serialize};

src/event.rs

@@ -1,8 +1,9 @@
 use async_trait::async_trait;
-use impl_cast::device_trait;
 use rumqttc::Publish;
 use tokio::sync::mpsc;
 
+use impl_cast::device_trait;
+
 use crate::devices::Notification;
 
 #[derive(Debug, Clone)]

src/main.rs

@@ -1,22 +1,23 @@
 #![feature(async_closure)]
 use std::process;
 
-use automation::auth::{OpenIDConfig, User};
+use axum::{
-use automation::config::Config;
+    extract::FromRef, http::StatusCode, response::IntoResponse, routing::post, Json, Router,
-use automation::device_manager::DeviceManager;
+};
-use automation::devices::{Ntfy, Presence};
-use automation::error::ApiError;
-use automation::mqtt;
-use axum::extract::FromRef;
-use axum::http::StatusCode;
-use axum::response::IntoResponse;
-use axum::routing::post;
-use axum::{Json, Router};
 use dotenvy::dotenv;
-use google_home::{GoogleHome, Request};
 use rumqttc::AsyncClient;
 use tracing::{debug, error, info};
 
+use automation::{
+    auth::{OpenIDConfig, User},
+    config::Config,
+    device_manager::DeviceManager,
+    devices::{Ntfy, Presence},
+    error::ApiError,
+    mqtt,
+};
+use google_home::{GoogleHome, Request};
+
 #[derive(Clone)]
 struct AppState {
     pub openid: OpenIDConfig,

src/mqtt.rs

@@ -1,6 +1,7 @@
-use rumqttc::{Event, EventLoop, Incoming};
 use tracing::{debug, warn};
 
+use rumqttc::{Event, EventLoop, Incoming};
+
 use crate::event::{self, EventChannel};
 
 pub fn start(mut eventloop: EventLoop, event_channel: &EventChannel) {