Home | History | Annotate | Download | only in shill 
      1 //
      2 // Copyright (C) 2012 The Android Open Source Project
      3 //
      4 // Licensed under the Apache License, Version 2.0 (the "License");
      5 // you may not use this file except in compliance with the License.
      6 // You may obtain a copy of the License at
      7 //
      8 //      http://www.apache.org/licenses/LICENSE-2.0
      9 //
     10 // Unless required by applicable law or agreed to in writing, software
     11 // distributed under the License is distributed on an "AS IS" BASIS,
     12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13 // See the License for the specific language governing permissions and
     14 // limitations under the License.
     15 //
     16 
     17 #ifndef SHILL_SCOPE_LOGGER_H_
     18 #define SHILL_SCOPE_LOGGER_H_
     19 
     20 #include <bitset>
     21 #include <string>
     22 #include <vector>
     23 
     24 #include <base/lazy_instance.h>
     25 #include <base/macros.h>
     26 #include <gtest/gtest_prod.h>
     27 
     28 #include "shill/callbacks.h"
     29 
     30 namespace shill {
     31 
     32 // A class that enables logging based on scope and verbose level. It is not
     33 // intended to be used directly but via the SLOG() macros in shill/logging.h
     34 class ScopeLogger {
     35  public:
     36   // Logging scopes.
     37   //
     38   // Update kScopeNames in scope_logger.cc after changing this enumerated type.
     39   // These scope identifiers are sorted by their scope names alphabetically.
     40   enum Scope {
     41     kBinder = 0,
     42     kCellular,
     43     kConnection,
     44     kCrypto,
     45     kDaemon,
     46     kDBus,
     47     kDevice,
     48     kDHCP,
     49     kDNS,
     50     kEthernet,
     51     kHTTP,
     52     kHTTPProxy,
     53     kInet,
     54     kLink,
     55     kManager,
     56     kMetrics,
     57     kModem,
     58     kPortal,
     59     kPower,
     60     kPPP,
     61     kPPPoE,
     62     kProfile,
     63     kProperty,
     64     kResolver,
     65     kRoute,
     66     kRTNL,
     67     kService,
     68     kStorage,
     69     kTask,
     70     kVPN,
     71     kWiFi,
     72     kWiMax,
     73     kNumScopes
     74   };
     75 
     76   typedef base::Callback<void(bool)> ScopeEnableChangedCallback;
     77   typedef std::vector<ScopeEnableChangedCallback>ScopeEnableChangedCallbacks;
     78 
     79   // Returns a singleton of this class.
     80   static ScopeLogger* GetInstance();
     81 
     82   ScopeLogger();
     83   ~ScopeLogger();
     84 
     85   // Returns true if logging is enabled for |scope| and |verbose_level|, i.e.
     86   // scope_enable_[|scope|] is true and |verbose_level| <= |verbose_level_|
     87   bool IsLogEnabled(Scope scope, int verbose_level) const;
     88 
     89   // Returns true if logging is enabled for |scope| at any verbosity level.
     90   bool IsScopeEnabled(Scope scope) const;
     91 
     92   // Returns a string comprising the names, separated by commas, of all scopes.
     93   std::string GetAllScopeNames() const;
     94 
     95   // Returns a string comprising the names, separated by plus signs, of all
     96   // scopes that are enabled for logging.
     97   std::string GetEnabledScopeNames() const;
     98 
     99   // Enables/disables scopes as specified by |expression|.
    100   //
    101   // |expression| is a string comprising a sequence of scope names, each
    102   // prefixed by a plus '+' or minus '-' sign. A scope prefixed by a plus
    103   // sign is enabled for logging, whereas a scope prefixed by a minus sign
    104   // is disabled for logging. Scopes that are not mentioned in |expression|
    105   // remain the same state.
    106   //
    107   // To allow resetting the state of all scopes, an exception is made for the
    108   // first scope name in the sequence, which may not be prefixed by any sign.
    109   // That is considered as an implicit plus sign for that scope and also
    110   // indicates that all scopes are first disabled before enabled by
    111   // |expression|.
    112   //
    113   // If |expression| is an empty string, all scopes are disabled. Any unknown
    114   // scope name found in |expression| is ignored.
    115   void EnableScopesByName(const std::string& expression);
    116 
    117   // Register for log scope enable/disable state changes for |scope|.
    118   void RegisterScopeEnableChangedCallback(
    119       Scope scope, ScopeEnableChangedCallback callback);
    120 
    121   // Sets the verbose level for all scopes to |verbose_level|.
    122   void set_verbose_level(int verbose_level) { verbose_level_ = verbose_level; }
    123 
    124  private:
    125   // Required for constructing LazyInstance<ScopeLogger>.
    126   friend struct base::DefaultLazyInstanceTraits<ScopeLogger>;
    127   friend class ScopeLoggerTest;
    128   FRIEND_TEST(ScopeLoggerTest, GetEnabledScopeNames);
    129   FRIEND_TEST(ScopeLoggerTest, SetScopeEnabled);
    130   FRIEND_TEST(ScopeLoggerTest, SetVerboseLevel);
    131 
    132   // Disables logging for all scopes.
    133   void DisableAllScopes();
    134 
    135   // Enables or disables logging for |scope|.
    136   void SetScopeEnabled(Scope scope, bool enabled);
    137 
    138   // Boolean values to indicate whether logging is enabled for each scope.
    139   std::bitset<kNumScopes> scope_enabled_;
    140 
    141   // Verbose level that is applied to all scopes.
    142   int verbose_level_;
    143 
    144   // Hooks to notify interested parties of changes to log scopes.
    145   ScopeEnableChangedCallbacks log_scope_callbacks_[kNumScopes];
    146 
    147   DISALLOW_COPY_AND_ASSIGN(ScopeLogger);
    148 };
    149 
    150 }  // namespace shill
    151 
    152 #endif  // SHILL_SCOPE_LOGGER_H_
    153