LIBS = @LIBS@

LIBS = @LIBS@ @LIB_SLP@

	$(common_obj) @BUILD_POPT@

	$(common_obj) @BUILD_POPT@ @BUILD_SLP@

	src/daemon.c src/distcc.c src/dsignal.c				\

	src/daemon.c src/distcc.c src/dsignal.c src/register_slp.c	\

	@GNOME_BIN@ 

	@GNOME_BIN@ \

	@SLP_BIN@ 

-- src/cc_version.c

#

# SLP support in distcc

#

It is enough to start the SLP server and distcc server, if you have 

compiled distccd with SLP support. You can simply use distcc as compiler

afterwards.

NOTE: SLP support is only used, when distccd runs as daemon, not when

      running via inetd or xinetd !

The distcc frontend cache SLP results inside the $HOME/.distcc.slp.cache

file. This file gets update every 3 minutes (hardcoded for now).

Alternative you can set the enviroment once via distccenv. A bash user

might simply do to set $DISTCC_HOSTS with

  eval `distccenv`

A distcc service url looks like

 service:distccd.$IDENTITY

The identity is usually set based on the used compiler at build time 

of distcc and the used system architecture.

However there is no check which checks the installed compiler, since it

is not known how it is called at distccd startup time.

You can set the IDENTIY during distccd startup via the --slp-identy=$IDENTIY

switch. You need to set the $DISTCC_IDENTITY enviroment variable to the

same value afterwards inside your enviroment (or during distccenv run).

There is some very basic load balancing code. You can enable it via

  export DISTCC_LOAD_BALANCE=1

in your compile enviroment. It is not active, if $DISTCC_HOSTS is set.

Have fun, adrian.

-- src/cc_version.h

/* -*- c-file-style: "java"; indent-tabs-mode: nil -*-

 *

 * distcc -- A simple distributed compiler system

 *

 * Copyright (C) 2003 by Adrian Schroeter <adrian@suse.de>

 *

 * 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 2 of the

 * License, or (at your option) any later version.

 *

 * 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, write to the Free Software

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307

 * USA

 */

#include <stdlib.h>

#include <string.h>

#include <stdio.h>

#include <sys/utsname.h>

#include "cc_version.h"

#include "config.h"

char *used_compiler_version(void)

{

    char *compiler     = NULL;

    char *architecture = NULL;

    char *ret;

    int len;

    /* The enviroment is always right ... */

    if ( getenv("DISTCC_IDENTIFY") )

	return getenv("DISTCC_IDENTIFY"); 

    /* do we really want a runtime check here ? */

    /* it would be worse performance wise for the distcc frontend ... */

    /* default compiler based on distcc build time */

#ifdef __GNUC__

#ifdef __GNUC_MINOR__

#ifdef __GNUC_PATCHLEVEL__

    compiler = (char*) malloc( 33 );

    snprintf( compiler, 32, "gcc-%d.%d.%d", __GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__ );

#endif

#endif

#endif

#ifdef GNU_HOST

    architecture = strdup(GNU_HOST);

    {

       char *p;

       p = strstr( architecture, "-" );

       if (p){

         *p = '\0';

         /* unify all different ia32 systems */

         p = architecture;

         if ( p[0] == 'i' && p[2] == '8' && p[3] == '6' && p[4] == '\0' )

           p[1] = '3';

       }

    }

#endif

    if ( compiler == NULL ){

       /* we use the system release, this is unreleated to the compiler

          version, but better than default ... */

       struct utsname t;

       if ( !uname( &t ) )

          compiler = t.release;

    }

    if ( architecture == NULL ){

       struct utsname t;

       if ( !uname( &t ) )

          architecture = t.machine;

    }

    /* fallback values */

    if ( compiler == NULL )

       compiler = strdup("default");

    if ( architecture == NULL )

       architecture = strdup("default");

    len = strlen(compiler) + 1 + strlen(architecture) + 1;

    ret = (char*) malloc(len + 1);

    snprintf( ret, len, "%s-%s", compiler, architecture );

    return ret;

}

-- src/config.h.in

char *used_compiler_version(void);

-- src/dopt.c

#include "config.h"

#ifndef WITH_SLP

#error distccenv needs SLP atm. 

#endif

#include <stdlib.h>

#include <stdio.h>

#include <string.h>

#include "register_slp.h"

#define BUFFER 1024

char compiler[BUFFER + 1];

FILE *out;

#define MAX_HOSTS 256

struct dcc_host{

  char *url;

  int  jobs;

  float speed;

  float load;

  long value;

};

struct dcc_host hosts[MAX_HOSTS];

int host_count = 0;

int slp_calls = 0;

int load_balancing = 0;

void dump_result(void);

SLPBoolean myAttrCallback(SLPHandle phslp, char* attrlist,

                          SLPError errcode, void* cookie );

