Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 5fb117bb authored by Nandana Dutt's avatar Nandana Dutt
Browse files

Separate options parsing from running dumpstate 

This refactor allows accepting options in other ways, for eg
via binder calls.

BUG: 111441001
Test: adb shell /data/nativetest64/dumpstate_test/dumpstate_test
Test: adb bugreport
Test: interactive bugreport
Change-Id: Id27c917a3b51e1b9c0485ef3ff473b3cf22243df
parent 8bae3798

cmds/dumpstate/DumpstateService.cpp

+6 −6
Original line number Diff line number Diff line
@@ -87,27 +87,27 @@ binder::Status DumpstateService::startBugreport(int, const sp<IDumpstateListener 
status_t DumpstateService::dump(int fd, const Vector<String16>&) {

    dprintf(fd, "id: %d\n", ds_.id_);

    dprintf(fd, "pid: %d\n", ds_.pid_);

    dprintf(fd, "update_progress: %s\n", ds_.update_progress_ ? "true" : "false");

    dprintf(fd, "update_progress: %s\n", ds_.options_->do_progress_updates ? "true" : "false");

    dprintf(fd, "update_progress_threshold: %d\n", ds_.update_progress_threshold_);

    dprintf(fd, "last_updated_progress: %d\n", ds_.last_updated_progress_);

    dprintf(fd, "progress:\n");

    ds_.progress_->Dump(fd, "  ");

    dprintf(fd, "args: %s\n", ds_.args_.c_str());

    dprintf(fd, "extra_options: %s\n", ds_.extra_options_.c_str());

    dprintf(fd, "args: %s\n", ds_.options_->args.c_str());

    dprintf(fd, "extra_options: %s\n", ds_.options_->extra_options.c_str());

    dprintf(fd, "version: %s\n", ds_.version_.c_str());

    dprintf(fd, "bugreport_dir: %s\n", ds_.bugreport_dir_.c_str());

    dprintf(fd, "screenshot_path: %s\n", ds_.screenshot_path_.c_str());

    dprintf(fd, "log_path: %s\n", ds_.log_path_.c_str());

    dprintf(fd, "tmp_path: %s\n", ds_.tmp_path_.c_str());

    dprintf(fd, "path: %s\n", ds_.path_.c_str());

    dprintf(fd, "extra_options: %s\n", ds_.extra_options_.c_str());

    dprintf(fd, "extra_options: %s\n", ds_.options_->extra_options.c_str());

    dprintf(fd, "base_name: %s\n", ds_.base_name_.c_str());

    dprintf(fd, "name: %s\n", ds_.name_.c_str());

    dprintf(fd, "now: %ld\n", ds_.now_);

    dprintf(fd, "is_zipping: %s\n", ds_.IsZipping() ? "true" : "false");

    dprintf(fd, "listener: %s\n", ds_.listener_name_.c_str());

    dprintf(fd, "notification title: %s\n", ds_.notification_title.c_str());

    dprintf(fd, "notification description: %s\n", ds_.notification_description.c_str());

    dprintf(fd, "notification title: %s\n", ds_.options_->notification_title.c_str());

    dprintf(fd, "notification description: %s\n", ds_.options_->notification_description.c_str());



    return NO_ERROR;

}

cmds/dumpstate/dumpstate.cpp

+185 −168

File changed.

Preview size limit exceeded, changes collapsed.

cmds/dumpstate/dumpstate.h

+22 −28
Original line number Diff line number Diff line
@@ -183,6 +183,8 @@ class Dumpstate { 
    friend class DumpstateTest;



  public:

    enum RunStatus { OK, HELP, INVALID_INPUT, ERROR };



    static android::os::dumpstate::CommandOptions DEFAULT_DUMPSYS;



    static Dumpstate& GetInstance();
@@ -290,22 +292,12 @@ class Dumpstate { 
    /* Returns true if the current version supports priority dump feature. */

    bool CurrentVersionSupportsPriorityDumps() const;



    // TODO: revisit the return values later.

    /*

     * Parses commandline arguments and sets runtime options accordingly.

     *

     * Returns 0 or positive number if the caller should exit with returned value as

     * exit code, or returns -1 if caller should proceed with execution.

     */

    int ParseCommandlineOptions(int argc, char* argv[]);

    struct DumpOptions;



    /* Sets runtime options from the system properties. */

    void SetOptionsFromProperties();

    /* Main entry point for running a complete bugreport. Takes ownership of options. */

    RunStatus RunWithOptions(std::unique_ptr<DumpOptions> options);



    /* Returns true if the options set so far are consistent. */

    bool ValidateOptions();



    // TODO: add update_progress_ & other options from DumpState.

    // TODO: add other options from DumpState.

    /*

     * Structure to hold options that determine the behavior of dumpstate.

     */
@@ -322,7 +314,22 @@ class Dumpstate { 
        bool do_start_service = false;

        bool telephony_only = false;

        bool wifi_only = false;

        // Whether progress updates should be published.

        bool do_progress_updates = false;

        std::string use_outfile;

        // Extra options passed as system property.

        std::string extra_options;

        // Command-line arguments as string

        std::string args;

        // Notification title and description

        std::string notification_title;

        std::string notification_description;



        /* Initializes options from commandline arguments and system properties. */

        RunStatus Initialize(int argc, char* argv[]);



        /* Returns true if the options set so far are consistent. */

        bool ValidateOptions() const;

    };



    // TODO: initialize fields on constructor
@@ -333,10 +340,7 @@ class Dumpstate { 
    pid_t pid_;



    // Runtime options.

    DumpOptions options_;



    // Whether progress updates should be published.

    bool update_progress_ = false;

    std::unique_ptr<DumpOptions> options_;



    // How frequently the progess should be updated;the listener will only be notificated when the

    // delta from the previous update is more than the threshold.
@@ -356,12 +360,6 @@ class Dumpstate { 
    // Bugreport format version;

    std::string version_ = VERSION_CURRENT;



    // Command-line arguments as string

    std::string args_;



    // Extra options passed as system property.

    std::string extra_options_;



    // Full path of the directory where the bugreport files will be written.

    std::string bugreport_dir_;
@@ -398,10 +396,6 @@ class Dumpstate { 
    std::string listener_name_;

    bool report_section_;



    // Notification title and description

    std::string notification_title;

    std::string notification_description;



    // List of open tombstone dump files.

    std::vector<DumpData> tombstone_data_;

cmds/dumpstate/tests/dumpstate_test.cpp

+161 −144
Original line number Diff line number Diff line
@@ -137,96 +137,42 @@ class DumpstateBaseTest : public Test { 
    }

};



class DumpstateTest : public DumpstateBaseTest {

class DumpOptionsTest : public Test {

  public:

    void SetUp() {

        DumpstateBaseTest::SetUp();

        SetDryRun(false);

        SetBuildType(android::base::GetProperty("ro.build.type", "(unknown)"));

        ds.progress_.reset(new Progress());

        ds.update_progress_ = false;

        ds.update_progress_threshold_ = 0;

        ds.options_ = Dumpstate::DumpOptions();

    }



    // Runs a command and capture `stdout` and `stderr`.

    int RunCommand(const std::string& title, const std::vector<std::string>& full_command,

                   const CommandOptions& options = CommandOptions::DEFAULT) {

        CaptureStdout();

        CaptureStderr();

        int status = ds.RunCommand(title, full_command, options);

        out = GetCapturedStdout();

        err = GetCapturedStderr();

        return status;

    }



    // Dumps a file and capture `stdout` and `stderr`.

    int DumpFile(const std::string& title, const std::string& path) {

        CaptureStdout();

        CaptureStderr();

        int status = ds.DumpFile(title, path);

        out = GetCapturedStdout();

        err = GetCapturedStderr();

        return status;

    }



    void SetProgress(long progress, long initial_max, long threshold = 0) {

        ds.update_progress_ = true;

        ds.update_progress_threshold_ = threshold;

        ds.last_updated_progress_ = 0;

        ds.progress_.reset(new Progress(initial_max, progress, 1.2));

    virtual ~DumpOptionsTest() {

    }



    std::string GetProgressMessage(const std::string& listener_name, int progress, int max,

                                   int old_max = 0, bool update_progress = true) {

        EXPECT_EQ(progress, ds.progress_->Get()) << "invalid progress";

        EXPECT_EQ(max, ds.progress_->GetMax()) << "invalid max";



        bool max_increased = old_max > 0;



        std::string message = "";

        if (max_increased) {

            message =

                android::base::StringPrintf("Adjusting max progress from %d to %d\n", old_max, max);

    virtual void SetUp() {

        options_ = Dumpstate::DumpOptions();

    }



        if (update_progress) {

            message += android::base::StringPrintf("Setting progress (%s): %d/%d\n",

                                                   listener_name.c_str(), progress, max);

        }



        return message;

    }



    // `stdout` and `stderr` from the last command ran.

    std::string out, err;



    Dumpstate& ds = Dumpstate::GetInstance();

    Dumpstate::DumpOptions options_;

};



TEST_F(DumpstateTest, ParseCommandlineOptionsNone) {

TEST_F(DumpOptionsTest, InitializeNone) {

    // clang-format off

    char* argv[] = {

        const_cast<char*>("dumpstate")

    };

    // clang-format on



    int ret = ds.ParseCommandlineOptions(ARRAY_SIZE(argv), argv);

    EXPECT_EQ(-1, ret);

    EXPECT_FALSE(ds.options_.do_add_date);

    EXPECT_FALSE(ds.options_.do_zip_file);

    EXPECT_EQ("", ds.options_.use_outfile);

    EXPECT_FALSE(ds.options_.use_socket);

    EXPECT_FALSE(ds.options_.use_control_socket);

    EXPECT_FALSE(ds.options_.show_header_only);

    EXPECT_TRUE(ds.options_.do_vibrate);

    EXPECT_FALSE(ds.options_.do_fb);

    EXPECT_FALSE(ds.update_progress_);

    EXPECT_FALSE(ds.options_.is_remote_mode);

    EXPECT_FALSE(ds.options_.do_broadcast);

}



TEST_F(DumpstateTest, ParseCommandlineOptionsPartial1) {

    Dumpstate::DumpOptions options;

    Dumpstate::RunStatus status = options_.Initialize(ARRAY_SIZE(argv), argv);



    EXPECT_EQ(status, Dumpstate::RunStatus::OK);

    EXPECT_FALSE(options_.do_add_date);

    EXPECT_FALSE(options_.do_zip_file);

    EXPECT_EQ("", options_.use_outfile);

    EXPECT_FALSE(options_.use_socket);

    EXPECT_FALSE(options_.use_control_socket);

    EXPECT_FALSE(options_.show_header_only);

    EXPECT_TRUE(options_.do_vibrate);

    EXPECT_FALSE(options_.do_fb);

    EXPECT_FALSE(options_.do_progress_updates);

    EXPECT_FALSE(options_.is_remote_mode);

    EXPECT_FALSE(options_.do_broadcast);

}



TEST_F(DumpOptionsTest, InitializePartial1) {

    // clang-format off

    char* argv[] = {

        const_cast<char*>("dumpstate"),
@@ -238,25 +184,27 @@ TEST_F(DumpstateTest, ParseCommandlineOptionsPartial1) { 


    };

    // clang-format on

    int ret = ds.ParseCommandlineOptions(ARRAY_SIZE(argv), argv);

    EXPECT_EQ(-1, ret);

    EXPECT_TRUE(ds.options_.do_add_date);

    EXPECT_TRUE(ds.options_.do_zip_file);



    Dumpstate::RunStatus status = options_.Initialize(ARRAY_SIZE(argv), argv);



    EXPECT_EQ(status, Dumpstate::RunStatus::OK);

    EXPECT_TRUE(options_.do_add_date);

    EXPECT_TRUE(options_.do_zip_file);

    // TODO: Maybe we should trim the filename

    EXPECT_EQ(" abc", std::string(ds.options_.use_outfile));

    EXPECT_TRUE(ds.options_.use_socket);

    EXPECT_TRUE(ds.options_.use_control_socket);

    EXPECT_EQ(" abc", std::string(options_.use_outfile));

    EXPECT_TRUE(options_.use_socket);

    EXPECT_TRUE(options_.use_control_socket);



    // Other options retain default values

    EXPECT_FALSE(ds.options_.show_header_only);

    EXPECT_TRUE(ds.options_.do_vibrate);

    EXPECT_FALSE(ds.options_.do_fb);

    EXPECT_FALSE(ds.update_progress_);

    EXPECT_FALSE(ds.options_.is_remote_mode);

    EXPECT_FALSE(ds.options_.do_broadcast);

    EXPECT_FALSE(options_.show_header_only);

    EXPECT_TRUE(options_.do_vibrate);

    EXPECT_FALSE(options_.do_fb);

    EXPECT_FALSE(options_.do_progress_updates);

    EXPECT_FALSE(options_.is_remote_mode);

    EXPECT_FALSE(options_.do_broadcast);

}



TEST_F(DumpstateTest, ParseCommandlineOptionsPartial2) {

TEST_F(DumpOptionsTest, InitializePartial2) {

    // clang-format off

    char* argv[] = {

        const_cast<char*>("dumpstate"),
@@ -268,93 +216,162 @@ TEST_F(DumpstateTest, ParseCommandlineOptionsPartial2) { 
        const_cast<char*>("-B"),

    };

    // clang-format on

    int ret = ds.ParseCommandlineOptions(ARRAY_SIZE(argv), argv);

    EXPECT_EQ(-1, ret);

    EXPECT_TRUE(ds.options_.show_header_only);

    EXPECT_FALSE(ds.options_.do_vibrate);

    EXPECT_TRUE(ds.options_.do_fb);

    EXPECT_TRUE(ds.update_progress_);

    EXPECT_TRUE(ds.options_.is_remote_mode);

    EXPECT_TRUE(ds.options_.do_broadcast);



    Dumpstate::RunStatus status = options_.Initialize(ARRAY_SIZE(argv), argv);



    EXPECT_EQ(status, Dumpstate::RunStatus::OK);

    EXPECT_TRUE(options_.show_header_only);

    EXPECT_FALSE(options_.do_vibrate);

    EXPECT_TRUE(options_.do_fb);

    EXPECT_TRUE(options_.do_progress_updates);

    EXPECT_TRUE(options_.is_remote_mode);

    EXPECT_TRUE(options_.do_broadcast);



    // Other options retain default values

    EXPECT_FALSE(ds.options_.do_add_date);

    EXPECT_FALSE(ds.options_.do_zip_file);

    EXPECT_EQ("", ds.options_.use_outfile);

    EXPECT_FALSE(ds.options_.use_socket);

    EXPECT_FALSE(ds.options_.use_control_socket);

    EXPECT_FALSE(options_.do_add_date);

    EXPECT_FALSE(options_.do_zip_file);

    EXPECT_EQ("", options_.use_outfile);

    EXPECT_FALSE(options_.use_socket);

    EXPECT_FALSE(options_.use_control_socket);

}



TEST_F(DumpstateTest, ParseCommandlineOptionsHelp) {

TEST_F(DumpOptionsTest, InitializeHelp) {

    // clang-format off

    char* argv[] = {

        const_cast<char*>("dumpstate"),

        const_cast<char*>("-h")

    };

    // clang-format on

    int ret = ds.ParseCommandlineOptions(ARRAY_SIZE(argv), argv);



    // -h is for help. Caller exit with code = 0 after printing usage, so expect return = 0.

    EXPECT_EQ(0, ret);

    Dumpstate::RunStatus status = options_.Initialize(ARRAY_SIZE(argv), argv);



    // -h is for help.

    EXPECT_EQ(status, Dumpstate::RunStatus::HELP);

}



TEST_F(DumpstateTest, ParseCommandlineOptionsUnknown) {

TEST_F(DumpOptionsTest, InitializeUnknown) {

    // clang-format off

    char* argv[] = {

        const_cast<char*>("dumpstate"),

        const_cast<char*>("-u")  // unknown flag

    };

    // clang-format on

    int ret = ds.ParseCommandlineOptions(ARRAY_SIZE(argv), argv);



    // -u is unknown. Caller exit with code = 1 to show execution failure, after printing usage,

    // so expect return = 1.

    EXPECT_EQ(1, ret);

    Dumpstate::RunStatus status = options_.Initialize(ARRAY_SIZE(argv), argv);



    // -u is unknown.

    EXPECT_EQ(status, Dumpstate::RunStatus::INVALID_INPUT);

}



TEST_F(DumpstateTest, ValidateOptionsNeedOutfile1) {

    ds.options_.do_zip_file = true;

    EXPECT_FALSE(ds.ValidateOptions());

    ds.options_.use_outfile = "a/b/c";

    EXPECT_TRUE(ds.ValidateOptions());

TEST_F(DumpOptionsTest, ValidateOptionsNeedOutfile1) {

    options_.do_zip_file = true;

    EXPECT_FALSE(options_.ValidateOptions());

    options_.use_outfile = "a/b/c";

    EXPECT_TRUE(options_.ValidateOptions());

}



TEST_F(DumpstateTest, ValidateOptionsNeedOutfile2) {

    ds.options_.do_broadcast = true;

    EXPECT_FALSE(ds.ValidateOptions());

    ds.options_.use_outfile = "a/b/c";

    EXPECT_TRUE(ds.ValidateOptions());

TEST_F(DumpOptionsTest, ValidateOptionsNeedOutfile2) {

    options_.do_broadcast = true;

    EXPECT_FALSE(options_.ValidateOptions());

    options_.use_outfile = "a/b/c";

    EXPECT_TRUE(options_.ValidateOptions());

}



TEST_F(DumpstateTest, ValidateOptionsNeedZipfile) {

    ds.options_.use_control_socket = true;

    EXPECT_FALSE(ds.ValidateOptions());

TEST_F(DumpOptionsTest, ValidateOptionsNeedZipfile) {

    options_.use_control_socket = true;

    EXPECT_FALSE(options_.ValidateOptions());



    ds.options_.do_zip_file = true;

    ds.options_.use_outfile = "a/b/c";  // do_zip_file needs outfile

    EXPECT_TRUE(ds.ValidateOptions());

    options_.do_zip_file = true;

    options_.use_outfile = "a/b/c";  // do_zip_file needs outfile

    EXPECT_TRUE(options_.ValidateOptions());

}



TEST_F(DumpstateTest, ValidateOptionsUpdateProgressNeedsBroadcast) {

    ds.update_progress_ = true;

    ds.options_.use_outfile = "a/b/c";  // update_progress_ needs outfile

    EXPECT_FALSE(ds.ValidateOptions());

TEST_F(DumpOptionsTest, ValidateOptionsUpdateProgressNeedsBroadcast) {

    options_.do_progress_updates = true;

    options_.use_outfile = "a/b/c";  // do_progress_updates needs outfile

    EXPECT_FALSE(options_.ValidateOptions());



    ds.options_.do_broadcast = true;

    EXPECT_TRUE(ds.ValidateOptions());

    options_.do_broadcast = true;

    EXPECT_TRUE(options_.ValidateOptions());

}



TEST_F(DumpstateTest, ValidateOptionsRemoteMode) {

    ds.options_.is_remote_mode = true;

    EXPECT_FALSE(ds.ValidateOptions());

TEST_F(DumpOptionsTest, ValidateOptionsRemoteMode) {

    options_.is_remote_mode = true;

    EXPECT_FALSE(options_.ValidateOptions());



    ds.options_.do_broadcast = true;

    ds.options_.do_zip_file = true;

    ds.options_.do_add_date = true;

    ds.options_.use_outfile = "a/b/c";  // do_broadcast needs outfile

    EXPECT_TRUE(ds.ValidateOptions());

    options_.do_broadcast = true;

    options_.do_zip_file = true;

    options_.do_add_date = true;

    options_.use_outfile = "a/b/c";  // do_broadcast needs outfile

    EXPECT_TRUE(options_.ValidateOptions());

}



class DumpstateTest : public DumpstateBaseTest {

  public:

    void SetUp() {

        DumpstateBaseTest::SetUp();

        SetDryRun(false);

        SetBuildType(android::base::GetProperty("ro.build.type", "(unknown)"));

        ds.progress_.reset(new Progress());

        ds.update_progress_threshold_ = 0;

        ds.options_.reset(new Dumpstate::DumpOptions());

    }



    // Runs a command and capture `stdout` and `stderr`.

    int RunCommand(const std::string& title, const std::vector<std::string>& full_command,

                   const CommandOptions& options = CommandOptions::DEFAULT) {

        CaptureStdout();

        CaptureStderr();

        int status = ds.RunCommand(title, full_command, options);

        out = GetCapturedStdout();

        err = GetCapturedStderr();

        return status;

    }



    // Dumps a file and capture `stdout` and `stderr`.

    int DumpFile(const std::string& title, const std::string& path) {

        CaptureStdout();

        CaptureStderr();

        int status = ds.DumpFile(title, path);

        out = GetCapturedStdout();

        err = GetCapturedStderr();

        return status;

    }



    void SetProgress(long progress, long initial_max, long threshold = 0) {

        ds.options_->do_progress_updates = true;

        ds.update_progress_threshold_ = threshold;

        ds.last_updated_progress_ = 0;

        ds.progress_.reset(new Progress(initial_max, progress, 1.2));

    }



    std::string GetProgressMessage(const std::string& listener_name, int progress, int max,

                                   int old_max = 0, bool update_progress = true) {

        EXPECT_EQ(progress, ds.progress_->Get()) << "invalid progress";

        EXPECT_EQ(max, ds.progress_->GetMax()) << "invalid max";



        bool max_increased = old_max > 0;



        std::string message = "";

        if (max_increased) {

            message =

                android::base::StringPrintf("Adjusting max progress from %d to %d\n", old_max, max);

        }



        if (update_progress) {

            message += android::base::StringPrintf("Setting progress (%s): %d/%d\n",

                                                   listener_name.c_str(), progress, max);

        }



        return message;

    }



    // `stdout` and `stderr` from the last command ran.

    std::string out, err;



    Dumpstate& ds = Dumpstate::GetInstance();

};



TEST_F(DumpstateTest, RunCommandNoArgs) {

    EXPECT_EQ(-1, RunCommand("", {}));

}

cmds/dumpstate/utils.cpp

+1 −1
Original line number Diff line number Diff line
@@ -916,7 +916,7 @@ void Dumpstate::UpdateProgress(int32_t delta_sec) { 
    bool max_changed = progress_->Inc(delta_sec);



    // ...but only notifiy listeners when necessary.

    if (!update_progress_) return;

    if (!options_->do_progress_updates) return;



    int progress = progress_->Get();

    int max = progress_->GetMax();