Copyright 2010 Nathan Phillip Brink

  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/>.

*/

#ifndef DISTREN_PROTOCOL_H

#define DISTREN_PROTOCOL_H

#include <stddef.h>

#include <stdint.h>

/**

   Server types:

 */

#define DISTREN_SERVERTYPE_SUBMIT (0x1)

#define DISTREN_SERVERTYPE_DISTRIBUTE (0x2)

#define DISTREN_SERVERTYPE_RENDER (0x4)

/**

   This file defines the constants and structs that the client uses to talk to the server and that the servers use to talk to eachother.

 */

/**

   generic, shared requests

 */

enum distren_request_type

  {

    /**

       identifies the version of software being

       used by the sender and tells if it is a client or server.

       Just send PACKAGE_STRING.

    */

    DISTREN_REQUEST_VERSION = 1,

    DISTREN_REQUEST_PING = 2,

    DISTREN_REQUEST_PONG = 3,

    DISTREN_REQUEST_DISCONNECT = 4,

    /**

       client->server only requests

    */

    DISTREN_REQUEST_SUBMIT = 5,

    /**

       anything->server requests

     */

    DISTREN_REQUEST_JOBINFO = 6, /*< retrieves information about a job based on its number */

    /**

       server->anything

     */

    DISTREN_REQUEST_JOBINFO_RESPONSE = 7, /*< returns information about a job */

    /**

       server->server

    */

    DISTREN_REQUEST_RENDERFRAME = 8,

    DISTREN_REQUEST_DONEFRAME = 9, /* server should check to make sure the

slave is repoting on a frame it's actually assigned to */

    DISTREN_REQUEST_PROGRESS = 10, /*< tells another server of the progress of the first server's work at rendering */

    DISTREN_REQUEST_GETWORK = 11,

    DISTREN_REQUEST_GETVERSION = 12, /*< returns version of software that slave should be running */

    DISTREN_REQUEST_GETRENDERPOWER = 13, /* returns the render power of a slave */

    DISTREN_REQUEST_SETRENDERPOWER = 14, /* sets renderpower in server

database */

    /**

       sets a frame back to unassigned,

       happens if the slave quits for some reason. server code should only allow

       resetting of a frame assigned to the slave calling the request (see php

       code)

    */ 

    DISTREN_REQUEST_RESETFRAME = 15,

  };

struct distren_request

{

  uint32_t magic;

  uint32_t len;

  /** treat type as an enum distren_request_type using casting */

  uint32_t /* enum distren_request_type */ type;

};

/**

#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_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 */

  struct general_info general_info;

  struct distrend_clientset *clients;

  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",

    {

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

      distrend_accept(general_info.config, clients, (distrend_handle_request_t)&distrend_handle_request, (void *)&general_info);

      /* 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_unlisten(general_info.config->listens, clients);

  distrend_config_free(general_info.config);

  xmlcleanup();

  /** free() paths */

  free(general_info.files.geninfo);

  mysqlDisconnect(general_info.conn);

  return 0;

}

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

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

{

  size_t counter;

  /* for response requests... if that makes any less sense ;-) */

  struct distren_request *newreq;

  fprintf(stderr, "I can haz data %d bytes long:", req->len);

  for(counter = 0; counter < req->len; counter ++)

    fputc(((char *)reqdata)[counter], stderr);

  fputc('\n', stderr);

  switch(req->type)

    {

    case DISTREN_REQUEST_VERSION:

      distren_request_new(&newreq, strlen(VERSION), DISTREN_REQUEST_VERSION);

      distrend_client_write_request(client, newreq, VERSION);

      distren_request_free(newreq);

      break;

    }

  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;

	      packet->len - client->expectlen);

      packet->len -= client->expectlen;

      client->inlen -= client->expectlen;

      client->expectlen = 0;

      (*handlereq)(client, req, reqdata, handlereqdata);

      distren_request_free(req);

    }

  return 0;

}

struct distrend_accept_fdset_prepare_data

{

  fd_set readfds;

  fd_set writefds;

  /**

     stores the highest FD number which is one less than the first

   arfgument to select(). So do select(maxfd + 1, ...)

  */

  int maxfd;

};

int distrend_accept_fdset_prepare(struct distrend_accept_fdset_prepare_data *data,

				  struct distrend_client *client)

{

  if(client->state == DISTREND_CLIENT_DEAD)

    return TRUE;

