from rpycbench.core.benchmark import BenchmarkContext
from rpycbench.servers.rpyc_servers import RPyCServer, create_rpyc_connection

# Start server
with RPyCServer(host='localhost', port=18812, mode='threaded'):
    # Create benchmark context
    with BenchmarkContext(
        name="My Operation",
        protocol="rpyc",
        measure_latency=True,
    ) as bench:
        conn = create_rpyc_connection('localhost', 18812)

        # Measure your operations
        for i in range(100):
            with bench.measure_request():
                result = conn.root.ping()
                bench.record_request(success=True)

        conn.close()

    # Get results
    metrics = bench.get_results()
    stats = metrics.compute_statistics()
    print(f"Average latency: {stats['latency']['mean']*1000:.2f}ms")
    print(f"P95 latency: {stats['latency']['p95']*1000:.2f}ms")

"""
Synthetic Application Example: Remote Data Processing Service

This demonstrates a realistic application with:
- Data validation
- Remote computation
- Error handling
- Performance measurement
"""

import rpyc
from rpycbench.core.benchmark import BenchmarkContext
from rpycbench.servers.rpyc_servers import RPyCServer, create_rpyc_connection


# Define your RPyC service (your application logic)
class DataProcessingService(rpyc.Service):
    """Example remote data processing service"""

    def exposed_validate_data(self, data):
        """Validate input data"""
        if not isinstance(data, dict):
            raise ValueError("Data must be a dictionary")
        if 'values' not in data:
            raise ValueError("Data must contain 'values' key")
        return True

    def exposed_compute_statistics(self, data):
        """Compute statistics on data"""
        values = data['values']
        return {
            'mean': sum(values) / len(values),
            'min': min(values),
            'max': max(values),
            'count': len(values),
        }

    def exposed_process_batch(self, batch):
        """Process a batch of data items"""
        results = []
        for item in batch:
            # Simulate processing
            processed = {
                'id': item['id'],
                'result': item['value'] * 2,
                'status': 'processed'
            }
            results.append(processed)
        return results

    def exposed_store_results(self, results):
        """Store processing results"""
        # Simulate storage
        return {'stored': len(results), 'status': 'success'}


# Your application client
class DataProcessingClient:
    """Client for data processing service"""

    def __init__(self, connection):
        self.conn = connection

    def validate(self, data):
        """Validate data before processing"""
        return self.conn.root.validate_data(data)

    def compute(self, data):
        """Compute statistics"""
        return self.conn.root.compute_statistics(data)

    def process_batch(self, batch):
        """Process a batch of items"""
        return self.conn.root.process_batch(batch)

    def store(self, results):
        """Store results"""
        return self.conn.root.store_results(results)

    def full_pipeline(self, data, batch):
        """Full processing pipeline"""
        # Validation
        self.validate(data)

        # Computation
        stats = self.compute(data)

        # Batch processing
        results = self.process_batch(batch)

        # Storage
        store_result = self.store(results)

        return {
            'stats': stats,
            'batch_results': results,
            'storage': store_result
        }


