int main(int argc, char ** argv) {
int num_src_drivers = 10;
int num_target_drivers = 32;
if (argc != 4)
usage();
{
char * src_path = argv[1] ;
char * target_path = argv[2] ;
char * dir = argv[3] ;
util_make_path( target_path );
if (util_same_file( src_path , target_path)) {
fprintf(stderr,"The two directories:%s and %s point to the same location \n" , src_path , target_path );
exit(1);
}
{
char * src_case = util_alloc_sprintf("%s/%s" , src_path , dir );
char * target_case = util_alloc_sprintf("%s/%s" , target_path , dir );
msg_type * msg = msg_alloc("Copying from: " , false);
msg_show( msg );
migrate_file(src_case , num_src_drivers , target_case , num_target_drivers , "ANALYZED" , 32 , msg);
migrate_file(src_case , num_src_drivers , target_case , num_target_drivers , "FORECAST" , 32 , msg);
migrate_file(src_case , num_src_drivers , target_case , num_target_drivers , "PARAMETER" , 32 , msg);
migrate_file(src_case , num_src_drivers , target_case , num_target_drivers , "STATIC" , 32 , msg);
copy_index( src_case , target_case );
free( src_case);
free( target_case );
msg_free( msg , true );
}
}
}
/*
* cluster
*
* Check that the relation is a relation in the appropriate user
* ACL. I will use the same security that limits users on the
* renamerel() function.
*
* Check that the index specified is appropriate for the task
* ( ie it's an index over this relation ). This is trickier.
*
* Create a list of all the other indicies on this relation. Because
* the cluster will wreck all the tids, I'll need to destroy bogus
* indicies. The user will have to re-create them. Not nice, but
* I'm not a nice guy. The alternative is to try some kind of post
* destroy re-build. This may be possible. I'll check out what the
* index create functiond want in the way of paramaters. On the other
* hand, re-creating n indicies may blow out the space.
*
* Create new (temporary) relations for the base heap and the new
* index.
*
* Exclusively lock the relations.
*
* Create new clustered index and base heap relation.
*
*/
void
cluster(char oldrelname[], char oldindexname[])
{
Oid OIDOldHeap, OIDOldIndex, OIDNewHeap;
Relation OldHeap, OldIndex;
Relation NewHeap;
char *NewIndexName;
char *szNewHeapName;
/*
*
* I'm going to force all checking back into the commands.c function.
*
* Get the list if indicies for this relation. If the index we want
* is among them, do not add it to the 'kill' list, as it will be
* handled by the 'clean up' code which commits this transaction.
*
* I'm not using the SysCache, because this will happen but
* once, and the slow way is the sure way in this case.
*
*/
/*
* Like vacuum, cluster spans transactions, so I'm going to handle it in
* the same way.
*/
/* matches the StartTransaction in PostgresMain() */
OldHeap = heap_openr(oldrelname);
if (!RelationIsValid(OldHeap)) {
elog(WARN, "cluster: unknown relation: \"%-.*s\"",
NAMEDATALEN, oldrelname);
}
OIDOldHeap = OldHeap->rd_id; /* Get OID for the index scan */
OldIndex=index_openr(oldindexname);/* Open old index relation */
if (!RelationIsValid(OldIndex)) {
elog(WARN, "cluster: unknown index: \"%-.*s\"",
NAMEDATALEN, oldindexname);
}
OIDOldIndex = OldIndex->rd_id; /* OID for the index scan */
heap_close(OldHeap);
index_close(OldIndex);
/*
* I need to build the copies of the heap and the index. The Commit()
* between here is *very* bogus. If someone is appending stuff, they will
* get the lock after being blocked and add rows which won't be present in
* the new table. Bleagh! I'd be best to try and ensure that no-one's
* in the tables for the entire duration of this process with a pg_vlock.
*/
NewHeap = copy_heap(OIDOldHeap);
OIDNewHeap = NewHeap->rd_id;
szNewHeapName = pstrdup(NewHeap->rd_rel->relname.data);
/* Need to do this to make the new heap visible. */
CommandCounterIncrement();
rebuildheap(OIDNewHeap, OIDOldHeap, OIDOldIndex);
/* Need to do this to make the new heap visible. */
CommandCounterIncrement();
/* can't be found in the SysCache. */
copy_index(OIDOldIndex, OIDNewHeap); /* No contention with the old */
/*
* make this really happen. Flush all the buffers.
*/
CommitTransactionCommand();
StartTransactionCommand();
/*
* Questionable bit here. Because the renamerel destroys all trace of the
* pre-existing relation, I'm going to Destroy old, and then rename new
* to old. If this fails, it fails, and you lose your old. Tough - say
* I. Have good backups!
*/
/*
Here lies the bogosity. The RelationNameGetRelation returns a bad
list of TupleDescriptors. Damn. Can't work out why this is.
*/
heap_destroy(oldrelname); /* AAAAAAAAGH!! */
CommandCounterIncrement();
/*
* The Commit flushes all palloced memory, so I have to grab the
* New stuff again. This is annoying, but oh heck!
*/
/*
renamerel(szNewHeapName.data, oldrelname);
TypeRename(&szNewHeapName, &szOldRelName);
sprintf(NewIndexName.data, "temp_%x", OIDOldIndex);
renamerel(NewIndexName.data, szOldIndexName.data);
*/
NewIndexName = palloc(NAMEDATALEN+1); /* XXX */
sprintf(NewIndexName, "temp_%x", OIDOldIndex);
renamerel(NewIndexName, oldindexname);
}
int main(int argc, const char *argv[])
{
CmdArgParser parser(argc, argv);
parser.setHeader("Archive Data Tool version " ARCH_VERSION_TXT ", "
EPICS_VERSION_STRING
", built " __DATE__ ", " __TIME__ "\n\n"
);
parser.setArgumentsInfo("<index-file>");
CmdArgFlag help (parser, "help", "Show help");
CmdArgInt verbosity (parser, "verbose", "<level>", "Show more info");
CmdArgFlag info (parser, "info", "Simple archive info");
CmdArgFlag list_index (parser, "list", "List channel name info");
CmdArgString copy_index (parser, "copy", "<new index>", "Copy channels");
CmdArgString start_time (parser, "start", "<time>",
"Format: \"mm/dd/yyyy[ hh:mm:ss[.nano-secs]]\"");
CmdArgString end_time (parser, "end", "<time>", "(exclusive)");
CmdArgDouble file_limit (parser, "file_limit", "<MB>", "File Size Limit");
CmdArgString basename (parser, "basename", "<string>", "Basename for new data files");
CmdArgFlag enforce_off (parser, "append_off", "Enforce a final 'Archive_Off' value when copying data");
CmdArgString dir2index (parser, "dir2index", "<dir. file>",
"Convert old directory file to index");
CmdArgString index2dir (parser, "index2dir", "<dir. file>",
"Convert index to old directory file");
CmdArgInt RTreeM (parser, "M", "<1-100>", "RTree M value");
CmdArgFlag dump_blocks (parser, "blocks", "List channel's data blocks");
CmdArgFlag all_blocks (parser, "Blocks", "List all data blocks");
CmdArgString dotindex (parser, "dotindex", "<dot filename>",
"Dump contents of RTree index into dot file");
CmdArgString channel_name(parser, "channel", "<name>", "Channel name");
CmdArgFlag hashinfo (parser, "hashinfo", "Show Hash table info");
CmdArgString seek_test (parser, "seek", "<time>", "Perform seek test");
CmdArgFlag test (parser, "test", "Perform some consistency tests");
try
{
// Defaults
RTreeM.set(50);
file_limit.set(100.0);
// Get Arguments
if (! parser.parse())
return -1;
if (help || parser.getArguments().size() != 1)
{
parser.usage();
return -1;
}
// Consistency checks
if ((dump_blocks ||
dotindex.get().length() > 0 ||
seek_test.get().length() > 0)
&& channel_name.get().length() <= 0)
{
fprintf(stderr,
"Options 'blocks' and 'dotindex' require 'channel'.\n");
return -1;
}
verbose = verbosity;
stdString index_name = parser.getArgument(0);
DataWriter::file_size_limit = (unsigned long)(file_limit*1024*1024);
if (file_limit < 10.0)
fprintf(stderr, "file_limit values under 10.0 MB are not useful\n");
// Start/end time
epicsTime *start = 0, *end = 0;
stdString txt;
if (start_time.get().length() > 0)
{
start = new epicsTime;
string2epicsTime(start_time.get(), *start);
if (verbose > 1)
printf("Using start time %s\n", epicsTimeTxt(*start, txt));
}
if (end_time.get().length() > 0)
{
end = new epicsTime();
string2epicsTime(end_time.get(), *end);
if (verbose > 1)
printf("Using end time %s\n", epicsTimeTxt(*end, txt));
}
// Base name
if (basename.get().length() > 0)
DataWriter::data_file_name_base = basename.get();
if (enforce_off)
do_enforce_off = true;
// What's requested?
if (info)
list_names(index_name, false);
else if (list_index)
list_names(index_name, true);
else if (copy_index.get().length() > 0)
{
copy(index_name, copy_index, RTreeM, start, end, channel_name);
return 0;
}
else if (hashinfo)
show_hash_info(index_name);
else if (dir2index.get().length() > 0)
{
convert_dir_index(RTreeM, dir2index, index_name);
return 0;
}
else if (index2dir.get().length() > 0)
{
convert_index_dir(index_name, index2dir);
return 0;
}
else if (all_blocks)
{
dump_all_datablocks(index_name);
return 0;
}
else if (dump_blocks)
{
dump_datablocks(index_name, channel_name);
return 0;
}
else if (dotindex.get().length() > 0)
{
dot_index(index_name, channel_name, dotindex);
return 0;
}
else if (seek_test.get().length() > 0)
{
seek_time(index_name, channel_name, seek_test);
return 0;
}
else if (test)
{
return check(index_name) ? 0 : -1;
}
else
{
parser.usage();
return -1;
}
}
catch (GenericException &e)
{
fprintf(stderr, "Error:\n%s\n", e.what());
}
return 0;
}