API: Przykłady kodu

Kompletne przykłady użycia SGS Hub API w różnych językach programowania.

Konfiguracja klienta

JavaScript (Node.js + Axios)

// client.js
const axios = require('axios');

class SGSHubClient {
  constructor(apiKey) {
    this.client = axios.create({
      baseURL: 'https://sgshub.eu/api',
      headers: {
        'Authorization': `Bearer ${apiKey}`,
        'Content-Type': 'application/json'
      },
      timeout: 30000
    });

    // Interceptor dla rate limiting
    this.client.interceptors.response.use(
      response => response,
      error => {
        if (error.response?.status === 429) {
          const retryAfter = error.response.headers['retry-after'];
          console.error(`Rate limit hit. Retry after ${retryAfter}s`);
        }
        throw error;
      }
    );
  }

  async get(endpoint, params = {}) {
    const response = await this.client.get(endpoint, { params });
    return response.data;
  }

  async post(endpoint, data = {}) {
    const response = await this.client.post(endpoint, data);
    return response.data;
  }

  async patch(endpoint, data = {}) {
    const response = await this.client.patch(endpoint, data);
    return response.data;
  }

  async delete(endpoint) {
    const response = await this.client.delete(endpoint);
    return response.data;
  }
}

// Użycie
const client = new SGSHubClient(process.env.SGSHUB_API_KEY);
module.exports = client;

Python (Requests)

# client.py
import requests
import os
from typing import Dict, Any, Optional

class SGSHubClient:
    def __init__(self, api_key: str):
        self.base_url = 'https://sgshub.eu/api'
        self.headers = {
            'Authorization': f'Bearer {api_key}',
            'Content-Type': 'application/json'
        }
        self.session = requests.Session()
        self.session.headers.update(self.headers)

    def _handle_response(self, response: requests.Response) -> Dict[str, Any]:
        """Handle API response and errors"""
        if response.status_code == 429:
            retry_after = response.headers.get('Retry-After', 60)
            raise Exception(f'Rate limit hit. Retry after {retry_after}s')

        response.raise_for_status()
        return response.json()

    def get(self, endpoint: str, params: Optional[Dict] = None) -> Dict[str, Any]:
        response = self.session.get(f'{self.base_url}{endpoint}', params=params)
        return self._handle_response(response)

    def post(self, endpoint: str, data: Optional[Dict] = None) -> Dict[str, Any]:
        response = self.session.post(f'{self.base_url}{endpoint}', json=data)
        return self._handle_response(response)

    def patch(self, endpoint: str, data: Optional[Dict] = None) -> Dict[str, Any]:
        response = self.session.patch(f'{self.base_url}{endpoint}', json=data)
        return self._handle_response(response)

    def delete(self, endpoint: str) -> Dict[str, Any]:
        response = self.session.delete(f'{self.base_url}{endpoint}')
        return self._handle_response(response)

# Użycie
client = SGSHubClient(os.getenv('SGSHUB_API_KEY'))

Scenariusz 1: Pełna automatyzacja serwera

Utwórz serwer, zainstaluj mody, skonfiguruj backupy i harmonogramy.

JavaScript

const client = require('./client');

async function setupCompleteServer() {
  try {
    console.log('1. Tworzenie serwera ARK ASA...');
    const server = await client.post('/servers', {
      name: 'Automated PvP Server',
      game: 'ARK_ASA',
      map: 'TheIsland',
      maxPlayers: 70,
      region: 'EU',
      config: {
        rates: { xp: 3.0, taming: 5.0, harvesting: 3.0 },
        pvp: true,
        difficulty: 5.0
      }
    });

    const serverId = server.data.id;
    console.log(`✅ Serwer utworzony: ${serverId}`);

    console.log('\n2. Instalacja modów...');
    const mods = [
      { modId: '928990', name: 'Structures Plus' },
      { modId: '1404697612', name: 'Awesome Spyglass' }
    ];

    for (const [index, mod] of mods.entries()) {
      await client.post(`/servers/${serverId}/mods`, {
        modId: mod.modId,
        source: 'CURSEFORGE',
        order: index,
        autoUpdate: true
      });
      console.log(`✅ Mod zainstalowany: ${mod.name}`);
    }

    console.log('\n3. Konfiguracja automatycznych backupów...');
    await client.post(`/servers/${serverId}/schedules`, {
      name: 'Daily Backup',
      action: 'BACKUP',
      cronExpression: '0 3 * * *',
      enabled: true,
      config: {
        backupType: 'FULL',
        stopServer: true,
        retention: 7
      }
    });
    console.log('✅ Backup schedule utworzony');

    console.log('\n4. Konfiguracja auto-restartów...');
    await client.post(`/servers/${serverId}/schedules`, {
      name: 'Restart co 6h',
      action: 'RESTART',
      cronExpression: '0 */6 * * *',
      enabled: true,
      config: {
        broadcastWarning: true,
        warningMinutes: 5
      }
    });
    console.log('✅ Restart schedule utworzony');

    console.log('\n5. Uruchamianie serwera...');
    await client.post(`/servers/${serverId}/power`, {
      action: 'start'
    });
    console.log('✅ Serwer uruchamia się');

    console.log(`\n🎉 Setup zakończony! Serwer ID: ${serverId}`);

  } catch (error) {
    console.error('❌ Błąd:', error.response?.data || error.message);
  }
}

