Peerplays_Blockchain/peerplays-fc
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

updates

Browse source
This commit is contained in:
Daniel Larimer 2014-05-04 14:26:36 -04:00
commit 3ac07ddbf5
9 changed files with 167 additions and 94 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

7
include/fc/network/tcp_socket.hpp
View file

@ -15,13 +15,16 @@ namespace fc {
void connect_to( const fc::ip::endpoint& remote_endpoint );
void connect_to( const fc::ip::endpoint& remote_endpoint, const fc::ip::endpoint& local_endpoint );
void enable_keep_alives(const fc::microseconds& interval);
fc::ip::endpoint remote_endpoint()const;
void set_reuse_address(bool enable = true); // set SO_REUSEADDR
fc::ip::endpoint remote_endpoint() const;
fc::ip::endpoint local_endpoint() const;
void get( char& c )
{
read( &c, 1 );
}
/// istream interface
/// @{
virtual size_t readsome( char* buffer, size_t max );
@ -35,6 +38,7 @@ namespace fc {
virtual void close();
/// @}
void open();
bool is_open()const;
private:
@ -57,6 +61,7 @@ namespace fc {
void close();
void accept( tcp_socket& s );
void set_reuse_address(bool enable = true); // set SO_REUSEADDR, call before listen
void listen( uint16_t port );
void listen( const fc::ip::endpoint& ep );
uint16_t get_port()const;

40
include/fc/reflect/reflect.hpp
View file

@ -17,7 +17,7 @@
#include <fc/reflect/typename.hpp>
namespace fc {
namespace fc {
/**
* @brief defines visit functions for T
@ -32,13 +32,13 @@ template<typename T>
struct reflector{
typedef T type;
typedef fc::false_type is_defined;
typedef fc::false_type is_enum;
typedef fc::false_type is_enum;
/**
* @tparam Visitor a function object of the form:
*
*
* @code
* struct functor {
* struct functor {
* template<typename Member, class Class, Member (Class::*member)>
* void operator()( const char* name )const;
* };
@ -46,19 +46,19 @@ struct reflector{
*
* If T is an enum then the functor has the following form:
* @code
* struct functor {
* struct functor {
* template<int Value>
* void operator()( const char* name )const;
* };
* @endcode
*
*
* @param v a functor that will be called for each member on T
*
* @note - this method is not defined for non-reflected types.
*/
#ifdef DOXYGEN
template<typename Visitor>
static inline void visit( const Visitor& v );
static inline void visit( const Visitor& v );
#endif // DOXYGEN
};
@ -77,7 +77,7 @@ void throw_bad_enum_cast( const char* k, const char* e );
#define TEMPLATE template
#else
// Disable warning C4482: nonstandard extention used: enum 'enum_type::enum_value' used in qualified name
#pragma warning( disable: 4482 )
#pragma warning( disable: 4482 )
#define TEMPLATE
#endif
@ -98,14 +98,14 @@ template<typename Visitor>\
static inline void visit( const Visitor& v ) { \
BOOST_PP_SEQ_FOR_EACH( FC_REFLECT_VISIT_BASE, v, INHERITS ) \
BOOST_PP_SEQ_FOR_EACH( FC_REFLECT_VISIT_MEMBER, v, MEMBERS ) \
}
}
#define FC_REFLECT_DERIVED_IMPL_EXT( TYPE, INHERITS, MEMBERS ) \
template<typename Visitor>\
void fc::reflector<TYPE>::visit( const Visitor& v ) { \
BOOST_PP_SEQ_FOR_EACH( FC_REFLECT_VISIT_BASE, v, INHERITS ) \
BOOST_PP_SEQ_FOR_EACH( FC_REFLECT_VISIT_MEMBER, v, MEMBERS ) \
}
}
#endif // DOXYGEN
@ -132,15 +132,23 @@ template<> struct reflector<ENUM> { \
}\
return nullptr; \
} \
static const char* to_string(ENUM elem) { \
switch( elem ) { \
BOOST_PP_SEQ_FOR_EACH( FC_REFLECT_ENUM_TO_STRING, ENUM, FIELDS ) \
default: \
fc::throw_bad_enum_cast( BOOST_PP_STRINGIZE(elem), BOOST_PP_STRINGIZE(ENUM) ); \
}\
return nullptr; \
} \
static ENUM from_string( const char* s ) { \
BOOST_PP_SEQ_FOR_EACH( FC_REFLECT_ENUM_FROM_STRING, ENUM, FIELDS ) \
fc::throw_bad_enum_cast( s, BOOST_PP_STRINGIZE(ENUM) ); \
return ENUM();\
} \
}; \
}
}
/* Note: FC_REFLECT_ENUM previously defined this function, but I don't think it ever
/* Note: FC_REFLECT_ENUM previously defined this function, but I don't think it ever
* did what we expected it to do. I've disabled it for now.
*
* template<typename Visitor> \
@ -152,7 +160,7 @@ template<> struct reflector<ENUM> { \
/**
* @def FC_REFLECT_DERIVED(TYPE,INHERITS,MEMBERS)
*
* @brief Specializes fc::reflector for TYPE where
* @brief Specializes fc::reflector for TYPE where
* type inherits other reflected classes
*
* @param INHERITS - a sequence of base class names (basea)(baseb)(basec)
@ -170,7 +178,7 @@ template<> struct reflector<TYPE> {\
total_member_count = local_member_count BOOST_PP_SEQ_FOR_EACH( FC_REFLECT_BASE_MEMBER_COUNT, +, INHERITS )\
}; \
FC_REFLECT_DERIVED_IMPL_INLINE( TYPE, INHERITS, MEMBERS ) \
}; }
}; }
#define FC_REFLECT_DERIVED_TEMPLATE( TEMPLATE_ARGS, TYPE, INHERITS, MEMBERS ) \
namespace fc { \
template<BOOST_PP_SEQ_ENUM(TEMPLATE_ARGS)> struct get_typename<TYPE> { static const char* name() { return BOOST_PP_STRINGIZE(TYPE); } }; \
@ -183,9 +191,9 @@ template<BOOST_PP_SEQ_ENUM(TEMPLATE_ARGS)> struct reflector<TYPE> {\
total_member_count = local_member_count BOOST_PP_SEQ_FOR_EACH( FC_REFLECT_BASE_MEMBER_COUNT, +, INHERITS )\
}; \
FC_REFLECT_DERIVED_IMPL_INLINE( TYPE, INHERITS, MEMBERS ) \
}; }
}; }
//BOOST_PP_SEQ_SIZE(MEMBERS),
//BOOST_PP_SEQ_SIZE(MEMBERS),
/**
* @def FC_REFLECT(TYPE,MEMBERS)

4
include/fc/time.hpp
View file

@ -45,13 +45,14 @@ namespace fc {
static time_point from_iso_string( const fc::string& s );
const microseconds& time_since_epoch()const { return elapsed; }
uint32_t sec_since_epoch()const { return elapsed.count() / 1000000; }
bool operator > ( const time_point& t )const { return elapsed._count > t.elapsed._count; }
bool operator >=( const time_point& t )const { return elapsed._count >=t.elapsed._count; }
bool operator < ( const time_point& t )const { return elapsed._count < t.elapsed._count; }
bool operator <=( const time_point& t )const { return elapsed._count <=t.elapsed._count; }
bool operator ==( const time_point& t )const { return elapsed._count ==t.elapsed._count; }
bool operator !=( const time_point& t )const { return elapsed._count !=t.elapsed._count; }
time_point& operator += ( const microseconds& m) { elapsed+=m; return *this; }
time_point& operator += ( const microseconds& m) { elapsed+=m; return *this; }
time_point operator + (const microseconds& m) const { return time_point(elapsed+m); }
time_point operator - (const microseconds& m) const { return time_point(elapsed-m); }
microseconds operator - (const time_point& m) const { return microseconds(elapsed.count() - m.elapsed.count()); }
@ -87,6 +88,7 @@ namespace fc {
friend bool operator <= ( const time_point_sec& a, const time_point_sec& b ) { return a.utc_seconds <= b.utc_seconds; }
friend bool operator >= ( const time_point_sec& a, const time_point_sec& b ) { return a.utc_seconds >= b.utc_seconds; }
friend bool operator == ( const time_point_sec& a, const time_point_sec& b ) { return a.utc_seconds == b.utc_seconds; }
friend bool operator != ( const time_point_sec& a, const time_point_sec& b ) { return a.utc_seconds != b.utc_seconds; }
time_point_sec& operator += ( uint32_t m ) { utc_seconds+=m; return *this; }
friend time_point operator - ( const time_point_sec& t, const microseconds& m ) { return time_point(t) - m; }

2
include/fc/variant_object.hpp
View file

@ -59,7 +59,7 @@ namespace fc
const variant& operator[]( const string& key )const;
const variant& operator[]( const char* key )const;
size_t size()const;
bool contains( const char* key ) { return find(key) != end(); }
bool contains( const char* key ) const { return find(key) != end(); }
///@}
variant_object();

12
src/io/iostream.cpp
View file

@ -264,12 +264,14 @@ namespace fc {
istream& operator>>( istream& o, std::string& v )
{
assert(false && "not implemented");
return o;
}
#ifdef USE_FC_STRING
istream& operator>>( istream& o, fc::string& v )
{
assert(false && "not implemented");
return o;
}
#endif
@ -282,51 +284,61 @@ namespace fc {
istream& operator>>( istream& o, double& v )
{
assert(false && "not implemented");
return o;
}
istream& operator>>( istream& o, float& v )
{
assert(false && "not implemented");
return o;
}
istream& operator>>( istream& o, int64_t& v )
{
assert(false && "not implemented");
return o;
}
istream& operator>>( istream& o, uint64_t& v )
{
assert(false && "not implemented");
return o;
}
istream& operator>>( istream& o, int32_t& v )
{
assert(false && "not implemented");
return o;
}
istream& operator>>( istream& o, uint32_t& v )
{
assert(false && "not implemented");
return o;
}
istream& operator>>( istream& o, int16_t& v )
{
assert(false && "not implemented");
return o;
}
istream& operator>>( istream& o, uint16_t& v )
{
assert(false && "not implemented");
return o;
}
istream& operator>>( istream& o, int8_t& v )
{
assert(false && "not implemented");
return o;
}
istream& operator>>( istream& o, uint8_t& v )
{
assert(false && "not implemented");
return o;
}

80
src/io/json.cpp
View file

@ -211,54 +211,58 @@ namespace fc
template<typename T>
variant number_from_stream( T& in )
{
char buf[30];
memset( buf, 0, sizeof(buf) );
char* pos = buf;
fc::stringstream ss;
bool dot = false;
bool neg = false;
if( in.peek() == '-')
{
neg = true;
*pos = in.get();
++pos;
ss.put( in.get() );
}
bool done = false;
while( !done)
try
{
char c = in.peek();
switch( c )
char c;
while((c = in.peek()) && !done)
{
case '.':
{
if( dot )
{
done = true;
break;
}
dot = true;
}
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
*pos = c;
++pos;
in.get();
break;
default:
done = true;
break;
switch( c )
{
case '.':
if (dot)
FC_THROW_EXCEPTION(parse_error_exception, "Can't parse a number with two decimal places");
dot = true;
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
ss.put( in.get() );
break;
default:
done = true;
break;
}
}
}
if( dot ) return to_double(buf);
if( neg ) return to_int64(buf);
return to_uint64(buf);
catch (fc::eof_exception&)
{
}
fc::string str = ss.str();
if (str == "-." || str == ".") // check the obviously wrong things we could have encountered
FC_THROW_EXCEPTION(parse_error_exception, "Can't parse token \"${token}\" as a JSON numeric constant", ("token", str));
if( dot )
return to_double(str);
if( neg )
return to_int64(str);
return to_uint64(str);
}
template<typename T>
variant token_from_stream( T& in )
@ -269,7 +273,7 @@ namespace fc
try
{
char c;
while( (c = in.peek()) && !parsed_unexpected_character)
while((c = in.peek()) && !parsed_unexpected_character)
{
switch( c )
{

106
src/network/tcp_socket.cpp
View file

@ -14,12 +14,21 @@ namespace fc {
class tcp_socket::impl {
public:
impl():_sock( fc::asio::default_io_service() ){}
impl() :
_sock( fc::asio::default_io_service() )
{}
~impl(){
if( _sock.is_open() ) _sock.close();
if( _sock.is_open() )
_sock.close();
}
boost::asio::ip::tcp::socket _sock;
};
void tcp_socket::open()
{
my->_sock.open(boost::asio::ip::tcp::endpoint(boost::asio::ip::tcp::v4(), 0).protocol());
}
bool tcp_socket::is_open()const {
return my->_sock.is_open();
}
@ -46,11 +55,17 @@ namespace fc {
return fc::asio::write_some( my->_sock, boost::asio::buffer( buf, len ) );
}
fc::ip::endpoint tcp_socket::remote_endpoint()const
{
auto rep = my->_sock.remote_endpoint();
return fc::ip::endpoint(rep.address().to_v4().to_ulong(), rep.port() );
}
fc::ip::endpoint tcp_socket::remote_endpoint()const
{
auto rep = my->_sock.remote_endpoint();
return fc::ip::endpoint(rep.address().to_v4().to_ulong(), rep.port() );
}
fc::ip::endpoint tcp_socket::local_endpoint() const
{
auto boost_local_endpoint = my->_sock.local_endpoint();
return fc::ip::endpoint(boost_local_endpoint.address().to_v4().to_ulong(), boost_local_endpoint.port() );
}
size_t tcp_socket::readsome( char* buf, size_t len ) {
auto r = fc::asio::read_some( my->_sock, boost::asio::buffer( buf, len ) );
@ -62,10 +77,17 @@ namespace fc {
}
void tcp_socket::connect_to( const fc::ip::endpoint& remote_endpoint, const fc::ip::endpoint& local_endpoint ) {
my->_sock = boost::asio::ip::tcp::socket(fc::asio::default_io_service(),
boost::asio::ip::tcp::endpoint(boost::asio::ip::address_v4(local_endpoint.get_address()),
local_endpoint.port()));
fc::asio::tcp::connect(my->_sock, fc::asio::tcp::endpoint( boost::asio::ip::address_v4(remote_endpoint.get_address()), remote_endpoint.port() ) );
try
{
my->_sock.bind(boost::asio::ip::tcp::endpoint(boost::asio::ip::address_v4(local_endpoint.get_address()),
local_endpoint.port()));
}
catch (std::exception& except)
{
elog("Exception binding outgoing connection to desired local endpoint: ${what}", ("what", except.what()));
throw;
}
fc::asio::tcp::connect(my->_sock, fc::asio::tcp::endpoint(boost::asio::ip::address_v4(remote_endpoint.get_address()), remote_endpoint.port()));
}
void tcp_socket::enable_keep_alives(const fc::microseconds& interval)
@ -77,30 +99,29 @@ namespace fc {
#if defined _WIN32 || defined WIN32 || defined OS_WIN64 || defined _WIN64 || defined WIN64 || defined WINNT
struct tcp_keepalive keepalive_settings;
keepalive_settings.onoff = 1;
keepalive_settings.keepalivetime = interval.count() / fc::milliseconds(1).count();
keepalive_settings.keepaliveinterval = interval.count() / fc::milliseconds(1).count();
keepalive_settings.keepalivetime = (ULONG)(interval.count() / fc::milliseconds(1).count());
keepalive_settings.keepaliveinterval = (ULONG)(interval.count() / fc::milliseconds(1).count());
DWORD dwBytesRet = 0;
if (WSAIoctl(my->_sock.native(), SIO_KEEPALIVE_VALS, &keepalive_settings, sizeof(keepalive_settings),
NULL, 0, &dwBytesRet, NULL, NULL) == SOCKET_ERROR)
wlog("Error setting TCP keepalive values");
#else
#elif !defined(__clang__) || (__clang_major__ >= 6)
// This should work for modern Linuxes and for OSX >= Mountain Lion
int timeout_sec = interval.count() / fc::seconds(1).count();
if (setsockopt(my->_sock.native(), IPPROTO_TCP,
# if defined( __APPLE__ )
#if defined( __APPLE__ )
TCP_KEEPALIVE,
# else
#else
TCP_KEEPIDLE,
# endif
#endif
(char*)&timeout_sec, sizeof(timeout_sec)) < 0)
wlog("Error setting TCP keepalive idle time");
#ifndef __APPLE__ // TCP_KEEPINTVL does not seem to work on 10.8.4
#ifndef __APPLE__ // TCP_KEEPINTVL does not seem to work on 10.8.4
if (setsockopt(my->_sock.native(), IPPROTO_TCP, TCP_KEEPINTVL,
(char*)&timeout_sec, sizeof(timeout_sec)) < 0)
wlog("Error setting TCP keepalive interval");
#endif // !__APPLE__
#endif // !__APPLE__
#endif
}
else
@ -110,13 +131,21 @@ namespace fc {
}
}
void tcp_socket::set_reuse_address(bool enable /* = true */)
{
FC_ASSERT(my->_sock.is_open());
boost::asio::socket_base::reuse_address option(enable);
my->_sock.set_option(option);
}
class tcp_server::impl {
public:
impl(uint16_t port)
:_accept( fc::asio::default_io_service(), boost::asio::ip::tcp::endpoint(boost::asio::ip::tcp::v4(), port) ){}
impl(const fc::ip::endpoint& ep )
:_accept( fc::asio::default_io_service(), boost::asio::ip::tcp::endpoint(boost::asio::ip::address_v4( ep.get_address()), ep.port()) ){}
impl()
:_accept( fc::asio::default_io_service() )
{
_accept.open(boost::asio::ip::tcp::endpoint(boost::asio::ip::tcp::v4(), 0).protocol());
}
~impl(){
try {
@ -131,8 +160,10 @@ namespace fc {
boost::asio::ip::tcp::acceptor _accept;
};
void tcp_server::close() {
if( my && my->_accept.is_open() ) my->_accept.close();
delete my; my = nullptr;
if( my && my->_accept.is_open() )
my->_accept.close();
delete my;
my = nullptr;
}
tcp_server::tcp_server()
:my(nullptr) {
@ -150,20 +181,31 @@ namespace fc {
fc::asio::tcp::accept( my->_accept, s.my->_sock );
} FC_RETHROW_EXCEPTIONS( warn, "Unable to accept connection on socket." );
}
void tcp_server::set_reuse_address(bool enable /* = true */)
{
if( !my )
my = new impl;
boost::asio::ip::tcp::acceptor::reuse_address option(enable);
my->_accept.set_option(option);
}
void tcp_server::listen( uint16_t port )
{
if( my ) delete my;
my = new impl(port);
if( !my )
my = new impl;
my->_accept.bind(boost::asio::ip::tcp::endpoint(boost::asio::ip::address_v4(), port));
my->_accept.listen();
}
void tcp_server::listen( const fc::ip::endpoint& ep )
{
if( my ) delete my;
my = new impl(ep);
if( !my )
my = new impl;
my->_accept.bind(boost::asio::ip::tcp::endpoint(boost::asio::ip::address_v4::from_string((string)ep.get_address()), ep.port()));
my->_accept.listen();
}
uint16_t tcp_server::get_port()const
{
FC_ASSERT( my != nullptr );
return my->_accept.local_endpoint().port();
}

6
src/rpc/json_connection.cpp
View file

@ -141,7 +141,7 @@ namespace fc { namespace rpc {
}
}
}
else if( i != obj.end() )
else if( i != obj.end() ) //handle any received JSON response
{
uint64_t id = i->value().as_int64();
auto await = _awaiting.find(id);
@ -149,11 +149,11 @@ namespace fc { namespace rpc {
{
auto r = obj.find("result");
auto e = obj.find("error");
if( r != obj.end() )
if( r != obj.end() ) //if regular result response
{
await->second->set_value( r->value() );
}
else if( e != obj.end() )
else if( e != obj.end() ) //if error response
{
try
{

4
src/variant.cpp
View file

@ -486,7 +486,7 @@ const string& variant::get_string()const
{
if( get_type() == string_type )
return **reinterpret_cast<const const_string_ptr*>(this);
FC_THROW_EXCEPTION( bad_cast_exception, "Invalid cast from ${type} to Object" );
FC_THROW_EXCEPTION( bad_cast_exception, "Invalid cast from type '${type}' to Object", ("type",int(get_type())) );
}
@ -495,7 +495,7 @@ const variant_object& variant::get_object()const
{
if( get_type() == object_type )
return **reinterpret_cast<const const_variant_object_ptr*>(this);
FC_THROW_EXCEPTION( bad_cast_exception, "Invalid cast from ${type} to Object" );
FC_THROW_EXCEPTION( bad_cast_exception, "Invalid cast from type '${type}' to Object", ("type",int(get_type())) );
}
void to_variant( const std::string& s, variant& v )