  if(client->sock > data->maxfd)

    data->maxfd = client->sock;

  FD_SET(client->sock, &data->readfds);

  /**

     Only select on an outgoing socket if we have something to

     say.

   */

  if(!q_empty(client->outmsgs))

    FD_SET(client->sock, &data->writefds);

  return TRUE;

}

struct distrend_accept_client_proc_data

{

  fd_set *fdset;

  struct distrend_config *config;

  distrend_handle_request_t handlereq;

  void *handlereqdata;

  enum {DISTREND_ACCEPT_CLIENT_READ, DISTREND_ACCEPT_CLIENT_WRITE} mode;

};

int distrend_accept_client_proc(struct distrend_accept_client_proc_data *data,

				struct distrend_client *client)

{

  struct distrend_packet *packet;

  ssize_t written_amount;

  if(client->state == DISTREND_CLIENT_DEAD)

    return TRUE;

  if(!FD_ISSET(client->sock, data->fdset))

    /** continue iteration through the list */

    return TRUE;

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

	  __FILE__, __LINE__, client->sock,

	  (data->mode == DISTREND_ACCEPT_CLIENT_READ) ? "read" : "writ");

  switch(data->mode)

    {

    case DISTREND_ACCEPT_CLIENT_WRITE:

      if(q_empty(client->outmsgs))

	return TRUE;

      packet = q_front(client->outmsgs);

      written_amount = write(client->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);

	}

      else

	{

	  /**

	     shifting seems the simplest solution.

	   */

	  packet->len -= written_amount;

	}

      break;

    case DISTREND_ACCEPT_CLIENT_READ:

      distrend_handleread(data->config, client, data->handlereq, data->handlereqdata);

      break;

    }

  /** continue iteration through the list */

  return TRUE;

}

int distrend_accept(struct distrend_config *config, struct distrend_clientset *clients, distrend_handle_request_t handlereq, void *handlereqdata)

{

  int tmp;

  int newclientsock;

  struct distrend_accept_fdset_prepare_data fdsets;

  struct distrend_accept_client_proc_data travinfo;

  struct distrend_client *newclient;

  FD_ZERO(&fdsets.readfds);

  FD_ZERO(&fdsets.writefds);

  FD_SET(config->listens->sock, &fdsets.readfds);

  fdsets.maxfd = config->listens->sock;

  list_traverse(clients->clients, &fdsets, (list_traverse_func_t)&distrend_accept_fdset_prepare, LIST_FRNT | LIST_ALTR);

  fprintf(stderr, "select()...");

  tmp = select(fdsets.maxfd + 1, &fdsets.readfds, &fdsets.writefds, NULL, (struct timeval *)NULL);

  if(tmp == -1)

    {

      perror("select");

      return 1;

    }

  /**

     Deal first with data waiting to be sent and then

     with input data.

   */

  travinfo.config = config;

  travinfo.fdset = &fdsets.writefds;

  travinfo.handlereq = handlereq;

  travinfo.handlereqdata = handlereqdata;

  travinfo.mode = DISTREND_ACCEPT_CLIENT_WRITE;

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

  travinfo.fdset = &fdsets.readfds;

  travinfo.mode = DISTREND_ACCEPT_CLIENT_READ;

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

  /**

     Handle new connections.

   */

  if(FD_ISSET(config->listens->sock, &fdsets.readfds))

    {

      newclientsock = accept(config->listens->sock, (struct sockaddr *)NULL, (socklen_t *)NULL);

      if(distrend_client_new(&newclient, newclientsock, DISTREND_CLIENT_PREAUTH))

	{

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

	  return 1;

	}

      clients->nfds ++;

      list_insert_after(clients->clients, newclient, 0);

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

      distrend_client_write(newclient, "hello\n", 6);

    }

  /**

     Until liblist supports deleting nodes during a traversal,

     we clean dead clients here:

   */

  list_mvfront(clients->clients);

  newclient = list_curr(clients->clients);

  while(newclient)

    {

      if(newclient->state == DISTREND_CLIENT_DEAD)

	{

	  distrend_client_free(newclient);

	  list_remove_curr(clients->clients);

	  fprintf(stderr, "removed dead connection\n");

	}

      list_mvnext(clients->clients);

      /* provide for termination of this loop */

      if(newclient == list_curr(clients->clients))

	newclient = NULL;

      else

	newclient = list_curr(clients->clients);

    }

  return 0;

}

