dce_server.c

Ho Chi Minh City University of Technology Computer Science Department Distributed Computing E

/***************************************
Ho Chi Minh City University of Technology
    Computer Science Department 
Distributed Computing Environment (DCE)
copyright by Nguyen Van Noi -59406114
File dce_server.c on Mon Dec 21 18:36:20 1998
****************************************/
#include <kstat.h>
#include <sys/param.h>

#include "dce_server.h"

ServerDes Server;
MSG msg;
int dce_server_init (int, char **);
void dce_server_exit ();
int dce_agent_mcastrecv (char *buf, int len);
int dce_server_mcastsend (char *buf, int len);
void dce_server_alive (void *p);
void dce_server_election_agent (void *p);
void dce_server_fork_agent ();
void dce_msg_admin_request_all_killserver ();
void dce_msg_agent_request_server_broadcastdata ();
void dce_msg_admin_reqeust_agent_addservice ();
void dce_msg_client_request_agent_service ();
void dce_msg_agent_request_server_serve_client ();
void dce_msg_all_reply_client_pleasewait ();
void dce_msg_service_reply_all_finish ();
void dce_msg_all_reply_alluserservice ();
void dce_server_treat_for_electionagent ();
void dce_msg_admin_requset_server_loadinfo();
double dce_server_getload ();
void
main (int argc, char *argv[])
{
  if (!dce_diamon ())
    exit (-1);
  if (!dce_server_init (argc, argv))
    exit (-2);
  while (!Server.bExit)
    {
      if (dce_server_mcastrecv ((char *) &msg, sizeof (MSG)) != sizeof (MSG))
	continue;
      switch (msg.who)
	{
	case ADMIN:

	  break;
	case AGENT:
	  Server.AgentTime = 2 * TIMEOUT_IAMALIVE + 1;
	  dce_killtimer (Server.TimerIdElection);
	  break;
	case SERVER:
	  dce_agent_update_newmsg ();
	  break;
	case SERVICE:

	  break;
	}

      switch (msg.type)
	{
	case DCE_MSG_SERVER_ELECTION_AGENT:
	  dce_server_treat_for_electionagent ();
	  break;
	case DCE_MSG_SERVER_ELECTED_AGENT:  
	    dce_server_fork_agent ();
	    break;
	case DCE_MSG_ALL_REPLY_ALL_USERSERVICE:
	  dce_msg_all_reply_alluserservice ();
	  break;
	case DCE_MSG_ALL_REPLY_CLIENT_PLEASEWAIT:
	  dce_msg_all_reply_client_pleasewait ();
	  break;
	case DCE_MSG_SERVICE_REPLY_ALL_FINISH:
	  dce_msg_service_reply_all_finish ();
	  break;
	case DCE_MSG_AGENT_REQUEST_SERVER_SERVE_CLIENT:
	  dce_msg_agent_request_server_serve_client ();
	  break;
	case DCE_MSG_AGENT_REQUEST_SERVER_BROADCASTDATA:
	  dce_msg_agent_request_server_broadcastdata ();
	  break;
	case DCE_MSG_ADMIN_REQUEST_SERVER_LOADINFO:  
	case DCE_MSG_CLIENT_REQUEST_AGENT_SERVICE:
	  dce_msg_client_request_agent_service ();
	  break;
	case DCE_MSG_ADMIN_REQUEST_AGENT_ADDSERVICE:
	  dce_msg_admin_reqeust_agent_addservice ();
	  break;
	case DCE_MSG_ADMIN_REQUEST_ALL_ADDUSER:
	  AddUid (Server.pUserList, msg.lextra);
	  break;
	case DCE_MSG_ADMIN_REQUEST_ALL_KILLSERVER:
	  dce_msg_admin_request_all_killserver ();
	  break;
	case DCE_MSG_KILLALL:
	  Server.bExit = 1;
	  break;
	}

    }

}

int
dce_server_init (int argc, char **argv)
{
  int i, n;
  u_long u;

  if (argc < 7)
    return 0;
  atexit (dce_server_exit);
  TIMEOUT_IAMALIVE= atoi (argv[7]);
  Server.Msg.order = atoi (argv[6]);
  Server.szDCE_ROOT = argv[1];
  Server.maddr = gethostaddr (argv[2]);
  Server.mport = atoi (argv[3]);
  u = gethostaddr (argv[4]);
  i = atoi (argv[5]);
  Server.Msg.who = SERVER;
  Server.Msg.saddr = getmyaddr ();
  if (!(Server.pList = NewList ()))
    return 0;
  if (!(Server.pUserList = NewList ()))
    return 0;
  if (!(Server.pService = NewList ()))
    return 0;
  if (!(Server.pCurUserService = NewList ()))
    return 0;

  if ((Server.nMSockSend = dce_mcastsocksend ()) < 0)
    return 0;
  if ((Server.nMSockRecv = dce_mcastsockrecv (Server.maddr, Server.mport)) < 0)
    return 0;
  if ((Server.nSocket = dce_socket (&Server.Msg.sport)) < 0)
    return 0;
  if ((n = dce_connect (u, i)) > 0)
    {
      Server.Msg.type = DCE_MSG_SERVER_REPLY_ADMIN_FORK_SUCCESS;
      write (n, (void *) &Server.Msg, sizeof (MSG));
      close (n);
    }
  else
    return 0;
  dce_signal ();
  if (!dce_timer_init ())
    return 0;
  Server.Msg.load = dce_server_getload ();
  dce_server_alive (NULL);
  Server.Msg.type = DCE_MSG_SERVER_REQUEST_AGENT_BROADCASTDATA;
  dce_server_mcastsend ((char *) &Server.Msg, sizeof (MSG));
  return 1;
}

