FileCatalyst integration guide

import com.filecatalyst.client.*;

public class FileTransferService {
    private FileCatalystClient client;
    
    public void initializeClient(String host, String user, String pass) {
        try {
            client = new FileCatalystClient();
            client.setConnectionTimeout(30000);
            client.setTransferMode(TransferMode.UDP);
            client.connect(host, 21, user, pass);
            
            // Configure transfer settings
            client.setCompression(true);
            client.setBandwidth(1000000); // 1 Gbps
            client.setRetryAttempts(3);
            
        } catch (FCException e) {
            logger.error("Connection failed: " + e.getMessage());
            throw new RuntimeException(e);
        }
    }
    
    public String uploadLargeFile(String localPath, String remotePath) {
        try {
            // Start transfer with progress monitoring
            TransferMonitor monitor = client.uploadFileWithMonitor(
                localPath, 
                remotePath,
                new ProgressListener() {
                    @Override
                    public void progressUpdate(long bytes, long total) {
                        double percent = (bytes * 100.0) / total;
                        logger.info(String.format("Progress: %.2f%%", percent));
                    }
                }
            );
            
            // Wait for completion
            monitor.waitForCompletion();
            
            // Verify integrity
            if (client.verifyChecksum(localPath, remotePath)) {
                return monitor.getTransferId();
            } else {
                throw new RuntimeException("Checksum verification failed");
            }
            
        } catch (Exception e) {
            logger.error("Transfer failed: " + e.getMessage());
            throw new RuntimeException(e);
        }
    }
}

import requests
import json
from typing import Dict, Optional

class FileCatalystAPI:
    def __init__(self, base_url: str, api_key: str):
        self.base_url = base_url
        self.headers = {
            'Authorization': f'Bearer {api_key}',
            'Content-Type': 'application/json'
        }
        self.session = requests.Session()
        self.session.headers.update(self.headers)
    
    def create_transfer_job(self, 
                           source: str, 
                           destination: str,
                           options: Optional[Dict] = None) -> str:
        """Create a new transfer job with FileCatalyst"""
        
        payload = {
            'source': source,
            'destination': destination,
            'options': options or {
                'compression': True,
                'encryption': 'AES256',
                'priority': 'high',
                'bandwidth_limit': 5000000,  # 5 Gbps
                'retry_on_failure': True,
                'delta_transfer': True
            }
        }
        
        response = self.session.post(
            f'{self.base_url}/api/v2/transfers',
            json=payload
        )
        response.raise_for_status()
        
        job_data = response.json()
        return job_data['job_id']
    
    def monitor_transfer(self, job_id: str) -> Dict:
        """Get real-time transfer status"""
        
        response = self.session.get(
            f'{self.base_url}/api/v2/transfers/{job_id}/status'
        )
        response.raise_for_status()
        
        return response.json()
    
    def get_transfer_metrics(self, job_id: str) -> Dict:
        """Get detailed transfer performance metrics"""
        
        response = self.session.get(
            f'{self.base_url}/api/v2/transfers/{job_id}/metrics'
        )
        response.raise_for_status()
        
        metrics = response.json()
        return {
            'average_speed': metrics['avg_speed_mbps'],
            'peak_speed': metrics['peak_speed_mbps'],
            'packet_loss': metrics['packet_loss_percent'],
            'compression_ratio': metrics['compression_ratio'],
            'time_elapsed': metrics['duration_seconds']
        }

# Usage example
if __name__ == '__main__':
    fc_api = FileCatalystAPI(
        base_url='https://transfer.company.com',
        api_key='your-api-key-here'
    )
    
    # Start large file transfer
    job_id = fc_api.create_transfer_job(
        source='/data/exports/dataset_100GB.tar',
        destination='s3://bucket/incoming/'
    )
    
    # Monitor progress
    import time
    while True:
        status = fc_api.monitor_transfer(job_id)
        print(f"Progress: {status['percent_complete']}%")
        print(f"Speed: {status['current_speed_mbps']} Mbps")
        
        if status['state'] == 'completed':
            metrics = fc_api.get_transfer_metrics(job_id)
            print(f"Transfer completed!")
            print(f"Average speed: {metrics['average_speed']} Mbps")
            break
        
        time.sleep(5)

# FileCatalyst PowerShell Module
Import-Module FileCatalyst

# Configure connection
$fcConfig = @{
    Server = "transfer.company.com"
    Port = 21
    Username = $env:FC_USERNAME
    Password = $env:FC_PASSWORD
    UseTLS = $true
}

# Connect to FileCatalyst
$session = New-FCSession @fcConfig

# Set transfer options
$transferOptions = @{
    Compression = $true
    Encryption = "AES256"
    BandwidthLimit = 5000  # Mbps
    Priority = "High"
    VerifyChecksum = $true
    DeltaTransfer = $true
    EmailNotification = "[email protected]"
}

# Upload large dataset with progress
$job = Start-FCUpload -Session $session `
    -LocalPath "D:\\Exports\\LargeDataset\\" `
    -RemotePath "/production/incoming/" `
    -Options $transferOptions `
    -Recursive `
    -AsJob

# Monitor transfer progress
while ($job.State -eq "Running") {
    $progress = Get-FCJobProgress -JobId $job.Id
    Write-Progress -Activity "Uploading Files" `
        -Status "$($progress.FilesTransferred) of $($progress.TotalFiles) files" `
        -PercentComplete $progress.PercentComplete
    
    Start-Sleep -Seconds 2
}

# Generate transfer report
$report = Get-FCTransferReport -JobId $job.Id
$report | Export-Csv -Path "transfer_report.csv" -NoTypeInformation

Write-Host "Transfer completed successfully!"
Write-Host "Total time: $($report.Duration)"
Write-Host "Average speed: $($report.AverageSpeed) Mbps"
Write-Host "Files transferred: $($report.FilesTransferred)"