# Benchmark your application
def benchmark_application():
    """Benchmark the data processing application"""

    # Start server with your service
    with RPyCServer(host='localhost', port=18812, mode='threaded'):
        # Connect to server
        conn = create_rpyc_connection('localhost', 18812)

        # Create client
        client = DataProcessingClient(conn)

        # Prepare test data
        test_data = {
            'values': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
        }

        test_batch = [
            {'id': i, 'value': i * 10}
            for i in range(20)
        ]

        # Benchmark individual operations
        print("=" * 80)
        print("BENCHMARKING INDIVIDUAL OPERATIONS")
        print("=" * 80)

        # 1. Validation performance
        with BenchmarkContext("Validation", "rpyc", measure_latency=True) as bench:
            for _ in range(1000):
                with bench.measure_request():
                    client.validate(test_data)
                    bench.record_request(success=True)

        stats = bench.get_results().compute_statistics()
        print(f"\nValidation:")
        print(f"  Mean: {stats['latency']['mean']*1000:.2f}ms")
        print(f"  P95:  {stats['latency']['p95']*1000:.2f}ms")

        # 2. Computation performance
        with BenchmarkContext("Computation", "rpyc", measure_latency=True) as bench:
            for _ in range(1000):
                with bench.measure_request():
                    client.compute(test_data)
                    bench.record_request(success=True)

        stats = bench.get_results().compute_statistics()
        print(f"\nComputation:")
        print(f"  Mean: {stats['latency']['mean']*1000:.2f}ms")
        print(f"  P95:  {stats['latency']['p95']*1000:.2f}ms")

        # 3. Batch processing performance with bandwidth tracking
        with BenchmarkContext("Batch Processing", "rpyc",
                              measure_latency=True,
                              measure_bandwidth=True) as bench:
            for _ in range(100):
                with bench.measure_request(bytes_sent=len(str(test_batch))):
                    results = client.process_batch(test_batch)
                    bench.record_request(success=True)

        stats = bench.get_results().compute_statistics()
        print(f"\nBatch Processing:")
        print(f"  Mean latency: {stats['latency']['mean']*1000:.2f}ms")
        print(f"  P95 latency:  {stats['latency']['p95']*1000:.2f}ms")
        print(f"  Throughput:   {stats['upload_bandwidth']['mean']/(1024*1024):.2f} MB/s")

        # 4. Full pipeline performance
        print("\n" + "=" * 80)
        print("BENCHMARKING FULL PIPELINE")
        print("=" * 80)

        with BenchmarkContext("Full Pipeline", "rpyc", measure_latency=True) as bench:
            for _ in range(100):
                with bench.measure_request():
                    try:
                        result = client.full_pipeline(test_data, test_batch)
                        bench.record_request(success=True)
                    except Exception as e:
                        bench.record_request(success=False)

        stats = bench.get_results().compute_statistics()
        metrics = bench.get_results()
        success_rate = (metrics.total_requests - metrics.failed_requests) / metrics.total_requests * 100

        print(f"\nFull Pipeline:")
        print(f"  Mean latency:  {stats['latency']['mean']*1000:.2f}ms")
        print(f"  P95 latency:   {stats['latency']['p95']*1000:.2f}ms")
        print(f"  P99 latency:   {stats['latency']['p99']*1000:.2f}ms")
        print(f"  Success rate:  {success_rate:.1f}%")
        print(f"  Total requests: {metrics.total_requests}")
        print(f"  Failed:        {metrics.failed_requests}")

        conn.close()


if __name__ == '__main__':
    benchmark_application()

from rpycbench.core.benchmark import BenchmarkContext, LatencyBenchmark
from rpycbench.servers.rpyc_servers import RPyCServer, create_rpyc_connection