setupCompleteServer();

Python

import time
from client import client

def setup_complete_server():
    """Pełna automatyzacja serwera ARK"""
    try:
        print('1. Tworzenie serwera ARK ASA...')
        server = client.post('/servers', {
            'name': 'Automated PvP Server',
            'game': 'ARK_ASA',
            'map': 'TheIsland',
            'maxPlayers': 70,
            'region': 'EU',
            'config': {
                'rates': {'xp': 3.0, 'taming': 5.0, 'harvesting': 3.0},
                'pvp': True,
                'difficulty': 5.0
            }
        })

        server_id = server['data']['id']
        print(f'✅ Serwer utworzony: {server_id}')

        print('\n2. Instalacja modów...')
        mods = [
            {'modId': '928990', 'name': 'Structures Plus'},
            {'modId': '1404697612', 'name': 'Awesome Spyglass'}
        ]

        for index, mod in enumerate(mods):
            client.post(f'/servers/{server_id}/mods', {
                'modId': mod['modId'],
                'source': 'CURSEFORGE',
                'order': index,
                'autoUpdate': True
            })
            print(f'✅ Mod zainstalowany: {mod["name"]}')

        print('\n3. Konfiguracja automatycznych backupów...')
        client.post(f'/servers/{server_id}/schedules', {
            'name': 'Daily Backup',
            'action': 'BACKUP',
            'cronExpression': '0 3 * * *',
            'enabled': True,
            'config': {
                'backupType': 'FULL',
                'stopServer': True,
                'retention': 7
            }
        })
        print('✅ Backup schedule utworzony')

        print('\n4. Konfiguracja auto-restartów...')
        client.post(f'/servers/{server_id}/schedules', {
            'name': 'Restart co 6h',
            'action': 'RESTART',
            'cronExpression': '0 */6 * * *',
            'enabled': True,
            'config': {
                'broadcastWarning': True,
                'warningMinutes': 5
            }
        })
        print('✅ Restart schedule utworzony')

        print('\n5. Uruchamianie serwera...')
        client.post(f'/servers/{server_id}/power', {'action': 'start'})
        print('✅ Serwer uruchamia się')

        print(f'\n🎉 Setup zakończony! Serwer ID: {server_id}')

    except Exception as e:
        print(f'❌ Błąd: {e}')

if __name__ == '__main__':
    setup_complete_server()

Scenariusz 2: Monitorowanie i alerty

Monitoruj serwery i wysyłaj alerty Discord.

JavaScript

const client = require('./client');
const axios = require('axios');

const DISCORD_WEBHOOK = process.env.DISCORD_WEBHOOK_URL;

async function sendDiscordAlert(message, color = 'RED') {
  const colors = { RED: 15158332, YELLOW: 16776960, GREEN: 3066993 };

  await axios.post(DISCORD_WEBHOOK, {
    embeds: [{
      title: '🚨 SGS Hub Alert',
      description: message,
      color: colors[color],
      timestamp: new Date().toISOString()
    }]
  });
}

async function monitorServers() {
  try {
    const { data: servers } = await client.get('/servers');

    for (const server of servers) {
      // Sprawdź status
      const { data: status } = await client.get(`/servers/${server.id}/status`);

      // Alert: Serwer offline
      if (status.status !== 'RUNNING') {
        await sendDiscordAlert(
          `⚠️ Serwer **${server.name}** jest ${status.status}`,
          'YELLOW'
        );
      }

      // Alert: Wysokie użycie zasobów
      const memoryPercent = (status.resources.memory.used / status.resources.memory.limit) * 100;
      if (memoryPercent > 90) {
        await sendDiscordAlert(
          `🔥 Serwer **${server.name}** używa ${memoryPercent.toFixed(1)}% RAM!`,
          'RED'
        );
      }

      // Alert: Dysk pełny
      const diskPercent = (status.resources.disk.used / status.resources.disk.limit) * 100;
      if (diskPercent > 85) {
        await sendDiscordAlert(
          `💾 Serwer **${server.name}** ma zajętych ${diskPercent.toFixed(1)}% dysku`,
          'YELLOW'
        );
      }
    }

    console.log('✅ Monitoring completed');

  } catch (error) {
    await sendDiscordAlert(
      `❌ Błąd monitoringu: ${error.message}`,
      'RED'
    );
  }
}

