pg_logical_replicator 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 33cf7006d00c233de6e00b5f667e37d48ad68d776cd3405537bbf8ade48426a6
+  data.tar.gz: b876513ec2a3998f486a6228f876b2c9ebb644880f2ebaabe8572128b9dab226
+SHA512:
+  metadata.gz: 8c7849de36e5824832a9eb778ebd33bae52455f43a05de3f8e2cf1f832ea98f8f1cfc45aee2e9e6dfd335de8df3f0cfde8d8b4ed6680e9c95198dd911352259b
+  data.tar.gz: e66b10fcf714cfa22d8cd64e096d5dfe3b67d44923eeb77109ea0a311341cd9ae9be6c2e3dc9f5cededb869644c764a7233b5d487b3a48f8a35e33b72eacdf2b

data/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) [year] [fullname]
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,159 @@
+# PgLogicalReplicator
+
+PgLogicalReplicator is a Ruby gem that helps set up and manage logical replication for PostgreSQL databases. This gem was created so you can migrate databases with near 0 downtime. It uses the PG snapshot ability to create a backup of the current db and restores that backup to the target db. After the restore is done replication begins where the backup left off. This allows you to have a near 0 downtime migration.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'pg_logical_replicator'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install pg_logical_replicator
+
+## Usage
+
+PgLogicalReplicator provides a command-line interface (CLI) to set up and stop logical replication between PostgreSQL databases.
+
+### Creating a Replication User on the Target Database
+
+Before setting up replication, you need to create a replication user on the target database. This user will have specific privileges to ensure that triggers and foreign keys are not enforced during replication. Use the following SQL commands to create and configure this user:
+
+```sql
+CREATE USER temp_replica_user WITH PASSWORD 'your_password';
+
+GRANT ALL PRIVILEGES ON DATABASE your_target_database TO temp_replica_user;
+GRANT ALL ON SCHEMA public TO temp_replica_user;
+GRANT ALL PRIVILEGES ON ALL TABLES IN SCHEMA public TO temp_replica_user;
+GRANT ALL PRIVILEGES ON ALL SEQUENCES IN SCHEMA public TO temp_replica_user;
+
+ALTER ROLE temp_replica_user SET session_replication_role = 'replica';
+```
+
+### Transferring Schema
+
+To transfer the schema from the source to the target database, use the following command:
+
+```
+pg_logical_replicator transfer_schema [OPTIONS]
+```
+
+- `--source_host SOURCE_HOST` : Source database host (required)
+- `--source_port SOURCE_PORT` : Source database port (default: 5432)
+- `--source_database SOURCE_DATABASE` : Source database name (required)
+- `--target_host TARGET_HOST` : Target database host (required)
+- `--target_port TARGET_PORT` : Target database port (default: 5432)
+- `--target_database TARGET_DATABASE` : Target database name (required)
+- `--source_username SOURCE_USERNAME` : Source database username (required)
+- `--source_password SOURCE_PASSWORD` : Source database password (required)
+- `--target_username TARGET_USERNAME` : Target database username (required)
+- `--target_password TARGET_PASSWORD` : Target database password (required)
+
+```
+pg_logical_replicator transfer_schema \
+  --source_host localhost \
+  --source_database mydb \
+  --source_username myuser \
+  --source_password mypass \
+  --target_host remotehost \
+  --target_database targetdb \
+  --target_username targetuser \
+  --target_password targetpass
+```
+
+This command will transfer the schema from the source database to the target database.
+
+### Setting Up Replication
+
+To set up logical replication, use the following command:
+
+```
+pg_logical_replicator setup [OPTIONS]
+```
+
+Options:
+
+- `--source_host SOURCE_HOST`          : Source database host (required)
+- `--source_port SOURCE_PORT`          : Source database port (default: 5432)
+- `--source_database SOURCE_DATABASE`  : Source database name (required)
+- `--target_host TARGET_HOST`          : Target database host (required)
+- `--target_port TARGET_PORT`          : Target database port (default: 5432)
+- `--target_database TARGET_DATABASE`  : Target database name (defaults to source database name)
+- `--source_username SOURCE_USERNAME`  : Source database username (required)
+- `--source_password SOURCE_PASSWORD`  : Source database password (required)
+- `--target_username TARGET_USERNAME`  : Target database username (defaults to source username)
+- `--target_password TARGET_PASSWORD`  : Target database password (defaults to source password)
+- `--target_rep_username REP_USERNAME` : Target replication username (defaults to target username)
+- `--target_rep_password REP_PASSWORD` : Target replication password (defaults to target password)
+- `--num_slots NUM_SLOTS`              : Number of replication slots (default: 10)
+- `--groups GROUP1,GROUP2,...`         : Groups to run (comma-separated list of numbers)
+
+Example:
+
+```
+pg_logical_replicator setup \
+  --source_host localhost \
+  --source_database mydb \
+  --source_username myuser \
+  --source_password mypass \
+  --target_host remotehost \
+  --num_slots 5 \
+  --groups 1,3,5
+```
+
+This command will set up logical replication for the specified groups of tables between the source and target databases.
+
+### Stopping Replication
+
+To stop all replication, use the following command:
+
+```
+pg_logical_replicator stop_replication [OPTIONS]
+```
+
+Options:
+
+- `--source_host SOURCE_HOST`          : Source database host (required)
+- `--source_port SOURCE_PORT`          : Source database port (default: 5432)
+- `--source_database SOURCE_DATABASE`  : Source database name (required)
+- `--target_host TARGET_HOST`          : Target database host (required)
+- `--target_port TARGET_PORT`          : Target database port (default: 5432)
+- `--target_database TARGET_DATABASE`  : Target database name (defaults to source database name)
+- `--source_username SOURCE_USERNAME`  : Source database username (required)
+- `--source_password SOURCE_PASSWORD`  : Source database password (required)
+- `--target_username TARGET_USERNAME`  : Target database username (defaults to source username)
+- `--target_password TARGET_PASSWORD`  : Target database password (defaults to source password)
+
+Example:
+
+```
+pg_logical_replicator stop_replication \
+  --source_host sourcehost \
+  --source_database mydb \
+  --source_username sourceuser \
+  --source_password sourcepass \
+  --target_host targethost
+```
+
+This command will drop all publications on the source database and all subscriptions on the target database, effectively stopping all logical replication.
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/yourusername/pg_logical_replicator.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/bin/pg_logical_replicator

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "pg_logical_replicator"
+
+PgLogicalReplicator::CLI.start(ARGV)

