cooper_volume.db文件读写

字节序格式图：

 

数据结构：

typedef struct {
    char    device_id[8];   // Without prefix "/dev/mapper/lv"
    char    subvol_id[16];  // volume_id + subvol_order
    char    src_subvol[16]; // volume_id + src_subvol_order
    char    member_ip[16];
    char    client_ip[16];
} SubVolType;
class VolumeType
{
public:
    VolumeType() {
        memset(volume_id, 0, 16);
        memset(srcvol_id, 0, 16);
    }
    
    ~VolumeType() {
        foreach (SubVolType* p, subvol_vec)
            delete p;
    }
    
public:
    char                role;
    unsigned int        timestamp;
    char                volume_id[16];  // The last 10 bytes of cinder-ID
    char                srcvol_id[16]; // The last 10 bytes of cinder-ID
    vector<SubVolType*> subvol_vec;
};
class CooperVolumeType 
{
public:
    ~CooperVolumeType() {
        foreach (VolumeType* p, cooper_volume_vec)
            delete p;
    }
    
public:
    vector<VolumeType*> cooper_volume_vec;
};

 

读写代码：

const int kVolumeIDLenth = 10;
const int kSubvolDevIDLenth = 4;
const char kRoleData = '0';
const char kRoleCloneSrc = '1';
const char kRoleClone = '2';
const char kRoleSnapshotSrc = '3';
const char kRoleSnapshot = '4';
const char kRoleCloneSnapshotSrc = '5';
const string kVolumeDevicePrefix = "/dev/mapper/lv";

bool GetCooperVolumes(CooperVolumeType& cp_volumes)
{
    cp_volumes.cooper_volume_vec.clear();
    BinaryFile bfile(kCooperVolumeDBFile);
    
    if (ReadBinaryFile(bfile) < 0) {
        return false;
    }
    
    char* cursor = bfile.file_buf_;
    unsigned int volume_count = *(unsigned int*)cursor;
    // printf("GetCooperVolumes: volume_count=%u\n", volume_count);
    cursor += sizeof(int);
    
    for (int i = 0; i != volume_count; ++i) {
        unsigned int subvol_count = *(unsigned int*)cursor;
        cursor += sizeof(int);
        // printf("GetCooperVolumes: subvol_count=%u\n", subvol_count);
        
        VolumeType* volume = new VolumeType;
        volume->role = cursor[0];
        cursor += 1;
        
        volume->timestamp = *(unsigned int*)cursor;
        cursor += sizeof(int);
        
        strncpy(volume->volume_id, cursor, kVolumeIDLenth);
        cursor += kVolumeIDLenth;
        
        strncpy(volume->srcvol_id, cursor, kVolumeIDLenth);
        cursor += kVolumeIDLenth;
        
        for (int j = 0; j != subvol_count; ++j) {
            SubVolType* subvol = new SubVolType;
            memset(subvol, 0, sizeof(SubVolType));
            unsigned int order = *(unsigned int*)cursor;
            cursor += sizeof(int);
            snprintf(subvol->subvol_id, 
                        sizeof(subvol->subvol_id), "%s%u", volume->volume_id, order);
            
            order = *(unsigned int*)cursor;
            cursor += sizeof(int);
            
            if (order != 0) {
                snprintf(subvol->src_subvol, 
                            sizeof(subvol->src_subvol), "%s%u", volume->volume_id, order);
            } else {
                sprintf(subvol->src_subvol, "none");
            }
            
            char id[kMemberIDLenth + 1];
            string ip("");
            memset(id, 0, sizeof(id));
            strncpy(id, cursor, kMemberIDLenth);
            cursor += kMemberIDLenth;
            
            ConvertIDtoIP(string(id), ip);
            strncpy(subvol->member_ip, ip.c_str(), ip.length());
            
            strncpy(id, cursor, kMemberIDLenth);
            cursor += kMemberIDLenth;
            
            ConvertIDtoIP(string(id), ip);
            strncpy(subvol->client_ip, ip.c_str(), ip.length());
            
            strncpy(subvol->device_id, cursor, kSubvolDevIDLenth);
            cursor += kSubvolDevIDLenth;
            
            volume->subvol_vec.push_back(subvol);
            // printf("GetCooperVolumes: Get subvolume: %s\n", subvol->subvol_id);
            // printf("GetCooperVolumes: Get subvolume: %s\n", subvol->device_id);
        }
        
        cp_volumes.cooper_volume_vec.push_back(volume);
    }
    
    return true;
}

