tools/fault-injection-service/FileSystem/failure_injector.cc

/** 
 * Licensed to the Apache Software Foundation (ASF) under one or more           
 * contributor license agreements.  See the NOTICE file distributed with this   
 * work for additional information regarding copyright ownership.  The ASF      
 * licenses this file to you 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                                      
 * <p>                                                                          
 * http://www.apache.org/licenses/LICENSE-2.0                                   
 * <p>                                                                          
 * 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<string>
#include<map>
#include<vector>
#include<iostream>
#include"failure_injector.h"

using namespace std;
using namespace NoiseInjector;

#define GEN_CODE_NAMES(x)  #x

string InjectedOpNames[] = {"NO_OP", InjectedOperations(GEN_CODE_NAMES)};

vector<InjectedAction> *FilePathFailures::GetFailures(InjectedOpCode op)
{
    auto iter = mInjectedOperations.find(op);
    if (iter == mInjectedOperations.end()) {
        return NULL;
    }
    return (vector<InjectedAction> *)&iter->second;
}

void FilePathFailures::addFailure(
    InjectedOpCode op,
    InjectedAction action) 
{
    auto iter = mInjectedOperations.find(op);
    if (iter == mInjectedOperations.end()) {
        mInjectedOperations[op].push_back(action);
    } else {
        vector<InjectedAction> &action_vector = iter->second;
        for (auto &existing_action : action_vector) {
            if (action.code == existing_action.code) {
                return;
            }
        }
        action_vector.push_back(action);
    }
}

void FilePathFailures::resetFailure(InjectedOpCode op)
{
    auto itr = mInjectedOperations.find(op);
    if (itr != mInjectedOperations.end()) {
        mInjectedOperations[op].clear();
        mInjectedOperations.erase(op);
    }
}

void FilePathFailures::resetFailure()
{
    for (auto iter:mInjectedOperations) {
        InjectedOpCode op = iter.first;
        mInjectedOperations[op].clear();
        mInjectedOperations.erase(op);
    }
}

void FilePathFailures::dumpFailures()
{
    for (auto iter:mInjectedOperations) {
        InjectedOpCode op = iter.first;
        for (const auto action : mInjectedOperations[op]) {
            cout << "\t" << InjectedOpNames[op] << ": " << action.code << "\n";
        }
    }
}

InjectedOpCode  FailureInjector::getOpCode(std::string op_name)
{
    int i = 0;
    for (auto name : InjectedOpNames) {
       if (!name.compare(op_name)) {
            return (InjectedOpCode)i;
       }
        ++i; 
    }
    return  NO_OP;
}

std::vector<InjectedAction>* FailureInjector::GetFailures(
    std::string path,
    std::string op_name)
{
    auto op =getOpCode(op_name);
    if (op >= NUM_OP_CODES) {
        return NULL;
    }

    auto iter = mAllInjectedFailures_.find(path);
    if (iter != mAllInjectedFailures_.end()) {
        FilePathFailures* failure = iter->second;
        return failure->GetFailures(op);
    }
    return NULL;
}

void FailureInjector::InjectFailure(
    std::string path,
    std::string op_name,
    InjectedAction action)
{
    InjectFailure(path, getOpCode(op_name), action);
}

void FailureInjector::InjectFailure(
    std::string path,
    InjectedOpCode op,
    InjectedAction action) 
{
    if (op >= NUM_OP_CODES) {
        return;
    }
    auto iter = mAllInjectedFailures_.find(path);
    if (iter == mAllInjectedFailures_.end()) {
        FilePathFailures* failure = new FilePathFailures();
        failure->addFailure(op, action);
        mAllInjectedFailures_[path] = failure;
    } else {
        FilePathFailures* failure = iter->second;
        failure->addFailure(op, action);
    }

}

void FailureInjector::ResetFailure(
    std::string path,
    std::string op_name) 
{
    auto op =getOpCode(op_name);
    if (op >= NUM_OP_CODES) {
        return NULL;
    }
    ResetFailure(path, op);
}

void FailureInjector::ResetFailure(
    std::string path,
    InjectedOpCode op) 
{
    auto iter = mAllInjectedFailures_.find(path);
    if (iter != mAllInjectedFailures_.end()) {
        FilePathFailures* failure = iter->second;
        failure->resetFailure(op);
    }
}

void FailureInjector::ResetFailure(
    std::string path) 
{
    auto iter = mAllInjectedFailures_.find(path);
    if (iter != mAllInjectedFailures_.end()) {
        FilePathFailures* failure = iter->second;
        failure->resetFailure();
        mAllInjectedFailures_.erase(path);
    }
}

void FailureInjector::ResetFailure() 
{
    for (auto iter : mAllInjectedFailures_) {
        FilePathFailures* failure = iter.second;
        failure->resetFailure();
    }
    mAllInjectedFailures_.clear();
}

void FailureInjector::dumpFailures(std::string path) 
{
    auto iter = mAllInjectedFailures_.find(path);
    if (iter != mAllInjectedFailures_.end()) {
        FilePathFailures* failure = iter->second;
        failure->dumpFailures();
    }
}

void FailureInjector::dumpFailures() 
{
    for (auto iter : mAllInjectedFailures_) {
        FilePathFailures* failure = iter.second;
        cout << "Path: " << iter.first << "\n";
        failure->dumpFailures();
    }
}