diff options
author | jai <jai@ae88bc3d-4319-0410-8dbf-d08b4c9d3795> | 2007-02-16 16:41:53 +0000 |
---|---|---|
committer | jai <jai@ae88bc3d-4319-0410-8dbf-d08b4c9d3795> | 2007-02-16 16:41:53 +0000 |
commit | 1b16b2a605536086687d808657bafa26b55231e5 (patch) | |
tree | e26d5ec9873acdc49f7b1521702346cf35868529 /TAO/tao/DiffServPolicy | |
parent | 37e86d16e460284fa8b94b8473939737b07bf5ec (diff) | |
download | ATCD-1b16b2a605536086687d808657bafa26b55231e5.tar.gz |
adding DS library
Diffstat (limited to 'TAO/tao/DiffServPolicy')
17 files changed, 1505 insertions, 0 deletions
diff --git a/TAO/tao/DiffServPolicy/Client_Network_Priority_Policy.cpp b/TAO/tao/DiffServPolicy/Client_Network_Priority_Policy.cpp new file mode 100644 index 00000000000..49c324115cb --- /dev/null +++ b/TAO/tao/DiffServPolicy/Client_Network_Priority_Policy.cpp @@ -0,0 +1,154 @@ +// $Id$ + +#include "tao/DiffServPolicy/Client_Network_Priority_Policy.h" +#include "tao/DiffServPolicy/DiffServPolicyC.h" +#include "tao/ORB_Constants.h" +#include "tao/SystemException.h" + +ACE_RCSID (DiffServPolicy, + Client_Network_Priority_Policy, + "$Id$") + +TAO_BEGIN_VERSIONED_NAMESPACE_DECL + +TAO_Client_Network_Priority_Policy::TAO_Client_Network_Priority_Policy (void) + : ::CORBA::Object () + , ::CORBA::Policy () + , ::CORBA::LocalObject () + , TAO::NetworkPriorityPolicy () + , TAO_Local_RefCounted_Object () + , request_diffserv_codepoint_ (0) + , reply_diffserv_codepoint_ (0) + , network_priority_model_ (TAO::NO_NETWORK_PRIORITY) +{ +} + +TAO_Client_Network_Priority_Policy::TAO_Client_Network_Priority_Policy ( + const TAO::DiffservCodepoint request_diffserv_codepoint, + const TAO::DiffservCodepoint reply_diffserv_codepoint, + TAO::NetworkPriorityModel network_priority_model) + : ::CORBA::Object () + , ::CORBA::Policy () + , ::CORBA::LocalObject () + , TAO::NetworkPriorityPolicy () + , TAO_Local_RefCounted_Object () + , request_diffserv_codepoint_ (request_diffserv_codepoint) + , reply_diffserv_codepoint_ (reply_diffserv_codepoint) + , network_priority_model_ (network_priority_model) +{ +} + +TAO_Client_Network_Priority_Policy::TAO_Client_Network_Priority_Policy ( + const TAO_Client_Network_Priority_Policy &rhs) + : ::CORBA::Object () + , ::CORBA::Policy () + , ::CORBA::LocalObject () + , TAO::NetworkPriorityPolicy () + , TAO_Local_RefCounted_Object () + , request_diffserv_codepoint_ (rhs.request_diffserv_codepoint_) + , reply_diffserv_codepoint_ (rhs.reply_diffserv_codepoint_) + , network_priority_model_ (rhs.network_priority_model_) +{ +} + +CORBA::Policy_ptr +TAO_Client_Network_Priority_Policy::create (const CORBA::Any &) +{ + CORBA::Policy_ptr policy = CORBA::Policy::_nil (); + + ACE_NEW_THROW_EX (policy, + TAO_Client_Network_Priority_Policy (), + CORBA::NO_MEMORY ( + CORBA::SystemException::_tao_minor_code ( + TAO::VMCID, + ENOMEM), + CORBA::COMPLETED_NO)); + + return policy; +} + +CORBA::PolicyType +TAO_Client_Network_Priority_Policy::policy_type (void) +{ + return TAO::CLIENT_NETWORK_PRIORITY_TYPE; +} + +TAO_Client_Network_Priority_Policy * +TAO_Client_Network_Priority_Policy::clone (void) const +{ + TAO_Client_Network_Priority_Policy *copy = 0; + ACE_NEW_RETURN (copy, + TAO_Client_Network_Priority_Policy (*this), + 0); + return copy; +} + +TAO::DiffservCodepoint +TAO_Client_Network_Priority_Policy::request_diffserv_codepoint (void) +{ + return this->request_diffserv_codepoint_; +} + +void +TAO_Client_Network_Priority_Policy::request_diffserv_codepoint ( + TAO::DiffservCodepoint req_dscp) +{ + this->request_diffserv_codepoint_ = req_dscp; +} + +TAO::DiffservCodepoint +TAO_Client_Network_Priority_Policy::reply_diffserv_codepoint (void) +{ + return this->reply_diffserv_codepoint_; +} + +void +TAO_Client_Network_Priority_Policy::reply_diffserv_codepoint ( + TAO::DiffservCodepoint reply_dscp) +{ + this->reply_diffserv_codepoint_ = reply_dscp; +} + +TAO::NetworkPriorityModel +TAO_Client_Network_Priority_Policy::network_priority_model (void) +{ + return this->network_priority_model_; +} + +void +TAO_Client_Network_Priority_Policy::network_priority_model ( + TAO::NetworkPriorityModel npm) +{ + this->network_priority_model_ = npm; +} + +CORBA::Policy_ptr +TAO_Client_Network_Priority_Policy::copy (void) +{ + TAO_Client_Network_Priority_Policy* servant = 0; + ACE_NEW_THROW_EX (servant, + TAO_Client_Network_Priority_Policy (*this), + CORBA::NO_MEMORY ()); + + return servant; +} + +void +TAO_Client_Network_Priority_Policy::destroy (void) +{ +} + +TAO_Cached_Policy_Type +TAO_Client_Network_Priority_Policy::_tao_cached_type (void) const +{ + return TAO_CACHED_POLICY_CLIENT_NETWORK_PRIORITY; +} + +TAO_Policy_Scope +TAO_Client_Network_Priority_Policy::_tao_scope (void) const +{ + return static_cast<TAO_Policy_Scope> (TAO_POLICY_DEFAULT_SCOPE | + TAO_POLICY_CLIENT_EXPOSED); +} + +TAO_END_VERSIONED_NAMESPACE_DECL diff --git a/TAO/tao/DiffServPolicy/Client_Network_Priority_Policy.h b/TAO/tao/DiffServPolicy/Client_Network_Priority_Policy.h new file mode 100644 index 00000000000..56e2d41a162 --- /dev/null +++ b/TAO/tao/DiffServPolicy/Client_Network_Priority_Policy.h @@ -0,0 +1,107 @@ +// -*- C++ -*- + +//============================================================================= +/** + * @file Client_Network_Priority_Policy.h + * + * $Id$ + * + * + */ +//============================================================================= + + +#ifndef TAO_CLIENT_NETWORK_PRIORITY_POLICY_H +#define TAO_CLIENT_NETWORK_PRIORITY_POLICY_H + +#include /**/ "ace/pre.h" + +#include "tao/DiffServPolicy/DiffServPolicy_Export.h" + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +# pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + +#include "tao/LocalObject.h" +#include "tao/Basic_Types.h" +#include "tao/DiffServPolicy/DiffServPolicyC.h" + +#if defined(_MSC_VER) +#pragma warning(push) +#pragma warning(disable:4250) +#endif /* _MSC_VER */ + +TAO_BEGIN_VERSIONED_NAMESPACE_DECL + +/** + * @class TAO_Client_Network_Priority_Policy + * + * @brief Implementation class for TAO-specific Network Priority Policy. + * + * This policy is defined by a client application to specify the + * network priority model that it would like to follow, as well as + * the request DiffServ codepoint and reply DiffServ codepoint + * corresponding to the network priority model. + */ +class TAO_DiffServPolicy_Export TAO_Client_Network_Priority_Policy + : public TAO::NetworkPriorityPolicy, + public TAO_Local_RefCounted_Object +{ +public: + /// Constructor. + TAO_Client_Network_Priority_Policy (void); + + /// Constructor. + TAO_Client_Network_Priority_Policy ( + const TAO::DiffservCodepoint request_diffserv_codepoint, + const TAO::DiffservCodepoint reply_diffserv_codepoint, + TAO::NetworkPriorityModel network_priority_model); + + /// Copy constructor. + TAO_Client_Network_Priority_Policy ( + const TAO_Client_Network_Priority_Policy &rhs); + + /// Returns a copy of <this>. + TAO_Client_Network_Priority_Policy *clone (void) const; + + TAO::DiffservCodepoint request_diffserv_codepoint (void); + + void request_diffserv_codepoint (TAO::DiffservCodepoint req_dscp); + + TAO::DiffservCodepoint reply_diffserv_codepoint (void); + + void reply_diffserv_codepoint (TAO::DiffservCodepoint reply_dscp); + + TAO::NetworkPriorityModel network_priority_model (void); + + void network_priority_model (TAO::NetworkPriorityModel npm); + + static CORBA::Policy_ptr create (const CORBA::Any &val); + + CORBA::PolicyType policy_type (void); + + CORBA::Policy_ptr copy (void); + + void destroy (void); + + // Return the cached policy type for this policy. + TAO_Cached_Policy_Type _tao_cached_type (void) const; + + // Returns the scope at which this policy can be applied. See orbconf.h. + TAO_Policy_Scope _tao_scope (void) const; + +private: + /// The attribute + TAO::DiffservCodepoint request_diffserv_codepoint_; + TAO::DiffservCodepoint reply_diffserv_codepoint_; + TAO::NetworkPriorityModel network_priority_model_; +}; + +TAO_END_VERSIONED_NAMESPACE_DECL + +#if defined(_MSC_VER) +#pragma warning(pop) +#endif /* _MSC_VER */ + +#include /**/ "ace/post.h" +#endif /* TAO_CLIENT_NETWORK_PRIORITY_POLICY_H */ diff --git a/TAO/tao/DiffServPolicy/DiffServPolicy.cpp b/TAO/tao/DiffServPolicy/DiffServPolicy.cpp new file mode 100644 index 00000000000..afdd56aef12 --- /dev/null +++ b/TAO/tao/DiffServPolicy/DiffServPolicy.cpp @@ -0,0 +1,53 @@ +// @(#) $Id$ + +#include "tao/DiffServPolicy/DiffServPolicy.h" +#include "tao/DiffServPolicy/DiffServPolicy_ORBInitializer.h" +#include "tao/DiffServPolicy/DiffServ_Protocols_Hooks.h" +#include "tao/ORB_Core.h" +#include "tao/ORBInitializer_Registry.h" +#include "tao/PI/PI.h" + +ACE_RCSID (DiffServPolicy, DiffServPolicy, "$Id$") + +TAO_BEGIN_VERSIONED_NAMESPACE_DECL + +int +TAO_DiffServPolicy_Initializer::init (void) +{ + // TAO_ORB_Core::set_network_priority_protocols_hooks ( + // "DS_Network_Priority_Protocols_Hooks"); + ACE_Service_Config::process_directive ( + ace_svc_desc_TAO_DS_Network_Priority_Protocols_Hooks); + + PortableInterceptor::ORBInitializer_ptr temp_orb_initializer = + PortableInterceptor::ORBInitializer::_nil (); + PortableInterceptor::ORBInitializer_var orb_initializer; + + try + { + /// Register the EndpointPolicy ORBInitializer. + ACE_NEW_THROW_EX (temp_orb_initializer, + TAO_DiffServPolicy_ORBInitializer, + CORBA::NO_MEMORY ( + CORBA::SystemException::_tao_minor_code ( + TAO::VMCID, + ENOMEM), + CORBA::COMPLETED_NO)); + + orb_initializer = temp_orb_initializer; + + PortableInterceptor::register_orb_initializer (orb_initializer.in ()); + } + catch (const ::CORBA::Exception& ex) + { + if (TAO_debug_level > 0) + { + ex._tao_print_exception ("Caught exception:"); + } + return -1; + } + + return 0; +} + +TAO_END_VERSIONED_NAMESPACE_DECL diff --git a/TAO/tao/DiffServPolicy/DiffServPolicy.h b/TAO/tao/DiffServPolicy/DiffServPolicy.h new file mode 100644 index 00000000000..788e567e1ad --- /dev/null +++ b/TAO/tao/DiffServPolicy/DiffServPolicy.h @@ -0,0 +1,50 @@ +// -*- C++ -*- + +//============================================================================= +/** + * @file DiffServPolicy.h + * + * $Id$ + * + * @author Jaiganesh Balasubramanian <jai@dre.vanderbilt.edu> + * Johnny Willemsen <jwillemsen@remedy.nl> + */ +//============================================================================= + + +#ifndef TAO_DIFFSERVPOLICY_H +#define TAO_DIFFSERVPOLICY_H + +#include /**/ "ace/pre.h" + +#include "tao/DiffServPolicy/DiffServPolicy_Export.h" + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +# pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + +#include "tao/PI/PI.h" +#include "tao/Versioned_Namespace.h" + +TAO_BEGIN_VERSIONED_NAMESPACE_DECL + +class TAO_DiffServPolicy_Export TAO_DiffServPolicy_Initializer +{ +public: + /// Used to force the initialization of the ORB code. + static int init (void); +}; + +static int +TAO_Requires_DiffServPolicy_Initializer = + TAO_DiffServPolicy_Initializer::init (); + +TAO_END_VERSIONED_NAMESPACE_DECL + +#include /**/ "ace/post.h" + +#define TAO_DIFFSERVPOLICY_SAFE_INCLUDE +#include "tao/DiffServPolicy/DiffServPolicyC.h" +#undef TAO_DIFFSERVPOLICY_SAFE_INCLUDE + +#endif /* TAO_DIFFSERVPOLICY_H */ diff --git a/TAO/tao/DiffServPolicy/DiffServPolicy.pidl b/TAO/tao/DiffServPolicy/DiffServPolicy.pidl new file mode 100644 index 00000000000..aee68884a08 --- /dev/null +++ b/TAO/tao/DiffServPolicy/DiffServPolicy.pidl @@ -0,0 +1,61 @@ +// -*- IDL -*- + +// ================================================================ +/** + * @file DiffServPolicy.pidl + * + * $Id$ + * + * This file contains TAO-specific idl interfaces for adding + * network priority or DiffServ support (not part of CORBA + * 2.6). + * + * The steps to regenerate the code are as follows: + * + * 1. Run the tao_idl compiler on the pidl file. The command used for + * this is: + * + * tao_idl + * -o orig -Gp -Gd -Ge 1 -GA -SS -Sci + * -Wb,export_macro=TAO_Export + * -Wb,pre_include="ace/pre.h" + * -Wb,post_include="ace/post.h" + * TAO_Network_Priority_Policy.pidl + * + * 2. The files are ready to use + */ +// ================================================================ + +#ifndef TAO_DIFFSERV_POLICY_IDL +#define TAO_DIFFSERV_POLICY_IDL + +#include "tao/Policy.pidl" + +#pragma prefix "tao" + +module TAO +{ + typedef long DiffservCodepoint; + + enum NetworkPriorityModel + { + CLIENT_PROPAGATED_NETWORK_PRIORITY, + SERVER_DECLARED_NETWORK_PRIORITY, + NO_NETWORK_PRIORITY + }; + + const CORBA::PolicyType SERVER_NETWORK_PRIORITY_TYPE = 85; + const CORBA::PolicyType CLIENT_NETWORK_PRIORITY_TYPE = 86; + const CORBA::PolicyType NETWORK_PRIORITY_TYPE = 87; + + local interface NetworkPriorityPolicy : CORBA::Policy + { + attribute NetworkPriorityModel network_priority_model; + attribute DiffservCodepoint request_diffserv_codepoint; + attribute DiffservCodepoint reply_diffserv_codepoint; + }; +}; + +#pragma prefix "" + +#endif /* TAO_DIFFSERV_POLICY_IDL */ diff --git a/TAO/tao/DiffServPolicy/DiffServPolicy_Export.h b/TAO/tao/DiffServPolicy/DiffServPolicy_Export.h new file mode 100644 index 00000000000..2c6f69d9411 --- /dev/null +++ b/TAO/tao/DiffServPolicy/DiffServPolicy_Export.h @@ -0,0 +1,58 @@ + +// -*- C++ -*- +// $Id$ +// Definition for Win32 Export directives. +// This file is generated automatically by generate_export_file.pl -s TAO_DiffServPolicy +// ------------------------------ +#ifndef TAO_DIFFSERVPOLICY_EXPORT_H +#define TAO_DIFFSERVPOLICY_EXPORT_H + +#include "ace/config-all.h" + +#if defined (ACE_AS_STATIC_LIBS) && !defined (TAO_DIFFSERVPOLICY_HAS_DLL) +# define TAO_DIFFSERVPOLICY_HAS_DLL 0 +#endif /* ACE_AS_STATIC_LIBS && TAO_DIFFSERVPOLICY_HAS_DLL */ + +#if !defined (TAO_DIFFSERVPOLICY_HAS_DLL) +# define TAO_DIFFSERVPOLICY_HAS_DLL 1 +#endif /* ! TAO_DIFFSERVPOLICY_HAS_DLL */ + +#if defined (TAO_DIFFSERVPOLICY_HAS_DLL) && (TAO_DIFFSERVPOLICY_HAS_DLL == 1) +# if defined (TAO_DIFFSERVPOLICY_BUILD_DLL) +# define TAO_DiffServPolicy_Export ACE_Proper_Export_Flag +# define TAO_DIFFSERVPOLICY_SINGLETON_DECLARATION(T) ACE_EXPORT_SINGLETON_DECLARATION (T) +# define TAO_DIFFSERVPOLICY_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK) ACE_EXPORT_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK) +# else /* TAO_DIFFSERVPOLICY_BUILD_DLL */ +# define TAO_DiffServPolicy_Export ACE_Proper_Import_Flag +# define TAO_DIFFSERVPOLICY_SINGLETON_DECLARATION(T) ACE_IMPORT_SINGLETON_DECLARATION (T) +# define TAO_DIFFSERVPOLICY_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK) ACE_IMPORT_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK) +# endif /* TAO_DIFFSERVPOLICY_BUILD_DLL */ +#else /* TAO_DIFFSERVPOLICY_HAS_DLL == 1 */ +# define TAO_DiffServPolicy_Export +# define TAO_DIFFSERVPOLICY_SINGLETON_DECLARATION(T) +# define TAO_DIFFSERVPOLICY_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK) +#endif /* TAO_DIFFSERVPOLICY_HAS_DLL == 1 */ + +// Set TAO_DIFFSERVPOLICY_NTRACE = 0 to turn on library specific tracing even if +// tracing is turned off for ACE. +#if !defined (TAO_DIFFSERVPOLICY_NTRACE) +# if (ACE_NTRACE == 1) +# define TAO_DIFFSERVPOLICY_NTRACE 1 +# else /* (ACE_NTRACE == 1) */ +# define TAO_DIFFSERVPOLICY_NTRACE 0 +# endif /* (ACE_NTRACE == 1) */ +#endif /* !TAO_DIFFSERVPOLICY_NTRACE */ + +#if (TAO_DIFFSERVPOLICY_NTRACE == 1) +# define TAO_DIFFSERVPOLICY_TRACE(X) +#else /* (TAO_DIFFSERVPOLICY_NTRACE == 1) */ +# if !defined (ACE_HAS_TRACE) +# define ACE_HAS_TRACE +# endif /* ACE_HAS_TRACE */ +# define TAO_DIFFSERVPOLICY_TRACE(X) ACE_TRACE_IMPL(X) +# include "ace/Trace.h" +#endif /* (TAO_DIFFSERVPOLICY_NTRACE == 1) */ + +#endif /* TAO_DIFFSERVPOLICY_EXPORT_H */ + +// End of auto generated file. diff --git a/TAO/tao/DiffServPolicy/DiffServPolicy_Factory.cpp b/TAO/tao/DiffServPolicy/DiffServPolicy_Factory.cpp new file mode 100644 index 00000000000..3fed4990ac9 --- /dev/null +++ b/TAO/tao/DiffServPolicy/DiffServPolicy_Factory.cpp @@ -0,0 +1,62 @@ +#include "tao/DiffServPolicy/DiffServPolicy_Factory.h" + +ACE_RCSID (DiffServPolicy, + DiffServPolicy_Factory, + "$Id$") + +#include "tao/DiffServPolicy/Client_Network_Priority_Policy.h" +#include "tao/DiffServPolicy/Server_Network_Priority_Policy.h" +#include "tao/PolicyC.h" +#include "tao/ORB_Constants.h" + +TAO_BEGIN_VERSIONED_NAMESPACE_DECL + +CORBA::Policy_ptr +TAO_DiffServ_PolicyFactory::create_policy ( + CORBA::PolicyType type, + const CORBA::Any &value) +{ + if (type == TAO::CLIENT_NETWORK_PRIORITY_TYPE) + return TAO_Client_Network_Priority_Policy::create (value); + + if (type == TAO::NETWORK_PRIORITY_TYPE) + return TAO_Server_Network_Priority_Policy::create (value); + + throw ::CORBA::PolicyError (CORBA::BAD_POLICY_TYPE); +} + +CORBA::Policy_ptr +TAO_DiffServ_PolicyFactory::_create_policy (CORBA::PolicyType type) +{ + CORBA::Policy_ptr policy = CORBA::Policy::_nil (); + + if (type == TAO::CLIENT_NETWORK_PRIORITY_TYPE) + { + ACE_NEW_THROW_EX (policy, + TAO_Client_Network_Priority_Policy (), + CORBA::NO_MEMORY ( + CORBA::SystemException::_tao_minor_code ( + TAO::VMCID, + ENOMEM), + CORBA::COMPLETED_NO)); + + return policy; + } + + if (type == TAO::NETWORK_PRIORITY_TYPE) + { + ACE_NEW_THROW_EX (policy, + TAO_Server_Network_Priority_Policy (), + CORBA::NO_MEMORY ( + CORBA::SystemException::_tao_minor_code ( + TAO::VMCID, + ENOMEM), + CORBA::COMPLETED_NO)); + + return policy; + } + + throw ::CORBA::PolicyError (CORBA::BAD_POLICY_TYPE); +} + +TAO_END_VERSIONED_NAMESPACE_DECL diff --git a/TAO/tao/DiffServPolicy/DiffServPolicy_Factory.h b/TAO/tao/DiffServPolicy/DiffServPolicy_Factory.h new file mode 100644 index 00000000000..9c58492b252 --- /dev/null +++ b/TAO/tao/DiffServPolicy/DiffServPolicy_Factory.h @@ -0,0 +1,60 @@ +// -*- C++ -*- + +//============================================================================= +/** + * @file DiffServPolicy_Factory.h + * + * $Id$ + * + * @author Jaiganesh Balasubramanian <jai@dre.vanderbilt.edu> + * @author Johnny Willemsen <jwillemsen@remedy.nl> + */ +//============================================================================= + + +#ifndef TAO_DIFFSERV_POLICY_FACTORY_H +#define TAO_DIFFSERV_POLICY_FACTORY_H + +#include /**/ "ace/pre.h" + +#include "tao/orbconf.h" +#include "tao/DiffServPolicy/DiffServPolicy_Export.h" + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +# pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + +#include "tao/PI/PI.h" +#include "tao/LocalObject.h" + +// This is to remove "inherits via dominance" warnings from MSVC. +// MSVC is being a little too paranoid. +#if defined(_MSC_VER) +#pragma warning(push) +#pragma warning(disable:4250) +#endif /* _MSC_VER */ + +TAO_BEGIN_VERSIONED_NAMESPACE_DECL + +/// Policy factory for all DiffServ related policies. +class TAO_DiffServPolicy_Export TAO_DiffServ_PolicyFactory + : public virtual PortableInterceptor::PolicyFactory, + public virtual TAO_Local_RefCounted_Object +{ +public: + + CORBA::Policy_ptr create_policy (CORBA::PolicyType type, + const CORBA::Any &value); + + CORBA::Policy_ptr _create_policy (CORBA::PolicyType type); +}; + +TAO_END_VERSIONED_NAMESPACE_DECL + +#if defined(_MSC_VER) +#pragma warning(pop) +#endif /* _MSC_VER */ + +#include /**/ "ace/post.h" + +#endif /* TAO_DIFFSERV_POLICY_FACTORY_H */ diff --git a/TAO/tao/DiffServPolicy/DiffServPolicy_ORBInitializer.cpp b/TAO/tao/DiffServPolicy/DiffServPolicy_ORBInitializer.cpp new file mode 100644 index 00000000000..52532c410ad --- /dev/null +++ b/TAO/tao/DiffServPolicy/DiffServPolicy_ORBInitializer.cpp @@ -0,0 +1,87 @@ +// $Id$ + +#include "tao/DiffServPolicy/DiffServPolicy_ORBInitializer.h" +#include "tao/DiffServPolicy/DiffServPolicyC.h" +#include "tao/DiffServPolicy/DiffServPolicy_Factory.h" +#include "tao/DiffServPolicy/DiffServ_Protocols_Hooks.h" +#include "tao/ORB_Core.h" +#include "tao/PI/ORBInitInfo.h" + +ACE_RCSID (DiffServPolicy, + DiffServPolicy_ORBInitializer, + "$Id$") + +TAO_BEGIN_VERSIONED_NAMESPACE_DECL + +void +TAO_DiffServPolicy_ORBInitializer::pre_init ( + PortableInterceptor::ORBInitInfo_ptr) +{ +} + +void +TAO_DiffServPolicy_ORBInitializer::post_init ( + PortableInterceptor::ORBInitInfo_ptr info) +{ + this->register_policy_factories (info); +} + +void +TAO_DiffServPolicy_ORBInitializer::register_policy_factories ( + PortableInterceptor::ORBInitInfo_ptr info) +{ + if (CORBA::is_nil (this->policy_factory_.in ())) + { + PortableInterceptor::PolicyFactory_ptr policy_factory; + ACE_NEW_THROW_EX (policy_factory, + TAO_DiffServ_PolicyFactory, + CORBA::NO_MEMORY ( + CORBA::SystemException::_tao_minor_code ( + TAO::VMCID, + ENOMEM), + CORBA::COMPLETED_NO)); + + this->policy_factory_ = policy_factory; + } + + // Bind the same policy factory to all DiffServ related policy + // types since a single policy factory is used to create each of + // the different types of DiffServ policies. + static CORBA::PolicyType const type[] = { + TAO::CLIENT_NETWORK_PRIORITY_TYPE, + TAO::NETWORK_PRIORITY_TYPE + }; + + const CORBA::PolicyType *end = + type + sizeof (type) / sizeof (type[0]); + + for (CORBA::PolicyType const * i = type; + i != end; + ++i) + { + try + { + info->register_policy_factory (*i, this->policy_factory_.in ()); + } + catch ( ::CORBA::BAD_INV_ORDER& ex) + { + if (ex.minor () == (CORBA::OMGVMCID | 16)) + { + // The factory is already there, it happens because the + // magic initializer in PortableServer.cpp registers + // with the ORB multiple times. This is an indication + // that we should do no more work in this + // ORBInitializer. + return; + } + throw; + } + catch ( ::CORBA::Exception&) + { + // Rethrow any other exceptions... + throw; + } + } +} + +TAO_END_VERSIONED_NAMESPACE_DECL diff --git a/TAO/tao/DiffServPolicy/DiffServPolicy_ORBInitializer.h b/TAO/tao/DiffServPolicy/DiffServPolicy_ORBInitializer.h new file mode 100644 index 00000000000..74b3295c32c --- /dev/null +++ b/TAO/tao/DiffServPolicy/DiffServPolicy_ORBInitializer.h @@ -0,0 +1,65 @@ +// -*- C++ -*- + +//============================================================================= +/** + * @file DiffServPolicy_ORBInitializer.h + * + * $Id$ + * + * @author Jaiganesh Balasubramanian <jai@dre.vanderbilt.edu> + * Johnny Willemsen <jwillemsen@remedy.nl> + */ +//============================================================================= + + +#ifndef TAO_DIFFSERV_POLICY_ORB_INITIALIZER_H +#define TAO_DIFFSERV_POLICY_ORB_INITIALIZER_H + +#include /**/ "ace/pre.h" + +#include "tao/DiffServPolicy/DiffServPolicy_Export.h" + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +# pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + +#include "tao/PI/PI.h" +#include "tao/LocalObject.h" + +// This is to remove "inherits via dominance" warnings from MSVC. +// MSVC is being a little too paranoid. +#if defined(_MSC_VER) +#pragma warning(push) +#pragma warning(disable:4250) +#endif /* _MSC_VER */ + +TAO_BEGIN_VERSIONED_NAMESPACE_DECL + +/// DiffServ Policy ORB initializer. +class TAO_DiffServPolicy_Export TAO_DiffServPolicy_ORBInitializer + : public virtual PortableInterceptor::ORBInitializer + , public virtual TAO_Local_RefCounted_Object +{ +public: + virtual void pre_init (PortableInterceptor::ORBInitInfo_ptr info); + + virtual void post_init (PortableInterceptor::ORBInitInfo_ptr info); + +private: + + /// Register DiffServ policy factories. + void register_policy_factories (PortableInterceptor::ORBInitInfo_ptr info); + +private: + PortableInterceptor::PolicyFactory_var policy_factory_; +}; + +TAO_END_VERSIONED_NAMESPACE_DECL + +#if defined(_MSC_VER) +#pragma warning(pop) +#endif /* _MSC_VER */ + +#include /**/ "ace/post.h" + +#endif /* TAO_DIFFSERV_POLICY_ORB_INITIALIZER_H */ diff --git a/TAO/tao/DiffServPolicy/DiffServ_Network_Priority_Hook.cpp b/TAO/tao/DiffServPolicy/DiffServ_Network_Priority_Hook.cpp new file mode 100644 index 00000000000..75ded365ad1 --- /dev/null +++ b/TAO/tao/DiffServPolicy/DiffServ_Network_Priority_Hook.cpp @@ -0,0 +1,106 @@ +// @(#) $Id$ + +#include "tao/DiffServPolicy/DiffServ_Network_Priority_Hook.h" +#include "tao/PortableServer/Root_POA.h" +#include "tao/PortableServer/POA_Policy_Set.h" +#include "tao/DiffServPolicy/Server_Network_Priority_Policy.h" +#include "tao/DiffServPolicy/DiffServPolicyC.h" +#include "tao/Service_Context.h" +#include "tao/TAO_Server_Request.h" +#include "tao/Network_Priority_Protocols_Hooks.h" +#include "tao/ORB_Core.h" +#include "tao/Connection_Handler.h" + +ACE_RCSID(DiffServPolicy, + DiffServ_Network_Priority_Hook, + "$Id$") + + +TAO_BEGIN_VERSIONED_NAMESPACE_DECL + + +TAO_DiffServ_Network_Priority_Hook::~TAO_DiffServ_Network_Priority_Hook(void) +{ +} + +void +TAO_DiffServ_Network_Priority_Hook::update_network_priority ( + TAO_Root_POA &poa, TAO_POA_Policy_Set &policy_set) +{ + for (CORBA::ULong i = 0; i < policy_set.num_policies (); i++) + { + CORBA::Policy_var policy = policy_set.get_policy_by_index (i); + + if (policy->policy_type () == TAO::NETWORK_PRIORITY_TYPE) + { + ::TAO::NetworkPriorityPolicy_var npp + = ::TAO::NetworkPriorityPolicy::_narrow (policy); + + if (!CORBA::is_nil (npp.in ())) + { + TAO::NetworkPriorityModel network_priority_model = + npp->network_priority_model (); + + poa.cached_policies ().network_priority_model ( + TAO::Portable_Server::Cached_Policies::NetworkPriorityModel ( + network_priority_model)); + + TAO::DiffservCodepoint request_diffserv_codepoint = + npp->request_diffserv_codepoint (); + + TAO::DiffservCodepoint reply_diffserv_codepoint = + npp->reply_diffserv_codepoint (); + + poa.cached_policies ().request_diffserv_codepoint ( + request_diffserv_codepoint); + poa.cached_policies ().reply_diffserv_codepoint ( + reply_diffserv_codepoint); + } + } + } +} + +void +TAO_DiffServ_Network_Priority_Hook::set_dscp_codepoint ( + TAO_ServerRequest &req, TAO_Root_POA &poa) +{ + CORBA::Long dscp_codepoint; + TAO_Service_Context &request_service_context = + req.request_service_context (); + + TAO_Network_Priority_Protocols_Hooks *nph = + poa.orb_core ().get_network_priority_protocols_hooks (); + + TAO::Portable_Server::Cached_Policies::NetworkPriorityModel npm = + poa.cached_policies ().network_priority_model (); + + if (npm == TAO::Portable_Server::Cached_Policies:: + CLIENT_PROPAGATED_NETWORK_PRIORITY) + { + dscp_codepoint = nph->get_dscp_codepoint (request_service_context); + } + else if (npm == TAO::Portable_Server::Cached_Policies:: + SERVER_DECLARED_NETWORK_PRIORITY) + { + dscp_codepoint = poa.cached_policies ().reply_diffserv_codepoint (); + } + else + { + dscp_codepoint = 0; + } + + TAO_Connection_Handler *connection_handler = + req.transport ()->connection_handler (); + connection_handler->set_dscp_codepoint (dscp_codepoint); +} + +TAO_END_VERSIONED_NAMESPACE_DECL + +ACE_FACTORY_DEFINE (TAO_DiffServPolicy, TAO_DiffServ_Network_Priority_Hook) +ACE_STATIC_SVC_DEFINE (TAO_DiffServ_Network_Priority_Hook, + ACE_TEXT ("TAO_Network_Priority_Hook"), + ACE_SVC_OBJ_T, + &ACE_SVC_NAME (TAO_DiffServ_Network_Priority_Hook), + ACE_Service_Type::DELETE_THIS + | ACE_Service_Type::DELETE_OBJ, + 0) diff --git a/TAO/tao/DiffServPolicy/DiffServ_Network_Priority_Hook.h b/TAO/tao/DiffServPolicy/DiffServ_Network_Priority_Hook.h new file mode 100644 index 00000000000..c27837e29a7 --- /dev/null +++ b/TAO/tao/DiffServPolicy/DiffServ_Network_Priority_Hook.h @@ -0,0 +1,60 @@ +// -*- C++ -*- + +//============================================================================= +/** + * @file Diffserv_Network_Priority_Hook.h + * + * $Id$ + * + * @author Jaiganesh Balasubramanian <jai@dre.vanderbilt.edu> + * Johnny Willemsen <jwillemsen@remedy.nl> + */ +//============================================================================= + +#ifndef TAO_DIFFSERV_NETWORK_PRIORITY_HOOK_H +#define TAO_DIFFSERV_NETWORK_PRIORITY_HOOK_H + +#include /**/ "ace/pre.h" +#include "ace/Service_Config.h" + +#include "tao/DiffServPolicy/DiffServPolicy_Export.h" + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +# pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + +#include "tao/PortableServer/Network_Priority_Hook.h" + +TAO_BEGIN_VERSIONED_NAMESPACE_DECL + +class TAO_DiffServPolicy_Export TAO_DiffServ_Network_Priority_Hook + : public TAO_Network_Priority_Hook +{ +public: + virtual ~TAO_DiffServ_Network_Priority_Hook(void); + + /// This function is a hook, that is called from the Root_POA's + /// constructor. It allows the POA to cache the server side network + /// priority policy, so that it can be used for sending replies with the + /// policy-specified DiffServ codepoint. + /// + void update_network_priority (TAO_Root_POA &poa, + TAO_POA_Policy_Set &poa_policy_set); + + /// This function is a hook, that is used by the POA's servant dispatcher + /// when it tries to assign DiffServ codepoints on the replies. + /// + void set_dscp_codepoint (TAO_ServerRequest &req, + TAO_Root_POA &poa); +}; + +TAO_END_VERSIONED_NAMESPACE_DECL + +ACE_STATIC_SVC_DECLARE_EXPORT (TAO_DiffServPolicy, + TAO_DiffServ_Network_Priority_Hook) +ACE_FACTORY_DECLARE (TAO_DiffServPolicy, TAO_DiffServ_Network_Priority_Hook) + + +#include /**/ "ace/post.h" + +#endif /* TAO_DIFFSERV_NETWORK_PRIORITY_HOOK_H */ diff --git a/TAO/tao/DiffServPolicy/DiffServ_Protocols_Hooks.cpp b/TAO/tao/DiffServPolicy/DiffServ_Protocols_Hooks.cpp new file mode 100644 index 00000000000..dd9160767d1 --- /dev/null +++ b/TAO/tao/DiffServPolicy/DiffServ_Protocols_Hooks.cpp @@ -0,0 +1,192 @@ +#include "tao/DiffServPolicy/DiffServ_Protocols_Hooks.h" +#include "tao/Stub.h" +#include "tao/Profile.h" +#include "tao/ORB_Core.h" +#include "tao/Service_Context.h" +#include "tao/CDR.h" +#include "tao/DiffServPolicy/Client_Network_Priority_Policy.h" +#include "ace/OS_NS_string.h" + +ACE_RCSID (DiffServPolicy, + DiffServ_Protocols_Hooks, + "$Id$") + +TAO_BEGIN_VERSIONED_NAMESPACE_DECL + +TAO_DS_Network_Priority_Protocols_Hooks:: +TAO_DS_Network_Priority_Protocols_Hooks (void) + : orb_core_ (0) +{ +} + + +TAO_DS_Network_Priority_Protocols_Hooks:: +~TAO_DS_Network_Priority_Protocols_Hooks (void) +{ +} + +void +TAO_DS_Network_Priority_Protocols_Hooks::init_hooks (TAO_ORB_Core *orb_core) +{ + this->orb_core_ = orb_core; +} + +void +TAO_DS_Network_Priority_Protocols_Hooks::np_service_context ( + TAO_Stub *stub, + TAO_Service_Context &service_context, + CORBA::Boolean restart) +{ + // If the restart flag is true, then this call for a + // reinvocation. We need not prepare the Service Context List once + // again. We can use the already existing one. + if (!restart) + { + CORBA::Policy_var cnpp = + stub->get_cached_policy (TAO_CACHED_POLICY_CLIENT_NETWORK_PRIORITY); + + if (!CORBA::is_nil (cnpp.in ())) + { + TAO::NetworkPriorityPolicy_var cnp = + TAO::NetworkPriorityPolicy::_narrow (cnpp.in ()); + + TAO::DiffservCodepoint reply_diffserv_codepoint; + reply_diffserv_codepoint = cnp->reply_diffserv_codepoint (); + + CORBA::Long rep_dscp_codepoint = reply_diffserv_codepoint; + + this->add_rep_np_service_context_hook (service_context, + rep_dscp_codepoint); + } + } +} + +void +TAO_DS_Network_Priority_Protocols_Hooks::add_rep_np_service_context_hook ( + TAO_Service_Context &service_context, + CORBA::Long &dscp_codepoint) +{ + TAO_OutputCDR cdr; + if ((cdr << ACE_OutputCDR::from_boolean (TAO_ENCAP_BYTE_ORDER) == 0) + || (cdr << dscp_codepoint) == 0) + { + throw CORBA::MARSHAL (); + } + + service_context.set_context (IOP::REP_NWPRIORITY, cdr); +} + +const CORBA::Long +TAO_DS_Network_Priority_Protocols_Hooks::get_dscp_codepoint ( + TAO_Service_Context &sc) +{ + CORBA::Long dscp_codepoint = 0; + const IOP::ServiceContext *context; + + if (sc.get_context (IOP::REP_NWPRIORITY, &context) == 1) + { + TAO_InputCDR cdr (reinterpret_cast + <const char*> + (context->context_data.get_buffer ()), + context->context_data.length ()); + + CORBA::Boolean byte_order; + if ((cdr >> ACE_InputCDR::to_boolean (byte_order)) == 0) + { + throw (CORBA::MARSHAL ()); + } + cdr.reset_byte_order (static_cast<int> (byte_order)); + + if ((cdr >> dscp_codepoint) == 0) + { + throw (CORBA::MARSHAL ()); + } + } + + return dscp_codepoint; +} + +const CORBA::Long +TAO_DS_Network_Priority_Protocols_Hooks::get_dscp_codepoint ( + TAO_Stub *stub, CORBA::Object *object) +{ + CORBA::Long dscp = 0; + TAO::DiffservCodepoint diffserv_codepoint; + CORBA::Policy_var server_nw_priority_policy; + + CORBA::Policy_var client_nw_priority_policy = + stub->get_cached_policy ( + TAO_CACHED_POLICY_CLIENT_NETWORK_PRIORITY); + + if (CORBA::is_nil (client_nw_priority_policy.in ())) + { + TAO_Stub *server_stub = object->_stubobj (); + TAO_MProfile server_profiles = server_stub->base_profiles (); + CORBA::PolicyList_var policy_list = + server_profiles.policy_list (); + + CORBA::ULong length = policy_list->length (); + + for (CORBA::ULong i = 0; i < length; ++i) + { + if (policy_list[i]->policy_type () == TAO::NETWORK_PRIORITY_TYPE) + { + server_nw_priority_policy = + CORBA::Policy::_duplicate (policy_list[i]); + } + } + + if (CORBA::is_nil (server_nw_priority_policy.in ())) + { + return dscp; + } + else + { + TAO::NetworkPriorityPolicy_var npp = + TAO::NetworkPriorityPolicy::_narrow ( + server_nw_priority_policy.in ()); + + if (!CORBA::is_nil (npp.in ())) + { + TAO::NetworkPriorityModel network_priority_model = + npp->network_priority_model (); + + if (network_priority_model == + TAO::SERVER_DECLARED_NETWORK_PRIORITY) + { + diffserv_codepoint = + npp->request_diffserv_codepoint (); + dscp = diffserv_codepoint; + return dscp; + } + } + } + } + else + { + TAO::NetworkPriorityPolicy_var client_nw_priority = + TAO::NetworkPriorityPolicy::_narrow (client_nw_priority_policy.in ()); + + if (!CORBA::is_nil (client_nw_priority.in ())) + { + diffserv_codepoint = + client_nw_priority->request_diffserv_codepoint (); + dscp = diffserv_codepoint; + return dscp; + } + } + + return dscp; +} + +TAO_END_VERSIONED_NAMESPACE_DECL + +ACE_STATIC_SVC_DEFINE (TAO_DS_Network_Priority_Protocols_Hooks, + ACE_TEXT ("DS_Network_Priority_Protocols_Hooks"), + ACE_SVC_OBJ_T, + &ACE_SVC_NAME (TAO_DS_Network_Priority_Protocols_Hooks), + ACE_Service_Type::DELETE_THIS + | ACE_Service_Type::DELETE_OBJ, + 0) +ACE_FACTORY_DEFINE (TAO_DiffServPolicy, + TAO_DS_Network_Priority_Protocols_Hooks) diff --git a/TAO/tao/DiffServPolicy/DiffServ_Protocols_Hooks.h b/TAO/tao/DiffServPolicy/DiffServ_Protocols_Hooks.h new file mode 100644 index 00000000000..20471e00304 --- /dev/null +++ b/TAO/tao/DiffServPolicy/DiffServ_Protocols_Hooks.h @@ -0,0 +1,91 @@ +// -*- C++ -*- + +// =================================================================== +/** + * @file DiffServ_Protocols_Hooks.h + * + * $Id$ + * + * @author Jaiganesh Balasubramanian <jai@dre.vanderbilt.edu> + * Johnny Willemsen <jwillemsen@remedy.nl> + */ +// =================================================================== + +#ifndef TAO_DIFFSERV_PROTOCOLS_HOOKS_H +#define TAO_DIFFSERVT_PROTOCOLS_HOOKS_H + +#include /**/ "ace/pre.h" + +#include "tao/orbconf.h" + +#include "tao/Network_Priority_Protocols_Hooks.h" +#include "ace/Service_Config.h" +#include "tao/DiffServPolicy/DiffServPolicy_Export.h" + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +# pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + +TAO_BEGIN_VERSIONED_NAMESPACE_DECL + +class TAO_DiffServPolicy_Export TAO_DS_Network_Priority_Protocols_Hooks + : public TAO_Network_Priority_Protocols_Hooks +{ +public: + + /// Constructor + TAO_DS_Network_Priority_Protocols_Hooks (void); + + /// Destructor + virtual ~TAO_DS_Network_Priority_Protocols_Hooks (void); + + /// Initialize the network priority protocols hooks instance. + void init_hooks (TAO_ORB_Core *orb_core); + + /// This function is used by the client side ORB to figure out + /// the DiffServ codepoint that needs to be added to the request + /// to be sent to the server. + /// + const CORBA::Long get_dscp_codepoint (TAO_Stub *stub, CORBA::Object *object); + + /// This function is used by the server side to figure out the + /// DiffServ codepoint that is attached and sent as part of the + /// service context of the request from the client side. + /// Specifically, when CLIENT_PROPAGATED networ priority model + /// is followed, the clients sent the DiffServ codepoint, they + /// want the server to use in the reply, as a service context + /// entry in the request. + /// + const CORBA::Long get_dscp_codepoint (TAO_Service_Context &sc); + + /// This function is called from the ORB_Core to add + /// network priority policy specific information on the request + /// service context. Specifically, when CLIENT_PROPAGATED network + /// priority model is used, the DiffServ codepoint that needs to be used + /// by the server side in the reply, is specified as a service context + /// entry, just like how RT-CORBA's CLIENT_PROPAGATED priority model works. + /// + void np_service_context (TAO_Stub *stub, + TAO_Service_Context &service_context, + CORBA::Boolean restart); + + /// Helper function that is used by the np_service_context () method. + /// + void add_rep_np_service_context_hook ( + TAO_Service_Context &service_context, + CORBA::Long &dscp_codepoint); + +protected: + + TAO_ORB_Core *orb_core_; +}; + +TAO_END_VERSIONED_NAMESPACE_DECL + +ACE_STATIC_SVC_DECLARE_EXPORT (TAO_DiffServPolicy, + TAO_DS_Network_Priority_Protocols_Hooks) +ACE_FACTORY_DECLARE (TAO_DiffServPolicy, + TAO_DS_Network_Priority_Protocols_Hooks) + +#include /**/ "ace/post.h" +#endif /* TAO_DIFFSERV_PROTOCOLS_HOOKS_H */ diff --git a/TAO/tao/DiffServPolicy/Server_Network_Priority_Policy.cpp b/TAO/tao/DiffServPolicy/Server_Network_Priority_Policy.cpp new file mode 100644 index 00000000000..12420df0717 --- /dev/null +++ b/TAO/tao/DiffServPolicy/Server_Network_Priority_Policy.cpp @@ -0,0 +1,170 @@ +// $Id$ + +#include "tao/DiffServPolicy/Server_Network_Priority_Policy.h" +#include "tao/DiffServPolicy/DiffServPolicyC.h" +#include "tao/SystemException.h" +#include "tao/ORB_Constants.h" + +ACE_RCSID (DiffServPolicy, + Server_Network_Priority_Policy, + "$Id$") + +TAO_BEGIN_VERSIONED_NAMESPACE_DECL + +TAO_Server_Network_Priority_Policy::TAO_Server_Network_Priority_Policy (void) + : ::CORBA::Object () + , ::CORBA::Policy () + , ::CORBA::LocalObject () + , TAO::NetworkPriorityPolicy () + , TAO_Local_RefCounted_Object () + , request_diffserv_codepoint_ (0) + , reply_diffserv_codepoint_ (0) + , network_priority_model_ (TAO::NO_NETWORK_PRIORITY) +{ +} + +TAO_Server_Network_Priority_Policy::~TAO_Server_Network_Priority_Policy (void) +{ +} + +TAO_Server_Network_Priority_Policy::TAO_Server_Network_Priority_Policy ( + const TAO::DiffservCodepoint &request_diffserv_codepoint, + const TAO::DiffservCodepoint &reply_diffserv_codepoint, + TAO::NetworkPriorityModel &network_priority_model) + : ::CORBA::Object () + , ::CORBA::Policy () + , ::CORBA::LocalObject () + , TAO::NetworkPriorityPolicy () + , TAO_Local_RefCounted_Object () + , request_diffserv_codepoint_ (request_diffserv_codepoint) + , reply_diffserv_codepoint_ (reply_diffserv_codepoint) + , network_priority_model_ (network_priority_model) +{ +} + +TAO_Server_Network_Priority_Policy::TAO_Server_Network_Priority_Policy ( + const TAO_Server_Network_Priority_Policy &rhs) + : ::CORBA::Object () + , ::CORBA::Policy () + , ::CORBA::LocalObject () + , TAO::NetworkPriorityPolicy () + , TAO_Local_RefCounted_Object () + , request_diffserv_codepoint_ (rhs.request_diffserv_codepoint_) + , reply_diffserv_codepoint_ (rhs.reply_diffserv_codepoint_) + , network_priority_model_ (rhs.network_priority_model_) +{ +} + +CORBA::Policy_ptr +TAO_Server_Network_Priority_Policy::create (const CORBA::Any &) +{ + CORBA::Policy_ptr policy = CORBA::Policy::_nil (); + + ACE_NEW_THROW_EX (policy, + TAO_Server_Network_Priority_Policy (), + CORBA::NO_MEMORY (TAO::VMCID, + CORBA::COMPLETED_NO)); + return policy; +} + +CORBA::PolicyType +TAO_Server_Network_Priority_Policy::policy_type (void) +{ + return TAO::NETWORK_PRIORITY_TYPE; +} + +TAO_Server_Network_Priority_Policy * +TAO_Server_Network_Priority_Policy::clone (void) const +{ + TAO_Server_Network_Priority_Policy *copy = 0; + ACE_NEW_RETURN (copy, + TAO_Server_Network_Priority_Policy (*this), + 0); + return copy; +} + +TAO::DiffservCodepoint +TAO_Server_Network_Priority_Policy::request_diffserv_codepoint (void) +{ + return this->request_diffserv_codepoint_; +} + +void +TAO_Server_Network_Priority_Policy::request_diffserv_codepoint ( + TAO::DiffservCodepoint req_dscp) +{ + this->request_diffserv_codepoint_ = req_dscp; +} + +TAO::DiffservCodepoint +TAO_Server_Network_Priority_Policy::reply_diffserv_codepoint (void) +{ + return this->reply_diffserv_codepoint_; +} + +void +TAO_Server_Network_Priority_Policy::reply_diffserv_codepoint ( + TAO::DiffservCodepoint reply_dscp) +{ + this->reply_diffserv_codepoint_ = reply_dscp; +} + +TAO::NetworkPriorityModel +TAO_Server_Network_Priority_Policy::network_priority_model (void) +{ + return this->network_priority_model_; +} + +void +TAO_Server_Network_Priority_Policy::network_priority_model ( + TAO::NetworkPriorityModel npm) +{ + this->network_priority_model_ = npm; +} + +CORBA::Policy_ptr +TAO_Server_Network_Priority_Policy::copy (void) +{ + TAO_Server_Network_Priority_Policy* servant = 0; + ACE_NEW_THROW_EX (servant, + TAO_Server_Network_Priority_Policy (*this), + CORBA::NO_MEMORY ()); + + return servant; +} + +void +TAO_Server_Network_Priority_Policy::destroy (void) +{ +} + +TAO_Cached_Policy_Type +TAO_Server_Network_Priority_Policy::_tao_cached_type (void) const +{ + return TAO_CACHED_POLICY_NETWORK_PRIORITY; +} + +TAO_Policy_Scope +TAO_Server_Network_Priority_Policy::_tao_scope (void) const +{ + return static_cast<TAO_Policy_Scope> (TAO_POLICY_DEFAULT_SCOPE | + TAO_POLICY_CLIENT_EXPOSED); +} + +CORBA::Boolean +TAO_Server_Network_Priority_Policy::_tao_encode (TAO_OutputCDR &out_cdr) +{ + return ((out_cdr << request_diffserv_codepoint_) && + (out_cdr << reply_diffserv_codepoint_) && + (out_cdr << network_priority_model_)); +} + +CORBA::Boolean +TAO_Server_Network_Priority_Policy::_tao_decode (TAO_InputCDR &in_cdr) +{ + return ((in_cdr >> request_diffserv_codepoint_) && + (in_cdr >> reply_diffserv_codepoint_) && + (in_cdr >> network_priority_model_)); +} + +TAO_END_VERSIONED_NAMESPACE_DECL diff --git a/TAO/tao/DiffServPolicy/Server_Network_Priority_Policy.h b/TAO/tao/DiffServPolicy/Server_Network_Priority_Policy.h new file mode 100644 index 00000000000..37b440dc4c5 --- /dev/null +++ b/TAO/tao/DiffServPolicy/Server_Network_Priority_Policy.h @@ -0,0 +1,118 @@ +// -*- C++ -*- + +//============================================================================= +/** + * @file Server_Network_Priority_Policy.h + * + * $Id$ + * + * + */ +//============================================================================= + + +#ifndef TAO_SERVER_NETWORK_PRIORITY_POLICY_H +#define TAO_SERVER_NETWORK_PRIORITY_POLICY_H + +#include /**/ "ace/pre.h" + +#include "tao/DiffServPolicy/DiffServPolicy_Export.h" +#include "tao/DiffServPolicy/DiffServPolicyC.h" + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +# pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + +#include "tao/LocalObject.h" +#include "tao/Basic_Types.h" + +#if defined(_MSC_VER) +#pragma warning(push) +#pragma warning(disable:4250) +#endif /* _MSC_VER */ + +TAO_BEGIN_VERSIONED_NAMESPACE_DECL + +/** + * @class TAO_Server_Network_Priority_Policy + * + * @brief Implementation class for TAO-specific Network Priority Policy. + * + * This policy is defined by a server application to specify the + * network priority model that it would like to follow, as well as + * the request DiffServ codepoint and reply DiffServ codepoint + * corresponding to the network priority model. + */ +class TAO_DiffServPolicy_Export TAO_Server_Network_Priority_Policy + : public TAO::NetworkPriorityPolicy, + public TAO_Local_RefCounted_Object +{ +public: + + /// default constructor. + TAO_Server_Network_Priority_Policy (void); + + /// Constructor. + TAO_Server_Network_Priority_Policy ( + const TAO::DiffservCodepoint &request_diffserv_codepoint, + const TAO::DiffservCodepoint &reply_diffserv_codepoint, + TAO::NetworkPriorityModel &network_priority_model); + + /// Copy constructor. + TAO_Server_Network_Priority_Policy ( + const TAO_Server_Network_Priority_Policy &rhs); + + /// Returns a copy of <this>. + TAO_Server_Network_Priority_Policy *clone (void) const; + + TAO::DiffservCodepoint request_diffserv_codepoint (void); + + void request_diffserv_codepoint (TAO::DiffservCodepoint req_dscp); + + TAO::DiffservCodepoint reply_diffserv_codepoint (void); + + void reply_diffserv_codepoint (TAO::DiffservCodepoint reply_dscp); + + TAO::NetworkPriorityModel network_priority_model (void); + + void network_priority_model (TAO::NetworkPriorityModel npm); + + static CORBA::Policy_ptr create (const CORBA::Any &val); + + CORBA::PolicyType policy_type (void); + + CORBA::Policy_ptr copy (void); + + void destroy (void); + + // Return the cached policy type for this policy. + TAO_Cached_Policy_Type _tao_cached_type (void) const; + + // Returns the scope at which this policy can be applied. See orbconf.h. + TAO_Policy_Scope _tao_scope (void) const; + + /// This method writes a CDR representation of the object state. + CORBA::Boolean _tao_encode (TAO_OutputCDR &out_cdr); + + /// This method reads the object state from a CDR representation. + CORBA::Boolean _tao_decode (TAO_InputCDR &in_cdr); + +protected: + + virtual ~TAO_Server_Network_Priority_Policy (void); + +private: + /// The attributes + TAO::DiffservCodepoint request_diffserv_codepoint_; + TAO::DiffservCodepoint reply_diffserv_codepoint_; + TAO::NetworkPriorityModel network_priority_model_; +}; + +TAO_END_VERSIONED_NAMESPACE_DECL + +#if defined(_MSC_VER) +#pragma warning(pop) +#endif /* _MSC_VER */ + +#include /**/ "ace/post.h" +#endif /* TAO_SERVER_NETWORK_PRIORITY_POLICY_H */ diff --git a/TAO/tao/DiffServPolicy/TAO_DiffServPolicy.pc.in b/TAO/tao/DiffServPolicy/TAO_DiffServPolicy.pc.in new file mode 100644 index 00000000000..67d0a2f065a --- /dev/null +++ b/TAO/tao/DiffServPolicy/TAO_DiffServPolicy.pc.in @@ -0,0 +1,11 @@ +prefix=@prefix@ +exec_prefix=@exec_prefix@ +libdir=@libdir@ +includedir=@includedir@ + +Name: TAO_DiffServPolicy +Description: TAO DiffServPolicy Library +Requires: TAO_PI, TAO_PortableServer, TAO +Version: @VERSION@ +Libs: -L${libdir} -lTAO_DiffServPolicy +Cflags: -I${includedir} |