Git-Mirrors/RetroShare
1
0
Fork 0
mirror of https://github.com/RetroShare/RetroShare.git synced 2024-12-25 23:49:35 -05:00
Code Issues Actions Packages Projects Releases Wiki Activity

Added external interface to control Relay Parameters.

Browse Source 
* Modified UdpRelay handles the counting... 
	now each Relay Class has a bandwidth limit, 
	and you can drop down to a lower class - if your one is full.
	This ensures that the desired bandwidth is kept, and allows more friends to use the relays.
 * Added Interface in p3bitdht.

TODO: Test this stuff!



git-svn-id: http://svn.code.sf.net/p/retroshare/code/branches/v0.5-dhtmods@4728 b45a01b8-16f6-495d-af2f-9b41ad6348cc
This commit is contained in:
drbob 2011-12-19 18:56:11 +00:00
parent 4d2175636e
commit 203fd6bffc
5 changed files with 159 additions and 53 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
libretroshare/src/dht/p3bitdht.h
View File

@ -164,6 +164,13 @@ virtual int getRelayProxies(std::list<RsDhtRelayProxy> &relayProxies);
virtual std::string getUdpAddressString();
// Interface for controlling Relays & DHT Relay Mode
virtual uint32_t getRelayMode();
virtual int setRelayMode(uint32_t mode);
virtual int getRelayAllowance(int classIdx, uint32_t &count, uint32_t &bandwidth);
virtual int setRelayAllowance(int classIdx, uint32_t count, uint32_t bandwidth);
/***********************************************************************************************
********** External RsDHT Interface (defined in libretroshare/src/retroshare/rsdht.h) *********
************************************************************************************************/

47
libretroshare/src/dht/p3bitdht_interface.cc
View File

@ -197,6 +197,53 @@ std::string p3BitDht::getUdpAddressString()
/***********************************************************************************************
********** External RsDHT Interface (defined in libretroshare/src/retroshare/rsdht.h) *********
************************************************************************************************/
/***********************************************************************************************
********** External RsDHT Interface for Dht-Relay Control *************************************
************************************************************************************************/
uint32_t p3BitDht::getRelayMode()
{
return 1;
}
int p3BitDht::setRelayMode(uint32_t mode)
{
return 1;
}
int p3BitDht::getRelayAllowance(int classIdx, uint32_t &count, uint32_t &bandwidth)
{
std::cerr << "p3BitDht::getRelayAllowance(" << classIdx << "): ";
if ((classIdx >= 0) && (classIdx < RSDHT_RELAY_NUM_CLASS))
{
count = mRelay->getRelayClassMax(classIdx);
bandwidth = mRelay->getRelayClassBandwidth(classIdx);
std::cerr << " count: " << count << " bandwidth: " << bandwidth;
std::cerr << std::endl;
return 1;
}
std::cerr << " Invalid classIdx";
std::cerr << std::endl;
return 0;
}
int p3BitDht::setRelayAllowance(int classIdx, uint32_t count, uint32_t bandwidth)
{
std::cerr << "p3BitDht::getRelayAllowance(" << classIdx << ", ";
std::cerr << ", " << count << ", " << bandwidth << ")";
std::cerr << std::endl;
return mRelay->setRelayClassMax(classIdx, count, bandwidth);
}
/***********************************************************************************************
********** External RsDHT Interface for Dht-Relay Control *************************************
************************************************************************************************/
void convertBdPeerToRsDhtPeer(RsDhtPeer &peer, const bdPeer &int_peer)

34
libretroshare/src/retroshare/rsdht.h
View File

@ -71,6 +71,13 @@ extern RsDht *rsDht;
#define RSDHT_TOU_MODE_RELAY 3
#define RSDHT_RELAY_NUM_CLASS 4
#define RSDHT_RELAY_CLASS_ALL 0
#define RSDHT_RELAY_CLASS_GENERAL 1
#define RSDHT_RELAY_CLASS_FOF 2
#define RSDHT_RELAY_CLASS_FRIENDS 3
class RsDhtPeer
{
@ -96,26 +103,18 @@ class RsDhtNetPeer
std::string mRsId;
uint32_t mPeerType;
uint32_t mDhtState;
//connectLogic.
std::string mConnectState;
// connect Status
uint32_t mPeerConnectState;
// connect mode
uint32_t mPeerConnectMode;
std::string mConnectState; // connectLogic.
uint32_t mPeerConnectState; // connect Status
uint32_t mPeerConnectMode; // connect mode
bool mExclusiveProxyLock;
std::string mPeerConnectProxyId;
// Req Status.
uint32_t mPeerReqState;
// Peer Cb Mgs.
std::string mCbPeerMsg;
uint32_t mPeerReqState; // Req Status.
std::string mCbPeerMsg; // Peer Cb Mgs.
};
@ -168,6 +167,15 @@ virtual int getRelayProxies(std::list<RsDhtRelayProxy> &relayProxies) = 0;
virtual std::string getUdpAddressString() = 0;
// Interface for controlling Relays & DHT Relay Mode
virtual uint32_t getRelayMode() = 0;
virtual int setRelayMode(uint32_t mode) = 0;
virtual int getRelayAllowance(int classIdx, uint32_t &count, uint32_t &bandwidth) = 0;
virtual int setRelayAllowance(int classIdx, uint32_t count, uint32_t bandwidth) = 0;
#if 0
virtual std::string getPeerStatusString();
virtual std::string getDhtStatusString();

