working on bandwidth draft

src/apps/relay/mainrelay.h

@@ -348,6 +348,14 @@ void init_listener(void);
 void setup_server(void);
 void run_listener_server(struct listener_server *ls);
 
+////////// BPS ////////////////
+
+band_limit_t get_bps_capacity_allocated(void);
+band_limit_t get_bps_capacity(void);
+void set_bps_capacity(band_limit_t value);
+band_limit_t get_max_bps(void);
+void set_max_bps(band_limit_t value);
+
 ///////////////////////////////
 
 #ifdef __cplusplus

src/apps/relay/netengine.c

@@ -81,20 +81,31 @@ static void barrier_wait_func(const char* func, int line)
 
 static pthread_mutex_t mutex_bps;
 
-static band_limit_t allocate_bps(band_limit_t bps)
+static band_limit_t allocate_bps(band_limit_t bps, int negative)
 {
 	band_limit_t ret = 0;
 	if(bps>0) {
 		pthread_mutex_lock(&mutex_bps);
 
-		if(turn_params.bps_capacity_allocated < turn_params.bps_capacity) {
+		if(!negative) {
-			band_limit_t reserve = turn_params.bps_capacity - turn_params.bps_capacity_allocated;
+
-			if(reserve <= bps) {
+			if(turn_params.bps_capacity_allocated < turn_params.bps_capacity) {
-				ret = reserve;
+				band_limit_t reserve = turn_params.bps_capacity - turn_params.bps_capacity_allocated;
-				turn_params.bps_capacity_allocated = turn_params.bps_capacity;
+				if(reserve <= bps) {
+					ret = reserve;
+					turn_params.bps_capacity_allocated = turn_params.bps_capacity;
+				} else {
+					ret = bps;
+					turn_params.bps_capacity_allocated -= ret;
+				}
+			}
+
+		} else {
+			if(turn_params.bps_capacity_allocated >= bps) {
+				turn_params.bps_capacity_allocated -= bps;
+				ret = turn_params.bps_capacity_allocated;
 			} else {
-				ret = bps;
+				turn_params.bps_capacity_allocated = 0;
-				turn_params.bps_capacity_allocated -= ret;
 			}
 		}
 
@@ -103,6 +114,47 @@ static band_limit_t allocate_bps(band_limit_t bps)
 	return ret;
 }
 
+band_limit_t get_bps_capacity_allocated(void)
+{
+	band_limit_t ret = 0;
+	pthread_mutex_lock(&mutex_bps);
+	ret = turn_params.bps_capacity_allocated;
+	pthread_mutex_unlock(&mutex_bps);
+	return ret;
+}
+
+band_limit_t get_bps_capacity(void)
+{
+	band_limit_t ret = 0;
+	pthread_mutex_lock(&mutex_bps);
+	ret = turn_params.bps_capacity;
+	pthread_mutex_unlock(&mutex_bps);
+	return ret;
+}
+
+void set_bps_capacity(band_limit_t value)
+{
+	pthread_mutex_lock(&mutex_bps);
+	turn_params.bps_capacity = value;
+	pthread_mutex_unlock(&mutex_bps);
+}
+
+band_limit_t get_max_bps(void)
+{
+	band_limit_t ret = 0;
+	pthread_mutex_lock(&mutex_bps);
+	ret = turn_params.max_bps;
+	pthread_mutex_unlock(&mutex_bps);
+	return ret;
+}
+
+void set_max_bps(band_limit_t value)
+{
+	pthread_mutex_lock(&mutex_bps);
+	turn_params.max_bps = value;
+	pthread_mutex_unlock(&mutex_bps);
+}
+
 /////////////// AUX SERVERS ////////////////
 
 static void add_aux_server_list(const char *saddr, turn_server_addrs_list_t *list)
@@ -735,7 +787,7 @@ static ioa_engine_handle create_new_listener_engine(void)
 	TURN_LOG_FUNC(TURN_LOG_LEVEL_INFO,"IO method (udp listener/relay thread): %s\n",event_base_get_method(eb));
 	super_memory_t* sm = new_super_memory_region();
 	ioa_engine_handle e = create_ioa_engine(sm, eb, turn_params.listener.tp, turn_params.relay_ifname, turn_params.relays_number, turn_params.relay_addrs,
-			turn_params.default_relays, turn_params.verbose, turn_params.max_bps
+			turn_params.default_relays, turn_params.verbose
 #if !defined(TURN_NO_HIREDIS)
 			,turn_params.redis_statsdb
 #endif
@@ -781,7 +833,7 @@ static void setup_listener(void)
 
 	turn_params.listener.ioa_eng = create_ioa_engine(sm, turn_params.listener.event_base, turn_params.listener.tp,
 			turn_params.relay_ifname, turn_params.relays_number, turn_params.relay_addrs,
-			turn_params.default_relays, turn_params.verbose, turn_params.max_bps
+			turn_params.default_relays, turn_params.verbose
 #if !defined(TURN_NO_HIREDIS)
 			,turn_params.redis_statsdb
 #endif
@@ -1355,7 +1407,7 @@ static void setup_relay_server(struct relay_server *rs, ioa_engine_handle e, int
 		rs->event_base = turn_event_base_new();
 		TURN_LOG_FUNC(TURN_LOG_LEVEL_INFO,"IO method (general relay thread): %s\n",event_base_get_method(rs->event_base));
 		rs->ioa_eng = create_ioa_engine(rs->sm, rs->event_base, turn_params.listener.tp, turn_params.relay_ifname,
-			turn_params.relays_number, turn_params.relay_addrs, turn_params.default_relays, turn_params.verbose, turn_params.max_bps
+			turn_params.relays_number, turn_params.relay_addrs, turn_params.default_relays, turn_params.verbose
 #if !defined(TURN_NO_HIREDIS)
 			,turn_params.redis_statsdb
 #endif
@@ -1408,7 +1460,7 @@ static void setup_relay_server(struct relay_server *rs, ioa_engine_handle e, int
 			 &turn_params.secure_stun, turn_params.shatype, &turn_params.mobility,
 			 turn_params.server_relay,
 			 send_turn_session_info,
-			 turn_params.max_bps, allocate_bps);
+			 allocate_bps);
 	
 	if(to_set_rfc5780) {
 		set_rfc5780(&(rs->server), get_alt_addr, send_message_from_listener_to_client);

src/apps/relay/ns_ioalib_engine_impl.c

@@ -335,7 +335,7 @@ static void timer_handler(ioa_engine_handle e, void* arg) {
 ioa_engine_handle create_ioa_engine(super_memory_t *sm,
 				struct event_base *eb, turnipports *tp, const s08bits* relay_ifname,
 				size_t relays_number, s08bits **relay_addrs, int default_relays,
-				int verbose, band_limit_t max_bps
+				int verbose
 #if !defined(TURN_NO_HIREDIS)
 				,const char* redis_report_connection_string
 #endif
@@ -370,7 +370,6 @@ ioa_engine_handle create_ioa_engine(super_memory_t *sm,
 
 		e->sm = sm;
 		e->default_relays = default_relays;
-		e->max_bpj = max_bps;
 		e->verbose = verbose;
 		e->tp = tp;
 		if (eb) {
@@ -627,10 +626,7 @@ static int ioa_socket_check_bandwidth(ioa_socket_handle s, size_t sz, int read)
 {
 	if(s && (s->e) && sz && (s->sat == CLIENT_SOCKET) && (s->session)) {
 
-		band_limit_t max_bps = s->e->max_bpj;
+		band_limit_t max_bps = s->session->realm_options.perf_options.max_bps;
-		band_limit_t s_max_bps = s->session->realm_options.perf_options.max_bps;
-		if(s_max_bps>0)
-			max_bps = s_max_bps;
 
 		if(max_bps<1)
 			return 1;

src/apps/relay/ns_ioalib_impl.h

@@ -144,7 +144,6 @@ struct _ioa_engine
 #endif
   SSL_CTX *dtls_ctx;
   turn_time_t jiffie; /* bandwidth check interval */
-  band_limit_t max_bpj;
   ioa_timer_handle timer_ev;
   s08bits cmsg[TURN_CMSG_SZ+1];
   int predef_timer_intervals[PREDEF_TIMERS_NUM];
@@ -238,7 +237,7 @@ ioa_engine_handle create_ioa_engine(super_memory_t *sm,
 				struct event_base *eb, turnipports* tp,
 				const s08bits* relay_if,
 				size_t relays_number, s08bits **relay_addrs, int default_relays,
-				int verbose, band_limit_t max_bps
+				int verbose
 #if !defined(TURN_NO_HIREDIS)
 				,const char* redis_report_connection_string
 #endif

src/apps/relay/turncli.c

@@ -358,17 +358,17 @@ static void change_cli_param(struct cli_session* cs, const char* pn)
 			cli_print_uint(cs,(unsigned long)turn_params.user_quota,"user-quota",2);
 			return;
 		} else if(strstr(pn,"max-bps")==pn) {
-			turn_params.max_bps = atoi(pn+strlen("max-bps"));
+			set_max_bps((band_limit_t)atol(pn+strlen("max-bps")));
-			cli_print_uint(cs,(unsigned long)turn_params.max_bps,"max-bps",2);
+			cli_print_uint(cs,(unsigned long)get_max_bps(),"max-bps",2);
+			return;
+		} else if(strstr(pn,"bps-capacity")==pn) {
+			set_bps_capacity((band_limit_t)atol(pn+strlen("bps-capacity")));
+			cli_print_uint(cs,(unsigned long)get_bps_capacity(),"bps-capacity",2);
 			return;
 		} else if(strstr(pn,"cli-max-output-sessions")==pn) {
 			cli_max_output_sessions = atoi(pn+strlen("cli-max-output-sessions"));
 			cli_print_uint(cs,(unsigned long)cli_max_output_sessions,"cli-max-output-sessions",2);
 			return;
-		} else if(strstr(pn,"bps-capacity")==pn) {
-			turn_params.bps_capacity = atoi(pn+strlen("bps-capacity"));
-			cli_print_uint(cs,(unsigned long)turn_params.bps_capacity,"bps-capacity",2);
-			return;
 		}
 
 		myprintf(cs, "\n");
@@ -722,7 +722,6 @@ static void cli_print_configuration(struct cli_session* cs)
 
 		cli_print_uint(cs,(unsigned long)turn_params.min_port,"min-port",0);
 		cli_print_uint(cs,(unsigned long)turn_params.max_port,"max-port",0);
-		cli_print_uint(cs,(unsigned long)turn_params.bps_capacity_allocated,"Allocated bps-capacity",0);
 
 		cli_print_ip_range_list(cs,&turn_params.ip_whitelist,"Whitelist IP",0);
 		cli_print_ip_range_list(cs,&turn_params.ip_blacklist,"Blacklist IP",0);
@@ -796,10 +795,11 @@ static void cli_print_configuration(struct cli_session* cs)
 
 		myprintf(cs,"\n");
 
-		cli_print_uint(cs,(unsigned long)turn_params.total_quota,"total-quota",2);
+		cli_print_uint(cs,(unsigned long)turn_params.total_quota,"Default total-quota",2);
-		cli_print_uint(cs,(unsigned long)turn_params.user_quota,"user-quota",2);
+		cli_print_uint(cs,(unsigned long)turn_params.user_quota,"Default user-quota",2);
-		cli_print_uint(cs,(unsigned long)turn_params.bps_capacity,"bps-capacity",2);
+		cli_print_uint(cs,(unsigned long)get_bps_capacity(),"Total server bps-capacity",2);
-		cli_print_uint(cs,(unsigned long)turn_params.max_bps,"max-bps",2);
+		cli_print_uint(cs,(unsigned long)get_bps_capacity_allocated(),"Allocated bps-capacity",0);
+		cli_print_uint(cs,(unsigned long)get_max_bps(),"Default max-bps",2);
 
 		myprintf(cs,"\n");
 

src/server/ns_turn_server.c

@@ -4349,7 +4349,7 @@ void init_turn_server(turn_turnserver* server,
 		send_socket_to_relay_cb send_socket_to_relay,
 		vintp secure_stun, SHATYPE shatype, vintp mobility, int server_relay,
 		send_turn_session_info_cb send_turn_session_info,
-		band_limit_t max_bps, allocate_bps_cb allocate_bps_func) {
+		allocate_bps_cb allocate_bps_func) {
 
 	if (!server)
 		return;
@@ -4406,7 +4406,6 @@ void init_turn_server(turn_turnserver* server,
 
 	server->send_socket_to_relay = send_socket_to_relay;
 
-	server->max_bps = max_bps;
 	server->allocate_bps_func = allocate_bps_func;
 
 	set_ioa_timer(server->e, 1, 0, timer_timeout_handler, server, 1, "timer_timeout_handler");

src/server/ns_turn_server.h

@@ -92,7 +92,7 @@ typedef void (*release_allocation_quota_cb)(u08bits *username, u08bits *realm);
 typedef int (*send_socket_to_relay_cb)(turnserver_id id, u64bits cid, stun_tid *tid, ioa_socket_handle s, int message_integrity, MESSAGE_TO_RELAY_TYPE rmt, ioa_net_data *nd);
 typedef int (*send_turn_session_info_cb)(struct turn_session_info *tsi);
 
-typedef band_limit_t (*allocate_bps_cb)(band_limit_t bps);
+typedef band_limit_t (*allocate_bps_cb)(band_limit_t bps, int negative);
 
 struct _turn_turnserver {
 
@@ -153,7 +153,6 @@ struct _turn_turnserver {
 	int server_relay;
 
 	/* Bandwidth draft: */
-	band_limit_t max_bps;
 	allocate_bps_cb allocate_bps_func;
 };
 
@@ -189,7 +188,6 @@ void init_turn_server(turn_turnserver* server,
 				    vintp mobility,
 				    int server_relay,
 				    send_turn_session_info_cb send_turn_session_info,
-				    band_limit_t max_bps,
 				    allocate_bps_cb allocate_bps_func);
 
 ioa_engine_handle turn_server_get_engine(turn_turnserver *s);