libfodbreposysconf.c

Go to the documentation of this file.

/* **************************************************************
 Copyright (C) 2011 Hewlett-Packard Development Company, L.P.
 Copyright (C) 2015, 2018 Siemens AG

 This program is free software; you can redistribute it and/or
 modify it under the terms of the GNU General Public License
 version 2 as published by the Free Software Foundation.

 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.,
 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
************************************************************** */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdarg.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>

#include <libfossscheduler.h>
#include <libfossdb.h>
#include "libfodbreposysconf.h"

#ifndef TESTDBDIR
// this is only to make IDEs happy
#define TESTDBDIR "../../../testing/db/"
#error
#endif

static char* Sysconf = NULL;
static char DBName[ARRAY_LENGTH];
static char DBConf[ARRAY_LENGTH];
static char RepoDir[ARRAY_LENGTH];
static char confFile[ARRAY_LENGTH];

fo_dbManager* createTestEnvironment(const char* srcDirs, const char* doConnectAsAgent, int initDbTables) {
  GString* gString = g_string_new(TESTDBDIR "/createTestEnvironment.php");
  if (srcDirs) {
    g_string_append_printf(gString, " -d '%s'", srcDirs);
  }
  if (initDbTables) {
    g_string_append_printf(gString, " -f");
  }
  gchar* cmd = g_string_free(gString, FALSE);

  FILE* pipe = popen(cmd, "r");

  if (!pipe) {
    printf("cannot run create test environment script: %s\n", cmd);
    goto createError;
  }

  Sysconf = calloc(1, ARRAY_LENGTH + 1);
  size_t count = fread(Sysconf, 1, ARRAY_LENGTH, pipe);

  int rv = fclose(pipe);

  if (rv != 0 || count == 0) {
    printf("command %s failed with output:\n%s\n", cmd, Sysconf);
    goto createError;
  }

  g_free(cmd);

  fo_dbManager* result = NULL;
  if (doConnectAsAgent) {
    char* argv[] = {(char*) doConnectAsAgent, "-c", Sysconf};
    int argc = 3;

    fo_scheduler_connect_dbMan(&argc, argv, &result);
  } else {
    char buffer[ARRAY_LENGTH + 1];
    snprintf(buffer, ARRAY_LENGTH, "%s/Db.conf", Sysconf);
    char* errorMsg = NULL;
    PGconn* conn = fo_dbconnect(buffer, &errorMsg);

    if (!errorMsg) {
      result = fo_dbManager_new_withConf(conn, buffer);
    } else {
      printf("error connecting: %s\n", errorMsg);
    }
  }
  return result;

createError:
  if (cmd) {
    g_free(cmd);
  }
  return NULL;
}

void dropTestEnvironment(fo_dbManager* dbManager, const char* srcDir, const char* doConnectAsAgent) {
  if (dbManager) {
    fo_dbManager_finish(dbManager);
  }
  if (doConnectAsAgent) {
    fo_scheduler_disconnect(0);
  }

  if (Sysconf) {
    char buffer[ARRAY_LENGTH];
    snprintf(buffer, ARRAY_LENGTH, TESTDBDIR "/purgeTestEnvironment.php -d '%s' -c '%s'", srcDir, Sysconf);
    FILE* pipe = popen(buffer, "r");

    if (!pipe) {
      printf("cannot run purge test environment script: %s\n", buffer);
      return;
    }

    fclose(pipe);
    free(Sysconf);
  }
}

static void command_output(char* command) {
  FILE* stream;
  char tmp[ARRAY_LENGTH];
  int i = 0;
  int status = 0;

  stream = popen(command, "r");
  if (!stream) status = 1;
  memset(tmp, '\0', sizeof(tmp));
  if (fgets(tmp, ARRAY_LENGTH, stream) != NULL) {
    while ((tmp[i] != '\n') && (tmp[i] != ' ') && (tmp[i] != EOF))
      i++;
    Sysconf = malloc(i);
    memcpy(Sysconf, tmp, i);
    Sysconf[i] = '\0';
  }
  int rc = pclose(stream);
  if (rc != 0) status = 1;
  if (status == 1) {
    printf("Failed to run %s, exit code is:%d .\n", command, rc >> 8);
    exit(1);
  }
  return;
}

int create_db_repo_sysconf(int type, char* agent_name, char* sysconfdir) {
#if 0
  char *sysconfdir;
  sysconfdir = getenv ("SYSCONFDIR");
  if (sysconfdir == NULL)
  {
    printf ("The SYSCONFDIR enviroment variable is not existed.\n");
    return 1;
  }
#endif

  const char INIT_CMD[] = "../../../testing/db/createTestDB.php";
  char *CMD, *tmp;

  CMD = (char *)malloc(strlen(INIT_CMD) + 1);
  if (!CMD)
  {
    return -1;
  }
  sprintf(CMD, "%s", INIT_CMD);

  if (sysconfdir)
  {
    tmp = (char *)malloc(strlen(CMD) + 4 + strlen(sysconfdir) + 1);
    if (!tmp)
    {
      free(CMD);
      return -1;
    }
    sprintf(tmp, "%s -c %s", CMD, sysconfdir);
    free(CMD);
    CMD = tmp;
  }

  switch(type)
  {
    case 0:
      tmp = (char *)malloc(strlen(CMD) + 4);
      if (!tmp)
      {
        free(CMD);
        return -1;
      }
      sprintf(tmp, "%s -e", CMD);
      free(CMD);
      CMD = tmp;
    case 1:
      command_output(CMD);
      break;
    default:
      break;
  }

  free(CMD);

  int argc = 3;
  char* argv[] = {agent_name, "-c", Sysconf};

  PGconn* unused;
  fo_scheduler_connect(&argc, argv, &unused);

#ifdef TEST
  printf("create_db_repo_sysconf sucessfully\n");
#endif
  return 0;
}

