# Copyright 2010 Nathan Phillip Brink, Ethan Zonca

#

# This file is a part of DistRen.

#

# Distren is free software: you can redistribute it and/or modify

# it under the terms of the GNU Affero General Public License as published by

# the Free Software Foundation, either version 3 of the License, or

# (at your option) any later version.

#

# DistRen is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU Affero General Public License for more details.

#

# You should have received a copy of the GNU Affero General Public License

# along with DistRen.  If not, see <http://www.gnu.org/licenses/>.

AC_PREREQ(2.61)

AC_CONFIG_SRCDIR([src/server/distrend.c])

AC_CONFIG_MACRO_DIR([m4])

AC_PROG_CC

AC_PROG_LIBTOOL

#AC_PROG_RANLIB #don't add this even if autoscan says to, because AC_PROG_LIBTOOL is enough

AM_INIT_AUTOMAKE([gnu dist-bzip2 subdir-objects -Wall])

AM_PROG_CC_C_O

#basic low-level checks (suggested by autoscan)

AC_CHECK_FUNCS([dup2])

AC_CHECK_FUNCS([memset])

AC_CHECK_FUNCS([strdup])

AC_CHECK_HEADERS([fcntl.h])

AC_CHECK_HEADERS([malloc.h])

AC_FUNC_FORK

AC_FUNC_MALLOC

AC_TYPE_PID_T

AC_TYPE_SIZE_T

# selective compilation

# For now, this is only left for when the C-based client is

# reintroducded.

