Migration configuration

1
// define how to compare the two read values
2
bool Checker(string a, string b) => a.Equals(b);
3
4
var migration = new MigrationBuilder<string, string, string, string>(_client)
5
    .Read(
6
        (payload) => MigrationMethod.Success("read old"),
7
        (payload) => MigrationMethod.Success("read new"),
8
        Checker)
9
    .Write(
10
        (payload) => MigrationMethod.Success("write old"),
11
        (payload) => MigrationMethod.Success("write new"))
12
    .ReadExecution(MigrationExecution.Parallel()) // or MigrationExecution.Serial(MigrationSerialOrder.Fixed)
13
    .TrackErrors(true)    // true by default
14
    .TrackLatency(true)   // true by default
15
    .Build();

1
client, _ := ld.MakeClient("YOUR_SDK_KEY", 5*time.Second)
2
3
var comparison ld.MigrationComparisonFn
4
comparison = func(interface{}, interface{}) bool {
5
	// compare the two read values
6
	return true
7
}
8
9
migrator, _ := ld.Migration(client).
10
	Read(
11
		func(interface{}) (interface{}, error) {
12
			return "old read", nil
13
		},
14
		func(interface{}) (interface{}, error) {
15
			return "new read", nil
16
		},
17
		&comparison,
18
	).
19
	ReadExecutionOrder(ldmigration.Random).
20
	Write(
21
		func(interface{}) (interface{}, error) {
22
			return "old write result", nil
23
		},
24
		func(interface{}) (interface{}, error) {
25
			return "new write result", nil
26
		},
27
	).
28
	TrackLatency(true).
29
	TrackErrors(true).
30
	Build()

1
LDClient client = new LDClient("YOUR_SDK_KEY");
2
3
MigrationBuilder<String, String, String, String> migrationBuilder = new MigrationBuilder<>(client)
4
  .read(
5
    (payload) -> MigrationMethodResult.Success("read old"),
6
    (payload) -> MigrationMethodResult.Success("read new"),
7
    (a, b) -> a.equals(b)
8
  )
9
  .readExecution(MigrationExecution.Serial(MigrationSerialOrder.RANDOM)) // default is .Parallel
10
  .write(
11
    (payload) -> MigrationMethodResult.Success("write old"),
12
    (payload) -> MigrationMethodResult.Success("write new")
13
  )
14
  .trackLatency(true)
15
  .trackErrors(true);
16
17
Migration<String, String, String, String> migration = migrationBuilder.build();

1
import { LDMigrationOptions, init, createMigration } from '@launchdarkly/node-server-sdk';
2
const options: LDMigrationOptions = {
3
  readNew: async(key?: string) => {
4
    console.log("Reading from new: ", key);
5
    return LDMigrationSuccess(true);
6
  },
7
  readOld: async(key?: string) => {
8
    console.log("Reading from old: ", key);
9
    return LDMigrationSuccess(true);
10
  },
11
  writeNew: async(params?: {key: string, value: string}) => {
12
    console.log("Writing to new: ", params);
13
    // if failure
14
    return LDMigrationError(new Error('example error'));
15
  },
16
  writeOld: async(params?: {key: string, value: string}) => {
17
    console.log("Writing to old: ", params);
18
    // if failure
19
    return LDMigrationError(new Error('example error'));
20
  },
21
22
  check: (old, new) => {
23
    // Define your consistency check for read operations
24
    // and return a boolean. Depending on your migration,
25
    // this may be as simple as 'return a === b;'
26
  },
27
28
  execution: new LDConcurrentExecution(),
29
    // or new LDSerialExecution(LDExecutionOrdering.Random),
30
    // or new LDSerialExecution(LDExecutionOrdering.Fixed),
31
32
  latencyTracking: true, // defaults to true
33
  errorTracking: true, // defaults to true
34
}
35
36
const client = init('YOUR_SDK_KEY');
37
const migration = createMigration(client, options);

