struct Failure
{
SGPath path;
- AbstractRepository::ResultCode error;
+ HTTPRepository::ResultCode error;
};
typedef std::vector<Failure> FailureList;
hashCacheDirty(false),
p(parent),
isUpdating(false),
- status(AbstractRepository::REPO_NO_ERROR),
+ status(HTTPRepository::REPO_NO_ERROR),
totalDownloaded(0)
{ ; }
std::string baseUrl;
SGPath basePath;
bool isUpdating;
- AbstractRepository::ResultCode status;
+ HTTPRepository::ResultCode status;
HTTPDirectory* rootDir;
size_t totalDownloaded;
std::string computeHashForPath(const SGPath& p);
void writeHashCache();
- void failedToGetRootIndex(AbstractRepository::ResultCode st);
+ void failedToGetRootIndex(HTTPRepository::ResultCode st);
void failedToUpdateChild(const SGPath& relativePath,
- AbstractRepository::ResultCode fileStatus);
+ HTTPRepository::ResultCode fileStatus);
typedef std::vector<RepoRequestPtr> RequestVector;
RequestVector queuedRequests,
std::sort(children.begin(), children.end());
}
- void failedToUpdate(AbstractRepository::ResultCode status)
+ void failedToUpdate(HTTPRepository::ResultCode status)
{
if (_relativePath.isNull()) {
// root dir failed
fpath.append(file);
if (it->hash != hash) {
- _repository->failedToUpdateChild(_relativePath, AbstractRepository::REPO_ERROR_CHECKSUM);
+ _repository->failedToUpdateChild(_relativePath, HTTPRepository::REPO_ERROR_CHECKSUM);
} else {
_repository->updatedFileContents(fpath, hash);
_repository->totalDownloaded += sz;
}
void didFailToUpdateFile(const std::string& file,
- AbstractRepository::ResultCode status)
+ HTTPRepository::ResultCode status)
{
SGPath fpath(_relativePath);
fpath.append(file);
return result;
}
-AbstractRepository::ResultCode
+HTTPRepository::ResultCode
HTTPRepository::failure() const
{
if ((_d->status == REPO_NO_ERROR) && !_d->failures.empty()) {
virtual void gotBodyData(const char* s, int n)
{
if (!file.get()) {
- file.reset(new SGFile(pathInRepo.str()));
+ file.reset(new SGBinaryFile(pathInRepo.str()));
if (!file->open(SG_IO_OUT)) {
SG_LOG(SG_TERRASYNC, SG_WARN, "unable to create file " << pathInRepo);
_directory->repository()->http->cancelRequest(this, "Unable to create output file");
SG_LOG(SG_TERRASYNC, SG_DEBUG, "got file " << fileName << " in " << _directory->absolutePath());
} else if (responseCode() == 404) {
SG_LOG(SG_TERRASYNC, SG_WARN, "terrasync file not found on server: " << fileName << " for " << _directory->absolutePath());
- _directory->didFailToUpdateFile(fileName, AbstractRepository::REPO_ERROR_FILE_NOT_FOUND);
+ _directory->didFailToUpdateFile(fileName, HTTPRepository::REPO_ERROR_FILE_NOT_FOUND);
} else {
SG_LOG(SG_TERRASYNC, SG_WARN, "terrasync file download error on server: " << fileName << " for " << _directory->absolutePath() << ": " << responseCode() );
- _directory->didFailToUpdateFile(fileName, AbstractRepository::REPO_ERROR_HTTP);
+ _directory->didFailToUpdateFile(fileName, HTTPRepository::REPO_ERROR_HTTP);
}
_directory->repository()->finishedRequest(this);
}
if (_directory) {
- _directory->didFailToUpdateFile(fileName, AbstractRepository::REPO_ERROR_SOCKET);
+ _directory->didFailToUpdateFile(fileName, HTTPRepository::REPO_ERROR_SOCKET);
_directory->repository()->finishedRequest(this);
}
}
std::string fileName; // if empty, we're getting the directory itself
SGPath pathInRepo;
simgear::sha1nfo hashContext;
- std::auto_ptr<SGFile> file;
+ std::auto_ptr<SGBinaryFile> file;
};
class DirGetRequest : public HTTPRepoGetRequest
if (responseCode() == 200) {
std::string hash = strutils::encodeHex(sha1_result(&hashContext), HASH_LENGTH);
if (!_targetHash.empty() && (hash != _targetHash)) {
- _directory->failedToUpdate(AbstractRepository::REPO_ERROR_CHECKSUM);
+ _directory->failedToUpdate(HTTPRepository::REPO_ERROR_CHECKSUM);
_directory->repository()->finishedRequest(this);
return;
}
_directory->updateChildrenBasedOnHash();
SG_LOG(SG_TERRASYNC, SG_INFO, "after update of:" << _directory->absolutePath() << " child update took:" << st.elapsedMSec());
} catch (sg_exception& ) {
- _directory->failedToUpdate(AbstractRepository::REPO_ERROR_IO);
+ _directory->failedToUpdate(HTTPRepository::REPO_ERROR_IO);
}
} else if (responseCode() == 404) {
- _directory->failedToUpdate(AbstractRepository::REPO_ERROR_FILE_NOT_FOUND);
+ _directory->failedToUpdate(HTTPRepository::REPO_ERROR_FILE_NOT_FOUND);
} else {
- _directory->failedToUpdate(AbstractRepository::REPO_ERROR_HTTP);
+ _directory->failedToUpdate(HTTPRepository::REPO_ERROR_HTTP);
}
_directory->repository()->finishedRequest(this);
virtual void onFail()
{
if (_directory) {
- _directory->failedToUpdate(AbstractRepository::REPO_ERROR_SOCKET);
+ _directory->failedToUpdate(HTTPRepository::REPO_ERROR_SOCKET);
_directory->repository()->finishedRequest(this);
}
}
sha1_init(&info);
char* buf = static_cast<char*>(malloc(1024 * 1024));
size_t readLen;
- SGFile f(p.str());
+ SGBinaryFile f(p.str());
if (!f.open(SG_IO_IN)) {
throw sg_io_exception("Couldn't open file for compute hash", p);
}
}
}
- void HTTPRepoPrivate::failedToGetRootIndex(AbstractRepository::ResultCode st)
+ void HTTPRepoPrivate::failedToGetRootIndex(HTTPRepository::ResultCode st)
{
SG_LOG(SG_TERRASYNC, SG_WARN, "Failed to get root of repo:" << baseUrl);
status = st;
}
void HTTPRepoPrivate::failedToUpdateChild(const SGPath& relativePath,
- AbstractRepository::ResultCode fileStatus)
+ HTTPRepository::ResultCode fileStatus)
{
Failure f;
f.path = relativePath;