feat: update slo

.github/workflows/slo.yml

@@ -1,75 +1,83 @@
+name: SLO
+
 on:
   push:
-    branches: [main]
+    branches:
+      - main
   pull_request:
-    branches: [main]
+    branches:
+      - main
   workflow_dispatch:
-
-name: SLO
+    inputs:
+      github_pull_request_number:
+        required: true
+      slo_workload_duration_seconds:
+        default: '600'
+        required: false
+      slo_workload_read_max_rps:
+        default: '1000'
+        required: false
+      slo_workload_write_max_rps:
+        default: '1000'
+        required: false
 
 jobs:
-  test-slo:
-    concurrency:
-      group: slo-${{ github.ref }}
+  ydb-slo-action:
     if: (!contains(github.event.pull_request.labels.*.name, 'no slo'))
 
-    runs-on: ubuntu-latest
     name: SLO test
-    permissions:
-      checks: write
-      pull-requests: write
-      contents: read
-      issues: write
-
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        sdk:
+          - AdoNet
+
+    concurrency:
+      group: slo-${{ github.ref }}-${{ matrix.workload }}
+      cancel-in-progress: true
+
     steps:
       - name: Checkout repository
         uses: actions/checkout@v4
-        if: env.DOCKER_REPO != null
-        env:
-          DOCKER_REPO: ${{ secrets.SLO_DOCKER_REPO }}
 
-      - name: Run SLO
-        uses: ydb-platform/slo-tests@main
-        if: env.DOCKER_REPO != null
-        env:
-          DOCKER_REPO: ${{ secrets.SLO_DOCKER_REPO }}
-        continue-on-error: true
+      - name: Install .NET
+        uses: actions/setup-dotnet@v4
+        with:
+          dotnet-version: 8.0.x
+
+      - name: Initialize YDB SLO
+        uses: ydb-platform/ydb-slo-action/init@main
         with:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          KUBECONFIG_B64: ${{ secrets.SLO_KUBE_CONFIG }}
-          AWS_CREDENTIALS_B64: ${{ secrets.SLO_AWS_CREDENTIALS }}
-          AWS_CONFIG_B64: ${{ secrets.SLO_AWS_CONFIG }}
-          DOCKER_USERNAME: ${{ secrets.SLO_DOCKER_USERNAME }}
-          DOCKER_PASSWORD: ${{ secrets.SLO_DOCKER_PASSWORD }}
-          DOCKER_REPO: ${{ secrets.SLO_DOCKER_REPO }}
-          DOCKER_FOLDER: ${{ secrets.SLO_DOCKER_FOLDER }}
-          s3_endpoint: ${{ secrets.SLO_S3_ENDPOINT }}
-          s3_images_folder: ${{ vars.SLO_S3_IMAGES_FOLDER }}
-          grafana_domain: ${{ vars.SLO_GRAFANA_DOMAIN }}
-          # grafana_dashboard: ${{ vars.SLO_GRAFANA_DASHBOARD }}
-          grafana_dashboard: dca60386-0d3d-43f5-a2af-5f3fd3e3b295
-          grafana_dashboard_width: 2000
-          grafana_dashboard_height: 2300
-          ydb_version: 'newest'
-          timeBetweenPhases: 30
-          shutdownTime: 30
+          github_pull_request_number: ${{ github.event.inputs.github_pull_request_number }}
+          github_token: ${{ secrets.GITHUB_TOKEN }}
+          sdk_name: ${{ matrix.sdk }}
+          ydb_database_node_count: 5
+
+      - name: Prepare SLO Database
+        run: |
+          cd slo/src/${{ matrix.sdk }}
+          dotnet run create grpc://localhost:2135 /Root/testdb
+
+      - name: Run SLO Tests
+        run: |
+          cd slo/src/${{ matrix.sdk }}
+          dotnet run run grpc://localhost:2135 /Root/testdb \
+            --prom-pgw localhost:9091 \
+            --report-period 250 \
+            --time ${{inputs.slo_workload_duration_seconds || 600 }} \
+            --read-rps ${{inputs.slo_workload_read_max_rps || 1000 }} \
+            --write-rps ${{inputs.slo_workload_write_max_rps || 1000 }} \
+            --read-timeout 1000 \
+            --write-timeout 1000
 
-          language_id0: 'table-service'
-          workload_path0: 'slo/src'
-          language0: '.NET SDK over table-service'
-          workload_build_context0: ../..
-          workload_build_options0: -f Dockerfile --build-arg SRC_PATH=TableService
-
-          language_id1: 'ado-net'
-          workload_path1: 'slo/src'
-          language1: 'ADO.NET over query-service'
-          workload_build_context1: ../..
-          workload_build_options1: -f Dockerfile --build-arg SRC_PATH=AdoNet
+      - if: always()
+        name: Store ydb chaos testing logs
+        run: |
+          docker logs ydb-chaos > chaos-ydb.log
 