data/lib/pg_logical_replicator/cli.rb

@@ -0,0 +1,144 @@
+require 'thor'
+require 'pg'
+require 'fileutils'
+
+module PgLogicalReplicator
+  class CLI < Thor
+    desc 'setup', 'Set up logical replication'
+    method_option :source_host, type: :string, required: true
+    method_option :source_port, type: :numeric, default: 5432
+    method_option :source_database, type: :string, required: true
+    method_option :target_host, type: :string, required: true
+    method_option :target_port, type: :numeric, default: 5432
+    method_option :target_database, type: :string
+    method_option :source_username, type: :string, required: true
+    method_option :source_password, type: :string, required: true
+    method_option :target_username, type: :string
+    method_option :target_password, type: :string
+    method_option :target_rep_username, type: :string
+    method_option :target_rep_password, type: :string
+    method_option :num_slots, type: :numeric, default: 10
+    method_option :groups, type: :array
+
+    def setup
+      source_host         = options[:source_host]
+      source_port         = options[:source_port]
+      source_database     = options[:source_database]
+      target_host         = options[:target_host]
+      target_port         = options[:target_port]
+      target_database     = options[:target_database] || source_database
+      source_username     = options[:source_username]
+      source_password     = options[:source_password]
+      target_username     = options[:target_username] || source_username
+      target_password     = options[:target_password] || source_password
+      target_rep_username = options[:target_rep_username] || target_username
+      target_rep_password = options[:target_rep_password] || target_password
+      num_slots           = options[:num_slots]
+      target_groups       = options[:groups]
+
+      conn = PG.connect(dbname: source_database, user: source_username, password: source_password, host: source_host, port: source_port)
+
+      query = "SELECT tablename FROM pg_tables WHERE schemaname = 'public' order by tablename ASC;"
+
+      tables = begin
+                 result = conn.exec(query)
+                 puts "List of tables in the 'public' schema:"
+                 result.map { |row| row['tablename'] }
+               ensure
+                 conn.close if conn
+               end
+      puts "Total Tables: #{tables.size}"
+
+      tables_per_group = tables.size / num_slots
+      puts "Tables per group: #{tables_per_group}"
+
+      dump_dir_root = "~/db-dumps-#{Time.now.strftime('%Y%m%d%H%M%S')}"
+      system("mkdir -p #{dump_dir_root}")
+
+      tables.each_slice(tables_per_group).with_index do |table_group, group_idx|
+        puts "Processing group #{group_idx + 1} size: #{table_group.size}"
+
+        group_number = group_idx + 1
+
+        next unless target_groups.nil? || target_groups.include?(group_number)
+
+        table_names = table_group.join(',')
+
+        dump_dir = "#{dump_dir_root}/#{group_number}"
+
+        puts "Removing directory: #{dump_dir}"
+
+        FileUtils.rm_rf(dump_dir)
+
+        LogicalReplicationInitializer.new({
+                                            slot_name:           "logical_sub_grp_#{group_number}",
+                                            publication_name:    "logical_pub_grp_#{group_number}",
+                                            primary_conn_str:    "host=#{source_host} port=#{source_port} dbname=#{source_database} user=#{source_username} password=#{source_password}",
+                                            target_conn_str:     "host=#{target_host} port=#{target_port} dbname=#{target_database} user=#{target_username} password=#{target_password}",
+                                            target_rep_conn_str: "host=#{target_host} port=#{target_port} dbname=#{target_database} user=#{target_rep_username} password=#{target_rep_password}",
+                                            table_names:         table_names,
+                                            dump_dir:            dump_dir
+                                          }).start
+      end
+    end
+
+    desc 'stop_replication', 'Stop all replication'
+    method_option :source_host, type: :string, required: true
+    method_option :source_port, type: :numeric, default: 5432
+    method_option :source_database, type: :string, required: true
+    method_option :target_host, type: :string, required: true
+    method_option :target_port, type: :numeric, default: 5432
+    method_option :target_database, type: :string
+    method_option :source_username, type: :string, required: true
+    method_option :source_password, type: :string, required: true
+    method_option :target_username, type: :string
+    method_option :target_password, type: :string
+
+    def stop_replication
+      source_config = {
+        host:     options[:source_host],
+        port:     options[:source_port],
+        dbname:   options[:source_database],
+        user:     options[:source_username],
+        password: options[:source_password]
+      }
+
+      target_config = {
+        host:     options[:target_host],
+        port:     options[:target_port],
+        dbname:   options[:target_database] || options[:source_database],
+        user:     options[:target_username] || options[:source_username],
+        password: options[:target_password] || options[:source_password]
+      }
+
+      ReplicationStopper.new(source_config, target_config).stop_replication
+    end
+
+    desc 'transfer_schema', 'Transfer schema from source to target database'
+    method_option :source_host, type: :string, required: true
+    method_option :source_port, type: :numeric, default: 5432
+    method_option :source_database, type: :string, required: true
+    method_option :target_host, type: :string, required: true
+    method_option :target_port, type: :numeric, default: 5432
+    method_option :target_database, type: :string, required: true
+    method_option :source_username, type: :string, required: true
+    method_option :source_password, type: :string, required: true
+    method_option :target_username, type: :string, required: true
+    method_option :target_password, type: :string, required: true
+
+    def transfer_schema
+      SchemaTransfer.new(
+        source_host:     options[:source_host],
+        source_port:     options[:source_port],
+        source_database: options[:source_database],
+        source_username: options[:source_username],
+        source_password: options[:source_password],
+        target_host:     options[:target_host],
+        target_port:     options[:target_port],
+        target_database: options[:target_database],
+        target_username: options[:target_username],
+        target_password: options[:target_password]
+      ).transfer
+    end
+  end
+end

