// 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
//
#include <Main/fg_props.hxx>
+#include <boost/foreach.hpp>
+
#include <simgear/structure/exception.hxx>
#include <simgear/misc/strutils.hxx>
#include <simgear/props/tiedpropertylist.hxx>
-#include <algorithm>
-#if defined(ENABLE_THREADS)
-#include <OpenThreads/Thread>
-#include <simgear/threads/SGQueue.hxx>
-#endif
+#include <simgear/io/HTTPClient.hxx>
+#include <simgear/io/HTTPRequest.hxx>
+#include <simgear/timing/sg_time.hxx>
+#include <simgear/structure/event_mgr.hxx>
+#include <algorithm>
namespace Environment {
+/* -------------------------------------------------------------------------------- */
+
+class FGHTTPClient : public simgear::HTTP::Client {
+public:
+ FGHTTPClient();
+};
+
+FGHTTPClient::FGHTTPClient()
+{
+ string proxyHost(fgGetString("/sim/presets/proxy/host"));
+ int proxyPort(fgGetInt("/sim/presets/proxy/port"));
+ string proxyAuth(fgGetString("/sim/presets/proxy/auth"));
+
+ if (!proxyHost.empty()) {
+ setProxy(proxyHost, proxyPort, proxyAuth);
+ }
+}
+
+/* -------------------------------------------------------------------------------- */
+
+class MetarDataHandler {
+public:
+ virtual void handleMetarData( const std::string & data ) = 0;
+};
+
+class MetarRequester {
+public:
+ virtual void requestMetar( MetarDataHandler * metarDataHandler, const std::string & id ) = 0;
+};
/* -------------------------------------------------------------------------------- */
-class LiveMetarProperties : public MetarProperties {
+class LiveMetarProperties : public MetarProperties, MetarDataHandler {
public:
- LiveMetarProperties( SGPropertyNode_ptr rootNode );
+ LiveMetarProperties( SGPropertyNode_ptr rootNode, MetarRequester * metarRequester );
virtual ~LiveMetarProperties();
virtual void update( double dt );
virtual double getTimeToLive() const { return _timeToLive; }
virtual void setTimeToLive( double value ) { _timeToLive = value; }
+
+ // implementation of MetarDataHandler
+ virtual void handleMetarData( const std::string & data );
+
+ static const unsigned MAX_POLLING_INTERVAL_SECONDS = 10;
+ static const unsigned DEFAULT_TIME_TO_LIVE_SECONDS = 900;
+
private:
double _timeToLive;
-
+ double _pollingTimer;
+ MetarRequester * _metarRequester;
};
typedef SGSharedPtr<LiveMetarProperties> LiveMetarProperties_ptr;
-LiveMetarProperties::LiveMetarProperties( SGPropertyNode_ptr rootNode ) :
+LiveMetarProperties::LiveMetarProperties( SGPropertyNode_ptr rootNode, MetarRequester * metarRequester ) :
MetarProperties( rootNode ),
- _timeToLive(0.0)
+ _timeToLive(0.0),
+ _pollingTimer(0.0),
+ _metarRequester(metarRequester)
{
_tiedProperties.Tie("time-to-live", &_timeToLive );
}
void LiveMetarProperties::update( double dt )
{
_timeToLive -= dt;
- if( _timeToLive < 0.0 ) _timeToLive = 0.0;
+ _pollingTimer -= dt;
+ if( _timeToLive < 0.0 ) {
+ _timeToLive = 0.0;
+ 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_INFO, "LiveMetarProperties::handleMetarData() received METAR for " << getStationId() << ": " << data );
+ _timeToLive = DEFAULT_TIME_TO_LIVE_SECONDS;
+ setMetar( data );
}
/* -------------------------------------------------------------------------------- */
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 ();
+
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;
simgear::TiedPropertyList _tiedProperties;
typedef std::vector<LiveMetarProperties_ptr> MetarPropertiesList;
MetarPropertiesList _metarProperties;
+
};
/* -------------------------------------------------------------------------------- */
~/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),
{
// at least instantiate MetarProperties for /environment/metar
_metarProperties.push_back( new LiveMetarProperties(
- fgGetNode( rootNode->getStringValue("metar", "/environment/metar"), true ) ) );
+ fgGetNode( rootNode->getStringValue("metar", "/environment/metar"), true ), metarRequester ));
- PropertyList metars = rootNode->getChildren("metar");
- for( PropertyList::size_type i = 1; i < metars.size(); i++ ) {
- SG_LOG( SG_ALL, SG_INFO, "Adding metar properties at " << metars[i]->getStringValue() );
+ BOOST_FOREACH( SGPropertyNode_ptr n, rootNode->getChildren("metar") ) {
+ SG_LOG( SG_ENVIRONMENT, SG_INFO, "Adding metar properties at " << n->getStringValue() );
_metarProperties.push_back( new LiveMetarProperties(
- fgGetNode( metars[i]->getStringValue(), true )));
+ fgGetNode( n->getStringValue(), true ), metarRequester ));
}
}
{
__enabled = false;
update(0); // fetch data ASAP
+
+ globals->get_event_mgr()->addTask("checkNearbyMetar", this,
+ &BasicRealWxController::checkNearbyMetar, 60 );
}
void BasicRealWxController::reinit()
{
__enabled = false;
}
+
+void BasicRealWxController::shutdown()
+{
+ globals->get_event_mgr()->removeTask("checkNearbyMetar");
+}
void BasicRealWxController::bind()
{
bool firstIteration = !__enabled; // first iteration after being enabled?
// 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->setTimeToLive( 0.0 );
+ p->update(dt);
}
- update( firstIteration, dt );
__enabled = true;
} else {
__enabled = false;
}
}
+void BasicRealWxController::checkNearbyMetar()
+{
+ 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]->setTimeToLive( 0.0 );
+ }
+ }
+ catch( sg_exception & ) {
+ return;
+ }
+
+}
+
/* -------------------------------------------------------------------------------- */
-class NoaaMetarRealWxController : public BasicRealWxController {
+class NoaaMetarRealWxController : public BasicRealWxController, MetarRequester {
public:
NoaaMetarRealWxController( SGPropertyNode_ptr rootNode );
virtual ~NoaaMetarRealWxController();
- virtual void update (bool first, double delta_time_sec);
- virtual void shutdown ();
+ virtual void update( double dt );
- class MetarLoadRequest {
- public:
- MetarLoadRequest( const string & stationId ) :
- _stationId(stationId),
- _proxyHost(fgGetNode("/sim/presets/proxy/host", true)->getStringValue()),
- _proxyPort(fgGetNode("/sim/presets/proxy/port", true)->getStringValue()),
- _proxyAuth(fgGetNode("/sim/presets/proxy/authentication", true)->getStringValue())
- {}
- MetarLoadRequest( const MetarLoadRequest & other ) :
- _stationId(other._stationId),
- _proxyHost(other._proxyAuth),
- _proxyPort(other._proxyPort),
- _proxyAuth(other._proxyAuth)
- {}
- string _stationId;
- string _proxyHost;
- string _proxyPort;
- string _proxyAuth;
- private:
- };
+ // implementation of MetarRequester
+ virtual void requestMetar( MetarDataHandler * metarDataHandler, const std::string & id );
- class MetarLoadResponse {
- public:
- MetarLoadResponse( const string & stationId, const string metar ) {
- _stationId = stationId;
- _metar = metar;
- }
- MetarLoadResponse( const MetarLoadResponse & other ) {
- _stationId = other._stationId;
- _metar = other._metar;
- }
- string _stationId;
- string _metar;
- };
private:
- double _positionTimeToLive;
- double _requestTimer;
-
-#if defined(ENABLE_THREADS)
- class MetarLoadThread : public OpenThreads::Thread {
- public:
- MetarLoadThread( long maxAge );
- virtual ~MetarLoadThread( ) { stop(); }
- void requestMetar( const MetarLoadRequest & metarRequest, bool background = true );
- bool hasMetar() { return _responseQueue.size() > 0; }
- MetarLoadResponse getMetar() { return _responseQueue.pop(); }
- virtual void run();
- void stop();
- private:
- void fetch( const MetarLoadRequest & );
- long _maxAge;
- long _minRequestInterval;
- volatile bool _stop;
- SGBlockingQueue <MetarLoadRequest> _requestQueue;
- SGBlockingQueue <MetarLoadResponse> _responseQueue;
- };
-
- MetarLoadThread * _metarLoadThread;
-#endif
+ FGHTTPClient _http;
};
NoaaMetarRealWxController::NoaaMetarRealWxController( SGPropertyNode_ptr rootNode ) :
- BasicRealWxController(rootNode),
- _positionTimeToLive(0.0),
- _requestTimer(0.0)
+ BasicRealWxController(rootNode, this )
{
-#if defined(ENABLE_THREADS)
- _metarLoadThread = new MetarLoadThread(getMetarMaxAgeMin());
- _metarLoadThread->start();
-#endif
-}
-
-void NoaaMetarRealWxController::shutdown()
-{
-#if defined(ENABLE_THREADS)
- if( _metarLoadThread ) {
- delete _metarLoadThread;
- _metarLoadThread = NULL;
- }
-#endif // ENABLE_THREADS
}
NoaaMetarRealWxController::~NoaaMetarRealWxController()
{
}
-void NoaaMetarRealWxController::update( bool first, double dt )
-{
- _positionTimeToLive -= dt;
- _requestTimer -= dt;
-
- if( _positionTimeToLive <= 0.0 ) {
- // check nearest airport
- SG_LOG(SG_ALL, SG_INFO, "NoaaMetarRealWxController::update(): (re) checking nearby airport with METAR" );
- _positionTimeToLive = 60.0;
-
- SGGeod pos = SGGeod::fromDeg(_longitude_n->getDoubleValue(), _latitude_n->getDoubleValue());
-
- FGAirport * nearestAirport = FGAirport::findClosest(pos, 10000.0, MetarAirportFilter::instance() );
- if( nearestAirport == NULL ) {
- SG_LOG(SG_ALL,SG_WARN,"RealWxController::update can't find airport with METAR within 10000NM" );
- return;
- }
-
- SG_LOG(SG_ALL, 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_ALL, 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;
-
- for( MetarPropertiesList::iterator it = _metarProperties.begin();
- it != _metarProperties.end(); it++ ) {
-
- if( (*it)->getTimeToLive() > 0.0 ) continue;
- const std::string & stationId = (*it)->getStationId();
- if( stationId.empty() ) continue;
-
- SG_LOG(SG_ALL, SG_INFO,
- "NoaaMetarRealWxController::update(): spawning load request for station-id '" << stationId << "'" );
-
- MetarLoadRequest request( stationId );
- // load the metar for the nearest airport in the foreground if the fdm is uninitialized
- // to make sure a metar is received
- // before the automatic runway selection code runs. All subsequent calls
- // run in the background
- bool background = fgGetBool("/sim/fdm-initialized", false ) || it != _metarProperties.begin();
- _metarLoadThread->requestMetar( request, background );
- }
- }
-
- // pick all the received responses from the result queue and update the associated
- // property tree
- while( _metarLoadThread->hasMetar() ) {
- MetarLoadResponse metar = _metarLoadThread->getMetar();
- SG_LOG( SG_ALL, SG_INFO, "NoaaMetarRwalWxController::update() received METAR for " << metar._stationId << ": " << metar._metar );
- for( MetarPropertiesList::iterator it = _metarProperties.begin();
- it != _metarProperties.end(); it++ ) {
- if( (*it)->getStationId() != metar._stationId )
- continue;
- (*it)->setTimeToLive(900);
- (*it)->setMetar( metar._metar );
- }
- }
-}
-
-/* -------------------------------------------------------------------------------- */
-
-#if defined(ENABLE_THREADS)
-NoaaMetarRealWxController::MetarLoadThread::MetarLoadThread( long maxAge ) :
- _maxAge(maxAge),
- _minRequestInterval(2000),
- _stop(false)
+void NoaaMetarRealWxController::update( double dt )
{
+ _http.update();
+ BasicRealWxController::update( dt );
}
-void NoaaMetarRealWxController::MetarLoadThread::requestMetar( const MetarLoadRequest & metarRequest, bool background )
+void NoaaMetarRealWxController::requestMetar( MetarDataHandler * metarDataHandler, const std::string & id )
{
- if( background ) {
- if( _requestQueue.size() > 10 ) {
- SG_LOG(SG_ALL,SG_ALERT,
- "NoaaMetarRealWxController::MetarLoadThread::requestMetar() more than 10 outstanding METAR requests, dropping "
- << metarRequest._stationId );
- return;
- }
-
- _requestQueue.push( metarRequest );
- } else {
- fetch( metarRequest );
- }
-}
-
-void NoaaMetarRealWxController::MetarLoadThread::stop()
-{
- // set stop flag and wake up the thread with an empty request
- _stop = true;
- MetarLoadRequest request("");
- requestMetar(request);
- join();
-}
-
-void NoaaMetarRealWxController::MetarLoadThread::run()
-{
- SGTimeStamp lastRun = SGTimeStamp::fromSec(0);
- for( ;; ) {
- SGTimeStamp dt = SGTimeStamp::now() - lastRun;
-
- long delayMs = _minRequestInterval - dt.getSeconds() * 1000;
- while (( delayMs > 0 ) && !_stop)
- {
- // sleep no more than 3 seconds at a time, otherwise shutdown response is too slow
- long sleepMs = (delayMs>3000) ? 3000 : delayMs;
- microSleep( sleepMs * 1000 );
- delayMs -= sleepMs;
- }
-
- if (_stop)
- break;
-
- lastRun = SGTimeStamp::now();
-
- const MetarLoadRequest request = _requestQueue.pop();
-
- if (( request._stationId.size() == 0 ) || _stop)
- break;
-
- fetch( request );
- }
-}
-
-void NoaaMetarRealWxController::MetarLoadThread::fetch( const MetarLoadRequest & request )
-{
- SGSharedPtr<FGMetar> result = NULL;
-
- try {
- result = new FGMetar( request._stationId, request._proxyHost, request._proxyPort, request._proxyAuth );
- _minRequestInterval = 2000;
- } catch (const sg_io_exception& e) {
- SG_LOG( SG_GENERAL, SG_WARN, "NoaaMetarRealWxController::fetchMetar(): can't get METAR for "
- << request._stationId << ":" << e.getFormattedMessage().c_str() );
- _minRequestInterval += _minRequestInterval/2;
- if( _minRequestInterval > 30000 )
- _minRequestInterval = 30000;
- return;
- }
-
- string reply = result->getData();
- std::replace(reply.begin(), reply.end(), '\n', ' ');
- string metar = simgear::strutils::strip( reply );
-
- if( metar.empty() ) {
- SG_LOG( SG_GENERAL, SG_WARN, "NoaaMetarRealWxController::fetchMetar(): dropping empty METAR for "
- << request._stationId );
- return;
- }
+ class NoaaMetarGetRequest : public simgear::HTTP::Request
+ {
+ public:
+ NoaaMetarGetRequest(MetarDataHandler* metarDataHandler, const string& stationId ) :
+ Request("http://weather.noaa.gov/pub/data/observations/metar/stations/" + stationId + ".TXT"),
+ _fromProxy(false),
+ _metarDataHandler(metarDataHandler)
+ {
+ }
+
+ virtual string_list requestHeaders() const
+ {
+ string_list reply;
+ reply.push_back("X-TIME");
+ return reply;
+ }
+
+ virtual std::string header(const std::string& name) const
+ {
+ string reply;
+
+ if( name == "X-TIME" ) {
+ std::ostringstream buf;
+ buf << globals->get_time_params()->get_cur_time();
+ reply = buf.str();
+ }
+
+ return reply;
+ }
+
+ 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) {
+ _metarDataHandler->handleMetarData( _metar);
+ } else {
+ SG_LOG(SG_ENVIRONMENT, SG_WARN, "metar download failed:" << url() << ": reason:" << responseReason());
+ }
+ }
+
+ bool fromMetarProxy() const
+ { return _fromProxy; }
+ private:
+ string _metar;
+ bool _fromProxy;
+ MetarDataHandler * _metarDataHandler;
+ };
- if( _maxAge && result->getAge_min() > _maxAge ) {
- SG_LOG( SG_GENERAL, SG_ALERT, "NoaaMetarRealWxController::fetchMetar(): dropping outdated METAR "
- << metar );
- return;
- }
- MetarLoadResponse response( request._stationId, metar );
- _responseQueue.push( response );
+ SG_LOG(SG_ENVIRONMENT, SG_INFO,
+ "NoaaMetarRealWxController::update(): spawning load request for station-id '" << id << "'" );
+ _http.makeRequest(new NoaaMetarGetRequest(metarDataHandler, id));
}
-#endif
/* -------------------------------------------------------------------------------- */