API Code Examples

async function checkWalletBalance() {
  const response = await fetch('https://api.oceanlinux.com/v1/wallet', {
    method: 'GET',
    headers: {
      'Authorization': 'Bearer ' + process.env.OCEANLINUX_API_KEY,
      'Content-Type': 'application/json'
    }
  });

  if (!response.ok) {
    throw new Error(`HTTP error! status: ${response.status}`);
  }

  const data = await response.json();

  console.log(`Current Balance: ₹${data.balance}`);
  console.log(`Total Credits: ₹${data.totalCredits}`);
  console.log(`Total Debits: ₹${data.totalDebits}`);

  // Check if balance is low
  if (data.balance < 1000) {
    console.warn('Warning: Low wallet balance!');
  }

  return data;
}

// Usage
checkWalletBalance().catch(console.error);

import requests
import os
from datetime import datetime

def check_wallet_balance():
    """Check wallet balance with comprehensive error handling"""

    api_key = os.getenv('OCEANLINUX_API_KEY')
    if not api_key:
        raise ValueError("API key not found in environment variables")

    headers = {
        'Authorization': f'Bearer {api_key}',
        'Content-Type': 'application/json'
    }

    try:
        response = requests.get(
            'https://api.oceanlinux.com/v1/wallet',
            headers=headers,
            timeout=30
        )
        response.raise_for_status()

        data = response.json()

        # Log balance information
        print(f"[{datetime.now()}] Current Balance: ₹{data['balance']}")
        print(f"Total Credits: ₹{data['totalCredits']}")
        print(f"Total Debits: ₹{data['totalDebits']}")

        # Recent transactions
        if data.get('transactions'):
            print("\nRecent Transactions:")
            for txn in data['transactions'][:5]:
                print(f"  {txn['type'].upper()}: ₹{txn['amount']} - {txn['description']}")

        # Balance alerts
        balance = data['balance']
        if balance < 500:
            print("⚠️  CRITICAL: Wallet balance very low!")
        elif balance < 1000:
            print("⚠️  WARNING: Wallet balance is low")
        else:
            print("✅ Wallet balance is healthy")

        return data

    except requests.exceptions.RequestException as e:
        print(f"Error checking wallet balance: {e}")
        raise
    except KeyError as e:
        print(f"Unexpected response format: {e}")
        raise

if __name__ == "__main__":
    check_wallet_balance()

import requests
import time
from typing import Dict, List, Optional