data/lib/pg_logical_replicator/logical_replication_initializer.rb

@@ -0,0 +1,145 @@
+require 'optparse'
+require 'pg'
+require 'logger'
+require 'fileutils'
+require 'open3'
+
+module PgLogicalReplicator
+  class LogicalReplicationInitializer
+    def initialize(args)
+      @options = args
+      setup_logger
+      validate_options
+      connect_to_databases
+    end
+
+    def setup_logger
+      @log = Logger.new(STDOUT)
+      @log.level = Logger::INFO
+    end
+
+    def validate_options
+      [:primary_conn_str, :target_conn_str, :target_rep_conn_str, :table_names, :dump_dir].each do |opt|
+        raise OptionParser::MissingArgument, opt.to_s unless @options[opt]
+      end
+
+      @options[:slot_name] ||= 'migration_sub'
+      @options[:publication_name] ||= 'migration_pub'
+      @options[:secondary_conn_str] ||= @options[:primary_conn_str]
+      @options[:subscription_conn_str] ||= @options[:primary_conn_str]
+    end
+
+    def connect_to_databases
+      @primary_conn = PG.connect(@options[:primary_conn_str])
+      @secondary_conn = PG.connect(@options[:secondary_conn_str])
+      @target_conn = PG.connect(@options[:target_conn_str])
+      @target_rep_conn = PG.connect(@options[:target_rep_conn_str])
+    end
+
+    def start
+      begin
+        @log.info("Dumping to #{@options[:dump_dir]}")
+
+        drop_subscription
+        drop_publication
+        create_publication
+        create_logical_replication_slot
+
+        snapshot = create_snapshot
+        dump_database(snapshot)
+        restore_dump
+        create_subscription
+        advance_subscription_origin(snapshot[:lsn])
+        enable_subscription
+      rescue => e
+        @log.error(e.message)
+        exit 1
+      end
+    end
+
+    def drop_subscription
+      @log.info("Dropping subscription #{@options[:slot_name]}")
+      @target_conn.exec("DROP SUBSCRIPTION IF EXISTS #{@options[:slot_name]}")
+    end
+
+    def drop_publication
+      @log.info("Dropping publication #{@options[:publication_name]}")
+      @primary_conn.exec("DROP PUBLICATION IF EXISTS #{@options[:publication_name]}")
+    end
+
+    def create_publication
+      @log.info("Creating publication #{@options[:publication_name]}")
+      table_names = @options[:table_names].split(',')
+      @primary_conn.exec("CREATE PUBLICATION #{@options[:publication_name]} FOR TABLE #{table_names.join(', ')}")
+    end
+
+    def create_logical_replication_slot
+      @log.info("Creating logical replication slot #{@options[:slot_name]}")
+      @primary_conn.exec("SELECT pg_create_logical_replication_slot('#{@options[:slot_name]}', 'pgoutput')")
+    end
+
+    def create_snapshot
+      @log.info("Creating snapshot")
+      @secondary_conn.transaction do |conn|
+        res = conn.exec("SELECT pg_current_wal_lsn(), pg_export_snapshot()")
+        { lsn: res.getvalue(0, 0), snapshot: res.getvalue(0, 1) }
+      end
+    end
+
+    def dump_database(snapshot)
+      @log.info("Dumping source DB")
+      table_names = @options[:table_names].split(',')
+      dump_command = [
+        'pg_dump',
+        '--no-publication',
+        '--no-subscription',
+        "--snapshot=#{snapshot[:snapshot]}",
+        '--format=d',
+        '--data-only',
+        '--jobs=8',
+        '-f', @options[:dump_dir],
+        @options[:secondary_conn_str]
+      ] + table_names.flat_map { |table| ['-t', table] }
+
+      @log.info("Executing DB Dump Command: #{dump_command.join(' ')}")
+      system(*dump_command)
+    end
+
+    def restore_dump
+      @log.info("Restoring dump to target DB")
+      table_names = @options[:table_names].split(',')
+      table_names.each { |table| truncate_table(table) }
+
+      restore_command = [
+        'pg_restore',
+        '--format=d',
+        '--jobs=8',
+        '--data-only',
+        '-d', @options[:target_rep_conn_str],
+        @options[:dump_dir]
+      ]
+
+      system(*restore_command)
+    end
+
+    def truncate_table(table)
+      @log.info("Truncating table #{table}")
+      @target_rep_conn.exec("TRUNCATE TABLE #{table}")
+    end
+
+    def create_subscription
+      @log.info("Creating subscription #{@options[:slot_name]}")
+      @target_conn.exec("CREATE SUBSCRIPTION #{@options[:slot_name]} CONNECTION '#{@options[:subscription_conn_str]}' PUBLICATION #{@options[:publication_name]} WITH (create_slot=false, slot_name='#{@options[:slot_name]}', enabled=false, copy_data=false)")
+    end
+
+    def advance_subscription_origin(lsn)
+      @log.info("Setting replication origin position to #{lsn}")
+      @target_conn.exec("SELECT pg_replication_origin_advance('pg_' || subid::text, '#{lsn}') FROM pg_stat_subscription WHERE subname = '#{@options[:slot_name]}'")
+    end
+
+    def enable_subscription
+      @log.info("Enabling subscription #{@options[:slot_name]}")
+      @target_conn.exec("ALTER SUBSCRIPTION #{@options[:slot_name]} ENABLE")
+    end
+  end
+end

