[PATCHv3,2/3] test: Add rpc test for dump/restore with --remote

Submitted by Radostin Stoyanov on Feb. 12, 2018, 10:54 a.m.

Details

Message ID 20180212105406.28358-3-rstoyanov1@gmail.com
State New
Series "Add remote option to RPC"
Headers show

Commit Message

Radostin Stoyanov Feb. 12, 2018, 10:54 a.m.
Signed-off-by: Radostin Stoyanov <rstoyanov1@gmail.com>
---
 test/others/rpc/remote.py | 86 +++++++++++++++++++++++++++++++++++++++++++++++
 test/others/rpc/run.sh    | 26 ++++++++++++++
 2 files changed, 112 insertions(+)
 create mode 100644 test/others/rpc/remote.py

Patch hide | download patch | download mbox

diff --git a/test/others/rpc/remote.py b/test/others/rpc/remote.py
new file mode 100644
index 00000000..96ce3e21
--- /dev/null
+++ b/test/others/rpc/remote.py
@@ -0,0 +1,86 @@ 
+#!/usr/bin/env python2
+
+import socket, os, imp, sys, errno, signal
+import rpc_pb2 as rpc
+import argparse
+
+MAX_MSG_SIZE = 1024
+
+parser = argparse.ArgumentParser(description="Test --remote option using CRIU RPC")
+parser.add_argument('socket', type = str, help = "CRIU service socket")
+parser.add_argument('dir', type = str, help = "Directory where CRIU images should be placed")
+parser.add_argument('pid', type = int, help = "PID of process to be dumped")
+
+args = vars(parser.parse_args())
+
+# Connect to RPC socket
+s = socket.socket(socket.AF_UNIX, socket.SOCK_SEQPACKET)
+s.connect(args['socket'])
+
+# Open images-dir
+dir_fd = os.open(args['dir'], os.O_DIRECTORY)
+if dir_fd < 0:
+	print "Failed to open dir %s" % args['dir']
+	sys.exit(-1)
+
+# Prepare dump request
+req = rpc.criu_req()
+req.type = rpc.DUMP
+req.opts.remote	= True
+req.opts.log_level = 4
+req.opts.pid = args['pid']
+req.opts.images_dir_fd	= dir_fd
+
+# Send dump request
+s.send(req.SerializeToString())
+
+# Receive responce
+resp	= rpc.criu_resp()
+resp.ParseFromString(s.recv(MAX_MSG_SIZE))
+
+# Reconnect to RPC socket
+s.close()
+s = socket.socket(socket.AF_UNIX, socket.SOCK_SEQPACKET)
+s.connect(args['socket'])
+
+
+if resp.type != rpc.DUMP:
+	print 'Unexpected dump msg type'
+	sys.exit(-1)
+else:
+	if resp.success:
+		print 'Dump Success'
+	else:
+		print 'Dump Fail'
+		sys.exit(-1)
+
+req			= rpc.criu_req()
+req.type		= rpc.RESTORE
+req.opts.remote	= True
+req.opts.log_level = 4
+req.opts.images_dir_fd	= dir_fd
+
+# Send restore request
+s.send(req.SerializeToString())
+
+# Receive response
+resp		= rpc.criu_resp()
+resp.ParseFromString(s.recv(MAX_MSG_SIZE))
+
+# Close RPC socket
+s.close()
+# Close fd of images dir
+os.close(dir_fd)
+
+if resp.type != rpc.RESTORE:
+	print 'Unexpected restore msg type'
+	sys.exit(-1)
+else:
+	if resp.success:
+		print 'Restore success'
+		print "PID of the restored program is %d\n" % (resp.restore.pid)
+		# Kill restored process
+		os.kill(resp.restore.pid, signal.SIGTERM)
+	else:
+		print 'Restore fail'
+		sys.exit(-1)
diff --git a/test/others/rpc/run.sh b/test/others/rpc/run.sh
index ed99addb..5364cc90 100755
--- a/test/others/rpc/run.sh
+++ b/test/others/rpc/run.sh
@@ -76,6 +76,31 @@  function test_errno {
 	setsid ./errno.py build/criu_service.socket build/imgs_errno < /dev/null &>> build/output_errno
 }
 
+function test_remote {
+	mkdir -p build/imgs_remote
+
+	title_print "Run image-cache"
+	${CRIU} image-cache -v4 -o dump-loop.log -D build/imgs_remote --port 9996 &
+	CACHE_PID=${!}
+
+	title_print "Run image-proxy"
+	${CRIU} image-proxy -v4 -o dump-loop.log -D build/imgs_remote --address localhost --port 9996 &
+	PROXY_PID=${!}
+
+	title_print "Run loop.sh"
+	setsid ./loop.sh < /dev/null &> build/loop.log &
+	LOOP_PID=${!}
+	echo "Start loop with pid ${P}"
+
+	title_print "Run dump/restore with --remote test"
+	./remote.py build/criu_service.socket build/imgs_remote $P < /dev/null &>> build/output_remote
+
+	# Clean up on failure
+	kill -SIGTERM ${LOOP_PID}
+	kill -SIGTERM ${CACHE_PID}
+	kill -SIGTERM ${PROXT_PID}
+}
+
 trap 'echo "FAIL"; stop_server' EXIT
 
 start_server
@@ -85,6 +110,7 @@  test_py
 test_restore_loop
 test_ps
 test_errno
+test_remote
 
 stop_server
 

Comments

Andrey Vagin May 10, 2018, 1:10 a.m.
Hi Radostin,

Should we run this test in scripts/travis/travis-tests?

Rodrigo has patches, which reworks image proxy & cache to a single
thread model. These patches are mostly ready to be merged, but need
some work.

Would it be interesting for you to finish criu --remote, that we could
merge it into the master branch?

For that, all tests have to pass, and image and cache have to
be single-thread processes.

There is one inline comment.

