Merge pull request #195 from luigi311/fix_user

Fix user

Dockerfile.alpine

@@ -2,9 +2,9 @@ FROM python:3.11-alpine
 
 ENV PUID=1000
 ENV PGID=1000
-ENV GOSU_VERSION 1.17
+ENV GOSU_VERSION=1.17
 
-RUN apk add --no-cache tini
+RUN apk add --no-cache tini dos2unix
 
 # Install gosu
 RUN set -eux; \
@@ -42,7 +42,8 @@ RUN pip install --no-cache-dir -r requirements.txt
 
 COPY . .
 
-RUN chmod +x *.sh
+RUN chmod +x *.sh && \
+	dos2unix *.sh
 
 ENTRYPOINT ["tini", "--", "/app/entrypoint.sh"]
 CMD ["python", "-u", "main.py"]

Dockerfile.slim

@@ -4,7 +4,7 @@ ENV PUID=1000
 ENV PGID=1000
 
 RUN apt-get update && \
-    apt-get install tini gosu --yes --no-install-recommends && \
+    apt-get install tini gosu dos2unix --yes --no-install-recommends && \
     apt-get clean && \
     rm -rf /var/lib/apt/lists/*
 
@@ -16,7 +16,8 @@ RUN pip install --no-cache-dir -r requirements.txt
 
 COPY . .
 
-RUN chmod +x *.sh
+RUN chmod +x *.sh && \
+    dos2unix *.sh
 
 ENTRYPOINT ["/bin/tini", "--", "/app/entrypoint.sh"]
 CMD ["python", "-u", "main.py"]

entrypoint.sh

@@ -2,29 +2,39 @@
 
 set -e
 
+# Check if user is root
+if [ "$(id -u)" = '0' ]; then
+    echo "User is root, checking if we need to create a user and group based on environment variables"
     # Create group and user based on environment variables
     if [ ! "$(getent group "$PGID")" ]; then
         # If groupadd exists, use it
         if command -v groupadd > /dev/null; then
-        groupadd -g "$PGID" jellyplex_group
-    else
-        addgroup -g "$PGID" jellyplex_group
+            groupadd -g "$PGID" jellyplex_watched
+        elif command -v addgroup > /dev/null; then
+            addgroup -g "$PGID" jellyplex_watched
         fi
     fi
 
+    # If user id does not exist, create the user
     if [ ! "$(getent passwd "$PUID")" ]; then
-    # If useradd exists, use it
         if command -v useradd > /dev/null; then
-        useradd --no-create-home -u "$PUID" -g "$PGID" jellyplex_user
+            useradd --no-create-home -u "$PUID" -g "$PGID" jellyplex_watched
+        elif command -v adduser > /dev/null; then
+            # Get the group name based on the PGID since adduser does not have a flag to specify the group id
+            # and if the group id already exists the group name will be sommething unexpected
+            GROUPNAME=$(getent group "$PGID" | cut -d: -f1)
+            
+            # Use alpine busybox adduser syntax
+            adduser -D -H -u "$PUID" -G "$GROUPNAME" jellyplex_watched
+        fi
+    fi
 else 
-        adduser -D -H -u "$PUID" -G jellyplex_group jellyplex_user
-    fi
+    # If user is not root, set the PUID and PGID to the current user
+    PUID=$(id -u)
+    PGID=$(id -g)
 fi
 
-# Adjust ownership of the application directory
-chown -R "$PUID:$PGID" /app
-
-# Get directory of log and mark file to create base folder if it doesnt exist and change permissions
+# Get directory of log and mark file to create base folder if it doesnt exist
 LOG_DIR=$(dirname "$LOG_FILE")
 # If LOG_DIR is set, create the directory
 if [ -n "$LOG_DIR" ]; then
@@ -36,8 +46,16 @@ if [ -n "$MARK_DIR" ]; then
     mkdir -p "$MARK_DIR"  
 fi
 
+echo "Starting JellyPlex-Watched with UID: $PUID and GID: $PGID"
+
+# If root run as the created user
+if [ "$(id -u)" = '0' ]; then
     chown -R "$PUID:$PGID" "$LOG_DIR"
     chown -R "$PUID:$PGID" "$MARK_DIR"
 
     # Run the application as the created user
     exec gosu "$PUID:$PGID" "$@"
+fi
+
+# Run the application as the current user
+exec "$@"

src/connection.py

@@ -0,0 +1,139 @@
+import os
+from dotenv import load_dotenv
+
+from src.functions import logger, str_to_bool
+from src.plex import Plex
+from src.jellyfin import Jellyfin
+from src.emby import Emby
+
+load_dotenv(override=True)
+
+
+def jellyfin_emby_server_connection(server_baseurl, server_token, server_type):
+    servers = []
+
+    server_baseurl = server_baseurl.split(",")
+    server_token = server_token.split(",")
+
+    if len(server_baseurl) != len(server_token):
+        raise Exception(
+            f"{server_type.upper()}_BASEURL and {server_type.upper()}_TOKEN must have the same number of entries"
+        )
+
+    for i, baseurl in enumerate(server_baseurl):
+        baseurl = baseurl.strip()
+        if baseurl[-1] == "/":
+            baseurl = baseurl[:-1]
+
+        if server_type == "jellyfin":
+            server = Jellyfin(baseurl=baseurl, token=server_token[i].strip())
+            servers.append(
+                (
+                    "jellyfin",
+                    server,
+                )
+            )
+
+        elif server_type == "emby":
+            server = Emby(baseurl=baseurl, token=server_token[i].strip())
+            servers.append(
+                (
+                    "emby",
+                    server,
+                )
+            )
+        else:
+            raise Exception("Unknown server type")
+
+        logger(f"{server_type} Server {i} info: {server.info()}", 3)
+
+    return servers
+
+
+def generate_server_connections():
+    servers = []
+
+    plex_baseurl = os.getenv("PLEX_BASEURL", None)
+    plex_token = os.getenv("PLEX_TOKEN", None)
+    plex_username = os.getenv("PLEX_USERNAME", None)
+    plex_password = os.getenv("PLEX_PASSWORD", None)
+    plex_servername = os.getenv("PLEX_SERVERNAME", None)
+    ssl_bypass = str_to_bool(os.getenv("SSL_BYPASS", "False"))
+
+    if plex_baseurl and plex_token:
+        plex_baseurl = plex_baseurl.split(",")
+        plex_token = plex_token.split(",")
+
+        if len(plex_baseurl) != len(plex_token):
+            raise Exception(
+                "PLEX_BASEURL and PLEX_TOKEN must have the same number of entries"
+            )
+
+        for i, url in enumerate(plex_baseurl):
+            server = Plex(
+                baseurl=url.strip(),
+                token=plex_token[i].strip(),
+                username=None,
+                password=None,
+                servername=None,
+                ssl_bypass=ssl_bypass,
+            )
+
+            logger(f"Plex Server {i} info: {server.info()}", 3)
+
+            servers.append(
+                (
+                    "plex",
+                    server,
+                )
+            )
+
+    if plex_username and plex_password and plex_servername:
+        plex_username = plex_username.split(",")
+        plex_password = plex_password.split(",")
+        plex_servername = plex_servername.split(",")
+
+        if len(plex_username) != len(plex_password) or len(plex_username) != len(
+            plex_servername
+        ):
+            raise Exception(
+                "PLEX_USERNAME, PLEX_PASSWORD and PLEX_SERVERNAME must have the same number of entries"
+            )
+
+        for i, username in enumerate(plex_username):
+            server = Plex(
+                baseurl=None,
+                token=None,
+                username=username.strip(),
+                password=plex_password[i].strip(),
+                servername=plex_servername[i].strip(),
+                ssl_bypass=ssl_bypass,
+            )
+
+            logger(f"Plex Server {i} info: {server.info()}", 3)
+            servers.append(
+                (
+                    "plex",
+                    server,
+                )
+            )
+
+    jellyfin_baseurl = os.getenv("JELLYFIN_BASEURL", None)
+    jellyfin_token = os.getenv("JELLYFIN_TOKEN", None)
+
+    if jellyfin_baseurl and jellyfin_token:
+        servers.extend(
+            jellyfin_emby_server_connection(
+                jellyfin_baseurl, jellyfin_token, "jellyfin"
+            )
+        )
+
+    emby_baseurl = os.getenv("EMBY_BASEURL", None)
+    emby_token = os.getenv("EMBY_TOKEN", None)
+
+    if emby_baseurl and emby_token:
+        servers.extend(
+            jellyfin_emby_server_connection(emby_baseurl, emby_token, "emby")
+        )
+
+    return servers

src/main.py

@@ -6,196 +6,16 @@ from src.functions import (
     logger,
     str_to_bool,
 )
-from src.users import (
-    generate_user_list,
-    combine_user_lists,
-    filter_user_lists,
-    generate_server_users,
-)
+from src.users import setup_users
 from src.watched import (
     cleanup_watched,
 )
 from src.black_white import setup_black_white_lists
-
-from src.plex import Plex
-from src.jellyfin import Jellyfin
-from src.emby import Emby
+from src.connection import generate_server_connections
 
 load_dotenv(override=True)
 
 
-def setup_users(
-    server_1, server_2, blacklist_users, whitelist_users, user_mapping=None
-):
-    server_1_users = generate_user_list(server_1)
-    server_2_users = generate_user_list(server_2)
-    logger(f"Server 1 users: {server_1_users}", 1)
-    logger(f"Server 2 users: {server_2_users}", 1)
-
-    users = combine_user_lists(server_1_users, server_2_users, user_mapping)
-    logger(f"User list that exist on both servers {users}", 1)
-
-    users_filtered = filter_user_lists(users, blacklist_users, whitelist_users)
-    logger(f"Filtered user list {users_filtered}", 1)
-
-    output_server_1_users = generate_server_users(server_1, users_filtered)
-    output_server_2_users = generate_server_users(server_2, users_filtered)
-
-    # Check if users is none or empty
-    if output_server_1_users is None or len(output_server_1_users) == 0:
-        logger(
-            f"No users found for server 1 {server_1[0]}, users: {server_1_users}, overlapping users {users}, filtered users {users_filtered}, server 1 users {server_1[1].users}"
-        )
-
-    if output_server_2_users is None or len(output_server_2_users) == 0:
-        logger(
-            f"No users found for server 2 {server_2[0]}, users: {server_2_users}, overlapping users {users} filtered users {users_filtered}, server 2 users {server_2[1].users}"
-        )
-
-    if (
-        output_server_1_users is None
-        or len(output_server_1_users) == 0
-        or output_server_2_users is None
-        or len(output_server_2_users) == 0
-    ):
-        raise Exception("No users found for one or both servers")
-
-    logger(f"Server 1 users: {output_server_1_users}", 1)
-    logger(f"Server 2 users: {output_server_2_users}", 1)
-
-    return output_server_1_users, output_server_2_users
-
-
-def jellyfin_emby_server_connection(server_baseurl, server_token, server_type):
-    servers = []
-
-    server_baseurl = server_baseurl.split(",")
-    server_token = server_token.split(",")
-
-    if len(server_baseurl) != len(server_token):
-        raise Exception(
-            f"{server_type.upper()}_BASEURL and {server_type.upper()}_TOKEN must have the same number of entries"
-        )
-
-    for i, baseurl in enumerate(server_baseurl):
-        baseurl = baseurl.strip()
-        if baseurl[-1] == "/":
-            baseurl = baseurl[:-1]
-
-        if server_type == "jellyfin":
-            server = Jellyfin(baseurl=baseurl, token=server_token[i].strip())
-            servers.append(
-                (
-                    "jellyfin",
-                    server,
-                )
-            )
-
-        elif server_type == "emby":
-            server = Emby(baseurl=baseurl, token=server_token[i].strip())
-            servers.append(
-                (
-                    "emby",
-                    server,
-                )
-            )
-        else:
-            raise Exception("Unknown server type")
-
-        logger(f"{server_type} Server {i} info: {server.info()}", 3)
-
-    return servers
-
-
-def generate_server_connections():
-    servers = []
-
-    plex_baseurl = os.getenv("PLEX_BASEURL", None)
-    plex_token = os.getenv("PLEX_TOKEN", None)
-    plex_username = os.getenv("PLEX_USERNAME", None)
-    plex_password = os.getenv("PLEX_PASSWORD", None)
-    plex_servername = os.getenv("PLEX_SERVERNAME", None)
-    ssl_bypass = str_to_bool(os.getenv("SSL_BYPASS", "False"))
-
-    if plex_baseurl and plex_token:
-        plex_baseurl = plex_baseurl.split(",")
-        plex_token = plex_token.split(",")
-
-        if len(plex_baseurl) != len(plex_token):
-            raise Exception(
-                "PLEX_BASEURL and PLEX_TOKEN must have the same number of entries"
-            )
-
-        for i, url in enumerate(plex_baseurl):
-            server = Plex(
-                baseurl=url.strip(),
-                token=plex_token[i].strip(),
-                username=None,
-                password=None,
-                servername=None,
-                ssl_bypass=ssl_bypass,
-            )
-
-            logger(f"Plex Server {i} info: {server.info()}", 3)
-
-            servers.append(
-                (
-                    "plex",
-                    server,
-                )
-            )
-
-    if plex_username and plex_password and plex_servername:
-        plex_username = plex_username.split(",")
-        plex_password = plex_password.split(",")
-        plex_servername = plex_servername.split(",")
-
-        if len(plex_username) != len(plex_password) or len(plex_username) != len(
-            plex_servername
-        ):
-            raise Exception(
-                "PLEX_USERNAME, PLEX_PASSWORD and PLEX_SERVERNAME must have the same number of entries"
-            )
-
-        for i, username in enumerate(plex_username):
-            server = Plex(
-                baseurl=None,
-                token=None,
-                username=username.strip(),
-                password=plex_password[i].strip(),
-                servername=plex_servername[i].strip(),
-                ssl_bypass=ssl_bypass,
-            )
-
-            logger(f"Plex Server {i} info: {server.info()}", 3)
-            servers.append(
-                (
-                    "plex",
-                    server,
-                )
-            )
-
-    jellyfin_baseurl = os.getenv("JELLYFIN_BASEURL", None)
-    jellyfin_token = os.getenv("JELLYFIN_TOKEN", None)
-
-    if jellyfin_baseurl and jellyfin_token:
-        servers.extend(
-            jellyfin_emby_server_connection(
-                jellyfin_baseurl, jellyfin_token, "jellyfin"
-            )
-        )
-
-    emby_baseurl = os.getenv("EMBY_BASEURL", None)
-    emby_token = os.getenv("EMBY_TOKEN", None)
-
-    if emby_baseurl and emby_token:
-        servers.extend(
-            jellyfin_emby_server_connection(emby_baseurl, emby_token, "emby")
-        )
-
-    return servers
-
-
 def should_sync_server(server_1_type, server_2_type):
     sync_from_plex_to_jellyfin = str_to_bool(
         os.getenv("SYNC_FROM_PLEX_TO_JELLYFIN", "True")

src/users.py

@@ -89,3 +89,45 @@ def generate_server_users(server, users):
                 server_users[jellyfin_user] = jellyfin_id
 
     return server_users
+
+
+def setup_users(
+    server_1, server_2, blacklist_users, whitelist_users, user_mapping=None
+):
+    server_1_users = generate_user_list(server_1)
+    server_2_users = generate_user_list(server_2)
+    logger(f"Server 1 users: {server_1_users}", 1)
+    logger(f"Server 2 users: {server_2_users}", 1)
+
+    users = combine_user_lists(server_1_users, server_2_users, user_mapping)
+    logger(f"User list that exist on both servers {users}", 1)
+
+    users_filtered = filter_user_lists(users, blacklist_users, whitelist_users)
+    logger(f"Filtered user list {users_filtered}", 1)
+
+    output_server_1_users = generate_server_users(server_1, users_filtered)
+    output_server_2_users = generate_server_users(server_2, users_filtered)
+
+    # Check if users is none or empty
+    if output_server_1_users is None or len(output_server_1_users) == 0:
+        logger(
+            f"No users found for server 1 {server_1[0]}, users: {server_1_users}, overlapping users {users}, filtered users {users_filtered}, server 1 users {server_1[1].users}"
+        )
+
+    if output_server_2_users is None or len(output_server_2_users) == 0:
+        logger(
+            f"No users found for server 2 {server_2[0]}, users: {server_2_users}, overlapping users {users} filtered users {users_filtered}, server 2 users {server_2[1].users}"
+        )
+
+    if (
+        output_server_1_users is None
+        or len(output_server_1_users) == 0
+        or output_server_2_users is None
+        or len(output_server_2_users) == 0
+    ):
+        raise Exception("No users found for one or both servers")
+
+    logger(f"Server 1 users: {output_server_1_users}", 1)
+    logger(f"Server 2 users: {output_server_2_users}", 1)
+
+    return output_server_1_users, output_server_2_users