data/lib/pg_logical_replicator/replication_stopper.rb

@@ -0,0 +1,48 @@
+require 'pg'
+
+module PgLogicalReplicator
+  class ReplicationStopper
+    def initialize(source_config, target_config)
+      @source_config = source_config
+      @target_config = target_config
+    end
+
+    def stop_replication
+      source_conn = PG.connect(@source_config)
+      target_conn = PG.connect(@target_config)
+
+      begin
+        drop_all_publications(source_conn)
+        drop_all_subscriptions(target_conn)
+        puts "All replication stopped successfully."
+      ensure
+        source_conn.close if source_conn
+        target_conn.close if target_conn
+      end
+    end
+
+    private
+
+    def drop_all_subscriptions(conn)
+      query = "SELECT subname FROM pg_subscription"
+      result = conn.exec(query)
+      result.each do |row|
+        subname = row['subname']
+        conn.exec("ALTER SUBSCRIPTION #{subname} DISABLE")
+        conn.exec("ALTER SUBSCRIPTION #{subname} SET (slot_name = NONE)")
+        conn.exec("DROP SUBSCRIPTION IF EXISTS #{subname}")
+        puts "Dropped subscription: #{subname}"
+      end
+    end
+
+    def drop_all_publications(conn)
+      query = "SELECT pubname FROM pg_publication"
+      result = conn.exec(query)
+      result.each do |row|
+        pubname = row['pubname']
+        conn.exec("DROP PUBLICATION IF EXISTS #{pubname}")
+        puts "Dropped publication: #{pubname}"
+      end
+    end
+  end
+end

