analyze_matrix/analyze_matrix.cpp

/*
 * Copyright (C) 2018 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include <optional>
#include <set>

#include <android-base/logging.h>
#include <gflags/gflags.h>
#include <hidl-util/FqInstance.h>
#include <vintf/FileSystem.h>
#include <vintf/parse_string.h>
#include <vintf/parse_xml.h>

namespace android {
namespace vintf {

namespace {

template <typename T>
std::optional<T> readObject(const std::string& path, const XmlConverter<T>& converter) {
    std::string xml;
    std::string error;
    status_t err = details::FileSystemImpl().fetch(path, &xml, &error);
    if (err != OK) {
        LOG(ERROR) << "Cannot read '" << path << "': " << error;
        return std::nullopt;
    }
    auto ret = std::make_optional<T>();
    if (!converter(&ret.value(), xml, &error)) {
        LOG(ERROR) << "Cannot parse '" << path << "': " << error;
        return std::nullopt;
    }
    return ret;
}

std::optional<std::set<std::string>> getInterfaces(const CompatibilityMatrix& mat) {
    auto set = std::make_optional<std::set<std::string>>();
    mat.forEachInstance([&set](const auto& matrixInstance) {
        for (auto minorVer = matrixInstance.versionRange().minMinor;
             minorVer <= matrixInstance.versionRange().maxMinor; ++minorVer) {
            FqInstance fqInstance;
            if (!fqInstance.setTo(matrixInstance.package(), matrixInstance.versionRange().majorVer,
                                  minorVer, matrixInstance.interface())) {
                LOG(ERROR) << "Matrix not valid; '" << matrixInstance.package() << "@"
                           << matrixInstance.versionRange().majorVer << "." << minorVer
                           << "::" << matrixInstance.interface() << "' is not a valid FQName.";
                set = std::nullopt;
                return false;  // break
            }

            set->insert(fqInstance.string());
        }
        return true;  // continue
    });
    return set;
}

}  // namespace

}  // namespace vintf
}  // namespace android

DEFINE_string(input, "", "Input compatibility matrix file");
static bool ValidateInput(const char* /* flagname */, const std::string& value) {
    return !value.empty();
}
DEFINE_validator(input, &ValidateInput);

DEFINE_bool(level, false, "Write level (FCM version) of the compatibility matrix.");
DEFINE_bool(interfaces, false, "Write strings like \"android.hardware.foo@1.0::IFoo\".");

int main(int argc, char** argv) {
    using namespace android::vintf;

    gflags::ParseCommandLineFlags(&argc, &argv, true /* remove flags */);

    auto mat = readObject(FLAGS_input, gCompatibilityMatrixConverter);
    if (!mat) {
        return 1;
    }

    bool written = false;

    if (FLAGS_level) {
        if (mat->level() == Level::UNSPECIFIED) {
            LOG(WARNING) << "FCM version is unspecified.";
        }
        std::cout << mat->level() << std::endl;

        written = true;
    }

    if (FLAGS_interfaces) {
        auto pvs = getInterfaces(*mat);
        if (!pvs) {
            return 1;
        }
        if (pvs->empty()) {
            LOG(WARNING) << "No package and versions are found.";
        }

        for (const auto& pv : *pvs) {
            std::cout << pv << std::endl;
        }

        written = true;
    }

    if (!written) {
        LOG(ERROR) << "No output format is set.";
        return 1;
    }

    return 0;
}