1
use LaunchDarkly\Migrations;
2
use LaunchDarkly\Types;
3
4
$builder = new Migrations\MigratorBuilder($client);
5
6
$builder->read(
7
    fn (?string $payload) => Types\Result::success("old read"),
8
    fn (?string $payload) => Types\Result::success("new read"),
9
    fn(string $old, string $new) => $old == $new,
10
);
11
12
$builder->write(
13
    fn (?string $payload) => Types\Result::success("old write"),
14
    fn (?string $payload) => Types\Result::success("new write")
15
);
16
$builder->readExecutionOrder(Migrations\ExecutionOrder::SERIAL);
17
// could also use ExecutionOrder::RANDOM
18
19
$builder->trackLatency(true); // defaults to true
20
$builder->trackErrors(true);  // defaults to true
21
22
$result = $builder->build();

1
from ldclient import Result, MigratorBuilder, ExecutionOrder
2
3
builder = MigratorBuilder(ldclient.get())
4
5
builder.read(lambda _: Result.success("read old"), lambda _: Result.success("read new"), lambda lhs, rhs: lhs == rhs)
6
builder.write(lambda _: Result.success("write old"), lambda _: Result.success("write new"))
7
8
builder.read_execution_order(ExecutionOrder.PARALLEL)
9
# could also use ExecutionOrder.SERIAL, ExecutionOrder.RANDOM
10
11
builder.track_latency(True) # defaults to True
12
builder.track_errors(True)  # defaults to True
13
14
result = builder.build()

1
builder = LaunchDarkly::Migrations::MigratorBuilder.new(@client)
2
builder.read(
3
  ->(_payload) { LaunchDarkly::Result.success('old value') },
4
  ->(_payload) { LaunchDarkly::Result.success('new value') },
5
  ->(lhs, rhs) { lhs == rhs }
6
)
7
8
builder.write(
9
  ->(_payload) { LaunchDarkly::Result.success('old value') },
10
  ->(_payload) { LaunchDarkly::Result.success('new value') }
11
)
12
builder.read_execution_order(builder.EXECUTION_PARALLEL) # or .EXECUTION_SERIAL, or .EXECUTION_RANDOM
13
builder.track_latency(true) # defaults to true
14
builder.track_errors(true)  # defaults to true
15
migrator = builder.build

1
let client = Arc::new(client);
2
let mut builder = MigratorBuilder::new(client.clone())
3
    .read(
4
        |_payload: &String| async move { Ok(()) }.boxed(),
5
        |_payload: &String| async move { Ok(()) }.boxed(),
6
        Some(|lhs, rhs| lhs == rhs),
7
    )
8
    .write(
9
        |_payload: &String| async move { Ok(()) }.boxed(),
10
        |_payload: &String| async move { Ok(()) }.boxed(),
11
    );
12
13
builder = builder
14
    .read_execution_order(ExecutionOrder::Concurrent) // Or ExecutionOrder::Serial or ExecutionOrder::Random
15
    .track_latency(true) // defaults to true
16
    .track_errors(true); // defaults to true
17
18
let migrator = builder.build().expect("build migrator");

1
import {
2
  createMigration,
3
  init,
4
  LDConcurrentExecution,
5
  LDMigrationError,
6
  LDMigrationOptions,
7
  LDMigrationSuccess,
8
} from '@launchdarkly/akamai-server-edgekv-sdk';
9
10
const options: LDMigrationOptions = {
11
  readNew: async(key?: string) => {
12
    console.log("Reading from new: ", key);
13
    return LDMigrationSuccess(true);
14
  },
15
  readOld: async(key?: string) => {
16
    console.log("Reading from new: ", key);
17
    return LDMigrationSuccess(true);
18
  },
19
  writeNew: async(params?: {key: string, value: string}) => {
20
    console.log("Writing to new: ", params);
21
    // if failure - can throw an exception
22
    throw new Error("example exception")
23
  },
24
  writeOld: async(params?: {key: string, value: string}) => {
25
    console.log("Writing to old: ", params);
26
    // if failure - can return the error
27
    return LDMigrationError(new Error('example error'));
28
  },
29
30
  check: (old, new) => {
31
    // Define your consistency check for read operations
32
    // and return a boolean. Depending on your migration,
33
    // this may be as simple as 'return a === b;'
34
  },
35
36
  execution: new LDConcurrentExecution(),
37
    // or new LDSerialExecution(LDExecutionOrdering.Random),
38
    // or new LDSerialExecution(LDExecutionOrdering.Fixed),
39
40
}
41
42
const client = init({
43
  sdkKey: 'example-client-side-id',
44
  namespace: 'your-edgekv-namespace',
45
  group: 'your-edgekv-group-id'
46
});
47
const migration = createMigration(client, options);

