/**
* This is a place where you need to put your test. Please insert your test code here and
* change the name of the test to be representative of what you are testing. You can use this test
* during the development period to test your code. When you do the final submission here you have to
* implement a test that tests some interesting functionality of the sfs.
* @return SUCCESS if the test is passed successfully FAIL otherwise.
*/
int customTest() {
int hr = SUCCESS;
int i, j, fd, fd1, fd2, lseek2;
char *randomBuf;//buffer contain junk data, size: SD_SECTORSIZE
randomBuf = (char *) malloc(sizeof(char) * SD_SECTORSIZE);
// For later tests
char* asciidata = (char*)malloc(257 * sizeof(char)); // 2
char* morealphabet = (char*)malloc(7*sizeof(char));
morealphabet[0] = 't';
morealphabet[1] = 'u';
morealphabet[2] = 'v';
morealphabet[3] = 'w';
morealphabet[4] = 'x';
morealphabet[5] = 'y';
morealphabet[6] = 'z';
char alphabet[26] = "abcdefghijklmnopqrstuvwxyz";
char* fd1read = (char*)malloc(26*sizeof(char));
// normal test from testfs
// initialize disk
FAIL_BRK4(SD_initDisk());
for (i = 0; i < SD_NUMSECTORS; i++) {
for (j = 0; j < SD_SECTORSIZE; j++) {
randomBuf[j] = (char) rand();
}
while (SD_write(i, (void*) randomBuf));
}
FAIL_BRK4(SD_loadDisk(gsDiskFName));
refreshDisk();
// initialize fs, sfs_mkfs
FAIL_BRK4(initFS());
refreshDisk();
// initialize test sfs_mkfs, when mkfs, nothing should appear again.
FAIL_BRK4(initFS());
FAIL_BRK4(sfs_mkdir("foo"));
refreshDisk();
FAIL_BRK4(sfs_fcd("foo"));
FAIL_BRK4(sfs_mkdir("bar"));
FAIL_BRK4(initFS());
refreshDisk();
FAIL_BRK4((sfs_fcd("foo") != -1));
FAIL_BRK4((sfs_fcd("bar") != -1));
FAIL_BRK4(sfs_fcd("/"));
FAIL_BRK4((sfs_fcd("foo") != -1));
FAIL_BRK4((sfs_fcd("bar") != -1));
FAIL_BRK4(sfs_mkdir("foo"));
refreshDisk();
FAIL_BRK4(sfs_fcd("foo"));
FAIL_BRK4((sfs_fcd("bar") != -1));
//normal test . and ..
FAIL_BRK4(initFS());
refreshDisk();
FAIL_BRK4((sfs_mkdir(".") != -1));
FAIL_BRK4(sfs_mkdir(".foo."));
FAIL_BRK4(sfs_mkdir(".foo"));
FAIL_BRK4((sfs_mkdir("..") != -1));
FAIL_BRK4(sfs_mkdir("..foo"));
FAIL_BRK4(sfs_mkdir("..foo.."));
FAIL_BRK4((sfs_mkdir("/") != -1));
FAIL_BRK4(sfs_mkdir("..."));
FAIL_BRK4(sfs_mkdir("...."));
FAIL_BRK4((sfs_mkdir("./") != -1));
FAIL_BRK4((sfs_mkdir("/.") != -1));
FAIL_BRK4((sfs_mkdir("./.") != -1));
// ascii code test, make a file containing all ascii code chars to make sure implementation does not use an EOF char for size
FAIL_BRK4(initFS());
refreshDisk();
//257 chars, possible ascii 0 -> 255 + 255 at the end to make sure we test
// create data
for (i = 0; i < 256; i++) {
asciidata[i] = i; // table sequentially
}
// now put 255 in again at the end
asciidata[256] = 255;
// now fwrite into the a file and fread and compare
FAIL_BRK4(createSmallFile("asciitable", asciidata, 257));
refreshDisk();
FAIL_BRK4(verifyFile("asciitable", asciidata, 257));
// This test will open the same file twice, write more onto it using one of the file descriptors to lengthen it, and read both to make sure they still match (should test to make sure size is with inodes and not the table
FAIL_BRK4(initFS());
refreshDisk();
FAIL_BRK4(createSmallFile("alphabet", "abcdefghijklmnopqrst", 20));
// Open twice
FAIL_BRK4((fd1 = sfs_fopen("alphabet")) == -1);
FAIL_BRK4((fd2 = sfs_fopen("alphabet")) == -1);
// lseek to end and write to second one
FAIL_BRK4((lseek2 = sfs_lseek(fd2, 19)) == -1);
FAIL_BRK4((sfs_fwrite(fd2, morealphabet, 7)) == -1);
// Now verify we can read from fd1 and it should be the full alphabet since we wrote to fd2 which is the same file
FAIL_BRK4((sfs_fread(fd1, fd1read, 26)) == -1);
FAIL_BRK4((strncmp(alphabet, fd1read, 26)) != 0); // here is the comparison of strings
FAIL_BRK4((sfs_fclose(fd1)) == -1);
FAIL_BRK4((sfs_fclose(fd2)) == -1);
//test dir takes more that one sector
//test for file
FAIL_BRK4(initFS());
refreshDisk();
FAIL_BRK4((fd = sfs_fopen("foo.bin")) == -1);
FAIL_BRK4(sfs_fclose(fd));
FAIL_BRK4((sfs_fcd("foo.bin") != -1));
//test same name
FAIL_BRK4(initFS());
refreshDisk();
FAIL_BRK4(sfs_mkdir("foo.bin"));
FAIL_BRK4((fd = sfs_fopen("foo.bin")) != -1);
FAIL_BRK4((fd = sfs_fopen("bar.bin")) == -1);
FAIL_BRK4((sfs_mkdir("bar.bin") != -1));
//test initFS will erase the file descriptor
FAIL_BRK4(initFS());
refreshDisk();
FAIL_BRK4((fd = sfs_fopen("foo.bin")) == -1);
FAIL_BRK4(initFS());
FAIL_BRK4((sfs_fclose(fd) != -1));
//test create nothing
FAIL_BRK4(initFS());
refreshDisk();
FAIL_BRK4((sfs_mkdir("") != -1));
FAIL_BRK4((fd = sfs_fopen("")) != -1);
//test open . and ..
FAIL_BRK4(initFS());
refreshDisk();
FAIL_BRK4((fd = sfs_fopen("/")) != -1);
FAIL_BRK4((fd = sfs_fopen(".")) != -1);
FAIL_BRK4((fd = sfs_fopen("..")) != -1);
FAIL_BRK4(sfs_mkdir("foo"));
FAIL_BRK4((fd = sfs_fopen("foo")) != -1);
FAIL_BRK4(sfs_fcd("foo"));
FAIL_BRK4((fd = sfs_fopen("/")) != -1);
FAIL_BRK4((fd = sfs_fopen(".")) != -1);
FAIL_BRK4((fd = sfs_fopen("..")) != -1);
FAIL_BRK4(sfs_fcd("/"));
FAIL_BRK4((fd = sfs_fopen("/.")) != -1);
FAIL_BRK4((fd = sfs_fopen("./")) != -1);
FAIL_BRK4((fd = sfs_fopen("./.")) != -1);
FAIL_BRK4((fd = sfs_fopen("/..")) != -1);
FAIL_BRK4((fd = sfs_fopen("../")) != -1);
FAIL_BRK4((fd = sfs_fopen("../..")) != -1);
FAIL_BRK4((fd = sfs_fopen("//")) != -1);
FAIL_BRK4((fd = sfs_fopen(".foo")) == -1);
FAIL_BRK4((fd = sfs_fopen(".foo.")) == -1);
FAIL_BRK4((fd = sfs_fopen("..foo")) == -1);
FAIL_BRK4((fd = sfs_fopen("..foo..")) == -1);
FAIL_BRK4((fd = sfs_fopen("...")) == -1);
FAIL_BRK4((fd = sfs_fopen(".....")) == -1);
// test the malloc not been released
FAIL_BRK4(sfs_mkfs());
refreshDisk();
int thememmax;
struct rusage ru;
getrusage(RUSAGE_SELF, &ru);
thememmax=ru.ru_maxrss;
long int k;
for(k = 0; k < 100000; ++k)
{
FAIL_BRK4(sfs_mkfs());
FAIL_BRK4(sfs_mkdir("foo"));
FAIL_BRK4(sfs_fcd("foo"));
FAIL_BRK4(sfs_ls(f_ls));
FAIL_BRK4((fd = sfs_fopen("bar")) == -1);
FAIL_BRK4((sfs_fwrite(fd, randomBuf, SD_SECTORSIZE)) == -1);
FAIL_BRK4((sfs_lseek(fd, 1)) == -1);
FAIL_BRK4((sfs_fread(fd, randomBuf, SD_SECTORSIZE - 1)) == -1);
FAIL_BRK4(sfs_fclose(fd));
}
getrusage(RUSAGE_SELF, &ru);
FAIL_BRK4(100 * thememmax <= ru.ru_maxrss);
/*
FAIL_BRK4(createFolder("bar"));
FAIL_BRK4(sfs_fcd("bar"));
FAIL_BRK4(createFolder("foo"));
FAIL_BRK4(sfs_fcd("foo"));
FAIL_BRK4(sfs_fcd("/bar/foo"));
// FAIL_BRK3((sfs_fcd("//bar/foo") != -1), stdout, "Error: sfs_fcd() failed\n");
FAIL_BRK4(sfs_fcd("/../bar/foo"));
FAIL_BRK4(sfs_fcd("/../bar/foo/"));
FAIL_BRK4(sfs_fcd("/"));
FAIL_BRK3(sfs_ls(f_ls), stdout, "Error: sfs_ls() failed\n");
FAIL_BRK4(sfs_fcd("/bar"));
FAIL_BRK3(sfs_ls(f_ls), stdout, "Error: sfs_ls() failed\n");
//int fopentmp;
//FAIL_BRK3((fopentmp = sfs_fopen("test.txt") != -1), stdout, "Error: Allowing read from unopened file\n");
//FAIL_BRK3((sfs_fread(fopentmp, buf, 50) != -1), stdout, "Error: Allowing read from unopened file\n");
// test if fcd does not allow going to places that does not exist
FAIL_BRK3((sfs_fcd("bla") != -1), stdout,
"Error: Allowing cd to folder that does not exist\n");
FAIL_BRK3((sfs_fcd("x") != -1), stdout,
"Error: Allowing cd to folder that does not exist\n");
FAIL_BRK3((sfs_fcd("x/y/x/z") != -1), stdout,
"Error: Allowing cd to folder that does not exist\n");
*/
Fail:
//clean up code goes here
SAFE_FREE(asciidata);
SAFE_FREE(morealphabet);
SAFE_FREE(fd1read);
SAFE_FREE(randomBuf);
saveAndCloseDisk();
PRINT_RESULTS("customTest!");
return hr;
}
/**
* Create a big file, write lots of data to it and close it. Then append another chunk of data to it.
*/
int appendFile() {
int hr = SUCCESS;
int fsize1 = 20 * SD_SECTORSIZE;
int fsize2 = 50 * SD_SECTORSIZE;
char *buffer = malloc(fsize2 * sizeof(char));
char *buffer2 = malloc(fsize2 * sizeof(char));
char *fileName = "foo";
// create the original file
FAIL_BRK3(singleBigFile(fileName, fsize1), stdout,
"Error: Unable to create the initial file\n");
FAIL_BRK3(refreshDisk(), stdout, "Error: Refresh disk failed\n");
// open it again
int fd = sfs_fopen(fileName);
FAIL_BRK3((fd == -1), stdout, "Error: Unable to reopen the file\n");
// lseek to the end of the file
int newPos = sfs_lseek(fd, fsize1 - 1);
FAIL_BRK3(
(newPos != fsize1 - 1),
stdout,
"Error: Seeking1 to the end of the file failed newPos (%d), fsize1(%d)\n",
newPos, fsize1);
initBuffer(buffer, fsize2);
// write the new data
int bytesWritten = sfs_fwrite(fd, buffer, fsize2);
FAIL_BRK3((bytesWritten != fsize2), stdout,
"Error: Appending write failed\n");
// close the file
FAIL_BRK3(sfs_fclose(fd), stdout, "Error: Closing the file failed\n");
FAIL_BRK3(refreshDisk(), stdout, "Error: Refresh disk failed\n");
// open it again
fd = sfs_fopen(fileName);
FAIL_BRK3((fd == -1), stdout, "Error: Unable to reopen the file\n");
// again lseek to the place where we started appending
newPos = sfs_lseek(fd, fsize1 - 1);
FAIL_BRK3((newPos != fsize1 - 1), stdout,
"Error: Seeking2 to the end of the file failed\n");
// read the data
int bytesRead = sfs_fread(fd, buffer2, fsize2);
FAIL_BRK3((bytesRead != fsize2), stdout,
"Error: Reading back the appended part failed\n");
// make sure it matches
FAIL_BRK3(checkBuffers(buffer, buffer2, fsize2, 0), stdout,
"Error: Contents don't match\n");
// close the file
FAIL_BRK3(sfs_fclose(fd), stdout, "Error: Closing the file failed\n");
// finalize
Fail:
// clean up
SAFE_FREE(buffer);
SAFE_FREE(buffer2);
return hr;
}
/**
* Performs various file operations.
*
* @param name name of file to create
* @param fsize size of file to create
* @return -1 upon failure, 0 otherwise
*/
int testFile(char* name, int fsize) {
int fd = 0; /* file handle */
int bytes, bytesToRead, offset;
// fix fsize of too small
if (fsize<=1) fsize=2;
char *buf = (char *) malloc(sizeof(char) * fsize);
char *cpy = (char *) malloc(sizeof(char) * fsize);
LOG(stdout, "Create file...\n");
fd = sfs_fopen(name);
FAIL_BRK((fd == -1), stdout, "Error: Open file failed for: %s\n", name);
initBuffer(buf, fsize);
/* write to disk */
FAIL_BRK((sfs_fwrite(fd, buf, fsize) == -1), stdout,
"Error: Writing %d bytes to file %s failed!\n", fsize, name);
/* close file */
FAIL_BRK(sfs_fclose(fd), stdout, "Closing file %s failed!\n", name);
/* save disk, close it and reload it to make sure changes are flushed to disk */
FAIL_BRK(refreshDisk(), stdout, "Error: Refreshing disk failed\n");
/* open file again */
fd = sfs_fopen(name);
FAIL_BRK((fd == -1), stdout, "Error: Second open file failed for: %s\n",
name);
/* read file */
int fsize2;
FAIL_BRK(((fsize2 = sfs_fread(fd, cpy, fsize)) == -1), stdout,
"Read failed for: %s\n", name);
FAIL_BRK(
(fsize != fsize2),
stdout,
"Error: The amount we wrote (%d) is different from what we read (%d)\n",
fsize, fsize2);
/* check contents */
FAIL_BRK(checkBuffers(buf, cpy, fsize, 0), stdout,
"Error: Contents don't match\n");
/* reset file */
FAIL_BRK(sfs_fclose(fd), stdout, "Error: Closing file (%d)(%s) failed\n",
fd, name);
fd = sfs_fopen(name);
FAIL_BRK((fd == -1), stdout, "Error: Opening file (%s) failed\n", name);
free(cpy);
cpy = (char *) malloc(sizeof(char) * fsize);
/* check contents using small chunks */
bytes = 0;
while (bytes < fsize) {
bytesToRead = rand() % 9 + 1;
if (bytes + bytesToRead >= fsize) {
bytesToRead = fsize - bytes;
}
/* read */
int bytesActuallyRead;
bytesActuallyRead = sfs_fread(fd, cpy + bytes, bytesToRead);
FAIL_BRK((bytesActuallyRead == -1), stdout,
"Error: Read failed for: %s\n", name);
FAIL_BRK(
(bytesActuallyRead != bytesToRead),
stdout,
"Error: For file (%s) expected to read (%d) but actually read (%d)\n",
name, bytesToRead, bytesActuallyRead);
bytes += bytesToRead;
}
FAIL_BRK(checkBuffers(buf, cpy, fsize, 0), stdout,
"Error: Contents don't match\n");
/* reset file */
FAIL_BRK(sfs_fclose(fd), stdout, "Error: Closing file (%d) failed\n", fd);
fd = sfs_fopen(name);
FAIL_BRK((fd == -1), stdout, "Error: Opening file (%s) failed\n", name);
free(cpy);
cpy = (char *) malloc(sizeof(char) * fsize);
/* check contents from offset */
offset = rand() % (fsize - 1);
bytesToRead = rand() % (fsize - offset);
if (bytesToRead == 0)
bytesToRead++;
FAIL_BRK((sfs_lseek(fd, offset) == -1), stdout,
"Error: lseek failed for: (%s) fd: (%d), offset: (%d)\n", name, fd,
offset);
/* read */
int bytesActuallyRead = 0;
bytesActuallyRead = sfs_fread(fd, cpy + offset, bytesToRead);
FAIL_BRK((bytesActuallyRead == -1), stdout, "Error: Read failed for: %s\n",
name);
FAIL_BRK(
(bytesActuallyRead != bytesToRead),
stdout,
"Error: For file (%s) expected to read (%d) but actually read (%d)\n",
name, bytesToRead, bytesActuallyRead);
FAIL_BRK(checkBuffers(buf, cpy, bytesToRead, offset), stdout,
"Error: Contents do not match\n");
FAIL_BRK(sfs_fclose(fd), stdout, "Error: Closing file (%d) failed\n", fd);
SAFE_FREE(buf);
SAFE_FREE(cpy);
return 0; /* passed all tests */
// Something went wrong...
Fail:
SAFE_FREE(buf);
SAFE_FREE(cpy);
return -1;
}
void GPFSConfigHandler::task()
{
int nFSs = 0;
int nPools = 0;
int nDisks = 0;
int nFsets = 0;
int nNodes = 0;
TEAL_ERR_T ret;
string msg;
char tmp[10];
string fsName;
string stgName;
string diskName;
string fsetName;
string nodeName;
string clusterName;
FilesystemInfo* fsInfo = NULL;
StoragePoolInfo* stgInfo = NULL;
DiskInfo* diskInfo = NULL;
FileSet* fsetInfo = NULL;
FileSet* fileSetList = NULL;
MErrno err = M_OK;
log_info("########################Start refreshing all entities#########################################");
err = GPFSHandler::getPollHandler()->getDaemonState();
if(err != M_OK)
{
msg = "daemon is down on local node ";
msg += Utils::int_to_char(tmp,10,(unsigned int*)&err);
log_warn(msg);
/* Simply ignore this error to continue....
log_error(msg);
return;
*/
}
err = GPFSHandler::getPollHandler()->refreshClusterRecipe();
if(err != M_OK)
{
msg = "refresh cluster failed with ";
msg += Utils::int_to_char(tmp,10,(unsigned int*)&err);
log_warn(msg);
/* Simply ignore this error to continue....
log_error(msg);
return;
*/
}
ClusterInfo* clusterInfo = new ClusterInfo(&err);
//update cluster info
err = GPFSHandler::getPollHandler()->updateClusterInfo(clusterInfo);
if(err != M_OK)
{
msg = "update cluster info failed with ";
msg += Utils::int_to_char(tmp,10,(unsigned int*)&err);
log_warn(msg);
/* Simply ignore this error to continue....
log_error(msg);
return;
*/
}
//update all nodes info
err = GPFSHandler::getPollHandler()->updateNodeInfo(clusterInfo);
if(err != M_OK)
{
msg = "update node failed with ";
msg += Utils::int_to_char(tmp,10,(unsigned int*)&err);
log_warn(msg);
/* Simply ignore this error to continue....
log_error(msg);
return;
*/
}
err = GPFSHandler::getPollHandler()->getClusterInfo(clusterInfo); //this maybe not needed
if(err != M_OK)
{
msg = "get cluster info failed with ";
msg += Utils::int_to_char(tmp,10,(unsigned int*)&err);
log_warn(msg);
/* Simply ignore this error to continue....
log_error(msg);
return;
*/
}
err = GPFSHandler::getPollHandler()->updateDiskSDRInfo();
if(err != M_OK)
{ /*TODO: This API invokes "mmsdrquery 30 3001:3004:3005:3006:3007:3008:3002:3003" under the cover. Need to check if it is a real error or an expected configuration to determin whether to ignore it or not.*/
msg = "update disk SDR info failed with ";
msg += Utils::int_to_char(tmp,10,(unsigned int*)&err);
msg += ", ignore it...";
log_warn(msg);
// return; // simply ignore it since there a configuration of two clusters and NSD may not be seen from the FS cluster.
}
err = GPFSHandler::getPollHandler()->updateFilesystemInfo(clusterInfo, 1);// to get perfermance statics even if not used.
if(err != M_OK)
{
msg = "update file system failed with ";
msg += Utils::int_to_char(tmp,10,(unsigned int*)&err);
log_warn(msg);
/* Simply ignore this error to continue....
log_error(msg);
return;
*/
}
err = GPFSHandler::getPollHandler()->updateMountedNodeInfo(clusterInfo); // to get mounted node info
if(err != M_OK)
{ /*TODO: This API invokes "mmlsmount all_local -Y" under the cover. Need to check if it is a real error or an expected configuration to determin whether to ignore it or not.*/
msg = "update mounted node info failed with ";
msg += Utils::int_to_char(tmp,10,(unsigned int*)&err);
msg += ", ignore it...";
log_warn(msg);
// return; // simply ignore it since there maybe no local file system configured
}
err = GPFSHandler::getPollHandler()->updateVfsStatsInfo(clusterInfo); // to get vfs info
if(err != M_OK)
{
msg = "update vfs info failed with ";
msg += Utils::int_to_char(tmp,10,(unsigned int*)&err);
log_warn(msg);
/* Simply ignore this error to continue....
log_error(msg);
return;
*/
}
err = GPFSHandler::getPollHandler()->updateThreadUtilInfo(clusterInfo); // to get thread util info
if(err != M_OK)
{
msg = "update thread util info failed with ";
msg += Utils::int_to_char(tmp,10,(unsigned int*)&err);
log_warn(msg);
/* Simply ignore this error to continue....
log_error(msg);
return;
*/
}
err = GPFSHandler::getPollHandler()->updateIocStatsInfo(clusterInfo); // to get ioc statics info
if(err != M_OK)
{
msg = "update ioc statics info failed with ";
msg += Utils::int_to_char(tmp,10,(unsigned int*)&err);
log_warn(msg);
/* Simply ignore this error to continue....
log_error(msg);
return;
*/
}
err = GPFSHandler::getPollHandler()->updateCacheStatsInfo(clusterInfo); // to get cache statics info
if(err != M_OK)
{
msg = "update cache statics info failed with ";
msg += Utils::int_to_char(tmp,10,(unsigned int*)&err);
log_warn(msg);
/* Simply ignore this error to continue....
log_error(msg);
return;
*/
}
err = GPFSHandler::getPollHandler()->updatePCacheStatsInfo(clusterInfo); // to get pcache statics info
if(err != M_OK)
{
msg = "update pcache statics info failed with ";
msg += Utils::int_to_char(tmp,10,(unsigned int*)&err);
log_warn(msg);
/* Simply ignore this error to continue....
log_error(msg);
return;
*/
}
err = GPFSHandler::getPollHandler()->updateFilesystemManagerInfo(clusterInfo);// update fs manager
if(err != M_OK)
{
msg = "update file system manager failed with ";
msg += Utils::int_to_char(tmp,10,(unsigned int*)&err);
log_warn(msg);
/* Simply ignore this error to continue....
log_error(msg);
return;
*/
}
err = GPFSHandler::getPollHandler()->updatePolicyInfo(clusterInfo); // to get policy info
if(err != M_OK)
{
msg = "update policy info failed with ";
msg += Utils::int_to_char(tmp,10,(unsigned int*)&err);
log_warn(msg);
/* Simply ignore this error to continue....
log_error(msg);
return;
*/
}
err = GPFSHandler::getPollHandler()->updateFilesystemConfigInfo(clusterInfo);// update fs config
if(err != M_OK)
{
msg = "update file system config failed with ";
msg += Utils::int_to_char(tmp,10,(unsigned int*)&err);
log_warn(msg);
/* Simply ignore this error to continue....
log_error(msg);
return;
*/
}
ClusterStatus* clusterStatus = new ClusterStatus();
err = GPFSHandler::getPollHandler()->getClusterStatus(clusterStatus);
if(err != M_OK)
{
msg = "get cluster status failed with ";
msg += Utils::int_to_char(tmp,10,(unsigned int*)&err);
log_warn(msg);
/* Simply ignore this error to continue....
log_error(msg);
return;
*/
}
clusterName = clusterInfo->getName();
int i = 0;
string clusterid = clusterInfo->getId();
nFSs = clusterInfo->getNumFilesystems();
//log fs one by one
for( i = 0 ; i < nFSs; i++)
{
fsInfo = clusterInfo->getFilesystem(i);
if (fsInfo == NULL)
{
msg = "NULL filesystem ";
msg += Utils::int_to_char(tmp,10,(unsigned int*)&i);
log_error(msg);
continue;
}
fsName = fsInfo->getName();
err = GPFSHandler::getPollHandler()->updateStoragePoolInfo(clusterInfo, (char*)fsName.c_str());
if(err != M_OK)
{
msg = "update storage pool info for file system: ";
msg += fsName;
msg += " failed with ";
msg += Utils::int_to_char(tmp,10,(unsigned int*)&err);
log_warn(msg);
continue;
}
msg = "Refresh file system: ";
msg += fsName;
log_debug(msg);
ret = refreshFS(fsInfo, clusterid);
if(ret != TEAL_SUCCESS)
{
msg = "Refresh file system: ";
msg += fsName;
msg += " failed with ";
msg += Utils::int_to_char(tmp,10,(unsigned int*)&ret);
log_error(msg);
}
nPools = fsInfo->getNumStoragePools();
int j = 0;
//log stg one by one
for(; j < nPools; j++ )
{
stgInfo = fsInfo->getStoragePool(j);
if(stgInfo == NULL)
{
msg = "ERR stgInfo for storage pool: ";
msg += Utils::int_to_char(tmp,10,(unsigned int*)&j);
msg += " in (fs: ";
msg += fsName;
msg += ") is NULL";
log_error(msg);
continue;
}
stgName = stgInfo->getName();
err = GPFSHandler::getPollHandler()->updateDiskInfo(clusterInfo, (char*)fsName.c_str(), (char*)stgName.c_str(),1);
if(err != M_OK)
{
msg = "update disk info in (file system: ";
msg += fsName;
msg += ", storage pool: ";
msg += stgName;
msg += ") failed with ";
msg += Utils::int_to_char(tmp,10,(unsigned int*)&err);
log_warn(msg);
continue;
}
msg = "Refresh storage pool: ";
msg += stgName;
msg += " in (fs: ";
msg += fsName;
msg += ")";
log_debug(msg);
ret = refreshStgPool(stgInfo, clusterid, fsName);
if(ret != TEAL_SUCCESS)
{
msg = "Refresh storage pool: ";
msg += stgName;
msg += " in (fs: ";
msg += fsName;
msg += ") failed with ";
msg += Utils::int_to_char(tmp,10,(unsigned int*)&ret);
log_error(msg);
}
int k = 0;
nDisks = stgInfo->getNumDisks();
//log disk one by one
for(; k < nDisks ; k++ )
{
diskInfo = stgInfo->getDisk(k);
if(diskInfo == NULL)
{
msg = "diskInfo for disk: ";
msg += Utils::int_to_char(tmp,10,(unsigned int*)&k);
msg += " in (storage pool: ";
msg += stgName;
msg += ", fs: ";
msg += fsName;
msg += ") is NULL";
log_error(msg);
continue;
}
diskName = diskInfo->getName();
msg = "Refresh disk: ";
msg += diskName;
msg += " in (storage pool: ";
msg += stgName;
msg += ", fs: ";
msg += fsName;
msg += ")";
log_debug(msg);
ret = refreshDisk(diskInfo, clusterid);
if(ret != TEAL_SUCCESS)
{
msg = "Refresh disk: ";
msg += diskName;
msg += " in (storage pool: ";
msg += stgName;
msg += ", fs: ";
msg += fsName;
msg += ") failed with ";
msg += Utils::int_to_char(tmp,10,(unsigned int*)&ret);
log_error(msg);
}
}//end of refresh disks
}//end of refresh stgpool
/* core dump in GPFS 3.4, only effective in 3.5
err = GPFSHandler::getPollHandler()->getFileSets((char*)fsName.c_str(), &fileSetList);
if(err != M_OK)
{
msg = "update fileset info in (fs: ";
msg += fsName;
msg += ") failed with ";
msg += Utils::int_to_char(tmp,10,(unsigned int*)&err);
log_error(msg);
nFsets = 0;
fileSetList = NULL;
continue;
} //at first time to get nFsets but will not return M_OK
*/
err = GPFSHandler::getPollHandler()->getFileSets1((char*)fsName.c_str(), fileSetList, &nFsets);
if(nFsets <= 0)
{
msg = "no fileset found in (fs: ";
msg += fsName;
msg += ")";
log_warn(msg);
nFsets = 0;
fileSetList = NULL;
continue;
}
fileSetList = new FileSet[nFsets];
err = GPFSHandler::getPollHandler()->getFileSets1((char*)fsName.c_str(), fileSetList, &nFsets);
if(err != M_OK)
{
msg = "update fileset info in (fs: ";
msg += fsName;
msg += ") failed with ";
msg += Utils::int_to_char(tmp,10,(unsigned int*)&err);
log_warn(msg);
nFsets = 0;
fileSetList = NULL;
continue;
}
int l = 0;
//log fileset one by one
for(; l < nFsets; l++ )
{
fsetInfo = &fileSetList[l];
if(fsetInfo == NULL)
{
msg = "fsetInfo for fset: ";
msg += Utils::int_to_char(tmp,10,(unsigned int*)&i);
msg += " in (fs: ";
msg += fsName;
msg += ") is NULL";
log_error(msg);
continue;
}
fsetName = fsetInfo->getName();
msg = "Refresh fileset: ";
msg += fsetName;
msg += " in (fs: ";
msg += fsName;
msg += ")";
log_debug(msg);
ret = refreshFset(fsetInfo, clusterid);
if(ret != TEAL_SUCCESS)
{
msg = "Refresh file set: ";
msg += fsetName;
msg += " in (fs: ";
msg += fsName;
msg += ") failed with";
msg += Utils::int_to_char(tmp,10,(unsigned int*)&ret);
log_error(msg);
}
}//end of refresh fset
if(fileSetList)
{
delete []fileSetList;
fileSetList = NULL;
nFsets = 0;
fsetInfo = NULL;
}
}//end of refresh fs
nNodes = clusterInfo->getNumNodes();
// to get disk access info, place this here to update num_access_disk in nodeinfo and need to invoke updateStoragePool() prior to this API
err = GPFSHandler::getPollHandler()->updateDiskAccessInfo(clusterInfo);
if(err != M_OK)
{
msg = "update disk access info failed with ";
msg += Utils::int_to_char(tmp,10,(unsigned int*)&err);
log_warn(msg);
/* Simply ignore this error to continue....
log_error(msg);
return;
*/
}
NodeInfo* nodeInfo = NULL;
//log node one by one
for( i = 0 ; i < nNodes; i++)
{
nodeInfo = clusterInfo->getNode(i);
if (nodeInfo == NULL)
{
msg = "nodeInfo for node ";
msg += Utils::int_to_char(tmp,10,(unsigned int*)&i);
msg += "is NULL";
log_error(msg);
continue;
}
nodeName = nodeInfo->getName();
msg = "Refresh node: ";
msg += nodeName;
log_debug(msg);
ret = refreshNode(nodeInfo, clusterid);
if(ret != TEAL_SUCCESS)
{
msg = "Refresh node: ";
msg += nodeName;
msg += " failed with ";
msg += Utils::int_to_char(tmp,10,(unsigned int*)&ret);
log_error(msg);
continue;
}
}//end of refresh node
//refresh free disks here since free disk number/info can only be got after invoking updateDiskInfo() to all fs/stgpool
err = GPFSHandler::getPollHandler()->updateFreeDiskInfo(clusterInfo);
if(err != M_OK)
{
msg = "update free disk info failed with ";
msg += Utils::int_to_char(tmp,10,(unsigned int*)&err);
msg += ", ignore it...";
log_warn(msg);
}
nDisks = clusterInfo->getNumFreeDisks();
int k = 0;
for(; k < nDisks ; k++ )
{
diskInfo = clusterInfo->getFreeDisk(k);
if(diskInfo == NULL)
{
msg = "diskInfo for free disk: ";
msg += Utils::int_to_char(tmp,10,(unsigned int*)&i);
msg += " is NULL";
log_error(msg);
continue;
}
diskName = diskInfo->getName();
int s;
int nServers = diskInfo->getNumServerItems();
int nBacks = diskInfo->getNumBackupServerItems();
string node_name;
for(s = 0; s < nServers; s++)
{
DiskServerInfo *ds = diskInfo->getServer(s);
node_name += string(ds->getName()) + string(" ");
}
for(s = 0; s < nBacks; s++)
{
DiskServerInfo *ds = diskInfo->getBackupServer(s);
node_name += string(ds->getName()) + string(" ");
}
msg = "Refresh free disk: ";
msg += "(";
msg += diskName;
msg += ")";
log_debug(msg);
char svrList[NAME_STRING_LEN] = {0};
strcpy(svrList,node_name.c_str());
ret = refreshDisk(diskInfo, clusterid, svrList);
if(ret != TEAL_SUCCESS)
{
msg = "Refresh free disk: ";
msg += "(";
msg += diskName;
msg += ") failed with ";
msg += Utils::int_to_char(tmp,10,(unsigned int*)&ret);
log_error(msg);
}
}//end of refresh free disks
//refresh cluster here since free disk number/info can only be got after invoking updateDiskInfo() to all fs/stgpool
msg = "Refresh cluster: ";
msg += clusterName;
log_debug(msg);
ret = refreshCluster(clusterInfo,clusterStatus);
if(ret != TEAL_SUCCESS)
{
msg = "Refresh cluster failed with ";
msg += Utils::int_to_char(tmp,10,(unsigned int*)&err);
log_error(msg);
}
log_info("##################Start to refresh perseus configuration###################");
int nRgAllocated = 6; /* number of rg slots allocated in the buffer in advance*/
char *bufP = NULL;
int bufLen = 0;
int rc = 0;
int nPdisk = 0;
int nVdisk = 0;
int nRg = 0;
int nDa = 0;
string pdiskName;
string vdiskName;
string rgName;
string daName;
gpfsRecoveryGroupSdrInfo *rgSdrTableP = NULL;
gpfsRecoveryGroupSdrInfo *rgSdrP = NULL;
gpfsRecoveryGroup *rgTableP = NULL;
gpfsRecoveryGroup *rgP = NULL;
gpfsRecoveryGroupDeclusteredArray* daP = NULL;
gpfsDeclusteredArrayPdisk* pdiskP = NULL;
gpfsDeclusteredArrayVdisk* vdiskP = NULL;
rgSdrTableP = new gpfsRecoveryGroupSdrInfo[nRgAllocated];
nRg = nRgAllocated;
/* get initial info from SDR (all RG names) */
rc = getNsdRAIDSdrInfo(rgSdrTableP, &nRg);
// retry if failed with ENOMEM
if(rc == ENOMEM)
{
log_debug("Not enough memory allocated, reallocate...");
nRgAllocated = nRg > nRgAllocated ? nRg : nRgAllocated;
delete[] rgSdrTableP;
rgSdrTableP = NULL;
rgSdrTableP = new gpfsRecoveryGroupSdrInfo[nRgAllocated];
nRg = nRgAllocated;
rc = getNsdRAIDSdrInfo(rgSdrTableP, &nRg);
}
if (rc == M_OK)
{
if (nRg >= 1)
{
rgTableP = new gpfsRecoveryGroup[nRg];
if (rgTableP == NULL)
{
msg = "Initial RG table failed with ";
msg += Utils::int_to_char(tmp,10,(unsigned int*)&rc);
log_error(msg);
return;
}
for (i = 0, rgSdrP = rgSdrTableP; i < nRg && i < nRgAllocated; i++, rgSdrP++)
{
rgP = rgTableP + i;
rgP->updateRgSdrInfo(rgSdrP->getRecoveryGroupName(),rgSdrP->getRecoveryGroupServerList(),rgSdrP->getRecoveryGroupId());
rc = getRecoveryGroupSummary(rgP); //refresh rg info
if (rc == 0)
{
rgName = rgP->getRecoveryGroupName();
rc = getRecoveryGroupDeclusteredArrays(rgP); // refresh da info
if (rc == 0)
{
int l = 0;
int nDa = rgP->getRecoveryGroupDeclusterArrays();
bool allDaOK = true; // is all DA ok?
for(; l < nDa; l++)
{
daP = rgP->getDeclusteredArrayP(l);
if(daP == NULL)
{
msg = "da: ";
msg += Utils::int_to_char(tmp,10,(unsigned int*)&l);
msg += "in (rg: ";
msg += rgName;
msg += ") is NULL";
log_error(msg);
continue;
}
daName = daP->getDeclusteredArrayName();
msg = "Refresh da: ";
msg += daName;
msg += " in rg: ";
msg += rgName;
log_debug(msg);
ret = refreshDa(daP, clusterid, rgName);
if(ret != TEAL_SUCCESS)
{
msg = "Refresh declustered array: ";
msg += daName;
msg += " in (rg: ";
msg += rgName;
msg += ") failed with ";
msg += Utils::int_to_char(tmp,10,(unsigned int*)&ret);
log_error(msg);
}
int j = 0;
int k = 0;
nPdisk = daP->getDeclusteredArrayPdisks();
nVdisk = daP->getDeclusteredArrayVdisks();
for(; j < nPdisk; j++)
{
pdiskP = daP->getDeclusteredArrayPdiskP(j);
if(pdiskP == NULL)
{
msg = "pdisk: ";
msg += Utils::int_to_char(tmp,10,(unsigned int*)&j);
msg += " in (rg: ";
msg += rgName;
msg += ", da: ";
msg += daName;
msg += ") is NULL";
log_error(msg);
continue;
}
pdiskName = pdiskP->getPdiskName();
msg = "Refresh pdisk: ";
msg += pdiskName;
msg += " in (rg: ";
msg += rgName;
msg += ", da: ";
msg += daName;
msg += ")";
log_debug(msg);
ret = refreshPdisk(pdiskP,clusterid,rgName,daName);
if(ret != TEAL_SUCCESS)
{
msg = "Refresh pdisk: ";
msg += pdiskName;
msg += " in (rg: ";
msg += rgName;
msg += ", da: ";
msg += daName;
msg += Utils::int_to_char(tmp,10,(unsigned int*)&ret);
log_error(msg);
}
}
for(; k < nVdisk; k++)
{
vdiskP = daP->getDeclusteredArrayVdiskP(k);
if(vdiskP == NULL)
{
msg = "vdisk: ";
msg += Utils::int_to_char(tmp,10,(unsigned int*)&k);
msg += " in (rg: ";
msg += rgName;
msg += ", da: ";
msg += daName;
msg += ") is NULL";
log_error(msg);
continue;
}
vdiskName = vdiskP->getVdiskName();
msg = "Refresh vdisk: ";
msg += vdiskName;
msg += " in (rg: ";
msg += rgName;
msg += ", da: ";
msg += daName;
log_debug(msg);
ret = refreshVdisk(vdiskP,clusterid,rgName,daName);
if(ret != TEAL_SUCCESS)
{
msg = "Refresh vdisk: ";
msg += vdiskName;
msg += " in (rg: ";
msg += rgName;
msg += ", da: ";
msg += daName;
msg += ") failed with ";
msg += Utils::int_to_char(tmp,10,(unsigned int*)&ret);
log_error(msg);
}
}
allDaOK &= strcmp(daP->getDeclusteredNeedsService(),"yes"); // check all DA's status
}
msg = "Refresh rg: ";
msg += rgName;
log_debug(msg);
ret = refreshRg(rgP, clusterid,allDaOK);
if(ret != TEAL_SUCCESS)
{
msg = "Refresh recovery group: ";
msg += rgName;
msg += " failed with ";
msg += Utils::int_to_char(tmp,10,(unsigned int*)&ret);
log_error(msg);
}
}
else
{
msg = "get DA to refresh DA in RG: ";
msg += rgName;
msg += " failed with ";
msg += Utils::int_to_char(tmp,10,(unsigned int*)&rc);
log_warn(msg);
continue;
}
}
else
{
msg = "get RG summary to refresh RG: ";
msg += Utils::int_to_char(tmp,10,(unsigned int*)&i);
msg += " failed with ";
msg += Utils::int_to_char(tmp,10,(unsigned int*)&rc);
log_warn(msg);
continue;
}
}
}
else
{
log_warn("No recovery group found!");
}
}
else if(rc == ENODEV)
{
msg = "No perseus configuration..";
log_info(msg);
}
else
{
msg = "Failed to getNsdRAIDSdrInfo with ";
msg += Utils::int_to_char(tmp,10,(unsigned int*)&rc);
log_warn(msg);
}
log_info("########################End of refresh all entities#########################################");
return;
}
