Servidor de detención seguro para el entorno de prueba de PlayReady

Información general

PlayReady Secure Stop Server proporciona un punto de conexión de prueba para validar la funcionalidad de detención segura en implementaciones de PlayReady. Secure Stop garantiza que los datos de seguimiento del consumo multimedia se transmitan de forma segura desde clientes a proveedores de contenido, lo que permite la supervisión precisa del uso y los informes de cumplimiento.

Punto de conexión del servicio

El servidor de prueba de detención segura está disponible en:

https://playready.directtaps.net/pr/svc/securestop.asmx

Protocolo de detención segura

Información general sobre el protocolo

Secure Stop permite a los clientes notificar la información de finalización de la sesión de forma segura:

1. El cliente comienza la sesión de reproducción
2. La licencia especifica los requisitos de detención seguros
3. El cliente genera datos de detención seguros durante la reproducción
4. Al final de la sesión, el cliente envía un informe de detención seguro al servidor.
5. El servidor valida y confirma la recepción

Flujo de mensajes

Client                    License Server           Secure Stop Server
  |                            |                           |
  |-- License Request -------->|                           |
  |<-- License Response -------|                           |
  |    (with SecureStop URL)   |                           |
  |                            |                           |
  |    [Playback Session]      |                           |
  |                            |                           |
  |-- Secure Stop Report ------|-------------------------->|
  |<-- Acknowledgment ---------|---------------------------|

Configuración del servidor

Requisitos de detención segura

Configure la detención segura en las respuestas de licencia:

{
  "licenseType": "persistent",
  "keyId": "key-id-guid",
  "secureStop": {
    "required": true,
    "serverUrl": "https://playready.directtaps.net/pr/svc/securestop.asmx",
    "reportingFrequency": "session-end",
    "customData": {
      "sessionId": "unique-session-identifier",
      "contentId": "content-identifier"
    }
  }
}

Configuración de respuesta del servidor

El servidor admite varios modos de respuesta para las pruebas:

{
  "responseMode": "success|failure|timeout|partial",
  "acknowledgmentDelay": 0,
  "customData": {
    "testScenario": "normal-operation"
  }
}

Puntos de conexión de API

Enviar informe de detención seguro

Punto final:POST /pr/svc/securestop.asmx/SubmitReport

Formato de solicitud:

POST /pr/svc/securestop.asmx/SubmitReport HTTP/1.1
Host: playready.directtaps.net
Content-Type: application/octet-stream

[Secure Stop Report Data - Binary Format]

Formato de respuesta:

HTTP/1.1 200 OK
Content-Type: application/octet-stream

[Secure Stop Acknowledgment - Binary Format]

Estado del informe de consulta

Punto final:GET /pr/svc/securestop.asmx/QueryStatus

Formato de solicitud:

GET /pr/svc/securestop.asmx/QueryStatus?sessionId=SESSION_ID HTTP/1.1
Host: playready.directtaps.net

Formato de respuesta:

{
  "sessionId": "session-identifier",
  "status": "pending|received|processed|error",
  "timestamp": "2024-01-15T10:30:00Z",
  "reportSize": 1024,
  "processingTime": 50
}

Escenarios de prueba

Pruebas básicas de detención segura

Pruebe el flujo de detención seguro normal:

async function testBasicSecureStop() {
    // 1. Acquire license with secure stop requirement
    const license = await acquireLicense({
        keyId: 'test-key-id',
        secureStopRequired: true,
        secureStopUrl: 'https://playready.directtaps.net/pr/svc/securestop.asmx'
    });
    
    // 2. Simulate playback session
    const session = await startPlaybackSession(license);
    
    // 3. End session and generate secure stop report
    const secureStopReport = await endSessionWithSecureStop(session);
    
    // 4. Submit secure stop report
    const response = await submitSecureStopReport(secureStopReport);
    
    return response.acknowledged;
}

Pruebas de control de errores

Escenarios de error de prueba:

async function testSecureStopErrorHandling() {
    const testCases = [
        {
            name: 'Invalid Report Format',
            data: generateInvalidReport(),
            expectedError: 'INVALID_FORMAT'
        },
        {
            name: 'Expired Session',
            data: generateExpiredSessionReport(),
            expectedError: 'SESSION_EXPIRED'
        },
        {
            name: 'Duplicate Report',
            data: generateDuplicateReport(),
            expectedError: 'DUPLICATE_REPORT'
        }
    ];
    
    const results = [];
    for (const testCase of testCases) {
        try {
            await submitSecureStopReport(testCase.data);
            results.push({ test: testCase.name, result: 'UNEXPECTED_SUCCESS' });
        } catch (error) {
            results.push({ 
                test: testCase.name, 
                result: error.code === testCase.expectedError ? 'PASS' : 'FAIL' 
            });
        }
    }
    
    return results;
}

Pruebas de rendimiento

Probar el rendimiento de detención segura:

async function testSecureStopPerformance() {
    const concurrentReports = 10;
    const reports = [];
    
    // Generate multiple secure stop reports
    for (let i = 0; i < concurrentReports; i++) {
        reports.push(generateSecureStopReport(`session-${i}`));
    }
    
    // Submit reports concurrently
    const startTime = Date.now();
    const promises = reports.map(report => submitSecureStopReport(report));
    const results = await Promise.allSettled(promises);
    const endTime = Date.now();
    
    return {
        totalTime: endTime - startTime,
        averageTime: (endTime - startTime) / concurrentReports,
        successCount: results.filter(r => r.status === 'fulfilled').length,
        errorCount: results.filter(r => r.status === 'rejected').length
    };
}

Integración de clientes

Implementación de JavaScript

class SecureStopClient {
    constructor(serverUrl) {
        this.serverUrl = serverUrl;
    }
    
