/*******************************************************************
 * Copyright 2009 Tycho Andersen. 
 *
 * File: tcrond.c
 *
 * Purpose: simple cron with second resolution instead of minute.
 * Usage: see file README
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License.
 *
 * This program 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 General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 * Changelog:
 * 0.2a: Fixed a small regression with sequential process handling.
 * 0.2: Fixed serious issue with parallel mode which would eventually
 * 	fill up the process table.
 * 0.1: Initial release.
 ******************************************************************/

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <stdint.h>
#include <unistd.h>
#include <string.h>

#define MAX_LINE_LENGTH 1024
#define MAX_ARG_COUNT 15
#define INITIAL_LIST_SIZE 11

typedef struct
{
	uint32_t modulus, offset;
	time_t next;
	char *command;
	char *args[MAX_ARG_COUNT];
} job;

/**************************************************************
 * Function: next_job
 * INPUT: job list, the size of the list, and the current time
 * OUTPUT: the function stores the list of jobs to be run at the time
 * 	returned in the list to_execute. This list is terminated by -1 if
 * 	not all jobs are to be executed.
 * 	to_execute should be at least count elements long.
 **************************************************************/
time_t next_job(job* list, uint32_t count, int32_t* to_execute)
{
	uint32_t min = UINT32_MAX, i, index = 0;

	for(i=0; i<count; i++)
	{
		if(list[i].next < min)
			min = list[i].next;
	}

	for(i=0; i<count; i++)
	{
		if(list[i].next == min)
		{
			list[i].next += list[i].modulus;
			to_execute[index++] = i;
		}
	}

	if(index != count)
		to_execute[index] = -1;
	return min;
}

int main(int argc, char* argv[])
{
	// config file read stuff
	FILE* in;
	char line[MAX_LINE_LENGTH];
	time_t start;

	// jobs list stuff
	uint32_t count = 0, size = INITIAL_LIST_SIZE, i;
	job* list = (job*) malloc(sizeof(job) * INITIAL_LIST_SIZE);
	int32_t* to_execute;
	char child_process_count = 0;

	// tcron options
	char sequential = 0;

	if(argc != 2 && argc != 3)
	{
		printf("usage: %s tcron.conf [--sequential]\n", argv[0]);
		exit(1);
	}

	if(argc == 3 && strcmp(argv[2], "--sequential") == 0)
		sequential = 1;

	// parse tcron.conf
	in = fopen(argv[1], "r");
	if(in == NULL)
	{
		printf("problem opening: %s\n", argv[2]);
		exit(2);
	}

	fgets(line, MAX_LINE_LENGTH, in);
	line[strlen(line)-1] = '\0'; // remove the trailing newline from the string
	start = time(NULL);
	while(!feof(in))
	{
		uint32_t arg = 0;
		char* temp;

		// grow the job list if necessary
		if(size == count)
		{
			list = (job*) realloc(list, sizeof(job) * size * 2);
			size*=2;
		}

		list[count].modulus = atoi(strtok(line, " "));
		list[count].offset = atoi(strtok(NULL, " "));
		temp = strtok(NULL, " ");
		list[count].command = (char*) malloc(sizeof(char)*(strlen(temp)+1));
		strcpy(list[count].command, temp);

		// by convention, the first argument is how the command is being executed
		list[count].args[0] = list[count].command;
		for(arg = 1; arg < MAX_ARG_COUNT; arg++)
		{
			temp = strtok(NULL, " ");
			if(temp == NULL)
			{
				list[count].args[arg] = NULL;
				break;
			}
			list[count].args[arg] = (char*) malloc(sizeof(char)*(strlen(temp)+1));
			strcpy(list[count].args[arg], temp);
		}
		list[count].next = start+(list[count].modulus-start%list[count].modulus)+list[count].offset;
		
		count++;
		fgets(line, MAX_LINE_LENGTH, in);
		line[strlen(line)-1] = '\0';
	}
	fclose(in);

	for(i=0; i<count; i++)
	{
		uint32_t arg = 0;
		printf("Parsed: ");
		arg = 0;
		while(list[i].args[arg] != NULL)
			printf(" %s", list[i].args[arg++]);
		printf(" every %d seconds offset by %d\n", list[i].modulus, list[i].offset);
	}

	to_execute = (int32_t*) malloc(sizeof(int32_t) * count);
	// enter tcron sequence
	while(1)
	{
		time_t now, target;
		pid_t pid;
		char num_exited = 0;
	
		now = time(NULL);
		target = next_job(list, count, to_execute); 
		if(target > now)
		{
			printf("sleeping for %lu...\n", (uint32_t) target-now);
			sleep(target - now);
		}
	
		// execute next jobs
		for(i=0; i<count; i++)
		{
			if(to_execute[i] < 0)
				break;
			printf("executing job %d at %lu\n", to_execute[i], (uint32_t) target);
			fflush(stdout);
			pid = fork();
			if(pid == 0)
				execvp(list[to_execute[i]].command, list[to_execute[i]].args);
			else if(sequential)
				wait(NULL);
			else
				child_process_count++;
		}

		if(!sequential)
		{
			// try and clean up any child processes who might have finished
			// NOTE: this will leave dead processes who finish after this
			// sequence in the process table until the next time this sequence
			// is called. I would like to fix this at some point, but I don't
			// really have any better ideas.
			for(i=0; i<child_process_count; i++)
			{
				pid = waitpid(-1, NULL, WNOHANG);
				if(pid > 0)
					num_exited++;
			}
			child_process_count -= num_exited;
		}
	}

	free(to_execute);
	for(i=0; i<count; i++)
	{
		uint32_t j = 0;
		while(list[i].args[j] != NULL)
			free(list[i].args[j]);
		free(list[i].command);
	}
	free(list);
	return 0;
}