data/lib/pg_logical_replicator/schema_transfer.rb

@@ -0,0 +1,57 @@
+#!/usr/bin/env ruby
+
+require 'optparse'
+require 'tempfile'
+
+module PgLogicalReplicator
+  class SchemaTransfer
+    def initialize(source_host:, source_port:, source_database:, target_host:, target_port:, target_database:, source_username:, source_password:, target_username:, target_password:)
+      @source_host     = source_host
+      @source_port     = source_port
+      @source_database = source_database
+      @source_username = source_username
+      @source_password = source_password
+      @target_host     = target_host
+      @target_port     = target_port
+      @target_database = target_database
+      @target_username = target_username
+      @target_password = target_password
+    end
+
+    def transfer
+      puts 'Starting schema transfer...'
+
+      ENV['PGPASSWORD_SOURCE'] = @source_password
+      ENV['PGPASSWORD_TARGET'] = @target_password
+
+      Tempfile.create('db_dump') do |tempfile|
+        pg_dump_command = [
+          "pg_dump",
+          "-s", "--no-owner", "--no-acl", "--no-privileges",
+          "-h", @source_host,
+          "-p", @source_port,
+          "-d", @source_database,
+          "-U", @source_username,
+          "> #{tempfile.path}"
+        ].join(' ')
+
+        psql_command = [
+          "psql",
+          "-h", @target_host,
+          "-p", @target_port,
+          "-d", @target_database,
+          "-U", @target_username,
+          "< #{tempfile.path}"
+        ].join(' ')
+
+        system({ "PGPASSWORD" => ENV['PGPASSWORD_SOURCE'] }, pg_dump_command)
+        system({ "PGPASSWORD" => ENV['PGPASSWORD_TARGET'] }, psql_command)
+      end
+
+      ENV.delete('PGPASSWORD_SOURCE')
+      ENV.delete('PGPASSWORD_TARGET')
+
+      puts 'Schema transfer completed successfully.'
+    end
+  end
+end