SLPBoolean MySLPSrvURLCallback( SLPHandle phslp, const char* srvurl,

                              unsigned short lifetime, SLPError errcode,

                              void* cookie );

void dump_result(void)

{

  int h, j, max_jobs = 0;

  float avg_speed = 0, avg_load = 0;

  if ( host_count == 0 )

     exit(-1);

  if ( !out )

     printf( "DISTCC_HOSTS=\"" );

  if ( load_balancing )

  {

     for ( h = 0; h<host_count; h++ ){

        avg_speed += hosts[h].speed;

        avg_load  += hosts[h].load;

     }

     avg_speed /= host_count;

     avg_load /= host_count;

     for ( h = 0; h<host_count; h++ ){

        hosts[h].value = hosts[h].jobs

                         * ( hosts[h].speed / avg_speed );

#if 0

// load might be misleading, so we only care about bogomips atm

// beside of architectures with random bogomips values (like s390) 

// this should work so far now.

                         * ( avg_load / hosts[h].load );

#endif

        if ( max_jobs < hosts[h].value )

           max_jobs = hosts[h].value;

     }

  }

  for ( j = 0; j<(load_balancing?max_jobs:1); j++ ){

     for ( h = 0; h<host_count; h++ ){

        if ( !load_balancing || j < hosts[h].value ){

           if ( out ){

              fputs( hosts[h].url, out );

              fputs( "\n", out );

           }else{

              printf( "%s ", hosts[h].url );

           }

        }

     }

  }

  if ( out )

    fclose( out );

  else

    printf( "\"\n" );

  exit(0);

}

SLPBoolean myAttrCallback(SLPHandle phslp,

                        char* attrlist,

                        SLPError errcode,

                        void* cookie )

{

    phslp = phslp;

    struct dcc_host *_host = &(hosts[(long)cookie]);

    if(attrlist && errcode == SLP_OK)

    {

	char *p;

        p = strstr( attrlist, "(maxjobs=" );

	if ( p )

	   _host->jobs  = atoi( p + strlen("(maxjobs=") );

        p = strstr( attrlist, "(bogomips=" );

	if ( p )

	   _host->speed = atol( p + strlen("(bogomips=") );

        p = strstr( attrlist, "(load=" );

	if ( p )

	   _host->load  = atol( p + strlen("(load=") );

    }

    return SLP_FALSE;

}

SLPBoolean MySLPSrvURLCallback( SLPHandle phslp,

                              const char* srvurl,

                              unsigned short lifetime,

                              SLPError errcode,

                              void* cookie )

{

  phslp = phslp; lifetime = lifetime; cookie = cookie;

  if ( host_count >= MAX_HOSTS || !srvurl

       || strncmp( compiler, srvurl, strlen(compiler) ) ) 

     return SLP_TRUE;

  if(errcode == SLP_OK || errcode == SLP_LAST_CALL) 

  {

     hosts[host_count].url   = strdup((char*)(strlen(compiler) + srvurl + 3));

     hosts[host_count].jobs  = -1;

     hosts[host_count].speed = -1;

     host_count++;

  }

  return SLP_TRUE;

}

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

{

  long h;

  SLPHandle phslp;

  SLPError result;

  char *p;

  out = 0;

  p = getenv("DISTCC_LOAD_BALANCE");

  if ( p && (!strcmp( "1", p)||!strncmp( "y", p, 1)) )

     load_balancing = 1;

  if ( argc > 2 && !strcmp(argv[1], "--file" ) )

     out = fopen( argv[2], "w" );

  snprintf( compiler, BUFFER, "service:distccd.%s", used_compiler_version() );

  result = SLPOpen( NULL, SLP_FALSE, &phslp);

  if (result != SLP_OK) {

     fprintf( stderr, "SLPOpen failed !   Aborting ... " );

     exit( -1 );

  } else {

     result = SLPFindSrvs( phslp,

                           compiler,

                           "", // TODO: Scope selector

                           "", // all services

                           MySLPSrvURLCallback,

                           0 );

     if (result != SLP_OK){

        fprintf( stderr, "unable to query for services !  Aborting .." );

        exit(-1);

     }

     if ( load_balancing )

     {

        for ( h = 0; h < host_count; h++ )

        {

           char buf[BUFFER+1];

           snprintf( buf, BUFFER, "%s://%s", compiler, hosts[h].url );

           result = SLPFindAttrs(phslp,

                                buf,

                                "",

                                "maxjobs,bogomips,load",

                                myAttrCallback,

                                (void*)h);

           if(result != SLP_OK)

           {

               printf("unable to request SLP attributes: %i\n",result);

               exit(-1);

           }

        }

     }else

        dump_result();

     SLPClose( phslp );

  }

  dump_result();

  return 0;

}

-- src/dparent.c