class ServerManager:
    def __init__(self, api_key: str):
        self.api_key = api_key
        self.base_url = 'https://api.oceanlinux.com/v1'
        self.headers = {
            'Authorization': f'Bearer {api_key}',
            'Content-Type': 'application/json'
        }

    def get_available_servers(self, filters: Dict = None) -> List[Dict]:
        """Get list of available servers with optional filters"""
        params = {}
        if filters:
            if 'location' in filters:
                params['location'] = filters['location']
            if 'min_ram' in filters:
                params['min_ram'] = filters['min_ram']
            if 'max_price' in filters:
                params['max_price'] = filters['max_price']

        response = requests.get(
            f'{self.base_url}/servers',
            headers=self.headers,
            params=params
        )
        response.raise_for_status()
        return response.json().get('servers', [])

    def calculate_total_cost(self, server: Dict, duration: int) -> Dict:
        """Calculate total cost with discounts"""
        base_cost = server['price'] * duration
        discount = 0

        if duration >= 12:
            discount = base_cost * 0.15  # 15% yearly discount
        elif duration >= 6:
            discount = base_cost * 0.10  # 10% semi-annual discount
        elif duration >= 3:
            discount = base_cost * 0.05  # 5% quarterly discount

        return {
            'base_cost': base_cost,
            'discount': discount,
            'final_cost': base_cost - discount,
            'savings': discount
        }

    def check_wallet_balance(self) -> Dict:
        """Check current wallet balance"""
        response = requests.get(f'{self.base_url}/wallet', headers=self.headers)
        response.raise_for_status()
        return response.json()

    def find_best_server(self, requirements: Dict) -> Optional[Dict]:
        """Find the best server based on requirements"""
        servers = self.get_available_servers()

        # Filter servers based on requirements
        suitable_servers = []

        for server in servers:
            if not server.get('available'):
                continue

            # Check RAM requirement
            if requirements.get('min_ram'):
                server_ram = int(server['specs']['ram'].replace('GB', ''))
                if server_ram < requirements['min_ram']:
                    continue

            # Check location preference
            if requirements.get('preferred_locations'):
                if server['location'] not in requirements['preferred_locations']:
                    continue

            # Check budget
            if requirements.get('max_budget'):
                cost_info = self.calculate_total_cost(server, requirements.get('duration', 1))
                if cost_info['final_cost'] > requirements['max_budget']:
                    continue

            suitable_servers.append(server)

        if not suitable_servers:
            return None

        # Sort by price (ascending) or other criteria
        sort_by = requirements.get('sort_by', 'price')
        if sort_by == 'price':
            suitable_servers.sort(key=lambda x: x['price'])
        elif sort_by == 'ram':
            suitable_servers.sort(key=lambda x: int(x['specs']['ram'].replace('GB', '')), reverse=True)

        return suitable_servers[0]

    def purchase_server_smart(self, requirements: Dict) -> Dict:
        """Smart server purchase with validation and optimization"""

        print("🔍 Finding the best server for your requirements...")

        # Find best server
        best_server = self.find_best_server(requirements)
        if not best_server:
            raise Exception("No suitable servers found matching your requirements")

        duration = requirements.get('duration', 1)
        cost_info = self.calculate_total_cost(best_server, duration)

        print(f"✅ Found suitable server: {best_server['location']} - {best_server['specs']['ram']} RAM")
        print(f"💰 Cost breakdown:")
        print(f"   Base cost: ₹{cost_info['base_cost']}")
        if cost_info['discount'] > 0:
            print(f"   Discount: -₹{cost_info['discount']}")
        print(f"   Final cost: ₹{cost_info['final_cost']}")

        # Check wallet balance
        wallet = self.check_wallet_balance()
        if wallet['balance'] < cost_info['final_cost']:
            raise Exception(
                f"Insufficient wallet balance. Required: ₹{cost_info['final_cost']}, "
                f"Available: ₹{wallet['balance']}"
            )

        print(f"💳 Wallet balance: ₹{wallet['balance']} (sufficient)")

        # Confirm purchase
        if requirements.get('auto_confirm', False):
            confirm = True
        else:
            confirm = input("\nProceed with purchase? (y/N): ").lower() == 'y'

        if not confirm:
            print("❌ Purchase cancelled by user")
            return {'status': 'cancelled'}

        # Make purchase
        purchase_data = {
            'serverId': best_server['_id'],
            'duration': duration,
            'specifications': requirements.get('specifications', {})
        }

        print("🚀 Processing purchase...")

        response = requests.post(
            f'{self.base_url}/servers/purchase',
            headers=self.headers,
            json=purchase_data
        )

        if response.status_code == 200:
            result = response.json()
            print("✅ Server purchased successfully!")
            print(f"🖥️  Server IP: {result['order']['server']['ip']}")
            print(f"📍 Location: {result['order']['server']['location']}")
            print(f"⏱️  Deployment: {result['order']['estimatedDeployment']}")
            return result
        else:
            error_data = response.json()
            raise Exception(f"Purchase failed: {error_data.get('error', 'Unknown error')}")

