diff --git a/migrate/20240619_lantern_doctor_queries.rb b/migrate/20240619_lantern_doctor_queries.rb
index 278162924..18d6dd99f 100644
--- a/migrate/20240619_lantern_doctor_queries.rb
+++ b/migrate/20240619_lantern_doctor_queries.rb
@@ -4,6 +4,7 @@
   up do
     # percent toward transaction wraparound
     sql = <<SQL
+ WITH max_age AS (
  SELECT 2000000000 as max_old_xid,
         setting AS autovacuum_freeze_max_age
         FROM pg_catalog.pg_settings
@@ -29,5 +30,7 @@
       response_type: "bool",
       severity: "warning"
     )
+    # Create semaphores for all lantern doctors to sync system queries
+    run "INSERT INTO semaphore (id, strand_id, name) SELECT gen_random_uuid(), id, 'sync_system_queries' FROM strand s WHERE s.prog = 'Lantern::LanternDoctorNexus'"
   end
 end
diff --git a/migrate/20240621_lantern_resource_logical_replication.rb b/migrate/20240621_lantern_resource_logical_replication.rb
new file mode 100644
index 000000000..4fef76579
--- /dev/null
+++ b/migrate/20240621_lantern_resource_logical_replication.rb
@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+Sequel.migration do
+  up do
+    alter_table(:lantern_resource) do
+      add_column :logical_replication, :bool, default: false
+    end
+  end
+end
diff --git a/model/lantern/lantern_resource.rb b/model/lantern/lantern_resource.rb
index a9eae65d5..c6fc64df6 100644
--- a/model/lantern/lantern_resource.rb
+++ b/model/lantern/lantern_resource.rb
@@ -21,7 +21,7 @@ class LanternResource < Sequel::Model
   include Authorization::HyperTagMethods
   include Authorization::TaggableMethods
 
-  semaphore :destroy
+  semaphore :destroy, :swap_leaders_with_parent
 
   plugin :column_encryption do |enc|
     enc.column :superuser_password
@@ -55,8 +55,8 @@ def display_state
     super || representative_server&.display_state || "unavailable"
   end
 
-  def connection_string
-    representative_server&.connection_string
+  def connection_string(port: 6432)
+    representative_server&.connection_string(port: port)
   end
 
   def required_standby_count
@@ -84,6 +84,138 @@ def allow_timeline_access_to_bucket
     api.allow_bucket_usage_by_prefix(service_account_name, Config.lantern_backup_bucket, timeline.ubid)
   end
 