def compare_baseline_vs_application():
    """Compare baseline RPyC performance vs application performance"""

    with RPyCServer(host='localhost', port=18812, mode='threaded'):
        # 1. Baseline benchmark (direct ping)
        baseline_bench = LatencyBenchmark(
            name="Baseline",
            protocol="rpyc",
            server_mode="threaded",
            connection_factory=lambda: create_rpyc_connection('localhost', 18812),
            request_func=lambda conn: conn.root.ping(),
            num_requests=1000,
        )
        baseline_metrics = baseline_bench.execute()
        baseline_stats = baseline_metrics.compute_statistics()

        # 2. Application benchmark
        conn = create_rpyc_connection('localhost', 18812)

        # Your application class with business logic
        class MyApp:
            def __init__(self, connection):
                self.conn = connection
                self.cache = {}

            def process_request(self, data):
                # Your application logic (validation, caching, etc.)
                if data in self.cache:
                    return self.cache[data]

                # Make remote call
                result = self.conn.root.echo(data)

                # Post-processing
                self.cache[data] = result
                return result

        app = MyApp(conn)

        with BenchmarkContext("Application", "rpyc", measure_latency=True) as bench:
            for i in range(1000):
                with bench.measure_request():
                    app.process_request(f"data_{i}")
                    bench.record_request(success=True)

        app_metrics = bench.get_results()
        app_stats = app_metrics.compute_statistics()

        conn.close()

        # Compare results
        print("=" * 80)
        print("BASELINE VS APPLICATION COMPARISON")
        print("=" * 80)

        baseline_mean = baseline_stats['latency']['mean'] * 1000
        app_mean = app_stats['latency']['mean'] * 1000
        overhead = app_mean - baseline_mean
        overhead_pct = (overhead / baseline_mean) * 100

        print(f"\nBaseline (direct RPyC call):")
        print(f"  Mean: {baseline_mean:.2f}ms")
        print(f"  P95:  {baseline_stats['latency']['p95']*1000:.2f}ms")

        print(f"\nApplication (with business logic):")
        print(f"  Mean: {app_mean:.2f}ms")
        print(f"  P95:  {app_stats['latency']['p95']*1000:.2f}ms")

        print(f"\nOverhead:")
        print(f"  Absolute: {overhead:.2f}ms")
        print(f"  Relative: {overhead_pct:.1f}%")

        if overhead_pct > 50:
            print(f"\n⚠️  Application overhead is {overhead_pct:.1f}% - consider optimization")
        else:
            print(f"\n✓ Application overhead is reasonable at {overhead_pct:.1f}%")


if __name__ == '__main__':
    compare_baseline_vs_application()

from rpycbench.core.benchmark import BenchmarkContext
from rpycbench.servers.rpyc_servers import RPyCServer, create_rpyc_connection

with RPyCServer(host='localhost', port=18812, mode='threaded'):
    with BenchmarkContext("My Service", "rpyc", measure_latency=True) as ctx:
        conn = create_rpyc_connection('localhost', 18812)

        for i in range(100):
            with ctx.measure_request():
                conn.root.my_method(i)
                ctx.record_request(success=True)

        conn.close()

    stats = ctx.get_results().compute_statistics()
    print(f"Mean: {stats['latency']['mean']*1000:.2f}ms")

with BenchmarkContext("File Upload", "rpyc", measure_bandwidth=True) as ctx:
    conn = create_rpyc_connection('localhost', 18812)

    for file_data in my_files:
        with ctx.measure_request(bytes_sent=len(file_data)):
            conn.root.upload(file_data)
            ctx.record_request(success=True)

    conn.close()

stats = ctx.get_results().compute_statistics()
print(f"Upload speed: {stats['upload_bandwidth']['mean']/(1024*1024):.2f} MB/s")

with BenchmarkContext("Connections", "rpyc", measure_connection=True) as ctx:
    for i in range(50):
        with ctx.measure_connection_time():
            conn = create_rpyc_connection('localhost', 18812)

        # Use connection
        conn.root.ping()
        conn.close()

stats = ctx.get_results().compute_statistics()
print(f"Avg connection time: {stats['connection_time']['mean']*1000:.2f}ms")

with BenchmarkContext("API Calls", "rpyc", measure_latency=True) as ctx:
    conn = create_rpyc_connection('localhost', 18812)

    for request in requests:
        with ctx.measure_request():
            try:
                result = conn.root.process(request)
                ctx.record_request(success=True)
            except Exception as e:
                ctx.record_request(success=False)
                # Handle error

    conn.close()

metrics = ctx.get_results()
success_rate = (metrics.total_requests - metrics.failed_requests) / metrics.total_requests
print(f"Success rate: {success_rate*100:.1f}%")

from rpycbench.core.benchmark import BinaryTransferBenchmark
from rpycbench.servers.rpyc_servers import RPyCServer, create_rpyc_connection