97
libretroshare/src/tcponudp/udprelay.cc
View File

@ -49,14 +49,17 @@ UdpRelayReceiver::UdpRelayReceiver(UdpPublisher *pub)
{
mClassLimit.resize(UDP_RELAY_NUM_CLASS);
mClassCount.resize(UDP_RELAY_NUM_CLASS);
mClassBandwidth.resize(UDP_RELAY_NUM_CLASS);
setRelayTotal(UDP_RELAY_DEFAULT_COUNT_ALL);
for(int i = 0; i < UDP_RELAY_NUM_CLASS; i++)
{
mClassCount[i] = 0;
mClassBandwidth[i] = 0;
}
setRelayTotal(UDP_RELAY_DEFAULT_COUNT_ALL);
/* only allocate this space once */
mTmpSendPkt = malloc(MAX_RELAY_UDP_PACKET_SIZE);
mTmpSendSize = MAX_RELAY_UDP_PACKET_SIZE;
@ -279,7 +282,7 @@ int UdpRelayReceiver::removeUdpRelay(UdpRelayAddrSet *addrSet)
}
int UdpRelayReceiver::addUdpRelay(UdpRelayAddrSet *addrSet, int relayClass, uint32_t &bandwidth)
int UdpRelayReceiver::addUdpRelay(UdpRelayAddrSet *addrSet, int &relayClass, uint32_t &bandwidth)
{
RsStackMutex stack(relayMtx); /********** LOCK MUTEX *********/
@ -288,22 +291,22 @@ int UdpRelayReceiver::addUdpRelay(UdpRelayAddrSet *addrSet, int relayClass, uint
int ok = (rit == mRelays.end());
if (!ok)
{
//#ifdef DEBUG_UDP_RELAY
#ifdef DEBUG_UDP_RELAY
std::cerr << "UdpRelayReceiver::addUdpRelay() ERROR Peer already exists!" << std::endl;
//#endif
#endif
return 0;
}
/* will install if there is space! */
if (installRelayClass_relayLocked(relayClass))
if (installRelayClass_relayLocked(relayClass, bandwidth))
{
//#ifdef DEBUG_UDP_RELAY
#ifdef DEBUG_UDP_RELAY
std::cerr << "UdpRelayReceiver::addUdpRelay() adding Relay" << std::endl;
//#endif
#endif
/* create UdpRelay */
UdpRelayProxy udpRelay(addrSet, relayClass);
UdpRelayProxy udpRelay(addrSet, relayClass, bandwidth);
UdpRelayAddrSet alt = addrSet->flippedSet();
UdpRelayProxy altUdpRelay(&alt, relayClass);
UdpRelayProxy altUdpRelay(&alt, relayClass, bandwidth);
/* must install two (A, B) & (B, A) */
mRelays[*addrSet] = udpRelay;
@ -315,9 +318,9 @@ int UdpRelayReceiver::addUdpRelay(UdpRelayAddrSet *addrSet, int relayClass, uint
return 1;
}
//#ifdef DEBUG_UDP_RELAY
#ifdef DEBUG_UDP_RELAY
std::cerr << "UdpRelayReceiver::addUdpRelay() WARNING Too many Relays!" << std::endl;
//#endif
#endif
return 0;
}
@ -359,8 +362,11 @@ int UdpRelayReceiver::removeUdpRelay_relayLocked(UdpRelayAddrSet *addrSet)
return 1;
}
/* Need some stats, to work out how many relays we are supporting */
int UdpRelayReceiver::installRelayClass_relayLocked(int classIdx)
/* Need some stats, to work out how many relays we are supporting
* modified the code to allow degrading of class ....
* so if you have too many friends, they will fill a FOF spot
*/
int UdpRelayReceiver::installRelayClass_relayLocked(int &classIdx, uint32_t &bandwidth)
{
/* check for total number of Relays */
if (mClassCount[UDP_RELAY_CLASS_ALL] >= mClassLimit[UDP_RELAY_CLASS_ALL])
@ -379,12 +385,25 @@ int UdpRelayReceiver::installRelayClass_relayLocked(int classIdx)
}
/* now check the specifics of the class */
if (mClassCount[classIdx] >= mClassLimit[classIdx])
while(mClassCount[classIdx] >= mClassLimit[classIdx])
{
std::cerr << "UdpRelayReceiver::installRelayClass() WARNING Relay Class Limit Exceeded";
std::cerr << std::endl;
std::cerr << "UdpRelayReceiver::installRelayClass() ClassIdx: " << classIdx;
std::cerr << std::endl;
std::cerr << "UdpRelayReceiver::installRelayClass() ClassLimit: " << mClassLimit[classIdx];
std::cerr << std::endl;
std::cerr << "UdpRelayReceiver::installRelayClass() Degrading Class =>: " << classIdx;
std::cerr << std::endl;
return 0;
classIdx--;
if (classIdx == 0)
{
std::cerr << "UdpRelayReceiver::installRelayClass() No Spaces Left";
std::cerr << std::endl;
return 0;
}
}
std::cerr << "UdpRelayReceiver::installRelayClass() Relay Class Ok, Count incremented";
@ -393,6 +412,7 @@ int UdpRelayReceiver::installRelayClass_relayLocked(int classIdx)
/* if we get here we can add one */
mClassCount[UDP_RELAY_CLASS_ALL]++;
mClassCount[classIdx]++;
bandwidth = mClassBandwidth[classIdx];
return 1;
}
@ -448,7 +468,7 @@ int UdpRelayReceiver::setRelayTotal(int count)
}
int UdpRelayReceiver::setRelayClassMax(int classIdx, int count)
int UdpRelayReceiver::setRelayClassMax(int classIdx, int count, int bandwidth)
{
RsStackMutex stack(relayMtx); /********** LOCK MUTEX *********/
@ -461,6 +481,7 @@ int UdpRelayReceiver::setRelayClassMax(int classIdx, int count)
}
mClassLimit[classIdx] = count;
mClassBandwidth[classIdx] = bandwidth;
return 1;
}
@ -480,6 +501,21 @@ int UdpRelayReceiver::getRelayClassMax(int classIdx)
return mClassLimit[classIdx];
}
int UdpRelayReceiver::getRelayClassBandwidth(int classIdx)
{
RsStackMutex stack(relayMtx); /********** LOCK MUTEX *********/
/* check the idx */
if ((classIdx < 0) || (classIdx >= UDP_RELAY_NUM_CLASS))
{
std::cerr << "UdpRelayReceiver::getRelayMaximum() ERROR class Idx invalid";
std::cerr << std::endl;
return 0;
}
return mClassBandwidth[classIdx];
}
int UdpRelayReceiver::getRelayCount(int classIdx)
{
RsStackMutex stack(relayMtx); /********** LOCK MUTEX *********/
@ -840,7 +876,7 @@ UdpRelayProxy::UdpRelayProxy()
mBandwidthLimit = 0;
}
UdpRelayProxy::UdpRelayProxy(UdpRelayAddrSet *addrSet, int relayClass)
UdpRelayProxy::UdpRelayProxy(UdpRelayAddrSet *addrSet, int relayClass, uint32_t bandwidth)
{
mAddrs = *addrSet;
mRelayClass = relayClass;
@ -852,18 +888,23 @@ UdpRelayProxy::UdpRelayProxy(UdpRelayAddrSet *addrSet, int relayClass)
mStartTS = time(NULL);
switch(relayClass)
mBandwidthLimit = bandwidth;
/* fallback */
if (mBandwidthLimit == 0)
{
default:
case UDP_RELAY_CLASS_GENERAL:
mBandwidthLimit = RELAY_MAX_BANDWIDTH;
break;
case UDP_RELAY_CLASS_FOF:
mBandwidthLimit = RELAY_MAX_BANDWIDTH;
break;
case UDP_RELAY_CLASS_FRIENDS:
mBandwidthLimit = RELAY_MAX_BANDWIDTH;
break;
switch(relayClass)
{
default:
case UDP_RELAY_CLASS_GENERAL:
mBandwidthLimit = RELAY_MAX_BANDWIDTH;
break;
case UDP_RELAY_CLASS_FOF:
mBandwidthLimit = RELAY_MAX_BANDWIDTH;
break;
case UDP_RELAY_CLASS_FRIENDS:
mBandwidthLimit = RELAY_MAX_BANDWIDTH;
break;
}
}
}