void drop_db_repo_sysconf(char* DBName) {
  char CMD[ARRAY_LENGTH];
  memset(CMD, '\0', sizeof(CMD));
  sprintf(CMD, "../../../testing/db/createTestDB.php -d %s", DBName);
  command_output(CMD);
#ifdef TEST
  printf("remove DBName is:%s\n", DBName);
#endif
  fo_scheduler_disconnect(0);
  free(Sysconf);
  Sysconf = NULL;
#ifdef TEST
  printf("drop_db_repo_sysconf sucessfully\n");
#endif
}

char* get_test_name() {
  char* TestName = strstr(Sysconf, "Conf") + 4;
#ifdef TEST
  printf("TestName is:%s\n", TestName);
#endif
  return TestName;
}

char* get_db_name() {
  memset(DBName, '\0', sizeof(DBName));
  char* TestName = get_test_name();
  sprintf(DBName, "fosstest%s", TestName);
#ifdef TEST
  printf("DBName is:%s\n", DBName);
#endif
  return DBName;
}

char* get_sysconfdir() {
#ifdef TEST
  printf("Sysconf is:%s\n", Sysconf);
#endif
  return Sysconf;
}

char* get_dbconf() {
  memset(DBConf, '\0', sizeof(DBConf));
  sprintf(DBConf, "%s/Db.conf", Sysconf);
  return DBConf;
}

char* get_confFile() {
  memset(confFile, '\0', sizeof(confFile));
  sprintf(confFile, "%s/fossology.conf", Sysconf);
  return confFile;
}
char* get_repodir() {
  strncpy(RepoDir, Sysconf, ARRAY_LENGTH);
  RepoDir[ARRAY_LENGTH-1] = '\0';

  char* test_name_tmp = strstr(RepoDir, "testDbConf");
  if (test_name_tmp)
  {
    *test_name_tmp = '\0';
  }

  char *tmp = malloc(strlen(RepoDir) + 1);
  if (!tmp) {
    return NULL;
  }

  sprintf(tmp, "%s", RepoDir);
  sprintf(RepoDir, "%stestDbRepo%s", tmp, get_test_name());

  free(tmp);

#ifdef TEST
  printf("RepoDir is:%s\n", RepoDir);
#endif
  return RepoDir;
}

char *createTestConfDir(char* cwd, char* agentName)
{
  struct stat st = {0};
  int rc;
  char CMD[2048];
  FILE *testConfFile;

  char *confDir = malloc((strlen(cwd) + 10) * sizeof(char));
  char confFile[1024];
  char agentDir[1024];

  if(cwd == NULL || agentName == NULL || cwd[0] == '\0' || agentName[0] == '\0')
  {
    return NULL;
  }

  sprintf(confDir, "%s/testconf", cwd);
  sprintf(confFile, "%s/fossology.conf", confDir);
  sprintf(agentDir, "%s/../..", cwd);

  if (stat(confDir, &st) == -1)
  {
    mkdir(confDir, 0775);
  }

  memset(CMD, '\0', sizeof(CMD));
  sprintf(CMD, "%s/mods-enabled/%s", confDir, agentName);
  if (stat(CMD, &st) == -1)
  {
    mkdir(CMD, 0775);
  }

  testConfFile = fopen(confFile,"w");
  fprintf(testConfFile, ";fossology.conf for testing\n");
  fprintf(testConfFile, "[FOSSOLOGY]\nport = 24693\n");
  fprintf(testConfFile, "address = localhost\n");
  fprintf(testConfFile, "depth = 0\n");
  fprintf(testConfFile, "path = %s\n", confDir);
  fprintf(testConfFile, "[HOSTS]\n");
  fprintf(testConfFile, "localhost = localhost AGENT_DIR 10\n");
  fprintf(testConfFile, "[REPOSITORY]\n");
  fprintf(testConfFile, "localhost = * 00 ff\n");
  fprintf(testConfFile, "[DIRECTORIES]\n");
  fprintf(testConfFile, "PROJECTUSER=fossy\n");
  fprintf(testConfFile, "PROJECTGROUP=fossy\n");
  fprintf(testConfFile, "MODDIR=%s/../../../..\n", cwd);
  fprintf(testConfFile, "LOGDIR=%s\n", confDir);
  fclose(testConfFile);

  memset(CMD, '\0', sizeof(CMD));
  sprintf(CMD, "install -D %s/../../../../VERSION %s/VERSION", cwd, confDir);
  rc = system(CMD);

  memset(CMD, '\0', sizeof(CMD));
  sprintf(CMD, "install -D %s/../../../../install/defconf/Db.conf %s/Db.conf", cwd, confDir);
  rc = system(CMD);

  memset(CMD, '\0', sizeof(CMD));
  sprintf(CMD, "install -D %s/VERSION %s/mods-enabled/%s/VERSION", agentDir, confDir, agentName);
  rc = system(CMD);

  memset(CMD, '\0', sizeof(CMD));
  sprintf(CMD, "ln -fs %s/agent %s/mods-enabled/%s", agentDir, confDir, agentName);
  rc = system(CMD);

  if (rc != -1)
    return confDir;
  else
    return NULL;
}

#if 0
int main()
{
  create_db_repo_sysconf(1);
  get_test_name();
  get_sysconfdir();
  get_db_name();
  drop_db_repo_sysconf(DBName);
}
#endif