Home | History | Annotate | Download | only in client 
      1 // Copyright 2014 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "remoting/client/client_status_logger.h"
      6 
      7 #include "base/macros.h"
      8 #include "base/rand_util.h"
      9 #include "remoting/client/chromoting_stats.h"
     10 #include "remoting/client/server_log_entry_client.h"
     11 
     12 using remoting::protocol::ConnectionToHost;
     13 
     14 namespace {
     15 
     16 const char kSessionIdAlphabet[] =
     17     "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890";
     18 const int kSessionIdLength = 20;
     19 
     20 const int kMaxSessionIdAgeDays = 1;
     21 
     22 bool IsStartOfSession(ConnectionToHost::State state) {
     23   return state == ConnectionToHost::INITIALIZING ||
     24       state == ConnectionToHost::CONNECTING ||
     25       state == ConnectionToHost::AUTHENTICATED ||
     26       state == ConnectionToHost::CONNECTED;
     27 }
     28 
     29 bool IsEndOfSession(ConnectionToHost::State state) {
     30   return state == ConnectionToHost::FAILED ||
     31       state == ConnectionToHost::CLOSED;
     32 }
     33 
     34 bool ShouldAddDuration(ConnectionToHost::State state) {
     35   // Duration is added to log entries at the end of the session, as well as at
     36   // some intermediate states where it is relevant (e.g. to determine how long
     37   // it took for a session to become CONNECTED).
     38   return IsEndOfSession(state) || state == ConnectionToHost::CONNECTED;
     39 }
     40 
     41 }  // namespace
     42 
     43 namespace remoting {
     44 
     45 ClientStatusLogger::ClientStatusLogger(ServerLogEntry::Mode mode,
     46                                        SignalStrategy* signal_strategy,
     47                                        const std::string& directory_bot_jid)
     48     : log_to_server_(mode, signal_strategy, directory_bot_jid) {
     49 }
     50 
     51 ClientStatusLogger::~ClientStatusLogger() {
     52 }
     53 
     54 void ClientStatusLogger::LogSessionStateChange(
     55     protocol::ConnectionToHost::State state,
     56     protocol::ErrorCode error) {
     57   DCHECK(CalledOnValidThread());
     58 
     59   scoped_ptr<ServerLogEntry> entry(
     60       MakeLogEntryForSessionStateChange(state, error));
     61   AddClientFieldsToLogEntry(entry.get());
     62   entry->AddModeField(log_to_server_.mode());
     63 
     64   MaybeExpireSessionId();
     65   if (IsStartOfSession(state)) {
     66     // Maybe set the session ID and start time.
     67     if (session_id_.empty()) {
     68       GenerateSessionId();
     69     }
     70     if (session_start_time_.is_null()) {
     71       session_start_time_ = base::TimeTicks::Now();
     72     }
     73   }
     74 
     75   if (!session_id_.empty()) {
     76     AddSessionIdToLogEntry(entry.get(), session_id_);
     77   }
     78 
     79   // Maybe clear the session start time and log the session duration.
     80   if (ShouldAddDuration(state) && !session_start_time_.is_null()) {
     81     AddSessionDurationToLogEntry(entry.get(),
     82                                  base::TimeTicks::Now() - session_start_time_);
     83   }
     84 
     85   if (IsEndOfSession(state)) {
     86     session_start_time_ = base::TimeTicks();
     87     session_id_.clear();
     88   }
     89 
     90   log_to_server_.Log(*entry.get());
     91 }
     92 
     93 void ClientStatusLogger::LogStatistics(ChromotingStats* statistics) {
     94   DCHECK(CalledOnValidThread());
     95 
     96   MaybeExpireSessionId();
     97 
     98   scoped_ptr<ServerLogEntry> entry(MakeLogEntryForStatistics(statistics));
     99   AddClientFieldsToLogEntry(entry.get());
    100   entry->AddModeField(log_to_server_.mode());
    101   AddSessionIdToLogEntry(entry.get(), session_id_);
    102   log_to_server_.Log(*entry.get());
    103 }
    104 
    105 void ClientStatusLogger::SetSignalingStateForTest(SignalStrategy::State state) {
    106   log_to_server_.OnSignalStrategyStateChange(state);
    107 }
    108 
    109 void ClientStatusLogger::GenerateSessionId() {
    110   session_id_.resize(kSessionIdLength);
    111   for (int i = 0; i < kSessionIdLength; i++) {
    112     const int alphabet_size = arraysize(kSessionIdAlphabet) - 1;
    113     session_id_[i] = kSessionIdAlphabet[base::RandGenerator(alphabet_size)];
    114   }
    115   session_id_generation_time_ = base::TimeTicks::Now();
    116 }
    117 
    118 void ClientStatusLogger::MaybeExpireSessionId() {
    119   if (session_id_.empty()) {
    120     return;
    121   }
    122 
    123   base::TimeDelta max_age = base::TimeDelta::FromDays(kMaxSessionIdAgeDays);
    124   if (base::TimeTicks::Now() - session_id_generation_time_ > max_age) {
    125     // Log the old session ID.
    126     scoped_ptr<ServerLogEntry> entry(MakeLogEntryForSessionIdOld(session_id_));
    127     entry->AddModeField(log_to_server_.mode());
    128     log_to_server_.Log(*entry.get());
    129 
    130     // Generate a new session ID.
    131     GenerateSessionId();
    132 
    133     // Log the new session ID.
    134     entry = MakeLogEntryForSessionIdNew(session_id_);
    135     entry->AddModeField(log_to_server_.mode());
    136     log_to_server_.Log(*entry.get());
    137   }
    138 }
    139 
    140 }  // namespace remoting
    141