Topology.h

Go to the documentation of this file.

/*
 * Copyright (c) 2013 Mark Travis <mtravis15432+src@gmail.com>
 * All rights reserved. No warranty, explicit or implicit, provided.
 *
 * This file is part of InfiniSQL(tm).
 
 * InfiniSQL is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 3
 * as published by the Free Software Foundation.
 *
 * InfiniSQL is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with InfiniSQL. If not, see <http://www.gnu.org/licenses/>.
 */

#ifndef INFINISQLTOPOLOGY_H
#define INFINISQLTOPOLOGY_H

#include <cstdlib>
#include <vector>
#include <stdint.h>
#include <pthread.h>
#include <string>
#include <stdio.h>
#include <boost/unordered_map.hpp>
#include "cfgenum.h"
#include <map>

using std::string;
using std::map;

extern pthread_mutex_t nodeTopologyMutex;
extern FILE *logfile;
using std::vector;

class Mbox;

class Topology
{
public:
    struct __attribute__ ((__packed__)) addressStruct
    {
        int16_t nodeid; 
        int16_t actorid; 
    };

    struct partitionAddress
    {
        addressStruct address;
        int64_t instance;
        class Mbox *mbox;
        actortypes_e type; 
        int epollfd;
        std::string argstring;
        std::string node;
        std::string service;
        std::vector<std::string> nodes;
        std::vector<std::string> services;
    };

    struct actor_s
    {
        actortypes_e type;
        int64_t instance;
        class Mbox *mbox;
    };

    Topology();
    Topology(const Topology &orig);
    virtual ~Topology();

    partitionAddress *newActor(actortypes_e type, class Mbox *mbox, int epollfd,
                               const string &argstring, int64_t actorid,
                               const vector<string> &nodes,
                               const vector<string> &services);

    int16_t nodeid; 
    int numreplicas;
    int activereplica;

    //local
    size_t numtransactionagents;
    size_t numengines;
    size_t numobgateways;

    vector<actor_s> actorList;

    //global
    int16_t numpartitions;
    int16_t userSchemaMgrNode;
    class Mbox *userSchemaMgrMbox;
    int16_t deadlockMgrNode;
    class Mbox *deadlockMgrMbox;
    // partitionList[replicaid][partition] = {nodeid, actorid}
    std::vector< vector<partitionAddress> > partitionList;
    std::vector<partitionAddress> partitionListThisReplica;
    std::map< int64_t, vector<std::string> > ibGateways;
    // allActors[nodeid][actorid] = type
    std::vector< vector<int> > allActors;
    boost::unordered_map< int16_t, std::vector<int> > allActorsThisReplica;
    // replicaMembers[replica][member] = nodeid
    std::vector< vector<int16_t> > replicaMembers;
    // tas[nodeid][tainstance] = actorid
    std::vector< vector<int16_t> > tas;
};

#endif  /* INFINISQLTOPOLOGY_H */