int distrend_unlisten(struct distrend_listen *listens, struct distrend_clientset *clients)

{

  fprintf(stderr, "%s:%d: I am a stub that needn't be implemented 'til later\n", __FILE__, __LINE__);

  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__);

}

int distrend_client_new(struct distrend_client **client, int sock, enum distrend_client_state state)

{

  int tmp;

  tmp = distrend_makesocknonblock(sock);

  if(tmp)

    {

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

      return 1;

    }

  *client = malloc(sizeof(struct distrend_client));

  if(!*client)

    {

      fprintf(stderr, "OOM\n");

      return 1;

    }

  (*client)->sock = sock;

  (*client)->state = state;

  (*client)->inlen = 0;

  (*client)->expectlen = 0;

  (*client)->inmsgs = q_init();

  (*client)->outmsgs = q_init();

  return 0;

}

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);

  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_client *client, char *towrite, size_t msglen)

{

  struct distrend_packet *packet;

  packet = malloc(sizeof(struct distrend_packet));

  if(!packet)

 */

int distrend_packets_collapse(QUEUE *queue, size_t len)

{

  struct distrend_packet *newpacket;

  struct distrend_packet *oldpacket;

  size_t copiedlen;

  newpacket = malloc(sizeof(struct distrend_packet));

  if(!newpacket)

    {

      fprintf(stderr, "OOM\n");

      return 1;

    }

  newpacket->data = malloc(len);

  if(!newpacket->data)

    {

      fprintf(stderr, "OOM\n");

      perror("malloc");

      free(newpacket);

      return 1;

    }

  for(copiedlen = 0;

      copiedlen < len && !q_empty(queue);

      )

    {

      oldpacket = q_dequeue(queue);

      memcpy(newpacket->data + copiedlen, oldpacket->data, oldpacket->len);

      copiedlen += oldpacket->len;

      distrend_packet_free(oldpacket);

    }

  newpacket->len = copiedlen;

  if(copiedlen < len || !q_empty(queue))

    {

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

      return 1;

    }

  q_enqueue(queue, newpacket, 0);

  return 0;

}

/*

  Copyright 2010 Nathan Phillip Brink

  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 distrend_clientset;

struct distrend_listen;

struct distrend_client;

#ifndef _DISTREN_LISTEN_H

#define _DISTREN_LISTEN_H

#include "distrend.h"

#include "common/protocol.h"

#include <queue.h>

enum distrend_client_state

  {

    DISTREND_CLIENT_PREAUTH,

    DISTREND_CLIENT_DEAD

  };

struct distrend_listen

{

  int port;

  int sock;

};

struct distrend_client

{

  int sock;

  enum distrend_client_state state;

  size_t inlen; /*< number of bytes waiting to be processed */

  size_t expectlen; /*< number of bytes that inlen has to be for a complete request to be had, 0 when waiting on header */

  QUEUE *inmsgs;

  QUEUE *outmsgs;

};

typedef int(*distrend_handle_request_t)(struct distrend_client *client, struct distren_request *req, void *reqdata, void *data);

/**

   initializes the listens and clientset

   @param config the configuration from distrend

   @param clients a pointer to a struct distrend_clientset pointer which will be set to memory allocated for the clientset

 */

int distrend_listen(struct distrend_config *config, struct distrend_clientset **clients);

/**

   checks states of the sockets I'm managing. If there are any new connections,

   or activity on any sockets, I'll call the appropriate function.

   I will block until there is some sort of activity, including

   signals. If you want to cleanly shut down, it's best to register

   signal handlers somewhere

 */

int distrend_accept(struct distrend_config *config, struct distrend_clientset *clients, distrend_handle_request_t handlereq, void *handlereqdata);

/**

   cleans listening socket. Unnecessary for a working server, currently a stub.

 */

int distrend_unlisten(struct distrend_listen *listens, struct distrend_clientset *clients);

/**

   writes message to client.

   @param towrite the caller is expected to free this string. This function will

   strdup() it, in essence.

 */

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

/**

   writes request to client.

   @param client client to write to

   @param req the request struct. caller must free this.

   @param data the data of the request which is req->len bytes long. caller must free this.

 */

int distrend_client_write_request(struct distrend_client *client, struct distren_request *req, void *data);

/**

   This is probably just NOT a placeholder for remotio

*/

void remotio_send_to_client();

#endif