start and stop rosbag within a python script

edit

Seems like

self.p = subprocess.Popen(command, stdin=subprocess.PIPE, shell=True, cwd=dir_save_bagfile)

starts a shell which then starts the program that does the job. One could see it with ps:

$ ps aux | grep record
sergey   17900  0.0  0.0   4272   584 pts/4    S    18:36   0:00 /bin/sh -c rosbag record -O /home/ . . . 
sergey   17901  7.3  0.1 288132  7124 pts/4    Sl   18:36   0:00 record --buffsize 256 -O /home/ . . .

Therefore killing the process with pid returned by subprocess.Popen does not kill the actual bag recording. We also need to kill its child. There is a nice code snippet here for kill_child_processes(). Here is my modified version:

import subprocess, os, signal

def terminate_process_and_children(p):
    ps_command = subprocess.Popen("ps -o pid --ppid %d --noheaders" % p.pid, shell=True, stdout=subprocess.PIPE)
    ps_output = ps_command.stdout.read()
    retcode = ps_command.wait()
    assert retcode == 0, "ps command returned %d" % retcode
    for pid_str in ps_output.split("\n")[:-1]:
            os.kill(int(pid_str), signal.SIGINT)
    p.terminate()

This function expects a subprocess.Popen object.

I was recently looking for solving the same issue and thought I would add my experience as this thread didn't have an answer that solved my problem.

The issue I was seeing was that rosbag would not clean exit, and thus write the .bag.active -> .bag file. Sending SIGINT, SIGKILL, etc.. in any order to the processes could not remedy the situation on my system.

Using rosnode I was able to kill the rosbag and have it cleanly exit. This would be more difficult when running multiple rosbag records at once (as you would need to find the rosnode id of each), however with only one running rosbag record, simply using 'rosnode list' to search for "/record_xxxx" and then executing "rosnode kill /record_xxxx" where xxx is the node id will cleanly exit the rosbag recording process.

def terminate_ros_node(s):
    list_cmd = subprocess.Popen("rosnode list", shell=True, stdout=subprocess.PIPE)
    list_output = list_cmd.stdout.read()
    retcode = list_cmd.wait()
    assert retcode == 0, "List command returned %d" % retcode
    for str in list_output.split("\n"):
        if (str.startswith(s)):
            os.system("rosnode kill " + str)

terminate_ros_node("/record")

Similar to sergey_alexandrov answer, but using psutils python module as highlight on stackoverflow : http://stackoverflow.com/questions/33...

def terminate_process_and_children(p):
  import psutil
  process = psutil.Process(p.pid)
  for sub_process in process.get_children(recursive=True):
      sub_process.send_signal(signal.SIGINT)
  p.wait()  # we wait for children to terminate
  p.terminate()

def main():
  dir_save_bagfile = '/tmp/'
  rosbag_process = subprocess.Popen('rosbag record -a -j -o {}'.format("my_rosbag_prefis"), stdin=subprocess.PIPE, shell=True, cwd=dir_save_bagfile)
  terminate_process_and_children(rosbag_process)

Picking from many of the answers here, I've come up with a class and ROS node to control recording start, stop and pause. Find it here.

You can either import the class and use it directly in your code or start the node standalone and use service calls to control recording.

There is a problem with pausing where, sometimes, some of the messages get their timestamps wrong after resuming recording. Unfortunately, I don't have the time to debug it now. Start and stop seem to work fine.

Tested with Ubuntu 16 and Kinetic.

The best solution to programmatic rosbag recording I've found is to wrap rosbag::Recorder in a C++ node. There isn't a way to shutdown recording in Recorder, but there can be a subscriber which calls ros::shutdown which will cleanly close the current recording bag file, and then the the node can be set to respawn=true. The exclude list can be passed in as a parameter and then useful other parameters set like below, or have params override defaults as desired:

  recorder_options_.exclude_regex = some_string_from_ros_param;
  ROS_INFO_STREAM("exclude list \"" << recorder_options_.exclude_regex << "\"");

  recorder_options_.record_all = true;    
  recorder_options_.trigger = false;
  recorder_options_.regex = false;
  recorder_options_.do_exclude = true;
  recorder_options_.quiet = false;
  recorder_options_.append_date = true;
  recorder_options_.verbose = false;
  recorder_options_.buffer_size = 1048576 * 512;
  recorder_options_.chunk_size = 1024 * 768;
  recorder_options_.limit = 0; // 0 is unlimited
  recorder_options_.split = true;
  recorder_options_.max_size = 1024 * 1024 * 1024;
  recorder_options_.min_space = 1024 * 1024 * 1024;
  recorder_options_.min_space_str = "Recording space is running out";