opensimMULTITOOL II

[Manfred Aabye]

Eine Erweiterung für osmtool in PHP hatte ich ja bereits gemacht, aber das Problem sind die rechte.
Am besten ist das, wenn man in C# eine umsetzen würde, das heißt aber alles in einer Programmiersprache neu erstellen.
Und das osWebinterface was ich gemacht habe, da kannst du mit deinem Viewer drauf zugreifen.

Was du benötigst, wäre folgendes, sagt meine KI:

Hier ist eine **komplette Anleitung** für eine C#-API, die den OpenSimulator aus `/home/opensim` startet, stoppt
und neu startet mit **Prozessmanagement in C#** für 24/7-Betrieb.

---

## **1. Voraussetzungen**
- **Linux-Server** (Ubuntu/Debian empfohlen).
- **.NET 6.0+** (für die C#-API).
- **OpenSimulator** installiert in `/home/opensim/bin/OpenSim.dll`.
- **PHP** für API-Aufrufe (optional, kann auch via `curl` genutzt werden).

---

## **2. C#-API einrichten**
### **Projekt erstellen**

Code:

```bash
mkdir OpenSimManager
cd OpenSimManager
dotnet new webapi
```

### **Angepasster Code (`Program.cs`)**

Code:

```csharp
using Microsoft.AspNetCore.Authentication;
using Microsoft.AspNetCore.Authorization;
using System.Diagnostics;
using System.Security.Claims;

var builder = WebApplication.CreateBuilder(args);

// Basic Authentication
builder.Services.AddAuthentication("BasicAuthentication")
    .AddScheme<AuthenticationSchemeOptions, BasicAuthHandler>("BasicAuthentication", null);
builder.Services.AddAuthorization();

var app = builder.Build();
app.UseAuthentication();
app.UseAuthorization();

// Globale Prozess-Referenz
private static Process _opensimProcess;

// API-Endpoints
app.MapGet("/api/opensim", [Authorize] (string action) =>
{
    try
    {
        switch (action.ToLower())
        {
            case "start":
                if (_opensimProcess != null && !_opensimProcess.HasExited)
                    return Results.BadRequest("OpenSimulator läuft bereits.");

                _opensimProcess = new Process();
                _opensimProcess.StartInfo.FileName = "dotnet";
                _opensimProcess.StartInfo.Arguments = "/home/opensim/bin/OpenSim.dll";
                _opensimProcess.StartInfo.WorkingDirectory = "/home/opensim/bin";
                _opensimProcess.StartInfo.RedirectStandardOutput = true;
                _opensimProcess.StartInfo.RedirectStandardError = true;
                _opensimProcess.StartInfo.UseShellExecute = false;
                _opensimProcess.StartInfo.CreateNoWindow = true;
                _opensimProcess.EnableRaisingEvents = true;
                _opensimProcess.Exited += (sender, e) =>
                    Console.WriteLine("OpenSimulator Prozess beendet (Exit-Code: " + _opensimProcess.ExitCode + ")");
                _opensimProcess.Start();
                return Results.Ok("OpenSimulator gestartet (PID: " + _opensimProcess.Id + ")");

            case "stop":
                if (_opensimProcess == null || _opensimProcess.HasExited)
                    return Results.BadRequest("OpenSimulator ist nicht gestartet.");

                _opensimProcess.Kill();
                _opensimProcess = null;
                return Results.Ok("OpenSimulator gestoppt.");

            case "restart":
                if (_opensimProcess != null && !_opensimProcess.HasExited)
                {
                    _opensimProcess.Kill();
                    Thread.Sleep(5000); // Wartezeit für Cleanup
                }
                // Neustart
                _opensimProcess = new Process();
                _opensimProcess.StartInfo.FileName = "dotnet";
                _opensimProcess.StartInfo.Arguments = "/home/opensim/bin/OpenSim.dll";
                _opensimProcess.StartInfo.WorkingDirectory = "/home/opensim/bin";
                _opensimProcess.Start();
                return Results.Ok("OpenSimulator neu gestartet (PID: " + _opensimProcess.Id + ")");

            case "status":
                if (_opensimProcess != null && !_opensimProcess.HasExited)
                    return Results.Ok("OpenSimulator läuft (PID: " + _opensimProcess.Id + ")");
                else
                    return Results.Ok("OpenSimulator ist nicht gestartet.");

            default:
                return Results.BadRequest("Ungültige Aktion. Erlaubt: start, stop, restart, status");
        }
    }
    catch (Exception ex)
    {
        return Results.Problem($"Fehler: {ex.Message}");
    }
});

app.Run();

// Basic Authentication Handler
public class BasicAuthHandler : AuthenticationHandler<AuthenticationSchemeOptions>
{
    public BasicAuthHandler(
        IOptionsMonitor<AuthenticationSchemeOptions> options,
        ILoggerFactory logger,
        UrlEncoder encoder,
        ISystemClock clock) : base(options, logger, encoder, clock) { }

    protected override Task<AuthenticateResult> HandleAuthenticateAsync()
    {
        if (!Request.Headers.ContainsKey("Authorization"))
            return Task.FromResult(AuthenticateResult.Fail("Authorization Header fehlt"));

        var authHeader = Request.Headers["Authorization"].ToString();
        if (!authHeader.StartsWith("Basic "))
            return Task.FromResult(AuthenticateResult.Fail("Ungültiges Format"));

        var encodedCreds = authHeader["Basic ".Length..];
        var creds = Encoding.UTF8.GetString(Convert.FromBase64String(encodedCreds)).Split(':');
        var username = creds[0];
        var password = creds[1];

        // Hier: Credentials prüfen (z. B. aus Konfiguration/Datenbank)
        if (username != "admin" || password != "geheim")
            return Task.FromResult(AuthenticateResult.Fail("Ungültige Anmeldedaten"));

        var claims = new[] { new Claim(ClaimTypes.Name, username) };
        var identity = new ClaimsIdentity(claims, Scheme.Name);
        var principal = new ClaimsPrincipal(identity);
        var ticket = new AuthenticationTicket(principal, Scheme.Name);

        return Task.FromResult(AuthenticateResult.Success(ticket));
    }
}
```

---

## **3. API als Systemd-Dienst einrichten (für 24/7-Betrieb)**
### **Service-Datei erstellen (`/etc/systemd/system/opensim-api.service`)**

Code:

```ini
[Unit]
Description=OpenSimulator Manager API
After=network.target

[Service]
Type=simple
User=opensim
WorkingDirectory=/home/opensim
ExecStart=/usr/bin/dotnet /pfad/zum/veröffentlichten/OpenSimManager.dll --urls "http://0.0.0.0:5000;https://0.0.0.0:5001"
Restart=always
RestartSec=10
Environment=ASPNETCORE_ENVIRONMENT=Production

[Install]
WantedBy=multi-user.target
```

### **Service aktivieren**

Code:

```bash
sudo systemctl daemon-reload
sudo systemctl enable opensim-api
sudo systemctl start opensim-api
```

---

## **4. PHP-Client für API-Aufrufe**
### **Beispiel-Skript (`opensim-control.php`)**

PHP-Code:

```php
<?php
function callOpenSimAPI($action) {
    $username = "admin";
    $password = "geheim";
    $apiUrl = "http://localhost:5000/api/opensim?action=" . urlencode($action);

    $options = [
        'http' => [
            'header' => "Authorization: Basic " . base64_encode("$username:$password"),
            'method' => 'GET',
            'ignore_errors' => true
        ]
    ];

    $context = stream_context_create($options);
    $response = file_get_contents($apiUrl, false, $context);
    return $response ?: "Fehler: API nicht erreichbar";
}

// Beispielaufruf
echo callOpenSimAPI("start"); // "stop", "restart", "status"
?>
``` 


---

## **5. Automatischer Restart alle 24 Stunden**
### **Cronjob einrichten**

Code:

```bash
crontab -e
```

Füge diese Zeile hinzu (führt täglich um 3 Uhr einen Restart aus):

Code:

```bash
0 3 * * * curl -u admin:geheim http://localhost:5000/api/opensim?action=restart
```

---

## **6. Sicherheitsmaßnahmen**
1. **HTTPS aktivieren** (Let’s Encrypt mit Nginx als Reverse Proxy).
2. **Firewall-Regeln**:

Code:

```bash
   sudo ufw allow 5000/tcp
   sudo ufw allow 5001/tcp
   ```

3. **Benutzerrechte**:

Code:

```bash
   sudo useradd opensim
   sudo chown -R opensim:opensim /home/opensim
   ```

---

## **Zusammenfassung**
| Komponente | Beschreibung |
|---------------------|-----------------------------------------------------------------------------|
| **C#-API** | Startet/Stoppt OpenSimulator direkt ohne `screen`. |
| **Systemd-Service** | Stellt sicher, dass die API immer läuft. |
| **PHP-Client** | Einfache Steuerung via HTTP. |
| **Cronjob** | Automatischer Restart alle 24 Stunden. |

**Fertig!** Ihre OpenSimulator-Instanz läuft nun stabil und kann über die API verwaltet werden. ?