+  def set_to_readonly(status: "on")
+    representative_server.run_query("
+      ALTER SYSTEM SET default_transaction_read_only TO #{status};
+      SELECT pg_reload_conf();
+      SHOW default_transaction_read_only;
+    ")
+  end
+
+  def create_replication_slot(name)
+    representative_server.run_query("SELECT lsn FROM pg_create_logical_replication_slot('#{name}', 'pgoutput');").chomp.strip
+  end
+
+  def create_ddl_log
+    commands = <<SQL
+    BEGIN;
+    CREATE TABLE IF NOT EXISTS ddl_log(
+        id SERIAL PRIMARY KEY,
+        object_tag TEXT,
+        ddl_command TEXT,
+        timestamp TIMESTAMP
+    );
+    CREATE OR REPLACE FUNCTION log_ddl_changes()
+    RETURNS event_trigger AS $$
+    BEGIN
+      INSERT INTO ddl_log (object_tag, ddl_command, timestamp)
+              VALUES (tg_tag, current_query(), current_timestamp);
+    END;
+    $$ LANGUAGE plpgsql;
+
+    DROP EVENT TRIGGER IF EXISTS log_ddl_trigger;
+    CREATE EVENT TRIGGER log_ddl_trigger
+    ON ddl_command_end
+    EXECUTE FUNCTION log_ddl_changes();
+    COMMIT;
+SQL
+    representative_server.run_query_all(commands)
+  end
+
+  def listen_ddl_log
+    commands = <<SQL
+   DROP EVENT TRIGGER IF EXISTS log_ddl_trigger;
+   TRUNCATE TABLE ddl_log RESTART IDENTITY;
+   CREATE OR REPLACE FUNCTION execute_ddl_command()
+   RETURNS TRIGGER AS $$
+   BEGIN
+       SET search_path TO public;
+       EXECUTE NEW.ddl_command;
+       RETURN NEW;
+   END;
+   $$ LANGUAGE plpgsql;
+
+   CREATE TRIGGER execute_ddl_after_insert
+   AFTER INSERT ON ddl_log
+   FOR EACH ROW
+   EXECUTE FUNCTION execute_ddl_command();
+   ALTER TABLE ddl_log ENABLE REPLICA TRIGGER execute_ddl_after_insert;
+SQL
+    representative_server.run_query_all(commands)
+  end
+
+  def create_publication(name)
+    representative_server.run_query_all("CREATE PUBLICATION #{name} FOR ALL TABLES")
+  end
+
+  def sync_sequences_with_parent
+    representative_server.list_all_databases.each do |db|
+      res = parent.representative_server.run_query("
+        SELECT sequence_schema, sequence_name, last_value
+    FROM information_schema.sequences
+    JOIN pg_sequences
+    ON (information_schema.sequences.sequence_schema = pg_sequences.schemaname
+    AND information_schema.sequences.sequence_name = pg_sequences.sequencename)
+    WHERE last_value > 0;", db: db)
+
+      statements = res.chomp.strip.split("\n").map do |row|
+        values = row.split(",")
+        "SELECT setval('#{values[0]}.#{values[1]}', #{values[2]});"
+      end
+
+      representative_server.run_query(statements, db: db)
+    end
+  end
+
+  def create_and_enable_subscription
+    representative_server.list_all_databases.each do |db|
+      commands = <<SQL
+      CREATE SUBSCRIPTION sub_#{ubid}
+      CONNECTION '#{parent.connection_string(port: 5432)}/#{db}'
+      PUBLICATION pub_#{ubid}
+      WITH (
+        copy_data = false,
+        create_slot = false,
+        binary = true,
+        enabled = true,
+        synchronous_commit = false,
+        connect = true,
+        slot_name = 'slot_#{ubid}'
+      );
+SQL
+      representative_server.run_query(commands, db: db)
+    end
+  end
+
+  def disable_logical_subscription
+    representative_server.run_query_all("ALTER SUBSCRIPTION sub_#{ubid} DISABLE")
+  end
+
+  def create_logical_replica(lantern_version: nil, extras_version: nil, minor_version: nil)
+    ubid = LanternResource.generate_ubid
+    create_ddl_log
+    create_publication("pub_#{ubid}")
+    slot_lsn = create_replication_slot("slot_#{ubid}")
+    Prog::Lantern::LanternResourceNexus.assemble(
+      project_id: project_id,
+      location: location,
+      name: "#{name}-#{Time.now.to_i}",
+      label: "#{label}-logical",
+      ubid: ubid,
+      target_vm_size: representative_server.target_vm_size,
+      target_storage_size_gib: representative_server.target_storage_size_gib,
+      parent_id: id,
+      restore_target: timeline.latest_restore_time.utc.to_s[..-5],
+      recovery_target_lsn: slot_lsn,
+      org_id: org_id,
+      version_upgrade: true,
+      logical_replication: true,
+      lantern_version: lantern_version || representative_server.lantern_version,
+      extras_version: extras_version || representative_server.extras_version,
+      minor_version: minor_version || representative_server.minor_version
+    )
+  end
+
   def create_logging_table
     api = Hosting::GcpApis.new
     schema = [
diff --git a/model/lantern/lantern_server.rb b/model/lantern/lantern_server.rb
index 259d5ccf5..77572dba0 100644
--- a/model/lantern/lantern_server.rb
+++ b/model/lantern/lantern_server.rb
@@ -37,13 +37,13 @@ def hostname
     vm.sshable.host
   end
 
-  def connection_string
+  def connection_string(port: 6432)
     return nil unless (hn = hostname)
     URI::Generic.build2(
       scheme: "postgres",
       userinfo: "postgres:#{URI.encode_uri_component(resource.superuser_password)}",
       host: hn,
-      port: 6432
+      port: port
     ).to_s
   end
 
diff --git a/prog/lantern/lantern_resource_nexus.rb b/prog/lantern/lantern_resource_nexus.rb
index c4df8b082..5f137230b 100644
--- a/prog/lantern/lantern_resource_nexus.rb
+++ b/prog/lantern/lantern_resource_nexus.rb
@@ -10,17 +10,16 @@ class Prog::Lantern::LanternResourceNexus < Prog::Base
   extend Forwardable
   def_delegators :lantern_resource, :servers, :representative_server
 
-  semaphore :destroy
+  semaphore :destroy, :swap_leaders_with_parent
 
-  def self.assemble(project_id:, location:, name:, target_vm_size:, target_storage_size_gib:, ha_type: LanternResource::HaType::NONE, parent_id: nil, restore_target: nil, recovery_target_lsn: nil,
+  def self.assemble(project_id:, location:, name:, target_vm_size:, target_storage_size_gib:, ubid: LanternResource.generate_ubid, ha_type: LanternResource::HaType::NONE, parent_id: nil, restore_target: nil, recovery_target_lsn: nil,
     org_id: nil, db_name: "postgres", db_user: "postgres", db_user_password: nil, superuser_password: nil, repl_password: nil, app_env: Config.rack_env,
     lantern_version: Config.lantern_default_version, extras_version: Config.lantern_extras_default_version, minor_version: Config.lantern_minor_default_version, domain: nil, enable_debug: false,
-    label: "", version_upgrade: false)
+    label: "", version_upgrade: false, logical_replication: false)
     unless (project = Project[project_id])
       fail "No existing project"
     end
 
-    ubid = LanternResource.generate_ubid
     name ||= LanternResource.ubid_to_name(ubid)
 
     Validation.validate_location(location, project.provider)
@@ -84,7 +83,8 @@ def self.assemble(project_id:, location:, name:, target_vm_size:, target_storage
         superuser_password: superuser_password, ha_type: ha_type, parent_id: parent_id,
         restore_target: restore_target, db_name: db_name, db_user: db_user,
         db_user_password: db_user_password, repl_user: repl_user, repl_password: repl_password,
-        label: label, doctor_id: lantern_doctor.id, recovery_target_lsn: recovery_target_lsn, version_upgrade: version_upgrade
+        label: label, doctor_id: lantern_doctor.id, recovery_target_lsn: recovery_target_lsn, version_upgrade: version_upgrade,
+        logical_replication: logical_replication
       ) { _1.id = ubid.to_uuid }
       lantern_resource.associate_with_project(project)
 
@@ -155,6 +155,17 @@ def before_run
   label def wait_servers
     lantern_resource.set_failed_on_deadline
     nap 5 if servers.any? { _1.strand.label != "wait" }
+
+    if lantern_resource.logical_replication
+      hop_enable_logical_replication
+    end
+
+    hop_wait
+  end
+
+  label def enable_logical_replication
+    lantern_resource.listen_ddl_log
+    lantern_resource.create_and_enable_subscription
     hop_wait
   end
 
@@ -177,9 +188,62 @@ def before_run
       lantern_resource.update(display_state: nil)
     end
 
+    when_swap_leaders_with_parent_set? do
+      if lantern_resource.parent.nil?
+        decr_swap_leaders_with_parent
+      else
+        lantern_resource.update(display_state: "failover")
+        lantern_resource.parent.update(display_state: "failover")
+        register_deadline(:wait, 10 * 60)
+        hop_swap_leaders_with_parent
+      end
+    end
+
     nap 30
   end
 
+  label def update_hosts
+    current_master = lantern_resource.parent.representative_server
+    current_master_domain = current_master.domain
+    new_master_domain = lantern_resource.representative_server.domain
+
+    lantern_resource.representative_server.update(domain: current_master_domain)
+    current_master.update(domain: new_master_domain)
+
+    # update display_states
+    lantern_resource.update(display_state: nil)
+    lantern_resource.parent.update(display_state: nil)
+
+    # remove fork association so parent can be deleted
+    lantern_resource.update(parent_id: nil)
+    lantern_resource.timeline.update(parent_id: nil)
+    hop_wait
+  end
+
+  label def wait_swap_ip
+    ready = false
+    begin
+      lantern_resource.representative_server.run_query("SELECT 1")
+      ready = true
+    rescue
+    end
+
+    if ready
+      hop_update_hosts
+    else
+      nap 5
+    end
+  end
+
+  label def swap_leaders_with_parent
+    decr_swap_leaders_with_parent
+    lantern_resource.parent.set_to_readonly
+    lantern_resource.disable_logical_subscription
+    lantern_resource.sync_sequences_with_parent
+    lantern_resource.representative_server.vm.swap_ip(lantern_resource.parent.representative_server.vm)
+    hop_wait_swap_ip
+  end
+
   label def destroy
     register_deadline(nil, 5 * 60)
 
diff --git a/spec/model/lantern/lantern_resource_spec.rb b/spec/model/lantern/lantern_resource_spec.rb
index 496ec839f..272e7756a 100644
--- a/spec/model/lantern/lantern_resource_spec.rb
+++ b/spec/model/lantern/lantern_resource_spec.rb
@@ -134,4 +134,153 @@
       expect(lantern_resource.big_query_table).to eq("#{lantern_resource.name}_logs")
     end
   end
+
+  describe "#create_ddl_log" do
+    it "create ddl log table" do
+      representative_server = instance_double(LanternServer)
+      expect(lantern_resource).to receive(:representative_server).and_return(representative_server).at_least(:once)
+      expect(lantern_resource.representative_server).to receive(:run_query_all).with(a_string_matching(/ddl_log/))
+      expect { lantern_resource.create_ddl_log }.not_to raise_error
+    end
+  end
+
+  describe "#listen_ddl_log" do
+    it "listends ddl log table" do
+      representative_server = instance_double(LanternServer)
+      expect(lantern_resource).to receive(:representative_server).and_return(representative_server).at_least(:once)
+      expect(lantern_resource.representative_server).to receive(:run_query_all).with(a_string_matching(/execute_ddl_command/))
+      expect { lantern_resource.listen_ddl_log }.not_to raise_error
+    end
+  end
+
+  describe "#set_to_readonly" do
+    it "convert server to readonly" do
+      representative_server = instance_double(LanternServer)
+      expect(lantern_resource).to receive(:representative_server).and_return(representative_server).at_least(:once)
+      expect(lantern_resource.representative_server).to receive(:run_query).with(a_string_matching(/default_transaction_read_only TO on/))
+      expect { lantern_resource.set_to_readonly }.not_to raise_error
+    end
+
+    it "convert server to writable" do
+      representative_server = instance_double(LanternServer)
+      expect(lantern_resource).to receive(:representative_server).and_return(representative_server).at_least(:once)
+      expect(lantern_resource.representative_server).to receive(:run_query).with(a_string_matching(/default_transaction_read_only TO off/))
+      expect { lantern_resource.set_to_readonly(status: "off") }.not_to raise_error
+    end
+  end
+
+  describe "#create_replication_slot" do
+    it "creates new replication slot" do
+      representative_server = instance_double(LanternServer)
+      expect(lantern_resource).to receive(:representative_server).and_return(representative_server).at_least(:once)
+      expect(lantern_resource.representative_server).to receive(:run_query).with("SELECT lsn FROM pg_create_logical_replication_slot('test', 'pgoutput');").and_return("0/6002748 \n")
+      expect(lantern_resource.create_replication_slot("test")).to eq("0/6002748")
+    end
+  end
+
+  describe "#create_publication" do
+    it "creates new publication" do
+      representative_server = instance_double(LanternServer)
+      expect(lantern_resource).to receive(:representative_server).and_return(representative_server).at_least(:once)
+      expect(lantern_resource.representative_server).to receive(:run_query_all).with("CREATE PUBLICATION test FOR ALL TABLES")
+      expect { lantern_resource.create_publication("test") }.not_to raise_error
+    end
+  end
+
+  describe "#create_and_enable_subscription" do
+    it "creates new subscription" do
+      representative_server = instance_double(LanternServer)
+      expect(lantern_resource).to receive(:representative_server).and_return(representative_server).at_least(:once)
+      expect(lantern_resource.representative_server).to receive(:list_all_databases).and_return(["db1", "db2"])
+      expect(lantern_resource.representative_server).to receive(:run_query).with(a_string_matching(/CREATE SUBSCRIPTION/), db: "db1")
+      expect(lantern_resource.representative_server).to receive(:run_query).with(a_string_matching(/CREATE SUBSCRIPTION/), db: "db2")
+      expect(lantern_resource).to receive(:connection_string).and_return("postgres://localhost:5432").at_least(:once)
+      expect(lantern_resource).to receive(:parent).and_return(lantern_resource).at_least(:once)
+      expect { lantern_resource.create_and_enable_subscription }.not_to raise_error
+    end
+  end
+
+  describe "#disable_logical_subscription" do
+    it "disables subscription" do
+      representative_server = instance_double(LanternServer)
+      expect(lantern_resource).to receive(:representative_server).and_return(representative_server).at_least(:once)
+      expect(lantern_resource.representative_server).to receive(:run_query_all).with("ALTER SUBSCRIPTION sub_#{lantern_resource.ubid} DISABLE")
+      expect { lantern_resource.disable_logical_subscription }.not_to raise_error
+    end
+  end
+
+  describe "#create_logical_replica" do
+    it "create logical replica with current version" do
+      representative_server = instance_double(LanternServer,
+        target_vm_size: "n1-standard-1",
+        target_storage_size_gib: 120,
+        lantern_version: Config.lantern_default_version,
+        extras_version: Config.lantern_extras_default_version,
+        minor_version: Config.lantern_minor_default_version)
+      expect(lantern_resource).to receive(:representative_server).and_return(representative_server).at_least(:once)
+      timeline = instance_double(LanternTimeline,
+        latest_restore_time: Time.new)
+      expect(lantern_resource).to receive(:timeline).and_return(timeline).at_least(:once)
+      expect(lantern_resource).to receive(:create_replication_slot)
+      expect(lantern_resource).to receive(:create_ddl_log)
+      expect(lantern_resource).to receive(:create_publication)
+      expect(Prog::Lantern::LanternResourceNexus).to receive(:assemble).with(hash_including(
+        parent_id: lantern_resource.id,
+        version_upgrade: true,
+        logical_replication: true,
+        lantern_version: representative_server.lantern_version,
+        extras_version: representative_server.extras_version,
+        minor_version: representative_server.minor_version
+      ))
+      expect { lantern_resource.create_logical_replica }.not_to raise_error
+    end
+
+    it "create logical replica with specified version" do
+      representative_server = instance_double(LanternServer,
+        target_vm_size: "n1-standard-1",
+        target_storage_size_gib: 120)
+      expect(lantern_resource).to receive(:representative_server).and_return(representative_server).at_least(:once)
+      timeline = instance_double(LanternTimeline,
+        latest_restore_time: Time.new)
+      expect(lantern_resource).to receive(:timeline).and_return(timeline).at_least(:once)
+      expect(lantern_resource).to receive(:create_replication_slot)
+      expect(lantern_resource).to receive(:create_ddl_log)
+      expect(lantern_resource).to receive(:create_publication)
+      expect(Prog::Lantern::LanternResourceNexus).to receive(:assemble).with(hash_including(
+        parent_id: lantern_resource.id,
+        version_upgrade: true,
+        logical_replication: true,
+        lantern_version: "0.3.0",
+        extras_version: "0.2.6",
+        minor_version: "1"
+      ))
+      expect { lantern_resource.create_logical_replica(lantern_version: "0.3.0", extras_version: "0.2.6", minor_version: "1") }.not_to raise_error
+    end
+  end
+
+  describe "#sync_sequences_with_parent" do
+    it "syncs sequences with parent" do
+      representative_server = instance_double(LanternServer)
+      parent_representative_server = instance_double(LanternServer)
+      parent = instance_double(described_class, representative_server: parent_representative_server)
+      databases = ["db1", "db2"]
+      query_result = "public,seq1,100\npublic,seq2,200"
+
+      allow(lantern_resource).to receive_messages(representative_server: representative_server, parent: parent)
+      allow(representative_server).to receive(:list_all_databases).and_return(databases)
+      allow(parent_representative_server).to receive(:run_query).with(anything, db: "db1").and_return(query_result)
+      allow(parent_representative_server).to receive(:run_query).with(anything, db: "db2").and_return(query_result)
+
+      statements_db1 = [
+        "SELECT setval('public.seq1', 100);",
+        "SELECT setval('public.seq2', 200);"
+      ]
+      statements_db2 = statements_db1 # identical statements for the test
+
+      expect(representative_server).to receive(:run_query).with(statements_db1, db: "db1")
+      expect(representative_server).to receive(:run_query).with(statements_db2, db: "db2")
+
+      expect { lantern_resource.sync_sequences_with_parent }.not_to raise_error
+    end
+  end
 end
diff --git a/spec/prog/lantern/lantern_resource_nexus_spec.rb b/spec/prog/lantern/lantern_resource_nexus_spec.rb
index e1779f966..33437db16 100644
--- a/spec/prog/lantern/lantern_resource_nexus_spec.rb
+++ b/spec/prog/lantern/lantern_resource_nexus_spec.rb
@@ -12,6 +12,7 @@
       location: "us-central1",
       org_id: 0,
       parent: nil,
+      logical_replication: false,
       servers: [instance_double(
         LanternServer,
         vm: instance_double(
@@ -181,7 +182,13 @@
       expect { nx.wait_servers }.to nap(5)
     end
 
-    it "hops if server is ready" do
+    it "hops to enable_logical_replication" do
+      expect(lantern_resource.servers).to all(receive(:strand).and_return(instance_double(Strand, label: "wait")))
+      expect(lantern_resource).to receive(:logical_replication).and_return(true)
+      expect { nx.wait_servers }.to hop("enable_logical_replication")
+    end
+
+    it "hops to if server is ready" do
       expect(lantern_resource.servers).to all(receive(:strand).and_return(instance_double(Strand, label: "wait")))
       expect { nx.wait_servers }.to hop("wait")
     end
@@ -208,6 +215,28 @@
       expect(lantern_resource).to receive(:servers).and_return([instance_double(LanternServer, strand: instance_double(Strand, label: "unavailable"))]).at_least(:once)
       expect { nx.wait }.to nap(30)
     end
+
+    it "naps if no parent on swap_leaders" do
+      expect(lantern_resource).to receive(:required_standby_count).and_return(0)
+      expect(lantern_resource).to receive(:display_state).and_return(nil)
+      expect(lantern_resource).to receive(:servers).and_return([instance_double(LanternServer, strand: instance_double(Strand, label: "wait"))]).at_least(:once)
+      expect(nx).to receive(:when_swap_leaders_with_parent_set?).and_yield
+      expect(lantern_resource).to receive(:parent).and_return(nil)
+      expect(nx).to receive(:decr_swap_leaders_with_parent)
+      expect { nx.wait }.to nap(30)
+    end
+
+    it "hops to swap_leaders" do
+      expect(lantern_resource).to receive(:required_standby_count).and_return(0)
+      expect(lantern_resource).to receive(:display_state).and_return(nil)
+      expect(lantern_resource).to receive(:servers).and_return([instance_double(LanternServer, strand: instance_double(Strand, label: "wait"))]).at_least(:once)
+      expect(nx).to receive(:when_swap_leaders_with_parent_set?).and_yield
+      parent = instance_double(LanternResource)
+      expect(lantern_resource).to receive(:parent).and_return(parent).at_least(:once)
+      expect(parent).to receive(:update).with(display_state: "failover")
+      expect(lantern_resource).to receive(:update).with(display_state: "failover")
+      expect { nx.wait }.to hop("swap_leaders_with_parent")
+    end
   end
 
   describe "#destroy" do
@@ -242,4 +271,69 @@
       expect { nx.destroy }.to exit({"msg" => "lantern resource is deleted"})
     end
   end
+
+  describe "#enable_logical_replication" do
+    it "enables logical replication" do
+      expect(lantern_resource).to receive(:listen_ddl_log)
+      expect(lantern_resource).to receive(:create_and_enable_subscription)
+      expect { nx.enable_logical_replication }.to hop("wait")
+    end
+  end
+
+  describe "#swap_leaders_with_parent" do
+    it "swaps ips with parent leader" do
+      parent = instance_double(LanternResource)
+      representative_server = instance_double(LanternServer)
+      vm = instance_double(GcpVm)
+      expect(parent).to receive(:representative_server).and_return(representative_server)
+      expect(lantern_resource).to receive(:representative_server).and_return(representative_server).at_least(:once)
+      expect(lantern_resource).to receive(:disable_logical_subscription)
+      expect(lantern_resource).to receive(:sync_sequences_with_parent)
+      expect(representative_server).to receive(:vm).and_return(vm).at_least(:once)
+      expect(vm).to receive(:swap_ip)
+      expect(lantern_resource).to receive(:parent).and_return(parent).at_least(:once)
+      expect(parent).to receive(:set_to_readonly)
+      expect { nx.swap_leaders_with_parent }.to hop("wait_swap_ip")
+    end
+  end
+
+  describe "#wait_swap_ip" do
+    it "naps if error" do
+      representative_server = instance_double(LanternServer)
+      expect(lantern_resource).to receive(:representative_server).and_return(representative_server).at_least(:once)
+      expect(representative_server).to receive(:run_query).and_raise "test"
+      expect { nx.wait_swap_ip }.to nap(5)
+    end
+
+    it "hops if ready" do
+      representative_server = instance_double(LanternServer)
+      expect(lantern_resource).to receive(:representative_server).and_return(representative_server).at_least(:once)
+      expect(representative_server).to receive(:run_query)
+      expect { nx.wait_swap_ip }.to hop("update_hosts")
+    end
+  end
+
+  describe "#update_hosts" do
+    it "updates the domains of the current and new master, updates display states, and removes fork association" do
+      parent = instance_double(LanternResource)
+      current_master = instance_double(LanternServer, domain: "current-master-domain.com")
+      new_master = instance_double(LanternServer, domain: "new-master-domain.com")
+      timeline = instance_double(LanternTimeline)
+
+      expect(lantern_resource).to receive(:parent).and_return(parent).at_least(:once)
+      expect(parent).to receive(:representative_server).and_return(current_master).at_least(:once)
+      expect(lantern_resource).to receive(:representative_server).and_return(new_master).at_least(:once)
+      expect(new_master).to receive(:update).with(domain: "current-master-domain.com")
+      expect(current_master).to receive(:update).with(domain: "new-master-domain.com")
+
+      expect(lantern_resource).to receive(:update).with(display_state: nil)
+      expect(parent).to receive(:update).with(display_state: nil)
+
+      expect(lantern_resource).to receive(:update).with(parent_id: nil)
+      expect(lantern_resource).to receive(:timeline).and_return(timeline)
+      expect(timeline).to receive(:update).with(parent_id: nil)
+
+      expect { nx.update_hosts }.to hop("wait")
+    end
+  end
 end