// Uruchom co 5 minut
setInterval(monitorServers, 5 * 60 * 1000);
monitorServers(); // Pierwsze uruchomienie

Scenariusz 3: Backup i restore workflow

Bezpieczna aktualizacja z backupem i rollback.

Python

import time
from client import client

def safe_server_update(server_id: str):
    """Bezpieczna aktualizacja serwera z backupem"""
    backup_id = None

    try:
        print('1. Zatrzymywanie serwera...')
        client.post(f'/servers/{server_id}/power', {'action': 'stop'})
        time.sleep(30)  # Poczekaj na zatrzymanie

        print('2. Tworzenie backupu FULL...')
        backup = client.post(f'/servers/{server_id}/backups', {
            'name': f'Pre-Update Backup {time.strftime("%Y-%m-%d %H:%M")}',
            'type': 'FULL',
            'stopServer': False  # Już zatrzymany
        })

        backup_id = backup['data']['id']
        print(f'Backup ID: {backup_id}')

        # Poczekaj na ukończenie backupu
        print('Czekam na ukończenie backupu...')
        while True:
            backup_status = client.get(f'/servers/{server_id}/backups/{backup_id}')
            status = backup_status['data']['status']

            if status == 'COMPLETED':
                print('✅ Backup ukończony')
                break
            elif status == 'FAILED':
                raise Exception('Backup failed!')

            print(f'  Progress: {backup_status["data"].get("progress", 0):.1f}%')
            time.sleep(5)

        print('\n3. Wykonywanie aktualizacji...')
        # Tutaj wykonaj aktualizację (instalacja modów, zmiana konfiguracji, etc.)
        client.post(f'/servers/{server_id}/mods', {
            'modId': '928990',
            'source': 'CURSEFORGE'
        })
        print('✅ Aktualizacja wykonana')

        print('\n4. Uruchamianie serwera...')
        client.post(f'/servers/{server_id}/power', {'action': 'start'})
        time.sleep(60)  # Poczekaj na start

        # Sprawdź czy serwer działa
        server_status = client.get(f'/servers/{server_id}/status')
        if server_status['data']['status'] == 'RUNNING':
            print('✅ Serwer uruchomiony pomyślnie')
        else:
            raise Exception('Serwer nie uruchomił się poprawnie')

    except Exception as e:
        print(f'\n❌ Błąd podczas aktualizacji: {e}')
        print('Rozpoczynam rollback...')

        if backup_id:
            # Przywróć backup
            client.post(f'/servers/{server_id}/backups/{backup_id}/restore', {
                'stopServer': True,
                'restoreType': 'FULL'
            })
            print('⏳ Przywracanie backupu...')

            # Poczekaj na restore
            time.sleep(120)
            print('✅ Backup przywrócony. Serwer powinien być w stanie sprzed aktualizacji.')
        else:
            print('❌ Brak backupu do przywrócenia!')

if __name__ == '__main__':
    safe_server_update('srv_xyz789')

Scenariusz 4: Masowe operacje

Wykonaj operację na wielu serwerach równolegle.

JavaScript (async/await + Promise.all)

const client = require('./client');

async function bulkServerOperation(operation) {
  try {
    // Pobierz wszystkie serwery
    const { data: servers } = await client.get('/servers');
    console.log(`Znaleziono ${servers.length} serwerów\n`);

    // Wykonaj operację na wszystkich równolegle
    const results = await Promise.allSettled(
      servers.map(server => operation(server))
    );

    // Podsumowanie
    const succeeded = results.filter(r => r.status === 'fulfilled').length;
    const failed = results.filter(r => r.status === 'rejected').length;

    console.log(`\n✅ Sukces: ${succeeded}`);
    console.log(`❌ Błędy: ${failed}`);

    return results;

  } catch (error) {
    console.error('❌ Błąd:', error.message);
  }
}

// Przykład: Restart wszystkich serwerów
async function restartAllServers() {
  await bulkServerOperation(async (server) => {
    console.log(`Restartuję: ${server.name}`);
    await client.post(`/servers/${server.id}/power`, {
      action: 'restart'
    });
  });
}

// Przykład: Backup wszystkich serwerów
async function backupAllServers() {
  await bulkServerOperation(async (server) => {
    console.log(`Tworzę backup: ${server.name}`);
    await client.post(`/servers/${server.id}/backups`, {
      name: `Auto Backup ${new Date().toISOString().split('T')[0]}`,
      type: 'FULL',
      stopServer: false
    });
  });
}

// Uruchom
restartAllServers();

Powiązane strony

• API: Wprowadzenie - podstawy API
• API: Uwierzytelnianie - klucze API
• API: Serwery - dokumentacja endpoints