Add files via upload

Initial import

Author: ghajj

Dockerfile

@@ -0,0 +1,31 @@
+# Use an official Python runtime as a parent image
+#Choose a lightweight base image
+FROM python:3.9-slim  
+
+
+# Install ps package for process management
+RUN apt-get update && apt-get install -y procps
+# Set the working directory in the container
+# Change this to your application's directory
+WORKDIR /app  
+
+# Copy the requirements file into the container
+# Assumes you have a `requirements.txt` file with dependencies
+COPY requirements.txt .  
+
+# Install any dependencies specified in the requirements file
+RUN pip install --no-cache-dir -r requirements.txt  
+
+# Copy the current directory contents into the container
+COPY *.py .
+COPY ./templates ./templates
+
+# Set the environment variables
+ENV FLASK_APP=app.py
+# Expose the port the app runs on
+EXPOSE 5003
+
+# Run the Flask app
+#CMD ["flask", "run", "--host=0.0.0.0", "--port=5003"]
+# Command to run the application with Gunicorn
+CMD ["gunicorn", "-b", "0.0.0.0:5003", "app:app"]

README.md

@@ -1 +1,141 @@
-Initial readme
+
+---
+
+# RsyncWebApp
+
+**RsyncWebApp** is a remote server rsync configuration tool designed to streamline the setup and management of rsync tasks on remote servers. This app allows you to log in to a remote server, configure rsync tasks, and save them to a shell script or directly to `crontab` for automated execution. Additionally, RsyncWebApp can discover SMB shares and generate mount scripts for easier access and management of shared network resources.
+
+## Features (The app has not been fully tested, please test before adoption).
+
+- **Remote Rsync Configuration**: Log on to a remote server and configure rsync tasks for data synchronization.
+- **Save to Shell or Crontab**: Save tasks to a shell script or directly to `crontab` for scheduled execution on the server.
+- **Execute Commands Remotely**: Execute saved shell or crontab commands directly on the remote server.
+- **SMB Share Discovery**: Discover available SMB shares and create mount scripts to connect to these shares.
+- **Docker Deployment**: Quickly deploy the app using the included `docker-compose.yml` file.
+
+## Getting Started
+
+### Prerequisites
+
+- **Docker** and **Docker Compose**: Ensure Docker and Docker Compose are installed on your system to use the containerized deployment option.
+- **Python 3.x** and **Flask**: If running the app directly, you'll need Python 3.x and Flask installed.
+
+### Installation and Setup
+
+#### 1. Clone the Repository
+Clone this repository to your local machine:
+   ```bash
+   git clone https://github.com/yourusername/rsyncwebapp.git
+   cd rsyncwebapp
+   ```
+   Create secrets.env in the app root directory with this content
+   ```bash
+   SECRET_KEY='yoursupersecretkeycombination'
+   ```
+
+
+#### 2. Docker Deployment
+To deploy using Docker Compose:
+   - Start the app with the following command:
+     ```bash
+     docker-compose up -d
+     ```
+   - The app will be accessible on the ports specified in the `docker-compose.yml` file. Adjust port mappings if needed to avoid conflicts.
+
+#### 3. Manual Deployment
+If you prefer to run the app directly with Python and Flask:
+   - Install the necessary dependencies:
+     ```bash
+     pip install -r requirements.txt
+     ```
+   - Start the Flask app:
+     ```bash
+     python app.py
+     ```
+   - By default, Flask will serve the app on port 5003, but this can be customized in `app.py`.
+
+#### 4. For dev:
+   ```bash
+    python3 -m venv venv
+    source venv/bin/activate
+    pip install --no-cache-dir -r requirements.txt
+    python app.py
+
+   ```
+### Usage
+
+1. **Login to Remote Server**
+   - Authenticate with a remote server using your credentials. This will allow you to set up rsync tasks and execute commands on the remote server.
+
+2. **Configure Rsync Task**
+   - Once logged in, define the rsync options, source, and destination paths. Customize rsync flags for options like `--delete` to remove extraneous files, `--archive` to preserve permissions, and more.
+
+3. **Save and Execute**
+   - Choose to save the rsync task to a shell script or directly to `crontab`. 
+   - For saved tasks:
+     - **Shell Script**: This creates a `.sh` file that you can execute manually or with a scheduler.
+     - **Crontab**: Save tasks directly to the server’s `crontab` for automatic execution based on your specified schedule.
+
+4. **Discover SMB Shares**
+   - Use the SMB discovery tool to scan for available SMB shares within your network.
+   - Generate mount scripts to easily mount SMB shares on your server or local machine.
+
+5. **Files**
+   - All yaml and shell files are in the /home/user/rsyncwebapp directory.
+
+### Configuration
+
+- The application’s exposed ports, network configuration, and environment variables can be adjusted within the `docker-compose.yml` file.
+- The default Flask server port can also be configured in `app.py` if running outside of Docker.
+
+### Example Docker Compose Configuration
+
+Here’s a snippet of what your `docker-compose.yml` might look like:
+
+```yaml
+services:
+  rsyncwebapp:
+    hostname: rsyncwebapp-container
+    build: .  # Build the Docker image from the current directory
+    container_name: rsyncwebapp
+    ports:
+      - "8003:5003/tcp"  # Map the container port to the host port
+    environment:
+      FLASK_ENV: 'production'
+      FLASK_APP: "app.py"
+      FLASK_DEBUG: "0"
+    env_file:
+      - secrets.env
+    volumes:
+      - /var/run/docker.sock:/var/run/docker.sock
+      - /etc/localtime:/etc/localtime:ro
+      - /etc/timezone:/etc/timezone:ro
+      - .:/app  # Mount the current directory to the container's `/app`
+
+```
+
+To change the default port or environment variables, simply edit this file before running `docker-compose up`.
+
+## Contributing
+
+Contributions are welcome! If you'd like to contribute, please fork the repository and submit a pull request with your changes. You can also open an issue to discuss any improvements or new features.
+
+1. Fork the Project
+2. Create your Feature Branch (`git checkout -b feature/AmazingFeature`)
+3. Commit your Changes (`git commit -m 'Add some AmazingFeature'`)
+4. Push to the Branch (`git push origin feature/AmazingFeature`)
+5. Open a Pull Request
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+## Acknowledgments
+
+- **Flask** for the web framework.
+- **Docker** and **Docker Compose** for containerization.
+- **Rsync** and **SMB tools** for the core functionality.
+
+---
+
+**RsyncWebApp** is your streamlined solution for managing rsync tasks and SMB shares on remote servers.