On Mon, Feb 12, 2018 at 10:54:05AM +0000, Radostin Stoyanov wrote:
> Signed-off-by: Radostin Stoyanov <rstoyanov1@gmail.com>
> ---
>  test/others/rpc/remote.py | 86 +++++++++++++++++++++++++++++++++++++++++++++++
>  test/others/rpc/run.sh    | 26 ++++++++++++++
>  2 files changed, 112 insertions(+)
>  create mode 100644 test/others/rpc/remote.py
> 
> diff --git a/test/others/rpc/remote.py b/test/others/rpc/remote.py
> new file mode 100644
> index 00000000..96ce3e21
> --- /dev/null
> +++ b/test/others/rpc/remote.py
> @@ -0,0 +1,86 @@
> +#!/usr/bin/env python2
> +
> +import socket, os, imp, sys, errno, signal
> +import rpc_pb2 as rpc
> +import argparse
> +
> +MAX_MSG_SIZE = 1024
> +
> +parser = argparse.ArgumentParser(description="Test --remote option using CRIU RPC")
> +parser.add_argument('socket', type = str, help = "CRIU service socket")
> +parser.add_argument('dir', type = str, help = "Directory where CRIU images should be placed")
> +parser.add_argument('pid', type = int, help = "PID of process to be dumped")
> +
> +args = vars(parser.parse_args())
> +
> +# Connect to RPC socket
> +s = socket.socket(socket.AF_UNIX, socket.SOCK_SEQPACKET)
> +s.connect(args['socket'])
> +
> +# Open images-dir
> +dir_fd = os.open(args['dir'], os.O_DIRECTORY)
> +if dir_fd < 0:
> +	print "Failed to open dir %s" % args['dir']
> +	sys.exit(-1)
> +
> +# Prepare dump request
> +req = rpc.criu_req()
> +req.type = rpc.DUMP
> +req.opts.remote	= True
> +req.opts.log_level = 4
> +req.opts.pid = args['pid']
> +req.opts.images_dir_fd	= dir_fd
> +
> +# Send dump request
> +s.send(req.SerializeToString())
> +
> +# Receive responce
> +resp	= rpc.criu_resp()
> +resp.ParseFromString(s.recv(MAX_MSG_SIZE))
> +
> +# Reconnect to RPC socket
> +s.close()
> +s = socket.socket(socket.AF_UNIX, socket.SOCK_SEQPACKET)
> +s.connect(args['socket'])
> +
> +
> +if resp.type != rpc.DUMP:
> +	print 'Unexpected dump msg type'
> +	sys.exit(-1)
> +else:
> +	if resp.success:
> +		print 'Dump Success'
> +	else:
> +		print 'Dump Fail'
> +		sys.exit(-1)
> +
> +req			= rpc.criu_req()
> +req.type		= rpc.RESTORE
> +req.opts.remote	= True
> +req.opts.log_level = 4
> +req.opts.images_dir_fd	= dir_fd
> +
> +# Send restore request
> +s.send(req.SerializeToString())
> +
> +# Receive response
> +resp		= rpc.criu_resp()
> +resp.ParseFromString(s.recv(MAX_MSG_SIZE))
> +
> +# Close RPC socket
> +s.close()
> +# Close fd of images dir
> +os.close(dir_fd)
> +
> +if resp.type != rpc.RESTORE:
> +	print 'Unexpected restore msg type'
> +	sys.exit(-1)
> +else:
> +	if resp.success:
> +		print 'Restore success'
> +		print "PID of the restored program is %d\n" % (resp.restore.pid)
> +		# Kill restored process
> +		os.kill(resp.restore.pid, signal.SIGTERM)
> +	else:
> +		print 'Restore fail'
> +		sys.exit(-1)
> diff --git a/test/others/rpc/run.sh b/test/others/rpc/run.sh
> index ed99addb..5364cc90 100755
> --- a/test/others/rpc/run.sh
> +++ b/test/others/rpc/run.sh
> @@ -76,6 +76,31 @@ function test_errno {
>  	setsid ./errno.py build/criu_service.socket build/imgs_errno < /dev/null &>> build/output_errno
>  }
>  
> +function test_remote {
> +	mkdir -p build/imgs_remote
> +
> +	title_print "Run image-cache"
> +	${CRIU} image-cache -v4 -o dump-loop.log -D build/imgs_remote --port 9996 &
> +	CACHE_PID=${!}
> +
> +	title_print "Run image-proxy"
> +	${CRIU} image-proxy -v4 -o dump-loop.log -D build/imgs_remote --address localhost --port 9996 &

How do you wait when image-cache creates a listen socket?

> +	PROXY_PID=${!}
> +
> +	title_print "Run loop.sh"
> +	setsid ./loop.sh < /dev/null &> build/loop.log &
> +	LOOP_PID=${!}
> +	echo "Start loop with pid ${P}"
> +
> +	title_print "Run dump/restore with --remote test"
> +	./remote.py build/criu_service.socket build/imgs_remote $P < /dev/null &>> build/output_remote
> +
> +	# Clean up on failure
> +	kill -SIGTERM ${LOOP_PID}
> +	kill -SIGTERM ${CACHE_PID}
> +	kill -SIGTERM ${PROXT_PID}
> +}
> +
>  trap 'echo "FAIL"; stop_server' EXIT
>  
>  start_server
> @@ -85,6 +110,7 @@ test_py
>  test_restore_loop
>  test_ps
>  test_errno
> +test_remote
>  
>  stop_server
>  
> -- 
> 2.14.3
> 
> _______________________________________________
> CRIU mailing list
> CRIU@openvz.org
> https://lists.openvz.org/mailman/listinfo/criu
Rodrigo Bruno May 10, 2018, 9:05 a.m.
Hi Andrei and Radostin,

in our last iteration, I sent to Andei a patch to rework the cache-proxy
code to be single threaded.

Is it possible to merge that patch into CRIU dev?

I think it would be easy this way because we would be then working on small
code changes to fix bugs related to tests failing.

I would be able to help fixing the implementation.

best,
rodrigo

2018-05-10 2:10 GMT+01:00 Andrei Vagin <avagin@virtuozzo.com>:

