Changeset 13135 for trunk/FACT++/dim


Ignore:
Timestamp:
03/18/12 20:53:49 (13 years ago)
Author:
tbretz
Message:
Updated to v19r30
Location:
trunk/FACT++/dim
Files:
13 edited

Legend:

Unmodified
Added
Removed

  • trunk/FACT++/dim/README_v19.txt

    r12757 r13135  
    11
    2                     DIM version 19.27 Release Notes
     2                    DIM version 19.30 Release Notes
    33
    44Notes 1 and 2 for Unix Users only
    … …  
    1717                Dns </dev/null >& dns.log &
    1818
    19 NOTE 3: The Version Number service provided by servers is now set to 1927.
     19NOTE 3: The Version Number service provided by servers is now set to 1930.
     20
     2114/03/2012
     22Changes for version 19.30:
     23    - Sometimes when trying to open a connection to a server the client could backoff for too
     24      long (10 seconds), now it will retry immediately and then at increasing intervals.
     25    - dim_stop() would sometimes not properly stop all threads if a new connection was received
     26      in the mean time.
     27    - The DimServerDns destructor could crash, fixed.
     28    - Removed some compiler warnings about variables set but not used.
     29    - Two new functions available:
     30        - dim_set_listen_backlog(int size)
     31        - int dim_get_listen_backlog()
     32    - The DNS will set the listen_backlog to 1024 at startup, but the OS will truncate it to
     33      a maximum limit (available in /proc/sys/net/core/somaxconn, linux default=128),
     34      while for servers the constant SOMAXCONN is used.
     35
     36
     3706/02/2012
     38Changes for version 19.28:
     39    - Added more log messages when a "Write Timeout" occurs to know where it originated.
     40    - A server could sometimes not release the connection in case of a "Write Timeout", and
     41      then keep on timing out for each message on this connection - fixed.
     42
    2043
    214419/01/2012

  • trunk/FACT++/dim/dim/dim.h

    r12757 r13135  
    1414#include "dim_common.h"
    1515
    16 #define DIM_VERSION_NUMBER 1927
     16#define DIM_VERSION_NUMBER 1930
    1717
    1818#define MY_LITTLE_ENDIAN        0x1

  • trunk/FACT++/dim/dim/dim_common.h

    r12757 r13135  
    204204_DIM_PROTOE( void dim_set_keepalive_timeout,            (int secs) );
    205205_DIM_PROTOE( int dim_get_keepalive_timeout,             () );
     206_DIM_PROTOE( void dim_set_listen_backlog,               (int size) );
     207_DIM_PROTOE( int dim_get_listen_backlog,                () );
    206208
    207209#ifdef WIN32

  • trunk/FACT++/dim/src/dic.c

    r12757 r13135  
    2929#endif
    3030
    31 #define BAD_CONN_TIMEOUT 10
     31#define BAD_CONN_TIMEOUT 2
    3232
    3333
    … …  
    13141314        char *node_name, *task_name;
    13151315        char node_info[MAX_NODE_NAME+4];
    1316         int i, port, protocol, format, ret, pid;
     1316        int i, port, protocol, format, pid;
    13171317        register DIC_CONNECTION *dic_connp ;
    13181318        DIC_DNS_PACKET dic_dns_packet;
    … …  
    14891489                        strncpy( bad_connp->conn.task_name, task_name, MAX_TASK_NAME);
    14901490                        bad_connp->conn.port = port;
    1491                         tmout = BAD_CONN_TIMEOUT * bad_connp->n_retries;
     1491                        tmout = BAD_CONN_TIMEOUT * (bad_connp->n_retries - 1);
    14921492                        if(tmout > 120)
    14931493                                tmout = 120;
    … …  
    15301530        servp->conn_id = conn_id;
    15311531
    1532         ret = send_service_command( servp );
     1532        send_service_command( servp );
    15331533/*
    15341534        if( ret == 1)
    … …  
    19421942        }
    19431943*/
     1944        if(!ret)
     1945        {
     1946                dim_print_date_time();
     1947                printf(" Client Sending Command: Couldn't write to Conn %3d : Server %s@%s\n",conn_id,
     1948                        Net_conns[conn_id].task, Net_conns[conn_id].node);
     1949                fflush(stdout);
     1950        }
    19441951        return(ret);
    19451952}
    … …  
    22442251void dic_stop()
    22452252{
     2253        int dic_find_server_conns();
     2254
    22462255        dtq_delete(Dic_timer_q);
    22472256        dic_close_dns();
    2248         dim_stop();
     2257        if(!dic_find_server_conns())
     2258                dim_stop();
     2259}
     2260
     2261int dic_find_server_conns()
     2262{
     2263        int i;
     2264        int n = 0;
     2265
     2266        for( i = 0; i< Curr_N_Conns; i++ )
     2267        {
     2268                if(Net_conns[i].channel != 0)
     2269                {
     2270                        if(Dna_conns[i].read_ast == recv_rout)
     2271                        {
     2272                                dna_close(i);
     2273                        }
     2274                        else
     2275                        {
     2276                                n++;
     2277                        }
     2278                }
     2279        }
     2280        return(n);
    22492281}
    22502282

  • trunk/FACT++/dim/src/dim_thr.c

    r12585 r13135  
    182182void dim_stop()
    183183{
     184        void dim_tcpip_stop(), dim_dtq_stop();
     185/*
    184186        int i;
    185187        int n = 0;
    186         void dim_tcpip_stop(), dim_dtq_stop();
    187188
    188189        for( i = 0; i< Curr_N_Conns; i++ )
    … …  
    193194        if(n)
    194195                return;
     196*/
    195197        if(IO_thread)
    196198                pthread_cancel(IO_thread);
    … …  
    666668void dim_stop_threads()
    667669{
     670/*
    668671        int i;
    669672        int n = 0;
    … …  
    676679        if(n)
    677680                return;
     681*/
    678682        if(hIO_thread)
    679683                TerminateThread(hIO_thread, 0);

  • trunk/FACT++/dim/src/dis.c

    r12757 r13135  
    13881388        register SERVICE *servp;
    13891389        char str[80], def[MAX_NAME];
    1390         register char *ptr;
    1391         int last_conn_id;
     1390        int conn_id, last_conn_id;
    13921391        int *pkt_buffer, header_size, aux;
    13931392#ifdef WIN32
    … …  
    14061405        reqp->delay_delete++;
    14071406        servp = reqp->service_ptr;
     1407        conn_id = reqp->conn_id;
     1408
     1409if(Debug_on)
     1410{
     1411dim_print_date_time();
     1412printf("Updating %s for %s@%s (req_id = %d)\n",
     1413           servp->name,
     1414           Net_conns[conn_id].task, Net_conns[conn_id].node,
     1415           reqp->req_id);
     1416}
     1417
    14081418        last_conn_id = Curr_conn_id;
    1409         Curr_conn_id = reqp->conn_id;
    1410         ptr = servp->def;
     1419        Curr_conn_id = conn_id;
    14111420        if(servp->type == COMMAND)
    14121421        {
    … …  
    14151424                size = 26;
    14161425                sprintf(def,"c:26");
    1417                 ptr = def;
    14181426        }
    14191427        else if( servp->user_routine != 0 )
    … …  
    14911499                buffp, size);
    14921500        Dis_packet->size = htovl(header_size + size);
    1493         if( !dna_write_nowait(reqp->conn_id, Dis_packet, header_size + size) )
    1494         {
     1501        if( !dna_write_nowait(conn_id, Dis_packet, header_size + size) )
     1502        {
     1503                if(Net_conns[conn_id].write_timedout)
     1504                {
     1505                        dim_print_date_time();
     1506                        if(reqp->delay_delete > 1)
     1507                        {
     1508                                printf(" Server (Explicitly) Updating Service %s: Couldn't write to Conn %3d : Client %s@%s\n",
     1509                                        servp->name, conn_id,
     1510                                        Net_conns[conn_id].task, Net_conns[conn_id].node);
     1511                        }
     1512                        else
     1513                        {
     1514                                printf(" Server Updating Service %s: Couldn't write to Conn %3d : Client %s@%s\n",
     1515                                        servp->name, conn_id,
     1516                                        Net_conns[conn_id].task, Net_conns[conn_id].node);
     1517                        }
     1518                }
     1519                fflush(stdout);
    14951520                if(reqp->delay_delete > 1)
    14961521                {
    … …  
    15001525                {
    15011526                        reqp->delay_delete = 0;
    1502                         release_conn(reqp->conn_id, 1, 0);
     1527                        release_conn(conn_id, 1, 0);
    15031528                }
    15041529        }
    … …  
    15131538        }
    15141539*/
    1515         reqp->delay_delete--;
     1540        if(reqp->delay_delete > 0)
     1541                reqp->delay_delete--;
    15161542        return(1);
    15171543}
    … …  
    15201546{
    15211547        register REQUEST *reqp;
    1522         register SERVICE *servp;
    15231548        static DIS_PACKET *dis_packet;
    15241549        static int packet_size = 0;
    … …  
    15281553        if(!reqp)
    15291554                return;
    1530         servp = reqp->service_ptr;
    15311555        if( !packet_size ) {
    15321556                dis_packet = (DIS_PACKET *)malloc(DIS_HEADER);
    … …  
    17081732                (DLL *) reqp)) )
    17091733        {
     1734/*
    17101735if(Debug_on)
    17111736{
    … …  
    17151740           Net_conns[reqp->conn_id].task, Net_conns[reqp->conn_id].node, reqp->req_id, (unsigned long)reqp);
    17161741}
     1742*/
    17171743                if(check_client(reqp, client_ids))
    17181744                {
    … …  
    20512077                if( !dna_write_nowait(conn_id, dis_packet, size + DIS_HEADER) )
    20522078                {
     2079                        dim_print_date_time();
     2080                        printf(" Server Sending Service: Couldn't write to Conn %3d : Client %s@%s\n",conn_id,
     2081                                Net_conns[conn_id].task, Net_conns[conn_id].node);
     2082                        fflush(stdout);
    20532083                        release_conn(conn_id, 1, 0);
    20542084                }
    … …  
    21422172        n_services = dnsp->dis_n_services;
    21432173
    2144         ENABLE_AST
    21452174        if(dnsp->serving)
    21462175        {
    21472176                if(n_services == 5)
    21482177                {
     2178                        if(Dis_conn_id)
     2179                        {
     2180                                dna_close(Dis_conn_id);
     2181                                Dis_conn_id = 0;
     2182                        }
     2183                        ENABLE_AST
    21492184/*
    21502185                        dis_stop_serving();
    … …  
    21522187                        do_dis_stop_serving_dns(dnsp);
    21532188                }
     2189                else
     2190                {
     2191                        ENABLE_AST
     2192                }
     2193        }
     2194        else
     2195        {
     2196                ENABLE_AST
    21542197        }
    21552198        return(found);
    … …  
    22812324register SERVICE *servp, *prevp;
    22822325void dim_stop_threads(void);
     2326int dis_find_client_conns();
    22832327int hash_index;
    22842328
    … …  
    23352379        if(Serving != -1)
    23362380*/
    2337         dim_stop_threads();
     2381        if(!dis_find_client_conns())
     2382                dim_stop_threads();
     2383}
     2384
     2385int dis_find_client_conns()
     2386{
     2387        int i;
     2388        int n = 0;
     2389
     2390        for( i = 0; i< Curr_N_Conns; i++ )
     2391        {
     2392                if(Net_conns[i].channel != 0)
     2393                {
     2394                        if(Dna_conns[i].read_ast == dis_insert_request)
     2395                        {
     2396                                dna_close(i);
     2397                        }
     2398                        else
     2399                        {
     2400                                n++;
     2401                        }
     2402                }
     2403        }
     2404        return(n);
    23382405}
    23392406

  • trunk/FACT++/dim/src/discpp.cxx

    r12757 r13135  
    312312void DimServerDns::init(const char *node, int port)
    313313{
    314         if(!itsNode)
    315         {
     314//      if(!itsNode)
     315//      {
    316316                itsNode = new char[strlen(node)+1];
    317317                strcpy(itsNode,node);
    318         }
     318//      }
    319319        itsPort = port;
    320320        autoStart = 1;
    … …  
    365365//                      delete[] itsName;
    366366        }
    367         if(itsNode)
     367//      if(itsNode)
    368368                delete[] itsNode;
    369369}

  • trunk/FACT++/dim/src/dna.c

    r12757 r13135  
    821821        if (tcpip_failure(tcpip_code))
    822822        {
     823                dim_print_date_time();
     824                printf(" Client Establishing Connection: Couldn't write to Conn %3d : Server %s@%s\n",conn_id,
     825                        Net_conns[conn_id].task, Net_conns[conn_id].node);
     826                fflush(stdout);
    823827                dna_close(conn_id);
    824828                return(0);
    … …  
    934938        }
    935939}
    936 

  • trunk/FACT++/dim/src/dns.c

    r12757 r13135  
    14381438        }
    14391439        dim_set_write_timeout(10);
     1440        dim_set_listen_backlog(1024);
    14401441        dim_init();
    14411442        conn_arr_create( SRC_DNS );

  • trunk/FACT++/dim/src/dtq.c

    r11071 r13135  
    8585struct sigaction sig_info;
    8686sigset_t set;
    87 int pid, ret = 0;
    88 
     87int ret = 0;
     88
     89/*
    8990        pid = getpid();
     91*/
    9092        if( !sigvec_done)
    9193        {
    … …  
    796798int dtq_stop_timer(long tag)
    797799{
    798         TIMR_ENT *entry, *queue_head, *prevp;
     800        TIMR_ENT *entry, *queue_head;
    799801        int time_left = -1;
    800802
    801803        queue_head = timer_queues[SPECIAL_QUEUE].queue_head;
    802804        entry = queue_head;
    803         prevp = entry;
    804805        while( (entry = (TIMR_ENT *)dll_get_next((DLL *)queue_head,(DLL *)entry)) )
    805806        {

  • trunk/FACT++/dim/src/examples/test_server.c

    r12757 r13135  
    7474        int new_dns = 0;
    7575        int index = 0;
     76/*
     77        dim_set_write_timeout(1);
     78*/
    7679/*
    7780        int buf_sz, buf_sz1;

  • trunk/FACT++/dim/src/tcpip.c

    r12757 r13135  
    8989static int DIM_IO_valid = 1;
    9090
     91static int Listen_backlog = SOMAXCONN;
    9192static int Keepalive_timeout_set = 0;
    9293static int Write_timeout = WRITE_TMOUT;
    … …  
    9798int Tcpip_max_io_data_write = TCP_SND_BUF_SIZE - 16;
    9899int Tcpip_max_io_data_read = TCP_RCV_BUF_SIZE - 16;
     100
     101void dim_set_listen_backlog(int size)
     102{
     103        Listen_backlog = size;
     104}
     105
     106int dim_get_listen_backlog()
     107{
     108        return(Listen_backlog);
     109}
    99110
    100111void dim_set_keepalive_timeout(int secs)
    … …  
    11381149        }
    11391150
    1140         if( (ret = listen(path, SOMAXCONN)) == -1 )
     1151        if( (ret = listen(path, Listen_backlog)) == -1 )
    11411152        {
    11421153                closesock(path);
Note: See TracChangeset for help on using the changeset viewer.