policy_document.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_STORAGE_POLICY_DOCUMENT_H
#define GOOGLE_CLOUD_CPP_GOOGLE_CLOUD_STORAGE_POLICY_DOCUMENT_H
 
#include "google/cloud/storage/version.h"
#include <chrono>
#include <map>
#include <string>
#include <utility>
#include <vector>
 
namespace google {
namespace cloud {
namespace storage {
inline namespace STORAGE_CLIENT_NS {
class PolicyDocumentCondition {
 public:
  PolicyDocumentCondition() = default;
  // NOLINTNEXTLINE(google-explicit-constructor)
  PolicyDocumentCondition(std::vector<std::string> elements)
      : elements_(std::move(elements)) {}
 
  std::vector<std::string> const& elements() const { return elements_; }
 
 
  static std::vector<std::string> ExactMatch(std::string const& field,
                                             std::string const& value) {
    std::vector<std::string> result;
    result.emplace_back("eq");
    result.emplace_back(std::string("$") + field);
    result.emplace_back(value);
    return result;
  }
 
  static std::vector<std::string> ExactMatchObject(std::string const& field,
                                                   std::string const& value) {
    std::vector<std::string> result;
    result.emplace_back(field);
    result.emplace_back(value);
    return result;
  }
 
  static std::vector<std::string> StartsWith(std::string const& field,
                                             std::string const& value) {
    std::vector<std::string> result;
    result.emplace_back("starts-with");
    result.emplace_back(std::string("$") + field);
    result.emplace_back(value);
    return result;
  }
 
  static std::vector<std::string> ContentLengthRange(std::int32_t min_range,
                                                     std::int32_t max_range) {
    std::vector<std::string> result;
    result.emplace_back("content-length-range");
    result.emplace_back(std::to_string(min_range));
    result.emplace_back(std::to_string(max_range));
    return result;
  }
 
 private:
  std::vector<std::string> elements_;
};
 
inline bool operator==(PolicyDocumentCondition const& lhs,
                       PolicyDocumentCondition const& rhs) {
  return lhs.elements() == rhs.elements();
}
 
inline bool operator<(PolicyDocumentCondition const& lhs,
                      PolicyDocumentCondition const& rhs) {
  return lhs.elements() < rhs.elements();
}
 
inline bool operator!=(PolicyDocumentCondition const& lhs,
                       PolicyDocumentCondition const& rhs) {
  return std::rel_ops::operator!=(lhs, rhs);
}
 
inline bool operator>(PolicyDocumentCondition const& lhs,
                      PolicyDocumentCondition const& rhs) {
  return std::rel_ops::operator>(lhs, rhs);
}
 
inline bool operator<=(PolicyDocumentCondition const& lhs,
                       PolicyDocumentCondition const& rhs) {
  return std::rel_ops::operator<=(lhs, rhs);
}
 
inline bool operator>=(PolicyDocumentCondition const& lhs,
                       PolicyDocumentCondition const& rhs) {
  return std::rel_ops::operator>=(lhs, rhs);
}
 
std::ostream& operator<<(std::ostream& os, PolicyDocumentCondition const& rhs);
 
struct PolicyDocument {
  std::chrono::system_clock::time_point expiration;
  std::vector<PolicyDocumentCondition> conditions;
};
 
std::ostream& operator<<(std::ostream& os, PolicyDocument const& rhs);
 
struct PolicyDocumentV4 {
  PolicyDocumentV4() = default;
  PolicyDocumentV4(std::string bucket, std::string object,
                   std::chrono::seconds expiration,
                   std::chrono::system_clock::time_point timestamp =
                       std::chrono::system_clock::now(),
                   std::vector<PolicyDocumentCondition> conditions = {})
      : bucket(std::move(bucket)),
        object(std::move(object)),
        expiration(std::move(expiration)),
        timestamp(std::move(timestamp)),
        conditions(std::move(conditions)) {}
 
  std::string bucket;
  std::string object;
  std::chrono::seconds expiration;
  std::chrono::system_clock::time_point timestamp;
  std::vector<PolicyDocumentCondition> conditions;
};
 
std::ostream& operator<<(std::ostream& os, PolicyDocumentV4 const& rhs);
 
struct PolicyDocumentResult {
  std::string access_id;
  std::chrono::system_clock::time_point expiration;
  std::string policy;
  std::string signature;
};
 
std::ostream& operator<<(std::ostream& os, PolicyDocumentResult const& rhs);
 
struct PolicyDocumentV4Result {
  std::string url;
  std::string access_id;
  std::chrono::system_clock::time_point expiration;
  std::string policy;
  std::string signature;
  std::string signing_algorithm;
  std::map<std::string, std::string> required_form_fields;
};
 
std::string FormatDateForForm(PolicyDocumentV4Result const&);
 
std::ostream& operator<<(std::ostream& os, PolicyDocumentV4Result const& rhs);
 
}  // namespace STORAGE_CLIENT_NS
}  // namespace storage
}  // namespace cloud
}  // namespace google
 
#endif  // GOOGLE_CLOUD_CPP_GOOGLE_CLOUD_STORAGE_POLICY_DOCUMENT_H