app.py

@@ -0,0 +1,176 @@
+from flask import Flask, render_template, request, redirect, url_for, flash, session
+import paramiko
+from flask_session import Session
+import os
+import logging
+from yaml_handler import YAMLHandler  # Import the refactored YAML handler
+from shAndCrontab import SHAndCRONTABHandler
+
+
+from browse import browse_blueprint  # Blueprint for browsing directories
+from configure import configure_blueprint  # Blueprint for configuring directory pairs
+from logs import log_blueprint  # Import the blueprint for managing log files
+from view_tasks import view_tasks_blueprint
+from server_management import server_management_blueprint
+
+from netbios import netbios_bp
+from smb_shares import smb_shares_bp
+
+app = Flask(__name__)
+
+app.config['ENV'] = os.environ.get("FLASK_ENV", "development")
+
+logging.basicConfig(filename='app.log', level=logging.DEBUG)
+
+app.secret_key = os.environ.get("SECRET_KEY", "default_secret_key")
+app.config['SESSION_TYPE'] = 'filesystem'
+Session(app)
+
+app.register_blueprint(browse_blueprint, url_prefix="/browse")
+app.register_blueprint(configure_blueprint, url_prefix="/configure")
+app.register_blueprint(log_blueprint, url_prefix="/logs")  # Optional prefix for the blueprint
+app.register_blueprint(view_tasks_blueprint, url_prefix="/view_tasks")
+app.register_blueprint(server_management_blueprint, url_prefix="/server_management")
+# Register the NetBIOS blueprint
+app.register_blueprint(netbios_bp, url_prefix='/netbios')
+app.register_blueprint(smb_shares_bp)
+
+@app.route('/')
+def index():
+
+    flash(f"app Environment = {app.config['ENV']}",'info')
+
+    if 'logged_in' not in session:
+        return redirect(url_for('login'))
+
+    hostname = os.uname().nodename
+
+    server = session.get('server', '')
+    # Create a YAMLHandler instance with remote handling
+    yaml_handler = YAMLHandler(use_remote=True)
+    # Load YAML data
+    yaml_data = yaml_handler.get_or_create_default_settings()  # Load YAML data
+
+    log_files_dir = yaml_data[server].get('log_files_dir', None)
+    # Get the directory pairs for the logged-in server
+    if log_files_dir is None:
+        log_files_dir = '/home/'+session['username']+'/rsyncwebapp'
+        yaml_data[server]['log_files_dir'] = log_files_dir
+        yaml_handler.save_yaml(yaml_data)
+
+    pairs = yaml_data[server].get('pairs', [])
+    if not pairs:
+        pairs = []
+        yaml_data[server]['pairs'] = pairs
+        yaml_handler.save_yaml(yaml_data)
+
+    # get server information
+    server_data = yaml_data.get(server, []) 
+
+    # get server information
+    server_data = yaml_data.get(server, [])
+    return render_template('index.html', hostname=hostname, server=server, logfiles=log_files_dir, server_data=pairs, enumerate=enumerate)  # Pass 'enumerate'
+
+@app.route('/remove_pair/<int:pair_index>', methods=['GET'])
+def remove_pair(pair_index):
+    if 'logged_in' not in session:
+        return redirect(url_for('login'))
+
+    server = session.get('server', '')
+    # Create a YAMLHandler instance with remote handling
+    yaml_handler = YAMLHandler(use_remote=True)
+    # Load YAML data
+    yaml_data = yaml_handler.load_yaml()
+
+    if server in yaml_data:
+        directory_pairs = yaml_data[server].get('pairs', [])
+        if 0 <= pair_index < len(directory_pairs):
+            #remove from crontab and shell script if they exist
+            shAndCrontab = SHAndCRONTABHandler(use_remote=True)
+            shAndCrontab.remove_from_crontab(directory_pairs[pair_index])
+            shAndCrontab.remove_from_script(directory_pairs[pair_index])
+
+            del directory_pairs[pair_index]  # Remove the pair
+            yaml_handler.save_yaml(yaml_data)  # Persist changes
+            flash("Pair removed successfully", "info")
+        else:
+            flash("Invalid pair index", "warning")
+    else:
+        flash("Server not found", "warning")
+
+    return redirect(url_for('index'))
+
+@app.route('/login', methods=['GET', 'POST'])
+def login():
+    hostname = os.uname().nodename
+    if request.method == 'POST':
+        server = request.form.get('server', 'hp-debian').strip()
+        username = request.form.get('username', 'ghassan').strip()
+        password = request.form.get('password', '').strip()
+        private_key_path = request.form.get('private_key_path', '').strip()
+        passphrase = request.form.get('passphrase', '').strip()
+
+        if not server or not username:
+            flash("Server and username are required.", "warning")
+            return render_template('login.html', hostname=hostname)
+
+        ssh = paramiko.SSHClient()
+        ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
+
+        try:
+            if private_key_path:
+                if not passphrase:
+                    flash("Passphrase is required for encrypted private keys.", 'warning')
+                    return render_template('login.html')
+
+                pkey = paramiko.RSAKey.from_private_key_file(private_key_path, password=passphrase)
+                ssh.connect(server, username=username, pkey=pkey)
+            else:
+                ssh.connect(server, username=username, password=password)
+
+            # Create the app directory to store the app files
+            stdin, stdout, stderr = ssh.exec_command(f"mkdir -p /home/{username}/rsyncwebapp")
+            error = stderr.read().decode().strip()
+            if error:
+                flash(f"Directory creation failed: {error}", "danger")
+                return render_template('login.html', hostname=hostname)
+
+            # Store session information
+            session['logged_in'] = True
+            session['server'] = server
+            session['username'] = username
+            session['password'] = password
+            session['private_key_path'] = private_key_path
+            session['passphrase'] = passphrase
+
+            # Assuming YAMLHandler class and yaml operations are defined elsewhere
+            yaml_handler = YAMLHandler(use_remote=True)
+            yaml_handler.ensure_yaml_file()
+
+            yaml_data = yaml_handler.load_yaml()  # Load YAML data
+
+            return redirect(url_for('index'))
+        
+        except paramiko.AuthenticationException:
+            flash("Invalid username or password.", "danger")
+            return render_template('login.html', hostname=hostname)
+        
+        except paramiko.SSHException as e:
+            flash(f"SSH connection failed: {e}", "danger")
+            return render_template('login.html', hostname=hostname)
+        
+        except Exception as e:
+            flash(f"Login failed: {e}", "danger")
+            return render_template('login.html', hostname=hostname)
+
+    return render_template('login.html', hostname=hostname)
+    
+@app.route('/logout')
+def logout():
+    session.clear()  # Clear session data
+    return redirect(url_for('login'))
+
+if __name__ == '__main__':
+    logging.info("app config: %s\n ", app.config)
+    
+    app.run(debug=True, host='0.0.0.0', port=5003)