int BackupStoreAccountsControl::HousekeepAccountNow(int32_t ID)
{
std::string rootDir;
int discSetNum;
std::auto_ptr<UnixUser> user; // used to reset uid when we return
if(!OpenAccount(ID, rootDir, discSetNum, user,
NULL /* housekeeping locks the account itself */))
{
BOX_ERROR("Failed to open account " << BOX_FORMAT_ACCOUNT(ID)
<< " for housekeeping.");
return 1;
}
HousekeepStoreAccount housekeeping(ID, rootDir, discSetNum, NULL);
bool success = housekeeping.DoHousekeeping();
if(!success)
{
BOX_ERROR("Failed to lock account " << BOX_FORMAT_ACCOUNT(ID)
<< " for housekeeping: perhaps a client is "
"still connected?");
return 1;
}
else
{
BOX_TRACE("Finished housekeeping on account " <<
BOX_FORMAT_ACCOUNT(ID));
return 0;
}
}
int BackupStoreAccountsControl::SetAccountName(int32_t ID, const std::string& rNewAccountName)
{
std::string rootDir;
int discSetNum;
std::auto_ptr<UnixUser> user; // used to reset uid when we return
NamedLock writeLock;
if(!OpenAccount(ID, rootDir, discSetNum, user, &writeLock))
{
BOX_ERROR("Failed to open account " << BOX_FORMAT_ACCOUNT(ID)
<< " to change name.");
return 1;
}
// Load the info
std::auto_ptr<BackupStoreInfo> info(BackupStoreInfo::Load(ID,
rootDir, discSetNum, false /* Read/Write */));
info->SetAccountName(rNewAccountName);
// Save
info->Save();
BOX_NOTICE("Account " << BOX_FORMAT_ACCOUNT(ID) <<
" name changed to " << rNewAccountName);
return 0;
}
int BackupStoreAccountsControl::CheckAccount(int32_t ID, bool FixErrors, bool Quiet,
bool ReturnNumErrorsFound)
{
std::string rootDir;
int discSetNum;
std::auto_ptr<UnixUser> user; // used to reset uid when we return
NamedLock writeLock;
if(!OpenAccount(ID, rootDir, discSetNum, user,
FixErrors ? &writeLock : NULL)) // don't need a write lock if not making changes
{
BOX_ERROR("Failed to open account " << BOX_FORMAT_ACCOUNT(ID)
<< " for checking.");
return 1;
}
// Check it
BackupStoreCheck check(rootDir, discSetNum, ID, FixErrors, Quiet);
check.Check();
if(ReturnNumErrorsFound)
{
return check.GetNumErrorsFound();
}
else
{
return check.ErrorsFound() ? 1 : 0;
}
}
int BackupStoreAccountsControl::SetLimit(int32_t ID, const char *SoftLimitStr,
const char *HardLimitStr)
{
std::string rootDir;
int discSetNum;
std::auto_ptr<UnixUser> user; // used to reset uid when we return
NamedLock writeLock;
if(!OpenAccount(ID, rootDir, discSetNum, user, &writeLock))
{
BOX_ERROR("Failed to open account " << BOX_FORMAT_ACCOUNT(ID)
<< " to change limits.");
return 1;
}
// Load the info
std::auto_ptr<BackupStoreInfo> info(BackupStoreInfo::Load(ID, rootDir,
discSetNum, false /* Read/Write */));
// Change the limits
int blocksize = BlockSizeOfDiscSet(discSetNum);
int64_t softlimit = SizeStringToBlocks(SoftLimitStr, blocksize);
int64_t hardlimit = SizeStringToBlocks(HardLimitStr, blocksize);
CheckSoftHardLimits(softlimit, hardlimit);
info->ChangeLimits(softlimit, hardlimit);
// Save
info->Save();
BOX_NOTICE("Limits on account " << BOX_FORMAT_ACCOUNT(ID) <<
" changed to " << softlimit << " soft, " <<
hardlimit << " hard.");
return 0;
}
void Application::Admin_select()
{
y -= 3;
ClientData data; // 고객 정보 임시 저장장소
account temp; // 계좌 임시 저장소
switch(y)
{
case 1:
data.GetClientData(); // 고객 정보 입력
m_ClientList.InsertItem(data); // 고객 추가 함수
data.PutClientData(); // 고객 정부 화면 출력
break;
case 2:
DeleteClient(); // 고객 리스트 제거 함수
break;
case 3:
if(!SearchList(data)) // 고객 검색
break;
data.PutClientData(); // 고객정보 화면에 띄우기
break;
case 4:
OpenAccount(); // 계좌 열기
break;
case 5:
if(!SearchList(data)) // 고객 검색
break;
data.CloseAccount();
break;
case 6:
return;
}
}
// SendCommand
// Pops up a Custinfo dialog or sends an exit command to Custinfo
// Assumptions:
// Custinfo is running. For a dialog, either the account is
// specified in the call or the correct account is already open in
// Custinfo.
// Returns:
// TRUE if able to post the message.
// FALSE if failed to post the message.
// Error messages:
// Internal error message when function returns FALSE.
// Side affects:
// Pops up a Custinfo dialog or exits Custinfo.
BOOL CCustinfoDriverApp::SendCommand(CArborCommandLineInfo::Flag flag)
{
UINT message;
if (flag == CArborCommandLineInfo::dialog)
{
if (!m_CmdInfo.m_sAccountid.IsEmpty() && !OpenAccount())
{
return FALSE;
}
message = GetDialogMessage();
}
else if (flag == CArborCommandLineInfo::exit)
{
message = ci_ipc::uAPP_EXIT;
}
else
{
ErrorMessage(__FILE__, __LINE__, "Unknown command.");
return FALSE;
}
if (!ci_ipc::FindCustInfo())
{
if (flag != CArborCommandLineInfo::exit)
{
if (m_CmdInfo.m_sUsermessage.IsEmpty())
{
UserMessage(m_sUsermessage);
}
else
{
UserMessage(m_CmdInfo.m_sUsermessage);
}
}
return FALSE;
}
if (!ci_ipc::DoIPC(message))
{
if (flag != CArborCommandLineInfo::exit)
{
ErrorMessage(__FILE__, __LINE__, "Unable to process request.");
}
return FALSE;
}
return TRUE;
}
int BackupStoreAccountsControl::SetAccountEnabled(int32_t ID, bool enabled)
{
std::string rootDir;
int discSetNum;
std::auto_ptr<UnixUser> user; // used to reset uid when we return
NamedLock writeLock;
if(!OpenAccount(ID, rootDir, discSetNum, user, &writeLock))
{
BOX_ERROR("Failed to open account " << BOX_FORMAT_ACCOUNT(ID)
<< " to change enabled flag.");
return 1;
}
// Load it in
std::auto_ptr<BackupStoreInfo> info(BackupStoreInfo::Load(ID,
rootDir, discSetNum, false /* ReadOnly */));
info->SetAccountEnabled(enabled);
info->Save();
return 0;
}
int BackupStoreAccountsControl::PrintAccountInfo(int32_t ID)
{
std::string rootDir;
int discSetNum;
std::auto_ptr<UnixUser> user; // used to reset uid when we return
if(!OpenAccount(ID, rootDir, discSetNum, user,
NULL /* no write lock needed for this read-only operation */))
{
BOX_ERROR("Failed to open account " << BOX_FORMAT_ACCOUNT(ID)
<< " to display info.");
return 1;
}
// Load it in
std::auto_ptr<BackupStoreInfo> info(BackupStoreInfo::Load(ID,
rootDir, discSetNum, true /* ReadOnly */));
return BackupAccountControl::PrintAccountInfo(*info,
BlockSizeOfDiscSet(discSetNum));
}
int BackupStoreAccountsControl::DeleteAccount(int32_t ID, bool AskForConfirmation)
{
std::string rootDir;
int discSetNum;
std::auto_ptr<UnixUser> user; // used to reset uid when we return
NamedLock writeLock;
// Obtain a write lock, as the daemon user
if(!OpenAccount(ID, rootDir, discSetNum, user, &writeLock))
{
BOX_ERROR("Failed to open account " << BOX_FORMAT_ACCOUNT(ID)
<< " for deletion.");
return 1;
}
// Check user really wants to do this
if(AskForConfirmation)
{
BOX_WARNING("Really delete account " <<
BOX_FORMAT_ACCOUNT(ID) << "? (type 'yes' to confirm)");
char response[256];
if(::fgets(response, sizeof(response), stdin) == 0 || ::strcmp(response, "yes\n") != 0)
{
BOX_NOTICE("Deletion cancelled.");
return 0;
}
}
// Back to original user, but write lock is maintained
user.reset();
std::auto_ptr<BackupStoreAccountDatabase> db(
BackupStoreAccountDatabase::Read(
mConfig.GetKeyValue("AccountDatabase")));
// Delete from account database
db->DeleteEntry(ID);
// Write back to disc
db->Write();
// Remove the store files...
// First, become the user specified in the config file
std::string username;
{
const Configuration &rserverConfig(mConfig.GetSubConfiguration("Server"));
if(rserverConfig.KeyExists("User"))
{
username = rserverConfig.GetKeyValue("User");
}
}
// Become the right user
if(!username.empty())
{
// Username specified, change...
user.reset(new UnixUser(username));
user->ChangeProcessUser(true /* temporary */);
// Change will be undone when user goes out of scope
}
// Secondly, work out which directories need wiping
std::vector<std::string> toDelete;
RaidFileController &rcontroller(RaidFileController::GetController());
RaidFileDiscSet discSet(rcontroller.GetDiscSet(discSetNum));
for(RaidFileDiscSet::const_iterator i(discSet.begin()); i != discSet.end(); ++i)
{
if(std::find(toDelete.begin(), toDelete.end(), *i) == toDelete.end())
{
toDelete.push_back((*i) + DIRECTORY_SEPARATOR + rootDir);
}
}
// NamedLock will throw an exception if it can't delete the lockfile,
// which it can't if it doesn't exist. Now that we've deleted the account,
// nobody can open it anyway, so it's safe to unlock.
writeLock.ReleaseLock();
int retcode = 0;
// Thirdly, delete the directories...
for(std::vector<std::string>::const_iterator d(toDelete.begin()); d != toDelete.end(); ++d)
{
BOX_NOTICE("Deleting store directory " << (*d) << "...");
// Just use the rm command to delete the files
std::string cmd("rm -rf ");
cmd += *d;
// Run command
if(::system(cmd.c_str()) != 0)
{
BOX_ERROR("Failed to delete files in " << (*d) <<
", delete them manually.");
retcode = 1;
}
}
// Success!
return retcode;
}
BOOL CCustinfoDriverApp::InitInstance()
{
InitArborLocale();
// Parse and validate command line
ParseCommandLine(m_CmdInfo);
if (ValidateCommandLine())
{
BOOL continue_processing = TRUE;
// Process command line instructions
if (m_CmdInfo.m_sApplication.IsEmpty() &&
m_CmdInfo.m_sDialog.IsEmpty() &&
m_CmdInfo.m_sAccountid.IsEmpty() &&
!m_CmdInfo.m_bExit)
{
ErrorMessage(__FILE__, __LINE__, "Unknown command.");
continue_processing = FALSE;
}
// Exit the Application
if (m_CmdInfo.m_bExit)
{
int count = 0;
while (count++ < 100 && ci_ipc::FindCustInfo())
{
continue_processing = SendCommand(CArborCommandLineInfo::exit);
Sleep(500);
}
if (count >= 100)
{
continue_processing = FALSE;
}
}
// Start Application
if (continue_processing && !m_CmdInfo.m_sApplication.IsEmpty())
{
if (m_CmdInfo.m_sApplication == m_sAppNames[custinfo])
{
if (!ci_ipc::FindCustInfo())
{
// Only attempt to start the app if its not already running.
continue_processing = StartApp();
// Wait for us to Find the application before continuing.
if (continue_processing)
{
int count = 0;
while (count++ < 100 && !ci_ipc::FindCustInfo())
{
Sleep(500);
}
if (count >= 100)
{
continue_processing = FALSE;
}
else
{
Sleep(1000);
}
}
}
}
else
{
continue_processing = StartApp();
}
}
// Open Account
if (continue_processing && !m_CmdInfo.m_sAccountid.IsEmpty())
{
continue_processing = OpenAccount();
}
// Switch to a Specific Dialog
if (continue_processing && !m_CmdInfo.m_sDialog.IsEmpty())
{
continue_processing = SendCommand(CArborCommandLineInfo::dialog);
}
}
DeleteArborLocale();
return TRUE;
}
