// realwx_ctrl.cxx -- Process real weather data
//
// Written by David Megginson, started February 2002.
-// Rewritten by Torsten Dreyer, August 2010
+// Rewritten by Torsten Dreyer, August 2010, August 2011
//
// Copyright (C) 2002 David Megginson - david@megginson.com
//
#endif
#include "realwx_ctrl.hxx"
-#include "metarproperties.hxx"
-#include "metarairportfilter.hxx"
-#include "fgmetar.hxx"
-
-#include <Main/fg_props.hxx>
+#include <algorithm>
#include <boost/foreach.hpp>
+#include <boost/algorithm/string/case_conv.hpp>
#include <simgear/structure/exception.hxx>
#include <simgear/misc/strutils.hxx>
#include <simgear/props/tiedpropertylist.hxx>
-#include <simgear/io/HTTPClient.hxx>
-#include <simgear/io/HTTPRequest.hxx>
+#include <simgear/io/HTTPMemoryRequest.hxx>
#include <simgear/timing/sg_time.hxx>
+#include <simgear/structure/event_mgr.hxx>
+#include <simgear/structure/commands.hxx>
-#include <algorithm>
-
-using simgear::PropertyList;
+#include "metarproperties.hxx"
+#include "metarairportfilter.hxx"
+#include "fgmetar.hxx"
+#include <Network/HTTPClient.hxx>
+#include <Main/fg_props.hxx>
namespace Environment {
+
+/* -------------------------------------------------------------------------------- */
+
+class MetarRequester;
+
/* -------------------------------------------------------------------------------- */
class LiveMetarProperties : public MetarProperties {
public:
- LiveMetarProperties( SGPropertyNode_ptr rootNode );
+ LiveMetarProperties( SGPropertyNode_ptr rootNode, MetarRequester * metarRequester, int maxAge );
virtual ~LiveMetarProperties();
virtual void update( double dt );
virtual double getTimeToLive() const { return _timeToLive; }
- virtual void setTimeToLive( double value ) { _timeToLive = value; }
+ virtual void resetTimeToLive()
+ { _timeToLive = 0.00; _pollingTimer = 0.0; }
+
+ // implementation of MetarDataHandler
+ virtual void handleMetarData( const std::string & data );
+ virtual void handleMetarFailure();
+
+ static const unsigned MAX_POLLING_INTERVAL_SECONDS = 10;
+ static const unsigned DEFAULT_TIME_TO_LIVE_SECONDS = 900;
+
private:
double _timeToLive;
-
+ double _pollingTimer;
+ MetarRequester * _metarRequester;
+ int _maxAge;
+ bool _failure;
};
typedef SGSharedPtr<LiveMetarProperties> LiveMetarProperties_ptr;
-LiveMetarProperties::LiveMetarProperties( SGPropertyNode_ptr rootNode ) :
+class MetarRequester {
+public:
+ virtual void requestMetar( LiveMetarProperties_ptr metarDataHandler, const std::string & id ) = 0;
+};
+
+
+LiveMetarProperties::LiveMetarProperties( SGPropertyNode_ptr rootNode, MetarRequester * metarRequester, int maxAge ) :
MetarProperties( rootNode ),
- _timeToLive(0.0)
+ _timeToLive(0.0),
+ _pollingTimer(0.0),
+ _metarRequester(metarRequester),
+ _maxAge(maxAge),
+ _failure(false)
{
_tiedProperties.Tie("time-to-live", &_timeToLive );
+ _tiedProperties.Tie("failure", &_failure);
}
LiveMetarProperties::~LiveMetarProperties()
void LiveMetarProperties::update( double dt )
{
_timeToLive -= dt;
- if( _timeToLive < 0.0 ) _timeToLive = 0.0;
+ _pollingTimer -= dt;
+ if( _timeToLive <= 0.0 ) {
+ _timeToLive = 0.0;
+ invalidate();
+ std::string stationId = getStationId();
+ if( stationId.empty() ) return;
+ if( _pollingTimer > 0.0 ) return;
+ _metarRequester->requestMetar( this, stationId );
+ _pollingTimer = MAX_POLLING_INTERVAL_SECONDS;
+ }
+}
+
+void LiveMetarProperties::handleMetarData( const std::string & data )
+{
+ SG_LOG( SG_ENVIRONMENT, SG_DEBUG, "LiveMetarProperties::handleMetarData() received METAR for " << getStationId() << ": " << data );
+ _timeToLive = DEFAULT_TIME_TO_LIVE_SECONDS;
+
+ SGSharedPtr<FGMetar> m;
+ try {
+ m = new FGMetar(data.c_str());
+ }
+ catch( sg_io_exception &) {
+ SG_LOG( SG_ENVIRONMENT, SG_WARN, "Can't parse metar: " << data );
+ _failure = true;
+ return;
+ }
+
+ if (_maxAge && (m->getAge_min() > _maxAge)) {
+ // METAR is older than max-age, ignore
+ SG_LOG( SG_ENVIRONMENT, SG_DEBUG, "Ignoring outdated METAR for " << getStationId());
+ return;
+ }
+
+ _failure = false;
+ setMetar( m );
}
+void LiveMetarProperties::handleMetarFailure()
+{
+ _failure = true;
+}
+
/* -------------------------------------------------------------------------------- */
class BasicRealWxController : public RealWxController
{
public:
- BasicRealWxController( SGPropertyNode_ptr rootNode );
+ BasicRealWxController( SGPropertyNode_ptr rootNode, MetarRequester * metarRequester );
virtual ~BasicRealWxController ();
virtual void init ();
virtual void reinit ();
+ virtual void shutdown ();
+
+ /**
+ * Create a metar-property binding at the specified property path,
+ * and initiate a request for the specified station-ID (which may be
+ * empty). If the property path is already mapped, the station ID
+ * will be updated.
+ */
+ void addMetarAtPath(const string& propPath, const string& icao);
+
+ void removeMetarAtPath(const string& propPath);
+ typedef std::vector<LiveMetarProperties_ptr> MetarPropertiesList;
+ MetarPropertiesList::iterator findMetarAtPath(const string &propPath);
protected:
void bind();
void unbind();
void update( double dt );
- virtual void update( bool first, double dt ) = 0;
+ void checkNearbyMetar();
long getMetarMaxAgeMin() const { return _max_age_n == NULL ? 0 : _max_age_n->getLongValue(); }
SGPropertyNode_ptr _rootNode;
- SGPropertyNode_ptr _longitude_n;
- SGPropertyNode_ptr _latitude_n;
SGPropertyNode_ptr _ground_elevation_n;
SGPropertyNode_ptr _max_age_n;
bool _enabled;
- bool __enabled;
+ bool _wasEnabled;
simgear::TiedPropertyList _tiedProperties;
- typedef std::vector<LiveMetarProperties_ptr> MetarPropertiesList;
MetarPropertiesList _metarProperties;
-
+ MetarRequester* _requester;
+
};
+static bool commandRequestMetar(const SGPropertyNode* arg)
+{
+ SGSubsystemGroup* envMgr = (SGSubsystemGroup*) globals->get_subsystem("environment");
+ if (!envMgr) {
+ return false;
+ }
+
+ BasicRealWxController* self = (BasicRealWxController*) envMgr->get_subsystem("realwx");
+ if (!self) {
+ return false;
+ }
+
+ string icao(arg->getStringValue("station"));
+ boost::to_upper(icao);
+ string path = arg->getStringValue("path");
+ self->addMetarAtPath(path, icao);
+ return true;
+}
+
+static bool commandClearMetar(const SGPropertyNode* arg)
+{
+ SGSubsystemGroup* envMgr = (SGSubsystemGroup*) globals->get_subsystem("environment");
+ if (!envMgr) {
+ return false;
+ }
+
+ BasicRealWxController* self = (BasicRealWxController*) envMgr->get_subsystem("realwx");
+ if (!self) {
+ return false;
+ }
+
+ string path = arg->getStringValue("path");
+ self->removeMetarAtPath(path);
+ return true;
+}
+
/* -------------------------------------------------------------------------------- */
/*
Properties
~/metar[1..n]: string Target property path for metar data
*/
-BasicRealWxController::BasicRealWxController( SGPropertyNode_ptr rootNode ) :
+BasicRealWxController::BasicRealWxController( SGPropertyNode_ptr rootNode, MetarRequester * metarRequester ) :
_rootNode(rootNode),
- _longitude_n( fgGetNode( "/position/longitude-deg", true )),
- _latitude_n( fgGetNode( "/position/latitude-deg", true )),
_ground_elevation_n( fgGetNode( "/position/ground-elev-m", true )),
_max_age_n( fgGetNode( "/environment/params/metar-max-age-min", false ) ),
_enabled(true),
- __enabled(false)
+ _wasEnabled(false),
+ _requester(metarRequester)
{
- // at least instantiate MetarProperties for /environment/metar
- _metarProperties.push_back( new LiveMetarProperties(
- fgGetNode( rootNode->getStringValue("metar", "/environment/metar"), true ) ) );
-
- PropertyList metars = rootNode->getChildren("metar");
- for( PropertyList::size_type i = 1; i < metars.size(); i++ ) {
- SG_LOG( SG_ENVIRONMENT, SG_INFO, "Adding metar properties at " << metars[i]->getStringValue() );
- _metarProperties.push_back( new LiveMetarProperties(
- fgGetNode( metars[i]->getStringValue(), true )));
- }
+
+ globals->get_commands()->addCommand("request-metar", commandRequestMetar);
+ globals->get_commands()->addCommand("clear-metar", commandClearMetar);
}
BasicRealWxController::~BasicRealWxController()
{
+ globals->get_commands()->removeCommand("request-metar");
+ globals->get_commands()->removeCommand("clear-metar");
}
void BasicRealWxController::init()
{
- __enabled = false;
+ _wasEnabled = false;
+
+ // at least instantiate MetarProperties for /environment/metar
+ SGPropertyNode_ptr metarNode = fgGetNode( _rootNode->getStringValue("metar", "/environment/metar"), true );
+ _metarProperties.push_back( new LiveMetarProperties(metarNode,
+ _requester,
+ getMetarMaxAgeMin()));
+
+ BOOST_FOREACH( SGPropertyNode_ptr n, _rootNode->getChildren("metar") ) {
+ SGPropertyNode_ptr metarNode = fgGetNode( n->getStringValue(), true );
+ addMetarAtPath(metarNode->getPath(), "");
+ }
+
+ checkNearbyMetar();
update(0); // fetch data ASAP
+
+ globals->get_event_mgr()->addTask("checkNearbyMetar", this,
+ &BasicRealWxController::checkNearbyMetar, 60 );
}
void BasicRealWxController::reinit()
{
- __enabled = false;
+ _wasEnabled = false;
+ checkNearbyMetar();
+ update(0); // fetch data ASAP
+}
+
+void BasicRealWxController::shutdown()
+{
+ globals->get_event_mgr()->removeTask("checkNearbyMetar");
}
void BasicRealWxController::bind()
}
void BasicRealWxController::update( double dt )
-{
+{
if( _enabled ) {
- bool firstIteration = !__enabled; // first iteration after being enabled?
-
+ bool firstIteration = !_wasEnabled;
// clock tick for every METAR in stock
- for( MetarPropertiesList::iterator it = _metarProperties.begin();
- it != _metarProperties.end(); it++ ) {
+ BOOST_FOREACH(LiveMetarProperties* p, _metarProperties) {
// first round? All received METARs are outdated
- if( firstIteration ) (*it)->setTimeToLive( 0.0 );
- (*it)->update(dt);
+ if( firstIteration ) p->resetTimeToLive();
+ p->update(dt);
}
- update( firstIteration, dt );
- __enabled = true;
+ _wasEnabled = true;
} else {
- __enabled = false;
+ _wasEnabled = false;
}
}
-/* -------------------------------------------------------------------------------- */
-
-class NoaaMetarRealWxController : public BasicRealWxController {
-public:
- NoaaMetarRealWxController( SGPropertyNode_ptr rootNode );
- virtual ~NoaaMetarRealWxController();
- virtual void update (bool first, double delta_time_sec);
- virtual void shutdown ();
-
- /**
- * callback from MetarGetRequest when a download succeeds
- */
- void gotMetar(const string& stationId, const string& metar);
-private:
- double _positionTimeToLive;
- double _requestTimer;
-
- simgear::HTTP::Client _http;
-};
-
-class MetarGetRequest : public simgear::HTTP::Request
+void BasicRealWxController::addMetarAtPath(const string& propPath, const string& icao)
{
-public:
- MetarGetRequest(NoaaMetarRealWxController* con, const string& s) :
- Request(""),
- stationId(s),
- fromProxy(false),
- wxController(con)
- {
- setUrl("http://weather.noaa.gov/pub/data/observations/metar/stations/" + stationId + ".TXT");
- }
-
- virtual string_list requestHeaders() const
- {
- string_list r;
- r.push_back("X-Time");
- return r;
+ // check for duplicate entries
+ MetarPropertiesList::iterator it = findMetarAtPath(propPath);
+ if( it != _metarProperties.end() ) {
+ SG_LOG( SG_ENVIRONMENT, SG_INFO, "Reusing metar properties at " << propPath << " for " << icao);
+ // already exists
+ if ((*it)->getStationId() != icao) {
+ (*it)->setStationId(icao);
+ (*it)->resetTimeToLive();
}
-
- virtual string header(const string& name) const
- {
- if (name == "X-Time") {
- char buf[16];
- snprintf(buf, 16, "%ld", globals->get_time_params()->get_cur_time());
- return buf;
- }
-
- return Request::header(name);
- }
-
- virtual void responseHeader(const string& key, const string& value)
- {
- if (key == "x-metarproxy") {
- fromProxy = true;
- }
- }
-
- virtual void gotBodyData(const char* s, int n)
- {
- metar += string(s, n);
- }
-
- virtual void responseComplete()
- {
- if (responseCode() == 200) {
- wxController->gotMetar(stationId, metar);
- } else {
- SG_LOG(SG_ENVIRONMENT, SG_WARN, "metar download failed:" << url() << ": reason:" << responseReason());
- }
- }
-
- bool fromMetarProxy() const
- { return fromProxy; }
-private:
- string stationId;
- string metar;
- bool fromProxy;
- NoaaMetarRealWxController* wxController;
-};
-
-
+ return;
+ }
-NoaaMetarRealWxController::NoaaMetarRealWxController( SGPropertyNode_ptr rootNode ) :
- BasicRealWxController(rootNode),
- _positionTimeToLive(0.0),
- _requestTimer(0.0)
-{
- string proxyHost(fgGetString("/sim/presets/proxy/host"));
- int proxyPort(fgGetInt("/sim/presets/proxy/port"));
- string proxyAuth(fgGetString("/sim/presets/proxy/auth"));
-
- if (!proxyHost.empty()) {
- _http.setProxy(proxyHost, proxyPort, proxyAuth);
- }
+ SGPropertyNode_ptr metarNode = fgGetNode(propPath, true);
+ SG_LOG( SG_ENVIRONMENT, SG_INFO, "Adding metar properties at " << propPath << " for " << icao);
+ LiveMetarProperties_ptr p(new LiveMetarProperties( metarNode, _requester, getMetarMaxAgeMin() ));
+ _metarProperties.push_back(p);
+ p->setStationId(icao);
}
-void NoaaMetarRealWxController::shutdown()
+void BasicRealWxController::removeMetarAtPath(const string &propPath)
{
+ MetarPropertiesList::iterator it = findMetarAtPath( propPath );
+ if( it != _metarProperties.end() ) {
+ SG_LOG(SG_ENVIRONMENT, SG_INFO, "removing metar properties at " << propPath);
+ _metarProperties.erase(it);
+ } else {
+ SG_LOG(SG_ENVIRONMENT, SG_WARN, "no metar properties at " << propPath);
+ }
}
-NoaaMetarRealWxController::~NoaaMetarRealWxController()
+BasicRealWxController::MetarPropertiesList::iterator BasicRealWxController::findMetarAtPath(const string &propPath)
{
+ // don not compare unprocessed property path
+ // /foo/bar[0]/baz equals /foo/bar/baz
+ SGPropertyNode_ptr n = fgGetNode(propPath,false);
+ if( false == n.valid() ) // trivial: node does not exist
+ return _metarProperties.end();
+
+ MetarPropertiesList::iterator it = _metarProperties.begin();
+ while( it != _metarProperties.end() &&
+ (*it)->get_root_node()->getPath() != n->getPath() )
+ ++it;
+
+ return it;
}
-
-void NoaaMetarRealWxController::update( bool first, double dt )
+
+void BasicRealWxController::checkNearbyMetar()
{
- _http.update();
+ try {
+ const SGGeod & pos = globals->get_aircraft_position();
+
+ // check nearest airport
+ SG_LOG(SG_ENVIRONMENT, SG_DEBUG, "NoaaMetarRealWxController::update(): (re) checking nearby airport with METAR" );
+
+ FGAirport * nearestAirport = FGAirport::findClosest(pos, 10000.0, MetarAirportFilter::instance() );
+ if( nearestAirport == NULL ) {
+ SG_LOG(SG_ENVIRONMENT,SG_WARN,"RealWxController::update can't find airport with METAR within 10000NM" );
+ return;
+ }
+
+ SG_LOG(SG_ENVIRONMENT, SG_DEBUG,
+ "NoaaMetarRealWxController::update(): nearest airport with METAR is: " << nearestAirport->ident() );
+
+ // if it has changed, invalidate the associated METAR
+ if( _metarProperties[0]->getStationId() != nearestAirport->ident() ) {
+ SG_LOG(SG_ENVIRONMENT, SG_INFO,
+ "NoaaMetarRealWxController::update(): nearest airport with METAR has changed. Old: '" <<
+ _metarProperties[0]->getStationId() <<
+ "', new: '" << nearestAirport->ident() << "'" );
+ _metarProperties[0]->setStationId( nearestAirport->ident() );
+ _metarProperties[0]->resetTimeToLive();
+ }
+ }
+ catch( sg_exception & ) {
+ return;
+ }
- _positionTimeToLive -= dt;
- _requestTimer -= dt;
+}
- if( _positionTimeToLive <= 0.0 ) {
- // check nearest airport
- SG_LOG(SG_ENVIRONMENT, SG_INFO, "NoaaMetarRealWxController::update(): (re) checking nearby airport with METAR" );
- _positionTimeToLive = 60.0;
+/* -------------------------------------------------------------------------------- */
- SGGeod pos = SGGeod::fromDeg(_longitude_n->getDoubleValue(), _latitude_n->getDoubleValue());
+class NoaaMetarRealWxController : public BasicRealWxController, MetarRequester {
+public:
+ NoaaMetarRealWxController( SGPropertyNode_ptr rootNode );
- FGAirport * nearestAirport = FGAirport::findClosest(pos, 10000.0, MetarAirportFilter::instance() );
- if( nearestAirport == NULL ) {
- SG_LOG(SG_ENVIRONMENT,SG_WARN,"RealWxController::update can't find airport with METAR within 10000NM" );
- return;
- }
+ // implementation of MetarRequester
+ virtual void requestMetar( LiveMetarProperties_ptr metarDataHandler, const std::string & id );
- SG_LOG(SG_ENVIRONMENT, SG_INFO,
- "NoaaMetarRealWxController::update(): nearest airport with METAR is: " << nearestAirport->ident() );
-
- // if it has changed, invalidate the associated METAR
- if( _metarProperties[0]->getStationId() != nearestAirport->ident() ) {
- SG_LOG(SG_ENVIRONMENT, SG_INFO,
- "NoaaMetarRealWxController::update(): nearest airport with METAR has changed. Old: '" <<
- _metarProperties[0]->getStationId() <<
- "', new: '" << nearestAirport->ident() << "'" );
- _metarProperties[0]->setStationId( nearestAirport->ident() );
- _metarProperties[0]->setTimeToLive( 0.0 );
- }
- }
-
- if( _requestTimer <= 0.0 ) {
- _requestTimer = 10.0;
-
- BOOST_FOREACH(LiveMetarProperties* p, _metarProperties) {
- if( p->getTimeToLive() > 0.0 ) continue;
- const std::string & stationId = p->getStationId();
- if( stationId.empty() ) continue;
-
- SG_LOG(SG_ENVIRONMENT, SG_INFO,
- "NoaaMetarRealWxController::update(): spawning load request for station-id '" << stationId << "'" );
-
- _http.makeRequest(new MetarGetRequest(this, stationId));
- } // of MetarProperties iteration
+ virtual ~NoaaMetarRealWxController()
+ {
}
+private:
+
+};
+
+NoaaMetarRealWxController::NoaaMetarRealWxController( SGPropertyNode_ptr rootNode ) :
+ BasicRealWxController(rootNode, this )
+{
}
-void NoaaMetarRealWxController::gotMetar(const string& stationId, const string& metar)
+void NoaaMetarRealWxController::requestMetar
+(
+ LiveMetarProperties_ptr metarDataHandler,
+ const std::string& id
+)
{
- SG_LOG( SG_ENVIRONMENT, SG_INFO, "NoaaMetarRwalWxController::update() received METAR for " << stationId << ": " << metar );
- BOOST_FOREACH(LiveMetarProperties* p, _metarProperties) {
- if (p->getStationId() != stationId)
- continue;
-
- p->setTimeToLive(900);
- p->setMetar( metar );
- }
+ static const std::string NOAA_BASE_URL =
+ "http://weather.noaa.gov/pub/data/observations/metar/stations/";
+ class NoaaMetarGetRequest:
+ public simgear::HTTP::MemoryRequest
+ {
+ public:
+ NoaaMetarGetRequest( LiveMetarProperties_ptr metarDataHandler,
+ const std::string& stationId ):
+ MemoryRequest(NOAA_BASE_URL + stationId + ".TXT"),
+ _metarDataHandler(metarDataHandler)
+ {
+ std::ostringstream buf;
+ buf << globals->get_time_params()->get_cur_time();
+ requestHeader("X-TIME") = buf.str();
+ }
+
+ virtual void onDone()
+ {
+ if( responseCode() != 200 )
+ {
+ SG_LOG
+ (
+ SG_ENVIRONMENT,
+ SG_WARN,
+ "metar download failed:" << url() << ": reason:" << responseReason()
+ );
+ return;
+ }
+
+ _metarDataHandler->handleMetarData
+ (
+ simgear::strutils::simplify(responseBody())
+ );
+ }
+
+ virtual void onFail()
+ {
+ SG_LOG(SG_ENVIRONMENT, SG_INFO, "metar download failure");
+ _metarDataHandler->handleMetarFailure();
+ }
+
+ private:
+ LiveMetarProperties_ptr _metarDataHandler;
+ };
+
+ string upperId = boost::to_upper_copy(id);
+
+ SG_LOG
+ (
+ SG_ENVIRONMENT,
+ SG_INFO,
+ "NoaaMetarRealWxController::update(): "
+ "spawning load request for station-id '" << upperId << "'"
+ );
+ FGHTTPClient* http = static_cast<FGHTTPClient*>(globals->get_subsystem("http"));
+ if (http) {
+ http->makeRequest(new NoaaMetarGetRequest(metarDataHandler, upperId));
+ }
}
/* -------------------------------------------------------------------------------- */
-
+
RealWxController * RealWxController::createInstance( SGPropertyNode_ptr rootNode )
{
-// string dataSource = rootNode->getStringValue("data-source", "noaa" );
-// if( dataSource == "nwx" ) {
-// return new NwxMetarRealWxController( rootNode );
-// } else {
- return new NoaaMetarRealWxController( rootNode );
-// }
+ return new NoaaMetarRealWxController( rootNode );
+}
+
+RealWxController::~RealWxController()
+{
}
/* -------------------------------------------------------------------------------- */