session_pool_options.h

Go to the documentation of this file.

// Copyright 2019 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#ifndef GOOGLE_CLOUD_CPP_GOOGLE_CLOUD_SPANNER_SESSION_POOL_OPTIONS_H
#define GOOGLE_CLOUD_CPP_GOOGLE_CLOUD_SPANNER_SESSION_POOL_OPTIONS_H

#include "google/cloud/spanner/version.h"
#include <algorithm>
#include <chrono>
#include <map>
#include <string>

namespace google {
namespace cloud {
namespace spanner {
inline namespace SPANNER_CLIENT_NS {

// What action to take if the session pool is exhausted.
enum class ActionOnExhaustion { kBlock, kFail };

class SessionPoolOptions {
 public:
  SessionPoolOptions& EnforceConstraints(int num_channels) {
    min_sessions_ = (std::max)(min_sessions_, 0);
    max_sessions_per_channel_ = (std::max)(max_sessions_per_channel_, 1);
    min_sessions_ =
        (std::min)(min_sessions_, max_sessions_per_channel_ * num_channels);
    max_idle_sessions_ = (std::max)(max_idle_sessions_, 0);
    return *this;
  }

  SessionPoolOptions& set_min_sessions(int count) {
    min_sessions_ = count;
    return *this;
  }

  int min_sessions() const { return min_sessions_; }

  SessionPoolOptions& set_max_sessions_per_channel(int count) {
    max_sessions_per_channel_ = count;
    return *this;
  }

  int max_sessions_per_channel() const { return max_sessions_per_channel_; }

  SessionPoolOptions& set_max_idle_sessions(int count) {
    max_idle_sessions_ = count;
    return *this;
  }

  int max_idle_sessions() const { return max_idle_sessions_; }

  SessionPoolOptions& set_action_on_exhaustion(ActionOnExhaustion action) {
    action_on_exhaustion_ = action;
    return *this;
  }

  ActionOnExhaustion action_on_exhaustion() const {
    return action_on_exhaustion_;
  }

  /*
   * Set the interval at which we refresh sessions so they don't get
   * collected by the backend GC. The GC collects objects older than 60
   * minutes, so any duration below that (less some slack to allow the calls
   * to be made to refresh the sessions) should suffice.
   */
  SessionPoolOptions& set_keep_alive_interval(std::chrono::seconds interval) {
    keep_alive_interval_ = interval;
    return *this;
  }

  std::chrono::seconds keep_alive_interval() const {
    return keep_alive_interval_;
  }

  SessionPoolOptions& set_labels(std::map<std::string, std::string> labels) {
    labels_ = std::move(labels);
    return *this;
  }

  std::map<std::string, std::string> const& labels() const { return labels_; }

 private:
  int min_sessions_ = 0;
  int max_sessions_per_channel_ = 100;
  int max_idle_sessions_ = 0;
  ActionOnExhaustion action_on_exhaustion_ = ActionOnExhaustion::kBlock;
  std::chrono::seconds keep_alive_interval_ = std::chrono::minutes(55);
  std::map<std::string, std::string> labels_;
};

}  // namespace SPANNER_CLIENT_NS
}  // namespace spanner
}  // namespace cloud
}  // namespace google

#endif  // GOOGLE_CLOUD_CPP_GOOGLE_CLOUD_SPANNER_SESSION_POOL_OPTIONS_H