27
libretroshare/src/tcponudp/udprelay.h
View File

@ -27,6 +27,7 @@
*/
#include "tcponudp/udppeer.h"
#include <retroshare/rsdht.h>
#include <vector>
class UdpRelayAddrSet;
@ -49,7 +50,7 @@ class UdpRelayProxy
{
public:
UdpRelayProxy();
UdpRelayProxy(UdpRelayAddrSet *addrSet, int relayClass);
UdpRelayProxy(UdpRelayAddrSet *addrSet, int relayClass, uint32_t bandwidth);
UdpRelayAddrSet mAddrs;
double mBandwidth;
@ -94,18 +95,19 @@ std::ostream &operator<<(std::ostream &out, const UdpRelayEnd &ure);
#define UDP_RELAY_DEFAULT_COUNT_ALL 10
#define UDP_RELAY_FRAC_GENERAL (0.2)
#define UDP_RELAY_FRAC_FOF (0.5)
#define UDP_RELAY_FRAC_FRIENDS (0.8)
#define UDP_RELAY_FRAC_FRIENDS (0.3)
#define UDP_RELAY_NUM_CLASS 4
/**** DEFINED IN EXTERNAL HEADER FILE ***/
#define UDP_RELAY_NUM_CLASS RSDHT_RELAY_NUM_CLASS
#define UDP_RELAY_CLASS_ALL 0
#define UDP_RELAY_CLASS_GENERAL 1
#define UDP_RELAY_CLASS_FOF 2
#define UDP_RELAY_CLASS_FRIENDS 3
#define UDP_RELAY_CLASS_ALL RSDHT_RELAY_CLASS_ALL
#define UDP_RELAY_CLASS_GENERAL RSDHT_RELAY_CLASS_GENERAL
#define UDP_RELAY_CLASS_FOF RSDHT_RELAY_CLASS_FOF
#define UDP_RELAY_CLASS_FRIENDS RSDHT_RELAY_CLASS_FRIENDS
// Just for some testing fun!
//#define UDP_RELAY_LIFETIME_GENERAL 180 // 3 minutes
//#define UDP_RELAY_LIFETIME_FOF 360 // 6 minutes.
//#define UDP_RELAY_LIFETIME_FOF 360 // 6 minutes.
//#define UDP_RELAY_LIFETIME_FRIENDS 720 // 12 minutes.
#define UDP_RELAY_LIFETIME_GENERAL 1800 // 30 minutes
@ -131,15 +133,16 @@ int removeUdpPeer(UdpPeer *peer);
* the end-points drop the connections
*/
int addUdpRelay(UdpRelayAddrSet *addrSet, int relayClass, uint32_t &bandwidth);
int addUdpRelay(UdpRelayAddrSet *addrSet, int &relayClass, uint32_t &bandwidth);
int removeUdpRelay(UdpRelayAddrSet *addrs);
/* Need some stats, to work out how many relays we are supporting */
int checkRelays();
int setRelayTotal(int count); /* sets all the Relay Counts (frac based on total) */
int setRelayClassMax(int classIdx, int count); /* set a specific class maximum */
int setRelayClassMax(int classIdx, int count, int bandwidth); /* set a specific class maximum */
int getRelayClassMax(int classIdx);
int getRelayClassBandwidth(int classIdx);
int getRelayCount(int classIdx); /* how many relays (of this type) do we have */
int RelayStatus(std::ostream &out);
@ -158,7 +161,7 @@ int status(std::ostream &out);
private:
int removeUdpRelay_relayLocked(UdpRelayAddrSet *addrs);
int installRelayClass_relayLocked(int classIdx);
int installRelayClass_relayLocked(int &classIdx, uint32_t &bandwidth);
int removeRelayClass_relayLocked(int classIdx);
/* Unfortunately, Due the reentrant nature of this classes activities...
@ -176,7 +179,7 @@ int status(std::ostream &out);
RsMutex relayMtx; /* for all class data (below) */
std::vector<int> mClassLimit, mClassCount;
std::vector<int> mClassLimit, mClassCount, mClassBandwidth;
std::map<struct sockaddr_in, UdpRelayEnd> mStreams; /* indexed by <dest> */
std::map<UdpRelayAddrSet, UdpRelayProxy> mRelays; /* indexed by <src,dest> */