github
/
aria2
mirror of https://github.com/aria2/aria2
1
0
Fork 0
Code Issues Releases Wiki Activity

Rewritten FeatureConfig into set of functions

pull/28/head
Tatsuhiro Tsujikawa 2012-09-22 18:54:14 +09:00
parent e2340efe27
commit 9d294741fd
7 changed files with 126 additions and 185 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

199
src/FeatureConfig.cc
View File

@ -2,7 +2,7 @@
/*
* aria2 - The high speed download utility
*
* Copyright (C) 2006 Tatsuhiro Tsujikawa
* Copyright (C) 2012 Tatsuhiro Tsujikawa
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
@ -34,133 +34,106 @@
/* copyright --> */
#include "FeatureConfig.h"
#include <numeric>
#include "array_fun.h"
#include "util.h"
#include "Request.h"
namespace aria2 {
SharedHandle<FeatureConfig> FeatureConfig::featureConfig_;
const std::string FeatureConfig::FEATURE_HTTPS("HTTPS");
const std::string FeatureConfig::FEATURE_BITTORRENT("BitTorrent");
const std::string FeatureConfig::FEATURE_METALINK("Metalink");
const std::string FeatureConfig::FEATURE_MESSAGE_DIGEST("Message Digest");
const std::string FeatureConfig::FEATURE_ASYNC_DNS("Async DNS");
const std::string FeatureConfig::FEATURE_XML_RPC("XML-RPC");
const std::string FeatureConfig::FEATURE_GZIP("GZip");
const std::string FeatureConfig::FEATURE_FIREFOX3_COOKIE("Firefox3 Cookie");
#ifdef ENABLE_SSL
# define HTTPS_ENABLED true
#else // !ENABLE_SSL
# define HTTPS_ENABLED false
#endif // !ENABLE_SSL
#ifdef ENABLE_BITTORRENT
# define BITTORRENT_ENABLED true
#else // !ENABLE_BITTORRENT
# define BITTORRENT_ENABLED false
#endif // !ENABLE_BITTORRENT
#ifdef ENABLE_METALINK
# define METALINK_ENABLED true
#else // !ENABLE_METALINK
# define METALINK_ENABLED false
#endif // !ENABLE_METALINK
#ifdef ENABLE_MESSAGE_DIGEST
# define MESSAGE_DIGEST_ENABLED true
#else // !ENABLE_MESSAGE_DIGEST
# define MESSAGE_DIGEST_ENABLED false
#endif // !ENABLE_MESSAGE_DIGEST
#ifdef ENABLE_ASYNC_DNS
# define ASYNC_DNS_ENABLED true
#else // !ENABLE_ASYNC_DNS
# define ASYNC_DNS_ENABLED false
#endif // !ENABLE_ASYNC_DNS
#ifdef ENABLE_XML_RPC
# define XML_RPC_ENABLED true
#else // !ENABLE_XML_RPC
# define XML_RPC_ENABLED false
#endif // !ENABLE_XML_RPC
#ifdef HAVE_ZLIB
# define GZIP_ENABLED true
#else // !HAVE_ZLIB
# define GZIP_ENABLED false
#endif // !HAVE_ZLIB
#ifdef HAVE_SQLITE3
# define FIREFOX3_COOKIE_ENABLED true
#else // !HAVE_SQLITE3
# define FIREFOX3_COOKIE_ENABLED false
#endif // !HAVE_SQLITE3
FeatureConfig::FeatureConfig() {
defaultPorts_.insert(PortMap::value_type(Request::PROTO_HTTP, 80));
defaultPorts_.insert(PortMap::value_type(Request::PROTO_HTTPS, 443));
defaultPorts_.insert(PortMap::value_type(Request::PROTO_FTP, 21));
FeatureMap::value_type featureArray[] = {
FeatureMap::value_type(FEATURE_HTTPS, HTTPS_ENABLED),
FeatureMap::value_type(FEATURE_BITTORRENT, BITTORRENT_ENABLED),
FeatureMap::value_type(FEATURE_METALINK, METALINK_ENABLED),
FeatureMap::value_type(FEATURE_MESSAGE_DIGEST, MESSAGE_DIGEST_ENABLED),
FeatureMap::value_type(FEATURE_ASYNC_DNS, ASYNC_DNS_ENABLED),
FeatureMap::value_type(FEATURE_XML_RPC, XML_RPC_ENABLED),
FeatureMap::value_type(FEATURE_GZIP, GZIP_ENABLED),
FeatureMap::value_type(FEATURE_FIREFOX3_COOKIE, FIREFOX3_COOKIE_ENABLED),
};
features_.insert(vbegin(featureArray), vend(featureArray));
}
FeatureConfig::~FeatureConfig() {}
const SharedHandle<FeatureConfig>& FeatureConfig::getInstance()
uint16_t getDefaultPort(const std::string& protocol)
{
if(!featureConfig_) {
featureConfig_.reset(new FeatureConfig());
}
return featureConfig_;
}
uint16_t FeatureConfig::getDefaultPort(const std::string& protocol) const
{
PortMap::const_iterator itr = defaultPorts_.find(protocol);
if(itr == defaultPorts_.end()) {
if(protocol == "http") {
return 80;
} else if(protocol == "https") {
return 443;
} else if(protocol == "ftp") {
return 21;
} else {
return 0;
} else {
return itr->second;
}
}
bool FeatureConfig::isSupported(const std::string& feature) const
{
FeatureMap::const_iterator itr = features_.find(feature);
if(itr == features_.end()) {
return false;
} else {
return itr->second;
}
}
std::string FeatureConfig::featureSummary() const
std::string featureSummary()
{
std::string s;
for(FeatureMap::const_iterator i = features_.begin(), eoi = features_.end();
i != eoi; ++i) {
if((*i).second) {
s += (*i).first;
for(int i = 0; i < MAX_FEATURE; ++i) {
const char* name = strSupportedFeature(i);
if(name) {
s += name;
s += ", ";
}
}
return util::strip(s, ", ");
}
const char* strSupportedFeature(int feature)
{
switch(feature) {
case(FEATURE_ASYNC_DNS):
#ifdef ENABLE_ASYNC_DNS
return "Async DNS";
#else // !ENABLE_ASYNC_DNS
return 0;
#endif // !ENABLE_ASYNC_DNS
break;
case(FEATURE_BITTORRENT):
#ifdef ENABLE_BITTORRENT
return "BitTorrent";
#else // !ENABLE_BITTORRENT
return 0;
#endif // !ENABLE_BITTORRENT
break;
case(FEATURE_FF3_COOKIE):
#ifdef HAVE_SQLITE3
return "Firefox3 Cookie";
#else // !HAVE_SQLITE3
return 0;
#endif // !HAVE_SQLITE3
break;
case(FEATURE_GZIP):
#ifdef HAVE_ZLIB
return "GZip";
#else // !HAVE_ZLIB
return 0;
#endif // !HAVE_ZLIB
break;
case(FEATURE_HTTPS):
#ifdef ENABLE_SSL
return "HTTPS";
#else // !ENABLE_SSL
return 0;
#endif // !ENABLE_SSL
break;
case(FEATURE_MESSAGE_DIGEST):
#ifdef ENABLE_MESSAGE_DIGEST
return "Message Digest";
#else // !ENABLE_MESSAGE_DIGEST
return 0;
#endif // !ENABLE_MESSAGE_DIGEST
break;
case(FEATURE_METALINK):
#ifdef ENABLE_METALINK
return "Metalink";
#else // !ENABLE_METALINK
return 0;
#endif // !ENABLE_METALINK
break;
case(FEATURE_XML_RPC):
#ifdef ENABLE_XML_RPC
return "XML-RPC";
#else // !ENABLE_XML_RPC
return 0;
#endif // !ENABLE_XML_RPC
break;
default:
return 0;
}
}
} // namespace aria2

58
src/FeatureConfig.h
View File

@ -2,7 +2,7 @@
/*
* aria2 - The high speed download utility
*
* Copyright (C) 2006 Tatsuhiro Tsujikawa
* Copyright (C) 2012 Tatsuhiro Tsujikawa
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
@ -37,50 +37,32 @@
#include "common.h"
#include <map>
#include <string>
#include "SharedHandle.h"
namespace aria2 {
typedef std::map<std::string, uint16_t> PortMap;
typedef std::map<std::string, bool> FeatureMap;
// Returns default port for the given |protocol|.
uint16_t getDefaultPort(const std::string& protocol);
class FeatureConfig {
private:
static SharedHandle<FeatureConfig> featureConfig_;
PortMap defaultPorts_;
FeatureMap features_;
FeatureConfig();
public:
~FeatureConfig();
static const SharedHandle<FeatureConfig>& getInstance();
uint16_t getDefaultPort(const std::string& protocol) const;
bool isSupported(const std::string& feature) const;
std::string featureSummary() const;
const FeatureMap& getFeatures() const
{
return features_;
}
static const std::string FEATURE_HTTPS;
static const std::string FEATURE_BITTORRENT;
static const std::string FEATURE_METALINK;
static const std::string FEATURE_MESSAGE_DIGEST;
static const std::string FEATURE_ASYNC_DNS;
static const std::string FEATURE_XML_RPC;
static const std::string FEATURE_GZIP;
static const std::string FEATURE_FIREFOX3_COOKIE;
enum FeatureType {
FEATURE_ASYNC_DNS,
FEATURE_BITTORRENT,
FEATURE_FF3_COOKIE,
FEATURE_GZIP,
FEATURE_HTTPS,
FEATURE_MESSAGE_DIGEST,
FEATURE_METALINK,
FEATURE_XML_RPC,
MAX_FEATURE
};
// Returns summary string of the available features.
std::string featureSummary();
// Returns the string representation of the given |feature| if it is
// available in the build. If it is not available, returns NULL.
const char* strSupportedFeature(int feature);
} // namespace aria2
#endif // D_FEATURE_CONFIG_H

9
src/RpcMethodImpl.cc
View File

@ -1228,11 +1228,10 @@ SharedHandle<ValueBase> GetVersionRpcMethod::process
SharedHandle<Dict> result = Dict::g();
result->put(KEY_VERSION, PACKAGE_VERSION);
SharedHandle<List> featureList = List::g();
const FeatureMap& features = FeatureConfig::getInstance()->getFeatures();
for(FeatureMap::const_iterator i = features.begin(), eoi = features.end();
i != eoi;++i){
if((*i).second) {
featureList->append((*i).first);
for(int feat = 0; feat < MAX_FEATURE; ++feat) {
const char* name = strSupportedFeature(feat);
if(name) {
featureList->append(name);
}
}
result->put(KEY_ENABLED_FEATURES, featureList);

6
src/uri.cc
View File

@ -131,8 +131,7 @@ bool parse(UriStruct& result, const std::string& uri)
if(protocolOffset == std::string::npos) return false;
result.protocol.assign(uri.begin(), uri.begin()+protocolOffset);
uint16_t defPort;
if((defPort = FeatureConfig::getInstance()->
getDefaultPort(result.protocol)) == 0) {
if((defPort = getDefaultPort(result.protocol)) == 0) {
return false;
}
// find authority
@ -268,8 +267,7 @@ std::string construct(const UriStruct& us)
} else {
res += us.host;
}
uint16_t defPort= FeatureConfig::getInstance()->
getDefaultPort(us.protocol);
uint16_t defPort= getDefaultPort(us.protocol);
if(us.port != 0 && defPort != us.port) {
res += fmt(":%u", us.port);
}

2
src/version_usage.cc
View File

@ -70,7 +70,7 @@ void showVersion() {
<< "\n"
<< _("** Configuration **") << "\n"
<< _("Enabled Features") << ": "
<< FeatureConfig::getInstance()->featureSummary() << "\n"
<< featureSummary() << "\n"
#ifdef ENABLE_MESSAGE_DIGEST
<< _("Hash Algorithms") << ": "
<< MessageDigest::getSupportedHashTypeString() << "\n"

33
test/FeatureConfigTest.cc
View File

@ -14,13 +14,12 @@ class FeatureConfigTest:public CppUnit::TestFixture {
CPPUNIT_TEST_SUITE(FeatureConfigTest);
CPPUNIT_TEST(testGetDefaultPort);
CPPUNIT_TEST(testIsSupported);
CPPUNIT_TEST(testStrSupportedFeature);
CPPUNIT_TEST(testFeatureSummary);
CPPUNIT_TEST_SUITE_END();
public:
void testGetDefaultPort();
void testIsSupported();
void testStrSupportedFeature();
void testFeatureSummary();
};
@ -28,26 +27,19 @@ public:
CPPUNIT_TEST_SUITE_REGISTRATION(FeatureConfigTest);
void FeatureConfigTest::testGetDefaultPort() {
CPPUNIT_ASSERT_EQUAL((uint16_t)80,
FeatureConfig::getInstance()->getDefaultPort("http"));
CPPUNIT_ASSERT_EQUAL((uint16_t)443,
FeatureConfig::getInstance()->getDefaultPort("https"));
CPPUNIT_ASSERT_EQUAL((uint16_t)21,
FeatureConfig::getInstance()->getDefaultPort("ftp"));
CPPUNIT_ASSERT_EQUAL((uint16_t)80, getDefaultPort("http"));
CPPUNIT_ASSERT_EQUAL((uint16_t)443, getDefaultPort("https"));
CPPUNIT_ASSERT_EQUAL((uint16_t)21, getDefaultPort("ftp"));
}
void FeatureConfigTest::testIsSupported() {
void FeatureConfigTest::testStrSupportedFeature() {
const char* https = strSupportedFeature(FEATURE_HTTPS);
#ifdef ENABLE_SSL
CPPUNIT_ASSERT_EQUAL(true,
FeatureConfig::getInstance()->isSupported
(FeatureConfig::FEATURE_HTTPS));
CPPUNIT_ASSERT(https);
#else
CPPUNIT_ASSERT_EQUAL(false,
FeatureConfig::getInstance()->isSupported
(FeatureConfig::FEATURE_HTTPS));
CPPUNIT_ASSERT(!https);
#endif // ENABLE_SSL
CPPUNIT_ASSERT_EQUAL(false,
FeatureConfig::getInstance()->isSupported("FTPS"));
CPPUNIT_ASSERT(!strSupportedFeature(MAX_FEATURE));
}
void FeatureConfigTest::testFeatureSummary() {
@ -92,9 +84,8 @@ void FeatureConfigTest::testFeatureSummary() {
std::for_each(vbegin(features), vend(features),
StringAppend(featuresString, delim));
featuresString = util::strip(featuresString, delim);
CPPUNIT_ASSERT_EQUAL(featuresString,
FeatureConfig::getInstance()->featureSummary());
CPPUNIT_ASSERT_EQUAL(featuresString, featureSummary());
}
} // namespace aria2

4
test/RpcMethodTest.cc
View File

@ -741,9 +741,7 @@ void RpcMethodTest::testGetVersion()
features += s->s();
features += ", ";
}
CPPUNIT_ASSERT_EQUAL(FeatureConfig::getInstance()->featureSummary()+", ",
features);
CPPUNIT_ASSERT_EQUAL(featureSummary()+", ", features);
}
void RpcMethodTest::testGatherStoppedDownload()