# Usage example
if __name__ == "__main__":
    api_key = "your_api_key_here"
    manager = ServerManager(api_key)

    # Define requirements
    requirements = {
        'min_ram': 8,  # Minimum 8GB RAM
        'duration': 6,  # 6 months
        'preferred_locations': ['Mumbai', 'Bangalore'],
        'max_budget': 8000,  # Maximum ₹8000
        'sort_by': 'price',  # Sort by price
        'specifications': {
            'os': 'Ubuntu 22.04',
            'hostname': 'my-production-server'
        },
        'auto_confirm': False  # Ask for confirmation
    }

    try:
        result = manager.purchase_server_smart(requirements)
        print(f"\n🎉 Purchase completed: {result}")
    except Exception as e:
        print(f"❌ Error: {e}")

const WebSocket = require('ws');
const axios = require('axios');
const EventEmitter = require('events');

class ServerMonitoringDashboard extends EventEmitter {
    constructor(apiKey) {
        super();
        this.apiKey = apiKey;
        this.baseUrl = 'https://api.oceanlinux.com/v1';
        this.headers = {
            'Authorization': `Bearer ${apiKey}`,
            'Content-Type': 'application/json'
        };
        this.servers = new Map();
        this.monitoringInterval = null;
    }

    async getMyServers() {
        try {
            const response = await axios.get(`${this.baseUrl}/servers/my-servers`, {
                headers: this.headers
            });
            return response.data.servers;
        } catch (error) {
            console.error('Failed to fetch servers:', error.message);
            return [];
        }
    }

    async getServerMetrics(serverId) {
        try {
            const response = await axios.get(
                `${this.baseUrl}/servers/${serverId}/metrics`,
                { headers: this.headers }
            );
            return response.data;
        } catch (error) {
            console.error(`Failed to fetch metrics for ${serverId}:`, error.message);
            return null;
        }
    }

    calculateHealthScore(metrics) {
        let score = 100;

        // Deduct points for high resource usage
        if (metrics.cpu_usage > 90) score -= 30;
        else if (metrics.cpu_usage > 80) score -= 20;
        else if (metrics.cpu_usage > 70) score -= 10;

        if (metrics.memory_usage > 90) score -= 30;
        else if (metrics.memory_usage > 80) score -= 20;
        else if (metrics.memory_usage > 70) score -= 10;

        if (metrics.disk_usage > 95) score -= 40;
        else if (metrics.disk_usage > 85) score -= 20;
        else if (metrics.disk_usage > 75) score -= 10;

        // Check network connectivity
        if (metrics.network_latency > 200) score -= 15;
        else if (metrics.network_latency > 100) score -= 10;

        return Math.max(0, score);
    }

    async updateServerMetrics() {
        const servers = await this.getMyServers();
        const updates = [];

        for (const server of servers) {
            const metrics = await this.getServerMetrics(server._id);

            if (metrics) {
                const previousData = this.servers.get(server._id) || {};
                const healthScore = this.calculateHealthScore(metrics);

                const serverData = {
                    ...server,
                    metrics,
                    healthScore,
                    status: healthScore > 80 ? 'healthy' : healthScore > 60 ? 'warning' : 'critical',
                    lastUpdated: new Date().toISOString()
                };

                this.servers.set(server._id, serverData);

                // Check for significant changes
                const previousScore = previousData.healthScore || 100;
                const scoreDiff = Math.abs(healthScore - previousScore);

                if (scoreDiff > 20) {
                    this.emit('healthScoreChange', {
                        server: serverData,
                        previousScore,
                        currentScore: healthScore,
                        change: healthScore - previousScore
                    });
                }

                // Check for threshold breaches
                if (metrics.cpu_usage > 90 && !previousData.highCpuAlert) {
                    this.emit('alert', {
                        type: 'high_cpu',
                        server: serverData,
                        value: metrics.cpu_usage,
                        threshold: 90
                    });
                    serverData.highCpuAlert = true;
                }

                if (metrics.memory_usage > 85 && !previousData.highMemoryAlert) {
                    this.emit('alert', {
                        type: 'high_memory',
                        server: serverData,
                        value: metrics.memory_usage,
                        threshold: 85
                    });
                    serverData.highMemoryAlert = true;
                }

                updates.push(serverData);
            }
        }

        return updates;
    }