-      - uses: actions/upload-artifact@v3
-        if: always() && env.DOCKER_REPO != null
-        env:
-          DOCKER_REPO: ${{ secrets.SLO_DOCKER_REPO }}
+      - if: always()
+        uses: actions/upload-artifact@v4
         with:
-          name: slo-logs
-          path: logs/
+          name: ${{ matrix.workload }}-chaos-ydb.log
+          path: ./chaos-ydb.log
+          retention-days: 1

.github/workflows/tests.yml

@@ -75,7 +75,7 @@ jobs:
           cd src
           dotnet test --filter "(FullyQualifiedName~Ado) | (FullyQualifiedName~Dapper)" -l "console;verbosity=normal"
 
-  core-integration-tests:
+  integration-tests:
     runs-on: ubuntu-22.04
     strategy:
       fail-fast: false

slo/src/Internal/Cli.cs

@@ -12,39 +12,19 @@ public static class Cli
         "db",
         "YDB database to connect to");
 
-    private static readonly Option<string> TableOption = new(
-        new[] { "-t", "--table-name" },
-        () => "testingTable",
-        "table name to create\n ");
+    private static readonly Option<string> PromPgwOption = new(
+        "--prom-pgw",
+        "minimum amount of partitions in table") { IsRequired = true };
+
+    private static readonly Option<string> ResourceYdbPath = new(
+        new[] { "-t", "--resource-ydb-path" },
+        () => "test-resource",
+        "resource ydb path to create\n ");
 
     private static readonly Option<int> WriteTimeoutOption = new(
         "--write-timeout",
-        () => 100,
-        "write timeout seconds");
-
-    private static readonly Option<int> MinPartitionsCountOption = new(
-        "--min-partitions-count",
-        () => 6,
-        "minimum amount of partitions in table");
-
-    private static readonly Option<int> MaxPartitionsCountOption = new(
-        "--max-partitions-count",
         () => 1000,
-        "maximum amount of partitions in table");
-
-    private static readonly Option<int> PartitionSizeOption = new(
-        "--partition-size",
-        () => 1,
-        "partition size in mb");
-
-    private static readonly Option<int> InitialDataCountOption = new(
-        new[] { "-c", "--initial-data-count" },
-        () => 1000,
-        "amount of initially created rows");
-
-    private static readonly Option<string> PromPgwOption = new(
-        "--prom-pgw",
-        "minimum amount of partitions in table") { IsRequired = true };
+        "write timeout seconds");
 
     private static readonly Option<int> ReportPeriodOption = new(
         "--report-period",
@@ -58,34 +38,43 @@ public static class Cli
 
     private static readonly Option<int> ReadTimeoutOption = new(
         "--read-timeout",
-        () => 100,
+        () => 1000,
         "read timeout seconds");
 
     private static readonly Option<int> WriteRpsOption = new(
         "--write-rps",
-        () => 100,
+        () => 1000,
         "write RPS");
 
     private static readonly Option<int> TimeOption = new(
         "--time",
-        () => 140,
+        () => 600,
         "run time in seconds");
 
-    private static readonly Option<int> ShutdownTimeOption = new(
-        "--shutdown-time",
-        () => 30,
-        "time to wait before force kill workers");
+    private static readonly Option<int> MinPartitionsCountOption = new(
+        "--min-partitions-count",
+        () => 5,
+        "minimum amount of partitions in table");
+
+    private static readonly Option<int> MaxPartitionsCountOption = new(
+        "--max-partitions-count",
+        () => 10,
+        "maximum amount of partitions in table");
+
+    private static readonly Option<int> InitialDataCountOption = new(
+        new[] { "-c", "--initial-data-count" },
+        () => 1000,
+        "amount of initially created rows");
 
     private static readonly Command CreateCommand = new(
         "create",
         "creates table in database")
     {
         EndpointArgument,
         DbArgument,
-        TableOption,
+        ResourceYdbPath,
         MinPartitionsCountOption,
         MaxPartitionsCountOption,
-        PartitionSizeOption,
         InitialDataCountOption,
         WriteTimeoutOption
     };
@@ -96,16 +85,15 @@ public static class Cli
     {
         EndpointArgument,
         DbArgument,
-        TableOption,
+        ResourceYdbPath,
         InitialDataCountOption,
         PromPgwOption,
         ReportPeriodOption,
         ReadRpsOption,
         ReadTimeoutOption,
         WriteRpsOption,
         WriteTimeoutOption,
-        TimeOption,
-        ShutdownTimeOption
+        TimeOption
     };
 
     private static readonly RootCommand RootCommand = new("SLO app")
@@ -116,12 +104,12 @@ public static class Cli
     public static async Task<int> Run<T>(SloContext<T> sloContext, string[] args) where T : IDisposable
     {
         CreateCommand.SetHandler(async createConfig => { await sloContext.Create(createConfig); },
-            new CreateConfigBinder(EndpointArgument, DbArgument, TableOption, MinPartitionsCountOption,
-                MaxPartitionsCountOption, PartitionSizeOption, InitialDataCountOption, WriteTimeoutOption));
+            new CreateConfigBinder(EndpointArgument, DbArgument, ResourceYdbPath, MinPartitionsCountOption,
+                MaxPartitionsCountOption, InitialDataCountOption, WriteTimeoutOption));
 
         RunCommand.SetHandler(async runConfig => { await sloContext.Run(runConfig); },
-            new RunConfigBinder(EndpointArgument, DbArgument, TableOption, PromPgwOption, ReportPeriodOption,
-                ReadRpsOption, ReadTimeoutOption, WriteRpsOption, WriteTimeoutOption, TimeOption, ShutdownTimeOption));
+            new RunConfigBinder(EndpointArgument, DbArgument, ResourceYdbPath, PromPgwOption, ReportPeriodOption,
+                ReadRpsOption, ReadTimeoutOption, WriteRpsOption, WriteTimeoutOption, TimeOption));
 
         return await RootCommand.InvokeAsync(args);
     }