> Hi Radostin,
>
> Should we run this test in scripts/travis/travis-tests?
>
> Rodrigo has patches, which reworks image proxy & cache to a single
> thread model. These patches are mostly ready to be merged, but need
> some work.
>
> Would it be interesting for you to finish criu --remote, that we could
> merge it into the master branch?
>
> For that, all tests have to pass, and image and cache have to
> be single-thread processes.
>
> There is one inline comment.
>
> On Mon, Feb 12, 2018 at 10:54:05AM +0000, Radostin Stoyanov wrote:
> > Signed-off-by: Radostin Stoyanov <rstoyanov1@gmail.com>
> > ---
> >  test/others/rpc/remote.py | 86 ++++++++++++++++++++++++++++++
> +++++++++++++++++
> >  test/others/rpc/run.sh    | 26 ++++++++++++++
> >  2 files changed, 112 insertions(+)
> >  create mode 100644 test/others/rpc/remote.py
> >
> > diff --git a/test/others/rpc/remote.py b/test/others/rpc/remote.py
> > new file mode 100644
> > index 00000000..96ce3e21
> > --- /dev/null
> > +++ b/test/others/rpc/remote.py
> > @@ -0,0 +1,86 @@
> > +#!/usr/bin/env python2
> > +
> > +import socket, os, imp, sys, errno, signal
> > +import rpc_pb2 as rpc
> > +import argparse
> > +
> > +MAX_MSG_SIZE = 1024
> > +
> > +parser = argparse.ArgumentParser(description="Test --remote option
> using CRIU RPC")
> > +parser.add_argument('socket', type = str, help = "CRIU service socket")
> > +parser.add_argument('dir', type = str, help = "Directory where CRIU
> images should be placed")
> > +parser.add_argument('pid', type = int, help = "PID of process to be
> dumped")
> > +
> > +args = vars(parser.parse_args())
> > +
> > +# Connect to RPC socket
> > +s = socket.socket(socket.AF_UNIX, socket.SOCK_SEQPACKET)
> > +s.connect(args['socket'])
> > +
> > +# Open images-dir
> > +dir_fd = os.open(args['dir'], os.O_DIRECTORY)
> > +if dir_fd < 0:
> > +     print "Failed to open dir %s" % args['dir']
> > +     sys.exit(-1)
> > +
> > +# Prepare dump request
> > +req = rpc.criu_req()
> > +req.type = rpc.DUMP
> > +req.opts.remote      = True
> > +req.opts.log_level = 4
> > +req.opts.pid = args['pid']
> > +req.opts.images_dir_fd       = dir_fd
> > +
> > +# Send dump request
> > +s.send(req.SerializeToString())
> > +
> > +# Receive responce
> > +resp = rpc.criu_resp()
> > +resp.ParseFromString(s.recv(MAX_MSG_SIZE))
> > +
> > +# Reconnect to RPC socket
> > +s.close()
> > +s = socket.socket(socket.AF_UNIX, socket.SOCK_SEQPACKET)
> > +s.connect(args['socket'])
> > +
> > +
> > +if resp.type != rpc.DUMP:
> > +     print 'Unexpected dump msg type'
> > +     sys.exit(-1)
> > +else:
> > +     if resp.success:
> > +             print 'Dump Success'
> > +     else:
> > +             print 'Dump Fail'
> > +             sys.exit(-1)
> > +
> > +req                  = rpc.criu_req()
> > +req.type             = rpc.RESTORE
> > +req.opts.remote      = True
> > +req.opts.log_level = 4
> > +req.opts.images_dir_fd       = dir_fd
> > +
> > +# Send restore request
> > +s.send(req.SerializeToString())
> > +
> > +# Receive response
> > +resp         = rpc.criu_resp()
> > +resp.ParseFromString(s.recv(MAX_MSG_SIZE))
> > +
> > +# Close RPC socket
> > +s.close()
> > +# Close fd of images dir
> > +os.close(dir_fd)
> > +
> > +if resp.type != rpc.RESTORE:
> > +     print 'Unexpected restore msg type'
> > +     sys.exit(-1)
> > +else:
> > +     if resp.success:
> > +             print 'Restore success'
> > +             print "PID of the restored program is %d\n" %
> (resp.restore.pid)
> > +             # Kill restored process
> > +             os.kill(resp.restore.pid, signal.SIGTERM)
> > +     else:
> > +             print 'Restore fail'
> > +             sys.exit(-1)
> > diff --git a/test/others/rpc/run.sh b/test/others/rpc/run.sh
> > index ed99addb..5364cc90 100755
> > --- a/test/others/rpc/run.sh
> > +++ b/test/others/rpc/run.sh
> > @@ -76,6 +76,31 @@ function test_errno {
> >       setsid ./errno.py build/criu_service.socket build/imgs_errno <
> /dev/null &>> build/output_errno
> >  }
> >
> > +function test_remote {
> > +     mkdir -p build/imgs_remote
> > +
> > +     title_print "Run image-cache"
> > +     ${CRIU} image-cache -v4 -o dump-loop.log -D build/imgs_remote
> --port 9996 &
> > +     CACHE_PID=${!}
> > +
> > +     title_print "Run image-proxy"
> > +     ${CRIU} image-proxy -v4 -o dump-loop.log -D build/imgs_remote
> --address localhost --port 9996 &
>
> How do you wait when image-cache creates a listen socket?
>
> > +     PROXY_PID=${!}
> > +
> > +     title_print "Run loop.sh"
> > +     setsid ./loop.sh < /dev/null &> build/loop.log &
> > +     LOOP_PID=${!}
> > +     echo "Start loop with pid ${P}"
> > +
> > +     title_print "Run dump/restore with --remote test"
> > +     ./remote.py build/criu_service.socket build/imgs_remote $P <
> /dev/null &>> build/output_remote
> > +
> > +     # Clean up on failure
> > +     kill -SIGTERM ${LOOP_PID}
> > +     kill -SIGTERM ${CACHE_PID}
> > +     kill -SIGTERM ${PROXT_PID}
> > +}
> > +
> >  trap 'echo "FAIL"; stop_server' EXIT
> >
> >  start_server
> > @@ -85,6 +110,7 @@ test_py
> >  test_restore_loop
> >  test_ps
> >  test_errno
> > +test_remote
> >
> >  stop_server
> >
> > --
> > 2.14.3
> >
> > _______________________________________________
> > CRIU mailing list
> > CRIU@openvz.org
> > https://lists.openvz.org/mailman/listinfo/criu
>
Radostin Stoyanov May 10, 2018, 10:18 a.m.
Hi Andrei and Rodrigo,

I would be happy to help finishing the criu --remote work and complete
the Image cache/proxy TODO list [1].
Rodrigo would you be able to send the patches for single thread model to
the mailing list?

[1] https://criu.org/Image_cache/proxy_TODO

--
Radostin

On 10/05/18 10:05, Rodrigo Bruno wrote:
> Hi Andrei and Radostin,
>
> in our last iteration, I sent to Andei a patch to rework the
> cache-proxy code to be single threaded.
>
> Is it possible to merge that patch into CRIU dev?
>
> I think it would be easy this way because we would be then working on
> small code changes to fix bugs related to tests failing.
>
> I would be able to help fixing the implementation.
>
> best,
> rodrigo
>
> 2018-05-10 2:10 GMT+01:00 Andrei Vagin <avagin@virtuozzo.com
> <mailto:avagin@virtuozzo.com>>:
>
>     Hi Radostin,
>
>     Should we run this test in scripts/travis/travis-tests?
>
>     Rodrigo has patches, which reworks image proxy & cache to a single
>     thread model. These patches are mostly ready to be merged, but need
>     some work.
>
>     Would it be interesting for you to finish criu --remote, that we could
>     merge it into the master branch?
>
>     For that, all tests have to pass, and image and cache have to
>     be single-thread processes.
>
>     There is one inline comment.
>
>     On Mon, Feb 12, 2018 at 10:54:05AM +0000, Radostin Stoyanov wrote:
>     > Signed-off-by: Radostin Stoyanov <rstoyanov1@gmail.com
>     <mailto:rstoyanov1@gmail.com>>
>     > ---
>     >  test/others/rpc/remote.py | 86
>     +++++++++++++++++++++++++++++++++++++++++++++++
>     >  test/others/rpc/run.sh    | 26 ++++++++++++++
>     >  2 files changed, 112 insertions(+)
>     >  create mode 100644 test/others/rpc/remote.py
>     >
>     > diff --git a/test/others/rpc/remote.py b/test/others/rpc/remote.py
>     > new file mode 100644
>     > index 00000000..96ce3e21
>     > --- /dev/null
>     > +++ b/test/others/rpc/remote.py
>     > @@ -0,0 +1,86 @@
>     > +#!/usr/bin/env python2
>     > +
>     > +import socket, os, imp, sys, errno, signal
>     > +import rpc_pb2 as rpc
>     > +import argparse
>     > +
>     > +MAX_MSG_SIZE = 1024
>     > +
>     > +parser = argparse.ArgumentParser(description="Test --remote
>     option using CRIU RPC")
>     > +parser.add_argument('socket', type = str, help = "CRIU service
>     socket")
>     > +parser.add_argument('dir', type = str, help = "Directory where
>     CRIU images should be placed")
>     > +parser.add_argument('pid', type = int, help = "PID of process
>     to be dumped")
>     > +
>     > +args = vars(parser.parse_args())
>     > +
>     > +# Connect to RPC socket
>     > +s = socket.socket(socket.AF_UNIX, socket.SOCK_SEQPACKET)
>     > +s.connect(args['socket'])
>     > +
>     > +# Open images-dir
>     > +dir_fd = os.open(args['dir'], os.O_DIRECTORY)
>     > +if dir_fd < 0:
>     > +     print "Failed to open dir %s" % args['dir']
>     > +     sys.exit(-1)
>     > +
>     > +# Prepare dump request
>     > +req = rpc.criu_req()
>     > +req.type = rpc.DUMP
>     > +req.opts.remote      = True
>     > +req.opts.log_level = 4
>     > +req.opts.pid = args['pid']
>     > +req.opts.images_dir_fd       = dir_fd
>     > +
>     > +# Send dump request
>     > +s.send(req.SerializeToString())
>     > +
>     > +# Receive responce
>     > +resp = rpc.criu_resp()
>     > +resp.ParseFromString(s.recv(MAX_MSG_SIZE))
>     > +
>     > +# Reconnect to RPC socket
>     > +s.close()
>     > +s = socket.socket(socket.AF_UNIX, socket.SOCK_SEQPACKET)
>     > +s.connect(args['socket'])
>     > +
>     > +
>     > +if resp.type != rpc.DUMP:
>     > +     print 'Unexpected dump msg type'
>     > +     sys.exit(-1)
>     > +else:
>     > +     if resp.success:
>     > +             print 'Dump Success'
>     > +     else:
>     > +             print 'Dump Fail'
>     > +             sys.exit(-1)
>     > +
>     > +req                  = rpc.criu_req()
>     > +req.type             = rpc.RESTORE
>     > +req.opts.remote      = True
>     > +req.opts.log_level = 4
>     > +req.opts.images_dir_fd       = dir_fd
>     > +
>     > +# Send restore request
>     > +s.send(req.SerializeToString())
>     > +
>     > +# Receive response
>     > +resp         = rpc.criu_resp()
>     > +resp.ParseFromString(s.recv(MAX_MSG_SIZE))
>     > +
>     > +# Close RPC socket
>     > +s.close()
>     > +# Close fd of images dir
>     > +os.close(dir_fd)
>     > +
>     > +if resp.type != rpc.RESTORE:
>     > +     print 'Unexpected restore msg type'
>     > +     sys.exit(-1)
>     > +else:
>     > +     if resp.success:
>     > +             print 'Restore success'
>     > +             print "PID of the restored program is %d\n" %
>     (resp.restore.pid)
>     > +             # Kill restored process
>     > +             os.kill(resp.restore.pid, signal.SIGTERM)
>     > +     else:
>     > +             print 'Restore fail'
>     > +             sys.exit(-1)
>     > diff --git a/test/others/rpc/run.sh b/test/others/rpc/run.sh
>     > index ed99addb..5364cc90 100755
>     > --- a/test/others/rpc/run.sh
>     > +++ b/test/others/rpc/run.sh
>     > @@ -76,6 +76,31 @@ function test_errno {
>     >       setsid ./errno.py build/criu_service.socket
>     build/imgs_errno < /dev/null &>> build/output_errno
>     >  }
>     > 
>     > +function test_remote {
>     > +     mkdir -p build/imgs_remote
>     > +
>     > +     title_print "Run image-cache"
>     > +     ${CRIU} image-cache -v4 -o dump-loop.log -D
>     build/imgs_remote --port 9996 &
>     > +     CACHE_PID=${!}
>     > +
>     > +     title_print "Run image-proxy"
>     > +     ${CRIU} image-proxy -v4 -o dump-loop.log -D
>     build/imgs_remote --address localhost --port 9996 &
>
>     How do you wait when image-cache creates a listen socket?
>
>     > +     PROXY_PID=${!}
>     > +
>     > +     title_print "Run loop.sh"
>     > +     setsid ./loop.sh < /dev/null &> build/loop.log &
>     > +     LOOP_PID=${!}
>     > +     echo "Start loop with pid ${P}"
>     > +
>     > +     title_print "Run dump/restore with --remote test"
>     > +     ./remote.py build/criu_service.socket build/imgs_remote $P
>     < /dev/null &>> build/output_remote
>     > +
>     > +     # Clean up on failure
>     > +     kill -SIGTERM ${LOOP_PID}
>     > +     kill -SIGTERM ${CACHE_PID}
>     > +     kill -SIGTERM ${PROXT_PID}
>     > +}
>     > +
>     >  trap 'echo "FAIL"; stop_server' EXIT
>     > 
>     >  start_server
>     > @@ -85,6 +110,7 @@ test_py
>     >  test_restore_loop
>     >  test_ps
>     >  test_errno
>     > +test_remote
>     > 
>     >  stop_server
>     >  
>     > --
>     > 2.14.3
>     >
>     > _______________________________________________
>     > CRIU mailing list
>     > CRIU@openvz.org <mailto:CRIU@openvz.org>
>     > https://lists.openvz.org/mailman/listinfo/criu
>     <https://lists.openvz.org/mailman/listinfo/criu>
>
>
Andrey Vagin May 10, 2018, 4:19 p.m.
On Thu, May 10, 2018 at 10:05:37AM +0100, Rodrigo Bruno wrote:
> Hi Andrei and Radostin,
> 
> in our last iteration, I sent to Andei a patch to rework the cache-proxy
> code to be single threaded.
> 
> Is it possible to merge that patch into CRIU dev?

Yes, it is. Could you send the last version into the maling list?

Thanks,
Andrei

> 
> I think it would be easy this way because we would be then working on small
> code changes to fix bugs related to tests failing.
> 
> I would be able to help fixing the implementation.
> 
> best,
> rodrigo
> 
> 2018-05-10 2:10 GMT+01:00 Andrei Vagin <avagin@virtuozzo.com>:
> 
> > Hi Radostin,
> >
> > Should we run this test in scripts/travis/travis-tests?
> >
> > Rodrigo has patches, which reworks image proxy & cache to a single
> > thread model. These patches are mostly ready to be merged, but need
> > some work.
> >
> > Would it be interesting for you to finish criu --remote, that we could
> > merge it into the master branch?
> >
> > For that, all tests have to pass, and image and cache have to
> > be single-thread processes.
> >
> > There is one inline comment.
> >
> > On Mon, Feb 12, 2018 at 10:54:05AM +0000, Radostin Stoyanov wrote:
> > > Signed-off-by: Radostin Stoyanov <rstoyanov1@gmail.com>
> > > ---
> > >  test/others/rpc/remote.py | 86 ++++++++++++++++++++++++++++++
> > +++++++++++++++++
> > >  test/others/rpc/run.sh    | 26 ++++++++++++++
> > >  2 files changed, 112 insertions(+)
> > >  create mode 100644 test/others/rpc/remote.py
> > >
> > > diff --git a/test/others/rpc/remote.py b/test/others/rpc/remote.py
> > > new file mode 100644
> > > index 00000000..96ce3e21
> > > --- /dev/null
> > > +++ b/test/others/rpc/remote.py
> > > @@ -0,0 +1,86 @@
> > > +#!/usr/bin/env python2
> > > +
> > > +import socket, os, imp, sys, errno, signal
> > > +import rpc_pb2 as rpc
> > > +import argparse
> > > +
> > > +MAX_MSG_SIZE = 1024
> > > +
> > > +parser = argparse.ArgumentParser(description="Test --remote option
> > using CRIU RPC")
> > > +parser.add_argument('socket', type = str, help = "CRIU service socket")
> > > +parser.add_argument('dir', type = str, help = "Directory where CRIU
> > images should be placed")
> > > +parser.add_argument('pid', type = int, help = "PID of process to be
> > dumped")
> > > +
> > > +args = vars(parser.parse_args())
> > > +
> > > +# Connect to RPC socket
> > > +s = socket.socket(socket.AF_UNIX, socket.SOCK_SEQPACKET)
> > > +s.connect(args['socket'])
> > > +
> > > +# Open images-dir
> > > +dir_fd = os.open(args['dir'], os.O_DIRECTORY)
> > > +if dir_fd < 0:
> > > +     print "Failed to open dir %s" % args['dir']
> > > +     sys.exit(-1)
> > > +
> > > +# Prepare dump request
> > > +req = rpc.criu_req()
> > > +req.type = rpc.DUMP
> > > +req.opts.remote      = True
> > > +req.opts.log_level = 4
> > > +req.opts.pid = args['pid']
> > > +req.opts.images_dir_fd       = dir_fd
> > > +
> > > +# Send dump request
> > > +s.send(req.SerializeToString())
> > > +
> > > +# Receive responce
> > > +resp = rpc.criu_resp()
> > > +resp.ParseFromString(s.recv(MAX_MSG_SIZE))
> > > +
> > > +# Reconnect to RPC socket
> > > +s.close()
> > > +s = socket.socket(socket.AF_UNIX, socket.SOCK_SEQPACKET)
> > > +s.connect(args['socket'])
> > > +
> > > +
> > > +if resp.type != rpc.DUMP:
> > > +     print 'Unexpected dump msg type'
> > > +     sys.exit(-1)
> > > +else:
> > > +     if resp.success:
> > > +             print 'Dump Success'
> > > +     else:
> > > +             print 'Dump Fail'
> > > +             sys.exit(-1)
> > > +
> > > +req                  = rpc.criu_req()
> > > +req.type             = rpc.RESTORE
> > > +req.opts.remote      = True
> > > +req.opts.log_level = 4
> > > +req.opts.images_dir_fd       = dir_fd
> > > +
> > > +# Send restore request
> > > +s.send(req.SerializeToString())
> > > +
> > > +# Receive response
> > > +resp         = rpc.criu_resp()
> > > +resp.ParseFromString(s.recv(MAX_MSG_SIZE))
> > > +
> > > +# Close RPC socket
> > > +s.close()
> > > +# Close fd of images dir
> > > +os.close(dir_fd)
> > > +
> > > +if resp.type != rpc.RESTORE:
> > > +     print 'Unexpected restore msg type'
> > > +     sys.exit(-1)
> > > +else:
> > > +     if resp.success:
> > > +             print 'Restore success'
> > > +             print "PID of the restored program is %d\n" %
> > (resp.restore.pid)
> > > +             # Kill restored process
> > > +             os.kill(resp.restore.pid, signal.SIGTERM)
> > > +     else:
> > > +             print 'Restore fail'
> > > +             sys.exit(-1)
> > > diff --git a/test/others/rpc/run.sh b/test/others/rpc/run.sh
> > > index ed99addb..5364cc90 100755
> > > --- a/test/others/rpc/run.sh
> > > +++ b/test/others/rpc/run.sh
> > > @@ -76,6 +76,31 @@ function test_errno {
> > >       setsid ./errno.py build/criu_service.socket build/imgs_errno <
> > /dev/null &>> build/output_errno
> > >  }
> > >
> > > +function test_remote {
> > > +     mkdir -p build/imgs_remote
> > > +
> > > +     title_print "Run image-cache"
> > > +     ${CRIU} image-cache -v4 -o dump-loop.log -D build/imgs_remote
> > --port 9996 &
> > > +     CACHE_PID=${!}
> > > +
> > > +     title_print "Run image-proxy"
> > > +     ${CRIU} image-proxy -v4 -o dump-loop.log -D build/imgs_remote
> > --address localhost --port 9996 &
> >
> > How do you wait when image-cache creates a listen socket?
> >
> > > +     PROXY_PID=${!}
> > > +
> > > +     title_print "Run loop.sh"
> > > +     setsid ./loop.sh < /dev/null &> build/loop.log &
> > > +     LOOP_PID=${!}
> > > +     echo "Start loop with pid ${P}"
> > > +
> > > +     title_print "Run dump/restore with --remote test"
> > > +     ./remote.py build/criu_service.socket build/imgs_remote $P <
> > /dev/null &>> build/output_remote
> > > +
> > > +     # Clean up on failure
> > > +     kill -SIGTERM ${LOOP_PID}
> > > +     kill -SIGTERM ${CACHE_PID}
> > > +     kill -SIGTERM ${PROXT_PID}
> > > +}
> > > +
> > >  trap 'echo "FAIL"; stop_server' EXIT
> > >
> > >  start_server
> > > @@ -85,6 +110,7 @@ test_py
> > >  test_restore_loop
> > >  test_ps
> > >  test_errno
> > > +test_remote
> > >
> > >  stop_server
> > >
> > > --
> > > 2.14.3
> > >
> > > _______________________________________________
> > > CRIU mailing list
> > > CRIU@openvz.org
> > > https://lists.openvz.org/mailman/listinfo/criu
> >
Rodrigo Bruno May 12, 2018, 1:32 p.m.
Hi,

it seams that I cannot build criu-dev (I can still build the master branch):

In file included from soccr/soccr.c:9:0:
soccr/soccr.h:14:8: error: redefinition of ‘struct tcp_repair_window’
 struct tcp_repair_window {
        ^~~~~~~~~~~~~~~~~
In file included from soccr/soccr.c:5:0:
/usr/include/netinet/tcp.h:319:8: note: originally defined here
 struct tcp_repair_window
        ^~~~~~~~~~~~~~~~~


Currently using: Linux criu-devel 4.15.0-20-generic

Any idea?

cheers,
rodrigo

2018-05-10 17:19 GMT+01:00 Andrei Vagin <avagin@virtuozzo.com>:

> On Thu, May 10, 2018 at 10:05:37AM +0100, Rodrigo Bruno wrote:
> > Hi Andrei and Radostin,
> >
> > in our last iteration, I sent to Andei a patch to rework the cache-proxy
> > code to be single threaded.
> >
> > Is it possible to merge that patch into CRIU dev?
>
> Yes, it is. Could you send the last version into the maling list?
>
> Thanks,
> Andrei
>
> >
> > I think it would be easy this way because we would be then working on
> small
> > code changes to fix bugs related to tests failing.
> >
> > I would be able to help fixing the implementation.
> >
> > best,
> > rodrigo
> >
> > 2018-05-10 2:10 GMT+01:00 Andrei Vagin <avagin@virtuozzo.com>:
> >
> > > Hi Radostin,
> > >
> > > Should we run this test in scripts/travis/travis-tests?
> > >
> > > Rodrigo has patches, which reworks image proxy & cache to a single
> > > thread model. These patches are mostly ready to be merged, but need
> > > some work.
> > >
> > > Would it be interesting for you to finish criu --remote, that we could
> > > merge it into the master branch?
> > >
> > > For that, all tests have to pass, and image and cache have to
> > > be single-thread processes.
> > >
> > > There is one inline comment.
> > >
> > > On Mon, Feb 12, 2018 at 10:54:05AM +0000, Radostin Stoyanov wrote:
> > > > Signed-off-by: Radostin Stoyanov <rstoyanov1@gmail.com>
> > > > ---
> > > >  test/others/rpc/remote.py | 86 ++++++++++++++++++++++++++++++
> > > +++++++++++++++++
> > > >  test/others/rpc/run.sh    | 26 ++++++++++++++
> > > >  2 files changed, 112 insertions(+)
> > > >  create mode 100644 test/others/rpc/remote.py
> > > >
> > > > diff --git a/test/others/rpc/remote.py b/test/others/rpc/remote.py
> > > > new file mode 100644
> > > > index 00000000..96ce3e21
> > > > --- /dev/null
> > > > +++ b/test/others/rpc/remote.py
> > > > @@ -0,0 +1,86 @@
> > > > +#!/usr/bin/env python2
> > > > +
> > > > +import socket, os, imp, sys, errno, signal
> > > > +import rpc_pb2 as rpc
> > > > +import argparse
> > > > +
> > > > +MAX_MSG_SIZE = 1024
> > > > +
> > > > +parser = argparse.ArgumentParser(description="Test --remote option
> > > using CRIU RPC")
> > > > +parser.add_argument('socket', type = str, help = "CRIU service
> socket")
> > > > +parser.add_argument('dir', type = str, help = "Directory where CRIU
> > > images should be placed")
> > > > +parser.add_argument('pid', type = int, help = "PID of process to be
> > > dumped")
> > > > +
> > > > +args = vars(parser.parse_args())
> > > > +
> > > > +# Connect to RPC socket
> > > > +s = socket.socket(socket.AF_UNIX, socket.SOCK_SEQPACKET)
> > > > +s.connect(args['socket'])
> > > > +
> > > > +# Open images-dir
> > > > +dir_fd = os.open(args['dir'], os.O_DIRECTORY)
> > > > +if dir_fd < 0:
> > > > +     print "Failed to open dir %s" % args['dir']
> > > > +     sys.exit(-1)
> > > > +
> > > > +# Prepare dump request
> > > > +req = rpc.criu_req()
> > > > +req.type = rpc.DUMP
> > > > +req.opts.remote      = True
> > > > +req.opts.log_level = 4
> > > > +req.opts.pid = args['pid']
> > > > +req.opts.images_dir_fd       = dir_fd
> > > > +
> > > > +# Send dump request
> > > > +s.send(req.SerializeToString())
> > > > +
> > > > +# Receive responce
> > > > +resp = rpc.criu_resp()
> > > > +resp.ParseFromString(s.recv(MAX_MSG_SIZE))
> > > > +
> > > > +# Reconnect to RPC socket
> > > > +s.close()
> > > > +s = socket.socket(socket.AF_UNIX, socket.SOCK_SEQPACKET)
> > > > +s.connect(args['socket'])
> > > > +
> > > > +
> > > > +if resp.type != rpc.DUMP:
> > > > +     print 'Unexpected dump msg type'
> > > > +     sys.exit(-1)
> > > > +else:
> > > > +     if resp.success:
> > > > +             print 'Dump Success'
> > > > +     else:
> > > > +             print 'Dump Fail'
> > > > +             sys.exit(-1)
> > > > +
> > > > +req                  = rpc.criu_req()
> > > > +req.type             = rpc.RESTORE
> > > > +req.opts.remote      = True
> > > > +req.opts.log_level = 4
> > > > +req.opts.images_dir_fd       = dir_fd
> > > > +
> > > > +# Send restore request
> > > > +s.send(req.SerializeToString())
> > > > +
> > > > +# Receive response
> > > > +resp         = rpc.criu_resp()
> > > > +resp.ParseFromString(s.recv(MAX_MSG_SIZE))
> > > > +
> > > > +# Close RPC socket
> > > > +s.close()
> > > > +# Close fd of images dir
> > > > +os.close(dir_fd)
> > > > +
> > > > +if resp.type != rpc.RESTORE:
> > > > +     print 'Unexpected restore msg type'
> > > > +     sys.exit(-1)
> > > > +else:
> > > > +     if resp.success:
> > > > +             print 'Restore success'
> > > > +             print "PID of the restored program is %d\n" %
> > > (resp.restore.pid)
> > > > +             # Kill restored process
> > > > +             os.kill(resp.restore.pid, signal.SIGTERM)
> > > > +     else:
> > > > +             print 'Restore fail'
> > > > +             sys.exit(-1)
> > > > diff --git a/test/others/rpc/run.sh b/test/others/rpc/run.sh
> > > > index ed99addb..5364cc90 100755
> > > > --- a/test/others/rpc/run.sh
> > > > +++ b/test/others/rpc/run.sh
> > > > @@ -76,6 +76,31 @@ function test_errno {
> > > >       setsid ./errno.py build/criu_service.socket build/imgs_errno <
> > > /dev/null &>> build/output_errno
> > > >  }
> > > >
> > > > +function test_remote {
> > > > +     mkdir -p build/imgs_remote
> > > > +
> > > > +     title_print "Run image-cache"
> > > > +     ${CRIU} image-cache -v4 -o dump-loop.log -D build/imgs_remote
> > > --port 9996 &
> > > > +     CACHE_PID=${!}
> > > > +
> > > > +     title_print "Run image-proxy"
> > > > +     ${CRIU} image-proxy -v4 -o dump-loop.log -D build/imgs_remote
> > > --address localhost --port 9996 &
> > >
> > > How do you wait when image-cache creates a listen socket?
> > >
> > > > +     PROXY_PID=${!}
> > > > +
> > > > +     title_print "Run loop.sh"
> > > > +     setsid ./loop.sh < /dev/null &> build/loop.log &
> > > > +     LOOP_PID=${!}
> > > > +     echo "Start loop with pid ${P}"
> > > > +
> > > > +     title_print "Run dump/restore with --remote test"
> > > > +     ./remote.py build/criu_service.socket build/imgs_remote $P <
> > > /dev/null &>> build/output_remote
> > > > +
> > > > +     # Clean up on failure
> > > > +     kill -SIGTERM ${LOOP_PID}
> > > > +     kill -SIGTERM ${CACHE_PID}
> > > > +     kill -SIGTERM ${PROXT_PID}
> > > > +}
> > > > +
> > > >  trap 'echo "FAIL"; stop_server' EXIT
> > > >
> > > >  start_server
> > > > @@ -85,6 +110,7 @@ test_py
> > > >  test_restore_loop
> > > >  test_ps
> > > >  test_errno
> > > > +test_remote
> > > >
> > > >  stop_server
> > > >
> > > > --
> > > > 2.14.3
> > > >
> > > > _______________________________________________
> > > > CRIU mailing list
> > > > CRIU@openvz.org
> > > > https://lists.openvz.org/mailman/listinfo/criu
> > >
>
Andrey Vagin May 12, 2018, 4:29 p.m.
On Sat, May 12, 2018 at 02:32:41PM +0100, Rodrigo Bruno wrote:
> Hi,
> 
> it seams that I cannot build criu-dev (I can still build the master branch):
> 
> In file included from soccr/soccr.c:9:0:
> soccr/soccr.h:14:8: error: redefinition of ‘struct tcp_repair_window’
>  struct tcp_repair_window {
>         ^~~~~~~~~~~~~~~~~
> In file included from soccr/soccr.c:5:0:
> /usr/include/netinet/tcp.h:319:8: note: originally defined here
>  struct tcp_repair_window
>         ^~~~~~~~~~~~~~~~~
> 
> 
> Currently using: Linux criu-devel 4.15.0-20-generic
> 
> Any idea?

We have a feature test, which should detect tcp_repair_window in
netinet/tcp.h

scripts/feature-tests.mak:

define FEATURE_TEST_TCP_REPAIR_WINDOW

#include <netinet/tcp.h>

int main(void)
{
        struct tcp_repair_window opts;

        opts.snd_wl1 = 0;

        return opts.snd_wl1;
}
endef


Could you try to clean a source directory and compile again?

git clean -dxf

> 
> cheers,
> rodrigo
> 
> 2018-05-10 17:19 GMT+01:00 Andrei Vagin <avagin@virtuozzo.com>:
> 
> > On Thu, May 10, 2018 at 10:05:37AM +0100, Rodrigo Bruno wrote:
> > > Hi Andrei and Radostin,
> > >
> > > in our last iteration, I sent to Andei a patch to rework the cache-proxy
> > > code to be single threaded.
> > >
> > > Is it possible to merge that patch into CRIU dev?
> >
> > Yes, it is. Could you send the last version into the maling list?
> >
> > Thanks,
> > Andrei
> >
> > >
> > > I think it would be easy this way because we would be then working on
> > small
> > > code changes to fix bugs related to tests failing.
> > >
> > > I would be able to help fixing the implementation.
> > >
> > > best,
> > > rodrigo
> > >
> > > 2018-05-10 2:10 GMT+01:00 Andrei Vagin <avagin@virtuozzo.com>:
> > >
> > > > Hi Radostin,
> > > >
> > > > Should we run this test in scripts/travis/travis-tests?
> > > >
> > > > Rodrigo has patches, which reworks image proxy & cache to a single
> > > > thread model. These patches are mostly ready to be merged, but need
> > > > some work.
> > > >
> > > > Would it be interesting for you to finish criu --remote, that we could
> > > > merge it into the master branch?
> > > >
> > > > For that, all tests have to pass, and image and cache have to
> > > > be single-thread processes.
> > > >
> > > > There is one inline comment.
> > > >
> > > > On Mon, Feb 12, 2018 at 10:54:05AM +0000, Radostin Stoyanov wrote:
> > > > > Signed-off-by: Radostin Stoyanov <rstoyanov1@gmail.com>
> > > > > ---
> > > > >  test/others/rpc/remote.py | 86 ++++++++++++++++++++++++++++++
> > > > +++++++++++++++++
> > > > >  test/others/rpc/run.sh    | 26 ++++++++++++++
> > > > >  2 files changed, 112 insertions(+)
> > > > >  create mode 100644 test/others/rpc/remote.py
> > > > >
> > > > > diff --git a/test/others/rpc/remote.py b/test/others/rpc/remote.py
> > > > > new file mode 100644
> > > > > index 00000000..96ce3e21
> > > > > --- /dev/null
> > > > > +++ b/test/others/rpc/remote.py
> > > > > @@ -0,0 +1,86 @@
> > > > > +#!/usr/bin/env python2
> > > > > +
> > > > > +import socket, os, imp, sys, errno, signal
> > > > > +import rpc_pb2 as rpc
> > > > > +import argparse
> > > > > +
> > > > > +MAX_MSG_SIZE = 1024
> > > > > +
> > > > > +parser = argparse.ArgumentParser(description="Test --remote option
> > > > using CRIU RPC")
> > > > > +parser.add_argument('socket', type = str, help = "CRIU service
> > socket")
> > > > > +parser.add_argument('dir', type = str, help = "Directory where CRIU
> > > > images should be placed")
> > > > > +parser.add_argument('pid', type = int, help = "PID of process to be
> > > > dumped")
> > > > > +
> > > > > +args = vars(parser.parse_args())
> > > > > +
> > > > > +# Connect to RPC socket
> > > > > +s = socket.socket(socket.AF_UNIX, socket.SOCK_SEQPACKET)
> > > > > +s.connect(args['socket'])
> > > > > +
> > > > > +# Open images-dir
> > > > > +dir_fd = os.open(args['dir'], os.O_DIRECTORY)
> > > > > +if dir_fd < 0:
> > > > > +     print "Failed to open dir %s" % args['dir']
> > > > > +     sys.exit(-1)
> > > > > +
> > > > > +# Prepare dump request
> > > > > +req = rpc.criu_req()
> > > > > +req.type = rpc.DUMP
> > > > > +req.opts.remote      = True
> > > > > +req.opts.log_level = 4
> > > > > +req.opts.pid = args['pid']
> > > > > +req.opts.images_dir_fd       = dir_fd
> > > > > +
> > > > > +# Send dump request
> > > > > +s.send(req.SerializeToString())
> > > > > +
> > > > > +# Receive responce
> > > > > +resp = rpc.criu_resp()
> > > > > +resp.ParseFromString(s.recv(MAX_MSG_SIZE))
> > > > > +
> > > > > +# Reconnect to RPC socket
> > > > > +s.close()
> > > > > +s = socket.socket(socket.AF_UNIX, socket.SOCK_SEQPACKET)
> > > > > +s.connect(args['socket'])
> > > > > +
> > > > > +
> > > > > +if resp.type != rpc.DUMP:
> > > > > +     print 'Unexpected dump msg type'
> > > > > +     sys.exit(-1)
> > > > > +else:
> > > > > +     if resp.success:
> > > > > +             print 'Dump Success'
> > > > > +     else:
> > > > > +             print 'Dump Fail'
> > > > > +             sys.exit(-1)
> > > > > +
> > > > > +req                  = rpc.criu_req()
> > > > > +req.type             = rpc.RESTORE
> > > > > +req.opts.remote      = True
> > > > > +req.opts.log_level = 4
> > > > > +req.opts.images_dir_fd       = dir_fd
> > > > > +
> > > > > +# Send restore request
> > > > > +s.send(req.SerializeToString())
> > > > > +
> > > > > +# Receive response
> > > > > +resp         = rpc.criu_resp()
> > > > > +resp.ParseFromString(s.recv(MAX_MSG_SIZE))
> > > > > +
> > > > > +# Close RPC socket
> > > > > +s.close()
> > > > > +# Close fd of images dir
> > > > > +os.close(dir_fd)
> > > > > +
> > > > > +if resp.type != rpc.RESTORE:
> > > > > +     print 'Unexpected restore msg type'
> > > > > +     sys.exit(-1)
> > > > > +else:
> > > > > +     if resp.success:
> > > > > +             print 'Restore success'
> > > > > +             print "PID of the restored program is %d\n" %
> > > > (resp.restore.pid)
> > > > > +             # Kill restored process
> > > > > +             os.kill(resp.restore.pid, signal.SIGTERM)
> > > > > +     else:
> > > > > +             print 'Restore fail'
> > > > > +             sys.exit(-1)
> > > > > diff --git a/test/others/rpc/run.sh b/test/others/rpc/run.sh
> > > > > index ed99addb..5364cc90 100755
> > > > > --- a/test/others/rpc/run.sh
> > > > > +++ b/test/others/rpc/run.sh
> > > > > @@ -76,6 +76,31 @@ function test_errno {
> > > > >       setsid ./errno.py build/criu_service.socket build/imgs_errno <
> > > > /dev/null &>> build/output_errno
> > > > >  }
> > > > >
> > > > > +function test_remote {
> > > > > +     mkdir -p build/imgs_remote
> > > > > +
> > > > > +     title_print "Run image-cache"
> > > > > +     ${CRIU} image-cache -v4 -o dump-loop.log -D build/imgs_remote
> > > > --port 9996 &
> > > > > +     CACHE_PID=${!}
> > > > > +
> > > > > +     title_print "Run image-proxy"
> > > > > +     ${CRIU} image-proxy -v4 -o dump-loop.log -D build/imgs_remote
> > > > --address localhost --port 9996 &
> > > >
> > > > How do you wait when image-cache creates a listen socket?
> > > >
> > > > > +     PROXY_PID=${!}
> > > > > +
> > > > > +     title_print "Run loop.sh"
> > > > > +     setsid ./loop.sh < /dev/null &> build/loop.log &
> > > > > +     LOOP_PID=${!}
> > > > > +     echo "Start loop with pid ${P}"
> > > > > +
> > > > > +     title_print "Run dump/restore with --remote test"
> > > > > +     ./remote.py build/criu_service.socket build/imgs_remote $P <
> > > > /dev/null &>> build/output_remote
> > > > > +
> > > > > +     # Clean up on failure
> > > > > +     kill -SIGTERM ${LOOP_PID}
> > > > > +     kill -SIGTERM ${CACHE_PID}
> > > > > +     kill -SIGTERM ${PROXT_PID}
> > > > > +}
> > > > > +
> > > > >  trap 'echo "FAIL"; stop_server' EXIT
> > > > >
> > > > >  start_server
> > > > > @@ -85,6 +110,7 @@ test_py
> > > > >  test_restore_loop
> > > > >  test_ps
> > > > >  test_errno
> > > > > +test_remote
> > > > >
> > > > >  stop_server
> > > > >
> > > > > --
> > > > > 2.14.3
> > > > >
> > > > > _______________________________________________
> > > > > CRIU mailing list
> > > > > CRIU@openvz.org
> > > > > https://lists.openvz.org/mailman/listinfo/criu
> > > >
> >
Rodrigo Bruno May 13, 2018, 3:27 p.m.
Andrei,

thanks, that did the trick. I will now send the patches.

cheers,
rodrigo


2018-05-12 17:29 GMT+01:00 Andrei Vagin <avagin@virtuozzo.com>:

> On Sat, May 12, 2018 at 02:32:41PM +0100, Rodrigo Bruno wrote:
> > Hi,
> >
> > it seams that I cannot build criu-dev (I can still build the master
> branch):
> >
> > In file included from soccr/soccr.c:9:0:
> > soccr/soccr.h:14:8: error: redefinition of ‘struct tcp_repair_window’
> >  struct tcp_repair_window {
> >         ^~~~~~~~~~~~~~~~~
> > In file included from soccr/soccr.c:5:0:
> > /usr/include/netinet/tcp.h:319:8: note: originally defined here
> >  struct tcp_repair_window
> >         ^~~~~~~~~~~~~~~~~
> >
> >
> > Currently using: Linux criu-devel 4.15.0-20-generic
> >
> > Any idea?
>
> We have a feature test, which should detect tcp_repair_window in
> netinet/tcp.h
>
> scripts/feature-tests.mak:
>
> define FEATURE_TEST_TCP_REPAIR_WINDOW
>
> #include <netinet/tcp.h>
>
> int main(void)
> {
>         struct tcp_repair_window opts;
>
>         opts.snd_wl1 = 0;
>
>         return opts.snd_wl1;
> }
> endef
>
>
> Could you try to clean a source directory and compile again?
>
> git clean -dxf
>
> >
> > cheers,
> > rodrigo
> >
> > 2018-05-10 17:19 GMT+01:00 Andrei Vagin <avagin@virtuozzo.com>:
> >
> > > On Thu, May 10, 2018 at 10:05:37AM +0100, Rodrigo Bruno wrote:
> > > > Hi Andrei and Radostin,
> > > >
> > > > in our last iteration, I sent to Andei a patch to rework the
> cache-proxy
> > > > code to be single threaded.
> > > >
> > > > Is it possible to merge that patch into CRIU dev?
> > >
> > > Yes, it is. Could you send the last version into the maling list?
> > >
> > > Thanks,
> > > Andrei
> > >
> > > >
> > > > I think it would be easy this way because we would be then working on
> > > small
> > > > code changes to fix bugs related to tests failing.
> > > >
> > > > I would be able to help fixing the implementation.
> > > >
> > > > best,
> > > > rodrigo
> > > >
> > > > 2018-05-10 2:10 GMT+01:00 Andrei Vagin <avagin@virtuozzo.com>:
> > > >
> > > > > Hi Radostin,
> > > > >
> > > > > Should we run this test in scripts/travis/travis-tests?
> > > > >
> > > > > Rodrigo has patches, which reworks image proxy & cache to a single
> > > > > thread model. These patches are mostly ready to be merged, but need
> > > > > some work.
> > > > >
> > > > > Would it be interesting for you to finish criu --remote, that we
> could
> > > > > merge it into the master branch?
> > > > >
> > > > > For that, all tests have to pass, and image and cache have to
> > > > > be single-thread processes.
> > > > >
> > > > > There is one inline comment.
> > > > >
> > > > > On Mon, Feb 12, 2018 at 10:54:05AM +0000, Radostin Stoyanov wrote:
> > > > > > Signed-off-by: Radostin Stoyanov <rstoyanov1@gmail.com>
> > > > > > ---
> > > > > >  test/others/rpc/remote.py | 86 ++++++++++++++++++++++++++++++
> > > > > +++++++++++++++++
> > > > > >  test/others/rpc/run.sh    | 26 ++++++++++++++
> > > > > >  2 files changed, 112 insertions(+)
> > > > > >  create mode 100644 test/others/rpc/remote.py
> > > > > >
> > > > > > diff --git a/test/others/rpc/remote.py
> b/test/others/rpc/remote.py
> > > > > > new file mode 100644
> > > > > > index 00000000..96ce3e21
> > > > > > --- /dev/null
> > > > > > +++ b/test/others/rpc/remote.py
> > > > > > @@ -0,0 +1,86 @@
> > > > > > +#!/usr/bin/env python2
> > > > > > +
> > > > > > +import socket, os, imp, sys, errno, signal
> > > > > > +import rpc_pb2 as rpc
> > > > > > +import argparse
> > > > > > +
> > > > > > +MAX_MSG_SIZE = 1024
> > > > > > +
> > > > > > +parser = argparse.ArgumentParser(description="Test --remote
> option
> > > > > using CRIU RPC")
> > > > > > +parser.add_argument('socket', type = str, help = "CRIU service
> > > socket")
> > > > > > +parser.add_argument('dir', type = str, help = "Directory where
> CRIU
> > > > > images should be placed")
> > > > > > +parser.add_argument('pid', type = int, help = "PID of process
> to be
> > > > > dumped")
> > > > > > +
> > > > > > +args = vars(parser.parse_args())
> > > > > > +
> > > > > > +# Connect to RPC socket
> > > > > > +s = socket.socket(socket.AF_UNIX, socket.SOCK_SEQPACKET)
> > > > > > +s.connect(args['socket'])
> > > > > > +
> > > > > > +# Open images-dir
> > > > > > +dir_fd = os.open(args['dir'], os.O_DIRECTORY)
> > > > > > +if dir_fd < 0:
> > > > > > +     print "Failed to open dir %s" % args['dir']
> > > > > > +     sys.exit(-1)
> > > > > > +
> > > > > > +# Prepare dump request
> > > > > > +req = rpc.criu_req()
> > > > > > +req.type = rpc.DUMP
> > > > > > +req.opts.remote      = True
> > > > > > +req.opts.log_level = 4
> > > > > > +req.opts.pid = args['pid']
> > > > > > +req.opts.images_dir_fd       = dir_fd
> > > > > > +
> > > > > > +# Send dump request
> > > > > > +s.send(req.SerializeToString())
> > > > > > +
> > > > > > +# Receive responce
> > > > > > +resp = rpc.criu_resp()
> > > > > > +resp.ParseFromString(s.recv(MAX_MSG_SIZE))
> > > > > > +
> > > > > > +# Reconnect to RPC socket
> > > > > > +s.close()
> > > > > > +s = socket.socket(socket.AF_UNIX, socket.SOCK_SEQPACKET)
> > > > > > +s.connect(args['socket'])
> > > > > > +
> > > > > > +
> > > > > > +if resp.type != rpc.DUMP:
> > > > > > +     print 'Unexpected dump msg type'
> > > > > > +     sys.exit(-1)
> > > > > > +else:
> > > > > > +     if resp.success:
> > > > > > +             print 'Dump Success'
> > > > > > +     else:
> > > > > > +             print 'Dump Fail'
> > > > > > +             sys.exit(-1)
> > > > > > +
> > > > > > +req                  = rpc.criu_req()
> > > > > > +req.type             = rpc.RESTORE
> > > > > > +req.opts.remote      = True
> > > > > > +req.opts.log_level = 4
> > > > > > +req.opts.images_dir_fd       = dir_fd
> > > > > > +
> > > > > > +# Send restore request
> > > > > > +s.send(req.SerializeToString())
> > > > > > +
> > > > > > +# Receive response
> > > > > > +resp         = rpc.criu_resp()
> > > > > > +resp.ParseFromString(s.recv(MAX_MSG_SIZE))
> > > > > > +
> > > > > > +# Close RPC socket
> > > > > > +s.close()
> > > > > > +# Close fd of images dir
> > > > > > +os.close(dir_fd)
> > > > > > +
> > > > > > +if resp.type != rpc.RESTORE:
> > > > > > +     print 'Unexpected restore msg type'
> > > > > > +     sys.exit(-1)
> > > > > > +else:
> > > > > > +     if resp.success:
> > > > > > +             print 'Restore success'
> > > > > > +             print "PID of the restored program is %d\n" %
> > > > > (resp.restore.pid)
> > > > > > +             # Kill restored process
> > > > > > +             os.kill(resp.restore.pid, signal.SIGTERM)
> > > > > > +     else:
> > > > > > +             print 'Restore fail'
> > > > > > +             sys.exit(-1)
> > > > > > diff --git a/test/others/rpc/run.sh b/test/others/rpc/run.sh
> > > > > > index ed99addb..5364cc90 100755
> > > > > > --- a/test/others/rpc/run.sh
> > > > > > +++ b/test/others/rpc/run.sh
> > > > > > @@ -76,6 +76,31 @@ function test_errno {
> > > > > >       setsid ./errno.py build/criu_service.socket
> build/imgs_errno <
> > > > > /dev/null &>> build/output_errno
> > > > > >  }
> > > > > >
> > > > > > +function test_remote {
> > > > > > +     mkdir -p build/imgs_remote
> > > > > > +
> > > > > > +     title_print "Run image-cache"
> > > > > > +     ${CRIU} image-cache -v4 -o dump-loop.log -D
> build/imgs_remote
> > > > > --port 9996 &
> > > > > > +     CACHE_PID=${!}
> > > > > > +
> > > > > > +     title_print "Run image-proxy"
> > > > > > +     ${CRIU} image-proxy -v4 -o dump-loop.log -D
> build/imgs_remote
> > > > > --address localhost --port 9996 &
> > > > >
> > > > > How do you wait when image-cache creates a listen socket?
> > > > >
> > > > > > +     PROXY_PID=${!}
> > > > > > +
> > > > > > +     title_print "Run loop.sh"
> > > > > > +     setsid ./loop.sh < /dev/null &> build/loop.log &
> > > > > > +     LOOP_PID=${!}
> > > > > > +     echo "Start loop with pid ${P}"
> > > > > > +
> > > > > > +     title_print "Run dump/restore with --remote test"
> > > > > > +     ./remote.py build/criu_service.socket build/imgs_remote $P
> <
> > > > > /dev/null &>> build/output_remote
> > > > > > +
> > > > > > +     # Clean up on failure
> > > > > > +     kill -SIGTERM ${LOOP_PID}
> > > > > > +     kill -SIGTERM ${CACHE_PID}
> > > > > > +     kill -SIGTERM ${PROXT_PID}
> > > > > > +}
> > > > > > +
> > > > > >  trap 'echo "FAIL"; stop_server' EXIT
> > > > > >
> > > > > >  start_server
> > > > > > @@ -85,6 +110,7 @@ test_py
> > > > > >  test_restore_loop
> > > > > >  test_ps
> > > > > >  test_errno
> > > > > > +test_remote
> > > > > >
> > > > > >  stop_server
> > > > > >
> > > > > > --
> > > > > > 2.14.3
> > > > > >
> > > > > > _______________________________________________
> > > > > > CRIU mailing list
> > > > > > CRIU@openvz.org
> > > > > > https://lists.openvz.org/mailman/listinfo/criu
> > > > >
> > >
>