#ifdef WITH_SLP

extern const char *compiler_version;

#endif

#ifdef WITH_SLP    

    if ((home = getenv("HOME")) != NULL) {

        struct stat fst;

        asprintf(&path, "%s/.distcc.slp.cache", home);

        /* the refresh rate of SLP cache is hardcoded to 5 minutes for now */

        if ( stat (path, &fst) || fst.st_mtime < time (0) - 60*5 ) { 

	    unlink( path );

	    /* sure, we could implement the SLP query also via a function

               call, but we would need to wait here anyway ... */

	    execlp("distccenv", "distccenv", "--file", path, 0 );

        }

        if (access(path, R_OK) == 0) {

            ret = dcc_parse_hosts_file(path, ret_list, ret_nhosts);

            free(path);

            return ret;

        } else {

            rs_trace("not reading %s: %s", path, strerror(errno));

            free(path);

        }

    }

#endif

-- src/register_slp.h

/* -*- c-file-style: "java"; indent-tabs-mode: nil -*-

 *

 * distcc -- A simple distributed compiler system

 *

 * Copyright (C) 2003 by Adrian Schroeter <adrian@suse.de>

 *

 * 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 2 of the

 * License, or (at your option) any later version.

 *

 * 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, write to the Free Software

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307

 * USA

 */

#include "register_slp.h"

#ifdef WITH_SLP

#include <stdlib.h>

#include <string.h>

#include <signal.h>

#include <unistd.h>

#include <stdio.h>

#include <sys/utsname.h>

#include "dopt.h"

#include "trace.h"

#include "cc_version.h"

extern int dcc_max_kids;

void mySLPRegReport(SLPHandle hslp, SLPError errcode, void *cookie)

{

    hslp = hslp; cookie = cookie;

    if (errcode)

       rs_log_warning( "SLP (de)registration error" );

}

void refresh_slp(void)

{

      register_slp();

}

void register_slp(void)

{

      SLPHandle phslp;

      SLPError result;

      struct sigaction act, oact;

      /* TODO: make it a config option */

      /* hardcode it to 5 minutes now, because we use also the load

         from last 5 minutes */

      int slp_timeout = 60 * 3;

      /* do not bomb the slp server with wrong configuration */

      if ( slp_timeout < 120 )

        slp_timeout = 120 ;

      if ( slp_timeout > SLP_LIFETIME_MAXIMUM )

         slp_timeout = SLP_LIFETIME_MAXIMUM;

      result = SLPOpen( 0, SLP_FALSE, &phslp);

      if (result != SLP_OK)

         rs_log_warning( "SLPOpen failed" );

      else {

         char hostname[1024];

         char SLPServiceUrl[2048];

         char SLPattributes[2048];

         long load = -1, bogomips = 0;

         FILE *proc;

         gethostname( hostname, 1023 );

         /* Linux specific part, no idea how to do this in general */

         proc = fopen( "/proc/cpuinfo", "r" );

         if ( proc ){

           while( !feof(proc) ) {

               long b = 0;

               int ret;

               ret = fscanf( proc, "bogomips        : %ld", &b );

               if ( ret < 0 )

                  break;

               if ( ret )

                  bogomips += b;

               fseek( proc, 1L, SEEK_CUR );

           }

           fclose( proc );

         }

         proc = fopen( "/proc/loadavg", "r" );

         if ( proc ){

           fscanf( proc, "%*d.%*d %ld.%*d %*s %*s %*s", &load );

           fclose( proc );

         }

	 if ( !bogomips ) bogomips = 1;

	 load += 1;

         snprintf( SLPServiceUrl, 1023, "service:distccd.%s://%s:%i", compiler_version, hostname, arg_port );

         snprintf( SLPattributes, 1023, "(maxjobs=%d),(bogomips=%ld),(load=%ld)", dcc_max_kids, bogomips, load );

         result = SLPReg( phslp,

                          SLPServiceUrl,

                          slp_timeout,

                          0,

                          SLPattributes,

                          SLP_TRUE,

                          mySLPRegReport,

                          0 );

         if (result != SLP_OK)

            rs_log_warning( "unable to register SLP service" );

         SLPClose( phslp );

         /* sigalarm is also used in inetd mode, but we should never

            use SLP in inetd mode anyway ...                         */

         act.sa_handler = refresh_slp;

         if (0 != sigaction(SIGALRM, &act, &oact))

             rs_log_warning("Error establishing signal handler for SLP");

         alarm(slp_timeout - 15);

      }

}

#endif

-- src/setuid.c

#include "config.h"

#ifdef WITH_SLP

#include <slp.h>

void  register_slp(void);

char* used_compiler_version(void);

void refresh_slp(void);

void mySLPRegReport(SLPHandle hslp, SLPError errcode, void *cookie);

#endif