void
dce_server_exit ()
{
  FreeList (Server.pList, NULL);
  FreeList (Server.pUserList, NULL);
  FreeList (Server.pService, NULL);
  FreeList (Server.pCurUserService, NULL);


  dce_timer_free ();
  dce_mcastcloserecv (Server.nMSockRecv, Server.maddr);
  close (Server.nSocket);
  close (Server.nMSockSend);
  _cleanup ();
  _exit ();

}



int
dce_server_mcastsend (char *buf, int len)
{
  return dce_mcastsendsend (Server.nMSockSend, Server.maddr, Server.mport, buf, len);
}

int
dce_server_mcastrecv (char *buf, int len)
{

  return dce_mcastrecvrecv (Server.nMSockRecv, Server.maddr, Server.mport, buf, len);
}

void
dce_server_alive (void *p)
{
  char c = Server.Msg.type;
  Server.Msg.type = DCE_MSG_IAMALIVE;

  dce_server_mcastsend ((char *) &Server.Msg, sizeof (MSG));

  dce_settimer (TIMEOUT_IAMALIVE, dce_server_alive, NULL);
  dce_server_dcetime ();
  DecTimeUserService (Server.pCurUserService);

  if (Server.AgentTime > 0)
    Server.AgentTime -= TIMEOUT_IAMALIVE;
  else
    {
      Server.Msg.type = DCE_MSG_SERVER_ELECTION_AGENT;
      dce_server_mcastsend ((char *) &Server.Msg, sizeof (MSG));
      Server.TimerIdElection = dce_settimer ((Server.Msg.order - 1) * TIMEOUT_IAMALIVE, dce_server_election_agent, NULL);
    }
  Server.Msg.type = c;
}

void
dce_server_election_agent (void *p)
{
  char c = Server.Msg.type;
  if (dce_server_minorder () != Server.Msg.order)
    return;
  Server.Msg.type = DCE_MSG_SERVER_ELECTED_AGENT;
  dce_server_mcastsend ((char *) &Server.Msg, sizeof (MSG));
  Server.Msg.type = c;

}

int
dce_server_accept ()
{
  int n = -1;
  int timeout = TIMEOUT;
  int tid = dce_settimer (timeout, dce_timerzero, (char *) &timeout);
  while (timeout)
    {
      if ((n = dce_socketaccept (Server.nSocket)) > 0)
	{
	  dce_killtimer (tid);
	  return n;
	}

    }

  return -1;
}

void
dce_server_fork_agent ()
{
  char cmd[256];
  char host[20];
  char ssport[20];
  char smport[20];
  char smax[10];
  char stime[10];
  int n, code;
  MSG msg;
  sprintf (cmd, "%s/bin/%s/dceagent", Server.szDCE_ROOT, sysinfo_hostarch ());
  strcpy (host, (char *) ascaddrip (getmyaddr ()));
  sprintf (smport, "%d", Server.mport);
  sprintf (ssport, "%d", Server.Msg.sport);
  sprintf (smax, "%d", Server.Msg.order);
  sprintf (stime,"%d",TIMEOUT_IAMALIVE);
  if (!IsFileExist (cmd))
    return;
  if ((code = fork ()) < 0)
    return;
  if (!code)
    {
      code = execlp (cmd, cmd, Server.szDCE_ROOT, ascaddrip (Server.maddr),smport, host, ssport, smax,stime, NULL);
      exit (-1);
    }
  if ((n = dce_server_accept ()) <= 0)
    return;

  if (read (n, (void *) &msg, sizeof (msg)) == sizeof (msg))
    if (msg.type == DCE_MSG_AGENT_REPLY_ADMIN_FORK_SUCCESS)
      close (n);
}

void
dce_msg_admin_request_all_killserver ()
{
  if (msg.aaddr == Server.Msg.saddr)
    Server.bExit = 1;
  else
    dce_server_delete_server (msg.aaddr);

}

void
dce_msg_agent_request_server_broadcastdata ()
{
  Server.Msg.type = DCE_MSG_ADMIN_REQUEST_ALL_ADDUSER;
  dce_server_userbroadcast ();
  Server.Msg.type = DCE_MSG_ADMIN_REQUEST_AGENT_ADDSERVICE;
  dce_server_servicebroadcast ();
  dce_server_userservicebroadcast ();
}
void
dce_msg_admin_reqeust_agent_addservice ()
{
  AddService (Server.pService, msg.nextra, msg.sername);
}