    async submitReport(secureStopData) {
        const response = await fetch(`${this.serverUrl}/SubmitReport`, {
            method: 'POST',
            headers: {
                'Content-Type': 'application/octet-stream'
            },
            body: secureStopData
        });
        
        if (!response.ok) {
            throw new Error(`Secure stop submission failed: ${response.status}`);
        }
        
        return await response.arrayBuffer();
    }
    
    async queryStatus(sessionId) {
        const response = await fetch(`${this.serverUrl}/QueryStatus?sessionId=${sessionId}`);
        
        if (!response.ok) {
            throw new Error(`Status query failed: ${response.status}`);
        }
        
        return await response.json();
    }
}

// Usage
const secureStopClient = new SecureStopClient('https://playready.directtaps.net/pr/svc/securestop.asmx');

Implementación de C#

public class SecureStopClient
{
    private readonly HttpClient httpClient;
    private readonly string serverUrl;
    
    public SecureStopClient(string serverUrl)
    {
        this.serverUrl = serverUrl;
        this.httpClient = new HttpClient();
    }
    
    public async Task<byte[]> SubmitReportAsync(byte[] secureStopData)
    {
        var content = new ByteArrayContent(secureStopData);
        content.Headers.ContentType = new MediaTypeHeaderValue("application/octet-stream");
        
        var response = await httpClient.PostAsync($"{serverUrl}/SubmitReport", content);
        response.EnsureSuccessStatusCode();
        
        return await response.Content.ReadAsByteArrayAsync();
    }
    
    public async Task<SecureStopStatus> QueryStatusAsync(string sessionId)
    {
        var response = await httpClient.GetAsync($"{serverUrl}/QueryStatus?sessionId={sessionId}");
        response.EnsureSuccessStatusCode();
        
        var json = await response.Content.ReadAsStringAsync();
        return JsonConvert.DeserializeObject<SecureStopStatus>(json);
    }
}

Formato de datos

Estructura de informe de detención segura

El informe de detención segura contiene:

• Identificador de sesión: identificador de sesión único
• Identificador de contenido: contenido que se consume
• Datos de uso: duración de la reproducción, calidad, etc.
• Información del dispositivo: detalles del dispositivo cliente
• Información de marca de tiempo: horas de inicio y finalización de la sesión
• Firma digital: prueba criptográfica de autenticidad

Validación de informes

El servidor valida los informes para:

• Integridad de formato: estructura binaria correcta
• Firma digital: autenticidad criptográfica
• Validez de la sesión: parámetros de sesión válidos
• Precisión de marca de tiempo: valores de tiempo razonables
• Detección de duplicados: prevención de envíos duplicados

Características avanzadas

Compatibilidad con datos personalizados

Incluya datos personalizados en informes de detención seguros:

{
  "customData": {
    "contentProvider": "test-provider",
    "userAgent": "PlayReady-Client/4.0",
    "playbackQuality": "HD",
    "geolocation": "US-WEST"
  }
}

Informes por lotes

Enviar varios informes de detención segura en una sola solicitud:

async function submitBatchReports(reports) {
    const batchData = {
        reports: reports,
        batchId: generateBatchId(),
        timestamp: new Date().toISOString()
    };
    
    const response = await fetch(`${serverUrl}/SubmitBatch`, {
        method: 'POST',
        headers: {
            'Content-Type': 'application/json'
        },
        body: JSON.stringify(batchData)
    });
    
    return await response.json();
}

Supervisión y análisis

Análisis de informes

El servidor de prueba proporciona puntos de conexión de análisis:

GET /pr/svc/securestop.asmx/Analytics?period=24h

La respuesta incluye:

• Total de informes recibidos
• Tiempo medio de procesamiento
• Tasas de error por tipo
• Distribución geográfica
• Estadísticas de la versión del cliente

Monitoreo de la salud

Supervisar el estado del servidor:

async function checkSecureStopServerHealth() {
    const response = await fetch('https://playready.directtaps.net/pr/svc/securestop.asmx/Health');
    return await response.json();
}

Procedimientos recomendados

Implementación de cliente

1. Entrega confiable: implementación de la lógica de reintento para envíos con errores
2. Soporte técnico sin conexión: los informes de cola cuando la red no está disponible
3. Validación de datos: validar los datos del informe antes del envío
4. Control de errores: control de errores del servidor correctamente
5. Privacidad: protección de datos confidenciales en informes

Recomendaciones de pruebas

1. Escenarios completos: Probar condiciones normales y de error
2. Pruebas de rendimiento: validación en condiciones de carga
3. Condiciones de red: prueba con varios escenarios de red
4. Integridad de datos: comprobar la precisión de los datos del informe
5. Pruebas de seguridad: validación de componentes criptográficos

Documentación relacionada

• Servicio de servidor de prueba de PlayReady : información general sobre el servicio principal
• Servidor de eliminación segura: funcionalidad segura relacionada
• Servidores con versiones: información de versión del servidor
• Servidores de prueba de PlayReady : documentación completa del servidor

Soporte técnico y solución de problemas

Para problemas con la funcionalidad de detención segura:

1. Comprobación de que la detención segura está habilitada en la licencia
2. Comprobar el formato y la estructura del informe
3. Validación de la conectividad de red con el servidor
4. Revisión de la respuesta del servidor para obtener detalles del error
5. Prueba con escenarios simplificados primero

Problemas comunes:

• Errores de formato de informe: formato binario o estructura no válidos
• Validación de firmas: problemas de firma criptográfica
• Tiempos de espera de red: problemas de conectividad del servidor
• Expiración de la sesión: los informes enviados demasiado tarde

Para obtener soporte adicional, consulte la documentación principal de los servidores de prueba de PlayReady .