bool SetCooperVolumes(const CooperVolumeType& cp_volumes)
{
    unsigned int volume_count = cp_volumes.cooper_volume_vec.size();
    unsigned int total_buf_size = sizeof(int);
    
    for (int i = 0; i != volume_count; ++i) {
        unsigned int subvol_count = cp_volumes.cooper_volume_vec[i]->subvol_vec.size();
        unsigned int subvol_bufsize = subvol_count * (2 * sizeof(int) + 2 * kMemberIDLenth + kSubvolDevIDLenth);
        unsigned int volume_bufsize = 2 * sizeof(int) + 1 + 2 * kVolumeIDLenth + subvol_bufsize;
        total_buf_size += volume_bufsize;
    }
    
    // printf("SetCooperVolumes: volume_count=%u, new_buf_size=%d\n", volume_count, total_buf_size);
    
    BinaryFile bfile(kCooperVolumeDBFile);
    bfile.InitBuf(total_buf_size);
    char* cursor = bfile.file_buf_;
    
    memcpy(cursor, (char*)&volume_count, sizeof(int));
    cursor += sizeof(int);
    
    for (int i = 0; i != volume_count; ++i) {
        unsigned int subvol_count = cp_volumes.cooper_volume_vec[i]->subvol_vec.size();
        memcpy(cursor, (char*)&subvol_count, sizeof(int));
        cursor += sizeof(int);
        
        cursor[0] = cp_volumes.cooper_volume_vec[i]->role;
        cursor += 1;
        
        memcpy(cursor, (char*)&(cp_volumes.cooper_volume_vec[i]->timestamp), sizeof(int));
        cursor += sizeof(int);
        
        strncpy(cursor, cp_volumes.cooper_volume_vec[i]->volume_id, kVolumeIDLenth);
        cursor += kVolumeIDLenth;
        
        strncpy(cursor, cp_volumes.cooper_volume_vec[i]->srcvol_id, kVolumeIDLenth);
        cursor += kVolumeIDLenth;
        
        for (int j = 0; j != subvol_count; ++j) {
            unsigned int order = atoi(cp_volumes.cooper_volume_vec[i]->subvol_vec[j]->subvol_id + kVolumeIDLenth);
            memcpy(cursor, (char*)&order, sizeof(int));
            cursor += sizeof(int);
            // printf("SetCooperVolumes: Set subvolume order %d\n", order);
            
            order = atoi(cp_volumes.cooper_volume_vec[i]->subvol_vec[j]->src_subvol + kVolumeIDLenth);
            memcpy(cursor, (char*)&order, sizeof(int));
            cursor += sizeof(int);
            // printf("SetCooperVolumes: Set src_subvol order %d\n", order);
            
            string id("");
            ConvertIPtoID(string(cp_volumes.cooper_volume_vec[i]->subvol_vec[j]->member_ip), id);
            strncpy(cursor, id.c_str(), kMemberIDLenth);
            cursor += kMemberIDLenth;
            
            ConvertIPtoID(string(cp_volumes.cooper_volume_vec[i]->subvol_vec[j]->client_ip), id);
            strncpy(cursor, id.c_str(), kMemberIDLenth);
            cursor += kMemberIDLenth;
            
            strncpy(cursor, cp_volumes.cooper_volume_vec[i]->subvol_vec[j]->device_id, kSubvolDevIDLenth);
            cursor += kSubvolDevIDLenth;
        }
    }
    
    if (WriteBinaryFile(bfile) < 0) {
        return false;
    }
    
    return true;
}

 

测试代码：