1
import {
2
  createMigration,
3
  init,
4
  LDConcurrentExecution,
5
  LDMigrationError,
6
  LDMigrationOptions,
7
  LDMigrationSuccess,
8
} from '@launchdarkly/cloudflare-server-sdk';
9
10
const options: LDMigrationOptions = {
11
  readNew: async(key?: string) => {
12
    console.log("Reading from new: ", key);
13
    return LDMigrationSuccess(true);
14
  },
15
  readOld: async(key?: string) => {
16
    console.log("Reading from new: ", key);
17
    return LDMigrationSuccess(true);
18
  },
19
  writeNew: async(params?: {key: string, value: string}) => {
20
    console.log("Writing to new: ", params);
21
    // if failure - can throw an exception
22
    throw new Error('example exception')
23
  },
24
  writeOld: async(params?: {key: string, value: string}) => {
25
    console.log("Writing to old: ", params);
26
    // if failure - can return the failure
27
    return LDMigrationError(new Error('example error'));
28
  },
29
30
  check: (old, new) => {
31
    // Define your consistency check for read operations
32
    // and return a boolean. Depending on your migration,
33
    // this may be as simple as 'return a === b;'
34
  },
35
36
  execution: new LDConcurrentExecution(),
37
    // or new LDSerialExecution(LDExecutionOrdering.Random),
38
    // or new LDSerialExecution(LDExecutionOrdering.Fixed),
39
40
  latencyTracking: true, // defaults to true
41
  errorTracking: true, // defaults to true
42
}
43
44
const client = init('YOUR_SDK_KEY', env.LD_KV, { sendEvents: true });
45
const migration = createMigration(client, options);

1
import {
2
  createMigration,
3
  init,
4
  LDConcurrentExecution,
5
  LDMigrationError,
6
  LDMigrationOptions,
7
  LDMigrationSuccess,
8
} from '@launchdarkly/vercel-server-sdk';
9
10
const options: LDMigrationOptions = {
11
  readNew: async(key?: string) => {
12
    console.log("Reading from new: ", key);
13
    return LDMigrationSuccess(true);
14
  },
15
  readOld: async(key?: string) => {
16
    console.log("Reading from new: ", key);
17
    return LDMigrationSuccess(true);
18
  },
19
  writeNew: async(params?: {key: string, value: string}) => {
20
    console.log("Writing to new: ", params);
21
    // if failure - can throw an exception
22
    throw new Error("example exception")
23
  },
24
  writeOld: async(params?: {key: string, value: string}) => {
25
    console.log("Writing to old: ", params);
26
    // if failure - can return the failure
27
    return LDMigrationError(new Error('example error'));
28
  },
29
30
  check: (old, new) => {
31
    // Define your consistency check for read operations
32
    // and return a boolean. Depending on your migration,
33
    // this may be as simple as 'return a === b;'
34
  },
35
36
  execution: new LDConcurrentExecution(),
37
    // or new LDSerialExecution(LDExecutionOrdering.Random),
38
    // or new LDSerialExecution(LDExecutionOrdering.Fixed),
39
40
  latencyTracking: true, // defaults to true
41
  errorTracking: true, // defaults to true
42
}
43
44
const client = init('example-client-side-id', edgeConfigClient, { sendEvents: true });
45
const migration = createMigration(client, options);