evaluation_context.h revision fb794f4b7274576e10b0df291655ad6c88a97df4
1// Copyright (c) 2014 The Chromium OS 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#ifndef UPDATE_ENGINE_UPDATE_MANAGER_EVALUATION_CONTEXT_H_ 6#define UPDATE_ENGINE_UPDATE_MANAGER_EVALUATION_CONTEXT_H_ 7 8#include <map> 9#include <string> 10 11#include <base/callback.h> 12#include <base/memory/ref_counted.h> 13#include <base/memory/scoped_ptr.h> 14#include <base/memory/weak_ptr.h> 15#include <base/time/time.h> 16 17#include "update_engine/clock_interface.h" 18#include "update_engine/update_manager/boxed_value.h" 19#include "update_engine/update_manager/event_loop.h" 20#include "update_engine/update_manager/variable.h" 21 22namespace chromeos_update_manager { 23 24// The EvaluationContext class is the interface between a policy implementation 25// and the state. The EvaluationContext tracks the variables used by a policy 26// request and caches the returned values, owning those cached values. 27// The same EvaluationContext should be re-used for all the evaluations of the 28// same policy request (an AsyncPolicyRequest might involve several 29// re-evaluations). Each evaluation of the EvaluationContext is run at a given 30// point in time, which is used as a reference for the evaluation timeout and 31// the time based queries of the policy, such as IsTimeGreaterThan(). 32// 33// Example: 34// 35// scoped_refptr<EvaluationContext> ec = new EvaluationContext; 36// 37// ... 38// // The following call to ResetEvaluation() is optional. Use it to reset the 39// // evaluation time if the EvaluationContext isn't used right after its 40// // construction. 41// ec->ResetEvaluation(); 42// EvalStatus status = policy->SomeMethod(ec, state, &result, args...); 43// 44// ... 45// // Run a closure when any of the used async variables changes its value or 46// // the timeout for requery the values happens again. 47// ec->RunOnValueChangeOrTimeout(closure); 48// // If the provided |closure| wants to re-evaluate the policy, it should 49// // call ec->ResetEvaluation() to start a new evaluation. 50// 51class EvaluationContext : public base::RefCounted<EvaluationContext>, 52 private BaseVariable::ObserverInterface { 53 public: 54 explicit EvaluationContext(chromeos_update_engine::ClockInterface* clock, 55 base::TimeDelta evaluation_timeout); 56 ~EvaluationContext(); 57 58 // Returns a pointer to the value returned by the passed variable |var|. The 59 // EvaluationContext instance keeps the ownership of the returned object. The 60 // returned object is valid during the life of the evaluation, even if the 61 // passed Variable changes it. 62 // 63 // In case of error, a NULL value is returned. 64 template<typename T> 65 const T* GetValue(Variable<T>* var); 66 67 // Returns whether the passed |timestamp| is greater than the evaluation 68 // time. The |timestamp| value should be in the same scale as the values 69 // returned by ClockInterface::GetWallclockTime(). 70 bool IsTimeGreaterThan(base::Time timestamp); 71 72 // TODO(deymo): Move the following methods to an interface only visible by the 73 // UpdateManager class and not the policy implementations. 74 75 // Resets the EvaluationContext to its initial state removing all the 76 // non-const cached variables and re-setting the evaluation time. This should 77 // be called right before any new evaluation starts. 78 void ResetEvaluation(); 79 80 // Schedules the passed |callback| closure to be called when a cached 81 // variable changes its value or a polling interval passes. If none of these 82 // events can happen, for example if there's no cached variable, this method 83 // returns false. 84 // 85 // Right before the passed closure is called the EvaluationContext is 86 // reseted, removing all the non-const cached values. 87 bool RunOnValueChangeOrTimeout(base::Closure callback); 88 89 // Returns a textual representation of the evaluation context, 90 // including the variables and their values. This is intended only 91 // to help with debugging and the format may change in the future. 92 std::string DumpContext() const; 93 94 private: 95 friend class UmEvaluationContextTest; 96 97 // Removes all the Observers and timeout callbacks scheduled by 98 // RunOnValueChangeOrTimeout(). This method is idempotent. 99 void RemoveObserversAndTimeout(); 100 101 // BaseVariable::ObserverInterface override. 102 void ValueChanged(BaseVariable* var); 103 104 // Called from the main loop when the scheduled poll timeout has passed. 105 void OnPollTimeout(); 106 107 // Removes the observers from the used Variables and cancels the poll timeout 108 // and executes the scheduled callback, if any. 109 void OnValueChangedOrPollTimeout(); 110 111 // The remaining time for the current evaluation. 112 base::TimeDelta RemainingTime() const; 113 114 // A map to hold the cached values for every variable. 115 typedef std::map<BaseVariable*, BoxedValue> ValueCacheMap; 116 117 // The cached values of the called Variables. 118 ValueCacheMap value_cache_; 119 120 // A pointer to a copy of the closure passed to RunOnValueChangeOrTimeout(). 121 scoped_ptr<base::Closure> value_changed_callback_; 122 123 // The EventId returned by the event loop identifying the timeout callback. 124 // Used to cancel the timeout callback. 125 EventId poll_timeout_event_ = kEventIdNull; 126 127 // Pointer to the mockable clock interface; 128 chromeos_update_engine::ClockInterface* clock_; 129 130 // The timestamp when the evaluation of this EvaluationContext started. This 131 // value is reset every time ResetEvaluation() is called. The time source 132 // used is the ClockInterface::GetWallclockTime(). 133 base::Time evaluation_start_; 134 135 // The timestamp measured on the GetWallclockTime() scale, when a reevaluation 136 // should be triggered due to IsTimeGreaterThan() calls value changes. This 137 // timestamp is greater or equal to |evaluation_start_| since it is a 138 // timestamp in the future, but it can be lower than the current 139 // GetWallclockTime() at some point of the evaluation. 140 base::Time reevaluation_time_; 141 142 // The timeout of an evaluation, used to compute the RemainingTime() of an 143 // evaluation. 144 const base::TimeDelta evaluation_timeout_; 145 146 // The timestamp in the ClockInterface::GetMonotonicTime() scale at which the 147 // current evaluation should finish. This is used to compute the 148 // RemainingTime(). 149 base::Time evaluation_monotonic_deadline_; 150 151 base::WeakPtrFactory<EvaluationContext> weak_ptr_factory_; 152 153 DISALLOW_COPY_AND_ASSIGN(EvaluationContext); 154}; 155 156} // namespace chromeos_update_manager 157 158// Include the implementation of the template methods. 159#include "update_engine/update_manager/evaluation_context-inl.h" 160 161#endif // UPDATE_ENGINE_UPDATE_MANAGER_EVALUATION_CONTEXT_H_ 162