Re: Forking from Gtk

[James Scott Jr <skoona verizon net>]

G,

I've seen most of the other responses, and better understand what you
are trying to do.  And like others -- fork() is not recommended. 

I had similar problem and resolved it in this codeset.
http://gfhcm.sourceforge.net  -- a monitor for the folding home project

First, like you I needed to start several executables in the background,
resolve their identify via pid number, and monitor their cpu utilization
and associated artifacts to gage their progress.  

I approached it two ways: with standalone gfhcm, and then in
client/server way using gfhcmc & gfhcmd; gfhcmc is the gtk gui and
gfhcmd is a glib helper daemon.

For your issue: I suggest g_[a]sync_command_line() as a way to launch a
background process from a gtk app.  Then using either ipc Queues, pipes,
or sockets to connect to process to echange commands and information.
Having a formal daemon will help the issue of starting/stopping the
background thread. and Finally a dedicated gui that expects to use an
IPC to communication with the process.

Anyway that you would like to proceed - I think we all can offer
solutions.  But be clear, I and maybe we think, forking is a bad ideal
for GTK program period.

My website may have something of interest:
http://mysite.verizon.net/skoona/id2.html

James,

On Tue, 2008-07-08 at 06:51 +0200, G Hasse wrote:
> On Mon, Jul 07, 2008 at 10:58:36PM -0400, James Scott Jr wrote:
> > G,
> > 
> > The basic design decision to use fork() as a way to do work in the
> > background flawed.  fork()ing is not practical for gtk program.  While
> > fork() has been a valid option for many non-gui programs in the absence
> > of threads, either g_thread_create() or pthread_create().  Today it is
> > not very useful -- as in stop doing it now!
> > 
> > Consider instead using a valid multi-threaded implementation like
> > g_threads_xxx() for GTK based programs.  Or if full multi-threading is
> > not required, look at g_timeout_add() which is a background timer
> > routine that can serve as one or more background execution units; neatly
> > inside an gtk context.
> 
> This is not a very practical solution if I want to quit the gtk program
> and go home... The example I gave was just an example. I want to create
> a process that run for a VERY long time. (a week). And to have the GUI
> running allong is not a solution. This process don't need to communicate
> with the GUI. And if so I can connect to the process with a socket and
> ask for services.
> 
> > 
> > $ devhelp
> > $ gtk-demo
> > 
> > The above two program you be pre-installed on your Linux machine:
> > devhelp has the gtk and glib api documentation, and gtk-demo shows you
> > many of the gtk/glib features in action.
> > 
> > Having said the multi-thread phrase, here is another word of caution.
> > In GTK only the main or ONE thread can safely interface with GTK api
> > calls that change the display.  Using more than one thread to call gtk
> > apis at the same time will fail or cause a sigfault.  The context of GTK
> > being your front-end to X11 is the source of this
> > none-thread-safe-caution; it is in how gtk MUST interact with X that
> > placing the multi-thread restriction.  There are elegant work-arounds
> > this issue.
> > 
> > Here is a link to the classic FAQ answer on Multi-threaded GTK programs:
> > http://library.gnome.org/devel/gtk-faq/stable/x482.html
> > 
> > Regards,
> > James,
> 
> Tanks for your answer but I don't thing threads is the solution in my
> case.
> 
> > 
> > On Mon, 2008-07-07 at 23:03 +0200, G Hasse wrote:
> > > Hello,
> > > 
> > > I have a small demo app. This works on FreeBSD but I can't
> > > get to work on Linux. I know that in Linux setsid will fail
> > > if the child has the same session_id as the parent. So on
> > > Linux you must fork twice. But it also seems that the parent
> > > must do an exit. And I don't want that. The code is not very
> > > long - so I include it here.
> > > 
> > > ---<snipp>---
> > > //----------------------------------------------------------------------
> > > //
> > > //  $Id: GtkFork.c,v 1.2 2008/07/07 20:29:17 gorhas Exp $
> > > //
> > > //  Experiment to run a thing in background
> > > //  This works on FreeBSD but not on Linux...
> > > //
> > > //  Build with
> > > //
> > > //  CFLAGS := `pkg-config glib-2.0 --cflags` `pkg-config gtk+-2.0 
> > > --cflags`
> > > //  LDFLAGS := `pkg-config glib-2.0 --libs` `pkg-config gtk+-2.0 --libs`
> > > //
> > > //  cc $(CFLAGS) -o GtkFork GtkFork.c $(LDFLAGS)
> > > //
> > > //----------------------------------------------------------------------
> > > 
> > > #include <gtk/gtk.h>
> > > #include <stdlib.h>
> > > #include <stdio.h>
> > > #include <time.h>
> > > #include <string.h>
> > > 
> > > //----------------------------------------------------------------------
> > > // run_btn_callback
> > > //
> > > // Try to run something in the background
> > > //
> > > //----------------------------------------------------------------------
> > > static void run_btn_callback (GtkWidget *button, gpointer data)
> > > {
> > > 
> > >    int loops_to_run = 0;
> > >    int i = 0;
> > >    int pid = -1;
> > >    int ret = -1;
> > > 
> > >    // Skriv ut innehållet på skärmen 
> > >    printf("Clicked..\n");
> > >    printf("Data was: %s\n", gtk_entry_get_text( data ));
> > > 
> > >    loops_to_run = atoi( gtk_entry_get_text(data));
> > > 
> > >    // We dont want to wait very long...
> > >    if( loops_to_run > 60 )
> > >    {
> > >       loops_to_run = 60;
> > >       printf("Adjusting to 60 loops...\n");
> > >    }
> > >    printf("Loops to run: %d\n", loops_to_run );
> > > 
> > > 
> > > 
> > >    printf("We make a daemon\n");
> > >    if ( ( pid = fork() ) < 0 )
> > >    {
> > >       // Something went wrong
> > >       printf("We could not fork.... just exit");
> > >       exit(-1);
> > >    }
> > >    else if ( pid != 0 )
> > >    {
> > >       
> > >       // This is the parent process
> > >       printf("The background process have pid:  %d\n", pid);
> > >       return;
> > >    }
> > > 
> > >    // Quit gtk
> > >    gtk_main_quit();
> > > 
> > >    // Become session leader
> > >    ret = setsid();
> > >    if( ret == -1 )
> > >    {
> > >       perror("We could not be session leader\n");
> > >       exit(-1);
> > >    }
> > > 
> > >    // Set umask for safety
> > >    umask(0);
> > >    
> > >    // Set root dir
> > >    chdir("/");
> > >   
> > >  
> > >    for( i = 0; i < loops_to_run; i++ )
> > >    {
> > >       printf("We are running: %d\n", i );
> > >       sleep(1);
> > >    } 
> > > 
> > >    exit(0);
> > > 
> > > }
> > > 
> > > //----------------------------------------------------------------------
> > > // When we quit
> > > //----------------------------------------------------------------------
> > > static void quit_callback()
> > > {
> > >    gtk_main_quit ();
> > > }
> > > 
> > > 
> > > //----------------------------------------------------------------------
> > > //  main
> > > //
> > > //  Creates a gtk windows to specify how many loops
> > > //  the daemon should run.
> > > //
> > > //----------------------------------------------------------------------
> > > int 
> > > main (int argc, char **argv)
> > > {
> > > 
> > >   GtkWidget *mainwin = 0L;
> > >   GtkWidget *number_entry = 0L;
> > >   GtkWidget *run_btn = 0L;
> > >   GtkWidget *vbox = 0L;
> > > 
> > >   /* Initialize i18n support */
> > >   printf("Locale is: %s\n", gtk_set_locale () );
> > > 
> > >   /* Initialize the widget set */
> > >   gtk_init (&argc, &argv);
> > > 
> > >   /* Create the main window */
> > >   mainwin = gtk_window_new (GTK_WINDOW_TOPLEVEL);
> > > 
> > >   /* Set up our GUI elements */
> > >   vbox = gtk_vbox_new (FALSE, 0);
> > > 
> > >   number_entry = gtk_entry_new();
> > > 
> > >   run_btn = gtk_button_new_with_label("Just run");
> > > 
> > >   gtk_container_add (GTK_CONTAINER (mainwin), vbox);
> > >   gtk_box_pack_start (GTK_BOX (vbox), number_entry, TRUE, TRUE, 0);
> > >   gtk_box_pack_start (GTK_BOX (vbox), run_btn, TRUE, TRUE, 0);
> > > 
> > >   
> > >   // Function to call when main window is destroyed
> > >   g_signal_connect (G_OBJECT (mainwin),
> > > 		    "destroy",
> > > 		    GTK_SIGNAL_FUNC (quit_callback),
> > > 		    NULL);
> > > 
> > >   // Function to call when we click the button
> > >   g_signal_connect(GTK_OBJECT(run_btn), "clicked",
> > > 		     G_CALLBACK(run_btn_callback),
> > > 		     number_entry);
> > > 
> > >   /* Show the application window */
> > >   gtk_widget_show_all (mainwin);
> > > 
> > >   /* Enter the main event loop, and wait for user interaction */
> > >   gtk_main ();
> > > 
> > >   /* The user lost interest */
> > >   return 0;
> > > 
> > > }
> > > 
> > > //------------------------------------------------------------------
> > > // END
> > > //------------------------------------------------------------------
> > > 
> > > ---<snipp>---
> > > 
> > 
>