void
dce_msg_client_request_agent_service ()
{
  Server.Msg.type = DCE_MSG_IAMALIVE;
  Server.Msg.load = dce_server_getload ();
  dce_server_mcastsend ((char *) &Server.Msg, sizeof (MSG));
}

void
dce_msg_agent_request_server_serve_client ()
{
  static char cmd[256];
  static char smaddr[20];
  static char smport[10];
  static char seaddr[20];
  static char seport[10];
  static char suserid[10];
  static char snparam[10];
  static char sorder[10];
  static char ssernum[10];
  static char stime[10];
  int n, code;
  PSERVICEINFO p;
  if (msg.aaddr != Server.Msg.saddr)
    return;
  sprintf (cmd, "%s/bin/%s/%s", Server.szDCE_ROOT, sysinfo_hostarch (), msg.sername);
  if ((!IsFileExist (cmd)) || (!(p = (PSERVICEINFO) FindService (Server.pService, msg.sername))))
    Server.Msg.type = DCE_MSG_ALL_REPLY_CLIENT_ERROR;
  else
    Server.Msg.type = DCE_MSG_ALL_REPLY_CLIENT_PLEASEWAIT;
  if ((n = dce_connect (msg.saddr, msg.sport)) <= 0)
    return;
  write (n, (void *) &Server.Msg, sizeof (MSG));
  close (n);
  if (Server.Msg.type != DCE_MSG_ALL_REPLY_CLIENT_PLEASEWAIT)
    return;
  strcpy (smaddr, ascaddrip (Server.maddr));
  sprintf (smport, "%d", Server.mport);
  strcpy (seaddr, ascaddrip (msg.saddr));
  sprintf (seport, "%d", msg.sport);
  sprintf (suserid, "%d", msg.uid);
  sprintf (snparam, "%d", msg.nextra);
  sprintf (sorder, "%d", Server.Msg.order);
  sprintf (ssernum, "%d", p->num);
  sprintf (stime,"%d",TIMEOUT_IAMALIVE);
  if (!(code = fork ()))
    {
      code = execlp (cmd, cmd, smaddr, smport, seaddr, seport, suserid, snparam,sorder, ssernum,stime,NULL);
      exit (-1);
    }

}
void
dce_msg_all_reply_client_pleasewait ()
{
  PUSERSERVICE p = (PUSERSERVICE) FindUserService (Server.pCurUserService, msg.pid, msg.saddr);
  if (p)
    {
      p->time = 2 * TIMEOUT_IAMALIVE + 1;
      p->status = 1;
      return;
    }
  if (p = (PUSERSERVICE) NewUserService (msg.pid, msg.saddr, msg.uid, msg.nextra, msg.aaddr, msg.lextra))
    InsertList (Server.pCurUserService, (void *) p);

}
void
dce_msg_service_reply_all_finish ()
{
  PUSERSERVICE p = (PUSERSERVICE) FindUserService (Server.pCurUserService, msg.pid, msg.saddr);
  if (p)
    {
      p->tEnd = msg.lextra1;
      p->time = -1;
      p->status = 0;
      return;
    }

}
void
dce_msg_all_reply_alluserservice ()
{
  PUSERSERVICE p = (PUSERSERVICE) FindUserService (Server.pCurUserService, msg.pid, msg.saddr);
  if (p)
    return;
  if (!(p = (PUSERSERVICE) NewUserService (msg.pid, msg.saddr, msg.uid, msg.nextra, msg.aaddr, msg.lextra)))
    return;
  p->tEnd = msg.lextra1;
  p->time = msg.sport;
  p->status = (p->time > 0);
  InsertList (Server.pCurUserService, (void *) p);
}

double
dce_server_getload ()
{


  static double y;
  double y1, y2, y3;
  kstat_ctl_t *kc;
  kstat_t *ksp;
  void *vp;

  if ((kc = kstat_open ()) == (void *) NULL)
    return y;
  if ((ksp = kstat_lookup (kc, "unix", 0, "system_misc")) == (void *) NULL)
    return y;
  if (kstat_read (kc, ksp, NULL) == (kid_t) - 1)
    return y;
  if ((vp = kstat_data_lookup (ksp, "avenrun_1min")) == (void *) NULL)
    return y;
  y = y3 = (double) (((kstat_named_t *) vp)->value.l) / (double) (FSCALE);
  if ((vp = kstat_data_lookup (ksp, "avenrun_5min")) == (void *) NULL)
    return y;
  y = y2 = (double) (((kstat_named_t *) vp)->value.l) / (double) (FSCALE);
  if ((vp = kstat_data_lookup (ksp, "avenrun_15min")) == (void *) NULL)
    return y;
  y = y1 = (double) (((kstat_named_t *) vp)->value.l) / (double) (FSCALE);

  y = y3;

  return y;
}
void
dce_server_treat_for_electionagent ()
{
  char c = Server.Msg.type;
  if (msg.order == Server.Msg.order)
    return;

  dce_killtimer (Server.TimerIdElection);
  Server.Msg.type = DCE_MSG_IAMALIVE;
  dce_server_mcastsend ((char *) &Server.Msg, sizeof (MSG));
  Server.Msg.type = c;

}