/**
* \brief clean the database
*/
int DBInsertClean()
{
memset(SQL,'\0',MAXSQL);
snprintf(SQL,MAXSQL,"BEGIN;");
result = PQexec(pgConn, SQL);
if (fo_checkPQcommand(pgConn, result, SQL, __FILE__ ,__LINE__))
{
printf("Remove pfile database information ERROR!\n");
return (-1);
}
PQclear(result);
/** delete uploadtree info */
memset(SQL,'\0',MAXSQL);
snprintf(SQL,MAXSQL,"DELETE FROM uploadtree WHERE upload_fk = %ld;", upload_pk);
result = PQexec(pgConn, SQL);
if (fo_checkPQcommand(pgConn, result, SQL, __FILE__ ,__LINE__))
{
printf("Remove pfile database information ERROR!\n");
return (-1);
}
PQclear(result);
/** delete upload info */
memset(SQL,'\0',MAXSQL);
snprintf(SQL,MAXSQL,"DELETE FROM upload WHERE upload_pk = %ld;", upload_pk);
result = PQexec(pgConn, SQL);
if (fo_checkPQcommand(pgConn, result, SQL, __FILE__ ,__LINE__))
{
printf("Remove pfile database information ERROR!\n");
return (-1);
}
PQclear(result);
/** delete pfile info */
memset(SQL,'\0',MAXSQL);
snprintf(SQL,MAXSQL,"DELETE FROM pfile WHERE pfile_pk = %ld;", pfile_pk);
result = PQexec(pgConn, SQL);
if (fo_checkPQcommand(pgConn, result, SQL, __FILE__ ,__LINE__))
{
printf("Remove pfile database information ERROR!\n");
return (-1);
}
PQclear(result);
memset(SQL,'\0',MAXSQL);
snprintf(SQL,MAXSQL,"COMMIT;");
result = PQexec(pgConn, SQL);
if (fo_checkPQcommand(pgConn, result, SQL, __FILE__ ,__LINE__))
{
printf("Perpare pfile information ERROR!\n");
return (-1);
}
PQclear(result);
if (pgConn) PQfinish(pgConn);
return 0;
}
/**
* \brief for function DBLoadMime
*/
void testDBLoadMime()
{
char SQL[MAXCMD] = {0};
PGresult *result = NULL;
char mimetype_name[] = "application/octet-stream";
/** delete the record mimetype_name is application/octet-stream in mimetype */
memset(SQL, '\0', MAXCMD);
snprintf(SQL, MAXCMD, "DELETE FROM mimetype where mimetype_name = '%s';", mimetype_name);
result = PQexec(pgConn, SQL);
if (fo_checkPQcommand(pgConn, result, SQL, __FILE__, __LINE__))
{
PQfinish(pgConn);
exit(-1);
}
PQclear(result);
memset(SQL, '\0', MAXCMD);
snprintf(SQL, MAXCMD, "INSERT INTO mimetype (mimetype_name) VALUES ('%s');", mimetype_name);
result = PQexec(pgConn, SQL);
if (fo_checkPQcommand(pgConn, result, SQL, __FILE__, __LINE__))
{
PQfinish(pgConn);
exit(-1);
}
PQclear(result);
MaxDBMime = 0;
/** exectue the tested function */
DBLoadMime();
/** select the record mimetype_name is application/octet-stream */
memset(SQL, '\0', MAXCMD);
snprintf(SQL, MAXCMD, "SELECT mimetype_name from mimetype where mimetype_name = ('%s');", mimetype_name);
result = PQexec(pgConn, SQL);
if (fo_checkPQresult(pgConn, result, SQL, __FILE__, __LINE__))
{
PQfinish(pgConn);
exit(-1);
}
int count = PQntuples(result);
PQclear(result);
CU_ASSERT_EQUAL(MaxDBMime, count);
/** delete the record mimetype_name is application/octet-stream in mimetype */
memset(SQL, '\0', MAXCMD);
snprintf(SQL, MAXCMD, "DELETE FROM mimetype where mimetype_name = '%s';", mimetype_name);
result = PQexec(pgConn, SQL);
/** reset the evn, that is clear all data in mimetype */
if (fo_checkPQcommand(pgConn, result, SQL, __FILE__, __LINE__))
{
PQfinish(pgConn);
exit(-1);
}
MaxDBMime = 0;
PQclear(result);
}
/**
* @brief fo_tableExists() tests:
* - Check for an existing table
* - Check for table that does not exist
* - Check for a non table entities (sequence, constraint, ...)
* @return void
*/
void test_fo_tableExists()
{
PGconn* pgConn;
int nonexistant_table;
int existing_table;
char* DBConfFile = dbConf;
char* ErrorBuf;
pgConn = fo_dbconnect(DBConfFile, &ErrorBuf);
CU_ASSERT_PTR_NOT_NULL(pgConn);
nonexistant_table = fo_tableExists(pgConn, "nonexistanttable");
CU_ASSERT_FALSE(nonexistant_table);
PGresult* result = PQexec(pgConn, "CREATE table exists()");
CU_ASSERT_PTR_NOT_NULL_FATAL(result);
CU_ASSERT_FALSE_FATAL(fo_checkPQcommand(pgConn, result, "create", __FILE__, __LINE__));
existing_table = fo_tableExists(pgConn, "exists");
CU_ASSERT_TRUE(existing_table);
PQfinish(pgConn);
return;
}
/**
* \brief Add a new license to license_ref table
*
* Adds a license to license_ref table.
*
* \param char $licenseName
*
* \return rf_pk for success, 0 for failure
*/
FUNCTION long add2license_ref(PGconn *pgConn, char *licenseName)
{
PGresult *result;
char query[256];
char insert[256];
char escLicName[256];
char *specialLicenseText;
long rf_pk;
int len;
int error;
int numRows;
// escape the name
len = strlen(licenseName);
PQescapeStringConn(pgConn, escLicName, licenseName, len, &error);
if (error)
printf("WARNING: %s(%d): Does license name have multibyte encoding?", __FILE__, __LINE__);
/* verify the license is not already in the table */
sprintf(query, "SELECT rf_pk FROM license_ref where rf_shortname='%s' and rf_detector_type=2", escLicName);
result = PQexec(pgConn, query);
if (fo_checkPQresult(pgConn, result, query, "add2license_ref", __LINE__)) return 0;
numRows = PQntuples(result);
if (numRows)
{
rf_pk = atol(PQgetvalue(result, 0, 0));
return rf_pk;
}
/* Insert the new license */
specialLicenseText = "License by Nomos.";
sprintf( insert,
"insert into license_ref(rf_shortname, rf_text, rf_detector_type) values('%s', '%s', 2)",
escLicName, specialLicenseText);
result = PQexec(pgConn, insert);
if (fo_checkPQcommand(pgConn, result, insert, __FILE__, __LINE__)) return 0;
PQclear(result);
/* retrieve the new rf_pk */
result = PQexec(pgConn, query);
if (fo_checkPQresult(pgConn, result, query, "add2license_ref", __LINE__)) return 0;
numRows = PQntuples(result);
if (numRows)
rf_pk = atol(PQgetvalue(result, 0, 0));
else
{
printf("ERROR: %s:%s:%d Just inserted value is missing. On: %s", __FILE__, "add2license_ref()", __LINE__, query);
return(0);
}
PQclear(result);
return (rf_pk);
}
/**
* \brief initialize
*/
int DBInsertInit()
{
char *ErrorBuf;
char *upload_filename = "argmatch.c.gz";
int upload_mode = 104;
char *upload_origin = "argmatch.c.gz";
char *tmp;
pgConn = fo_dbconnect(DBConfFile, &ErrorBuf);
if (!pgConn)
{
LOG_FATAL("Unable to connect to database");
exit(-1);
}
/** insert upload info */
memset(SQL,'\0',MAXSQL);
snprintf(SQL,MAXSQL,"INSERT INTO upload (upload_filename,upload_mode,upload_origin) VALUES ('%s', %d, '%s');",upload_filename, upload_mode, upload_origin);
result = PQexec(pgConn, SQL);
if (fo_checkPQcommand(pgConn, result, SQL, __FILE__ ,__LINE__))
{
printf("Insert upload information ERROR!\n");
return (-1);
}
PQclear(result);
/* select the upload pk */
memset(SQL,'\0',MAXSQL);
snprintf(SQL,MAXSQL,"SELECT upload_pk FROM upload WHERE upload_filename = '%s';",
upload_filename);
result = PQexec(pgConn, SQL); /* SELECT */
if (fo_checkPQresult(pgConn, result, SQL, __FILE__, __LINE__)) return(-1);
tmp = PQgetvalue(result,0,0);
if(tmp)
{
Upload_Pk = tmp;
upload_pk = atol(tmp);
}
PQclear(result);
return 0;
}
/**
* \brief simple wrapper which includes PQexec and fo_checkPQcommand
* \param desc description for the SQL command, else NULL
* \param SQL SQL command executed
* \param file source file name
* \param line source line number
* \return PQexec query result
* \see PQexec()
*/
PGresult * PQexecCheck(const char *desc, char *SQL, char *file, const int line)
{
PGresult *result;
if(desc == NULL)
{
printfInCaseOfVerbosity("# %s:%i: %s\n", file, line, SQL);
}
else
{
printfInCaseOfVerbosity("# %s:%i: %s (%s)\n", file, line, desc, SQL);
}
result = PQexec(pgConn, SQL);
if (fo_checkPQcommand(pgConn, result, SQL, file, line))
{
exitNow(-1);
}
return result;
}
/**
* \brief Prepare database
*
* \param db_conn the database connection
* \param pi the pointer of debpkginfo
*
* \return upload_pk on OK, -1 on failure
*/
long prepare_Database(PGconn *db_conn, struct debpkginfo *pi)
{
long upload_pk;
char SQL[MAXSQL];
PGresult *result;
long control_pfilepk;
memset(SQL,'\0',MAXSQL);
snprintf(SQL,MAXSQL,"BEGIN;");
result = PQexec(db_conn, SQL);
if (fo_checkPQcommand(db_conn, result, SQL, __FILE__ ,__LINE__))
{
printf("Perpare pfile information ERROR!\n");
return (-1);
}
PQclear(result);
/* insert mimetype */
memset(SQL,'\0',MAXSQL);
snprintf(SQL,MAXSQL,"INSERT INTO mimetype (mimetype_name) VALUES ('application/x-rpm');");
result = PQexec(db_conn, SQL);
if (fo_checkPQcommand(db_conn, result, SQL, __FILE__ ,__LINE__))
{
printf("Perpare mimetype information ERROR!\n");
return (-1);
}
PQclear(result);
memset(SQL,'\0',MAXSQL);
snprintf(SQL,MAXSQL,"INSERT INTO mimetype (mimetype_name) VALUES ('application/x-debian-package');");
result = PQexec(db_conn, SQL);
if (fo_checkPQcommand(db_conn, result, SQL, __FILE__ ,__LINE__))
{
printf("Perpare mimetype information ERROR!\n");
return (-1);
}
PQclear(result);
memset(SQL,'\0',MAXSQL);
snprintf(SQL,MAXSQL,"INSERT INTO mimetype (mimetype_name) VALUES ('application/x-debian-source');");
result = PQexec(db_conn, SQL);
if (fo_checkPQcommand(db_conn, result, SQL, __FILE__ ,__LINE__))
{
printf("Perpare mimetype information ERROR!\n");
return (-1);
}
PQclear(result);
/* insert pfile: fossology-web_1.4.1_all.deb */
memset(SQL,'\0',MAXSQL);
snprintf(SQL,MAXSQL,"INSERT INTO pfile (pfile_sha1,pfile_md5,pfile_size) VALUES ('%.40s','%.32s','%s');",
"AF1DF2C4B32E4115DB5F272D9EFD0E674CF2A0BC","2239AA7DAC291B6F8D0A56396B1B8530","4560");
result = PQexec(db_conn, SQL);
if (fo_checkPQcommand(db_conn, result, SQL, __FILE__ ,__LINE__))
{
printf("Perpare pfile information ERROR!\n");
return (-1);
}
PQclear(result);
/* insert pfile: control */
memset(SQL,'\0',MAXSQL);
snprintf(SQL,MAXSQL,"INSERT INTO pfile (pfile_sha1,pfile_md5,pfile_size) VALUES ('%.40s','%.32s','%s');",
"F1D2319DF20ABC4CEB02CA5A3C2021BD87B26810","87972FC55E2CDD2609ED85051BE50BAF","722");
result = PQexec(db_conn, SQL);
if (fo_checkPQcommand(db_conn, result, SQL, __FILE__ ,__LINE__))
{
printf("Perpare pfile information ERROR!\n");
return (-1);
}
PQclear(result);
/* select pfile_pk: fossology-web_1.4.1_all.deb */
memset(SQL,'\0',MAXSQL);
snprintf(SQL,MAXSQL,"SELECT pfile_pk FROM pfile WHERE pfile_sha1 = '%.40s' AND pfile_md5 = '%.32s' AND pfile_size = '%s';",
"AF1DF2C4B32E4115DB5F272D9EFD0E674CF2A0BC","2239AA7DAC291B6F8D0A56396B1B8530","4560");
result = PQexec(db_conn, SQL);
if (fo_checkPQresult(db_conn, result, SQL, __FILE__, __LINE__))
{
printf("Get pfile information ERROR!\n");
return (-1);
}
pi->pFileFk = atoi(PQgetvalue(result, 0, 0));
PQclear(result);
/* select pfile_pk: control */
memset(SQL,'\0',MAXSQL);
snprintf(SQL,MAXSQL,"SELECT pfile_pk FROM pfile WHERE pfile_sha1 = '%.40s' AND pfile_md5 = '%.32s' AND pfile_size = '%s';",
"F1D2319DF20ABC4CEB02CA5A3C2021BD87B26810","87972FC55E2CDD2609ED85051BE50BAF","722");
result = PQexec(db_conn, SQL);
if (fo_checkPQresult(db_conn, result, SQL, __FILE__, __LINE__))
{
printf("Get pfile information ERROR!\n");
return (-1);
}
control_pfilepk = atoi(PQgetvalue(result, 0, 0));
PQclear(result);
/* insert upload: fossology-web_1.4.1_all.deb */
memset(SQL,'\0',MAXSQL);
snprintf(SQL,MAXSQL,"INSERT INTO upload (upload_filename,upload_mode,upload_ts,pfile_fk) VALUES ('%s',40,now(),%ld);",
"fossology-web_1.4.1_all.deb", pi->pFileFk);
result = PQexec(db_conn, SQL);
if (fo_checkPQcommand(db_conn, result, SQL, __FILE__ ,__LINE__))
{
printf("Perpare pfile information ERROR!\n");
exit(-1);
}
PQclear(result);
memset(SQL,'\0',MAXSQL);
snprintf(SQL,MAXSQL,"SELECT upload_pk FROM upload WHERE pfile_fk = '%ld';",
pi->pFileFk);
result = PQexec(db_conn, SQL);
if (fo_checkPQresult(db_conn, result, SQL, __FILE__, __LINE__))
{
printf("Get pfile information ERROR!\n");
return (-1);
}
upload_pk = atoi(PQgetvalue(result, 0, 0));
PQclear(result);
/* insert uploadtree: fossology-web_1.4.1_all.deb */
memset(SQL,'\0',MAXSQL);
snprintf(SQL,MAXSQL,"INSERT INTO uploadtree (upload_fk,pfile_fk,lft,rgt,ufile_name) VALUES (%ld,%ld,1,48,'fossology-web_1.4.1_all.deb');",
upload_pk, pi->pFileFk);
result = PQexec(db_conn, SQL);
if (fo_checkPQcommand(db_conn, result, SQL, __FILE__ ,__LINE__))
{
printf("Perpare pfile information ERROR!\n");
return (-1);
}
PQclear(result);
/* insert uploadtree: control */
memset(SQL,'\0',MAXSQL);
snprintf(SQL,MAXSQL,"INSERT INTO uploadtree (upload_fk,pfile_fk,lft,rgt,ufile_name) VALUES (%ld,%ld,9,10,'control');",
upload_pk, control_pfilepk);
result = PQexec(db_conn, SQL);
if (fo_checkPQcommand(db_conn, result, SQL, __FILE__ ,__LINE__))
{
printf("Perpare pfile information ERROR!\n");
return (-1);
}
PQclear(result);
memset(SQL,'\0',MAXSQL);
snprintf(SQL,MAXSQL,"COMMIT;");
result = PQexec(db_conn, SQL);
if (fo_checkPQcommand(db_conn, result, SQL, __FILE__ ,__LINE__))
{
printf("Perpare pfile information ERROR!\n");
return (-1);
}
PQclear(result);
return upload_pk;
}
/**
* \brief remove database
*
* \param db_conn the database connection
* \param pi the pointer of debpkginfo
* \param upload_pk
*
* \return 0 on OK, -1 on failure
*/
int remove_Database(PGconn *db_conn, struct debpkginfo *pi, long upload_pk)
{
char SQL[MAXSQL];
PGresult *result;
memset(SQL,'\0',MAXSQL);
snprintf(SQL,MAXSQL,"BEGIN;");
result = PQexec(db_conn, SQL);
if (fo_checkPQcommand(db_conn, result, SQL, __FILE__ ,__LINE__))
{
printf("Remove pfile database information ERROR!\n");
return (-1);
}
PQclear(result);
memset(SQL,'\0',MAXSQL);
snprintf(SQL,MAXSQL,"DELETE FROM mimetype;");
result = PQexec(db_conn, SQL);
if (fo_checkPQcommand(db_conn, result, SQL, __FILE__ ,__LINE__))
{
printf("Remove mimetype information ERROR!\n");
return (-1);
}
PQclear(result);
memset(SQL,'\0',MAXSQL);
snprintf(SQL,MAXSQL,"DELETE FROM uploadtree WHERE upload_fk = %ld;", upload_pk);
result = PQexec(db_conn, SQL);
if (fo_checkPQcommand(db_conn, result, SQL, __FILE__ ,__LINE__))
{
printf("Remove pfile database information ERROR!\n");
return (-1);
}
PQclear(result);
memset(SQL,'\0',MAXSQL);
snprintf(SQL,MAXSQL,"DELETE FROM upload WHERE upload_pk = %ld;", upload_pk);
result = PQexec(db_conn, SQL);
if (fo_checkPQcommand(db_conn, result, SQL, __FILE__ ,__LINE__))
{
printf("Remove pfile database information ERROR!\n");
return (-1);
}
PQclear(result);
memset(SQL,'\0',MAXSQL);
snprintf(SQL,MAXSQL,"DELETE FROM pfile WHERE pfile_pk = %ld;", pi->pFileFk);
result = PQexec(db_conn, SQL);
if (fo_checkPQcommand(db_conn, result, SQL, __FILE__ ,__LINE__))
{
printf("Remove pfile database information ERROR!\n");
return (-1);
}
PQclear(result);
memset(SQL,'\0',MAXSQL);
snprintf(SQL,MAXSQL,"DELETE FROM pfile WHERE pfile_sha1 = '%.40s' AND pfile_md5 = '%.32s' AND pfile_size = '%s';", "F1D2319DF20ABC4CEB02CA5A3C2021BD87B26810","87972FC55E2CDD2609ED85051BE50BAF","722");
result = PQexec(db_conn, SQL);
if (fo_checkPQcommand(db_conn, result, SQL, __FILE__ ,__LINE__))
{
printf("Remove pfile database 'control' ERROR!\n");
return (-1);
}
PQclear(result);
memset(SQL,'\0',MAXSQL);
snprintf(SQL,MAXSQL,"COMMIT;");
result = PQexec(db_conn, SQL);
if (fo_checkPQcommand(db_conn, result, SQL, __FILE__ ,__LINE__))
{
printf("Perpare pfile information ERROR!\n");
return (-1);
}
PQclear(result);
return (0);
}
int main(int argc, char **argv)
{
char *agentDesc = "Bucket agent";
int cmdopt;
int verbose = 0;
int ReadFromStdin = 1;
int head_uploadtree_pk = 0;
PGconn *pgConn;
PGresult *topresult;
PGresult *result;
char sqlbuf[512];
char *Delims = ",= \t\n\r";
char *token, *saveptr;
int agent_pk = 0;
int nomos_agent_pk = 0;
int bucketpool_pk = 0;
int ars_pk = 0;
int readnum = 0;
int rv;
int hasPrules;
int user_pk = 0;
char *bucketpool_name;
char *COMMIT_HASH;
char *VERSION;
char *uploadtree_tablename;
char agent_rev[myBUFSIZ];
int rerun = 0;
// int *bucketList;
pbucketdef_t bucketDefArray = 0;
pbucketdef_t tmpbucketDefArray = 0;
cacheroot_t cacheroot;
uploadtree_t uploadtree;
uploadtree.upload_fk = 0;
/* connect to the scheduler */
fo_scheduler_connect(&argc, argv, &pgConn);
user_pk = fo_scheduler_userID(); /* get user_pk for user who queued the agent */
/* command line options */
while ((cmdopt = getopt(argc, argv, "rin:p:t:u:vc:hV")) != -1)
{
switch (cmdopt)
{
case 'i': /* "Initialize" */
PQfinish(pgConn);
exit(0);
case 'n': /* bucketpool_name */
ReadFromStdin = 0;
bucketpool_name = optarg;
/* find the highest rev active bucketpool_pk */
if (!bucketpool_pk)
{
bucketpool_pk = getBucketpool_pk(pgConn, bucketpool_name);
if (!bucketpool_pk)
printf("%s is not an active bucketpool name.\n", bucketpool_name);
}
break;
case 'p': /* bucketpool_pk */
ReadFromStdin = 0;
bucketpool_pk = atoi(optarg);
/* validate bucketpool_pk */
sprintf(sqlbuf, "select bucketpool_pk from bucketpool where bucketpool_pk=%d and active='Y'", bucketpool_pk);
bucketpool_pk = validate_pk(pgConn, sqlbuf);
if (!bucketpool_pk)
printf("%d is not an active bucketpool_pk.\n", atoi(optarg));
break;
case 't': /* uploadtree_pk */
ReadFromStdin = 0;
if (uploadtree.upload_fk) break;
head_uploadtree_pk = atoi(optarg);
/* validate bucketpool_pk */
sprintf(sqlbuf, "select uploadtree_pk from uploadtree where uploadtree_pk=%d", head_uploadtree_pk);
head_uploadtree_pk = validate_pk(pgConn, sqlbuf);
if (!head_uploadtree_pk)
printf("%d is not an active uploadtree_pk.\n", atoi(optarg));
break;
case 'u': /* upload_pk */
ReadFromStdin = 0;
if (!head_uploadtree_pk)
{
uploadtree.upload_fk = atoi(optarg);
/* validate upload_pk and get uploadtree_pk */
sprintf(sqlbuf, "select upload_pk from upload where upload_pk=%d", uploadtree.upload_fk);
uploadtree.upload_fk = validate_pk(pgConn, sqlbuf);
if (!uploadtree.upload_fk)
printf("%d is not an valid upload_pk.\n", atoi(optarg));
else
{
sprintf(sqlbuf, "select uploadtree_pk from uploadtree where upload_fk=%d and parent is null", uploadtree.upload_fk);
head_uploadtree_pk = validate_pk(pgConn, sqlbuf);
}
}
break;
case 'v': /* verbose output for debugging */
verbose++;
break;
case 'c': break; /* handled by fo_scheduler_connect() */
case 'r':
rerun = 1; /** rerun bucket */
break;
case 'V': /* print version info */
printf("%s", BuildVersion);
PQfinish(pgConn);
exit(0);
default:
Usage(argv[0]);
PQfinish(pgConn);
exit(-1);
}
}
debug = verbose;
/*** validate command line ***/
if (!bucketpool_pk && !ReadFromStdin)
{
printf("FATAL: You must specify an active bucketpool.\n");
Usage(argv[0]);
exit(-1);
}
if (!head_uploadtree_pk && !ReadFromStdin)
{
printf("FATAL: You must specify a valid uploadtree_pk or upload_pk.\n");
Usage(argv[0]);
exit(-1);
}
/* get agent pk
* Note, if GetAgentKey fails, this process will exit.
*/
COMMIT_HASH = fo_sysconfig("buckets", "COMMIT_HASH");
VERSION = fo_sysconfig("buckets", "VERSION");
sprintf(agent_rev, "%s.%s", VERSION, COMMIT_HASH);
agent_pk = fo_GetAgentKey(pgConn, basename(argv[0]), uploadtree.upload_fk, agent_rev, agentDesc);
/*** Initialize the license_ref table cache ***/
/* Build the license ref cache to hold 2**11 (2048) licenses.
This MUST be a power of 2.
*/
cacheroot.maxnodes = 2<<11;
cacheroot.nodes = calloc(cacheroot.maxnodes, sizeof(cachenode_t));
if (!lrcache_init(pgConn, &cacheroot))
{
printf("FATAL: Bucket agent could not allocate license_ref table cache.\n");
exit(1);
}
/* main processing loop */
while(++readnum)
{
uploadtree.upload_fk = 0;
if (ReadFromStdin)
{
bucketpool_pk = 0;
/* Read the bucketpool_pk and upload_pk from stdin.
* Format looks like 'bppk=123, upk=987'
*/
if (!fo_scheduler_next()) break;
token = strtok_r(fo_scheduler_current(), Delims, &saveptr);
while (token && (!uploadtree.upload_fk || !bucketpool_pk))
{
if (strcmp(token, "bppk") == 0)
{
bucketpool_pk = atoi(strtok_r(NULL, Delims, &saveptr));
}
else
if (strcmp(token, "upk") == 0)
{
uploadtree.upload_fk = atoi(strtok_r(NULL, Delims, &saveptr));
}
token = strtok_r(NULL, Delims, &saveptr);
}
/* Check Permissions */
if (GetUploadPerm(pgConn, uploadtree.upload_fk, user_pk) < PERM_WRITE)
{
LOG_ERROR("You have no update permissions on upload %d", uploadtree.upload_fk);
continue;
}
/* From the upload_pk, get the head of the uploadtree, pfile_pk and ufile_name */
sprintf(sqlbuf, "select uploadtree_pk, pfile_fk, ufile_name, ufile_mode,lft,rgt from uploadtree \
where upload_fk='%d' and parent is null limit 1", uploadtree.upload_fk);
topresult = PQexec(pgConn, sqlbuf);
if (fo_checkPQresult(pgConn, topresult, sqlbuf, agentDesc, __LINE__)) return -1;
if (PQntuples(topresult) == 0)
{
printf("ERROR: %s.%s missing upload_pk %d.\nsql: %s",
__FILE__, agentDesc, uploadtree.upload_fk, sqlbuf);
PQclear(topresult);
continue;
}
head_uploadtree_pk = atol(PQgetvalue(topresult, 0, 0));
uploadtree.uploadtree_pk = head_uploadtree_pk;
uploadtree.upload_fk = uploadtree.upload_fk;
uploadtree.pfile_fk = atol(PQgetvalue(topresult, 0, 1));
uploadtree.ufile_name = strdup(PQgetvalue(topresult, 0, 2));
uploadtree.ufile_mode = atoi(PQgetvalue(topresult, 0, 3));
uploadtree.lft = atoi(PQgetvalue(topresult, 0, 4));
uploadtree.rgt = atoi(PQgetvalue(topresult, 0, 5));
PQclear(topresult);
} /* end ReadFromStdin */
else
{
/* Only one input to process if from command line, so terminate if it's been done */
if (readnum > 1) break;
/* not reading from stdin
* Get the pfile, and ufile_name for head_uploadtree_pk
*/
sprintf(sqlbuf, "select pfile_fk, ufile_name, ufile_mode,lft,rgt, upload_fk from uploadtree where uploadtree_pk=%d", head_uploadtree_pk);
topresult = PQexec(pgConn, sqlbuf);
if (fo_checkPQresult(pgConn, topresult, sqlbuf, agentDesc, __LINE__))
{
free(uploadtree.ufile_name);
return -1;
}
if (PQntuples(topresult) == 0)
{
printf("FATAL: %s.%s missing root uploadtree_pk %d\n",
__FILE__, agentDesc, head_uploadtree_pk);
PQclear(topresult);
continue;
}
uploadtree.uploadtree_pk = head_uploadtree_pk;
uploadtree.pfile_fk = atol(PQgetvalue(topresult, 0, 0));
uploadtree.ufile_name = strdup(PQgetvalue(topresult, 0, 1));
uploadtree.ufile_mode = atoi(PQgetvalue(topresult, 0, 2));
uploadtree.lft = atoi(PQgetvalue(topresult, 0, 3));
uploadtree.rgt = atoi(PQgetvalue(topresult, 0, 4));
uploadtree.upload_fk = atoi(PQgetvalue(topresult, 0, 5));
PQclear(topresult);
}
/* Find the most recent nomos data for this upload. That's what we want to use
to process the buckets.
*/
nomos_agent_pk = LatestNomosAgent(pgConn, uploadtree.upload_fk);
if (nomos_agent_pk == 0)
{
printf("WARNING: Bucket agent called on treeitem (%d), but the latest nomos agent hasn't created any license data for this tree.\n",
head_uploadtree_pk);
continue;
}
/* at this point we know:
* bucketpool_pk, bucket agent_pk, nomos agent_pk, upload_pk,
* pfile_pk, and head_uploadtree_pk (the uploadtree_pk of the head tree to scan)
*/
/* Has the upload already been processed? If so, we are done.
Don't even bother to create a bucket_ars entry.
*/
switch (UploadProcessed(pgConn, agent_pk, nomos_agent_pk, uploadtree.pfile_fk, head_uploadtree_pk, uploadtree.upload_fk, bucketpool_pk))
{
case 1: /* upload has already been processed */
if (1 == rerun) break;
printf("LOG: Duplicate request for bucket agent to process upload_pk: %d, uploadtree_pk: %d, bucketpool_pk: %d, bucket agent_pk: %d, nomos agent_pk: %d, pfile_pk: %d ignored.\n",
uploadtree.upload_fk, head_uploadtree_pk, bucketpool_pk, agent_pk, nomos_agent_pk, uploadtree.pfile_fk);
continue;
case -1: /* SQL error, UploadProcessed() wrote error message */
continue;
case 0: /* upload has not been processed */
break;
}
/*** Initialize the Bucket Definition List bucketDefArray ***/
bucketDefArray = initBuckets(pgConn, bucketpool_pk, &cacheroot);
if (bucketDefArray == 0)
{
printf("FATAL: %s.%d Bucket definition for pool %d could not be initialized.\n",
__FILE__, __LINE__, bucketpool_pk);
exit(-2);
}
bucketDefArray->nomos_agent_pk = nomos_agent_pk;
bucketDefArray->bucket_agent_pk = agent_pk;
/* Find the correct uploadtree table name */
uploadtree_tablename = GetUploadtreeTableName(pgConn, uploadtree.upload_fk);
if (!(uploadtree_tablename))
{
LOG_FATAL("buckets passed invalid upload, upload_pk = %d", uploadtree.upload_fk);
return(-110);
}
/* set uploadtree_tablename in all the bucket definition structs */
for (tmpbucketDefArray = bucketDefArray; tmpbucketDefArray->bucket_pk; tmpbucketDefArray++)
{
tmpbucketDefArray->uploadtree_tablename = uploadtree_tablename;
}
/* loop through rules (bucket defs) to see if there are any package only rules */
hasPrules = 0;
for (tmpbucketDefArray = bucketDefArray; tmpbucketDefArray->bucket_pk; tmpbucketDefArray++)
if (tmpbucketDefArray->applies_to == 'p')
{
hasPrules = 1;
break;
}
/*** END initializing bucketDefArray ***/
/*** Initialize DEB_SOURCE and DEB_BINARY ***/
sprintf(sqlbuf, "select mimetype_pk from mimetype where mimetype_name='application/x-debian-package'");
result = PQexec(pgConn, sqlbuf);
if (fo_checkPQresult(pgConn, result, sqlbuf, __FILE__, __LINE__)) return -1;
if (PQntuples(result) == 0)
{
printf("FATAL: (%s.%d) Missing application/x-debian-package mimetype.\n",__FILE__,__LINE__);
return -1;
}
DEB_BINARY = atoi(PQgetvalue(result, 0, 0));
PQclear(result);
sprintf(sqlbuf, "select mimetype_pk from mimetype where mimetype_name='application/x-debian-source'");
result = PQexec(pgConn, sqlbuf);
if (fo_checkPQresult(pgConn, result, sqlbuf, __FILE__, __LINE__)) return -1;
if (PQntuples(result) == 0)
{
printf("FATAL: (%s.%d) Missing application/x-debian-source mimetype.\n",__FILE__,__LINE__);
return -1;
}
DEB_SOURCE = atoi(PQgetvalue(result, 0, 0));
PQclear(result);
/*** END Initialize DEB_SOURCE and DEB_BINARY ***/
/*** Record analysis start in bucket_ars, the bucket audit trail. ***/
if (0 == rerun) { // do not have any bucket scan on this upload
snprintf(sqlbuf, sizeof(sqlbuf),
"insert into bucket_ars (agent_fk, upload_fk, ars_success, nomosagent_fk, bucketpool_fk) values(%d,%d,'%s',%d,%d)",
agent_pk, uploadtree.upload_fk, "false", nomos_agent_pk, bucketpool_pk);
if (debug)
printf("%s(%d): %s\n", __FILE__, __LINE__, sqlbuf);
result = PQexec(pgConn, sqlbuf);
if (fo_checkPQcommand(pgConn, result, sqlbuf, __FILE__ ,__LINE__)) return -1;
PQclear(result);
/* retrieve the ars_pk of the newly inserted record */
sprintf(sqlbuf, "select ars_pk from bucket_ars where agent_fk='%d' and upload_fk='%d' and ars_success='%s' and nomosagent_fk='%d' \
and bucketpool_fk='%d' and ars_endtime is null \
order by ars_starttime desc limit 1",
agent_pk, uploadtree.upload_fk, "false", nomos_agent_pk, bucketpool_pk);
result = PQexec(pgConn, sqlbuf);
if (fo_checkPQresult(pgConn, result, sqlbuf, __FILE__, __LINE__)) return -1;
if (PQntuples(result) == 0)
{
printf("FATAL: (%s.%d) Missing bucket_ars record.\n%s\n",__FILE__,__LINE__,sqlbuf);
return -1;
}
ars_pk = atol(PQgetvalue(result, 0, 0));
PQclear(result);
}
/*** END bucket_ars insert ***/
if (debug) printf("%s sql: %s\n",__FILE__, sqlbuf);
/* process the tree for buckets
Do this as a single transaction, therefore this agent must be
run as a single thread. This will prevent the scheduler from
consuming excess time (this is a fast agent), and allow this
process to update bucket_ars.
*/
rv = walkTree(pgConn, bucketDefArray, agent_pk, head_uploadtree_pk, 0,
hasPrules);
/* if no errors and top level is a container, process the container */
if ((!rv) && (IsContainer(uploadtree.ufile_mode)))
{
rv = processFile(pgConn, bucketDefArray, &uploadtree, agent_pk, hasPrules);
}
/* Record analysis end in bucket_ars, the bucket audit trail. */
if (0 == rerun && ars_pk)
{
if (rv)
snprintf(sqlbuf, sizeof(sqlbuf),
"update bucket_ars set ars_endtime=now(), ars_success=false where ars_pk='%d'",
ars_pk);
else
snprintf(sqlbuf, sizeof(sqlbuf),
"update bucket_ars set ars_endtime=now(), ars_success=true where ars_pk='%d'",
ars_pk);
if (debug)
printf("%s(%d): %s\n", __FILE__, __LINE__, sqlbuf);
result = PQexec(pgConn, sqlbuf);
if (fo_checkPQcommand(pgConn, result, sqlbuf, __FILE__ ,__LINE__)) return -1;
PQclear(result);
}
} /* end of main processing loop */
/**
* \brief Test pkgagent.c function RecordMetadataDEB()
* \test
* -# Create a test upload in pfile table
* -# Create debpkginfo object and populate it
* -# Call RecordMetadataDEB()
* -# Check if meta data got inserted in DB
*/
void test_RecordMetadataDEB()
{
struct debpkginfo *pi;
int data_size, i, j;
char SQL[MAXSQL];
PGresult *result;
char Fuid[1024];
//char *DBConfFile = NULL; /* use default Db.conf */
char *ErrorBuf;
for(i=0; i<20; i++) { sprintf(Fuid+0+i*2,"%02X",'s'); }
Fuid[40]='.';
for(i=0; i<16; i++) { sprintf(Fuid+41+i*2,"%02X",'m'); }
Fuid[73]='.';
snprintf(Fuid+74,sizeof(Fuid)-74,"%Lu",(long long unsigned int)100);
pi = (struct debpkginfo *)malloc(sizeof(struct debpkginfo));
memset(pi, 0, sizeof(struct debpkginfo));
int predictValue = 0;
/* perpare testing data in database */
db_conn = fo_dbconnect(DBConfFile, &ErrorBuf);
snprintf(SQL,MAXSQL,"INSERT INTO pfile (pfile_sha1,pfile_md5,pfile_size) VALUES ('%.40s','%.32s','%s');",
Fuid,Fuid+41,Fuid+74);
result = PQexec(db_conn, SQL);
if (fo_checkPQcommand(db_conn, result, SQL, __FILE__ ,__LINE__))
{
printf("Perpare pfile information ERROR!\n");
free(pi);
exit(-1);
}
PQclear(result);
memset(SQL,'\0',MAXSQL);
snprintf(SQL,MAXSQL,"SELECT pfile_pk FROM pfile WHERE pfile_sha1 = '%.40s' AND pfile_md5 = '%.32s' AND pfile_size = '%s';",
Fuid,Fuid+41,Fuid+74);
result = PQexec(db_conn, SQL);
if (fo_checkPQresult(db_conn, result, SQL, __FILE__, __LINE__))
{
printf("Get pfile information ERROR!\n");
exit(-1);
}
pi->pFileFk = atoi(PQgetvalue(result, 0, 0));
PQclear(result);
strncpy(pi->pkgName, "Test Pkg", sizeof(pi->pkgName));
strncpy(pi->pkgArch, "Test Arch", sizeof(pi->pkgArch));
strncpy(pi->version, "Test version", sizeof(pi->version));
strncpy(pi->maintainer, "Test maintainer", sizeof(pi->maintainer));
strncpy(pi->description, "Test description", sizeof(pi->description));
strncpy(pi->section, "Test section", sizeof(pi->section));
strncpy(pi->priority, "Test priority", sizeof(pi->priority));
strncpy(pi->homepage, "Test homepage", sizeof(pi->homepage));
strncpy(pi->source, "Test source", sizeof(pi->source));
strncpy(pi->summary, "Test summary", sizeof(pi->summary));
strncpy(pi->format, "Test format", sizeof(pi->format));
strncpy(pi->uploaders, "Test uploaders", sizeof(pi->uploaders));
strncpy(pi->standardsVersion, "Test standard", sizeof(pi->standardsVersion));
pi->installedSize = 0;
data_size = 2;
pi->depends = calloc(data_size, sizeof(char *));
for (j=0; j<data_size;j++){
pi->depends[j] = malloc(MAXCMD);
strcpy(pi->depends[j],"Test depends");
}
pi->dep_size = data_size;
/* Test RecordMetadataRPM function */
int Result = RecordMetadataDEB(pi);
printf("RecordMetadataDEB Result is:%d\n", Result);
/* Check data correction */
memset(SQL,'\0',MAXSQL);
snprintf(SQL,MAXSQL,"SELECT pkg_pk, pkg_name, pkg_arch, version, maintainer, description FROM pkg_deb INNER JOIN pfile ON pfile_fk = '%ld' AND pfile_fk = pfile_pk;", pi->pFileFk);
result = PQexec(db_conn, SQL);
if (fo_checkPQresult(db_conn, result, SQL, __FILE__, __LINE__))
{
printf("Get pkg information ERROR!\n");
PQclear(result);
free(pi);
exit(-1);
}
CU_ASSERT_STRING_EQUAL(PQgetvalue(result, 0, 1), "Test Pkg");
CU_ASSERT_STRING_EQUAL(PQgetvalue(result, 0, 2), "Test Arch");
CU_ASSERT_STRING_EQUAL(PQgetvalue(result, 0, 3), "Test version");
CU_ASSERT_STRING_EQUAL(PQgetvalue(result, 0, 4), "Test maintainer");
CU_ASSERT_STRING_EQUAL(PQgetvalue(result, 0, 5), "Test description");
PQclear(result);
/* Clear testing data in database */
memset(SQL,'\0',MAXSQL);
snprintf(SQL,MAXSQL,"DELETE FROM pkg_deb_req WHERE pkg_fk IN (SELECT pkg_pk FROM pkg_deb WHERE pfile_fk = '%ld');", pi->pFileFk);
result = PQexec(db_conn, SQL);
if (fo_checkPQcommand(db_conn, result, SQL, __FILE__ ,__LINE__))
{
printf("Clear pkg_deb_req test data ERROR!\n");
PQclear(result);
free(pi);
exit(-1);
}
PQclear(result);
memset(SQL,'\0',MAXSQL);
snprintf(SQL,MAXSQL,"DELETE FROM pkg_deb WHERE pfile_fk = '%ld';", pi->pFileFk);
result = PQexec(db_conn, SQL);
if (fo_checkPQcommand(db_conn, result, SQL, __FILE__ ,__LINE__))
{
printf("Clear pkg_deb test data ERROR!\n");
PQclear(result);
free(pi);
exit(-1);
}
PQclear(result);
memset(SQL,'\0',MAXSQL);
snprintf(SQL,MAXSQL,"DELETE FROM pfile WHERE pfile_pk = '%ld'", pi->pFileFk);
result = PQexec(db_conn, SQL);
if (fo_checkPQcommand(db_conn, result, SQL, __FILE__ ,__LINE__))
{
printf("Clear pfile test data ERROR!\n");
PQclear(result);
free(pi);
exit(-1);
}
PQclear(result);
PQfinish(db_conn);
int k;
for(k=0; k< pi->dep_size;k++)
free(pi->depends[k]);
free(pi->depends);
memset(pi,0,sizeof(struct debpkginfo));
free(pi);
CU_ASSERT_EQUAL(Result, predictValue);
}
int main(int argc, char *argv[])
{
int Pid;
int c;
int rvExist1=0, rvExist2=0;
PGresult *result;
char *NewDir=".";
char *AgentName = "ununpack";
char *AgentARSName = "ununpack_ars";
char *agent_desc = "Unpacks archives (iso, tar, etc)";
int Recurse=0;
int ars_pk = 0;
int user_pk = 0;
long Pfile_size = 0;
char *ListOutName=NULL;
char *Fname = NULL;
char *FnameCheck = NULL;
char *COMMIT_HASH;
char *VERSION;
char agent_rev[PATH_MAX];
struct stat Stat;
/* connect to the scheduler */
fo_scheduler_connect(&argc, argv, &pgConn);
while((c = getopt(argc,argv,"ACc:d:FfHhL:m:PQiqRr:T:t:U:VvXx")) != -1)
{
switch(c)
{
case 'A': SetContainerArtifact=0; break;
case 'C': ForceContinue=1; break;
case 'c': break; /* handled by fo_scheduler_connect() */
case 'd':
/* if there is a %U in the path, substitute a unique ID */
NewDir=PathCheck(optarg);
break;
case 'F': UseRepository=1; break;
case 'f': ForceDuplicate=1; break;
case 'L': ListOutName=optarg; break;
case 'm':
MaxThread = atoi(optarg);
if (MaxThread < 1) MaxThread=1;
break;
case 'P': PruneFiles=1; break;
case 'R': Recurse=-1; break;
case 'r': Recurse=atoi(optarg); break;
case 'i':
if (!IsExe("dpkg-source",Quiet))
LOG_WARNING("dpkg-source is not available on this system. This means that debian source packages will NOT be unpacked.");
SafeExit(0);
break; /* never reached */
case 'Q':
UseRepository=1;
user_pk = fo_scheduler_userID(); /* get user_pk for user who queued the agent */
/* Get the upload_pk from the scheduler */
if((Upload_Pk = fo_scheduler_next()) == NULL) SafeExit(0);
break;
case 'q': Quiet=1; break;
case 'T':
memset(REP_GOLD,0,sizeof(REP_GOLD));
strncpy(REP_GOLD,optarg,sizeof(REP_GOLD)-1);
break;
case 't':
memset(REP_FILES,0,sizeof(REP_FILES));
strncpy(REP_FILES,optarg,sizeof(REP_FILES)-1);
break;
case 'U':
UseRepository = 1;
Recurse = -1;
Upload_Pk = optarg;
break;
case 'V': printf("%s", BuildVersion);SafeExit(0);
case 'v': Verbose++; break;
case 'X': UnlinkSource=1; break;
case 'x': UnlinkAll=1; break;
default:
Usage(argv[0], BuildVersion);
SafeExit(25);
}
}
/* Open DB and Initialize CMD table */
if (UseRepository)
{
/* Check Permissions */
if (GetUploadPerm(pgConn, atoi(Upload_Pk), user_pk) < PERM_WRITE)
{
LOG_ERROR("You have no update permissions on upload %s", Upload_Pk);
SafeExit(100);
}
COMMIT_HASH = fo_sysconfig(AgentName, "COMMIT_HASH");
VERSION = fo_sysconfig(AgentName, "VERSION");
sprintf(agent_rev, "%s.%s", VERSION, COMMIT_HASH);
/* Get the unpack agent key */
agent_pk = fo_GetAgentKey(pgConn, AgentName, atoi(Upload_Pk), agent_rev,agent_desc);
InitCmd();
/* Make sure ars table exists */
if (!fo_CreateARSTable(pgConn, AgentARSName)) SafeExit(0);
/* Has this user previously unpacked this upload_pk successfully?
* In this case we are done. No new ars record is needed since no
* processing is initiated.
* The unpack version is ignored.
*/
snprintf(SQL,MAXSQL,
"SELECT ars_pk from %s where upload_fk='%s' and ars_success=TRUE",
AgentARSName, Upload_Pk);
result = PQexec(pgConn, SQL);
if (fo_checkPQresult(pgConn, result, SQL, __FILE__, __LINE__)) SafeExit(101);
if (PQntuples(result) > 0) /* if there is a value */
{
PQclear(result);
LOG_WARNING("Upload_pk %s, has already been unpacked. No further action required",
Upload_Pk)
SafeExit(0);
}
PQclear(result);
/* write the unpack_ars start record */
ars_pk = fo_WriteARS(pgConn, ars_pk, atoi(Upload_Pk), agent_pk, AgentARSName, 0, 0);
/* Get Pfile path and Pfile_Pk, from Upload_Pk */
snprintf(SQL,MAXSQL,
"SELECT pfile.pfile_sha1 || '.' || pfile.pfile_md5 || '.' || pfile.pfile_size AS pfile, pfile_fk, pfile_size FROM upload INNER JOIN pfile ON upload.pfile_fk = pfile.pfile_pk WHERE upload.upload_pk = '%s'",
Upload_Pk);
result = PQexec(pgConn, SQL);
if (fo_checkPQresult(pgConn, result, SQL, __FILE__, __LINE__)) SafeExit(102);
if (PQntuples(result) > 0) /* if there is a value */
{
Pfile = strdup(PQgetvalue(result,0,0));
Pfile_Pk = strdup(PQgetvalue(result,0,1));
Pfile_size = atol(PQgetvalue(result, 0, 2));
if (Pfile_size == 0)
{
PQclear(result);
LOG_WARNING("Uploaded file (Upload_pk %s), is zero length. There is nothing to unpack.",
Upload_Pk)
SafeExit(0);
}
PQclear(result);
}
// Determine if uploadtree records should go into a separate table.
// If the input file size is > 500MB, then create a separate uploadtree_{upload_pk} table
// that inherits from the master uploadtree table.
// Save uploadtree_tablename, it will get written to upload.uploadtree_tablename later.
if (Pfile_size > 500000000)
{
sprintf(uploadtree_tablename, "uploadtree_%s", Upload_Pk);
if (!fo_tableExists(pgConn, uploadtree_tablename))
{
snprintf(SQL,MAXSQL,"CREATE TABLE %s (LIKE uploadtree INCLUDING DEFAULTS INCLUDING CONSTRAINTS INCLUDING INDEXES); ALTER TABLE %s ADD CONSTRAINT %s CHECK (upload_fk=%s); ALTER TABLE %s INHERIT uploadtree",
uploadtree_tablename, uploadtree_tablename, uploadtree_tablename, Upload_Pk, uploadtree_tablename);
PQsetNoticeProcessor(pgConn, SQLNoticeProcessor, SQL); // ignore notice about implicit primary key index creation
result = PQexec(pgConn, SQL);
// Ignore postgres notice about creating an implicit index
if (PQresultStatus(result) != PGRES_NONFATAL_ERROR)
if (fo_checkPQcommand(pgConn, result, SQL, __FILE__, __LINE__)) SafeExit(103);
PQclear(result);
}
}
else
strcpy(uploadtree_tablename, "uploadtree_a");
}
CheckCommands(Quiet);
if (NewDir) MkDir(NewDir);
if (Verbose) { fclose(stderr) ; stderr=stdout; } /* don't interlace! */
if (ListOutName != NULL)
{
if ((ListOutName[0]=='-') && (ListOutName[1]=='\0'))
ListOutFile=stdout;
else ListOutFile = fopen(ListOutName,"w");
if (!ListOutFile)
{
LOG_ERROR("pfile %s Unable to write to %s\n",Pfile_Pk,ListOutName)
SafeExit(104);
}
else
{
/* Start the file */
fputs("<xml tool=\"ununpack\" ",ListOutFile);
fputs("version=\"",ListOutFile);
fputs(Version,ListOutFile);
fputs("\" ",ListOutFile);
fputs("compiled_date=\"",ListOutFile);
fputs(__DATE__,ListOutFile);
fputs(" ",ListOutFile);
fputs(__TIME__,ListOutFile);
fputs("\"",ListOutFile);
fputs(">\n",ListOutFile);
}
/* Problem: When parallel processing, the XML may be generated out
of order. Solution? When using XML, only use 1 thread. */
MaxThread=1;
}
// Set ReunpackSwitch if the uploadtree records are missing from the database.
if (!ReunpackSwitch && UseRepository)
{
snprintf(SQL,MAXSQL,"SELECT uploadtree_pk FROM uploadtree WHERE upload_fk=%s limit 1;",Upload_Pk);
result = PQexec(pgConn, SQL);
if (fo_checkPQresult(pgConn, result, SQL, __FILE__, __LINE__)) SafeExit(105);
if (PQntuples(result) == 0) ReunpackSwitch=1;
PQclear(result);
}
/*** process files from command line ***/
for( ; optind<argc; optind++)
{
CksumFile *CF=NULL;
Cksum *Sum;
int i;
if (Fname) { free(Fname); Fname=NULL; }
if (ListOutName != NULL)
{
fprintf(ListOutFile,"<source source=\"%s\" ",argv[optind]);
if (UseRepository && !fo_RepExist(REP_FILES,argv[optind]))
{
/* make sure the source exists in the src repository */
if (fo_RepImport(argv[optind],REP_FILES,argv[optind],1) != 0)
{
LOG_ERROR("Failed to import '%s' as '%s' into the repository",argv[optind],argv[optind])
SafeExit(106);
}
}
}
if (UseRepository)
{
if (fo_RepExist(REP_FILES,argv[optind]))
{
Fname=fo_RepMkPath(REP_FILES,argv[optind]);
}
else if (fo_RepExist(REP_GOLD,argv[optind]))
{
Fname=fo_RepMkPath(REP_GOLD,argv[optind]);
if (fo_RepImport(Fname,REP_FILES,argv[optind],1) != 0)
{
LOG_ERROR("Failed to import '%s' as '%s' into the repository",Fname,argv[optind])
SafeExit(107);
}
}
if (Fname)
{
FnameCheck = Fname;
CF = SumOpenFile(Fname);
}
else
{
LOG_ERROR("NO file unpacked. File %s does not exist either in GOLD or FILES", Pfile);
SafeExit(108);
}
/* else: Fname is NULL and CF is NULL */
}
else
{
FnameCheck = argv[optind];
CF = SumOpenFile(argv[optind]);
}
/* Check file to unpack. Does it exist? Is it zero length? */
if (stat(FnameCheck,&Stat))
{
LOG_ERROR("File to unpack is unavailable: %s, error: %s", Fname, strerror(errno));
SafeExit(109);
}
else
if (Stat.st_size < 1)
{
LOG_WARNING("File to unpack is empty: %s", Fname);
SafeExit(110);
}
if (ListOutFile)
{
if (CF)
{
Sum = SumComputeBuff(CF);
SumCloseFile(CF);
if (Sum)
{
fputs("fuid=\"",ListOutFile);
for(i=0; i<20; i++)
{ fprintf(ListOutFile,"%02X",Sum->SHA1digest[i]); }
fputs(".",ListOutFile);
for(i=0; i<16; i++)
{ fprintf(ListOutFile,"%02X",Sum->MD5digest[i]); }
fputs(".",ListOutFile);
fprintf(ListOutFile,"%Lu",(long long unsigned int)Sum->DataLen);
fputs("\" ",ListOutFile);
free(Sum);
} /* if Sum */
} /* if CF */
else /* file too large to mmap (probably) */
{
FILE *Fin;
Fin = fopen(argv[optind],"rb");
if (Fin)
{
Sum = SumComputeFile(Fin);
if (Sum)
{
fputs("fuid=\"",ListOutFile);
for(i=0; i<20; i++)
{ fprintf(ListOutFile,"%02X",Sum->SHA1digest[i]); }
fputs(".",ListOutFile);
for(i=0; i<16; i++)
{ fprintf(ListOutFile,"%02X",Sum->MD5digest[i]); }
fputs(".",ListOutFile);
fprintf(ListOutFile,"%Lu",(long long unsigned int)Sum->DataLen);
fputs("\" ",ListOutFile);
free(Sum);
}
fclose(Fin);
}
} /* else no CF */
fprintf(ListOutFile,">\n"); /* end source XML */
}
if (Fname) TraverseStart(Fname,"called by main via args",NewDir,Recurse);
else TraverseStart(argv[optind],"called by main",NewDir,Recurse);
if (ListOutName != NULL) fprintf(ListOutFile,"</source>\n");
} /* end for */
/* free memory */
if (Fname) { free(Fname); Fname=NULL; }
/* process pfile from scheduler */
if (Pfile)
{
if (0 == (rvExist1 = fo_RepExist2(REP_FILES,Pfile)))
{
Fname=fo_RepMkPath(REP_FILES,Pfile);
}
else if (0 == (rvExist2 = fo_RepExist2(REP_GOLD,Pfile)))
{
Fname=fo_RepMkPath(REP_GOLD,Pfile);
if (fo_RepImport(Fname,REP_FILES,Pfile,1) != 0)
{
LOG_ERROR("Failed to import '%s' as '%s' into the repository",Fname,Pfile)
SafeExit(111);
}
}
if (Fname)
{
TraverseStart(Fname,"called by main via env",NewDir,Recurse);
free(Fname);
Fname=NULL;
}
else
{
LOG_ERROR("NO file unpacked!");
if (rvExist1 > 0)
{
Fname=fo_RepMkPath(REP_FILES, Pfile);
LOG_ERROR("Error is %s for %s", strerror(rvExist1), Fname);
}
if (rvExist2 > 0)
{
Fname=fo_RepMkPath(REP_GOLD, Pfile);
LOG_ERROR("Error is %s for %s", strerror(rvExist2), Fname);
}
SafeExit(112);
}
}
/* recurse on all the children */
if (Thread > 0) do
{
Pid = ParentWait();
Thread--;
if (Pid >= 0)
{
if (!Queue[Pid].ChildEnd)
{
/* copy over data */
if (Recurse > 0)
Traverse(Queue[Pid].ChildRecurse,NULL,"called by wait",NULL,Recurse-1,&Queue[Pid].PI);
else if (Recurse < 0)
Traverse(Queue[Pid].ChildRecurse,NULL,"called by wait",NULL,Recurse,&Queue[Pid].PI);
}
}
} while(Pid >= 0);
if (MagicCookie) magic_close(MagicCookie);
if (ListOutFile)
{
fprintf(ListOutFile,"<summary files_regular=\"%d\" files_compressed=\"%d\" artifacts=\"%d\" directories=\"%d\" containers=\"%d\" />\n",
TotalFiles,TotalCompressedFiles,TotalArtifacts,
TotalDirectories,TotalContainers);
fputs("</xml>\n",ListOutFile);
}
if (pgConn)
{
/* If it completes, mark it! */
if (Upload_Pk)
{
snprintf(SQL,MAXSQL,"UPDATE upload SET upload_mode = (upload_mode | (1<<5)), uploadtree_tablename='%s' WHERE upload_pk = '%s';",uploadtree_tablename, Upload_Pk);
result = PQexec(pgConn, SQL); /* UPDATE upload */
if (fo_checkPQcommand(pgConn, result, SQL, __FILE__ ,__LINE__)) SafeExit(113);
PQclear(result);
snprintf(SQL,MAXSQL,"UPDATE %s SET realparent = getItemParent(uploadtree_pk) WHERE upload_fk = '%s'",uploadtree_tablename, Upload_Pk);
result = PQexec(pgConn, SQL); /* UPDATE uploadtree */
if (fo_checkPQcommand(pgConn, result, SQL, __FILE__ ,__LINE__)) SafeExit(114);
PQclear(result);
}
if (ars_pk) fo_WriteARS(pgConn, ars_pk, atoi(Upload_Pk), agent_pk, AgentARSName, 0, 1);
}
if (ListOutFile && (ListOutFile != stdout))
{
fclose(ListOutFile);
}
if (UnlinkAll && MaxThread > 1)
{
/* Delete temporary files */
if (strcmp(NewDir, ".")) RemoveDir(NewDir);
}
SafeExit(0);
return(0); // never executed but makes the compiler happy
}
/**************** main *******************/
int main(int argc, char** argv)
{
PGconn* pgConn;
PGresult* result;
psqlCopy_t pCopy;
char* TestTable = "TestsqlCopy";
char col_vc[40] = "This is \n\r column vc[40] 123456789\r";
char* col_text;
char* DataBuf;
int datasize;
char sql[2048];
int NumColumns = 3;
int CopyBufSize;
int RowsToTest;
int NumTextBytes;
int RowNum;
clock_t StartTime, EndTime;
char* DBConfFile = NULL; /* use default Db.conf */
char* ErrorBuf;
if (argc != 4)
{
printf("Usage: %s RowsToTest NumTextBytes CopyDataBufferSize\n", argv[0]);
exit(-1);
}
/* first argument is the number of rows to test,
* the second is the number of bytes to use for col_text
* third is the Copy data buffer size
*/
RowsToTest = atoi(argv[1]);
NumTextBytes = atoi(argv[2]);
CopyBufSize = atoi(argv[3]);
/* Populate test data */
col_text = GetTextCol(NumTextBytes);
datasize = NumTextBytes + 8 + 40 + 1;
DataBuf = calloc(datasize, sizeof(char));
if (!DataBuf)
{
ERROR_RETURN("Allocating test data buffer failed.")
exit(-2);
}
pgConn = fo_dbconnect(DBConfFile, &ErrorBuf);
/* Create a test table to populate */
snprintf(sql, sizeof(sql), "create table %s (col_int integer, col_text text, col_vc varchar(40))", TestTable);
result = PQexec(pgConn, sql);
fo_checkPQcommand(pgConn, result, sql, __FILE__, __LINE__);
/* Start timer */
StartTime = clock();
/* Create the pCopy */
pCopy = fo_sqlCopyCreate(pgConn, TestTable, CopyBufSize, NumColumns,
"col_int", "col_text", "col_vc");
if (!pCopy) exit(1); /* CopyCreate prints errors to stdout */
/* Add data */
for (RowNum = 0; RowNum < RowsToTest; RowNum++)
{
snprintf(DataBuf, datasize, "%d\t%s\t%s\n", RowNum, col_text, col_vc);
fo_sqlCopyAdd(pCopy, DataBuf);
}
free(col_text);
/* Destroy - flushes remaining data and frees */
fo_sqlCopyDestroy(pCopy, 1);
/* Print run time for the load (whole Create/Add/Destroy cycle). */
EndTime = clock();
printf("%.6f Seconds to load.\n", ((double) (EndTime - StartTime)) / CLOCKS_PER_SEC);
/* Verify that the right number of records were loaded */
snprintf(sql, sizeof(sql), "select count(*) from %s", TestTable);
result = PQexec(pgConn, sql);
fo_checkPQresult(pgConn, result, sql, __FILE__, __LINE__);
printf("%d records inserted, %d expected\n",
atoi(PQgetvalue(result, 0, 0)),
RowsToTest);
PQclear(result);
/* Remove the test table */
/*
snprintf(sql, sizeof(sql), "drop table %s", TestTable);
result = PQexec(pgConn, sql);
fo_checkPQcommand(pgConn, result, sql, __FILE__, __LINE__);
*/
PQfinish(pgConn);
return (0);
}