void TestInitCooperVolumes(CooperVolumeType& cp_volumes, unsigned int volume_count)
{
    cp_volumes.cooper_volume_vec.clear();
    char roles[] = "012345";
    
    for (int i = 0; i != volume_count; ++i) {
        int subvol_cnt = i % 32 + 1;
        VolumeType* volume = new VolumeType;
        
        volume->role = roles[i % 6];
        volume->timestamp = time(NULL);
        snprintf(volume->volume_id, kVolumeIDLenth + 1, "%dabbccddee", i);
        
        if (volume->role == kRoleData || volume->role == kRoleCloneSrc || volume->role == kRoleSnapshotSrc) {
            sprintf(volume->srcvol_id, "none");
        } else {
            snprintf(volume->srcvol_id, kVolumeIDLenth + 1, "ff%dbbccdde", i);
        }
        
        // printf("Init volume: Role=%c, timestamp=%u, subvol_cnt=%u, volume_id=%s, srcvol_id=%s\n", 
                // volume->role, volume->timestamp, subvol_cnt, volume->volume_id, volume->srcvol_id);
        
        for (int j = 0; j != subvol_cnt; ++j) {
            SubVolType* subvol = new SubVolType;
            memset(subvol, 0, sizeof(SubVolType));
            snprintf(subvol->device_id, kSubvolDevIDLenth + 1, "%d%d", i, j);
            snprintf(subvol->subvol_id, kVolumeIDLenth + sizeof(int) + 1, "%s%d%d", volume->volume_id, i, j);
            snprintf(subvol->member_ip, 16, "%d.%d.%d.12%d", i%256, i%256, i%256, j%10);
            snprintf(subvol->client_ip, 16, "12%d.%d.%d.%d", j%10, i%256, i%256, i%256);
            
            if (volume->role != kRoleData && volume->role != kRoleCloneSrc && volume->role != kRoleSnapshotSrc) {
                snprintf(subvol->src_subvol, kVolumeIDLenth + sizeof(int) + 1, "%s%d%d", volume->volume_id, j, i);
            } else {
                sprintf(subvol->src_subvol, "none");
            }
            
            volume->subvol_vec.push_back(subvol);
            // printf("Init subvolume: device_id=%s, subvol_id=%s, member_ip=%s, client_ip=%s, src_subvol=%s\n", 
                    // subvol->device_id, subvol->subvol_id, 
                    // subvol->member_ip, subvol->client_ip, subvol->src_subvol);
        }
        
        cp_volumes.cooper_volume_vec.push_back(volume);
    }
}

void PrintCooperVolumes(const CooperVolumeType& cp_volumes)
{
    map<char, string> role_dict;
    role_dict.insert(make_pair('0', "data"));
    role_dict.insert(make_pair('1', "clone source"));
    role_dict.insert(make_pair('2', "clone"));
    role_dict.insert(make_pair('3', "snapshot source"));
    role_dict.insert(make_pair('4', "snapshot"));
    role_dict.insert(make_pair('5', "clone snapshot source"));
    
    foreach (VolumeType* vp, cp_volumes.cooper_volume_vec) {
        cout << "Volume ID:   " << vp->volume_id << endl;
        
        if (role_dict.find(vp->role) != role_dict.end()) {
            cout << "Volume Role: " << role_dict[vp->role] << endl;
        } else {
            cout << "Volume Role: unknown" << endl;
        }
        
        cout << "Source ID:   " << vp->srcvol_id << endl;
        string timestr("");
        ConvertTimestampToString(vp->timestamp, timestr);
        cout << "Update Time: " << timestr << endl;
        cout << "[" << endl;
        int si = 0;
        
        foreach (SubVolType* svp, vp->subvol_vec) {
            cout << "    SubVolume ID: " << svp->subvol_id << endl;
            cout << "    Source ID:    " << svp->src_subvol << endl;
            cout << "    Device Path:  " << kVolumeDevicePrefix << svp->device_id << endl;
            cout << "    Home Cluster: " << svp->member_ip << endl;
            cout << "    Attached To:  " << svp->client_ip << endl;
            
            if (++si < vp->subvol_vec.size()) 
                cout << "    ------" << endl;
        }
        
        cout << "]" << endl << endl;
    }
}