AC_ARG_ENABLE([server],

	[AS_HELP_STRING([--disable-server],[Don't build the distren server])],

	[enable_server=$enableval],

	[enable_server=yes])

AM_CONDITIONAL([ENABLE_SERVER],

	[test "x$enable_server" = "xyes"])

# to grab GNU-specific function prototypes for the following functions:

# getline

AC_DEFINE([_GNU_SOURCE], [1])

#package dependencies:

PKG_PROG_PKG_CONFIG(0.17.2)

PKGCONFIG_OHNOWRAP([DISTLIBS], [libconfuse >= 2.5 libcurl libxml-2.0 liblist >= 2.2.1 libarchive >= 2.8.0 ])

AX_LIB_MYSQL

AS_IF( [test "x${MYSQL_VERSION}" = "x"],

	[ AC_MSG_ERROR([I need mysql]) ] )

#include <time.h>

#include <unistd.h>

#include <libxml/encoding.h>

#include <libxml/parser.h>

#include <libxml/tree.h>

#include <libxml/xmlmemory.h>

#include <libxml/xmlreader.h>

#include <libxml/xmlwriter.h>

/* ******************* Structs ************************ */

struct general_info

{

  struct distrenjob head;

  distrend_mysql_conn_t conn;

  struct distrend_config *config;

  struct

  {

    /** general_info.xml */

    char *geninfo;

  } files;

  int jobs_in_queue;

  unsigned int free_clients;

  unsigned int rendering_clients;

  unsigned int total_finished_jobs;

  unsigned int total_frames_rendered;

  unsigned int highest_jobnum;

  int hibernate;

  time_t timestamp;

  unsigned long total_render_power;

  unsigned long total_priority_pieces;

};

/* *********************************************

   Function Prototypes

   ********************************************* */

/* ************General Functions************* */

int distrend_do();

int distrend_do_config(int argc, char *argv[], struct distrend_config **config);

int distrend_config_free(struct distrend_config *config);

int distrend_handle_request(struct distrend_listens *listens, struct distrend_client *client, struct distren_request *req, void *reqdata, struct general_info *geninfo);

/* **************XML Functions**************** */

void update_general_info(struct general_info *geninfo);

int import_general_info(struct general_info *general_info);

int update_xml_joblist(struct general_info *geninfo);

/* **************Test Functions**************** */

int interactiveTest(int test, struct general_info *general_info);

/* **************** Main ********************* */

int main(int argc, char *argv[])

{

  /* Parse arguments */

  int counter;

  int test = 0; /*< Interactive mode if 1 */

  int tmp;

  struct general_info general_info;

  enum clientstatus

  {

    CLIENTSTATUS_UNINITIALIZED = 0,

    CLIENTSTATUS_BUSY = 1,

    CLIENTSTATUS_IDLE = 2

  } clientstatus;

  clientstatus = CLIENTSTATUS_UNINITIALIZED;

  // xmlinit();

  for(counter = 0; counter < argc; counter ++)

    {

      if(strcmp(argv[counter], "-h") == 0)

      {

    	  fprintf(stderr, "Usage: distrend [option] \nStarts the distrend server\n\t-h\tshow this help\n\t-t\tlaunches queue testing interface \n");

	  return 2;

      }

      else if(strcmp(argv[counter], "-t") == 0)

      {

    	  fprintf(stderr, "Entering into test mode...\n\n");

    	  test = 1;

      }

    }

  if(distrend_do_config(argc, argv, &general_info.config))

    return 1;

  /** preset paths */

  _distren_asprintf(&general_info.files.geninfo, "%s/general_info.xml",

		    general_info.config->datadir);

  /** MySQL Connection */

  fprintf(stderr,"Connecting to mysql...\n");

  if(mysqlConnect(&general_info.conn,

		  general_info.config->mysql_user,

		  general_info.config->mysql_host,

		  general_info.config->mysql_pass,

		  general_info.config->mysql_database) )

    {

      fprintf(stderr, "%s:%d: mysqlConnect() failed\n", __FILE__, __LINE__);

      fprintf(stderr, "don't test mysql stuff\n");

      interactiveTest(test, &general_info);

      return 1;

    }

  fprintf(stderr,"Finished connecting!\n");

  /** Execute test function */

  interactiveTest(test, &general_info);

  general_info.config->listens = distrend_listens_new(&general_info);

  if(!general_info.config->listens)

    {

      fprintf(stderr, "error initializing listens\n");

      return 1;

    }

  for(counter = 0; general_info.config->listen_ports[counter]; counter ++)

    {

      tmp = distrend_listen_add(general_info.config->listens, general_info.config->listen_ports[counter]);

      if(tmp)

	{

	  fprintf(stderr, "Error listening on port %d\n", general_info.config->listen_ports[counter]);

	  return 1;

	}

    }

  int slaveKey = 0; // Remotio should set me on a per-slave basis

  /* Main Loop */

  general_info.config->die = 0;

  while(!general_info.config->die)

    {

      int clientrequest = 0; /*< temporary example variable, will be replaced when we can handle messages */

      distrend_accept(general_info.config->listens);

      /* Run the watchdog, @TODO: like every 10 mins or something */

      frame_watchdog(general_info.conn);

      struct frameset frame;

      struct distrenjob *job;

      distrenjob_new(&job);

      memset(&frame, '\0', sizeof(frame));

      /** If client requests work */

      if(clientrequest == DISTREN_REQUEST_GETWORK)

	{

	  int returnnum = find_jobframe(general_info.conn, slaveKey, &job->jobnum, &frame.num); // Finds a frame to render @FIXME: Slavenum :D

	  if(returnnum); /* No work on server */

	  else

	    remotio_send_to_client(frame.num, job->jobnum); // Pseudo-sends data to client

	}

      /* If the client states that they finished the frame */

      else if(clientrequest == DISTREN_REQUEST_DONEFRAME)

	{

	  clientstatus = CLIENTSTATUS_IDLE; // Sets the client back to idle

	  finish_frame(general_info.conn, 0, job->jobnum, frame.num); // @TODO: Make sure this actually works.

	}

      distrenjob_free(&job);

    }

  distrend_listen_free(general_info.config->listens);

  distrend_config_free(general_info.config);

  xmlcleanup();

  /** free() paths */

  free(general_info.files.geninfo);

  mysqlDisconnect(general_info.conn);

  return 0;

}

/* ********************** Functions ************************* */

{

  char *tmp_str;

  char fixedbuf[32];

  struct distren_request *newreq;

    {

    }

  return 0;

}

/**

   Performs command stored in a client's request. @TODO: Fill stub

*/

int distrend_do()

{

  return 0;

}

/* Grabs config info from confs */

int distrend_do_config(int argc, char *argv[], struct distrend_config **config)

{

  unsigned int counter;

  cfg_opt_t myopts_listen[] =

    {

      CFG_SIMPLE_STR("type", NULL),

      CFG_SIMPLE_STR("path", NULL),

      CFG_SIMPLE_INT("port", NULL),

      CFG_END()

    };

  cfg_opt_t myopts[] =

    {

      CFG_SEC("listen",  /* this must be imported into struct listens (which must still be declared) */

          myopts_listen,

          CFGF_MULTI),

      CFG_SIMPLE_STR("datadir", NULL),

      CFG_STR_LIST("render_types", NULL, CFGF_NONE),

      CFG_SIMPLE_STR("mysql_user", NULL),

      CFG_SIMPLE_STR("mysql_host", NULL),

      CFG_SIMPLE_STR("mysql_pass", NULL),

      CFG_SIMPLE_STR("mysql_database", NULL),

      CFG_END()

    };

  cfg_t *cfg_listen;

  fprintf(stderr, "%s:%d: running config\n", __FILE__, __LINE__);

  *config = malloc(sizeof(struct distrend_config));

  myopts[1].simple_value = &(*config)->datadir;

  myopts[3].simple_value = &(*config)->mysql_user;

  myopts[4].simple_value = &(*config)->mysql_host;

  myopts[5].simple_value = &(*config)->mysql_pass;

  myopts[6].simple_value = &(*config)->mysql_database;

      perror("bind");

      distrend_listen_add_unwind(newsock);

      return 1;

    }

  tmp = listen(newsock->sock.sock, 1);

  if(tmp == -1)

    {

      perror("listen");

      distrend_listen_add_unwind(newsock);

      return 1;

    }

  tmp = distrend_makesocknonblock(newsock->sock.sock);

  if(tmp)

    {

      /* error is already printed to user by distrend_makesocknonblock() */

      distrend_listen_add_unwind(newsock);

      return 1;

    }

  distrend_listen_poll_newfd(listens, &newsock->sock, POLLRDNORM);

  list_insert_after(listens->listen_socks, newsock, 0);

  return 0;

}

int distrend_handleread(struct distrend_listens *listens,

			struct distrend_client *client)

{

  struct distrend_packet *packet;

  ssize_t readlen;

  char buf[8192];

  struct distren_request *req;

  void *reqdata;

  packet = malloc(sizeof(struct distrend_packet));

  if(!packet)

    {

      fprintf(stderr, "OOM\n");

      return 1;

    }

  packet->len = 0;

  packet->data = NULL;

      readlen = read(client->sock.sock, buf, sizeof(buf));

      if(readlen == -1)

	{

	  perror("read");

	  switch(errno)

	    {

	    case EINTR:

	    case EAGAIN:

	      break;

	    default:

	      client->state = DISTREND_CLIENT_DEAD;

	      free(packet);

	      return 1;

	    }

	}

      if(readlen == 0)

	/* handle EOF */

	{

	  client->state = DISTREND_CLIENT_DEAD;

	  free(packet);

	  return 1;

	}

      packet->len = readlen;

      packet->data = malloc(readlen);

      if(!packet->data)

	{

	  fprintf(stderr, "OOM!\n");

	  free(packet);

	  return 1;

	}

      memcpy(packet->data, buf, readlen);

      q_enqueue(client->inmsgs, packet, 0);

      client->inlen += packet->len;

      packet = NULL;

  /**

     Manage input, etc.

   */

  if(client->expectlen == 0)

    {

      /* search out header from input so far */

      distrend_packets_collapse(client->inmsgs, client->inlen);

      packet = q_front(client->inmsgs);

      if(packet->len > sizeof(struct distren_request))

	{

	  if(distren_request_new_fromdata(&req, packet->data, packet->len))

	    {

	      fprintf(stderr, "Error handling data from client (magic likely did not match), closing connection\n");

	      client->state = DISTREND_CLIENT_DEAD;

	      return 1;

	    }

	  client->expectlen = req->len + sizeof(struct distren_request);

	  distren_request_free(req);

	}

    }

  if(client->expectlen

     && client->inlen >= client->expectlen)

    {

      /** essentially un-queue-ize the queue ;-) */

      distrend_packets_collapse(client->inmsgs, client->inlen);

      packet = q_front(client->inmsgs);

      if(distren_request_new_fromdata(&req, packet->data, packet->len))

	{

	  fprintf(stderr, "error handling data from client\n");

	  client->state = DISTREND_CLIENT_DEAD;

	  return 1;

	}

      if(packet->len - sizeof(struct distren_request) < req->len)

	{

	  fprintf(stderr, "error handling some data from client\n");

	  distren_request_free(req);

	  client->state = DISTREND_CLIENT_DEAD;

	  return 1;

	}

      reqdata = malloc(req->len);

      if(!reqdata)

	{

	  fprintf(stderr, "OOM\n");

	  distren_request_free(req);

	  return 1;

	}

      memcpy(reqdata, ((void *)packet->data) + sizeof(struct distren_request), req->len);

      memmove(packet->data,

	      ((void *)packet->data) + client->expectlen,

	      packet->len - client->expectlen);

      packet->len -= client->expectlen;

      client->inlen -= client->expectlen;

      client->expectlen = 0;

      distrend_dispatch_request(listens, client, req, reqdata);

      distren_request_free(req);

    }

  return 0;

}

struct distrend_accept_client_proc_data

{

  struct distrend_listens *listens;

  time_t current_time;

};

int distrend_accept_client_proc(struct distrend_accept_client_proc_data *data,

				struct distrend_client *client)

{

  struct distrend_packet *packet;

  ssize_t written_amount;

  short revents;

  if(client->state == DISTREND_CLIENT_DEAD)

    return TRUE;

  /**

     Manage timing-out clients.

   */

  if(data->current_time > client->cleanup_time)

    switch(client->state)

      {

      case DISTREND_CLIENT_PREAUTH:

	distrend_send_disconnect(data->listens, client, "You have failed to present authentication information in a timely manner. Cya ;-)");

	break;

      case DISTREND_CLIENT_GOOD:

	distrend_send_disconnect(data->listens, client, "Ping timeout :-p");

	break;

      case DISTREND_CLIENT_BAD:

	client->state = DISTREND_CLIENT_DEAD;

	return TRUE;

      default:

	break;

      }

  revents = data->listens->pollfds[client->sock.pollfd_offset].revents;

  if(revents & POLLRDNORM)

    /* handle reading */

    {

      fprintf(stderr, "%s:%d: My traversal says that sock %d is available for reading\n",

	      __FILE__, __LINE__, client->sock.sock);

      distrend_handleread(data->listens, client);

    }

  if(revents & POLLWRNORM)

    {

      fprintf(stderr, "%s:%d: My traversal says that sock %d is available for writing\n",

	      __FILE__, __LINE__, client->sock.sock);

      if(q_empty(client->outmsgs))

	{

	  data->listens->pollfds[client->sock.pollfd_offset].events &= ~POLLWRNORM;

	  return TRUE;

	}

      packet = q_front(client->outmsgs);

      written_amount = write(client->sock.sock, packet->data, packet->len);

      /**

	 Disconnect in case of write error.

       */

      if(written_amount == -1)

	{

	  perror("write");

	  /*

	    distrend_client_free();

	    Until liblist has the ability to delete nodes

	    during traversal, we'll have to free the client

	    during a client-list cleanup/pruning cycle.

	  */

	  client->state = DISTREND_CLIENT_DEAD;

	}

      if(packet->len == written_amount)

	{

	  q_dequeue(client->outmsgs);

	  distrend_packet_free(packet);

	  if(q_empty(client->outmsgs))

	    data->listens->pollfds[client->sock.pollfd_offset].events &= ~POLLWRNORM;

	}

      else

	{

	  /**

	     shifting seems the simplest solution.

	   */

	  packet->len -= written_amount;

	  memmove(packet->data, packet->data + written_amount, packet->len);

	}

    }

  /** continue iteration through the list */

  return TRUE;

}

int distrend_accept_newclient_proc(struct distrend_listens *listens, struct distrend_listen_sock *listen_sock)

{

  short revents;

  int newclientsock;

  revents = listens->pollfds[listen_sock->sock.pollfd_offset].revents;

  fprintf(stderr, "blah %d\n", (int)revents);

  if(revents & POLLRDNORM)

    {

      newclientsock = accept(listen_sock->sock.sock, (struct sockaddr *)NULL, (socklen_t *)NULL);

	{

	  fprintf(stderr, "error allocating/adding client struct\n");

	  return 1;

	}

      fprintf(stderr, "accepted new connection\n");

    }

  /**

     Check other listen blocks too.

   */

  return TRUE;

}

int distrend_accept(struct distrend_listens *listens)//, struct distrend_clientset *clients, distrend_handle_request_t handlereq, void *handlereqdata)

{

  int tmp;

  struct distrend_accept_client_proc_data travinfo;

  struct distrend_client *newclient;

  fprintf(stderr, "poll(*, %d, -1)...\n", (int)listens->nfds);

  poll(listens->pollfds, listens->nfds, -1);

  if(tmp == -1)

    {

      perror("select");

      return 1;

    }

  /**

     Deal first with data waiting to be sent and then

     with input data.

   */

  travinfo.listens = listens;

  travinfo.current_time = time(NULL); /*< cache the time */

  list_traverse(listens->clients, &travinfo, (list_traverse_func_t)&distrend_accept_client_proc, LIST_FRNT | LIST_SAVE);

  /**

     Handle new connections.

   */

  list_traverse(listens->listen_socks, listens, (list_traverse_func_t)&distrend_accept_newclient_proc, LIST_FRNT | LIST_SAVE);

  /**

     Until liblist supports deleting nodes during a traversal,

     we clean dead clients here:

   */

  list_mvfront(listens->clients);

  newclient = list_curr(listens->clients);

  return 1;

}

/**

   This is probably just NOT a placeholder for remotio

*/

void remotio_send_to_client(struct distrend_client *client, const char *msg, size_t len)

{

    fprintf(stderr, "%s:%d: STUB I should queue data for writing to a client\n", __FILE__, __LINE__);

}

/**

   Adds a newly connected distrend_client to the listens->clients list

 */

int distrend_client_add(struct distrend_listens *listens, int sock, enum distrend_client_state state)

{

  int tmp;

  struct distrend_client *client;

  tmp = distrend_makesocknonblock(sock);

  if(tmp)

    {

      fprintf(stderr, "Not accepting this connection because I cannot make the sock non-blocking\n");

      close(sock);

      return 1;

    }

  client = malloc(sizeof(struct distrend_client));

  if(!client)

    {

      fprintf(stderr, "OOM\n");

      close(sock);

      return 1;

    }

  client->sock.sock = sock;

  distrend_listen_poll_newfd(listens, &client->sock, POLLRDNORM); /*< error checking? bah! */

  client->state = state;

  client->cleanup_time = time(NULL) + DISTREND_LISTEN_AUTHTIME;

  client->inlen = 0;

  client->expectlen = 0;

  client->inmsgs = q_init();

  client->outmsgs = q_init();

  list_insert_after(listens->clients, client, 0);

  /**

     For those using netcat/telnet to debug their internets.

   */

  return 0;

}

/**

   This function shall only be called after the appropriate

   distrend_listen_poll_deletefd() has been called

 */

int distrend_client_free(struct distrend_client *client)

{

  q_free(client->inmsgs, (list_dealloc_func_t)distrend_packet_free);

  q_free(client->outmsgs, (list_dealloc_func_t)distrend_packet_free);

  close(client->sock.sock);

  return 0;

}

void distrend_packet_free(struct distrend_packet *packet)

{

  free(packet->data);

  free(packet); 

}

int distrend_makesocknonblock(int sock)

{

  int fdstatus;

  int tmp;

  fdstatus = fcntl(sock, F_GETFL);

  fdstatus |= O_NONBLOCK;

  tmp = fcntl(sock, F_SETFL, fdstatus);

  if(tmp == -1)

    {

      perror("fcntl");

      return 1;

    }

  return 0;

}

int distrend_client_write(struct distrend_listens *listens, struct distrend_client *client, char *towrite, size_t msglen)

{

  struct distrend_packet *packet;

  packet = malloc(sizeof(struct distrend_packet));

  if(!packet)

  This file is a part of DistRen.

  DistRen is free software: you can redistribute it and/or modify

  it under the terms of the GNU Affero General Public License as published by

  the Free Software Foundation, either version 3 of the License, or

  (at your option) any later version.

  DistRen is distributed in the hope that it will be useful,

  but WITHOUT ANY WARRANTY; without even the implied warranty of

  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  GNU Affero General Public License for more details.

  You should have received a copy of the GNU Affero General Public License

  along with DistRen.  If not, see <http://www.gnu.org/licenses/>.

*/

struct general_info;

struct distrend_listens;

struct distrend_client;

#ifndef _DISTREN_LISTEN_H

#define _DISTREN_LISTEN_H

#include "distrend.h"

#include "common/protocol.h"

#include <poll.h>

#include <queue.h>

#include <time.h>

/**

   How long a client has after connecting to send

   authentication information before his connection is cleaned

   up.

 */

#define DISTREND_LISTEN_AUTHTIME 32

/**

   How long a client has when in DISTREND_CLIENT_BAD before

   his connection is dropped. This grace time is intended so that

   the client will actually see his disconnect message instead of

   just having his connection reset.

 */

#define DISTREND_LISTEN_DISCONNECT_GRACE 8