process.h File Reference

a simple object-oriented process manager object model inspired by Zed Shaw More...

#include <stdlib.h>
#include <stdbool.h>
#include "util.h"
#include "obj.h"

Go to the source code of this file.

Classes
struct	co_process_t

Typedefs
typedef struct co_process_t	co_process_t

Enumerations
enum	co_process_state_t {   _STOPPING = 0, _STOPPED =1, _STARTING = 2, _STARTED = 3,   _FAILED = -1 }

Functions
struct co_process_t	__attribute__ ((packed))
co_obj_t *	co_process_create (size_t size, co_process_t proto, const char *name, const char *pid_file, const char *exec_path, const char *run_path)
	creates a new commotion process More...
int	co_process_destroy (co_obj_t *self)
	removes a process from commotiond More...
int	co_process_start (co_obj_t *self, char *argv[])
	starts a selected process More...
int	co_process_stop (co_obj_t *self)
	stops a running process More...
int	co_process_restart (co_obj_t *self)
	restarts a process More...

Variables
typedef	__attribute__
co_obj_t	_header
uint8_t	_exttype
uint8_t	_len
int	pid
bool	registered
bool	use_watchdog
co_process_state_t	state
char *	name
char *	pid_file
char *	exec_path
char *	run_path
int	input
int	output
int(*	init )(co_obj_t *self)
int(*	destroy )(co_obj_t *self)
int(*	start )(co_obj_t *self, char *argv[])
int(*	stop )(co_obj_t *self)
int(*	restart )(co_obj_t *self)

Detailed Description

a simple object-oriented process manager object model inspired by Zed Shaw

Author

Josh King (jheretic), jking.nosp@m.@cha.nosp@m.mbana.nosp@m..net

Enumeration Type Documentation

enum co_process_state_t

defines the state of the process

             {
  _STOPPING = 0,
  _STOPPED =1,
  _STARTING = 2,
  _STARTED = 3,
  _FAILED = -1
} co_process_state_t;

Function Documentation

co_obj_t* co_process_create	(	size_t	size,
		co_process_t	proto,
		const char *	name,
		const char *	pid_file,
		const char *	exec_path,
		const char *	run_path
	)

creates a new commotion process

Parameters

size	size of the process
co_process_t	protocol
name	name of the process
pid_file	the lockfile where the process id is stored
exec_path	the execution path
run_path	the run path

Returns

co_process_t to be registered with the daemon

References co_process_destroy(), co_process_start(), and co_process_stop().

                                                                                                                                                        {
  if(!proto.init) proto.init = NULL;
  if(!proto.destroy) proto.destroy = co_process_destroy;
  if(!proto.start) proto.start = co_process_start;
  if(!proto.stop) proto.stop = co_process_stop;

  co_process_t *new_proc = h_calloc(1,size);
  *new_proc = proto;
  new_proc->_header._type = _ext8;
  new_proc->_exttype = _process;
  new_proc->_len = size;

  CHECK_MEM(new_proc);
  
  new_proc->name = h_strdup(name); 
  hattach(new_proc->name,new_proc);
  new_proc->pid_file = h_strdup(pid_file); 
  hattach(new_proc->pid_file,new_proc);
  new_proc->exec_path = h_strdup(exec_path); 
  hattach(new_proc->exec_path,new_proc);
  new_proc->run_path = h_strdup(run_path);
  hattach(new_proc->run_path,new_proc);

  if(!new_proc->init((co_obj_t*)new_proc)) {
    SENTINEL("Failed to initialize new process.");
  } else {
    return (co_obj_t*)new_proc;
  }

error:
  new_proc->destroy((co_obj_t*)new_proc);
  return NULL;
}

int co_process_destroy

(

co_obj_t *

self

)

removes a process from commotiond

Parameters

self	pointer to the process' struct

Referenced by co_process_create().

                                       {
  CHECK_MEM(self);
  CHECK(IS_PROCESS(self),"Not a process.");

  co_obj_free(self);

  return 1;

error:
  return 0;
}

int co_process_restart

(

co_obj_t *

self

)

restarts a process

Parameters

self	pointer to the process' struct

                                       {
  CHECK_MEM(self);
  CHECK(IS_PROCESS(self),"Not a process.");
  co_process_t *this = (co_process_t*)self;
  if(this->stop((co_obj_t*)this)) this->start((co_obj_t*)this, NULL);

  return 1;

error:
  return 0;
}

int co_process_start	(	co_obj_t *	self,
		char *	argv[]
	)

starts a selected process

Parameters

self	pointer to the process' struct
argv[]	execution path for the process

References exec.

Referenced by co_process_create().

                                                   {
  CHECK_MEM(self);
  CHECK(IS_PROCESS(self),"Not a process.");
  co_process_t *this = (co_process_t*)self;
  char *exec = NULL;
  CHECK(((exec = this->exec_path) != NULL), "Invalid exec path!");
  int pid = 0;
  int local_stdin_pipe[2], local_stdout_pipe[2];

  if(pipe(local_stdin_pipe)) {
    ERROR("Could not initialize stdin pipe.");
    return 0;
  }
  if(pipe(local_stdout_pipe)) {
    ERROR("Could not initialize stdout pipe.");
    return 0;
  }
  
  if (!(pid = fork())) {
    dup2(local_stdin_pipe[0], 0);
    dup2(local_stdout_pipe[1], 1);

    close(local_stdin_pipe[0]);
    close(local_stdin_pipe[1]);
    close(local_stdout_pipe[0]);
    close(local_stdout_pipe[1]);

    CHECK((execvp(exec, argv) != -1), "Failed to exec!");
  }
  INFO("fork()ed: %d\n", pid);
  this->pid = pid;

  this->input = local_stdin_pipe[1];
  this->output = local_stdout_pipe[0];

  close(local_stdin_pipe[0]);
  close(local_stdout_pipe[1]);

  return 1;

error:
  exit(1);
  return 0;
}

int co_process_stop

(

co_obj_t *

self

)

stops a running process

Parameters

self	pointer to the process' struct

Referenced by co_process_create().

                                    {
  CHECK_MEM(self);
  CHECK(IS_PROCESS(self),"Not a process.");
  co_process_t *this = (co_process_t*)self;
  CHECK(!(kill(this->pid, SIGKILL)), "Failed to kill co_process_t %d.", this->pid);

  return 1;

error:
  return 0;
}