server_ping.c

Go to the documentation of this file.

/* $Id: server_ping.c,v 1.6 2008/08/28 21:37:35 seymour Exp $ */
/* $UTK_Copyright: $ */

#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/stat.h>
#include <sys/time.h>
#include <netinet/in.h>
#include <netdb.h>
#include <stdio.h>
#include <unistd.h>
#include <glob.h>
#include <dirent.h>
#include <errno.h>
#include <utime.h>

#include "server.h"
#include "utility.h"
#include "comm_basics.h"
#include "comm_data.h"
#include "comm_encode.h"
#include "general.h"
#include "gs_pm_model.h"

int
  gs_send_ping_updates(gs_server_t *, gs_server_t **, double *, int),
  gs_get_servers_to_be_pinged(gs_server_t *, gs_server_t ***, int *);

#ifdef GS_SMART_GRIDSOLVE

void 
gs_server_ping(void **args)
{
  gs_server_t *gs_server, **server_list;
  double *ping_times;
  int count, i;
  char *buf;

  if(!args || !args[0])
    return;

  gs_server = args[0];
 

  buf = (char *)malloc(GS_SERVER_PING_SIZE);

  if(!buf) {
    ERRPRINTF("malloc failed\n");
    return;
  }

  if(gs_get_servers_to_be_pinged(gs_server, &server_list, &count) < 0) {
    ERRPRINTF("Failed to get server list\n");
    return;
  }

  ping_times = (double *)malloc(count * sizeof(double));

  if(!ping_times) {
    ERRPRINTF("malloc ping_times array failed\n");
    return;
  }

fprintf(stderr,"got %d servers to ping..\n", count);
  for(i=0;i<count;i++) {
fprintf(stderr, "pinging server '%s'\n", server_list[i]->hostname);
    if(gs_do_ping(server_list[i], buf, GS_SERVER_PING_SIZE, &ping_times[i]) < 0) {
      ERRPRINTF("Warning: ping to '%s' failed.\n", server_list[i]->hostname);
      ping_times[i] = 99999.0;
    }
fprintf(stderr, "....time = %g\n", ping_times[i]);
  }

fprintf(stderr, "sending ping updates to the agent\n");
  if(gs_send_ping_updates(gs_server, server_list, ping_times, count) < 0) {
    ERRPRINTF("sending ping updates to agent failed\n");
    return;
  }

  return;
}

int
gs_send_ping_updates(gs_server_t *server, gs_server_t **server_list, double *times, int count)
{
  char *srv_ping_encoding = NULL, my_cid[2*CID_LEN+1];
  int sock, tag;

  proxy_cid_to_str(my_cid, server->componentid);

  if((sock = gs_connect_direct(server->agenthost, server->agentport)) == INVALID_SOCKET)
    return -1;

  if((gs_send_tag(sock, GS_PROT_SERVER_PING_UPDATE) < 0) ||
     (gs_send_string(sock, VERSION) < 0) ||
     (gs_recv_tag(sock, &tag) < 0))
    goto error_communication_failed;
  if(tag != GS_PROT_OK) {
    if(tag == GS_PROT_VERSION_MISMATCH) {
      ERRPRINTF("Version mismatch communicating with agent\n");
      return -1;
    } else {
      ERRPRINTF("Failed communicating with agent\n");
    }
  }

  if(gs_send_string(sock, my_cid) < 0)
    goto error_communication_failed;
/*
  if(gs_encode_smart_info(&srv_ping_encoding, server, server_list, times, count) < 0) {
    ERRPRINTF("encoding of server ping times failed\n");
    return -1;
  }
*/
  
  if(gs_smart_encode_ping_info(&srv_ping_encoding, server, server_list, times, count) < 0) {
    ERRPRINTF("encoding of server ping times failed\n");
    return -1;
  }

  if(!srv_ping_encoding) {
    ERRPRINTF("encoding of server ping times failed (NULL string)\n");
    return -1;
  }

  if(gs_send_string(sock, srv_ping_encoding) < 0)
    goto error_communication_failed;

  FREE(srv_ping_encoding);

  if(sock != INVALID_SOCKET)  
    proxy_close(sock);

  return 0;

 error_communication_failed:
  FREE(srv_ping_encoding);
  DBGPRINTF("Error: Communication failed\n");
  if(sock != INVALID_SOCKET)
    proxy_close(sock);
  return -1;
}

int
gs_get_servers_to_be_pinged(gs_server_t *server, gs_server_t ***slist, int *count)
{
  char *msg = NULL, my_cid[2*CID_LEN+1];
  gs_server_t **server_list;
  int i, num_servers, tag;
  SOCKET sock;

  *slist = NULL;
  *count = 0;

  proxy_cid_to_str(my_cid, server->componentid);

  if((sock = gs_connect_direct(server->agenthost, server->agentport)) == INVALID_SOCKET)
    return -1;

  if((gs_send_tag(sock, GS_PROT_SERVER_PING_LIST) < 0) ||
     (gs_send_string(sock, VERSION) < 0) ||
     (gs_recv_tag(sock, &tag) < 0))
    goto error_communication_failed;
  if(tag != GS_PROT_OK) {
    if(tag == GS_PROT_VERSION_MISMATCH) {
      ERRPRINTF("Version mismatch communicating with agent\n");
      return -1;
    } else {
      ERRPRINTF("Failed communicating with agent\n");
    }
  }

  if(gs_send_string(sock, my_cid) < 0)
    goto error_communication_failed;

  if(gs_recv_int(sock, &num_servers) < 0)
    goto error_communication_failed;

  if(num_servers <= 0)
    return 0;

  server_list = (gs_server_t **) CALLOC(num_servers, sizeof(gs_server_t *));
  if(!server_list)
    return -1;

  for(i=0;i<num_servers;i++) {
    server_list[i] = (gs_server_t *) CALLOC(1,sizeof(gs_server_t));
    if(gs_recv_string(sock, &msg) < 0) {
      goto error_communication_failed;
    }
    if(gs_decode_server(msg, server_list[i]) < 0) {
      FREE(msg);
      return -1;
    }
    FREE(msg)
  }

  if(sock != INVALID_SOCKET)  
    proxy_close(sock);

  *slist = server_list;
  *count = num_servers;

  return 0;

 error_communication_failed:
  DBGPRINTF("Error: Communication failed\n");
  FREE(msg);
  if(sock != INVALID_SOCKET)
    proxy_close(sock);
  return -1;
}

#endif