text stringlengths 14 100k | source stringclasses 1
value | repo stringclasses 810
values | language stringclasses 13
values |
|---|---|---|---|
<|fim_suffix|>l<OneTimePasswordSecret> otp_secret;
String ldap_server_name;
String kerberos_realm;
#if USE_SSL
X509Certificate::Subjects ssl_certificate_subjects;
#endif
String salt;
#if USE_SSH
std::vector<SSHKey> ssh_keys;
#endif
/// HTTP authentication properties
String http_auth_server... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Access/CachedAccessChecking.h>
#include <Access/ContextAccess.h>
namespace DB
{
CachedAc<|fim_suffix|> result = false;
throw;
}
}
else
{
result = access->isGranted(element);
}
checked = true;
return result;
}
}
<|fim_middle|>cessCheck... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Access/Common/AccessRightsElement.h>
#include <Access/ContextAccess.h>
#include <memory>
namespace DB
{
class ContextAccess;
/// Checks if the current use<|fim_suffix|>fied access type granted,
/// and if it's checked another time later, it will just return the first result.
cla... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Acce<|fim_suffix|>QUOTA:
{
static const auto info = make_info("QUOTA", "QUOTAS", 'Q', ErrorCodes::UNKNOWN_QUOTA);
return info;
}
case AccessEntityType::MASKING_POLICY:
{
static const auto info = make_info("MASKING_POLICY", "MASK... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>tity_name) const;
static const AccessEntityTypeInfo & get(AccessEntityType type_);
static AccessEntityType parseType(const String & name_);
};
}
<|fim_prefix|>#pragma once
#include <Core/Types.h>
namespace DB
{
/// Represents the type of an access entity (see the IAccessEntity class).
enum c... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>urn Helper::instance().getAllFlagsGrantableOnColumnLevel(); }
AccessFlags operator |(AccessType left, AccessType right) { return AccessFlags(left) | right; }
AccessFlags operator &(AccessType left, AccessType right) { return AccessFlags(left) & right; }
AccessFlags operator -(AccessType left, AccessType ... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ated to a source.
static AccessFlags allSourceFlags();
/// Returns all the flags which could be granted on the global level.
/// The same as allFlags().
static AccessFlags allFlagsGrantableOnGlobalLevel();
/// Returns all the flags which could be granted on the global with parameter ... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Access/AccessControl.h>
#include <Access/Common/AccessRightsElement.h>
#include <Access/Common/AccessType.h>
#include <Common/logger_useful.h>
#include <Common/quoteString.h>
#include <IO/Operators.h>
#include <IO/WriteBufferFromString.h>
#include <Interpreters/Context.h>
#include <Parsers/IAST.... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma <|fim_suffix|> return sameDatabaseAndTable(other) && sameParameter(other) && (wildcard == other.wildcard) && (filter == other.filter);
}
bool sameParameter(const AccessRightsElement & other) const
{
return (parameter == other.parameter) && (anyParameter() == other.anyParameter... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>ing;
};
}
std::string_view toString(AccessType type)
{
return AccessTypeToStringConverter::instance().convert(type);
}
}
<|fim_prefix|>#include <Access/Common/AccessType.h>
#include <boost/algorithm/string/replace.hpp>
#include <vector>
namespace DB
{
namespace
{
using Strings<|fim_middle... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>EM_RELOAD) /* implicitly enabled by the grant SYSTEM_RELOAD_DICTIONARY ON *.* */\
M(SYSTEM_RELOAD_ASYNCHRONOUS_METRICS, "RELOAD ASYNCHRONOUS METRICS", GLOBAL, SYSTEM_RELOAD) \
M(SYSTEM_RECONNECT_ZOOKEEPER, "SYSTEM RECONNECT ZOOKEEPER, RECONNECT ZOOKEEPER", GLOBAL, SYSTEM) \
M(SYSTEM_RELOAD, ""... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Access/Common/AllowedClientHosts.h>
#include <Common/Exception.h>
#include <Common/likePatternToRegexp.h>
#include <Common/logger_useful.h>
#include <base/scope_guard.h>
#include <Poco/Net/SocketAddress.h>
#include <Poco/RegularExpression.h>
#include <boost/algorithm/string/predicate.hpp>
#inclu... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>NameRegexps() const { return name_regexps; }
/// Allows IP addresses or host names using LIKE pattern.
/// This pattern can contain % and _ wildcard characters.
/// For example, addLikePattern("%") will allow all addresses.
void addLikePattern(const String & pattern);
void removeLikeP... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>uthenticationType::JWT:
{
static const auto info = make_info(Keyword::JWT);
return info;
}
case AuthenticationType::MAX:
break;
}
throw Exception(ErrorCodes::LOGICAL_ERROR, "Unknown authentication type: {}", static_cast<int>(type_));
}
}... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <base/types.h>
#include <Parsers/CommonParsers.h>
namespace DB
{
enum class AuthenticationType : ui<|fim_suffix|>iew(AuthenticationTypeInfo::get(type_).keyword));
}
}
<|fim_middle|>nt8_t
{
/// User doesn't have to enter password.
NO_PASSWORD,
/// Password is stored a... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Access/Common/HTTPAuthenticationScheme.h>
#include <base/EnumReflection.h>
#include <base/types.h>
#include <Poco/String.h>
#include <Common/Exception.h>
namespace DB
{
namespace ErrorCodes
{
extern const int BAD_ARGUMENTS;
}
String toString(HTTPAuthenticationScheme scheme)
{
return ... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>& scheme_str);
}
<|fim_prefix|>#pragma once
#include <base/types.<|fim_middle|>h>
namespace DB
{
enum class HTTPAuthenticationScheme
{
BASIC,
};
String toString(HTTPAuthenticationScheme scheme);
HTTPAuthenticationScheme parseHTTPAuthenticationScheme(const String <|endoftext|> | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <string_view>
#include <Access/Common/OneTimePassword.h>
#include <Common/Exception.h>
#include <Common/ErrorCodes.h>
#include <Common/logger_useful.h>
#include <fmt/format.h>
#include <Poco/String.h>
#include "config.h"
#if USE_SSL && USE_LIBCOTP
#include <cotp.h>
constexpr int TOTP_SHA512 =... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <base/types.h>
#include <optional>
namespace DB
{
struct OneTimePasswordParams
{
Int32 num_digits = 6;
Int32 period = 30;
enum class Algorithm : UInt8
{
SHA1,
SHA256,
SHA512,
} algorithm = Algorithm::SHA1;
explicit OneTimePasswordP... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Access/Common/QuotaDefs.h>
#include <Common/Exception.h>
#include <IO/ReadHelpers.h>
#include <IO/WriteHelpers.h>
#include <base/range.h>
#include <boost/algorithm/string/case_conv.hpp>
#include <boost/algorithm/string/classification.hpp>
#include <boost/algorithm/string/replace.hpp>
#include <... | fim | ClickHouse/ClickHouse | cpp |
#pragma once
#include <Core/Types.h>
namespace DB
{
/// We use UInt64 to count used resources.
using QuotaValue = UInt64;
/// Kinds of resource what we wish to quota.
enum class QuotaType : uint8_t
{
QUERIES, /// Number of queries.
QUERY_SELECTS, /// N... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> case RowPolicyFilterType::DELETE_FILTER:
{
static const auto info = make_info("DELETE_FILTER");
return info;
}
#endif
case RowPolicyFilterType::MAX: break;
}
throw Exception(ErrorCodes::LOGICAL_ERROR, "Unknown type: {}", static_cast<size_t>(type_)... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Core/Type<|fim_suffix|>onst bool is_check; /// E.g. false for SELECT_FILTER.
static const RowPolicyFilterTypeInfo & get(RowPolicyFilterType type);
};
}
<|fim_middle|>s.h>
namespace DB
{
/// Represents the full name of a row policy, e.g. "myfilter ON mydb.mytable".
struct R... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <Core/Types.h>
/// SQL security enum. Used in ASTSQLSecurity::type. For more info, please refer to the do<|fim_suffix|>: uint8_t
{
INVOKER, /// All queries will be executed with the current user's context.
DEFINER, /// All queries will be executed with the specified user's... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> subscription_for_user_change = access_control->subscribeForChanges(
*params.user_id,
[weak_ptr = weak_from_this()](const UUID &, const AccessEntityPtr & entity)
{
auto ptr = weak_ptr.lock();
if (!ptr)
return;
UserPtr changed_u... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> ALWAYS_INLINE bool hasGrantOption(const AccessFlags & flags, std::string_view database, std::string_view table, const std::vector<std::string_view> & columns) const { return access->hasGrantOption(context, flags, database, table, columns); }
ALWAYS_INLINE bool hasGrantOption(const AccessFlags & fl... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Access/ContextAccessParams.h>
#include <Core/Settings.h>
#include <IO/Operators.h>
#include <Common/typeid_cast.h>
#include <Poco/Net/SocketAddress.h>
#include <Poco/Net/IPAddress.h>
namespace DB
{
namespace Setting
{
extern const SettingsBool allow_ddl;
extern const SettingsBool allo... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Interpreters/ClientInfo.h>
#include <Core/UUID.h>
#include <optional>
#include <vector>
namespace Poco::Net
{
class IPA<|fim_suffix|> right) { return !(right < left); }
friend bool operator >=(const ContextAccessParams & left, const ContextAccessParams & right) { return !... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Access/Credentials.h>
#include <Common/Exception.h>
#include <Poco/Net/HTTPRequest.h>
#include <Common/Crypto/X509Certificate.h>
namespace DB
{
namespace ErrorCodes
{
extern const int LOGICAL_ERROR;
}
Credentials::Credentials(const String & user_name_)
: user_name(user_name_)
{
}
con... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include "config.h"
#include <Common/SSHWrapper.h>
#if USE_SSL
# include <Common/Crypto/X509Certificate.h>
#endif
#include <base/types.h>
namespace Poco::Net
{
class HTTPRequest;
class SocketAddress;
}
namespace DB
{
class Credentials
{
public:
explicit Credentials() = d... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Access/DiskAccessStorage.h>
#include <Access/AccessEntityIO.h>
#include <Access/AccessChangesNotifier.h>
#include <Access/MemoryAccessStorage.h>
#include <IO/WriteHelpers.h>
#include <IO/ReadHelpers.h>
#include <IO/ReadBufferFromFile.h>
#include <IO/WriteBufferFromFile.h>
#include <Interpreters/... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Access/MemoryAccessStorage.h>
#include <Common/ThreadPool_fwd.h>
#include <boost/container/flat_set.hpp>
namespace DB
{
class AccessChangesNotifier;
/// Loads and saves access entities on a local disk to a specified directory.
class DiskAccessStorage : public IAccessStorage
{
pu... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Access/EnabledQuota.h>
#include <Access/QuotaUsage.h>
#include <Common/Exception.h>
#include <Common/quoteString.h>
#include <Common/thread_local_rng.h>
#include <base/chrono_io.h>
#include <base/range.h>
#include <boost/smart_ptr/make_shared.hpp>
#include <boost/range/algorithm/fill.hpp>
name... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Access/Common/QuotaDefs.h>
#include <Common/HashTable/HashMap.h>
#include <Core/UUID.h>
#include <Poco/Net/IPAddress.h>
#include <boost/container/flat_set.hpp>
#include <boost/noncopyable.hpp>
#include <boost/smart_ptr/atomic_shared_ptr.hpp>
#include <atomic>
#include <chrono>
#inc... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Access/EnabledRoles.h>
#include <Access/Role.h>
#include <Access/EnabledRolesInfo.h>
#include <boost/range/algorithm/copy.hpp>
namespace DB
{
EnabledRoles::EnabledRoles(const Params & params_) : params(params_), handlers(std::make_shared<Handlers>())
{
}
EnabledRoles::~EnabledRoles() = defaul... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>std::shared_ptr<const EnabledRolesInfo> info;
mutable std::mutex info_mutex;
struct Handlers
{
std::list<OnChangeHandler> list;
std::mutex mutex;
};
/// shared_ptr is here for safety because EnabledRoles can be destroyed before all subscriptions are removed.
std::... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>(lhs.enabled_roles_with_admin_option == rhs.enabled_roles_with_admin_option) && (lhs.names_of_roles == rhs.names_of_roles)
&& (lhs.access == rhs.access) && (lhs.settings_from_enabled_roles == rhs.settings_from_enabled_roles);
}
}
<|fim_prefix|>#include <Access/EnabledRolesInfo.h>
namespace DB
{... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Access/AccessRights.h>
#include <Access/SettingsProfileElement.h>
#include <Core/UUID.h>
#include <boost/container/flat_set.hpp>
#include <unordered_map>
namespace DB
{
/// Information about roles enabled for a user at some specific time.
struct EnabledRolesInfo
{
boost::con... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Access/EnabledRowPolicies.h>
#include <Parsers/makeASTForLogicalFunction.h>
#include <boost/range/adaptor/map.hpp>
#include <boost/range/algorithm/copy.hpp>
namespace DB
{
bool RowPolicyFilter::isAlwaysTrue() const
{
bool value = false;
return !expression || (tryGetLiteralBool(express... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|> friend bool operator==(const MixedFiltersKey & left, const MixedFiltersKey & right) { return left.toTuple() == right.toTuple(); }
friend bool operator!=(const MixedFiltersKey & left, const MixedFiltersKey & right) { return left.toTuple() != right.toTuple(); }
};
struct Hash
{
... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> info = info_;
}
}
<|fim_prefix|>#include <Access/EnabledSettings.h>
#include <Common/SettingsChanges.h>
namespace DB
{
EnabledSettings::EnabledSettings(const Params & params_) : params(params_)
{
}
EnabledSettings::~EnabledSettings() = default;
std::shared_ptr<const SettingsProfilesInfo> Enabled... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>) const;
~EnabledSettings();
private:
friend class SettingsProfilesCache;
explicit EnabledSettings(const Params & params_);
void setInfo(const std::shared_ptr<const SettingsProfilesInfo> & info_);
const Params params;
std::shared_ptr<const SettingsProfilesInfo> info TSA_GUARDED_... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> return is_ok;
}
}
<|fim_prefix|>#include <Access/ExternalAuthenticators.h>
#include <Access/LDAPClient.h>
#include <Access/SettingsAuthResponseParser.h>
#include <Access/resolveSetting.h>
#include <Common/Exception.h>
#include <Common/SettingsChanges.h>
#include <Common/SipHash.h>
#include <Common/quote... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Access/Credentials.h>
#include <Access/GSSAcceptor.h>
#include <Access/HTTPAuthClient.h>
#include <Access/LDAPClient.h>
#include <Interpreters/ClientInfo.h>
#include <base/defines.h>
#include <base/extended_types.h>
#include <base/types.h>
#include <Poco/URI.h>
#include <chrono>
... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Access/GSSAcceptor.h>
#include <Common/Exception.h>
#include <base/scope_guard.h>
#include <Poco/StringTokenizer.h>
#include <mutex>
#include <tuple>
#include <filesystem>
namespace DB
{
namespace ErrorCodes
{
extern const int BAD_ARGUMENTS;
extern const int FEATURE_IS_NOT_ENABLED_A... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>onst Params & params_);
~GSSAcceptorContext() override;
GSSAcceptorContext(const GSSAcceptorContext &) = delete;
GSSAcceptorContext(GSSAcceptorContext &&) = delete;
GSSAcceptorContext & operator= (const GSSAcceptorContext &) = delete;
GSSAcceptorContext & operator= (GSSAcceptorContext... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>; it != roles_with_admin_option.end();)
{
if (ids.contains(*it))
it = roles_with_admin_option.erase(it);
else
++it;
}
}
}
}
<|fim_prefix|>#include <Access/GrantedRoles.h>
#include <Access/RolesOrUsersSet.h>
#include <boost/range/... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Core/UUID.h>
#include <boost/container/flat_set.hpp>
#include <vector>
#include <unordered_map>
namespace DB
{
struct RolesOrUsersSet;
/// Roles when they are gra<|fim_suffix|>dRoles
{
public:
void grant(const UUID & role_);
void grant(const std::vector<UUID> & roles_);
... | fim | ClickHouse/ClickHouse | c |
#pragma once
#include <IO/ConnectionTimeouts.h>
#include <IO/HTTPCommon.h>
#include <base/sleep.h>
#include <Poco/Net/HTTPBasicCredentials.h>
#include <set>
namespace DB
{
struct HTTPAuthClientParams
{
Poco::URI uri;
ConnectionTimeouts timeouts;
size_t max_tries{};
size_t retry_initial_backoff_ms{};... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Access/IAccessEntity.h>
names<|fim_suffix|>pe() == other.getType());
}
}
<|fim_middle|>pace DB
{
bool IAccessEntity::equal(const IAccessEntity & other) const
{
return (name == other.name) && (getTy<|endoftext|> | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Access/Common/AccessEntityType.h>
#include <Common/typeid_cast.h>
#include <base/types.h>
#include <memory>
#include <unordered_map>
namespace DB
{
/// Access entity is a set of data which have a name and a type. Access entity control something related to the access control.
///... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Access/IAccessStorage.h>
#include <Access/Authentication.h>
#include <Access/Credentials.h>
#include <Access/User.h>
#include <Access/AccessBackup.h>
#include <Backups/BackupEntriesCollector.h>
#include <Backups/IBackupCoordination.h>
#include <Backups/IRestoreCoordination.h>
#include <Backups/R... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Access/IAccessEntity.h>
#include <Access/AuthenticationData.h>
#include <Core/Types.h>
#include <Common/SettingsChanges.h>
#include <Common/callOnce.h>
#include <Interpreters/ClientInfo.h>
#include <functional>
#include <optional>
#include <unordered_set>
#include <vector>
#inclu... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>e);
if (ret)
throw Exception(ErrorCodes::KERBEROS_ERROR, "Error while getting default cache: {}", fmtError(ret));
LOG_TRACE(log,"Resolved default cache");
deftype = krb5_cc_get_type(k5.ctx, defcache);
if (krb5_cc_get_principal(k5.ctx, defcache, &defcache_princ) ... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>e, const String & principal, const String & cache_name = "");
#endif // USE_KRB5
<|fim_prefix|>#pragma once
#i<|fim_middle|>nclude "config.h"
#include <base/types.h>
#if USE_KRB5
void kerberosInit(const String & keytab_fil<|endoftext|> | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Access/LDAPAccessStorage.h>
#include <Access/AccessControl.h>
#include <Access/ExternalAuthenticators.h>
#include <Access/User.h>
#include <Access/Role.h>
#include <Access/Credentials.h>
#include <Access/LDAPClient.h>
#include <Common/Exception.h>
#include <Common/logger_useful.h>
#include <base... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Access/MemoryAccessStorage.h>
#include <Access/LDAPClient.h>
#include <Access/Credentials.h>
#include <base/types.h>
#include <base/scope_guard.h>
#include <map>
#include <mutex>
#include <set>
#include <vector>
namespace Poco
{
namespace Util
{
class AbstractConf... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>BUILD_TIME, "ClickHouse was built without LDAP support");
}
bool LDAPSimpleAuthClient::authenticate(const RoleSearchParamsList *, SearchResultsList *)
{
throw Exception(ErrorCodes::FEATURE_IS_NOT_ENABLED_AT_BUILD_TIME, "ClickHouse was built without LDAP support");
}
#endif // USE_LDAP
}
<|fim_prefi... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>onst LDAPClient &) = delete;
LDAPClient(LDAPClient &&) = delete;
LDAPClient & operator= (const LDAPClient &) = delete;
LDAPClient & operator= (LDAPClient &&) = delete;
protected:
MAYBE_NORETURN void handleError(int result_code, String text = "");
MAYBE_NORETURN bool openConnection();
... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>Type() const override { return TYPE; }
std::vector<UUID> findDependencies() const override;
bool hasDependencies(const std::unordered_set<UUID> & ids) const override;
void replaceDependencies(const std::unordered_map<UUID, UUID> & old_to_new_ids) override;
void copyDependenciesFrom(const ... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>ard lock{mutex};
return removeNoLock(id, throw_if_not_exists);
}
bool MemoryAccessStorage::removeNoLock(const UUID & id, bool throw_if_not_exists, bool notify)
{
auto it = entries_by_id.find(id);
if (it == entries_by_id.end())
{
if (throw_if_not_exists)
throwNotFound(... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>air of name and type.
std::unordered_map<String, Entry *> entries_by_name_and_type[static_cast<size_t>(AccessEntityType::MAX)];
AccessChangesNotifier & changes_notifier;
const bool backup_allowed = false;
};
}
<|fim_prefix|>#pragma once
#include <Access/IAccessStorage.h>
#include <base/define... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> storage->getStorageName());
}
}
}
}
}
return storage_for_updating->update(id, update_func, throw_if_not_exists);
}
std::optional<AuthResult>
MultipleAccessStorage::authenticateImpl(const Credentials & credentials, const Poco::Net::IPAddre... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Access/IAccessStorage.h>
#include <base/defines.h>
#include <Common/CacheBase.h>
#include <mutex>
namespace DB
{
/// Implementation of IAccessStorage which contains multiple nested storages.
class MultipleAccessStorage : public IAccessStorage
{
public:
static constexpr char S... | fim | ClickHouse/ClickHouse | c |
#include <Access/Quota.h>
#include <boost/range/algorithm/equal.hpp>
namespace DB
{
bool operator ==(const Quota::Limits & lhs, const Quota::Limits & rhs)
{
return boost::range::equal(lhs.max, rhs.max) && (lhs.duration == rhs.duration)
&& (lhs.randomize_interval == rhs.randomize_interval);
}
bool Quota:... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma<|fim_suffix|> std::optional<MaskBits> ipv4_prefix_bits;
std::optional<MaskBits> ipv6_prefix_bits;
/// Which roles or users should use this quota.
RolesOrUsersSet to_roles;
bool equal(const IAccessEntity & other) const override;
std::shared_ptr<IAccessEntity> clone() const o... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Access/EnabledQuota.h>
#include <Access/Quota.h>
#include <Access/QuotaCache.h>
#include <Access/QuotaUsage.h>
#include <Access/AccessControl.h>
#include <Common/Exception.h>
#include <base/range.h>
#include <boost/range/adaptor/map.hpp>
#include <boost/range/algorithm/copy.hpp>
#include <boost/... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Access/EnabledQuota.h>
#include <base/scope_guard.h>
#include <memory>
#include <mutex>
#include <map>
#include <unordered_map>
namespace DB
{
class AccessControl;
struct Quota;
using QuotaPtr = std::shared_ptr<const Quota>;
struct RolesOrUsersSet;
/// Stores information how muc... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>::Interval::Interval()
{
boost::range::fill(used, 0);
}
}
<|fim_prefix|>#include <Access/QuotaUsage.h>
#include <boost/range/algorithm/fill.hpp>
namespace DB
{
QuotaUsage::QuotaUsage() <|fim_middle|>: quota_id(UUID(UInt128(0)))
{
}
QuotaUsage<|endoftext|> | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ame;
String quota_key;
QuotaUsage();
};
}
<|fim_prefix|>#pragma once
#include <Access/Common/QuotaDefs.h>
#include <chrono>
#include <optional>
namespace DB
{
/// The information about a qu<|fim_middle|>ota consumption.
struct QuotaUsage
{
struct Interval
{
QuotaValue used[stati... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>backup_allowed(allow_backup_)
{
if (zookeeper_path_.empty())
throw Exception(ErrorCodes::BAD_ARGUMENTS, "ZooKeeper path must be non-empty");
}
ReplicatedAccessStorage::~ReplicatedAccessStorage()
{
try
{
ReplicatedAccessStorage::shutdown();
}
catch (...)
{
t... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Access/IAccessStorage.h>
#include <Access/MemoryAccessStorage.h>
#include <Access/ZooKeeperReplicator.h>
namespace DB
{
class AccessChangesNotifier;
/// Implementation of IAccessStorage which keeps all data in zookeeper.
class ReplicatedAccessStorage : public IAccessStorage
{
pub... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Access/Role.h>
#include <base/insertAtEnd.h>
namespace DB
{
bool Role::equal(const IAccessEntity & other) const
{
if (!IAccessEntity::equal(other))
return false;
const auto & other_role = typeid_cast<const Role &>(other);
return (access == other_role.access) && (granted_ro... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Access/IAccessEntity.h>
#include <Access/AccessRights.h>
#include <Access/GrantedRoles.h>
#include <Access/SettingsProfileElement.h>
#include <optional>
namespace DB
{
struct Role : public IAccessEntity
{
AccessRights access;
GrantedRoles granted_roles;
SettingsProfi... | fim | ClickHouse/ClickHouse | c |
#include <Access/RoleCache.h>
#include <Access/Role.h>
#include <Access/EnabledRolesInfo.h>
#include <Access/AccessControl.h>
#include <boost/container/flat_set.hpp>
#include <base/FnTraits.h>
namespace DB
{
namespace
{
void collectRoles(EnabledRolesInfo & roles_info,
boost::container::flat_... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#<|fim_suffix|> RolePtr getRole(const UUID & role_id, SubscriptionsOnRoles & subscriptions_on_roles) TSA_REQUIRES(mutex);
void roleChanged(const UUID & role_id, const RolePtr & changed_role);
void roleRemoved(const UUID & role_id);
const AccessControl & access_control;
P... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>sersSet::removeDependencies(const std::unordered_set<UUID> & dependencies_ids)
{
for (auto it = ids.begin(); it != ids.end();)
{
if (dependencies_ids.contains(*it))
it = ids.erase(it);
else
++it;
}
for (auto it = except_ids.begin(); it != except_ids... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Parsers/IAST_fwd.h>
#include <Core/UUID.h>
#include <Core/Types.h>
#include <boost/container/flat_set.hpp>
#include <memory>
#include <optional>
#include <unordered_map>
namespace DB
{
class ASTRolesOrUsersSet;
class AccessControl;
/// Represents a set of users/roles like
/// {... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Access/RowPolicy.h>
#include <Common/Exception.h>
#include <Common/quoteString.h>
#include <boost/range/algorithm/equal.hpp>
namespace DB
{
namespace ErrorCodes
{
extern const int NOT_IMPLEMENTED;
}
void RowPolicy::setDatabase(const String & database)
{
full_name.database = database;... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>me() const { return full_name; }
/// A SQL conditional expression used to figure out which rows should be visible
/// for user or available for modification.
std::array<String, static_cast<size_t>(RowPolicyFilterType::MAX)> filters;
/// Sets that the policy is permissive.
/// A row i... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Access/RowPolicyCache.h>
#include <Access/AccessControl.h>
#include <Access/EnabledRowPolicies.h>
#include <Access/RowPolicy.h>
#include <Parsers/ExpressionListParsers.h>
#include <Parsers/parseQuery.h>
#include <Parsers/makeASTForLogicalFunction.h>
#include <Common/Exception.h>
#include <Common... | fim | ClickHouse/ClickHouse | cpp |
#pragma once
#include <Access/EnabledRowPolicies.h>
#include <base/scope_guard.h>
#include <mutex>
#include <map>
#include <unordered_map>
namespace DB
{
class AccessControl;
struct RolesOrUsersSet;
struct RowPolicy;
using RowPolicyPtr = std::shared_ptr<const RowPolicy>;
/// Stores read and parsed row policies.
cla... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <stdexcept>
#include <Access/SSH/SSHPublicKey.h>
#include <Common/Exception.h>
#include <Common/clibssh.h>
namespace DB
{
namespace ErrorCodes
{
extern const int SSH_EXCEPTION;
extern const int LOGICAL_ERROR;
extern const int BAD_ARGUMENTS;
}
}
n<|fim_suffix|> throw DB::Exception... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ue_ptr
static void disabledDeleter(KeyPtr) { }
using UniqueKeyPtr = std::unique_ptr<ssh_key_struct, decltype(&deleter)>;
UniqueKeyPtr key;
};
}
<|fim_prefix|>#pragma once
#include <cstdint>
#include <memory>
#include <string>
#include <unordered_set>
#include <base/types.h>
struct ssh_key_... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Access/SettingsAuthResponseParser.h>
#include <Access/resolveSetting.h>
#include <IO/HTTPCommon.h>
#include <Poco/JSON/Object.h>
#include <Poco/JSON/Parser.h>
namespace DB
{
SettingsAuthResponseParser::Result
SettingsAuthResponseParser::parse(const Poco::Net::HTTPResponse & response, std::is... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Common/SettingsC<|fim_suffix|>ude <istream>
namespace Poco::Net
{
class HTTPResponse;
}
namespace DB
{
/// Class for parsing authentication response containing session settings
class SettingsAuthResponseParser
{
static constexpr auto settings_key = "settings";
public:
str... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|>
SettingChange value(element.setting_name, *element.value);
check(current_settings, value, source);
}
if (element.min_value)
{
SettingChange value(element.setting_name, *element.min_value);
check(current_settings, value, source);
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Core/Field.h>
#include <Common/LoggingFormatStringHelpers.h>
#include <Common/SettingConstraintWritability.h>
#include <Common/SettingSource.h>
#include <unordered_map>
namespace Poco::Util
{
class AbstractConfiguration;
}
namespace DB
{
struct Settings;
struct MergeTreeSett... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#pragma once
#include <Access/SettingsConstraints.h>
#include <|fim_suffix|>raints(access_control_) {}
};
}
<|fim_middle|><Core/UUID.h>
#include <vector>
namespace DB
{
/// Information about currently applied constraints and profiles.
struct SettingsConstraintsAndProfileIDs
{
SettingsConstraints ... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Access/SettingsProfile.h>
#include <base/inse<|fim_suffix|>& (to_roles == other_profile.to_roles);
}
std::vector<UUID> SettingsProfile::findDependencies() const
{
std::vector<UUID> res;
insertAtEnd(res, elements.findDependencies());
insertAtEnd(res, to_roles.findDependencies());
... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>ride;
void replaceDependencies(const std::unordered_map<UUID, UUID> & old_to_new_ids) override;
void copyDependenciesFrom(const IAccessEntity & src, const std::unordered_set<UUID> & ids) override;
void removeDependencies(const std::unordered_set<UUID> & ids) override;
void clearAllExceptDe... | fim | ClickHouse/ClickHouse | c |
#include <Access/SettingsProfileElement.h>
#include <Access/SettingsConstraints.h>
#include <Access/AccessControl.h>
#include <Access/SettingsProfile.h>
#include <Core/Settings.h>
#include <Common/SettingConstraintWritability.h>
#include <Common/SettingsChanges.h>
#include <IO/ReadHelpers.h>
#include <IO/WriteHelpers.h... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Parsers/IAST_fwd.h>
#include <Core/Field.h>
#include <Core/UUID.h>
#include <Common/SettingConstraintWritability.h>
#include <optional>
#include <unordered_map>
#include <vector>
namespace DB
{
struct Settings;
class SettingsChanges;
class SettingsConstraints;
struct AlterSetting... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Access/SettingsProfilesCache.h>
#include <Access/AccessControl.h>
#include <Access/SettingsProfile.h>
#include <Access/SettingsProfilesInfo.h>
#include <Common/quoteString.h>
namespace DB
{
namespace ErrorCodes
{
extern const int THERE_IS_NO_PROFILE;
}
SettingsProfilesCache::SettingsProfi... | fim | ClickHouse/ClickHouse | cpp |
<|fim_suffix|>default_profile_name);
std::shared_ptr<const EnabledSettings> getEnabledSettings(
const UUID & user_id,
const SettingsProfileElements & settings_from_user_,
const boost::container::flat_set<UUID> & enabled_roles,
const SettingsProfileElements & settings_from_enabled_ro... | fim | ClickHouse/ClickHouse | c |
<|fim_suffix|> res->constraints = previous->constraints;
res->constraints.merge(constraints);
}
else
res->constraints = constraints;
if (previous)
{
res->enabled_profiles.reserve(previous->enabled_profiles.size() + profiles_with_implicit.size());
res->enabled_profiles ... | fim | ClickHouse/ClickHouse | cpp |
<|fim_prefix|>#pragma once
#include <Access/SettingsConstraints.h>
#include <Common/SettingsChanges.h>
#include <Core/UUID.h>
#include <unordered_map>
namespace DB
{
struct SettingsConstraintsAndProfileIDs;
/// Information about the default settings which are applied to an user on login.
struct SettingsProfilesInfo... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Access/User.h>
#include <Common/StringUtils.h>
#include <Core/Protocol.h>
#include <base/insertAtEnd.h>
namespace DB
{
namespace ErrorCodes
{
extern const int BAD_ARGUMENTS;
}
bool User::equal(const IAccessEntity & other) const
{
if (!IAccessEntity::equal(other))
return false;... | fim | ClickHouse/ClickHouse | cpp |
#pragma once
#include <Access/IAccessEntity.h>
#include <Access/AccessRights.h>
#include <Access/AuthenticationData.h>
#include <Access/Common/AllowedClientHosts.h>
#include <Access/GrantedRoles.h>
#include <Access/RolesOrUsersSet.h>
#include <Access/SettingsProfileElement.h>
namespace DB
{
/** User and ACL.
*/
st... | fim | ClickHouse/ClickHouse | c |
<|fim_prefix|>#include <Access/UsersConfigAccessStorage.h>
#include <Access/UsersConfigParser.h>
#include <Access/AccessControl.h>
#include <Access/AccessChangesNotifier.h>
#include <Common/Config/ConfigReloader.h>
#include <Common/ZooKeeper/ZooKeeperNodeCache.h>
#include <Common/quoteString.h>
#include <Core/Settings.... | fim | ClickHouse/ClickHouse | cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.