11 |
14 | );
15 | }
16 |
--------------------------------------------------------------------------------
/src/types/scheduleTypes.ts:
--------------------------------------------------------------------------------
1 | export type Schedule = {
2 | id: number;
3 | name: string;
4 | repository: string;
5 | cron: string;
6 | paused: boolean;
7 | username: string;
8 | keepLast: number;
9 | };
10 |
11 | export type ScheduleHistory = {
12 | id: number;
13 | backupJobId: number;
14 | backupJob?: {
15 | name: string;
16 | };
17 | timestamp: string;
18 | success: boolean;
19 | message: string | null;
20 | };
21 |
22 | export type ScheduleWithHistory = Schedule & {
23 | backupHistory: ScheduleHistory[];
24 | };
25 |
--------------------------------------------------------------------------------
/src/components/Pagination/PageElement.tsx:
--------------------------------------------------------------------------------
1 | import React from "react";
2 |
3 | type Props = {
4 | current: boolean;
5 | children: React.ReactNode;
6 | };
7 |
8 | export default function PageElement(props: Props) {
9 | return (
10 |
14 | {props.children}
15 |
16 | );
17 | }
18 |
--------------------------------------------------------------------------------
/backend/models/schedule.model.ts:
--------------------------------------------------------------------------------
1 | import { z } from "zod";
2 |
3 | export const postScheduleRequest = z.object({
4 | name: z.string(),
5 | repository: z.string(),
6 | every: z.number(),
7 | timespan: z.enum(["minutes", "hours", "days"]),
8 | private: z.string().nullable(),
9 | accessTokenId: z.string().nullable(),
10 | keepLast: z.number(),
11 | });
12 |
13 | export const putScheduleRequest = z.object({
14 | name: z.string(),
15 | repository: z.string(),
16 | every: z.number(),
17 | timespan: z.enum(["minutes", "hours", "days"]),
18 | keepLast: z.number(),
19 | });
20 |
--------------------------------------------------------------------------------
/backend/routes/index.route.ts:
--------------------------------------------------------------------------------
1 | import express from "express";
2 | import userRouter from "./user.route";
3 | import scheduleRouter from "./schedule.route";
4 | import historyRouter from "./history.route";
5 | import accessTokenRouter from "./accessToken.route";
6 | import configRouter from "./config.route";
7 |
8 | const apiRouter = express.Router();
9 |
10 | apiRouter.use(userRouter);
11 | apiRouter.use("/schedules", scheduleRouter);
12 | apiRouter.use("/history", historyRouter);
13 | apiRouter.use("/access-tokens", accessTokenRouter);
14 | apiRouter.use("/config", configRouter);
15 |
16 | export default apiRouter;
17 |
--------------------------------------------------------------------------------
/src/pages/setup.astro:
--------------------------------------------------------------------------------
1 | ---
2 | import Layout from "../layouts/Layout.astro";
3 | import GitIcon from "../components/icons/GitIcon";
4 | import SetupComponent from "../components/Setup";
5 | ---
6 |
7 | {props.heading}
12 | {props.children} 13 |
10 |
20 |
11 |
19 |
14 |
17 |
10 |
21 |
11 |
20 |
14 |
17 | Sign in
18 |
10 |
18 | History
11 | 17 |
19 |
21 |
14 |
29 | );
30 | }
31 |
--------------------------------------------------------------------------------
/src/layouts/Layout.astro:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
9 |
10 | 15 | {formatTimestamp(props.timestamp)} 16 |
17 |{props.name}
18 |
19 |
22 |
23 | {props.success
24 | ? "Backup successful"
25 | : `Backup failed (${props.message})`}
26 |
27 |
28 |
15 | {props.label && (
16 |
19 | )}
20 |
34 | );
35 | }
36 |
--------------------------------------------------------------------------------
/backend/services/encryption.service.ts:
--------------------------------------------------------------------------------
1 | import crypto from "crypto";
2 | import { ENCRYPTION_SECRET } from "../configs/app.config";
3 |
4 | const ALGORITHM = "aes-256-cbc";
5 | const IV_LENGTH = 16;
6 |
7 | export class EncryptionService {
8 | static encrypt(text: string) {
9 | const iv = crypto.randomBytes(IV_LENGTH);
10 | const cipher = crypto.createCipheriv(
11 | ALGORITHM,
12 | Buffer.from(ENCRYPTION_SECRET.padEnd(32, " ")),
13 | iv,
14 | );
15 | let encrypted = cipher.update(text);
16 | encrypted = Buffer.concat([encrypted, cipher.final()]);
17 | return iv.toString("hex") + ":" + encrypted.toString("hex");
18 | }
19 |
20 | static decrypt(encryptedText: string): string {
21 | const parts = encryptedText.split(":");
22 | const iv = Buffer.from(parts[0], "hex");
23 | const encryptedData = Buffer.from(parts[1], "hex");
24 | const decipher = crypto.createDecipheriv(
25 | ALGORITHM,
26 | Buffer.from(ENCRYPTION_SECRET.padEnd(32, " ")),
27 | iv,
28 | );
29 | let decrypted = decipher.update(encryptedData);
30 | decrypted = Buffer.concat([decrypted, decipher.final()]);
31 | return decrypted.toString();
32 | }
33 | }
34 |
--------------------------------------------------------------------------------
/backend/routes/schedule.route.ts:
--------------------------------------------------------------------------------
1 | import express from "express";
2 | import { authenticateJWT } from "../middlewares/authenticateJWT";
3 | import {
4 | backupScheduleNow,
5 | createSchedule,
6 | deleteSchedule,
7 | getSchedules,
8 | pauseSchedule,
9 | resumeSchedule,
10 | updateSchedule,
11 | } from "../controllers/schedule.controller";
12 | import { validateSchema } from "../middlewares/validateSchema.middleware";
13 | import {
14 | postScheduleRequest,
15 | putScheduleRequest,
16 | } from "../models/schedule.model";
17 |
18 | const scheduleRouter = express.Router();
19 |
20 | scheduleRouter.get("", authenticateJWT, getSchedules);
21 | scheduleRouter.post(
22 | "",
23 | authenticateJWT,
24 | validateSchema(postScheduleRequest),
25 | createSchedule
26 | );
27 | scheduleRouter.put(
28 | "/:id",
29 | authenticateJWT,
30 | validateSchema(putScheduleRequest),
31 | updateSchedule
32 | );
33 | scheduleRouter.post("/:id/backup", authenticateJWT, backupScheduleNow);
34 | scheduleRouter.put("/:id/pause", authenticateJWT, pauseSchedule);
35 | scheduleRouter.put("/:id/resume", authenticateJWT, resumeSchedule);
36 | scheduleRouter.delete("/:id", authenticateJWT, deleteSchedule);
37 |
38 | export default scheduleRouter;
39 |
--------------------------------------------------------------------------------
/backend/controllers/history.controller.ts:
--------------------------------------------------------------------------------
1 | import { HistoryService } from "../services/history.service";
2 | import { Request, Response } from "express";
3 | import { AuthenticatedRequest } from "../types/AuthenticatedRequest";
4 |
5 | interface PaginationQuery {
6 | limit?: string;
7 | offset?: string;
8 | }
9 |
10 | export async function getHistory(
11 | req: Request<{}, {}, {}, PaginationQuery>,
12 | res: Response
13 | ) {
14 | const { limit, offset } = req.query;
15 | const username = (req as AuthenticatedRequest).user.username;
16 |
17 | // Convert string values to numbers
18 | const numLimit = limit ? parseInt(limit, 10) : undefined;
19 | const numOffset = offset ? parseInt(offset, 10) : undefined;
20 |
21 | // Check if values are missing or invalid
22 | if (
23 | numLimit === undefined ||
24 | numOffset === undefined ||
25 | isNaN(numLimit) ||
26 | isNaN(numOffset) ||
27 | numLimit <= 0 ||
28 | numOffset < 0
29 | ) {
30 | return res.status(400).send("Invalid limit or offset");
31 | }
32 |
33 | const { backupHistory, totalCount } = await HistoryService.getHistory(
34 | username,
35 | numOffset,
36 | numLimit
37 | );
38 | return res.json({ backupHistory, totalCount });
39 | }
40 |
--------------------------------------------------------------------------------
/src/pages/dashboard/overview.astro:
--------------------------------------------------------------------------------
1 | ---
2 | import HistoryList from "../../components/dashboard/HistoryList";
3 | import ScheduleList from "../../components/dashboard/ScheduleList";
4 | import ReloadIcon from "../../components/icons/ReloadIcon";
5 | import DashboardLayout from "../../layouts/DashboardLayout.astro";
6 | ---
7 |
8 |
23 |
32 |
33 |
19 |
27 | Overview
20 | 26 |
28 |
37 | Schedules
29 |
30 |
32 | History
33 |
34 |
36 |
33 |
41 | Schedules
34 | 40 |
42 |
46 |
43 |
45 | If you're not redirected, click here
54 | 55 | 56 | -------------------------------------------------------------------------------- /src/components/icons/MenuIcon.tsx: -------------------------------------------------------------------------------- 1 | type Props = { 2 | size?: number; 3 | }; 4 | 5 | export default function MenuIcon({ size = 10 }: Props) { 6 | return ( 7 | 26 | ); 27 | } 28 | -------------------------------------------------------------------------------- /backend/lib/logger.ts: -------------------------------------------------------------------------------- 1 | import { existsSync, mkdirSync, appendFile } from "fs"; 2 | import { join } from "path"; 3 | 4 | const logDirectory = "./data/logs"; 5 | 6 | if (!existsSync(logDirectory)) { 7 | mkdirSync(logDirectory); 8 | } 9 | 10 | function createLogString(level: string, message: string, fileName: string) { 11 | const date = new Date().toLocaleString("en-US", { 12 | year: "numeric", 13 | month: "short", 14 | day: "numeric", 15 | hour: "numeric", 16 | minute: "numeric", 17 | second: "numeric", 18 | hour12: false, 19 | }); 20 | return `[${date}] [${level.toUpperCase()}] [${fileName}]: ${message}`; 21 | } 22 | 23 | function logToFile(level: string, message: string) { 24 | const logFilePath = join(logDirectory, `${level}.log`); 25 | 26 | appendFile(logFilePath, message, (err) => { 27 | if (err) { 28 | console.error(`Failed to write log to file: ${err}`); 29 | } 30 | }); 31 | } 32 | 33 | export default class Logger { 34 | private fileName: string; 35 | constructor(fileName: string) { 36 | this.fileName = fileName; 37 | } 38 | 39 | info(message: string) { 40 | const level = "info"; 41 | const logMessage = createLogString(level, message, this.fileName); 42 | console.log(logMessage); 43 | logToFile(level, logMessage); 44 | } 45 | 46 | error(message: string) { 47 | const level = "error"; 48 | const logMessage = createLogString(level, message, this.fileName); 49 | console.error(logMessage); 50 | logToFile(level, logMessage); 51 | } 52 | 53 | warn(message: string) { 54 | const level = "warn"; 55 | const logMessage = createLogString(level, message, this.fileName); 56 | console.warn(logMessage); 57 | logToFile(level, logMessage); 58 | } 59 | } 60 | -------------------------------------------------------------------------------- /backend/services/accessToken.service.ts: -------------------------------------------------------------------------------- 1 | import prisma from "../../prisma/client"; 2 | import { EncryptionService } from "./encryption.service"; 3 | 4 | export class AccessTokenService { 5 | static async getAccessToken(username: string) { 6 | const accessToken = await prisma.accessToken.findMany({ 7 | where: { 8 | username: username, 9 | }, 10 | select: { 11 | id: true, 12 | name: true, 13 | }, 14 | }); 15 | 16 | return accessToken; 17 | } 18 | 19 | static async createAccessToken( 20 | name: string, 21 | token: string, 22 | username: string, 23 | ) { 24 | const encryptedToken = EncryptionService.encrypt(token); 25 | const accessToken = await prisma.accessToken.create({ 26 | data: { 27 | name: name, 28 | token: encryptedToken, 29 | username: username, 30 | }, 31 | }); 32 | 33 | return accessToken; 34 | } 35 | 36 | static async updateAccessToken(id: number, name: string, token: string) { 37 | let accessToken; 38 | if (!token) { 39 | const accessToken = await prisma.accessToken.update({ 40 | where: { 41 | id: id, 42 | }, 43 | data: { 44 | name: name, 45 | }, 46 | }); 47 | 48 | return accessToken; 49 | } else { 50 | const encryptedToken = EncryptionService.encrypt(token); 51 | const accessToken = await prisma.accessToken.update({ 52 | where: { 53 | id: id, 54 | }, 55 | data: { 56 | name: name, 57 | token: encryptedToken, 58 | }, 59 | }); 60 | 61 | return accessToken; 62 | } 63 | } 64 | 65 | static async deleteAccessToken(id: number) { 66 | const accessToken = await prisma.accessToken.delete({ 67 | where: { 68 | id: id, 69 | }, 70 | }); 71 | 72 | return accessToken; 73 | } 74 | } 75 | -------------------------------------------------------------------------------- /public/favicon.svg: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /src/components/dashboard/settings/AccessToken.tsx: -------------------------------------------------------------------------------- 1 | import React, { useEffect, useRef } from "react"; 2 | import MenuIcon from "../../icons/MenuIcon"; 3 | 4 | type Props = { 5 | id: number; 6 | name: string; 7 | editClick: () => void; 8 | deleteClick: () => void; 9 | }; 10 | 11 | export default function AccessToken(props: Props) { 12 | const [showMenu, setShowMenu] = React.useState
29 | {props.name}
30 |
55 | );
56 | }
57 |
--------------------------------------------------------------------------------
/backend/middlewares/authenticateJWT.ts:
--------------------------------------------------------------------------------
1 | import jwt from "jsonwebtoken";
2 | import type { Request, Response, NextFunction } from "express";
3 | import { DISABLE_AUTH, JWT_SECRET } from "../configs/app.config";
4 | import { User } from "../types/User";
5 | import { AuthenticatedRequest } from "../types/AuthenticatedRequest";
6 | import prisma from "../../prisma/client";
7 |
8 | function getCookie(cookies: string | undefined, name: string) {
9 | const value = `; ${cookies}`;
10 | const parts = value.split(`; ${name}=`);
11 | if (parts.length === 2) return parts.pop()?.split(";").shift();
12 | }
13 |
14 | export const authenticateJWT = (
15 | req: Request,
16 | res: Response,
17 | next: NextFunction,
18 | redirectOnSuccess: boolean | undefined = undefined,
19 | ) => {
20 | if (DISABLE_AUTH) {
21 | prisma.user.findFirst().then((user) => {
22 | if (!user) {
23 | return res.status(500).json({ message: "No user found" });
24 | }
25 |
26 | if (redirectOnSuccess === true) {
27 | return res.redirect("/dashboard");
28 | }
29 |
30 | (req as AuthenticatedRequest).user = user as User;
31 | return next();
32 | });
33 | } else {
34 | const token = getCookie(req.headers.cookie, "auth_session");
35 |
36 | if (token) {
37 | jwt.verify(token, JWT_SECRET, (err, user) => {
38 | if (err) {
39 | if (redirectOnSuccess === false) {
40 | return res.redirect("/login");
41 | } else if (redirectOnSuccess === undefined) {
42 | return res.status(403).json({ message: "Invalid token" });
43 | }
44 | }
45 |
46 | if (redirectOnSuccess === true) {
47 | return res.redirect("/dashboard");
48 | }
49 |
50 | (req as AuthenticatedRequest).user = user as User;
51 | next();
52 | });
53 | } else {
54 | if (redirectOnSuccess === false) {
55 | return res.redirect("/login");
56 | } else if (redirectOnSuccess === true) {
57 | next();
58 | } else {
59 | res.status(401).json({ message: "No token provided" });
60 | }
61 | }
62 | }
63 | };
64 |
--------------------------------------------------------------------------------
/backend/services/config.service.ts:
--------------------------------------------------------------------------------
1 | import prisma from "../../prisma/client";
2 |
3 | export class ConfigService {
4 | static async getStorageConfig(includePassword = false) {
5 | const config = await prisma.appConfig.findMany({
6 | where: {
7 | OR: [
8 | {
9 | key: "default_location",
10 | },
11 | {
12 | key: "smb_address",
13 | },
14 | {
15 | key: "smb_location",
16 | },
17 | {
18 | key: "smb_username",
19 | },
20 | ...(includePassword
21 | ? [
22 | {
23 | key: "smb_password",
24 | },
25 | ]
26 | : []),
27 | ],
28 | },
29 | });
30 | let storageConfig: {
31 | defaultLocation: string;
32 | smbAddress: string;
33 | smbLocation: string;
34 | smbUsername: string;
35 | smbPassword: string;
36 | } = {
37 | defaultLocation: "",
38 | smbAddress: "",
39 | smbLocation: "",
40 | smbUsername: "",
41 | smbPassword: "",
42 | };
43 | for (const item of config) {
44 | switch (item.key) {
45 | case "default_location":
46 | storageConfig.defaultLocation = item.value;
47 | break;
48 | case "smb_address":
49 | storageConfig.smbAddress = item.value;
50 | break;
51 | case "smb_location":
52 | storageConfig.smbLocation = item.value;
53 | break;
54 | case "smb_username":
55 | storageConfig.smbUsername = item.value;
56 | break;
57 | case "smb_password":
58 | storageConfig.smbPassword = item.value;
59 | break;
60 | }
61 | }
62 |
63 | return storageConfig;
64 | }
65 |
66 | static async updateConfigEntry(key: string, value: string) {
67 | await prisma.appConfig.update({
68 | where: { key },
69 | data: { value },
70 | });
71 | }
72 |
73 | static async getConfigEntry(key: string) {
74 | const config = await prisma.appConfig.findFirst({
75 | where: { key },
76 | });
77 |
78 | return config;
79 | }
80 | }
81 |
--------------------------------------------------------------------------------
/src/pages/dashboard/settings/about.astro:
--------------------------------------------------------------------------------
1 | ---
2 | import GitIcon from "../../../components/icons/GitIcon";
3 | import SettingsLayout from "../../../layouts/SettingsLayout.astro";
4 | const applicationVersion = process.env.npm_package_version;
5 | ---
6 |
7 |
25 |
26 |
31 |
37 |
54 |
40 |
46 |
52 |
53 |
29 |
57 |
32 |
37 |
33 |
35 | GitSave
36 |
38 |
56 | Version: {applicationVersion}
39 | GitHub 44 |
45 |
55 |
46 |
47 | Update avaliable
48 |
49 | Click here for update instructions
54 |
50 |
72 | {error &&
75 | );
76 | }
77 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | {error}
} 73 | {success &&{success}
} 74 |
2 | 
3 |
6 |
7 |
8 | 
9 |
10 | https://github.com/user-attachments/assets/301b28ca-6b72-490a-8efb-217e39fb73d3
11 |
12 | # Git happens...
13 |
14 | So be prepared and keep backups of your own and favourite Git repositories.
15 |
16 | ## 🛠️ Features
17 |
18 | - Easy to use and responsive web interface
19 | - Automated install using Docker
20 | - Scheduling of backups
21 | - Select amount of backups you want to keep
22 | - Support for GitHub, GitLab and other Git platforms
23 | - Support for own authentication provider
24 | - Pause/resume schedules
25 | - View backup history
26 | - Support for backing up to a SMB share
27 |
28 | ## 🚀 Deploy GitSave for yourself
29 |
30 | > [!WARNING]
31 | > Make sure to change the env variables "JWT_SECRET" and "ENCRYPTION_SECRET" to something secure. [This generator](https://witzdam.com/tools/coding/generator/jwt-secret-generator) may help you with that.
32 | > The ENCRYPTION_SECRET must be 32 characters long.
33 |
34 | ### Single run command
35 |
36 | ```bash
37 | docker run -d --restart=always -p 3000:3000 -v gitsave:/app/data -v ./backups:/app/backups -e JWT_SECRET={YOUR_SECRET_HERE} -e ENCRYPTION_SECRET={YOUR_SECRET_HERE_32_CHARACTERS} -e DISABLE_AUTH=false --name GitSave timwitzdam/gitsave:latest
38 | ```
39 |
40 | ### Docker compose
41 |
42 | 1. Create .env file
43 |
44 | ```bash
45 | # You can generate a JWT_SECRET here: https://witzdam.com/tools/coding/generator/jwt-secret-generator
46 | JWT_SECRET="REPLACE_THIS"
47 | DISABLE_AUTH=false
48 | ENCRYPTION_SECRET="REPLACE_THIS_WITH_32_CHARACTERS_SECRET"
49 | ```
50 |
51 | 2. Create `docker-compose.yml` file
52 |
53 | ```yaml
54 | services:
55 | gitsave:
56 | image: timwitzdam/gitsave:latest
57 | container_name: GitSave
58 | restart: always
59 | ports:
60 | - "3000:3000"
61 | volumes:
62 | - gitsave:/app/data
63 | - ./backups:/app/backups
64 | environment:
65 | - JWT_SECRET=${JWT_SECRET:?error}
66 | - DISABLE_AUTH=${DISABLE_AUTH:?error}
67 | - ENCRYPTION_SECRET=${ENCRYPTION_SECRET:?error}
68 |
69 | volumes:
70 | gitsave:
71 | ```
72 |
73 | ## 👀 Any questions, suggestions or problems?
74 |
75 | You're welcome to contribute to GitSave or open an issue if you have any suggestions or find any problems.
76 |
77 | I'm also available via mail: [contact@witzdam.com](mailto:contact@witzdam.com)
78 |
--------------------------------------------------------------------------------
/backend/controllers/user.controller.ts:
--------------------------------------------------------------------------------
1 | import { UserService } from "../services/user.service";
2 | import bcrypt from "bcryptjs";
3 | import { Request, Response } from "express";
4 | import { AuthenticatedRequest } from "../types/AuthenticatedRequest";
5 |
6 | export async function login(req: Request, res: Response) {
7 | const username = req.body.username;
8 | const password = req.body.password;
9 |
10 | const user = await UserService.getUserByUsername(username);
11 |
12 | if (!user) {
13 | return res.status(401).send("Invalid credentials");
14 | }
15 |
16 | bcrypt.compare(password, user.password, (err, result) => {
17 | if (err || !result) {
18 | return res.status(401).send("Invalid credentials");
19 | }
20 |
21 | const token = UserService.createJWTToken(username);
22 | res.json({ token });
23 | });
24 | }
25 |
26 | export async function register(req: Request, res: Response) {
27 | const username = req.body.username;
28 | const password = req.body.password;
29 |
30 | bcrypt.hash(password, 10, (err, hash) => {
31 | if (err) {
32 | return res.status(500).send("Internal server error");
33 | }
34 |
35 | const token = UserService.createJWTToken(username);
36 | UserService.createUser(username, hash);
37 |
38 | res.json({ token });
39 | });
40 | }
41 |
42 | export async function getUsername(req: Request, res: Response) {
43 | const username = (req as AuthenticatedRequest).user.username;
44 | return res.json({ username });
45 | }
46 |
47 | export async function setUsername(req: Request, res: Response) {
48 | const newUsername = req.body.username;
49 | const user = await UserService.getUserByUsername(newUsername);
50 |
51 | if (user) {
52 | return res.status(409).json({ message: "Username already exists" });
53 | }
54 |
55 | const username = (req as AuthenticatedRequest).user.username;
56 |
57 | await UserService.updateUsername(username, newUsername);
58 | const token = UserService.createJWTToken(newUsername);
59 |
60 | return res.json({ token });
61 | }
62 |
63 | export async function changePassword(req: Request, res: Response) {
64 | const oldPassword = req.body.password;
65 | const newPassword = req.body.newPassword;
66 | const username = (req as AuthenticatedRequest).user.username;
67 |
68 | const user = await UserService.getUserByUsername(username);
69 |
70 | if (!user) {
71 | return res.status(401).send("Invalid credentials");
72 | }
73 |
74 | bcrypt.compare(oldPassword, user.password, (err, result) => {
75 | if (err || !result) {
76 | return res.status(401).send("Invalid credentials");
77 | }
78 |
79 | bcrypt.hash(newPassword, 10, (err, hash) => {
80 | if (err) {
81 | return res.status(500).send("Internal server error");
82 | }
83 |
84 | UserService.updateUserPassword(username, hash);
85 | return res.json({ message: "Password updated" });
86 | });
87 | });
88 | }
89 |
--------------------------------------------------------------------------------
/src/components/PhoneNavMenu.tsx:
--------------------------------------------------------------------------------
1 | import React from "react";
2 | import GitIcon from "./icons/GitIcon";
3 |
4 | type Props = {
5 | links: { name: string; href: string }[];
6 | };
7 |
8 | export default function PhoneNavMenu(props: Props) {
9 | return (
10 |
65 | );
66 | }
67 |
--------------------------------------------------------------------------------
/src/layouts/SettingsLayout.astro:
--------------------------------------------------------------------------------
1 | ---
2 | import ShortArrow from "../components/icons/ShortArrow";
3 | import DashboardLayout from "./DashboardLayout.astro";
4 |
5 | type Props = {
6 | currentPage: string;
7 | };
8 |
9 | const { currentPage }: Props = Astro.props;
10 |
11 | const settings = [
12 | {
13 | name: "Overview",
14 | slug: "overview",
15 | hidden: true,
16 | },
17 | {
18 | name: "User",
19 | slug: "user",
20 | },
21 | {
22 | name: "Access tokens",
23 | slug: "access-tokens",
24 | },
25 | {
26 | name: "Storage",
27 | slug: "storage",
28 | },
29 | {
30 | name: "About",
31 | slug: "about",
32 | },
33 | ];
34 |
35 | function getCurrentPage() {
36 | return settings.find((setting) => setting.slug === currentPage);
37 | }
38 | ---
39 |
40 |
60 |
61 |
3 | GitSave
4 |Easily back up your Git repositories on a schedule.
5 |6 |
63 |
65 | {getCurrentPage()?.name}
64 |
66 | {
67 | currentPage === "overview" && (
68 |
105 |
69 | {settings
70 | .filter((setting) => !setting.hidden)
71 | .map((setting) => (
72 |
76 | {setting.name}
77 |
81 | )
82 | }
83 |
84 |
104 |
85 |
100 |
86 | {
87 | settings
88 | .filter((setting) => !setting.hidden)
89 | .map((setting) => (
90 |
94 | {setting.name}
95 |
96 | ))
97 | }
98 |
99 |
101 |
103 |
70 |
74 |
85 | {pageElement}
86 |
87 | )
88 | )}
89 |
93 |
96 | );
97 | }
98 |
--------------------------------------------------------------------------------
/src/components/dashboard/Schedule.tsx:
--------------------------------------------------------------------------------
1 | import React, { useEffect, useRef } from "react";
2 | import MenuIcon from "../icons/MenuIcon";
3 | import TimeIcon from "../icons/TimeIcon";
4 |
5 | type Props = {
6 | name: string;
7 | link: string;
8 | paused: boolean;
9 | lastBackup: string;
10 | last?: boolean;
11 | success: boolean;
12 | editClick: () => void;
13 | backupNowClick: () => void;
14 | pauseClick: () => void;
15 | deleteClick: () => void;
16 | };
17 |
18 | export default function Schedule(props: Props) {
19 | const [showMenu, setShowMenu] = React.useState(false);
20 | const menuRef = useRef
75 |
77 |
78 | {pageElements.map(
79 | (pageElement: PageElement, index: number) =>
80 | pageElement && (
81 |
37 |
88 | );
89 | }
90 |
--------------------------------------------------------------------------------
/src/components/dashboard/settings/AccessTokensSettings.tsx:
--------------------------------------------------------------------------------
1 | import BaseButton from "../../BaseButton";
2 | import React, { useEffect } from "react";
3 | import BaseSettingPanel from "./BaseSettingPanel";
4 | import AccessToken from "./AccessToken";
5 | import EditAccessTokenPopup from "./EditAccessTokenPopup";
6 |
7 | export default function AccessTokensSettings() {
8 | const [editMenu, setEditMenu] = React.useState<{
9 | id: number;
10 | name: string;
11 | } | null>(null);
12 | const [tokens, setTokens] = React.useState<{ name: string; id: number }[]>(
13 | [],
14 | );
15 | const [deleteMenu, setDeleteMenu] = React.useState
38 |
81 |
39 |
42 |
47 |
43 |
46 | {props.name}
44 | {props.link} 45 |
48 |
51 |
80 |
54 |
60 |
66 |
72 |
78 |
79 |
82 |
87 |
50 |
51 | setEditMenu(null)}
69 | />
70 | )}
71 | {deleteMenu && (
72 |
101 |
102 | );
103 | }
104 |
--------------------------------------------------------------------------------
/backend/services/schedule.service.ts:
--------------------------------------------------------------------------------
1 | import prisma from "../../prisma/client";
2 | import { EncryptionService } from "./encryption.service";
3 |
4 | export class ScheduleService {
5 | static async getSchedulesByUser(username: string) {
6 | const schedules = await prisma.backupJob.findMany({
7 | where: {
8 | username: username,
9 | },
10 | include: {
11 | backupHistory: {
12 | orderBy: {
13 | timestamp: "desc",
14 | },
15 | take: 1,
16 | },
17 | },
18 | });
19 |
20 | return schedules;
21 | }
22 |
23 | static async getScheduleById(id: string) {
24 | const schedule = await prisma.backupJob.findUnique({
25 | where: {
26 | id: parseInt(id),
27 | },
28 | });
29 |
30 | return schedule;
31 | }
32 |
33 | static async addSchedule(
34 | username: string,
35 | schedule: {
36 | name: string;
37 | repository: string;
38 | every: number;
39 | timespan: string;
40 | private: string;
41 | accessTokenId: string;
42 | keepLast: number;
43 | },
44 | initialUrl: string,
45 | ) {
46 | const newSchedule = await prisma.backupJob.create({
47 | data: {
48 | name: schedule.name,
49 | repository: initialUrl,
50 | cron: this.createCronExpression(schedule.every, schedule.timespan),
51 | username: username,
52 | accessTokenId:
53 | schedule.private === "on" ? parseInt(schedule.accessTokenId) : null,
54 | keepLast: schedule.keepLast,
55 | },
56 | });
57 |
58 | return newSchedule;
59 | }
60 |
61 | static async editSchedule(
62 | schedule: {
63 | name: string;
64 | repository: string;
65 | every: number;
66 | timespan: string;
67 | keepLast: number;
68 | },
69 | id: string,
70 | ) {
71 | const updatedSchedule = await prisma.backupJob.update({
72 | where: {
73 | id: parseInt(id),
74 | },
75 | data: {
76 | name: schedule.name,
77 | repository: schedule.repository,
78 | cron: this.createCronExpression(schedule.every, schedule.timespan),
79 | keepLast: schedule.keepLast,
80 | },
81 | });
82 |
83 | return updatedSchedule;
84 | }
85 |
86 | static async pauseSchedule(id: string) {
87 | const schedule = await prisma.backupJob.update({
88 | where: {
89 | id: parseInt(id),
90 | },
91 | data: {
92 | paused: true,
93 | },
94 | });
95 |
96 | return schedule;
97 | }
98 |
99 | static async resumeSchedule(id: string) {
100 | const schedule = await prisma.backupJob.update({
101 | where: {
102 | id: parseInt(id),
103 | },
104 | data: {
105 | paused: false,
106 | },
107 | });
108 |
109 | return schedule;
110 | }
111 |
112 | static async deleteSchedule(id: string) {
113 | const schedule = await prisma.backupJob.delete({
114 | where: {
115 | id: parseInt(id),
116 | },
117 | });
118 |
119 | return schedule;
120 | }
121 |
122 | static async getAccessToken(id: string) {
123 | const accessToken = await prisma.accessToken.findUnique({
124 | where: { id: parseInt(id) },
125 | select: { token: true },
126 | });
127 |
128 | if (accessToken === null) return undefined;
129 | const decryptedAccessToken = EncryptionService.decrypt(accessToken.token);
130 |
131 | return decryptedAccessToken;
132 | }
133 |
134 | static createCronExpression(every: number, timespan: string) {
135 | const currentDate = new Date();
136 | const currentHour = currentDate.getHours();
137 | const currentMinute = currentDate.getMinutes();
138 |
139 | switch (timespan) {
140 | case "minutes":
141 | return `*/${every} * * * *`;
142 | case "hours":
143 | return `${currentMinute} */${every} * * *`;
144 | case "days":
145 | return `${currentMinute} ${currentHour} */${every} * *`;
146 | default:
147 | return "";
148 | }
149 | }
150 | }
151 |
--------------------------------------------------------------------------------
/src/components/dashboard/HistoryList.tsx:
--------------------------------------------------------------------------------
1 | import React from "react";
2 | import History from "./History";
3 | import type { ScheduleHistory } from "../../types/scheduleTypes";
4 | import Pagination from "../Pagination/Pagination";
5 | import BaseButton from "../BaseButton";
6 |
7 | type Props = {
8 | disablePaging?: boolean;
9 | };
10 |
11 | export default function HistoryList({ disablePaging = false }: Props) {
12 | const [history, setHistory] = React.useState
52 | {tokens.map((token) => (
53 | setEditMenu(token)}
57 | deleteClick={() => setDeleteMenu(token.id)}
58 | />
59 | ))}
60 | {tokens.length === 0 && (
61 |
64 | {editMenu && (
65 | No access tokens found
62 | )}
63 |
73 |
99 | )}
100 |
76 |
98 | Delete access token
77 |
78 |
80 |
82 | All schedules using this token will stop working.
79 |80 |
Are you sure you want to delete this access token?
81 |
83 | setDeleteMenu(null)}
86 | fullWidth
87 | >
88 | Cancel
89 |
90 | handleDeleteClick(deleteMenu)}
92 | fullWidth
93 | >
94 | Delete
95 |
96 |
97 |
59 | {loading ? (
60 |
112 | );
113 | }
114 |
--------------------------------------------------------------------------------
/src/layouts/DashboardLayout.astro:
--------------------------------------------------------------------------------
1 | ---
2 | import Layout from "./Layout.astro";
3 | import GitIcon from "../components/icons/GitIcon";
4 | import UserIcon from "../components/icons/UserIcon";
5 | import BurgerMenuIcon from "../components/icons/BurgerMenuIcon";
6 | import PhoneNavMenu from "../components/PhoneNavMenu";
7 |
8 | const links = [
9 | { name: "Overview", href: "/dashboard/overview" },
10 | { name: "Schedules", href: "/dashboard/schedules/" },
11 | { name: "History", href: "/dashboard/history/" },
12 | { name: "Settings", href: "/dashboard/settings/" },
13 | ];
14 | ---
15 |
16 |
59 |
60 |
61 |
77 | ) : history.length === 0 ? (
78 |
62 | {Array.from(Array(5).keys()).map((index) => (
63 |
76 |
67 |
68 |
69 |
74 | ))}
75 |
70 |
71 |
72 |
73 |
79 |
83 | ) : (
84 |
80 |
82 | No history found
81 |
87 | {history.map((item, index) => (
88 | Show all
100 |
101 | )}
102 |
103 | )}
104 | {!disablePaging && !loading && fetched && total > perPage && (
105 |
62 |
113 |
63 |
97 |
66 |
69 |
70 |
96 |
71 |
77 |
88 |
89 |
95 |
98 |
111 |
99 | {
100 | links.map((link) => (
101 |
105 | {link.name}
106 |
107 | ))
108 | }
109 |
110 |
114 |
118 |
115 |
117 |
52 |
115 |
129 | );
130 | }
131 |
--------------------------------------------------------------------------------
/src/components/dashboard/settings/StorageSettings.tsx:
--------------------------------------------------------------------------------
1 | import BaseInput from "../../BaseInput";
2 | import BaseButton from "../../BaseButton";
3 | import React from "react";
4 | import BaseSettingPanel from "./BaseSettingPanel";
5 |
6 | export default function StorageSettings() {
7 | const [location, setLocation] = React.useState("local_folder");
8 | const [serverAddress, setServerAddress] = React.useState("");
9 | const [remoteLocation, setRemoteLocation] = React.useState("");
10 | const [username, setUsername] = React.useState("");
11 | const [password, setPassword] = React.useState("");
12 | const [locationError, setLocationError] = React.useState("");
13 | const [locationSuccess, setLocationSuccess] = React.useState("");
14 |
15 | React.useEffect(() => {
16 | fetch("/api/config/storage", {
17 | headers: {
18 | "Content-Type": "application/json",
19 | },
20 | })
21 | .then((res) => {
22 | if (res.ok) {
23 | return res.json();
24 | }
25 | })
26 | .then((data) => {
27 | if (!data) return;
28 |
29 | setLocation(data.defaultLocation);
30 | setServerAddress(data.smbAddress);
31 | setRemoteLocation(data.smbLocation);
32 | setUsername(data.smbUsername);
33 | })
34 | .catch((err) => {
35 | console.error(err);
36 | });
37 | }, []);
38 |
39 | function handleDefaultLocationSubmit(e: React.FormEvent
118 |
128 | Access token edited
119 |
120 |
124 | Close
125 |
126 |
127 | 121 | Your access token has been edited successfully. 122 |
123 |
76 |
77 |
134 |
135 |
136 | );
137 | }
138 |
--------------------------------------------------------------------------------
/src/components/dashboard/settings/UserSettings.tsx:
--------------------------------------------------------------------------------
1 | import BaseInput from "../../BaseInput";
2 | import BaseButton from "../../BaseButton";
3 | import React from "react";
4 | import BaseSettingPanel from "./BaseSettingPanel";
5 |
6 | export default function UserSettings() {
7 | const [username, setUsername] = React.useState("");
8 | const [usernameError, setUsernameError] = React.useState("");
9 | const [usernameSuccess, setUsernameSuccess] = React.useState("");
10 | const [passwordError, setPasswordError] = React.useState("");
11 | const [passwordSuccess, setPasswordSuccess] = React.useState("");
12 |
13 | React.useEffect(() => {
14 | const username = localStorage.getItem("username") || "";
15 | setUsername(username);
16 |
17 | // In case username changed on a different device
18 | fetch("/api/user/name", {
19 | headers: {
20 | "Content-Type": "application/json",
21 | },
22 | })
23 | .then((res) => {
24 | if (res.ok) {
25 | return res.json();
26 | }
27 | })
28 | .then((data) => {
29 | if (!data) return;
30 |
31 | localStorage.setItem("username", data.username);
32 | setUsername(data.username);
33 | })
34 | .catch((err) => {
35 | console.error(err);
36 | });
37 | }, []);
38 |
39 | function handleUsernameSubmit(e: React.FormEvent
113 |
114 |
129 |
130 |
131 |
132 |
159 |
160 |
161 | );
162 | }
163 |
--------------------------------------------------------------------------------
/backend/controllers/schedule.controller.ts:
--------------------------------------------------------------------------------
1 | import { ScheduleService } from "../services/schedule.service";
2 | import { execFile } from "child_process";
3 | import Logger from "../lib/logger";
4 | import {
5 | createBackup,
6 | resumeCronJob,
7 | scheduleCronJobs,
8 | stopCronJob,
9 | } from "../server";
10 | import { Request, Response } from "express";
11 | import { AuthenticatedRequest } from "../types/AuthenticatedRequest";
12 |
13 | const logger = new Logger("schedule.controller");
14 |
15 | export async function getSchedules(req: Request, res: Response) {
16 | const username = (req as AuthenticatedRequest).user.username;
17 | const schedules = await ScheduleService.getSchedulesByUser(username);
18 | return res.json(schedules);
19 | }
20 |
21 | export async function createSchedule(req: Request, res: Response) {
22 | const schedule = req.body;
23 | const username = (req as AuthenticatedRequest).user.username;
24 |
25 | let repoUrl: URL;
26 | try {
27 | repoUrl = new URL(schedule.repository);
28 | } catch (error) {
29 | return res.status(400).send("Invalid repository URL");
30 | }
31 |
32 | const initialUrl = repoUrl.href;
33 | if (schedule.private) {
34 | const accessToken = await ScheduleService.getAccessToken(
35 | schedule.accessTokenId,
36 | );
37 | if (!accessToken) {
38 | return res.status(400).send("Access token not found");
39 | }
40 |
41 | repoUrl.href = repoUrl.href.replace("https://", `https://${accessToken}@`);
42 | }
43 |
44 | const options = {
45 | env: {
46 | ...process.env,
47 | GIT_ASKPASS: "/bin/false",
48 | },
49 | };
50 | const child = execFile(
51 | "git",
52 | ["ls-remote", repoUrl.href],
53 | options,
54 | async (error, stdout, stderr) => {
55 | if (error) {
56 | logger.error(error.toString());
57 | return res
58 | .status(400)
59 | .send(
60 | "Invalid repository. Either it does not exist or you forgot to select an access token.",
61 | );
62 | }
63 |
64 | const newSchedule = await ScheduleService.addSchedule(
65 | username,
66 | schedule,
67 | initialUrl,
68 | );
69 | scheduleCronJobs();
70 | return res.json(newSchedule);
71 | },
72 | );
73 |
74 | const timeout = setTimeout(() => {
75 | child.kill();
76 | }, 5000);
77 |
78 | child.on("exit", (code) => {
79 | clearTimeout(timeout);
80 | if (code === null) {
81 | return res.status(400).send("The process took too long and was aborted.");
82 | }
83 | });
84 | }
85 |
86 | export async function updateSchedule(req: Request, res: Response) {
87 | const { id } = req.params;
88 | const schedule = req.body;
89 |
90 | let url: URL;
91 |
92 | try {
93 | url = new URL(schedule.repository);
94 | } catch (error) {
95 | return res.status(400).send("Invalid repository URL");
96 | }
97 |
98 | const options = {
99 | env: {
100 | ...process.env,
101 | GIT_ASKPASS: "/bin/false",
102 | },
103 | };
104 | const child = execFile(
105 | "git",
106 | ["ls-remote", url.href],
107 | options,
108 | async (error, stdout, stderr) => {
109 | if (error) {
110 | logger.error(error.toString());
111 | return res
112 | .status(400)
113 | .send(
114 | "Invalid repository. Either it does not exist or you forgot to select an access token.",
115 | );
116 | }
117 |
118 | const updatedSchedule = await ScheduleService.editSchedule(schedule, id);
119 | scheduleCronJobs();
120 | return res.json(updatedSchedule);
121 | },
122 | );
123 |
124 | const timeout = setTimeout(() => {
125 | child.kill();
126 | }, 5000);
127 |
128 | child.on("exit", (code) => {
129 | clearTimeout(timeout);
130 | if (code === null) {
131 | return res.status(400).send("The process took too long and was aborted.");
132 | }
133 | });
134 | }
135 |
136 | export async function backupScheduleNow(req: Request, res: Response) {
137 | const { id } = req.params;
138 |
139 | const schedule = await ScheduleService.getScheduleById(id);
140 |
141 | if (!schedule) {
142 | return res.status(404).send("Schedule not found");
143 | }
144 |
145 | if (schedule.accessTokenId) {
146 | const accessToken = await ScheduleService.getAccessToken(
147 | schedule.accessTokenId.toString(),
148 | );
149 | if (!accessToken) {
150 | return res.status(400).send("Access token not found");
151 | }
152 |
153 | schedule.repository = schedule.repository.replace(
154 | "https://",
155 | `https://${accessToken}@`,
156 | );
157 | }
158 |
159 | createBackup(
160 | schedule.id,
161 | schedule.name,
162 | schedule.repository,
163 | schedule.keepLast,
164 | );
165 | return res.send(
166 | "Backup started. Depending on the size of the repository, this may take a while.",
167 | );
168 | }
169 |
170 | export async function pauseSchedule(req: Request, res: Response) {
171 | const { id } = req.params;
172 |
173 | const pausedSchedule = await ScheduleService.pauseSchedule(id);
174 | stopCronJob(parseInt(id));
175 | return res.json(pausedSchedule);
176 | }
177 |
178 | export async function resumeSchedule(req: Request, res: Response) {
179 | const { id } = req.params;
180 |
181 | const resumedSchedule = await ScheduleService.resumeSchedule(id);
182 | resumeCronJob(parseInt(id));
183 | return res.json(resumedSchedule);
184 | }
185 |
186 | export async function deleteSchedule(req: Request, res: Response) {
187 | const { id } = req.params;
188 |
189 | await ScheduleService.deleteSchedule(id);
190 | stopCronJob(parseInt(id), true);
191 | return res.send("Schedule deleted");
192 | }
193 |
--------------------------------------------------------------------------------
/src/components/dashboard/ScheduleList.tsx:
--------------------------------------------------------------------------------
1 | import React from "react";
2 | import Schedule from "./Schedule";
3 | import type { ScheduleWithHistory } from "../../types/scheduleTypes";
4 | import EditSchedulePopup from "./EditSchedulePopup";
5 | import BaseButton from "../BaseButton";
6 | import { formatTimestamp } from "../../lib/formatTimestamp";
7 |
8 | export default function ScheduleList() {
9 | const [schedules, setSchedules] = React.useState
117 | {loading ? (
118 |
157 | setEditMenuDetails({
158 | id: schedule.id,
159 | name: schedule.name,
160 | cron: schedule.cron,
161 | repository: schedule.repository,
162 | keepLast: schedule.keepLast,
163 | })
164 | }
165 | backupNowClick={() => backupNow(schedule.id)}
166 | pauseClick={() => handlePauseClick(schedule.id, schedule.paused)}
167 | deleteClick={() => setShowDelete(schedule.id)}
168 | />
169 | ))
170 | )}
171 | {editMenuDetails && (
172 |
228 | );
229 | }
230 |
--------------------------------------------------------------------------------
/src/components/dashboard/EditSchedulePopup.tsx:
--------------------------------------------------------------------------------
1 | import React from "react";
2 | import BaseInput from "../BaseInput";
3 | import BaseButton from "../BaseButton";
4 | import updateIfNotBelow from "../../lib/updateIfNotBelow";
5 |
6 | type Props = {
7 | id: number;
8 | name: string;
9 | cron: string;
10 | repository: string;
11 | keepLast: number;
12 | closeEdit: () => void;
13 | };
14 |
15 | export default function EditSchedulePopup(props: Props) {
16 | const [loading, setLoading] = React.useState(false);
17 | const [error, setError] = React.useState("");
18 | const [success, setSuccess] = React.useState(false);
19 | const [name, setName] = React.useState(props.name);
20 | const [repository, setRepository] = React.useState(props.repository);
21 |
22 | const extractedCronParams = extractCronParameters(props.cron);
23 | const [every, setEvery] = React.useState(extractedCronParams.every);
24 | const [timespan, setTimespan] = React.useState(extractedCronParams.timespan);
25 | const [keepLast, setKeepLast] = React.useState(props.keepLast);
26 |
27 | function extractCronParameters(cronExpression: string) {
28 | const parts = cronExpression.split(" ");
29 |
30 | if (parts.length !== 5) {
31 | throw new Error("Invalid cron expression");
32 | }
33 |
34 | if (parts[0].includes("/")) {
35 | return { every: parseInt(parts[0].split("/")[1]), timespan: "minutes" };
36 | } else if (parts[1].includes("/")) {
37 | return { every: parseInt(parts[1].split("/")[1]), timespan: "hours" };
38 | } else if (parts[2].includes("/")) {
39 | return { every: parseInt(parts[2].split("/")[1]), timespan: "days" };
40 | } else {
41 | throw new Error("Unable to determine timespan from cron expression");
42 | }
43 | }
44 |
45 | function handleSubmit(e: React.FormEvent
119 |
135 | ) : schedules.length === 0 ? (
136 |
120 | {Array.from(Array(3).keys()).map((index) => (
121 |
134 |
125 |
126 |
127 |
132 | ))}
133 |
128 |
129 |
130 |
131 |
137 |
142 | ) : (
143 | schedules.map((schedule, index) => (
144 | 138 | You don't have any schedules yet. Create one by clicking the button 139 | on the top right. 140 |
141 |
183 |
197 | )}
198 | {showDelete && (
199 |
186 |
196 | Backup now
187 |
188 | {showBackupNow}
189 |
190 |
191 | setShowBackupNow("")} fullWidth>
192 | Close
193 |
194 |
195 |
200 |
226 | )}
227 |
203 |
225 | Delete schedule
204 |
205 |
209 | 206 | Are you sure you want to delete this schedule? 207 |
208 |
210 | setShowDelete(null)}
213 | fullWidth
214 | >
215 | Cancel
216 |
217 | handleDeleteClick(showDelete)}
219 | fullWidth
220 | >
221 | Delete
222 |
223 |
224 |
83 |
194 |
208 | );
209 | }
210 |
--------------------------------------------------------------------------------
/backend/server.ts:
--------------------------------------------------------------------------------
1 | import express from "express";
2 | import prisma from "../prisma/client";
3 | import { execFile } from "child_process";
4 | import cron from "node-cron";
5 | import fs from "fs";
6 | import { authenticateJWT } from "./middlewares/authenticateJWT";
7 | import { userExistCheck } from "./middlewares/userExistCheck";
8 | import { sanitize } from "./lib/sanatize";
9 | import Logger from "./lib/logger";
10 | import { PORT, GIT_TIMEOUT } from "./configs/app.config";
11 | import apiRouter from "./routes/index.route";
12 | import { ConfigService } from "./services/config.service";
13 | import { CronJob } from "./types/CronJob";
14 | import { EncryptionService } from "./services/encryption.service";
15 |
16 | const logger = new Logger("server");
17 | logger.info("Server starting");
18 |
19 | const app = express();
20 | let cronJobs: CronJob[] = [];
21 | app.use(express.json());
22 |
23 | async function prepareDatabase() {
24 | async function createAppConfig(key: string, value: string, dataType: string) {
25 | try {
26 | await prisma.appConfig.findFirstOrThrow({
27 | where: { key },
28 | });
29 | } catch (error) {
30 | await prisma.appConfig.create({
31 | data: {
32 | key,
33 | value,
34 | dataType,
35 | },
36 | });
37 | }
38 | }
39 |
40 | await createAppConfig("default_location", "local_folder", "string");
41 | await createAppConfig("smb_address", "", "string");
42 | await createAppConfig("smb_location", "", "string");
43 | await createAppConfig("smb_username", "", "string");
44 | await createAppConfig("smb_password", "", "string");
45 | }
46 |
47 | app.use("/api", apiRouter);
48 |
49 | interface backupHistoryEntry {
50 | backupJobId: number;
51 | success: boolean;
52 | message?: string;
53 | }
54 |
55 | function createHistoryEntry(data: backupHistoryEntry) {
56 | prisma.backupHistory
57 | .create({
58 | data: data,
59 | })
60 | .then((schedule) => {
61 | return true;
62 | })
63 | .catch((error) => {
64 | console.error(error);
65 | return false;
66 | });
67 | }
68 |
69 | export function createBackup(
70 | id: number,
71 | name: string,
72 | repository: string,
73 | keepLast: number
74 | ) {
75 | let backupJobData: backupHistoryEntry = {
76 | backupJobId: id,
77 | success: false,
78 | };
79 | const currentTimestamp = Math.floor(Date.now() / 1000);
80 | const options = {
81 | env: {
82 | ...process.env,
83 | GIT_ASKPASS: "/bin/false",
84 | },
85 | };
86 | prisma.appConfig
87 | .findUnique({
88 | where: {
89 | key: "default_location",
90 | },
91 | })
92 | .then((defaultLocation) => {
93 | let folderName = `./backups/${id}_${sanitize(name)}`;
94 | if (defaultLocation?.value === "smb_share") {
95 | folderName = `./tmp/backups/${id}-${sanitize(name)}`;
96 | }
97 | const child = execFile(
98 | "git",
99 | ["clone", "--mirror", repository, `${folderName}/${currentTimestamp}`],
100 | options,
101 | async (error, stdout, stderr) => {
102 | if (error) {
103 | if (error.killed) {
104 | backupJobData = {
105 | backupJobId: id,
106 | success: false,
107 | message:
108 | "Request took too long (has the access token expired?)",
109 | };
110 | } else {
111 | backupJobData = {
112 | backupJobId: id,
113 | success: false,
114 | message: "Missing privileges or cannot access",
115 | };
116 | }
117 | } else {
118 | backupJobData = {
119 | backupJobId: id,
120 | success: true,
121 | };
122 | if (defaultLocation?.value === "smb_share") {
123 | const config = await ConfigService.getStorageConfig();
124 | execFile(
125 | "smbclient",
126 | [
127 | `//${config.smbAddress}`,
128 | "-U",
129 | config.smbUsername,
130 | "--password",
131 | config.smbPassword,
132 | "-c",
133 | `prompt OFF; recurse ON; mkdir ${
134 | config.smbLocation
135 | }/${id}-${sanitize(name)}/${currentTimestamp}; cd ${
136 | config.smbLocation
137 | }/${id}-${sanitize(
138 | name
139 | )}/${currentTimestamp}; lcd ${folderName}/${currentTimestamp}; mput *`,
140 | ],
141 | options,
142 | (error, stdout, stderr) => {
143 | if (error) {
144 | logger.error(
145 | "Something went wrong backing up to SMB. Make sure the server is reachable and the credentials are correct."
146 | );
147 | } else {
148 | createHistoryEntry(backupJobData);
149 | fs.rmSync(`${folderName}/${currentTimestamp}`, {
150 | recursive: true,
151 | force: true,
152 | });
153 | }
154 | }
155 | );
156 | } else {
157 | fs.readdir(`${folderName}/`, (err, files) => {
158 | if (files.length >= keepLast) {
159 | const oldFiles = files.filter(
160 | (f) => parseInt(f) != currentTimestamp
161 | );
162 | oldFiles.sort((a, b) => parseInt(a) - parseInt(b));
163 | for (const oldFile of oldFiles.slice(
164 | 0,
165 | oldFiles.length - keepLast + 1
166 | )) {
167 | fs.rmSync(`${folderName}/${oldFile}`, {
168 | recursive: true,
169 | force: true,
170 | });
171 | }
172 | }
173 | });
174 | createHistoryEntry(backupJobData);
175 | }
176 | }
177 | }
178 | );
179 |
180 | const timeout = setTimeout(() => {
181 | child.kill();
182 | }, parseInt(GIT_TIMEOUT || "15000"));
183 |
184 | child.on("exit", (code) => {
185 | clearTimeout(timeout);
186 | if (code === null) {
187 | backupJobData = {
188 | backupJobId: id,
189 | success: false,
190 | message: "Request took too long (has the access token expired?)",
191 | };
192 | createHistoryEntry(backupJobData);
193 | }
194 | });
195 | });
196 | }
197 |
198 | export function scheduleCronJobs() {
199 | for (const cronJob of cronJobs) {
200 | cronJob.job.stop();
201 | }
202 | cronJobs = [];
203 |
204 | prisma.backupJob
205 | .findMany()
206 | .then((backupJobs) => {
207 | logger.info(
208 | `Scheduling ${backupJobs.length} backup job${
209 | backupJobs.length === 0 || backupJobs.length > 1 ? "s" : ""
210 | }`
211 | );
212 | for (const job of backupJobs) {
213 | if (job.accessTokenId) {
214 | prisma.accessToken
215 | .findUnique({
216 | where: {
217 | id: job.accessTokenId,
218 | },
219 | select: {
220 | token: true,
221 | },
222 | })
223 | .then((accessToken) => {
224 | if (!accessToken) {
225 | logger.error("Access token not found");
226 | } else {
227 | const decryptedToken = EncryptionService.decrypt(
228 | accessToken.token
229 | );
230 | const repoWithToken = job.repository.replace(
231 | "https://",
232 | `https://${decryptedToken}@`
233 | );
234 | pushCronJob(
235 | job.cron,
236 | job.id,
237 | job.name,
238 | repoWithToken,
239 | job.keepLast,
240 | job.paused
241 | );
242 | }
243 | })
244 | .catch((error) => {
245 | logger.error(error);
246 | });
247 | } else {
248 | pushCronJob(
249 | job.cron,
250 | job.id,
251 | job.name,
252 | job.repository,
253 | job.keepLast,
254 | job.paused
255 | );
256 | }
257 | }
258 | })
259 | .catch((error) => {
260 | logger.error(error);
261 | });
262 |
263 | function pushCronJob(
264 | cronString: string,
265 | id: number,
266 | name: string,
267 | repository: string,
268 | keepLast: number,
269 | paused: boolean
270 | ) {
271 | const c = cron.schedule(cronString, () => {
272 | logger.info(`Starting backup for ${name}`);
273 | createBackup(id, name, repository, keepLast);
274 | logger.info(`Backup for ${name} completed`);
275 | });
276 | cronJobs.push({ id: id, job: c });
277 | if (paused) {
278 | c.stop();
279 | }
280 | }
281 | }
282 |
283 | export function stopCronJob(id: number, deleteJob = false) {
284 | const job = cronJobs.find((j) => j.id === id);
285 | if (job) {
286 | job.job.stop();
287 | if (deleteJob) cronJobs = cronJobs.filter((j) => j.id !== id);
288 | }
289 | }
290 |
291 | export function resumeCronJob(id: number) {
292 | const job = cronJobs.find((j) => j.id === id);
293 | if (job) {
294 | job.job.start();
295 | }
296 | }
297 |
298 | async function main() {
299 | await prepareDatabase();
300 | app.use(
301 | "/dashboard",
302 | (req, res, next) => authenticateJWT(req, res, next, false),
303 | express.static("dist/dashboard")
304 | );
305 | app.use(
306 | "/login",
307 | (req, res, next) => authenticateJWT(req, res, next, true),
308 | express.static("dist/login")
309 | );
310 | app.use("/setup", userExistCheck, express.static("dist/setup"));
311 | app.use(express.static("dist"));
312 |
313 | scheduleCronJobs();
314 | app.listen(PORT, () => {
315 | logger.info(`Server running on port ${PORT}`);
316 | });
317 | }
318 |
319 | main().catch((error) => {
320 | logger.error("An error occurred while starting the server:" + error);
321 | process.exit(1);
322 | });
323 |
--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
1 | Apache License
2 | Version 2.0, January 2004
3 | http://www.apache.org/licenses/
4 |
5 | TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
6 |
7 | 1. Definitions.
8 |
9 | "License" shall mean the terms and conditions for use, reproduction,
10 | and distribution as defined by Sections 1 through 9 of this document.
11 |
12 | "Licensor" shall mean the copyright owner or entity authorized by
13 | the copyright owner that is granting the License.
14 |
15 | "Legal Entity" shall mean the union of the acting entity and all
16 | other entities that control, are controlled by, or are under common
17 | control with that entity. For the purposes of this definition,
18 | "control" means (i) the power, direct or indirect, to cause the
19 | direction or management of such entity, whether by contract or
20 | otherwise, or (ii) ownership of fifty percent (50%) or more of the
21 | outstanding shares, or (iii) beneficial ownership of such entity.
22 |
23 | "You" (or "Your") shall mean an individual or Legal Entity
24 | exercising permissions granted by this License.
25 |
26 | "Source" form shall mean the preferred form for making modifications,
27 | including but not limited to software source code, documentation
28 | source, and configuration files.
29 |
30 | "Object" form shall mean any form resulting from mechanical
31 | transformation or translation of a Source form, including but
32 | not limited to compiled object code, generated documentation,
33 | and conversions to other media types.
34 |
35 | "Work" shall mean the work of authorship, whether in Source or
36 | Object form, made available under the License, as indicated by a
37 | copyright notice that is included in or attached to the work
38 | (an example is provided in the Appendix below).
39 |
40 | "Derivative Works" shall mean any work, whether in Source or Object
41 | form, that is based on (or derived from) the Work and for which the
42 | editorial revisions, annotations, elaborations, or other modifications
43 | represent, as a whole, an original work of authorship. For the purposes
44 | of this License, Derivative Works shall not include works that remain
45 | separable from, or merely link (or bind by name) to the interfaces of,
46 | the Work and Derivative Works thereof.
47 |
48 | "Contribution" shall mean any work of authorship, including
49 | the original version of the Work and any modifications or additions
50 | to that Work or Derivative Works thereof, that is intentionally
51 | submitted to Licensor for inclusion in the Work by the copyright owner
52 | or by an individual or Legal Entity authorized to submit on behalf of
53 | the copyright owner. For the purposes of this definition, "submitted"
54 | means any form of electronic, verbal, or written communication sent
55 | to the Licensor or its representatives, including but not limited to
56 | communication on electronic mailing lists, source code control systems,
57 | and issue tracking systems that are managed by, or on behalf of, the
58 | Licensor for the purpose of discussing and improving the Work, but
59 | excluding communication that is conspicuously marked or otherwise
60 | designated in writing by the copyright owner as "Not a Contribution."
61 |
62 | "Contributor" shall mean Licensor and any individual or Legal Entity
63 | on behalf of whom a Contribution has been received by Licensor and
64 | subsequently incorporated within the Work.
65 |
66 | 2. Grant of Copyright License. Subject to the terms and conditions of
67 | this License, each Contributor hereby grants to You a perpetual,
68 | worldwide, non-exclusive, no-charge, royalty-free, irrevocable
69 | copyright license to reproduce, prepare Derivative Works of,
70 | publicly display, publicly perform, sublicense, and distribute the
71 | Work and such Derivative Works in Source or Object form.
72 |
73 | 3. Grant of Patent License. Subject to the terms and conditions of
74 | this License, each Contributor hereby grants to You a perpetual,
75 | worldwide, non-exclusive, no-charge, royalty-free, irrevocable
76 | (except as stated in this section) patent license to make, have made,
77 | use, offer to sell, sell, import, and otherwise transfer the Work,
78 | where such license applies only to those patent claims licensable
79 | by such Contributor that are necessarily infringed by their
80 | Contribution(s) alone or by combination of their Contribution(s)
81 | with the Work to which such Contribution(s) was submitted. If You
82 | institute patent litigation against any entity (including a
83 | cross-claim or counterclaim in a lawsuit) alleging that the Work
84 | or a Contribution incorporated within the Work constitutes direct
85 | or contributory patent infringement, then any patent licenses
86 | granted to You under this License for that Work shall terminate
87 | as of the date such litigation is filed.
88 |
89 | 4. Redistribution. You may reproduce and distribute copies of the
90 | Work or Derivative Works thereof in any medium, with or without
91 | modifications, and in Source or Object form, provided that You
92 | meet the following conditions:
93 |
94 | (a) You must give any other recipients of the Work or
95 | Derivative Works a copy of this License; and
96 |
97 | (b) You must cause any modified files to carry prominent notices
98 | stating that You changed the files; and
99 |
100 | (c) You must retain, in the Source form of any Derivative Works
101 | that You distribute, all copyright, patent, trademark, and
102 | attribution notices from the Source form of the Work,
103 | excluding those notices that do not pertain to any part of
104 | the Derivative Works; and
105 |
106 | (d) If the Work includes a "NOTICE" text file as part of its
107 | distribution, then any Derivative Works that You distribute must
108 | include a readable copy of the attribution notices contained
109 | within such NOTICE file, excluding those notices that do not
110 | pertain to any part of the Derivative Works, in at least one
111 | of the following places: within a NOTICE text file distributed
112 | as part of the Derivative Works; within the Source form or
113 | documentation, if provided along with the Derivative Works; or,
114 | within a display generated by the Derivative Works, if and
115 | wherever such third-party notices normally appear. The contents
116 | of the NOTICE file are for informational purposes only and
117 | do not modify the License. You may add Your own attribution
118 | notices within Derivative Works that You distribute, alongside
119 | or as an addendum to the NOTICE text from the Work, provided
120 | that such additional attribution notices cannot be construed
121 | as modifying the License.
122 |
123 | You may add Your own copyright statement to Your modifications and
124 | may provide additional or different license terms and conditions
125 | for use, reproduction, or distribution of Your modifications, or
126 | for any such Derivative Works as a whole, provided Your use,
127 | reproduction, and distribution of the Work otherwise complies with
128 | the conditions stated in this License.
129 |
130 | 5. Submission of Contributions. Unless You explicitly state otherwise,
131 | any Contribution intentionally submitted for inclusion in the Work
132 | by You to the Licensor shall be under the terms and conditions of
133 | this License, without any additional terms or conditions.
134 | Notwithstanding the above, nothing herein shall supersede or modify
135 | the terms of any separate license agreement you may have executed
136 | with Licensor regarding such Contributions.
137 |
138 | 6. Trademarks. This License does not grant permission to use the trade
139 | names, trademarks, service marks, or product names of the Licensor,
140 | except as required for reasonable and customary use in describing the
141 | origin of the Work and reproducing the content of the NOTICE file.
142 |
143 | 7. Disclaimer of Warranty. Unless required by applicable law or
144 | agreed to in writing, Licensor provides the Work (and each
145 | Contributor provides its Contributions) on an "AS IS" BASIS,
146 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
147 | implied, including, without limitation, any warranties or conditions
148 | of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
149 | PARTICULAR PURPOSE. You are solely responsible for determining the
150 | appropriateness of using or redistributing the Work and assume any
151 | risks associated with Your exercise of permissions under this License.
152 |
153 | 8. Limitation of Liability. In no event and under no legal theory,
154 | whether in tort (including negligence), contract, or otherwise,
155 | unless required by applicable law (such as deliberate and grossly
156 | negligent acts) or agreed to in writing, shall any Contributor be
157 | liable to You for damages, including any direct, indirect, special,
158 | incidental, or consequential damages of any character arising as a
159 | result of this License or out of the use or inability to use the
160 | Work (including but not limited to damages for loss of goodwill,
161 | work stoppage, computer failure or malfunction, or any and all
162 | other commercial damages or losses), even if such Contributor
163 | has been advised of the possibility of such damages.
164 |
165 | 9. Accepting Warranty or Additional Liability. While redistributing
166 | the Work or Derivative Works thereof, You may choose to offer,
167 | and charge a fee for, acceptance of support, warranty, indemnity,
168 | or other liability obligations and/or rights consistent with this
169 | License. However, in accepting such obligations, You may act only
170 | on Your own behalf and on Your sole responsibility, not on behalf
171 | of any other Contributor, and only if You agree to indemnify,
172 | defend, and hold each Contributor harmless for any liability
173 | incurred by, or claims asserted against, such Contributor by reason
174 | of your accepting any such warranty or additional liability.
175 |
176 | END OF TERMS AND CONDITIONS
177 |
178 | APPENDIX: How to apply the Apache License to your work.
179 |
180 | To apply the Apache License to your work, attach the following
181 | boilerplate notice, with the fields enclosed by brackets "[]"
182 | replaced with your own identifying information. (Don't include
183 | the brackets!) The text should be enclosed in the appropriate
184 | comment syntax for the file format. We also recommend that a
185 | file or class name and description of purpose be included on the
186 | same "printed page" as the copyright notice for easier
187 | identification within third-party archives.
188 |
189 | Copyright [yyyy] [name of copyright owner]
190 |
191 | Licensed under the Apache License, Version 2.0 (the "License");
192 | you may not use this file except in compliance with the License.
193 | You may obtain a copy of the License at
194 |
195 | http://www.apache.org/licenses/LICENSE-2.0
196 |
197 | Unless required by applicable law or agreed to in writing, software
198 | distributed under the License is distributed on an "AS IS" BASIS,
199 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
200 | See the License for the specific language governing permissions and
201 | limitations under the License.
202 |
--------------------------------------------------------------------------------
/src/components/dashboard/AddSchedulePopup.tsx:
--------------------------------------------------------------------------------
1 | import React from "react";
2 | import BaseInput from "../BaseInput";
3 | import BaseButton from "../BaseButton";
4 | import updateIfNotBelow from "../../lib/updateIfNotBelow";
5 |
6 | export default function AddSchedulePopup() {
7 | const [every, setEvery] = React.useState(1);
8 | const [keepLast, setKeepLast] = React.useState(5);
9 | const [loading, setLoading] = React.useState(false);
10 | const [error, setError] = React.useState("");
11 | const [success, setSuccess] = React.useState(false);
12 | const [showAddAccessToken, setShowAddAccessToken] = React.useState(false);
13 | const [privateRepo, setPrivateRepo] = React.useState(false);
14 | const [accessToken, setAccessToken] = React.useState("default");
15 | const [availableAccessTokens, setAvailableAccessTokens] = React.useState<
16 | { id: number; name: string }[]
17 | >([]);
18 |
19 | function updateAccessToken(e: React.ChangeEvent
197 |
207 | Schedule edited
198 |
199 |
203 | Close
204 |
205 |
206 | 200 | Your schedule has been edited successfully. 201 |
202 |
107 |
242 |
296 | );
297 | }
298 |
--------------------------------------------------------------------------------
/src/components/Setup.tsx:
--------------------------------------------------------------------------------
1 | import React from "react";
2 | import BaseButton from "./BaseButton";
3 | import BaseInput from "./BaseInput";
4 | import updateIfNotBelow from "../lib/updateIfNotBelow";
5 |
6 | export default function Setup() {
7 | const [error, setError] = React.useState("");
8 | const [success, setSuccess] = React.useState("");
9 | const [step, setStep] = React.useState(0);
10 | const [every, setEvery] = React.useState(1);
11 | const [keepLast, setKeepLast] = React.useState(5);
12 | const [loading, setLoading] = React.useState(false);
13 | const [showAddAccessToken, setShowAddAccessToken] = React.useState(false);
14 | const [privateRepo, setPrivateRepo] = React.useState(false);
15 | const [accessToken, setAccessToken] = React.useState("default");
16 | const [availableAccessTokens, setAvailableAccessTokens] = React.useState<
17 | { id: number; name: string }[]
18 | >([]);
19 |
20 | function handleRegisterSubmit(e: React.FormEvent
245 |
255 | Schedule added
246 |
247 |
251 | Close
252 |
253 |
254 | 248 | Your schedule has been added successfully. 249 |
250 |
258 |
295 | Add access token
259 | 294 |
151 | {step === 0 && (
152 |
395 | );
396 | }
397 |
--------------------------------------------------------------------------------
153 | setStep(1)} fullWidth>
160 | Get started
161 |
162 |
163 | )}
164 | {step === 1 && (
165 | 154 | Welcome to GitSave 155 |
156 |157 | Let's get you started with a quick 2 step initial setup 158 |
159 |
166 |
214 | )}
215 | {step === 2 && (
216 | 167 | 1. Account creation 168 |
169 | 213 |
217 |
391 | )}
392 | {error &&
218 |
352 | 219 | 2. Adding first schedule 220 |
221 |
222 | (location.href = "/dashboard")}
225 | >
226 | Skip for now
227 |
228 |
229 |
351 |
353 |
390 | Add access token
354 | 389 |{error}
} 393 | {success &&{success}
} 394 |