data/lib/pg_logical_replicator/version.rb

@@ -0,0 +1,3 @@
+module PgLogicalReplicator
+  VERSION = "0.1.0"
+end

data/lib/pg_logical_replicator.rb

@@ -0,0 +1,25 @@
+require_relative "pg_logical_replicator/version"
+require_relative "pg_logical_replicator/logical_replication_initializer"
+require_relative "pg_logical_replicator/replication_stopper"
+require_relative "pg_logical_replicator/cli"
+require_relative 'pg_logical_replicator/schema_transfer'
+
+module PgLogicalReplicator
+  class Error < StandardError; end
+
+  # You can add any module-level methods or constants here if needed
+
+  # For example, you might want to add a method to get the gem's root directory:
+  def self.root
+    File.expand_path('..', __dir__)
+  end
+
+  # Or a method to get the gem's configuration if you decide to add config options in the future:
+  # def self.configuration
+  #   @configuration ||= Configuration.new
+  # end
+
+  # def self.configure
+  #   yield(configuration) if block_given?
+  # end
+end

metadata

@@ -0,0 +1,125 @@
+--- !ruby/object:Gem::Specification
+name: pg_logical_replicator
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- eni9889
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2024-07-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: pg
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: A tool to set up and manage logical replication for PostgreSQL databases
+email:
+- enea09@gmail.com
+executables:
+- pg_logical_replicator
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- bin/pg_logical_replicator
+- lib/pg_logical_replicator.rb
+- lib/pg_logical_replicator/cli.rb
+- lib/pg_logical_replicator/logical_replication_initializer.rb
+- lib/pg_logical_replicator/replication_stopper.rb
+- lib/pg_logical_replicator/schema_transfer.rb
+- lib/pg_logical_replicator/version.rb
+homepage: https://github.com/eni9889/pg_logical_replicator
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/eni9889/pg_logical_replicator
+  source_code_uri: https://github.com/eni9889/pg_logical_replicator
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.6
+signing_key:
+specification_version: 4
+summary: PostgreSQL logical replication setup tool
+test_files: []