Compare commits
1 Commits
main
...
debug-prin
| Author | SHA1 | Date | |
|---|---|---|---|
66eac50be4
|
1
.gitignore
vendored
1
.gitignore
vendored
@ -1,2 +1 @@
|
||||
/target
|
||||
result
|
||||
|
||||
1143
Cargo.lock
generated
1143
Cargo.lock
generated
File diff suppressed because it is too large
Load Diff
20
Cargo.toml
20
Cargo.toml
@ -2,33 +2,19 @@
|
||||
name = "greg-ng"
|
||||
version = "0.1.0"
|
||||
edition = "2021"
|
||||
license = "MIT"
|
||||
authors = ["oysteikt@pvv.ntnu.no"]
|
||||
readme = "README.md"
|
||||
|
||||
# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
|
||||
|
||||
[dependencies]
|
||||
anyhow = "1.0.82"
|
||||
axum = { version = "0.7.7", features = ["macros"] }
|
||||
axum = { version = "0.6.20", features = ["macros"] }
|
||||
clap = { version = "4.4.1", features = ["derive"] }
|
||||
clap-verbosity-flag = "2.2.2"
|
||||
env_logger = "0.10.0"
|
||||
futures = "0.3.30"
|
||||
log = "0.4.20"
|
||||
mpvipc-async = { git = "https://git.pvv.ntnu.no/oysteikt/mpvipc-async.git", rev = "v0.1.0" }
|
||||
sd-notify = "0.4.3"
|
||||
mpvipc-async = { path = "../mpvipc-async" }
|
||||
serde = { version = "1.0.188", features = ["derive"] }
|
||||
serde_json = "1.0.105"
|
||||
systemd-journal-logger = "2.2.0"
|
||||
tempfile = "3.11.0"
|
||||
tokio = { version = "1.32.0", features = ["full"] }
|
||||
tower = { version = "0.4.13", features = ["full"] }
|
||||
tower-http = { version = "0.4.3", features = ["full"] }
|
||||
utoipa = { version = "5.1.3", features = ["axum_extras"] }
|
||||
utoipa-axum = "0.1.2"
|
||||
utoipa-swagger-ui = { version = "8.0.3", features = ["axum", "vendored"] }
|
||||
|
||||
[profile.release]
|
||||
strip = true
|
||||
lto = true
|
||||
codegen-units = 1
|
||||
|
||||
18
README.md
18
README.md
@ -1,21 +1,3 @@
|
||||
# Greg-ng
|
||||
|
||||
New implementation of https://github.com/Programvareverkstedet/grzegorz
|
||||
|
||||
## Test it out
|
||||
|
||||
```sh
|
||||
# NixOS
|
||||
nix run "git+https://git.pvv.ntnu.no/Projects/greg-ng#" -- --mpv-socket-path /tmp/mpv.sock
|
||||
|
||||
# Other (after git clone and rust toolchain has been set up)
|
||||
cargo run -- --mpv-socket-path /tmp/mpv.sock
|
||||
```
|
||||
|
||||
See also https://git.pvv.ntnu.no/Projects/grzegorz-clients for frontend alternatives
|
||||
|
||||
## Debugging
|
||||
|
||||
```sh
|
||||
RUST_LOG=greg_ng=trace,mpvipc=trace cargo run -- --mpv-socket-path /tmp/mpv.sock
|
||||
```
|
||||
|
||||
@ -1,3 +0,0 @@
|
||||
[youtube]
|
||||
profile-cond=path:find('youtu%.?be')
|
||||
--ytdl-format="bestvideo[height<=?720][vcodec!~='vp0?9']+bestaudio/best"
|
||||
Binary file not shown.
|
Before Width: | Height: | Size: 157 KiB |
52
default.nix
52
default.nix
@ -1,52 +0,0 @@
|
||||
{
|
||||
lib
|
||||
, fetchFromGitHub
|
||||
, rustPlatform
|
||||
, makeWrapper
|
||||
, mpv
|
||||
, wrapped ? false
|
||||
}:
|
||||
|
||||
rustPlatform.buildRustPackage rec {
|
||||
pname = "greg-ng";
|
||||
version = "0.1.0";
|
||||
src = builtins.filterSource (path: type: let
|
||||
baseName = baseNameOf (toString path);
|
||||
in !(lib.any (b: b) [
|
||||
(!(lib.cleanSourceFilter path type))
|
||||
(type == "directory" && lib.elem baseName [
|
||||
".direnv"
|
||||
".git"
|
||||
"target"
|
||||
"result"
|
||||
])
|
||||
(type == "regular" && lib.elem baseName [
|
||||
"flake.nix"
|
||||
"flake.lock"
|
||||
"default.nix"
|
||||
"module.nix"
|
||||
".envrc"
|
||||
])
|
||||
])) ./.;
|
||||
|
||||
nativeBuildInputs = [ makeWrapper ];
|
||||
|
||||
cargoLock = {
|
||||
lockFile = ./Cargo.lock;
|
||||
outputHashes = {
|
||||
"mpvipc-async-0.1.0" = "sha256-2TQ2d4q9/DTxTZe9kOAoKBhsmegRZw32x3G2hbluS6U=";
|
||||
};
|
||||
};
|
||||
|
||||
postInstall = lib.optionalString wrapped ''
|
||||
wrapProgram $out/bin/greg-ng \
|
||||
--prefix PATH : '${lib.makeBinPath [ mpv ]}'
|
||||
'';
|
||||
|
||||
meta = with lib; {
|
||||
license = licenses.mit;
|
||||
maintainers = with maintainers; [ h7x4 ];
|
||||
platforms = platforms.linux ++ platforms.darwin;
|
||||
mainProgram = "greg-ng";
|
||||
};
|
||||
}
|
||||
12
flake.lock
generated
12
flake.lock
generated
@ -2,11 +2,11 @@
|
||||
"nodes": {
|
||||
"nixpkgs": {
|
||||
"locked": {
|
||||
"lastModified": 1729256560,
|
||||
"narHash": "sha256-/uilDXvCIEs3C9l73JTACm4quuHUsIHcns1c+cHUJwA=",
|
||||
"lastModified": 1722421184,
|
||||
"narHash": "sha256-/DJBI6trCeVnasdjUo9pbnodCLZcFqnVZiLUfqLH4jA=",
|
||||
"owner": "NixOS",
|
||||
"repo": "nixpkgs",
|
||||
"rev": "4c2fcb090b1f3e5b47eaa7bd33913b574a11e0a0",
|
||||
"rev": "9f918d616c5321ad374ae6cb5ea89c9e04bf3e58",
|
||||
"type": "github"
|
||||
},
|
||||
"original": {
|
||||
@ -29,11 +29,11 @@
|
||||
]
|
||||
},
|
||||
"locked": {
|
||||
"lastModified": 1729391507,
|
||||
"narHash": "sha256-as0I9xieJUHf7kiK2a9znDsVZQTFWhM1pLivII43Gi0=",
|
||||
"lastModified": 1722651535,
|
||||
"narHash": "sha256-2uRmNwxe3CO5h7PfvqXrRe8OplXaEdwhqOUtaF13rpU=",
|
||||
"owner": "oxalica",
|
||||
"repo": "rust-overlay",
|
||||
"rev": "784981a9feeba406de38c1c9a3decf966d853cca",
|
||||
"rev": "56d83ca6f3c557647476f3720426a7615c22b860",
|
||||
"type": "github"
|
||||
},
|
||||
"original": {
|
||||
|
||||
40
flake.nix
40
flake.nix
@ -8,8 +8,6 @@
|
||||
|
||||
outputs = { self, nixpkgs, rust-overlay }:
|
||||
let
|
||||
inherit (nixpkgs) lib;
|
||||
|
||||
systems = [
|
||||
"x86_64-linux"
|
||||
"aarch64-linux"
|
||||
@ -17,8 +15,7 @@
|
||||
"aarch64-darwin"
|
||||
"armv7l-linux"
|
||||
];
|
||||
|
||||
forAllSystems = f: lib.genAttrs systems (system: let
|
||||
forAllSystems = f: nixpkgs.lib.genAttrs systems (system: let
|
||||
pkgs = import nixpkgs {
|
||||
inherit system;
|
||||
overlays = [
|
||||
@ -27,23 +24,9 @@
|
||||
};
|
||||
|
||||
rust-bin = rust-overlay.lib.mkRustBin { } pkgs.buildPackages;
|
||||
toolchain = rust-bin.stable.latest.default.override {
|
||||
extensions = [ "rust-src" "rust-analyzer" "rust-std" ];
|
||||
};
|
||||
toolchain = rust-bin.stable.latest.default;
|
||||
in f system pkgs toolchain);
|
||||
in {
|
||||
apps = forAllSystems (system: pkgs: _: {
|
||||
default = self.apps.${system}.greg-ng;
|
||||
greg-ng = let
|
||||
package = self.packages.${system}.greg-ng-wrapped;
|
||||
in {
|
||||
type = "app";
|
||||
program = toString (pkgs.writeShellScript "greg-ng" ''
|
||||
${lib.getExe package} --mpv-socket-path /tmp/greg-ng-mpv.sock -vvvv
|
||||
'');
|
||||
};
|
||||
});
|
||||
|
||||
devShells = forAllSystems (system: pkgs: toolchain: {
|
||||
default = pkgs.mkShell {
|
||||
nativeBuildInputs = [
|
||||
@ -54,22 +37,5 @@
|
||||
RUST_SRC_PATH = "${toolchain}/lib/rustlib/src/rust/library";
|
||||
};
|
||||
});
|
||||
|
||||
overlays = {
|
||||
default = self.overlays.greg-ng;
|
||||
greg-ng = final: prev: {
|
||||
inherit (self.packages.${prev.system}) greg-ng;
|
||||
};
|
||||
};
|
||||
|
||||
packages = forAllSystems (system: pkgs: _: {
|
||||
default = self.packages.${system}.greg-ng;
|
||||
greg-ng = pkgs.callPackage ./default.nix { };
|
||||
greg-ng-wrapped = pkgs.callPackage ./default.nix {
|
||||
wrapped = true;
|
||||
};
|
||||
});
|
||||
} // {
|
||||
nixosModules.default = ./module.nix;
|
||||
};
|
||||
}
|
||||
}
|
||||
197
module.nix
197
module.nix
@ -1,197 +0,0 @@
|
||||
{ config, pkgs, lib, ... }:
|
||||
let
|
||||
cfg = config.services.greg-ng;
|
||||
in
|
||||
{
|
||||
options.services.greg-ng = {
|
||||
enable = lib.mkEnableOption "greg-ng, an mpv based media player";
|
||||
|
||||
package = lib.mkPackageOption pkgs "greg-ng" { };
|
||||
|
||||
mpvPackage = lib.mkPackageOption pkgs "mpv" { };
|
||||
|
||||
enableSway = lib.mkEnableOption "sway as the main window manager";
|
||||
|
||||
enablePipewire = lib.mkEnableOption "pipewire" // { default = true; };
|
||||
|
||||
logLevel = lib.mkOption {
|
||||
type = lib.types.enum [ "quiet" "error" "warn" "info" "debug" "trace" ];
|
||||
default = "debug";
|
||||
description = "Log level.";
|
||||
apply = level: {
|
||||
"quiet" = "-q";
|
||||
"error" = "";
|
||||
"warn" = "-v";
|
||||
"info" = "-vv";
|
||||
"debug" = "-vvv";
|
||||
"trace" = "-vvvv";
|
||||
}.${level};
|
||||
};
|
||||
|
||||
# TODO: create some better descriptions
|
||||
settings = {
|
||||
host = lib.mkOption {
|
||||
type = lib.types.str;
|
||||
default = "localhost";
|
||||
example = "0.0.0.0";
|
||||
description = ''
|
||||
Which host to bind to.
|
||||
'';
|
||||
};
|
||||
|
||||
port = lib.mkOption {
|
||||
type = lib.types.port;
|
||||
default = 8008;
|
||||
example = 10008;
|
||||
description = ''
|
||||
Which port to bind to.
|
||||
'';
|
||||
};
|
||||
|
||||
mpv-socket-path = lib.mkOption {
|
||||
type = lib.types.str;
|
||||
default = "%t/greg-ng-mpv.sock";
|
||||
description = ''
|
||||
Path to the mpv socket.
|
||||
'';
|
||||
};
|
||||
|
||||
mpv-executable-path = lib.mkOption {
|
||||
type = lib.types.str;
|
||||
default = lib.getExe cfg.mpvPackage;
|
||||
defaultText = lib.literalExpression ''
|
||||
lib.getExe config.services.greg-ng.mpvPackage
|
||||
'';
|
||||
description = ''
|
||||
Path to the mpv executable.
|
||||
'';
|
||||
};
|
||||
|
||||
mpv-config-file = lib.mkOption {
|
||||
type = with lib.types; nullOr str;
|
||||
default = null;
|
||||
description = ''
|
||||
Path to the mpv config file.
|
||||
'';
|
||||
};
|
||||
|
||||
auto-start-mpv = lib.mkOption {
|
||||
type = lib.types.bool;
|
||||
default = true;
|
||||
description = ''
|
||||
Whether to automatically start mpv.
|
||||
'';
|
||||
};
|
||||
|
||||
force-auto-start = lib.mkOption {
|
||||
type = lib.types.bool;
|
||||
default = true;
|
||||
description = ''
|
||||
Whether to force auto starting mpv.
|
||||
'';
|
||||
};
|
||||
};
|
||||
};
|
||||
|
||||
config = lib.mkMerge [
|
||||
(lib.mkIf cfg.enable {
|
||||
systemd.user.services.greg-ng = {
|
||||
description = "greg-ng, an mpv based media player";
|
||||
wantedBy = [ "graphical-session.target" ];
|
||||
partOf = [ "graphical-session.target" ];
|
||||
serviceConfig = {
|
||||
Type = "notify";
|
||||
ExecStart = let
|
||||
args = lib.cli.toGNUCommandLineShell { } (cfg.settings // {
|
||||
systemd = true;
|
||||
});
|
||||
in "${lib.getExe cfg.package} ${cfg.logLevel} ${args}";
|
||||
|
||||
Restart = "always";
|
||||
RestartSec = 3;
|
||||
WatchdogSec = lib.mkDefault 15;
|
||||
TimeoutStartSec = lib.mkDefault 30;
|
||||
|
||||
RestrictAddressFamilies = [ "AF_UNIX" "AF_INET" "AF_INET6" ];
|
||||
AmbientCapabilities = [ "" ];
|
||||
CapabilityBoundingSet = [ "" ];
|
||||
DeviceAllow = [ "" ];
|
||||
LockPersonality = true;
|
||||
# Might work, but wouldn't bet on it with embedded lua in mpv
|
||||
MemoryDenyWriteExecute = false;
|
||||
NoNewPrivileges = true;
|
||||
# MPV and mesa tries to talk directly to the GPU.
|
||||
PrivateDevices = false;
|
||||
PrivateMounts = true;
|
||||
PrivateTmp = true;
|
||||
PrivateUsers = true;
|
||||
ProcSubset = "pid";
|
||||
ProtectClock = true;
|
||||
ProtectControlGroups = true;
|
||||
# MPV wants ~/.cache
|
||||
ProtectHome = false;
|
||||
ProtectHostname = true;
|
||||
ProtectKernelLogs = true;
|
||||
ProtectKernelModules = true;
|
||||
ProtectKernelTunables = true;
|
||||
ProtectProc = "invisible";
|
||||
# I'll figure it out sometime
|
||||
# ProtectSystem = "full";
|
||||
RemoveIPC = true;
|
||||
UMask = "0077";
|
||||
RestrictNamespaces = true;
|
||||
RestrictRealtime = true;
|
||||
RestrictSUIDSGID = true;
|
||||
SystemCallArchitectures = "native";
|
||||
# Something brokey
|
||||
# SystemCallFilter = [
|
||||
# "@system-service"
|
||||
# "~@privileged"
|
||||
# "~@resources"
|
||||
# ];
|
||||
};
|
||||
};
|
||||
})
|
||||
(lib.mkIf (cfg.enable && cfg.enablePipewire) {
|
||||
services.pipewire = {
|
||||
enable = true;
|
||||
alsa.enable = true;
|
||||
alsa.support32Bit = true;
|
||||
pulse.enable = true;
|
||||
};
|
||||
})
|
||||
(lib.mkIf (cfg.enable && cfg.enableSway) {
|
||||
programs.sway = {
|
||||
enable = true;
|
||||
wrapperFeatures.gtk = true;
|
||||
};
|
||||
|
||||
xdg.portal = {
|
||||
enable = true;
|
||||
wlr.enable = true;
|
||||
extraPortals = [ pkgs.xdg-desktop-portal-gtk ];
|
||||
};
|
||||
|
||||
users = {
|
||||
users.greg = {
|
||||
isNormalUser = true;
|
||||
group = "greg";
|
||||
uid = 2000;
|
||||
description = "loud gym bro";
|
||||
};
|
||||
groups.greg.gid = 2000;
|
||||
};
|
||||
|
||||
services.greetd = {
|
||||
enable = true;
|
||||
settings = rec {
|
||||
initial_session = {
|
||||
command = "${pkgs.sway}/bin/sway";
|
||||
user = "greg";
|
||||
};
|
||||
default_session = initial_session;
|
||||
};
|
||||
};
|
||||
})
|
||||
];
|
||||
}
|
||||
@ -1,4 +1,4 @@
|
||||
mod base;
|
||||
mod rest_wrapper_v1;
|
||||
|
||||
pub use rest_wrapper_v1::{rest_api_routes, rest_api_docs};
|
||||
pub use rest_wrapper_v1::rest_api_routes;
|
||||
|
||||
@ -8,10 +8,6 @@ use axum::{
|
||||
use mpvipc_async::Mpv;
|
||||
use serde_json::{json, Value};
|
||||
|
||||
use utoipa::OpenApi;
|
||||
use utoipa_axum::{router::OpenApiRouter, routes};
|
||||
use utoipa_swagger_ui::SwaggerUi;
|
||||
|
||||
use super::base;
|
||||
|
||||
pub fn rest_api_routes(mpv: Mpv) -> Router {
|
||||
@ -35,69 +31,6 @@ pub fn rest_api_routes(mpv: Mpv) -> Router {
|
||||
.with_state(mpv)
|
||||
}
|
||||
|
||||
pub fn rest_api_docs(mpv: Mpv) -> Router {
|
||||
let (router, api) = OpenApiRouter::with_openapi(ApiDoc::openapi())
|
||||
.routes(routes!(loadfile))
|
||||
.routes(routes!(play_get, play_set))
|
||||
.routes(routes!(volume_get, volume_set))
|
||||
.routes(routes!(time_get, time_set))
|
||||
.routes(routes!(
|
||||
playlist_get,
|
||||
playlist_remove_or_clear
|
||||
))
|
||||
.routes(routes!(playlist_next))
|
||||
.routes(routes!(playlist_previous))
|
||||
.routes(routes!(playlist_goto))
|
||||
.routes(routes!(playlist_move))
|
||||
.routes(routes!(playlist_get_looping, playlist_set_looping))
|
||||
.routes(routes!(shuffle))
|
||||
.with_state(mpv)
|
||||
.split_for_parts();
|
||||
|
||||
router.merge(SwaggerUi::new("/docs").url("/docs/openapi.json", api))
|
||||
}
|
||||
|
||||
// NOTE: the openapi stuff is very heavily duplicated and introduces
|
||||
// a lot of maintenance overhead and boilerplate. It should theoretically
|
||||
// be possible to infer a lot of this from axum, but I haven't found a
|
||||
// good library that does this and works properly yet (I have tried some
|
||||
// but they all had issues). Feel free to replace this with a better solution.
|
||||
|
||||
#[derive(OpenApi)]
|
||||
#[openapi(
|
||||
info(
|
||||
description = "The legacy Grzegorz Brzeczyszczykiewicz API, used to control a running mpv instance",
|
||||
version = "1.0.0",
|
||||
),
|
||||
)]
|
||||
struct ApiDoc;
|
||||
|
||||
#[derive(serde::Serialize, utoipa::ToSchema)]
|
||||
struct EmptySuccessResponse {
|
||||
success: bool,
|
||||
error: bool,
|
||||
}
|
||||
|
||||
#[derive(serde::Serialize, utoipa::ToSchema)]
|
||||
struct SuccessResponse {
|
||||
#[schema(example = true)]
|
||||
success: bool,
|
||||
#[schema(example = false)]
|
||||
error: bool,
|
||||
#[schema(example = json!({ some: "arbitrary json value" }))]
|
||||
value: Value,
|
||||
}
|
||||
|
||||
#[derive(serde::Serialize, utoipa::ToSchema)]
|
||||
struct ErrorResponse {
|
||||
#[schema(example = "error....")]
|
||||
error: String,
|
||||
#[schema(example = "error....")]
|
||||
errortext: String,
|
||||
#[schema(example = false)]
|
||||
success: bool,
|
||||
}
|
||||
|
||||
pub struct RestResponse(anyhow::Result<Value>);
|
||||
|
||||
impl From<anyhow::Result<Value>> for RestResponse {
|
||||
@ -131,178 +64,73 @@ impl IntoResponse for RestResponse {
|
||||
|
||||
// TODO: These could possibly be generated with a proc macro
|
||||
|
||||
#[derive(serde::Deserialize, utoipa::IntoParams)]
|
||||
#[derive(serde::Deserialize)]
|
||||
struct LoadFileArgs {
|
||||
path: String,
|
||||
}
|
||||
|
||||
|
||||
/// Add item to playlist
|
||||
#[utoipa::path(
|
||||
post,
|
||||
path = "/load",
|
||||
params(LoadFileArgs),
|
||||
responses(
|
||||
(status = 200, description = "Success", body = EmptySuccessResponse),
|
||||
(status = 500, description = "Internal server error", body = ErrorResponse),
|
||||
)
|
||||
)]
|
||||
async fn loadfile(State(mpv): State<Mpv>, Query(query): Query<LoadFileArgs>) -> RestResponse {
|
||||
base::loadfile(mpv, &query.path).await.into()
|
||||
}
|
||||
|
||||
/// Check whether the player is paused or playing
|
||||
#[utoipa::path(
|
||||
get,
|
||||
path = "/play",
|
||||
responses(
|
||||
(status = 200, description = "Success", body = SuccessResponse),
|
||||
(status = 500, description = "Internal server error", body = ErrorResponse),
|
||||
)
|
||||
)]
|
||||
async fn play_get(State(mpv): State<Mpv>) -> RestResponse {
|
||||
base::play_get(mpv).await.into()
|
||||
}
|
||||
|
||||
#[derive(serde::Deserialize, utoipa::IntoParams)]
|
||||
#[derive(serde::Deserialize)]
|
||||
struct PlaySetArgs {
|
||||
play: String,
|
||||
}
|
||||
|
||||
/// Set whether the player is paused or playing
|
||||
#[utoipa::path(
|
||||
post,
|
||||
path = "/play",
|
||||
params(PlaySetArgs),
|
||||
responses(
|
||||
(status = 200, description = "Success", body = EmptySuccessResponse),
|
||||
(status = 500, description = "Internal server error", body = ErrorResponse),
|
||||
)
|
||||
)]
|
||||
async fn play_set(State(mpv): State<Mpv>, Query(query): Query<PlaySetArgs>) -> RestResponse {
|
||||
let play = query.play.to_lowercase() == "true";
|
||||
base::play_set(mpv, play).await.into()
|
||||
}
|
||||
|
||||
/// Get the current player volume
|
||||
#[utoipa::path(
|
||||
get,
|
||||
path = "/volume",
|
||||
responses(
|
||||
(status = 200, description = "Success", body = SuccessResponse),
|
||||
(status = 500, description = "Internal server error", body = ErrorResponse),
|
||||
)
|
||||
)]
|
||||
async fn volume_get(State(mpv): State<Mpv>) -> RestResponse {
|
||||
base::volume_get(mpv).await.into()
|
||||
}
|
||||
|
||||
#[derive(serde::Deserialize, utoipa::IntoParams)]
|
||||
#[derive(serde::Deserialize)]
|
||||
struct VolumeSetArgs {
|
||||
volume: f64,
|
||||
}
|
||||
|
||||
/// Set the player volume
|
||||
#[utoipa::path(
|
||||
post,
|
||||
path = "/volume",
|
||||
params(VolumeSetArgs),
|
||||
responses(
|
||||
(status = 200, description = "Success", body = EmptySuccessResponse),
|
||||
(status = 500, description = "Internal server error", body = ErrorResponse),
|
||||
)
|
||||
)]
|
||||
async fn volume_set(State(mpv): State<Mpv>, Query(query): Query<VolumeSetArgs>) -> RestResponse {
|
||||
base::volume_set(mpv, query.volume).await.into()
|
||||
}
|
||||
|
||||
/// Get current playback position
|
||||
#[utoipa::path(
|
||||
get,
|
||||
path = "/time",
|
||||
responses(
|
||||
(status = 200, description = "Success", body = SuccessResponse),
|
||||
(status = 500, description = "Internal server error", body = ErrorResponse),
|
||||
)
|
||||
)]
|
||||
async fn time_get(State(mpv): State<Mpv>) -> RestResponse {
|
||||
base::time_get(mpv).await.into()
|
||||
}
|
||||
|
||||
#[derive(serde::Deserialize, utoipa::IntoParams)]
|
||||
#[derive(serde::Deserialize)]
|
||||
struct TimeSetArgs {
|
||||
pos: Option<f64>,
|
||||
percent: Option<f64>,
|
||||
}
|
||||
|
||||
/// Set playback position
|
||||
#[utoipa::path(
|
||||
post,
|
||||
path = "/time",
|
||||
params(TimeSetArgs),
|
||||
responses(
|
||||
(status = 200, description = "Success", body = EmptySuccessResponse),
|
||||
(status = 500, description = "Internal server error", body = ErrorResponse),
|
||||
)
|
||||
)]
|
||||
async fn time_set(State(mpv): State<Mpv>, Query(query): Query<TimeSetArgs>) -> RestResponse {
|
||||
base::time_set(mpv, query.pos, query.percent).await.into()
|
||||
}
|
||||
|
||||
/// Get the current playlist
|
||||
#[utoipa::path(
|
||||
get,
|
||||
path = "/playlist",
|
||||
responses(
|
||||
(status = 200, description = "Success", body = SuccessResponse),
|
||||
(status = 500, description = "Internal server error", body = ErrorResponse),
|
||||
)
|
||||
)]
|
||||
async fn playlist_get(State(mpv): State<Mpv>) -> RestResponse {
|
||||
base::playlist_get(mpv).await.into()
|
||||
}
|
||||
|
||||
/// Go to the next item in the playlist
|
||||
#[utoipa::path(
|
||||
post,
|
||||
path = "/playlist/next",
|
||||
responses(
|
||||
(status = 200, description = "Success", body = EmptySuccessResponse),
|
||||
(status = 500, description = "Internal server error", body = ErrorResponse),
|
||||
)
|
||||
)]
|
||||
async fn playlist_next(State(mpv): State<Mpv>) -> RestResponse {
|
||||
base::playlist_next(mpv).await.into()
|
||||
}
|
||||
|
||||
/// Go back to the previous item in the playlist
|
||||
#[utoipa::path(
|
||||
post,
|
||||
path = "/playlist/previous",
|
||||
responses(
|
||||
(status = 200, description = "Success", body = EmptySuccessResponse),
|
||||
(status = 500, description = "Internal server error", body = ErrorResponse),
|
||||
)
|
||||
)]
|
||||
async fn playlist_previous(State(mpv): State<Mpv>) -> RestResponse {
|
||||
base::playlist_previous(mpv).await.into()
|
||||
}
|
||||
|
||||
#[derive(serde::Deserialize, utoipa::IntoParams)]
|
||||
#[derive(serde::Deserialize)]
|
||||
struct PlaylistGotoArgs {
|
||||
index: usize,
|
||||
}
|
||||
|
||||
/// Go to a specific item in the playlist
|
||||
#[utoipa::path(
|
||||
post,
|
||||
path = "/playlist/goto",
|
||||
params(PlaylistGotoArgs),
|
||||
responses(
|
||||
(status = 200, description = "Success", body = EmptySuccessResponse),
|
||||
(status = 500, description = "Internal server error", body = ErrorResponse),
|
||||
)
|
||||
)]
|
||||
async fn playlist_goto(
|
||||
State(mpv): State<Mpv>,
|
||||
Query(query): Query<PlaylistGotoArgs>,
|
||||
@ -310,21 +138,11 @@ async fn playlist_goto(
|
||||
base::playlist_goto(mpv, query.index).await.into()
|
||||
}
|
||||
|
||||
#[derive(serde::Deserialize, utoipa::IntoParams)]
|
||||
#[derive(serde::Deserialize)]
|
||||
struct PlaylistRemoveOrClearArgs {
|
||||
index: Option<usize>,
|
||||
}
|
||||
|
||||
/// Clears a single item or the entire playlist
|
||||
#[utoipa::path(
|
||||
delete,
|
||||
path = "/playlist",
|
||||
params(PlaylistRemoveOrClearArgs),
|
||||
responses(
|
||||
(status = 200, description = "Success", body = EmptySuccessResponse),
|
||||
(status = 500, description = "Internal server error", body = ErrorResponse),
|
||||
)
|
||||
)]
|
||||
async fn playlist_remove_or_clear(
|
||||
State(mpv): State<Mpv>,
|
||||
Query(query): Query<PlaylistRemoveOrClearArgs>,
|
||||
@ -335,22 +153,12 @@ async fn playlist_remove_or_clear(
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(serde::Deserialize, utoipa::IntoParams)]
|
||||
#[derive(serde::Deserialize)]
|
||||
struct PlaylistMoveArgs {
|
||||
index1: usize,
|
||||
index2: usize,
|
||||
}
|
||||
|
||||
/// Move a playlist item to a different position
|
||||
#[utoipa::path(
|
||||
post,
|
||||
path = "/playlist/move",
|
||||
params(PlaylistMoveArgs),
|
||||
responses(
|
||||
(status = 200, description = "Success", body = EmptySuccessResponse),
|
||||
(status = 500, description = "Internal server error", body = ErrorResponse),
|
||||
)
|
||||
)]
|
||||
async fn playlist_move(
|
||||
State(mpv): State<Mpv>,
|
||||
Query(query): Query<PlaylistMoveArgs>,
|
||||
@ -360,47 +168,19 @@ async fn playlist_move(
|
||||
.into()
|
||||
}
|
||||
|
||||
/// Shuffle the playlist
|
||||
#[utoipa::path(
|
||||
post,
|
||||
path = "/playlist/shuffle",
|
||||
responses(
|
||||
(status = 200, description = "Success", body = EmptySuccessResponse),
|
||||
(status = 500, description = "Internal server error", body = ErrorResponse),
|
||||
)
|
||||
)]
|
||||
async fn shuffle(State(mpv): State<Mpv>) -> RestResponse {
|
||||
base::shuffle(mpv).await.into()
|
||||
}
|
||||
|
||||
/// Check whether the playlist is looping
|
||||
#[utoipa::path(
|
||||
get,
|
||||
path = "/playlist/loop",
|
||||
responses(
|
||||
(status = 200, description = "Success", body = SuccessResponse),
|
||||
(status = 500, description = "Internal server error", body = ErrorResponse),
|
||||
)
|
||||
)]
|
||||
async fn playlist_get_looping(State(mpv): State<Mpv>) -> RestResponse {
|
||||
base::playlist_get_looping(mpv).await.into()
|
||||
}
|
||||
|
||||
#[derive(serde::Deserialize, utoipa::IntoParams)]
|
||||
#[derive(serde::Deserialize)]
|
||||
struct PlaylistSetLoopingArgs {
|
||||
r#loop: bool,
|
||||
}
|
||||
|
||||
/// Set whether the playlist should loop
|
||||
#[utoipa::path(
|
||||
post,
|
||||
path = "/playlist/loop",
|
||||
params(PlaylistSetLoopingArgs),
|
||||
responses(
|
||||
(status = 200, description = "Success", body = EmptySuccessResponse),
|
||||
(status = 500, description = "Internal server error", body = ErrorResponse),
|
||||
)
|
||||
)]
|
||||
async fn playlist_set_looping(
|
||||
State(mpv): State<Mpv>,
|
||||
Query(query): Query<PlaylistSetLoopingArgs>,
|
||||
|
||||
291
src/main.rs
291
src/main.rs
@ -1,15 +1,16 @@
|
||||
use anyhow::Context;
|
||||
use axum::Router;
|
||||
use axum::{Router, Server};
|
||||
use clap::Parser;
|
||||
use clap_verbosity_flag::Verbosity;
|
||||
use mpv_setup::{connect_to_mpv, create_mpv_config_file, show_grzegorz_image};
|
||||
use mpvipc_async::Mpv;
|
||||
use std::net::{IpAddr, SocketAddr};
|
||||
use systemd_journal_logger::JournalLog;
|
||||
use tempfile::NamedTempFile;
|
||||
use futures::StreamExt;
|
||||
use mpvipc_async::{parse_property, Mpv, MpvExt, Switch};
|
||||
use std::{
|
||||
fs::create_dir_all,
|
||||
net::{IpAddr, SocketAddr},
|
||||
path::Path,
|
||||
};
|
||||
use tokio::process::{Child, Command};
|
||||
|
||||
mod api;
|
||||
mod mpv_setup;
|
||||
|
||||
#[derive(Parser)]
|
||||
struct Args {
|
||||
@ -19,21 +20,12 @@ struct Args {
|
||||
#[clap(short, long, default_value = "8008")]
|
||||
port: u16,
|
||||
|
||||
#[command(flatten)]
|
||||
verbose: Verbosity,
|
||||
|
||||
#[clap(long)]
|
||||
systemd: bool,
|
||||
|
||||
#[clap(long, value_name = "PATH", default_value = "/run/mpv/mpv.sock")]
|
||||
mpv_socket_path: String,
|
||||
|
||||
#[clap(long, value_name = "PATH")]
|
||||
mpv_executable_path: Option<String>,
|
||||
|
||||
#[clap(long, value_name = "PATH")]
|
||||
mpv_config_file: Option<String>,
|
||||
|
||||
#[clap(long, default_value = "true")]
|
||||
auto_start_mpv: bool,
|
||||
|
||||
@ -41,16 +33,90 @@ struct Args {
|
||||
force_auto_start: bool,
|
||||
}
|
||||
|
||||
struct MpvConnectionArgs<'a> {
|
||||
struct MpvConnectionArgs {
|
||||
socket_path: String,
|
||||
executable_path: Option<String>,
|
||||
config_file: &'a NamedTempFile,
|
||||
auto_start: bool,
|
||||
force_auto_start: bool,
|
||||
}
|
||||
|
||||
/// Helper function to resolve a hostname to an IP address.
|
||||
/// Why is this not in the standard library? >:(
|
||||
async fn connect_to_mpv(args: &MpvConnectionArgs) -> anyhow::Result<(Mpv, Option<Child>)> {
|
||||
log::debug!("Connecting to mpv");
|
||||
|
||||
debug_assert!(
|
||||
!args.force_auto_start || args.auto_start,
|
||||
"force_auto_start requires auto_start"
|
||||
);
|
||||
|
||||
let socket_path = Path::new(&args.socket_path);
|
||||
|
||||
if !socket_path.exists() {
|
||||
log::debug!("Mpv socket not found at {}", &args.socket_path);
|
||||
if !args.auto_start {
|
||||
panic!("Mpv socket not found at {}", &args.socket_path);
|
||||
}
|
||||
|
||||
log::debug!("Ensuring parent dir of mpv socket exists");
|
||||
let parent_dir = Path::new(&args.socket_path)
|
||||
.parent()
|
||||
.context("Failed to get parent dir of mpv socket")?;
|
||||
|
||||
if !parent_dir.is_dir() {
|
||||
create_dir_all(parent_dir).context("Failed to create parent dir of mpv socket")?;
|
||||
}
|
||||
} else {
|
||||
log::debug!("Existing mpv socket found at {}", &args.socket_path);
|
||||
if args.force_auto_start {
|
||||
log::debug!("Removing mpv socket");
|
||||
std::fs::remove_file(&args.socket_path)?;
|
||||
}
|
||||
}
|
||||
|
||||
let process_handle = if args.auto_start {
|
||||
log::info!("Starting mpv with socket at {}", &args.socket_path);
|
||||
|
||||
// TODO: try to fetch mpv from PATH
|
||||
Some(
|
||||
Command::new(args.executable_path.as_deref().unwrap_or("mpv"))
|
||||
.arg(format!("--input-ipc-server={}", &args.socket_path))
|
||||
.arg("--idle")
|
||||
.arg("--force-window")
|
||||
.arg("--fullscreen")
|
||||
// .arg("--no-terminal")
|
||||
.arg("--load-unsafe-playlists")
|
||||
.arg("--keep-open") // Keep last frame of video on end of video
|
||||
.spawn()
|
||||
.context("Failed to start mpv")?,
|
||||
)
|
||||
} else {
|
||||
None
|
||||
};
|
||||
|
||||
// Wait for mpv to create the socket
|
||||
if tokio::time::timeout(tokio::time::Duration::from_millis(500), async {
|
||||
while !&socket_path.exists() {
|
||||
log::debug!("Waiting for mpv socket at {}", &args.socket_path);
|
||||
tokio::time::sleep(tokio::time::Duration::from_millis(10)).await;
|
||||
}
|
||||
})
|
||||
.await
|
||||
.is_err()
|
||||
{
|
||||
return Err(anyhow::anyhow!(
|
||||
"Failed to connect to mpv socket: {}",
|
||||
&args.socket_path
|
||||
));
|
||||
}
|
||||
|
||||
Ok((
|
||||
Mpv::connect(&args.socket_path).await.context(format!(
|
||||
"Failed to connect to mpv socket: {}",
|
||||
&args.socket_path
|
||||
))?,
|
||||
process_handle,
|
||||
))
|
||||
}
|
||||
|
||||
async fn resolve(host: &str) -> anyhow::Result<IpAddr> {
|
||||
let addr = format!("{}:0", host);
|
||||
let addresses = tokio::net::lookup_host(addr).await?;
|
||||
@ -61,147 +127,81 @@ async fn resolve(host: &str) -> anyhow::Result<IpAddr> {
|
||||
.ok_or_else(|| anyhow::anyhow!("Failed to resolve address"))
|
||||
}
|
||||
|
||||
/// Helper function that spawns a tokio thread that
|
||||
/// continuously sends a ping to systemd watchdog, if enabled.
|
||||
async fn setup_systemd_watchdog_thread() -> anyhow::Result<()> {
|
||||
let mut watchdog_microsecs: u64 = 0;
|
||||
if sd_notify::watchdog_enabled(true, &mut watchdog_microsecs) {
|
||||
watchdog_microsecs = watchdog_microsecs.div_ceil(2);
|
||||
tokio::spawn(async move {
|
||||
log::debug!(
|
||||
"Starting systemd watchdog thread with {} millisecond interval",
|
||||
watchdog_microsecs.div_ceil(1000)
|
||||
);
|
||||
loop {
|
||||
tokio::time::sleep(tokio::time::Duration::from_micros(watchdog_microsecs)).await;
|
||||
if let Err(err) = sd_notify::notify(false, &[sd_notify::NotifyState::Watchdog]) {
|
||||
log::warn!("Failed to notify systemd watchdog: {}", err);
|
||||
} else {
|
||||
log::trace!("Ping sent to systemd watchdog");
|
||||
}
|
||||
}
|
||||
});
|
||||
} else {
|
||||
log::info!("Watchdog not enabled, skipping");
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
async fn shutdown(mpv: Mpv, proc: Option<tokio::process::Child>) {
|
||||
log::info!("Shutting down");
|
||||
sd_notify::notify(false, &[sd_notify::NotifyState::Stopping]).unwrap_or_else(|e| {
|
||||
log::warn!(
|
||||
"Failed to notify systemd that the service is stopping: {}",
|
||||
e
|
||||
)
|
||||
});
|
||||
|
||||
mpv.disconnect()
|
||||
.await
|
||||
.unwrap_or_else(|e| log::warn!("Failed to disconnect from mpv: {}", e));
|
||||
if let Some(mut proc) = proc {
|
||||
proc.kill()
|
||||
.await
|
||||
.unwrap_or_else(|e| log::warn!("Failed to kill mpv process: {}", e));
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::main]
|
||||
async fn main() -> anyhow::Result<()> {
|
||||
env_logger::init();
|
||||
let args = Args::parse();
|
||||
|
||||
let systemd_mode = args.systemd && sd_notify::booted().unwrap_or(false);
|
||||
if systemd_mode {
|
||||
JournalLog::new()
|
||||
.context("Failed to initialize journald logging")?
|
||||
.install()
|
||||
.context("Failed to install journald logger")?;
|
||||
|
||||
log::set_max_level(args.verbose.log_level_filter());
|
||||
|
||||
log::debug!("Running with systemd integration");
|
||||
|
||||
setup_systemd_watchdog_thread().await?;
|
||||
} else {
|
||||
env_logger::Builder::new()
|
||||
.filter_level(args.verbose.log_level_filter())
|
||||
.init();
|
||||
|
||||
log::info!("Running without systemd integration");
|
||||
}
|
||||
|
||||
let mpv_config_file = create_mpv_config_file(args.mpv_config_file)?;
|
||||
|
||||
let (mpv, proc) = connect_to_mpv(&MpvConnectionArgs {
|
||||
socket_path: args.mpv_socket_path,
|
||||
executable_path: args.mpv_executable_path,
|
||||
config_file: &mpv_config_file,
|
||||
auto_start: args.auto_start_mpv,
|
||||
force_auto_start: args.force_auto_start,
|
||||
})
|
||||
.await
|
||||
.context("Failed to connect to mpv")?;
|
||||
.await?;
|
||||
|
||||
if let Err(e) = show_grzegorz_image(mpv.clone()).await {
|
||||
log::warn!("Could not show Grzegorz image: {}", e);
|
||||
}
|
||||
let addr = SocketAddr::new(resolve(&args.host).await?, args.port);
|
||||
log::info!("Starting API on {}", addr);
|
||||
|
||||
let addr = match resolve(&args.host)
|
||||
.await
|
||||
.context(format!("Failed to resolve address: {}", &args.host))
|
||||
{
|
||||
Ok(addr) => addr,
|
||||
Err(e) => {
|
||||
log::error!("{}", e);
|
||||
shutdown(mpv, proc).await;
|
||||
return Err(e);
|
||||
}
|
||||
};
|
||||
let socket_addr = SocketAddr::new(addr, args.port);
|
||||
log::info!("Starting API on {}", socket_addr);
|
||||
|
||||
let app = Router::new()
|
||||
.nest("/api", api::rest_api_routes(mpv.clone()))
|
||||
.merge(api::rest_api_docs(mpv.clone()));
|
||||
|
||||
let listener = match tokio::net::TcpListener::bind(&socket_addr)
|
||||
.await
|
||||
.context(format!("Failed to bind API server to '{}'", &socket_addr))
|
||||
{
|
||||
Ok(listener) => listener,
|
||||
Err(e) => {
|
||||
log::error!("{}", e);
|
||||
shutdown(mpv, proc).await;
|
||||
return Err(e);
|
||||
}
|
||||
};
|
||||
|
||||
if systemd_mode {
|
||||
match sd_notify::notify(false, &[sd_notify::NotifyState::Ready])
|
||||
.context("Failed to notify systemd that the service is ready")
|
||||
{
|
||||
Ok(_) => log::trace!("Notified systemd that the service is ready"),
|
||||
Err(e) => {
|
||||
log::error!("{}", e);
|
||||
shutdown(mpv, proc).await;
|
||||
return Err(e);
|
||||
}
|
||||
}
|
||||
}
|
||||
let app = Router::new().nest("/api", api::rest_api_routes(mpv.clone()));
|
||||
|
||||
if let Some(mut proc) = proc {
|
||||
tokio::select! {
|
||||
exit_status = proc.wait() => {
|
||||
log::warn!("mpv process exited with status: {}", exit_status?);
|
||||
shutdown(mpv, Some(proc)).await;
|
||||
mpv.disconnect().await?;
|
||||
}
|
||||
_ = tokio::signal::ctrl_c() => {
|
||||
log::info!("Received Ctrl-C, exiting");
|
||||
shutdown(mpv, Some(proc)).await;
|
||||
mpv.disconnect().await?;
|
||||
proc.kill().await?;
|
||||
}
|
||||
result = axum::serve(listener, app.into_make_service()) => {
|
||||
/* DEBUG */
|
||||
_ = async {
|
||||
let mut event_stream = mpv.get_event_stream().await;
|
||||
mpv.set_playback(Switch::Off).await.unwrap();
|
||||
mpv.observe_property(1, "volume").await.unwrap();
|
||||
mpv.observe_property(2, "pause").await.unwrap();
|
||||
mpv.observe_property(3, "time-pos").await.unwrap();
|
||||
mpv.observe_property(4, "duration").await.unwrap();
|
||||
mpv.observe_property(5, "playlist").await.unwrap();
|
||||
mpv.observe_property(6, "playlist-pos").await.unwrap();
|
||||
mpv.observe_property(7, "tick").await.unwrap();
|
||||
mpv.observe_property(8, "eof-reached").await.unwrap();
|
||||
mpv.observe_property(9, "speed").await.unwrap();
|
||||
mpv.observe_property(10, "filename").await.unwrap();
|
||||
mpv.observe_property(11, "media-title").await.unwrap();
|
||||
mpv.observe_property(12, "loop-file").await.unwrap();
|
||||
mpv.observe_property(13, "loop-playlist").await.unwrap();
|
||||
mpv.observe_property(14, "mute").await.unwrap();
|
||||
|
||||
loop {
|
||||
let event = event_stream.next().await;
|
||||
if let Some(Ok(event)) = event {
|
||||
match &event {
|
||||
mpvipc_async::Event::PropertyChange { name, data, id } => {
|
||||
let parsed_event_property = parse_property(name, data.clone());
|
||||
log::info!("PropertyChange({}): {:#?}", id, parsed_event_property);
|
||||
}
|
||||
event => {
|
||||
log::info!("Event: {:?}", event);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
} => {
|
||||
|
||||
}
|
||||
/* END_DEBUG */
|
||||
result = async {
|
||||
match Server::try_bind(&addr.clone()).context("Failed to bind server") {
|
||||
Ok(server) => server.serve(app.into_make_service()).await.context("Failed to serve app"),
|
||||
Err(err) => Err(err),
|
||||
}
|
||||
} => {
|
||||
log::info!("API server exited");
|
||||
shutdown(mpv, Some(proc)).await;
|
||||
mpv.disconnect().await?;
|
||||
proc.kill().await?;
|
||||
result?;
|
||||
}
|
||||
}
|
||||
@ -209,17 +209,14 @@ async fn main() -> anyhow::Result<()> {
|
||||
tokio::select! {
|
||||
_ = tokio::signal::ctrl_c() => {
|
||||
log::info!("Received Ctrl-C, exiting");
|
||||
shutdown(mpv.clone(), None).await;
|
||||
mpv.disconnect().await?;
|
||||
}
|
||||
result = axum::serve(listener, app.into_make_service()) => {
|
||||
log::info!("API server exited");
|
||||
shutdown(mpv.clone(), None).await;
|
||||
result?;
|
||||
_ = Server::bind(&addr.clone()).serve(app.into_make_service()) => {
|
||||
log::info!("API server exited");
|
||||
mpv.disconnect().await?;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
std::mem::drop(mpv_config_file);
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
144
src/mpv_setup.rs
144
src/mpv_setup.rs
@ -1,144 +0,0 @@
|
||||
use std::{fs::create_dir_all, io::Write, path::Path};
|
||||
|
||||
use anyhow::Context;
|
||||
use mpvipc_async::{Mpv, MpvExt};
|
||||
use tempfile::NamedTempFile;
|
||||
use tokio::process::{Child, Command};
|
||||
|
||||
use crate::MpvConnectionArgs;
|
||||
|
||||
const DEFAULT_MPV_CONFIG_CONTENT: &str = include_str!("../assets/default-mpv.conf");
|
||||
|
||||
const THE_MAN_PNG: &[u8] = include_bytes!("../assets/the_man.png");
|
||||
|
||||
// https://mpv.io/manual/master/#options-ytdl
|
||||
const YTDL_HOOK_ARGS: [&str; 2] = ["try_ytdl_first=yes", "thumbnails=none"];
|
||||
|
||||
pub fn create_mpv_config_file(args_config_file: Option<String>) -> anyhow::Result<NamedTempFile> {
|
||||
let file_content = if let Some(path) = args_config_file {
|
||||
if !Path::new(&path).exists() {
|
||||
anyhow::bail!("Mpv config file not found at {}", &path);
|
||||
}
|
||||
|
||||
std::fs::read_to_string(&path).context("Failed to read mpv config file")?
|
||||
} else {
|
||||
DEFAULT_MPV_CONFIG_CONTENT.to_string()
|
||||
};
|
||||
|
||||
let tmpfile = tempfile::Builder::new()
|
||||
.prefix("mpv-")
|
||||
.rand_bytes(8)
|
||||
.suffix(".conf")
|
||||
.tempfile()?;
|
||||
|
||||
tmpfile.reopen()?.write_all(file_content.as_bytes())?;
|
||||
|
||||
Ok(tmpfile)
|
||||
}
|
||||
|
||||
pub async fn connect_to_mpv<'a>(
|
||||
args: &MpvConnectionArgs<'a>,
|
||||
) -> anyhow::Result<(Mpv, Option<Child>)> {
|
||||
log::debug!("Connecting to mpv");
|
||||
|
||||
debug_assert!(
|
||||
!args.force_auto_start || args.auto_start,
|
||||
"force_auto_start requires auto_start"
|
||||
);
|
||||
|
||||
let socket_path = Path::new(&args.socket_path);
|
||||
|
||||
if !socket_path.exists() {
|
||||
log::debug!("Mpv socket not found at {}", &args.socket_path);
|
||||
if !args.auto_start {
|
||||
panic!("Mpv socket not found at {}", &args.socket_path);
|
||||
}
|
||||
|
||||
log::debug!("Ensuring parent dir of mpv socket exists");
|
||||
let parent_dir = Path::new(&args.socket_path)
|
||||
.parent()
|
||||
.context("Failed to get parent dir of mpv socket")?;
|
||||
|
||||
if !parent_dir.is_dir() {
|
||||
create_dir_all(parent_dir).context("Failed to create parent dir of mpv socket")?;
|
||||
}
|
||||
} else {
|
||||
log::debug!("Existing mpv socket found at {}", &args.socket_path);
|
||||
if args.force_auto_start {
|
||||
log::debug!("Removing mpv socket");
|
||||
std::fs::remove_file(&args.socket_path)?;
|
||||
}
|
||||
}
|
||||
|
||||
let process_handle = if args.auto_start {
|
||||
log::info!("Starting mpv with socket at {}", &args.socket_path);
|
||||
|
||||
// TODO: try to fetch mpv from PATH
|
||||
Some(
|
||||
Command::new(args.executable_path.as_deref().unwrap_or("mpv"))
|
||||
.arg(format!("--input-ipc-server={}", &args.socket_path))
|
||||
.arg("--idle")
|
||||
.arg("--force-window")
|
||||
.arg("--fullscreen")
|
||||
.arg("--no-config")
|
||||
.arg("--ytdl=yes")
|
||||
.args(
|
||||
YTDL_HOOK_ARGS
|
||||
.into_iter()
|
||||
.map(|x| format!("--script-opts=ytdl_hook-{}", x))
|
||||
.collect::<Vec<_>>(),
|
||||
)
|
||||
.arg(format!(
|
||||
"--include={}",
|
||||
&args.config_file.path().to_string_lossy()
|
||||
))
|
||||
// .arg("--no-terminal")
|
||||
.arg("--load-unsafe-playlists")
|
||||
.arg("--keep-open") // Keep last frame of video on end of video
|
||||
.spawn()
|
||||
.context("Failed to start mpv")?,
|
||||
)
|
||||
} else {
|
||||
None
|
||||
};
|
||||
|
||||
// Wait for mpv to create the socket
|
||||
if tokio::time::timeout(tokio::time::Duration::from_millis(500), async {
|
||||
while !&socket_path.exists() {
|
||||
log::debug!("Waiting for mpv socket at {}", &args.socket_path);
|
||||
tokio::time::sleep(tokio::time::Duration::from_millis(10)).await;
|
||||
}
|
||||
})
|
||||
.await
|
||||
.is_err()
|
||||
{
|
||||
return Err(anyhow::anyhow!(
|
||||
"Failed to connect to mpv socket: {}",
|
||||
&args.socket_path
|
||||
));
|
||||
}
|
||||
|
||||
Ok((
|
||||
Mpv::connect(&args.socket_path).await.context(format!(
|
||||
"Failed to connect to mpv socket: {}",
|
||||
&args.socket_path
|
||||
))?,
|
||||
process_handle,
|
||||
))
|
||||
}
|
||||
|
||||
pub async fn show_grzegorz_image(mpv: Mpv) -> anyhow::Result<()> {
|
||||
let path = std::env::temp_dir().join("the_man.png");
|
||||
std::fs::write(path.as_path(), THE_MAN_PNG)?;
|
||||
|
||||
mpv.playlist_clear().await?;
|
||||
mpv.playlist_add(
|
||||
path.to_string_lossy().as_ref(),
|
||||
mpvipc_async::PlaylistAddTypeOptions::File,
|
||||
mpvipc_async::PlaylistAddOptions::Append,
|
||||
)
|
||||
.await?;
|
||||
mpv.next().await?;
|
||||
|
||||
Ok(())
|
||||
}
|
||||
Loading…
Reference in New Issue
Block a user