*/*/.git

*/*/*.yml

FROM alpine:3.4

RUN apk add --update gcc libc-dev bison flex readline-dev zlib-dev perl make diffutils gdb iproute2 musl-dbg

RUN mkdir /pg && chown postgres:postgres pg

ENV LANG en_US.utf8

ENV CFLAGS -O0

ENV PATH /pg/install/bin:$PATH

COPY ./ /pg/src

RUN chown -R postgres:postgres /pg

RUN cd /pg/src && \

./configure --enable-cassert --enable-debug --prefix=/pg/install && \

make -j 4 install

tests/node*

package Cluster;

use strict;

use warnings;

use Proc::ProcessTable;

use PostgresNode;

use TestLib;

use Test::More;

use Cwd;

my %allocated_ports = ();

sub allocate_ports

{

my @allocated_now = ();

my ($host, $ports_to_alloc) = @_;

while ($ports_to_alloc > 0)

{

my $port = int(rand() * 16384) + 49152;

next if $allocated_ports{$port};

diag("checking for port $port\n");

if (!TestLib::run_log(['pg_isready', '-h', $host, '-p', $port]))

{

$allocated_ports{$port} = 1;

push(@allocated_now, $port);

$ports_to_alloc--;

}

}

return @allocated_now;

}

sub new

{

my ($class, $nodenum) = @_;

my $nodes = [];

foreach my $i (1..$nodenum)

{

my $host = "127.0.0.1";

my ($pgport, $arbiter_port) = allocate_ports($host, 2);

my $node = new PostgresNode("node$i", $host, $pgport);

$node->{id} = $i;

$node->{arbiter_port} = $arbiter_port;

push(@$nodes, $node);

}

my $self = {

nodenum => $nodenum,

nodes => $nodes,

};

bless $self, $class;

return $self;

}

sub init

{

my ($self) = @_;

my $nodes = $self->{nodes};

foreach my $node (@$nodes)

{

$node->init(hba_permit_replication => 0);

}

}

sub configure

{

my ($self) = @_;

my $nodes = $self->{nodes};

my $nnodes = scalar @{ $nodes };

my $connstr = join(', ', map { "${ \$_->connstr('postgres') } arbiter_port=${ \$_->{arbiter_port} }" } @$nodes);

foreach my $node (@$nodes)

{

my $id = $node->{id};

my $host = $node->host;

my $pgport = $node->port;

my $arbiter_port = $node->{arbiter_port};

$node->append_conf("postgresql.conf", qq(

));

$node->append_conf("pg_hba.conf", qq(

));

}

}

sub start

{

my ($self) = @_;

my $nodes = $self->{nodes};

foreach my $node (@$nodes)

{

$node->start();

}

}

sub stopnode

{

my ($node, $mode) = @_;

return 1 unless defined $node->{_pid};

$mode = 'fast' unless defined $mode;

my $name = $node->name;

diag("stopping $name ${mode}ly");

if ($mode eq 'kill') {

killtree($node->{_pid});

return 1;

}

my $pgdata = $node->data_dir;

my $ret = TestLib::system_log('pg_ctl', '-D', $pgdata, '-m', 'fast', 'stop');

my $pidfile = $node->data_dir . "/postmaster.pid";

diag("unlink $pidfile");

unlink $pidfile;

$node->{_pid} = undef;

$node->_update_pid;

if ($ret != 0) {

diag("$name failed to stop ${mode}ly");

return 0;

}

return 1;

}

sub stopid

{

my ($self, $idx, $mode) = @_;

return stopnode($self->{nodes}->[$idx]);

}

sub killtree

{

my $root = shift;

diag("killtree $root\n");

my $t = new Proc::ProcessTable;

my %parent = ();

#my %cmd = ();

foreach my $p (@{$t->table}) {

$parent{$p->pid} = $p->ppid;

# $cmd{$p->pid} = $p->cmndline;

}

if (!defined $root) {

return;

}

my @queue = ($root);

my @killist = ();

while (scalar @queue) {

my $victim = shift @queue;

while (my ($pid, $ppid) = each %parent) {

if ($ppid == $victim) {

push @queue, $pid;

}

}

diag("SIGSTOP to $victim");

kill 'STOP', $victim;

unshift @killist, $victim;

}

diag("SIGKILL to " . join(' ', @killist));

kill 'KILL', @killist;

#foreach my $victim (@killist) {

# print("kill $victim " . $cmd{$victim} . "\n");

#}

}

sub stop

{

my ($self, $mode) = @_;

my $nodes = $self->{nodes};

$mode = 'fast' unless defined $mode;

diag("Dumping logs:");

foreach my $node (@$nodes) {

diag("##################################################################");

diag($node->{_logfile});

diag("##################################################################");

my $filename = $node->{_logfile};

open my $fh, '<', $filename or die "error opening $filename: $!";

my $data = do { local $/; <$fh> };

diag($data);

diag("##################################################################\n\n");

}

my $ok = 1;

diag("stopping cluster ${mode}ly");

foreach my $node (@$nodes) {

if (!stopnode($node, $mode)) {

$ok = 0;

if (!stopnode($node, 'kill')) {

my $name = $node->name;

BAIL_OUT("failed to kill $name");

}

}

}

sleep(2);

return $ok;

}

sub teardown

{

my ($self) = @_;

my $nodes = $self->{nodes};

foreach my $node (@$nodes)

{

$node->teardown();

}

}

sub psql

{

my ($self, $index, @args) = @_;

my $node = $self->{nodes}->[$index];

return $node->psql(@args);

}

sub poll

{

my ($self, $poller, $dbname, $pollee, $tries, $delay) = @_;

my $node = $self->{nodes}->[$poller];

for (my $i = 0; $i < $tries; $i++) {

my $psql_out;

my $pollee_plus_1 = $pollee + 1;

$self->psql($poller, $dbname, "select mtm.poll_node($pollee_plus_1, true);", stdout => \$psql_out);

if ($psql_out eq "t") {

return 1;

}

my $tries_left = $tries - $i - 1;

diag("$poller poll for $pollee failed [$tries_left tries left]");

sleep($delay);

}

return 0;

}

1;

FROM pgproent

RUN mkdir /pg/mmts

COPY ./ /pg/mmts/

RUN export USE_PGXS=1 && \

cd /pg/mmts && make clean && make install

RUN cp /pg/src/src/test/regress/*.so /pg/install/lib/postgresql/

USER postgres

RUN mkdir /pg/src/src/test/regress/results

ENV PGDATA /pg/data

ENTRYPOINT ["/pg/mmts/tests2/docker-entrypoint.sh"]

EXPOSE 5432

CMD ["postgres"]

MODULE_big = multimaster

OBJS = multimaster.o arbiter.o bytebuf.o bgwpool.o pglogical_output.o pglogical_proto.o pglogical_receiver.o pglogical_apply.o pglogical_hooks.o pglogical_config.o pglogical_relid_map.o ddd.o bkb.o spill.o

EXTENSION = multimaster

DATA = multimaster--1.0.sql

.PHONY: all

all: multimaster.so

tests/dtmbench:

make -C tests

PG_CPPFLAGS = -I$(libpq_srcdir)

SHLIB_LINK = $(libpq)

ifdef USE_PGXS

PG_CONFIG = pg_config

PGXS := $(shell $(PG_CONFIG) --pgxs)

include $(PGXS)

else

subdir = contrib/multimaster

top_builddir = ../..

include $(top_builddir)/src/Makefile.global

include $(top_srcdir)/contrib/contrib-global.mk

check:

env DESTDIR='$(abs_top_builddir)'/tmp_install make install

$(prove_check)