    startMonitoring(interval = 30000) {
        console.log('🚀 Starting real-time server monitoring...');

        // Initial load
        this.updateServerMetrics();

        // Set up periodic updates
        this.monitoringInterval = setInterval(async () => {
            try {
                const updates = await this.updateServerMetrics();
                this.emit('metricsUpdate', updates);
            } catch (error) {
                console.error('Monitoring update failed:', error.message);
                this.emit('error', error);
            }
        }, interval);

        return this;
    }

    stopMonitoring() {
        if (this.monitoringInterval) {
            clearInterval(this.monitoringInterval);
            this.monitoringInterval = null;
            console.log('⏹️  Server monitoring stopped');
        }
    }

    getDashboardData() {
        const servers = Array.from(this.servers.values());

        return {
            summary: {
                total: servers.length,
                healthy: servers.filter(s => s.status === 'healthy').length,
                warning: servers.filter(s => s.status === 'warning').length,
                critical: servers.filter(s => s.status === 'critical').length,
                averageHealthScore: servers.length > 0
                    ? Math.round(servers.reduce((sum, s) => sum + s.healthScore, 0) / servers.length)
                    : 0
            },
            servers: servers.sort((a, b) => {
                // Sort by health score (worst first)
                return a.healthScore - b.healthScore;
            }),
            lastUpdated: new Date().toISOString()
        };
    }

    printDashboard() {
        const data = this.getDashboardData();

        console.clear();
        console.log('\n🖥️  OceanLinux Server Dashboard');
        console.log('═'.repeat(50));

        // Summary
        console.log(`📊 Summary: ${data.summary.total} servers | ${data.summary.healthy} healthy | ${data.summary.warning} warnings | ${data.summary.critical} critical`);
        console.log(`🏥 Average Health Score: ${data.summary.averageHealthScore}%\n`);

        // Server details
        data.servers.forEach(server => {
            const statusIcon = server.status === 'healthy' ? '✅' :
                              server.status === 'warning' ? '⚠️' : '❌';

            console.log(`${statusIcon} ${server.ip} (${server.location}) - Health: ${server.healthScore}%`);
            console.log(`   CPU: ${server.metrics.cpu_usage}% | RAM: ${server.metrics.memory_usage}% | Disk: ${server.metrics.disk_usage}%`);
            console.log(`   Uptime: ${Math.round(server.metrics.uptime / 3600)}h | Load: ${server.metrics.load_average}\n`);
        });

        console.log(`Last updated: ${new Date(data.lastUpdated).toLocaleTimeString()}`);
    }
}

// Usage example
const monitor = new ServerMonitoringDashboard('your_api_key_here');

// Set up event listeners
monitor.on('alert', (alertData) => {
    console.log(`🚨 ALERT: ${alertData.type.toUpperCase()} on ${alertData.server.ip}`);
    console.log(`   Value: ${alertData.value}% | Threshold: ${alertData.threshold}%`);

    // Here you could send notifications, emails, Slack messages, etc.
});

monitor.on('healthScoreChange', (changeData) => {
    const trend = changeData.change > 0 ? '📈' : '📉';
    console.log(`${trend} Health score change for ${changeData.server.ip}:`);
    console.log(`   ${changeData.previousScore}% → ${changeData.currentScore}% (${changeData.change > 0 ? '+' : ''}${changeData.change})`);
});

monitor.on('metricsUpdate', (updates) => {
    monitor.printDashboard();
});

monitor.on('error', (error) => {
    console.error('❌ Monitoring error:', error.message);
});

// Start monitoring with 30-second intervals
monitor.startMonitoring(30000);

// Graceful shutdown
process.on('SIGINT', () => {
    console.log('\n⏹️  Shutting down monitoring...');
    monitor.stopMonitoring();
    process.exit(0);
});