slo/src/Internal/ConfigBinders.cs

@@ -6,10 +6,9 @@ namespace Internal;
 public class CreateConfigBinder(
     Argument<string> endpointArgument,
     Argument<string> dbArgument,
-    Option<string> tableOption,
+    Option<string> resourceYdbPath,
     Option<int> minPartitionsCountOption,
     Option<int> maxPartitionsCountOption,
-    Option<int> partitionSizeOption,
     Option<int> initialDataCountOption,
     Option<int> writeTimeoutOption)
     : BinderBase<CreateConfig>
@@ -19,62 +18,41 @@ protected override CreateConfig GetBoundValue(BindingContext bindingContext)
         return new CreateConfig(
             bindingContext.ParseResult.GetValueForArgument(endpointArgument),
             bindingContext.ParseResult.GetValueForArgument(dbArgument),
-            bindingContext.ParseResult.GetValueForOption(tableOption)!,
+            bindingContext.ParseResult.GetValueForOption(resourceYdbPath)!,
             bindingContext.ParseResult.GetValueForOption(minPartitionsCountOption),
             bindingContext.ParseResult.GetValueForOption(maxPartitionsCountOption),
-            bindingContext.ParseResult.GetValueForOption(partitionSizeOption),
             bindingContext.ParseResult.GetValueForOption(initialDataCountOption),
             bindingContext.ParseResult.GetValueForOption(writeTimeoutOption)
         );
     }
 }
 
-internal class CleanUpConfigBinder(
-    Argument<string> endpointArgument,
-    Argument<string> dbArgument,
-    Option<string> tableOption,
-    Option<int> writeTimeoutOption)
-    : BinderBase<CleanUpConfig>
-{
-    protected override CleanUpConfig GetBoundValue(BindingContext bindingContext)
-    {
-        return new CleanUpConfig(
-            bindingContext.ParseResult.GetValueForArgument(endpointArgument),
-            bindingContext.ParseResult.GetValueForArgument(dbArgument),
-            bindingContext.ParseResult.GetValueForOption(tableOption)!,
-            bindingContext.ParseResult.GetValueForOption(writeTimeoutOption)
-        );
-    }
-}
-
 internal class RunConfigBinder(
     Argument<string> endpointArgument,
     Argument<string> dbArgument,
-    Option<string> tableOption,
+    Option<string> resourceYdbPath,
     Option<string> promPgwOption,
     Option<int> reportPeriodOption,
     Option<int> readRpsOption,
     Option<int> readTimeoutOption,
     Option<int> writeRpsOption,
     Option<int> writeTimeoutOption,
-    Option<int> timeOption,
-    Option<int> shutdownTimeOption)
+    Option<int> timeOption)
     : BinderBase<RunConfig>
 {
     protected override RunConfig GetBoundValue(BindingContext bindingContext)
     {
         return new RunConfig(
             bindingContext.ParseResult.GetValueForArgument(endpointArgument),
             bindingContext.ParseResult.GetValueForArgument(dbArgument),
-            bindingContext.ParseResult.GetValueForOption(tableOption)!,
+            bindingContext.ParseResult.GetValueForOption(resourceYdbPath)!,
             bindingContext.ParseResult.GetValueForOption(promPgwOption)!,
             bindingContext.ParseResult.GetValueForOption(reportPeriodOption),
             bindingContext.ParseResult.GetValueForOption(readRpsOption),
             bindingContext.ParseResult.GetValueForOption(readTimeoutOption),
             bindingContext.ParseResult.GetValueForOption(writeRpsOption),
             bindingContext.ParseResult.GetValueForOption(writeTimeoutOption),
-            bindingContext.ParseResult.GetValueForOption(timeOption),
-            bindingContext.ParseResult.GetValueForOption(shutdownTimeOption)
+            bindingContext.ParseResult.GetValueForOption(timeOption)
         );
     }
 }