int
purge( osg::ArgumentParser& args )
{
osg::ref_ptr<osg::Node> node = osgDB::readNodeFiles( args );
if ( !node.valid() )
return usage( "Failed to read .earth file." );
MapNode* mapNode = MapNode::findMapNode( node.get() );
if ( !mapNode )
return usage( "Input file was not a .earth file" );
Map* map = mapNode->getMap();
if ( !map->getCache() )
return message( "Earth file does not contain a cache." );
std::vector<Entry> entries;
ImageLayerVector imageLayers;
map->getLayers( imageLayers );
for( ImageLayerVector::const_iterator i = imageLayers.begin(); i != imageLayers.end(); ++i )
{
ImageLayer* layer = i->get();
bool useMFP =
layer->getProfile() &&
layer->getProfile()->getSRS()->isSphericalMercator() &&
mapNode->getMapNodeOptions().getTerrainOptions().enableMercatorFastPath() == true;
const Profile* cacheProfile = useMFP ? layer->getProfile() : map->getProfile();
CacheSettings* cacheSettings = layer->getCacheSettings();
if (cacheSettings)
{
CacheBin* bin = cacheSettings->getCacheBin();
if ( bin )
{
entries.push_back(Entry());
entries.back()._isImage = true;
entries.back()._name = i->get()->getName();
entries.back()._bin = bin;
}
}
}
ElevationLayerVector elevationLayers;
map->getLayers( elevationLayers );
for( ElevationLayerVector::const_iterator i = elevationLayers.begin(); i != elevationLayers.end(); ++i )
{
ElevationLayer* layer = i->get();
bool useMFP =
layer->getProfile() &&
layer->getProfile()->getSRS()->isSphericalMercator() &&
mapNode->getMapNodeOptions().getTerrainOptions().enableMercatorFastPath() == true;
const Profile* cacheProfile = useMFP ? layer->getProfile() : map->getProfile();
CacheSettings* cacheSettings = layer->getCacheSettings();
if (cacheSettings)
{
CacheBin* bin = cacheSettings->getCacheBin();
if (bin)
{
entries.push_back(Entry());
entries.back()._isImage = false;
entries.back()._name = i->get()->getName();
entries.back()._bin = bin;
}
}
}
if ( entries.size() > 0 )
{
std::cout << std::endl;
for( unsigned i=0; i<entries.size(); ++i )
{
std::cout << (i+1) << ") " << entries[i]._name << " (" << (entries[i]._isImage? "image" : "elevation" ) << ")" << std::endl;
}
std::cout
<< std::endl
<< "Enter number of cache to purge, or <enter> to quit: "
<< std::flush;
std::string input;
std::getline( std::cin, input );
if ( !input.empty() )
{
unsigned k = as<unsigned>(input, 0L);
if ( k > 0 && k <= entries.size() )
{
Config meta = entries[k-1]._bin->readMetadata();
if ( !meta.empty() )
{
std::cout
<< std::endl
<< "Cache METADATA:" << std::endl
<< meta.toJSON()
<< std::endl << std::endl;
}
std::cout
<< "Are you sure (y/N)? "
<< std::flush;
std::getline( std::cin, input );
if ( input == "y" || input == "Y" )
{
std::cout << "Purging.." << std::flush;
entries[k-1]._bin->clear();
}
else
{
std::cout << "No action taken." << std::endl;
}
}
else
{
std::cout << "Invalid choice." << std::endl;
}
}
else
{
std::cout << "No action taken." << std::endl;
}
}
return 0;
}
virtual ReadResult readNode(std::istream& in, const osgDB::Options* readOptions) const
{
// pull the URI context from the options structure (since we're reading
// from an "anonymous" stream here)
URIContext uriContext( readOptions );
osg::ref_ptr<XmlDocument> doc = XmlDocument::load( in, uriContext );
if ( !doc.valid() )
return ReadResult::ERROR_IN_READING_FILE;
Config docConf = doc->getConfig();
// support both "map" and "earth" tag names at the top level
Config conf;
if ( docConf.hasChild( "map" ) )
conf = docConf.child( "map" );
else if ( docConf.hasChild( "earth" ) )
conf = docConf.child( "earth" );
osg::ref_ptr<osg::Node> node;
if ( !conf.empty() )
{
// see if we were given a reference URI to use:
std::string refURI = uriContext.referrer();
if ( conf.value("version") == "1" )
{
OE_INFO << LC << "Detected a version 1.x earth file" << std::endl;
EarthFileSerializer1 ser;
node = ser.deserialize( conf, refURI );
}
else
{
if ( conf.value("version") != "2" )
OE_DEBUG << LC << "No valid earth file version; assuming version='2'" << std::endl;
// attempt to parse a "default options" JSON string:
std::string defaultConfStr;
if ( readOptions )
{
defaultConfStr = readOptions->getPluginStringData("osgEarth.defaultOptions");
if ( !defaultConfStr.empty() )
{
Config optionsConf("options");
if (optionsConf.fromJSON(defaultConfStr))
{
//OE_NOTICE << "\n\nOriginal = \n" << conf.toJSON(true) << "\n";
Config* original = conf.mutable_child("options");
if ( original )
{
recursiveUniqueKeyMerge(optionsConf, *original);
}
if ( !optionsConf.empty() )
{
conf.set("options", optionsConf);
}
//OE_NOTICE << "\n\nMerged = \n" << conf.toJSON(true) << "\n";
}
}
}
EarthFileSerializer2 ser;
node = ser.deserialize( conf, refURI );
}
}
MapNode* mapNode = MapNode::get(node.get());
if (mapNode)
{
// If the user passed in a cache object, apply it to the map now
CacheSettings* cacheSettings = CacheSettings::get(readOptions);
if (cacheSettings && cacheSettings->getCache())
{
mapNode->getMap()->setCache( cacheSettings->getCache() );
OE_INFO << LC << "Applied user-supplied cache to the Map\n";
}
}
return ReadResult(node.get());
}
CacheBin*
TerrainLayer::getCacheBin(const Profile* profile)
{
if ( !_openCalled )
{
OE_WARN << LC << "Illegal- called getCacheBin() before layer is open.. did you call open()?\n";
return 0L;
}
CacheSettings* cacheSettings = getCacheSettings();
if (!cacheSettings)
return 0L;
if (cacheSettings->cachePolicy()->isCacheDisabled())
return 0L;
CacheBin* bin = cacheSettings->getCacheBin();
if (!bin)
return 0L;
// does the metadata need initializing?
std::string metaKey = getMetadataKey(profile);
Threading::ScopedMutexLock lock(_mutex);
CacheBinMetadataMap::iterator i = _cacheBinMetadata.find(metaKey);
if (i == _cacheBinMetadata.end())
{
//std::string cacheId = _runtimeOptions->cacheId().get();
// read the metadata record from the cache bin:
ReadResult rr = bin->readString(metaKey, _readOptions.get());
osg::ref_ptr<CacheBinMetadata> meta;
bool metadataOK = false;
if (rr.succeeded())
{
// Try to parse the metadata record:
Config conf;
conf.fromJSON(rr.getString());
meta = new CacheBinMetadata(conf);
if (meta->isOK())
{
metadataOK = true;
// verify that the cache if compatible with the open tile source:
if ( getTileSource() && getProfile() )
{
//todo: check the profile too
if ( meta->_sourceDriver.get() != getTileSource()->getOptions().getDriver() )
{
OE_WARN << LC
<< "Layer \"" << getName() << "\" is requesting a \""
<< getTileSource()->getOptions().getDriver() << "\" cache, but a \""
<< meta->_sourceDriver.get() << "\" cache exists at the specified location. "
<< "The cache will ignored for this layer.\n";
cacheSettings->cachePolicy() = CachePolicy::NO_CACHE;
return 0L;
}
}
// if not, see if we're in cache-only mode and still need a profile:
else if (cacheSettings->cachePolicy()->isCacheOnly() && !_profile.valid())
{
// in cacheonly mode, create a profile from the first cache bin accessed
// (they SHOULD all be the same...)
setProfile( Profile::create(meta->_sourceProfile.get()) );
_tileSize = meta->_sourceTileSize.get();
}
bin->setMetadata(meta.get());
}
else
{
OE_WARN << LC << "Metadata appears to be corrupt.\n";
}
}
if (!metadataOK)
{
// cache metadata does not exist, so try to create it.
if ( getProfile() )
{
meta = new CacheBinMetadata();
// no existing metadata; create some.
meta->_cacheBinId = _runtimeCacheId;
meta->_sourceName = this->getName();
meta->_sourceTileSize = getTileSize();
meta->_sourceProfile = getProfile()->toProfileOptions();
meta->_cacheProfile = profile->toProfileOptions();
meta->_cacheCreateTime = DateTime().asTimeStamp();
meta->_dataExtents = getDataExtents();
if (getTileSource())
{
meta->_sourceDriver = getTileSource()->getOptions().getDriver();
}
// store it in the cache bin.
std::string data = meta->getConfig().toJSON(false);
osg::ref_ptr<StringObject> temp = new StringObject(data);
bin->write(metaKey, temp.get(), _readOptions.get());
bin->setMetadata(meta.get());
}
else if ( cacheSettings->cachePolicy()->isCacheOnly() )
{
disable(Stringify() <<
"Failed to open a cache for layer "
"because cache_only policy is in effect and bin [" << _runtimeCacheId << "] "
"could not be located.");
return 0L;
}
else
{
OE_WARN << LC <<
"Failed to create cache bin [" << _runtimeCacheId << "] "
"because there is no valid profile."
<< std::endl;
cacheSettings->cachePolicy() = CachePolicy::NO_CACHE;
return 0L;
}
}
// If we loaded a profile from the cache metadata, apply the overrides:
applyProfileOverrides();
if (meta.valid())
{
_cacheBinMetadata[metaKey] = meta.get();
OE_DEBUG << LC << "Established metadata for cache bin [" << _runtimeCacheId << "]" << std::endl;
}
}
return bin;
}