with RPyCServer(host='localhost', port=18812, mode='threaded'):
    bench = BinaryTransferBenchmark(
        name="My File Transfer",
        protocol="rpyc",
        server_mode="threaded",
        connection_factory=lambda: create_rpyc_connection('localhost', 18812),
        upload_func=lambda conn, data: conn.root.upload_file(data),
        download_func=lambda conn, size: conn.root.download_file(size),
        upload_chunked_func=lambda conn, chunks: conn.root.upload_file_chunked(chunks),
        download_chunked_func=lambda conn, size, chunk_size: conn.root.download_file_chunked(size, chunk_size),
        file_sizes=[1_048_576, 10_485_760],  # 1MB, 10MB
        chunk_size=65_536,  # 64KB
        iterations=5,
    )

    metrics = bench.execute()

    for result in metrics.metadata['transfer_results']:
        print(f"{result['type']}: {result['throughput_mbps']:.2f} Mbps")

from rpycbench.utils.profiler import create_profiled_connection
from rpycbench.utils.telemetry import RPyCTelemetry
from rpycbench.servers.rpyc_servers import RPyCServer

with RPyCServer(host='localhost', port=18812, mode='threaded'):
    telemetry = RPyCTelemetry(
        enabled=True,
        track_netrefs=True,
        slow_call_threshold=0.1,
        deep_stack_threshold=5,
    )

    conn = create_profiled_connection(
        host='localhost',
        port=18812,
        telemetry_inst=telemetry,
    )

    # Your remote calls are automatically tracked
    for i in range(10):
        conn.root.ping()

    conn.close()

    # Print comprehensive report
    telemetry.print_summary()

from rpycbench import mark

# Using context manager (recommended)
with mark.section("Establishing 128 client connections"):
    for i in range(128):
        connections.append(rpyc.connect(host, port))

# Using explicit start/end
mark.start("Processing batch")
process_large_batch()
mark.end()

#!/usr/bin/env python3
"""
Example: myapp.py

Run normally:    python myapp.py
Run profiled:    python -m rpycbench.autobench myapp.py
"""
import rpyc.utils.classic

try:
    from rpycbench import mark
except ImportError:
    # Markers become no-ops if rpycbench not installed
    class mark:
        @staticmethod
        def start(name): pass
        @staticmethod
        def end(): pass
        @staticmethod
        def section(name):
            from contextlib import contextmanager
            @contextmanager
            def noop():
                yield
            return noop()


def main():
    with mark.section("Connecting to server"):
        conn = rpyc.utils.classic.connect('localhost', 18812)

    with mark.section("Fetching remote data"):
        remote_os = conn.modules.os
        cwd = remote_os.getcwd()
        print(f"Remote CWD: {cwd}")

    conn.close()


if __name__ == '__main__':
    main()

from rpycbench.benchmarks.suite import BenchmarkSuite

suite = BenchmarkSuite(
    rpyc_host='0.0.0.0',
    rpyc_port=18812,
    http_host='0.0.0.0',
    http_port=5000,
    remote_host='user@remote-server.com',
)

results = suite.run_all(
    test_rpyc_threaded=True,
    test_rpyc_forking=True,
    test_http=True,
)

results.print_summary()

from rpycbench.core.benchmark import BenchmarkContext
from rpycbench.remote.servers import RemoteRPyCServer
from rpycbench.servers.rpyc_servers import create_rpyc_connection

with RemoteRPyCServer(
    remote_host='user@hostname',
    host='0.0.0.0',
    port=18812,
    mode='threaded'
):
    with BenchmarkContext("My Remote Test", "rpyc", measure_latency=True) as bench:
        conn = create_rpyc_connection('hostname', 18812)

        for i in range(100):
            with bench.measure_request():
                result = conn.root.ping()
                bench.record_request(success=True)

        conn.close()

    stats = bench.get_results().compute_statistics()
    print(f"Remote latency: {stats['latency']['mean']*1000:.2f}ms")